import { stringEnum } from "openclaw/plugin-sdk/channel-actions";

import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";

import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";

import { Static, Type } from "typebox";

import { Type } from "typebox";

import type { Static } from "typebox";

import type { AnyAgentTool, OpenClawPluginApi, OpenClawPluginToolContext } from "../api.js";

import { PlaywrightDiffScreenshotter, type DiffScreenshotter } from "./browser.js";

import { resolveDiffImageRenderOptions } from "./config.js";

import type { DiscordGatewayHandle } from "./monitor/gateway-handle.js";

import {

import { DiscordGatewayLifecycleError } from "./monitor/gateway-supervisor.js";

import type {

DiscordGatewayEvent,

DiscordGatewayLifecycleError,

DiscordGatewaySupervisor,

} from "./monitor/gateway-supervisor.js";

("httpsProxy" in options || "httpProxy" in options)

) {

const proxyOptions = options as { httpsProxy?: unknown; httpProxy?: unknown };

if (

proxyOptions.httpsProxy === "bad-proxy" ||

proxyOptions.httpProxy === "bad-proxy"

) {

if (proxyOptions.httpsProxy === "bad-proxy" || proxyOptions.httpProxy === "bad-proxy") {

throw new Error("bad env proxy");

}

}

import {

definePluginEntry,

OpenClawConfig,

type OpenClawPluginApi,

type ProviderAuthContext,

type ProviderAuthMethodNonInteractiveContext,

type ProviderAuthResult,

type ProviderRuntimeModel,

} from "openclaw/plugin-sdk/plugin-entry";

import type { OpenClawConfig } from "openclaw/plugin-sdk/plugin-entry";

import { CUSTOM_LOCAL_AUTH_MARKER } from "openclaw/plugin-sdk/provider-auth";

import { lmstudioMemoryEmbeddingProviderAdapter } from "./memory-embedding-adapter.js";

import {

decryptionKeyBase64: string | null;

};

const MATRIX_CRYPTO_STORE_SQLITE = 0;

function resolveLegacyMachineStorePath(params: {

cryptoRootDir: string;

deviceId: string;

log: params.log,

});

const { DeviceId, OlmMachine, StoreType, UserId } = requireFn(

const { DeviceId, OlmMachine, UserId } = requireFn(

"@matrix-org/matrix-sdk-crypto-nodejs",

) as typeof import("@matrix-org/matrix-sdk-crypto-nodejs");

const machine = await OlmMachine.initialize(

new UserId(params.userId),

new DeviceId(params.deviceId),

machineStorePath,

"",

StoreType.Sqlite,

MATRIX_CRYPTO_STORE_SQLITE,

);

try {

import {

ParseErrorCode,

type ParseError,

parseTree,

printParseErrorCode,

} from "jsonc-parser/lib/esm/main.js";

import { type ParseError, parseTree, printParseErrorCode } from "jsonc-parser/lib/esm/main.js";

import type { Diagnostic } from "../ast.js";

import type { JsoncAst, JsoncEntry, JsoncValue } from "./ast.js";

* supported configuration.

*/

export const MAX_JSONC_INPUT_BYTES = 16 * 1024 * 1024;

const JSONC_PARSE_INVALID_SYMBOL = 1;

const JSONC_PARSE_END_OF_FILE_EXPECTED = 9;

export interface JsoncParseResult {

readonly ast: JsoncAst;

tree: JsoncParserNode | undefined,

): Diagnostic {

const treeEnd = tree ? tree.offset + tree.length : 0;

const errorCode: number = error.error;

const isTrailingInput =

error.error === ParseErrorCode.EndOfFileExpected ||

(tree !== undefined && error.error === ParseErrorCode.InvalidSymbol && error.offset >= treeEnd);

errorCode === JSONC_PARSE_END_OF_FILE_EXPECTED ||

(tree !== undefined && errorCode === JSONC_PARSE_INVALID_SYMBOL && error.offset >= treeEnd);

return {

line: lineMap.lineForOffset(error.offset),

message: printParseErrorCode(error.error),

import type { ChannelRuntimeSurface } from "openclaw/plugin-sdk/channel-contract";

import { Mock, vi } from "vitest";

import { vi } from "vitest";

import type { Mock } from "vitest";

import { clearSlackInboundDeliveryStateForTest } from "./monitor/inbound-delivery-state.js";

type SlackHandler = (args: unknown) => Promise<void>;

TelegramMessageContextOptions,

TelegramPromptContextEntry,

} from "./bot-message-context.types.js";

import {

parseTelegramNativeCommandCallbackData,

RegisterTelegramHandlerParams,

} from "./bot-native-commands.js";

import { parseTelegramNativeCommandCallbackData } from "./bot-native-commands.js";

import type { RegisterTelegramHandlerParams } from "./bot-native-commands.js";

import {

MEDIA_GROUP_TIMEOUT_MS,

type MediaGroupEntry,

};

class TelegramRetryableCallbackError extends Error {

constructor(public override readonly cause: unknown) {

public override readonly cause: unknown;

constructor(cause: unknown) {

super(String(cause));

this.cause = cause;

this.name = "TelegramRetryableCallbackError";

}

}

syncTelegramMenuCommands as syncTelegramMenuCommandsRuntime,

type TelegramMenuCommand,

} from "./bot-native-command-menu.js";

import { TelegramUpdateKeyContext } from "./bot-updates.js";

import type { TelegramUpdateKeyContext } from "./bot-updates.js";

import type { TelegramBotOptions } from "./bot.types.js";

import {

buildTelegramRoutingTarget,

import { WHATSAPP_GROUP_METADATA_CACHE_MAX_ENTRIES } from "./inbound/monitor.js";

import {

type InboxMonitorOptions,

InboxOnMessage,

buildNotifyMessageUpsert,

failNextWhatsAppPluginStateRegisterIfAbsent,

getAuthDir,

startInboxMonitor,

waitForMessageCalls,

} from "./monitor-inbox.test-harness.js";

import type { InboxOnMessage } from "./monitor-inbox.test-harness.js";

const { sleepWithAbortMock } = vi.hoisted(() => ({

sleepWithAbortMock: vi.fn(async (_ms: number, _signal?: AbortSignal) => undefined),