@53ai/53ai-openclaw 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1583 @@
+import { DEFAULT_ACCOUNT_ID, addWildcardAllowFrom, formatPairingApproveHint, emptyPluginConfigSchema } from 'openclaw/plugin-sdk';
+import WebSocket from 'ws';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+let runtime = null;
+function setRuntime(r) {
+    runtime = r;
+}
+function getRuntime() {
+    if (!runtime) {
+        throw new Error("Plugin runtime not initialized - plugin not registered");
+    }
+    return runtime;
+}
+
+const CHANNEL_ID = "53aihub";
+// ============================================================================
+// WebSocket 配置
+// ============================================================================
+/** 默认 WebSocket URL */
+const DEFAULT_WS_URL = "ws://localhost:8080/ws";
+/** 心跳间隔（毫秒） */
+const WS_HEARTBEAT_INTERVAL_MS = 15000;
+/**
+ * 最大重连次数
+ * 设为 60 次，配合指数退避（最大 30 秒），总重连时间约 30 分钟
+ */
+const WS_MAX_RECONNECT_ATTEMPTS = 60;
+/** 重连基础延迟（毫秒） - 指数退避的起始值 */
+const WS_RECONNECT_BASE_DELAY_MS = 1000;
+// ============================================================================
+// 消息处理配置
+// ============================================================================
+/** 文本分块限制 */
+const TEXT_CHUNK_LIMIT = 4000;
+/** 消息处理超时（毫秒） */
+const MESSAGE_PROCESS_TIMEOUT_MS = 120000;
+// ============================================================================
+// 媒体处理配置
+// ============================================================================
+/** 默认媒体大小上限（MB） */
+const DEFAULT_MEDIA_MAX_MB = 20;
+/** 图片下载超时（毫秒） */
+const IMAGE_DOWNLOAD_TIMEOUT_MS = 30000;
+/** 文件下载超时（毫秒） */
+const FILE_DOWNLOAD_TIMEOUT_MS = 60000;
+/** 仅包含图片时的消息占位符 */
+const MEDIA_IMAGE_PLACEHOLDER = "<media:image>";
+/** 仅包含文件时的消息占位符 */
+const MEDIA_DOCUMENT_PLACEHOLDER = "<media:document>";
+// ============================================================================
+// 状态管理配置
+// ============================================================================
+/** 消息状态 TTL（毫秒） */
+const MESSAGE_STATE_TTL_MS = 5 * 60 * 1000;
+/** 消息状态清理间隔（毫秒） */
+const MESSAGE_STATE_CLEANUP_INTERVAL_MS = 60 * 1000;
+/** 消息状态最大条目数 */
+const MESSAGE_STATE_MAX_SIZE = 1000;
+// ============================================================================
+// 持久化配置
+// ============================================================================
+/** 持久化目录名称 */
+const PERSISTENCE_DIR_NAME = ".53aihub_store";
+/** ReqId 存储文件名 */
+const REQID_STORE_FILENAME = "reqid_map.json";
+/** ReqId 刷写防抖时间（毫秒） */
+const REQID_FLUSH_DEBOUNCE_MS = 2000;
+/** ReqId 最大条目数 */
+const REQID_MAX_ENTRIES = 5000;
+const THINKING_MESSAGE = "🤔 正在思考中...";
+
+// ============================================================================
+// 错误处理
+// ============================================================================
+/**
+ * 错误码枚举
+ */
+var ErrorCode;
+(function (ErrorCode) {
+    // 访问控制
+    ErrorCode["ACCESS_DENIED"] = "ACCESS_DENIED";
+    ErrorCode["PAIRING_REQUIRED"] = "PAIRING_REQUIRED";
+    // AI 服务错误
+    ErrorCode["RATE_LIMITED"] = "RATE_LIMITED";
+    ErrorCode["INSUFFICIENT_QUOTA"] = "INSUFFICIENT_QUOTA";
+    ErrorCode["MODEL_OVERLOADED"] = "MODEL_OVERLOADED";
+    ErrorCode["MODEL_NOT_FOUND"] = "MODEL_NOT_FOUND";
+    // 请求错误
+    ErrorCode["INVALID_REQUEST"] = "INVALID_REQUEST";
+    ErrorCode["CONTEXT_LENGTH_EXCEEDED"] = "CONTEXT_LENGTH_EXCEEDED";
+    ErrorCode["CONTENT_FILTERED"] = "CONTENT_FILTERED";
+    // 系统错误
+    ErrorCode["TIMEOUT"] = "TIMEOUT";
+    ErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    ErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+    ErrorCode["WEBSOCKET_ERROR"] = "WEBSOCKET_ERROR";
+})(ErrorCode || (ErrorCode = {}));
+// ============================================================================
+// 错误码映射工具
+// ============================================================================
+/**
+ * 从错误消息中推断错误码
+ */
+function inferErrorCode(errorText) {
+    const text = errorText.toLowerCase();
+    if (text.includes("rate limit") || text.includes("429") || text.includes("too many requests")) {
+        return ErrorCode.RATE_LIMITED;
+    }
+    if (text.includes("quota") || text.includes("insufficient") || text.includes("balance") || text.includes("credit")) {
+        return ErrorCode.INSUFFICIENT_QUOTA;
+    }
+    if (text.includes("overload") || text.includes("capacity") || text.includes("temporarily unavailable")) {
+        return ErrorCode.MODEL_OVERLOADED;
+    }
+    if (text.includes("model not found") || text.includes("does not exist")) {
+        return ErrorCode.MODEL_NOT_FOUND;
+    }
+    if (text.includes("context length") || text.includes("token limit") || text.includes("max tokens")) {
+        return ErrorCode.CONTEXT_LENGTH_EXCEEDED;
+    }
+    if (text.includes("content filtered") || text.includes("content policy") || text.includes("safety")) {
+        return ErrorCode.CONTENT_FILTERED;
+    }
+    if (text.includes("timeout") || text.includes("timed out")) {
+        return ErrorCode.TIMEOUT;
+    }
+    if (text.includes("service unavailable") || text.includes("503")) {
+        return ErrorCode.SERVICE_UNAVAILABLE;
+    }
+    if (text.includes("invalid") || text.includes("bad request")) {
+        return ErrorCode.INVALID_REQUEST;
+    }
+    return ErrorCode.INTERNAL_ERROR;
+}
+
+function extractTextFromContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (Array.isArray(content)) {
+        return content
+            .filter((item) => typeof item === "object" && item !== null && item.type === "text")
+            .map((item) => item.text || "")
+            .join("\n");
+    }
+    return "";
+}
+function extractImagesFromContent(content) {
+    const urls = [];
+    const items = [];
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (typeof item !== "object" || item === null)
+                continue;
+            const itemRecord = item;
+            if (itemRecord.type === "image_url" &&
+                typeof itemRecord.image_url === "object" &&
+                itemRecord.image_url !== null &&
+                "url" in itemRecord.image_url) {
+                const url = String(itemRecord.image_url.url);
+                urls.push(url);
+                items.push({
+                    type: "image",
+                    image: { url },
+                });
+            }
+            else if (itemRecord.type === "image" && (itemRecord.url || itemRecord.base64)) {
+                if (typeof itemRecord.url === "string")
+                    urls.push(itemRecord.url);
+                items.push({
+                    type: "image",
+                    image: {
+                        url: typeof itemRecord.url === "string" ? itemRecord.url : undefined,
+                        base64: typeof itemRecord.base64 === "string" ? itemRecord.base64 : undefined,
+                        mimeType: typeof itemRecord.mimeType === "string" ? itemRecord.mimeType : undefined,
+                    },
+                });
+            }
+        }
+    }
+    return { urls, items };
+}
+function extractFilesFromContent(content) {
+    const urls = [];
+    const items = [];
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (typeof item !== "object" || item === null)
+                continue;
+            const itemRecord = item;
+            if (itemRecord.type === "file" && (itemRecord.url || itemRecord.base64)) {
+                if (typeof itemRecord.url === "string")
+                    urls.push(itemRecord.url);
+                items.push({
+                    type: "file",
+                    file: {
+                        url: typeof itemRecord.url === "string" ? itemRecord.url : undefined,
+                        base64: typeof itemRecord.base64 === "string" ? itemRecord.base64 : undefined,
+                        filename: typeof itemRecord.filename === "string" ? itemRecord.filename : undefined,
+                        mimeType: typeof itemRecord.mimeType === "string" ? itemRecord.mimeType : undefined,
+                    },
+                });
+            }
+        }
+    }
+    return { urls, items };
+}
+function parseIncomingMessage(rawJson) {
+    try {
+        const wsMsg = JSON.parse(rawJson);
+        if (wsMsg.action === "ping" || wsMsg.action === "pong") {
+            return null;
+        }
+        if (wsMsg.action === "chat") {
+            const openAIReq = wsMsg.data;
+            if (!openAIReq || !openAIReq.messages || !Array.isArray(openAIReq.messages)) {
+                return null;
+            }
+            const lastUserMsg = [...openAIReq.messages].reverse().find((m) => m.role === "user");
+            if (!lastUserMsg)
+                return null;
+            const userId = openAIReq.user || lastUserMsg.name || `user-${wsMsg.req_id}`;
+            const chatId = openAIReq.conversation_id || userId;
+            const text = extractTextFromContent(lastUserMsg.content);
+            const { urls: imageUrls, items: imageItems } = extractImagesFromContent(lastUserMsg.content);
+            const { urls: fileUrls, items: fileItems } = extractFilesFromContent(lastUserMsg.content);
+            const contentItems = [...imageItems, ...fileItems];
+            return {
+                type: "message",
+                msgId: wsMsg.req_id,
+                reqId: wsMsg.req_id,
+                chatId: chatId,
+                userId: userId,
+                text,
+                imageUrls: imageUrls.length > 0 ? imageUrls : undefined,
+                fileUrls: fileUrls.length > 0 ? fileUrls : undefined,
+                contentItems: contentItems.length > 0 ? contentItems : undefined,
+            };
+        }
+        // 处理非标准格式的消息 (action === "message")
+        const data = wsMsg.data;
+        const dataRecord = data;
+        const rawImages = dataRecord.images;
+        const rawFiles = dataRecord.files;
+        const imageUrls = data.imageUrls ||
+            (Array.isArray(rawImages) ? rawImages.map((img) => {
+                if (typeof img === "string")
+                    return img;
+                if (typeof img === "object" && img !== null && "url" in img)
+                    return String(img.url);
+                return "";
+            }).filter(Boolean) : []);
+        const fileUrls = data.fileUrls ||
+            (Array.isArray(rawFiles) ? rawFiles.map((f) => {
+                if (typeof f === "string")
+                    return f;
+                if (typeof f === "object" && f !== null && "url" in f)
+                    return String(f.url);
+                return "";
+            }).filter(Boolean) : []);
+        return {
+            type: dataRecord.type || "message",
+            msgId: dataRecord.msgId || dataRecord.id || `msg-${Date.now()}`,
+            chatId: dataRecord.chatId || dataRecord.userId || "default-chat",
+            userId: dataRecord.userId || dataRecord.chatId || "default-user",
+            text: dataRecord.text || dataRecord.content || "",
+            imageUrls: imageUrls.length > 0 ? imageUrls : undefined,
+            fileUrls: fileUrls.length > 0 ? fileUrls : undefined,
+            quoteContent: dataRecord.quoteContent,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseMessageContent(msg) {
+    const textParts = [];
+    const imageUrls = [];
+    const fileUrls = [];
+    const contentItems = [];
+    if (msg.text?.trim()) {
+        textParts.push(msg.text.trim());
+    }
+    if (msg.imageUrls?.length) {
+        imageUrls.push(...msg.imageUrls);
+        for (const url of msg.imageUrls) {
+            contentItems.push({ type: "image", image: { url } });
+        }
+    }
+    if (msg.fileUrls?.length) {
+        fileUrls.push(...msg.fileUrls);
+        for (const url of msg.fileUrls) {
+            contentItems.push({ type: "file", file: { url } });
+        }
+    }
+    if (msg.contentItems?.length) {
+        for (const item of msg.contentItems) {
+            if (item.type === "image" && item.image?.url && !imageUrls.includes(item.image.url)) {
+                imageUrls.push(item.image.url);
+            }
+            if (item.type === "file" && item.file?.url && !fileUrls.includes(item.file.url)) {
+                fileUrls.push(item.file.url);
+            }
+            contentItems.push(item);
+        }
+    }
+    return { textParts, imageUrls, fileUrls, contentItems };
+}
+
+async function sendReply(params) {
+    const { wsClient, text, toChatId, replyToMsgId, runtime, finish, streamId, isError, errorCode, errorDetails } = params;
+    const reqId = replyToMsgId || streamId;
+    runtime.log?.(`[53aihub] sendReply START: reqId=${reqId}, finish=${finish}, isError=${isError}, textLen=${text?.length || 0}, wsReadyState=${wsClient.readyState}`);
+    if (wsClient.readyState !== 1) {
+        runtime.error?.(`[53aihub] WebSocket is not open (readyState=${wsClient.readyState}). Cannot send message to ${toChatId}`);
+        return;
+    }
+    if (isError) {
+        runtime.error?.(`[53aihub] sendReply ERROR: reqId=${reqId}, code=${errorCode}, text=${text?.substring(0, 100)}`);
+        const errorInfo = {
+            code: errorCode || ErrorCode.INTERNAL_ERROR,
+            message: text || "Unknown error",
+            details: errorDetails,
+        };
+        const errorChunk = {
+            id: reqId,
+            object: "chat.completion.chunk",
+            created: Math.floor(Date.now() / 1000),
+            model: "openclaw-agent",
+            choices: [
+                {
+                    index: 0,
+                    delta: {
+                        content: text,
+                        role: "assistant",
+                    },
+                    finish_reason: "error",
+                },
+            ],
+            error: errorInfo,
+        };
+        const errMsg = {
+            req_id: reqId,
+            action: "chat",
+            status: "error",
+            data: errorChunk,
+        };
+        const jsonStr = JSON.stringify(errMsg);
+        runtime.log?.(`[53aihub] sendReply ERROR SENDING: reqId=${reqId}, payloadLen=${jsonStr.length}`);
+        wsClient.send(jsonStr);
+        return;
+    }
+    const chunk = {
+        id: reqId,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: "openclaw-agent",
+        choices: [
+            {
+                index: 0,
+                delta: {
+                    content: text,
+                    role: "assistant",
+                },
+                finish_reason: finish ? "stop" : null,
+            },
+        ],
+    };
+    const payload = {
+        req_id: reqId,
+        action: "chat",
+        status: finish ? "done" : "streaming",
+        data: chunk,
+    };
+    const jsonStr = JSON.stringify(payload);
+    runtime.log?.(`[53aihub] sendReply SENDING: reqId=${reqId}, status=${payload.status}, textLen=${text?.length || 0}, payloadLen=${jsonStr.length}, textPreview=${text?.substring(0, 50) || "(empty)"}`);
+    try {
+        wsClient.send(jsonStr);
+        runtime.log?.(`[53aihub] sendReply SENT: reqId=${reqId}, status=${payload.status}`);
+    }
+    catch (error) {
+        runtime.error?.(`[53aihub] sendReply FAILED: reqId=${reqId}, error=${String(error)}`);
+        throw error;
+    }
+}
+async function sendDirectMessage(wsClient, to, content, runtime) {
+    if (wsClient.readyState !== 1) {
+        throw new Error(`[53aihub] WebSocket not connected`);
+    }
+    const payload = {
+        req_id: `msg-${Date.now()}`,
+        action: "message",
+        status: "final",
+        data: {
+            toChatId: to,
+            text: content,
+        },
+    };
+    wsClient.send(JSON.stringify(payload));
+}
+async function sendMediaMessage(wsClient, to, media, text, runtime) {
+    if (wsClient.readyState !== 1) {
+        throw new Error(`[53aihub] WebSocket not connected`);
+    }
+    const payload = {
+        req_id: `msg-${Date.now()}`,
+        action: "message",
+        status: "final",
+        data: {
+            toChatId: to,
+            text: text || "",
+            media: {
+                type: media.type,
+                url: media.url,
+                base64: media.base64,
+                mimeType: media.mimeType,
+                filename: media.filename,
+            },
+        },
+    };
+    wsClient.send(JSON.stringify(payload));
+}
+async function sendThinkingMessage(wsClient, text, msgId, streamId, runtime) {
+    const wsState = wsClient.readyState;
+    runtime?.log?.(`[53aihub] sendThinkingMessage CALLED: msgId=${msgId}, streamId=${streamId}, text=${text}, wsReadyState=${wsState}`);
+    if (wsState !== 1) {
+        runtime?.error?.(`[53aihub] sendThinkingMessage SKIPPED: WebSocket not ready (state=${wsState})`);
+        return;
+    }
+    // 使用 OpenAI 兼容格式，确保 Go 后端能正确解析
+    // 关键：req_id 必须使用原始消息的 msgId，这样 Go 后端才能关联请求和响应
+    const chunk = {
+        id: streamId,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: "openclaw-agent",
+        choices: [
+            {
+                index: 0,
+                delta: {
+                    content: text,
+                    role: "assistant",
+                },
+                finish_reason: null,
+            },
+        ],
+    };
+    const payload = {
+        req_id: msgId,
+        action: "chat",
+        status: "thinking",
+        data: chunk,
+    };
+    const jsonStr = JSON.stringify(payload);
+    runtime?.log?.(`[53aihub] sendThinkingMessage SENDING: ${jsonStr}`);
+    try {
+        wsClient.send(jsonStr);
+        runtime?.log?.(`[53aihub] sendThinkingMessage SENT SUCCESS: msgId=${msgId}`);
+    }
+    catch (err) {
+        runtime?.error?.(`[53aihub] sendThinkingMessage SEND FAILED: ${String(err)}`);
+    }
+}
+
+/**
+ * 访问策略检查
+ *
+ * 策略模式：
+ * - "open": 允许所有用户（默认）
+ * - "allowlist": 仅允许 allowFrom 中的用户
+ * - "pairing": 首次使用需要管理员审批
+ */
+async function checkAccessPolicy(options) {
+    const { userId, account, runtime } = options;
+    const core = getRuntime();
+    const accessPolicy = account.config.accessPolicy ?? "open";
+    // 开放模式 - 所有用户都能用
+    if (accessPolicy === "open") {
+        return { allowed: true };
+    }
+    // 白名单模式
+    if (accessPolicy === "allowlist") {
+        const allowFrom = account.config.allowFrom ?? [];
+        if (allowFrom.includes(userId)) {
+            return { allowed: true };
+        }
+        runtime.log?.(`[53aihub] User ${userId} not in allowlist`);
+        return { allowed: false, reason: `User ${userId} not in allowlist` };
+    }
+    // 配对模式 - 首次使用需要审批
+    if (accessPolicy === "pairing") {
+        // 检查配置中的白名单
+        const allowFrom = account.config.allowFrom ?? [];
+        if (allowFrom.includes(userId)) {
+            return { allowed: true };
+        }
+        // 检查持久化的配对记录
+        const persistentAllowFrom = await core.channel.pairing.readAllowFromStore({
+            channel: CHANNEL_ID,
+            accountId: account.accountId,
+        });
+        if (persistentAllowFrom.includes(userId)) {
+            return { allowed: true };
+        }
+        // 记录配对请求
+        runtime.log?.(`[53aihub] User ${userId} requires pairing. Recording request.`);
+        await core.channel.pairing.upsertPairingRequest({
+            channel: CHANNEL_ID,
+            accountId: account.accountId,
+            id: userId,
+            meta: {
+                displayName: `53AIHub 用户 (${userId})`,
+            },
+        });
+        return { allowed: false, reason: "Pairing required" };
+    }
+    return { allowed: false };
+}
+
+function createPersistentReqIdStore(accountId) {
+    const memoryCache = new Map();
+    let flushTimer = null;
+    let isDirty = false;
+    const getStoreDir = () => {
+        const storagePath = getRuntime().state.resolveStateDir();
+        const dir = path.join(storagePath, PERSISTENCE_DIR_NAME, accountId);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+    };
+    const getStorePath = () => path.join(getStoreDir(), REQID_STORE_FILENAME);
+    const scheduleFlush = () => {
+        isDirty = true;
+        if (flushTimer)
+            return;
+        flushTimer = setTimeout(async () => {
+            await flush();
+        }, REQID_FLUSH_DEBOUNCE_MS);
+    };
+    const flush = async () => {
+        if (!isDirty)
+            return;
+        if (flushTimer) {
+            clearTimeout(flushTimer);
+            flushTimer = null;
+        }
+        try {
+            const data = JSON.stringify(Object.fromEntries(memoryCache));
+            const filePath = getStorePath();
+            const tmpPath = `${filePath}.tmp`;
+            fs.writeFileSync(tmpPath, data);
+            fs.renameSync(tmpPath, filePath);
+            isDirty = false;
+        }
+        catch (error) {
+            console.error(`[53aihub] Failed to flush reqId store for ${accountId}:`, error);
+        }
+    };
+    return {
+        set(chatId, reqId) {
+            memoryCache.set(chatId, reqId);
+            if (memoryCache.size > REQID_MAX_ENTRIES) {
+                const firstKey = memoryCache.keys().next().value;
+                if (firstKey !== undefined)
+                    memoryCache.delete(firstKey);
+            }
+            scheduleFlush();
+        },
+        async get(chatId) {
+            return memoryCache.get(chatId);
+        },
+        getSync(chatId) {
+            return memoryCache.get(chatId);
+        },
+        delete(chatId) {
+            if (memoryCache.delete(chatId)) {
+                scheduleFlush();
+            }
+        },
+        async warmup(onError) {
+            try {
+                const filePath = getStorePath();
+                if (fs.existsSync(filePath)) {
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    const data = JSON.parse(content);
+                    memoryCache.clear();
+                    for (const [k, v] of Object.entries(data)) {
+                        memoryCache.set(k, v);
+                    }
+                    return memoryCache.size;
+                }
+            }
+            catch (error) {
+                onError?.(error);
+            }
+            return 0;
+        },
+        flush,
+    };
+}
+
+const wsClientInstances = new Map();
+function getWebSocket(accountId) {
+    return wsClientInstances.get(accountId) ?? null;
+}
+function setWebSocket(accountId, client) {
+    wsClientInstances.set(accountId, client);
+}
+const messageStates = new Map();
+let cleanupTimer = null;
+function startMessageStateCleanup() {
+    if (cleanupTimer)
+        return;
+    cleanupTimer = setInterval(() => {
+        pruneMessageStates();
+    }, MESSAGE_STATE_CLEANUP_INTERVAL_MS);
+    if (cleanupTimer && typeof cleanupTimer === "object" && "unref" in cleanupTimer) {
+        cleanupTimer.unref();
+    }
+}
+function pruneMessageStates() {
+    const now = Date.now();
+    for (const [key, entry] of messageStates) {
+        if (now - entry.createdAt >= MESSAGE_STATE_TTL_MS) {
+            messageStates.delete(key);
+        }
+    }
+    if (messageStates.size > MESSAGE_STATE_MAX_SIZE) {
+        const sorted = [...messageStates.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt);
+        const toRemove = sorted.slice(0, messageStates.size - MESSAGE_STATE_MAX_SIZE);
+        for (const [key] of toRemove) {
+            messageStates.delete(key);
+        }
+    }
+}
+function setMessageState(messageId, state) {
+    messageStates.set(messageId, {
+        state,
+        createdAt: Date.now(),
+    });
+}
+function deleteMessageState(messageId) {
+    messageStates.delete(messageId);
+}
+// ReqId Persistence Management
+const reqIdStores = new Map();
+function getOrCreateReqIdStore(accountId) {
+    let store = reqIdStores.get(accountId);
+    if (!store) {
+        store = createPersistentReqIdStore(accountId);
+        reqIdStores.set(accountId, store);
+    }
+    return store;
+}
+function setLastMsgIdForChat(chatId, msgId, accountId = "default") {
+    getOrCreateReqIdStore(accountId).set(chatId, msgId);
+}
+async function warmupReqIdStore(accountId = "default", log) {
+    const store = getOrCreateReqIdStore(accountId);
+    return store.warmup((err) => log?.(`ReqId warmup error: ${String(err)}`));
+}
+async function cleanupAccount(accountId) {
+    const wsClient = wsClientInstances.get(accountId);
+    if (wsClient) {
+        try {
+            wsClient.close();
+        }
+        catch (err) {
+            console.error(`[53aihub] Error closing WebSocket for account ${accountId}:`, err);
+        }
+        wsClientInstances.delete(accountId);
+    }
+    const store = reqIdStores.get(accountId);
+    if (store)
+        await store.flush();
+}
+
+/**
+ * 超时处理工具模块
+ */
+/**
+ * 为 Promise 添加超时保护
+ * @param promise 需要包装的 Promise
+ * @param ms 超时时间（毫秒）
+ * @param message 超时错误消息
+ */
+async function withTimeout(promise, ms, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`Timeout after ${ms}ms: ${message}`));
+        }, ms);
+        promise
+            .then((result) => {
+            clearTimeout(timer);
+            resolve(result);
+        })
+            .catch((error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+
+async function detectContentType(data) {
+    const header = data.slice(0, 12);
+    if (header[0] === 0xff && header[1] === 0xd8 && header[2] === 0xff) {
+        return "image/jpeg";
+    }
+    if (header[0] === 0x89 && header[1] === 0x50 && header[2] === 0x4e && header[3] === 0x47) {
+        return "image/png";
+    }
+    if (header[0] === 0x47 && header[1] === 0x49 && header[2] === 0x46) {
+        return "image/gif";
+    }
+    if (header[0] === 0x52 && header[1] === 0x49 && header[2] === 0x46 && header[3] === 0x46) {
+        if (header[8] === 0x57 && header[9] === 0x45 && header[10] === 0x42 && header[11] === 0x50) {
+            return "image/webp";
+        }
+    }
+    if (header[4] === 0x66 && header[5] === 0x74 && header[6] === 0x79 && header[7] === 0x70) {
+        const ftyp = header.slice(8, 12).toString("ascii");
+        if (ftyp.startsWith("heic") || ftyp.startsWith("heix"))
+            return "image/heic";
+        if (ftyp.startsWith("avif"))
+            return "image/avif";
+        return "video/mp4";
+    }
+    if (header[0] === 0x25 && header[1] === 0x50 && header[2] === 0x44 && header[3] === 0x46) {
+        return "application/pdf";
+    }
+    if (header.slice(0, 4).toString("ascii") === "PK\x03\x04") {
+        return "application/zip";
+    }
+    return "application/octet-stream";
+}
+async function downloadAndSaveImages(params) {
+    const { imageUrls, config, runtime } = params;
+    const core = getRuntime();
+    const mediaList = [];
+    for (const imageUrl of imageUrls) {
+        try {
+            runtime.log?.(`[53aihub] Downloading image from: ${imageUrl}`);
+            const mediaMaxMb = config.agents?.defaults?.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB;
+            const maxBytes = mediaMaxMb * 1024 * 1024;
+            const fetched = await withTimeout(core.channel.media.fetchRemoteMedia({ url: imageUrl }), IMAGE_DOWNLOAD_TIMEOUT_MS, `Image download timed out: ${imageUrl}`);
+            let imageBuffer = fetched.buffer;
+            let imageContentType = fetched.contentType ?? await detectContentType(imageBuffer);
+            runtime.log?.(`[53aihub] Image fetched: contentType=${imageContentType}, size=${imageBuffer.length}`);
+            const saved = await core.channel.media.saveMediaBuffer(imageBuffer, imageContentType, "inbound", maxBytes);
+            mediaList.push({ path: saved.path, contentType: saved.contentType });
+            runtime.log?.(`[53aihub] Image saved to ${saved.path}`);
+        }
+        catch (err) {
+            runtime.error?.(`[53aihub] Failed to download image: ${String(err)}`);
+        }
+    }
+    return mediaList;
+}
+async function downloadAndSaveFiles(params) {
+    const { fileUrls, config, runtime } = params;
+    const core = getRuntime();
+    const mediaList = [];
+    for (const fileUrl of fileUrls) {
+        try {
+            runtime.log?.(`[53aihub] Downloading file from: ${fileUrl}`);
+            const mediaMaxMb = config.agents?.defaults?.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB;
+            const maxBytes = mediaMaxMb * 1024 * 1024;
+            const fetched = await withTimeout(core.channel.media.fetchRemoteMedia({ url: fileUrl }), FILE_DOWNLOAD_TIMEOUT_MS, `File download timed out: ${fileUrl}`);
+            let fileBuffer = fetched.buffer;
+            let fileContentType = fetched.contentType ?? await detectContentType(fileBuffer);
+            runtime.log?.(`[53aihub] File fetched: contentType=${fileContentType}, size=${fileBuffer.length}`);
+            const saved = await core.channel.media.saveMediaBuffer(fileBuffer, fileContentType, "inbound", maxBytes);
+            mediaList.push({ path: saved.path, contentType: saved.contentType });
+            runtime.log?.(`[53aihub] File saved to ${saved.path}`);
+        }
+        catch (err) {
+            runtime.error?.(`[53aihub] Failed to download file: ${String(err)}`);
+        }
+    }
+    return mediaList;
+}
+
+// 消息队列处理器 - 确保消息按顺序处理，避免竞态条件
+class MessageQueue {
+    queue = [];
+    processing = false;
+    runtime;
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    enqueue(task) {
+        this.queue.push(task);
+        this.process();
+    }
+    async process() {
+        if (this.processing || this.queue.length === 0)
+            return;
+        this.processing = true;
+        try {
+            const task = this.queue.shift();
+            if (task) {
+                await task();
+            }
+        }
+        catch (err) {
+            this.runtime.error?.(`[53aihub] MessageQueue error: ${String(err)}`);
+        }
+        finally {
+            this.processing = false;
+            // 继续处理队列中的下一条消息
+            if (this.queue.length > 0) {
+                this.process();
+            }
+        }
+    }
+    clear() {
+        this.queue = [];
+    }
+}
+function buildMessageContext(body, account, config, mediaList) {
+    const core = getRuntime();
+    const chatId = body.chatId || body.userId;
+    const route = core.channel.routing.resolveAgentRoute({
+        cfg: config,
+        channel: CHANNEL_ID,
+        accountId: account.accountId,
+        peer: {
+            kind: "direct",
+            id: chatId,
+        },
+    });
+    const hasImages = mediaList.some((m) => m.contentType?.startsWith("image/"));
+    const messageBody = body.text || (mediaList.length > 0 ? (hasImages ? MEDIA_IMAGE_PLACEHOLDER : MEDIA_DOCUMENT_PLACEHOLDER) : "");
+    const mediaPaths = mediaList.length > 0 ? mediaList.map((m) => m.path) : undefined;
+    const mediaTypes = mediaList.length > 0
+        ? mediaList.map((m) => m.contentType).filter(Boolean)
+        : undefined;
+    return core.channel.reply.finalizeInboundContext({
+        Body: messageBody,
+        RawBody: messageBody,
+        CommandBody: messageBody,
+        MessageSid: body.msgId,
+        From: `${CHANNEL_ID}:${body.userId}`,
+        To: `${CHANNEL_ID}:${chatId}`,
+        SenderId: body.userId,
+        SessionKey: route.sessionKey,
+        AccountId: account.accountId,
+        ChatType: "direct",
+        ConversationLabel: `user:${body.userId}`,
+        Timestamp: Date.now(),
+        Provider: CHANNEL_ID,
+        Surface: CHANNEL_ID,
+        OriginatingChannel: CHANNEL_ID,
+        OriginatingTo: `${CHANNEL_ID}:${chatId}`,
+        CommandAuthorized: true,
+        ReplyToBody: body.quoteContent,
+        MediaPath: mediaList[0]?.path,
+        MediaType: mediaList[0]?.contentType,
+        MediaPaths: mediaPaths,
+        MediaTypes: mediaTypes,
+        MediaUrls: mediaPaths,
+    });
+}
+async function processMessage(params) {
+    const { rawPayload, account, config, runtime, wsClient } = params;
+    runtime.log?.(`[53aihub] processMessage: rawPayload length=${rawPayload.length}`);
+    const body = parseIncomingMessage(rawPayload);
+    if (!body) {
+        runtime.log?.(`[53aihub] processMessage: parseIncomingMessage returned null`);
+        return;
+    }
+    const parsed = parseMessageContent(body);
+    const hasMedia = parsed.imageUrls.length > 0 || parsed.fileUrls.length > 0;
+    if (!parsed.textParts.join("\n").trim() && !hasMedia) {
+        runtime.log?.(`[53aihub] processMessage: empty message, body=${JSON.stringify(body)}`);
+        return;
+    }
+    const chatId = body.chatId || body.userId;
+    runtime.log?.(`[53aihub] processMessage: chatId=${chatId}, msgId=${body.msgId}, text=${parsed.textParts.join(" ").substring(0, 50)}... images=${parsed.imageUrls.length} files=${parsed.fileUrls.length}`);
+    const core = getRuntime();
+    const streamId = `stream-${Date.now()}`;
+    const accessResult = await checkAccessPolicy({
+        userId: body.userId,
+        account,
+        runtime,
+    });
+    if (!accessResult.allowed) {
+        await sendReply({
+            wsClient,
+            text: accessResult.reason === "Pairing required"
+                ? "您尚未获得授权使用此机器人，请联系管理员进行审核。"
+                : `⚠️ 访问被拒绝: ${accessResult.reason || "未知原因"}`,
+            toChatId: chatId,
+            replyToMsgId: body.msgId,
+            runtime,
+            finish: true,
+            streamId,
+            isError: true,
+            errorCode: ErrorCode.ACCESS_DENIED,
+            errorDetails: accessResult.reason,
+        });
+        return;
+    }
+    setLastMsgIdForChat(chatId, body.msgId, account.accountId);
+    const state = { accumulatedText: "", lastSentText: "", streamId };
+    setMessageState(body.msgId, state);
+    if (account.sendThinkingMessage) {
+        runtime.log?.(`[53aihub] processMessage: sendThinkingMessage=${account.sendThinkingMessage}, about to send thinking message`);
+        try {
+            await sendThinkingMessage(wsClient, THINKING_MESSAGE, body.msgId, state.streamId, runtime);
+            runtime.log?.(`[53aihub] processMessage: thinking message sent successfully`);
+        }
+        catch (err) {
+            runtime.error?.(`[53aihub] Failed to send thinking message: ${String(err)}`);
+        }
+    }
+    else {
+        runtime.log?.(`[53aihub] processMessage: sendThinkingMessage=${account.sendThinkingMessage}, SKIPPING thinking message`);
+    }
+    const cleanupState = () => {
+        deleteMessageState(body.msgId);
+    };
+    const [imageMediaList, fileMediaList] = await Promise.all([
+        downloadAndSaveImages({
+            imageUrls: parsed.imageUrls,
+            config,
+            runtime}),
+        downloadAndSaveFiles({
+            fileUrls: parsed.fileUrls,
+            config,
+            runtime}),
+    ]);
+    const mediaList = [...imageMediaList, ...fileMediaList];
+    const ctxPayload = buildMessageContext(body, account, config, mediaList);
+    let cleanedUp = false;
+    const safeCleanup = () => {
+        if (!cleanedUp) {
+            cleanedUp = true;
+            cleanupState();
+        }
+    };
+    runtime.log?.(`[53aihub] processMessage: Starting dispatchReplyWithBufferedBlockDispatcher for msgId=${body.msgId}`);
+    try {
+        await withTimeout(core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg: config,
+            dispatcherOptions: {
+                deliver: async (payload, info) => {
+                    state.accumulatedText += payload.text;
+                    runtime.log?.(`[53aihub] deliver: kind=${info.kind}, textLen=${payload.text?.length || 0}, accumulatedLen=${state.accumulatedText.length}, isError=${payload.isError}`);
+                    if (payload.isError) {
+                        const errorMsg = payload.text || "Unknown error";
+                        const errorCode = inferErrorCode(errorMsg);
+                        runtime.error?.(`[53aihub] deliver ERROR: ${errorMsg}`);
+                        await sendReply({
+                            wsClient,
+                            text: `⚠️ ${errorMsg}`,
+                            toChatId: chatId,
+                            replyToMsgId: body.msgId,
+                            runtime,
+                            finish: true,
+                            streamId: state.streamId,
+                            isError: true,
+                            errorCode,
+                            errorDetails: errorMsg,
+                        });
+                        return;
+                    }
+                    if (info.kind !== "final") {
+                        runtime.log?.(`[53aihub] deliver STREAMING: accumulatedText preview=${state.accumulatedText.substring(0, 50)}...`);
+                        await sendReply({
+                            wsClient,
+                            text: state.accumulatedText,
+                            toChatId: chatId,
+                            replyToMsgId: body.msgId,
+                            runtime,
+                            finish: false,
+                            streamId: state.streamId,
+                        });
+                    }
+                },
+                onError: async (err, info) => {
+                    runtime.error?.(`[53aihub] onError: kind=${info.kind}, error=${String(err)}`);
+                    const errorText = String(err);
+                    const errorCode = inferErrorCode(errorText);
+                    try {
+                        await sendReply({
+                            wsClient,
+                            text: `⚠️ 系统错误: ${errorText}`,
+                            toChatId: chatId,
+                            replyToMsgId: body.msgId,
+                            runtime,
+                            finish: true,
+                            streamId: state.streamId,
+                            isError: true,
+                            errorCode,
+                            errorDetails: `kind=${info.kind}, error=${errorText}`,
+                        });
+                    }
+                    catch (sendErr) {
+                        runtime.error?.(`[53aihub] Failed to send error notification: ${String(sendErr)}`);
+                    }
+                },
+            },
+        }), MESSAGE_PROCESS_TIMEOUT_MS, `Message processing timed out (msgId=${body.msgId})`);
+        runtime.log?.(`[53aihub] processMessage: dispatchReply completed, accumulatedTextLen=${state.accumulatedText.length}`);
+        if (state.accumulatedText) {
+            runtime.log?.(`[53aihub] processMessage: Sending final reply with accumulatedText`);
+            await sendReply({
+                wsClient,
+                text: state.accumulatedText,
+                toChatId: chatId,
+                replyToMsgId: body.msgId,
+                runtime,
+                finish: true,
+                streamId: state.streamId,
+            });
+        }
+        else {
+            runtime.log?.(`[53aihub] processMessage: No accumulatedText, sending empty final reply`);
+            await sendReply({
+                wsClient,
+                text: "",
+                toChatId: chatId,
+                replyToMsgId: body.msgId,
+                runtime,
+                finish: true,
+                streamId: state.streamId,
+            });
+        }
+        safeCleanup();
+    }
+    catch (err) {
+        runtime.error?.(`[53aihub] processMessage FAILED: ${String(err)}`);
+        const errorText = String(err);
+        const errorCode = inferErrorCode(errorText);
+        if (!cleanedUp) {
+            try {
+                await sendReply({
+                    wsClient,
+                    text: `⚠️ 处理请求时发生异常: ${errorText}`,
+                    toChatId: chatId,
+                    replyToMsgId: body.msgId,
+                    runtime,
+                    finish: true,
+                    streamId: state.streamId,
+                    isError: true,
+                    errorCode,
+                    errorDetails: errorText,
+                });
+            }
+            catch (sendErr) {
+                runtime.error?.(`[53aihub] Failed to send final error notification: ${String(sendErr)}`);
+            }
+        }
+        safeCleanup();
+    }
+}
+async function monitorProvider(options) {
+    const { account, config, runtime, abortSignal } = options;
+    runtime.log?.(`[${account.accountId}] Initializing WS connection to 53AIHub...`);
+    startMessageStateCleanup();
+    return new Promise((resolve, reject) => {
+        let wsClient = null;
+        let reconnectAttempts = 0;
+        let pingInterval = null;
+        let isAborted = false;
+        let messageQueue = null;
+        const cleanup = async () => {
+            if (pingInterval) {
+                clearInterval(pingInterval);
+                pingInterval = null;
+            }
+            if (messageQueue) {
+                messageQueue.clear();
+                messageQueue = null;
+            }
+            await cleanupAccount(account.accountId);
+        };
+        const connect = () => {
+            if (isAborted)
+                return;
+            // 安全: 不在 URL 中传递敏感信息，仅通过 headers 传递认证
+            const wsUrl = account.websocketUrl;
+            const botId = account.botId || account.config.botId;
+            const secret = account.secret || account.token || account.config.secret || account.config.token;
+            // 日志输出时隐藏敏感信息
+            const safeUrl = new URL(wsUrl);
+            const logUrl = `${safeUrl.origin}${safeUrl.pathname}`;
+            const authBase64 = Buffer.from(`${botId}:${secret}`).toString('base64');
+            const wsOptions = {
+                headers: {
+                    "Authorization": `Bearer ${secret}`,
+                    "Proxy-Authorization": `Basic ${authBase64}`,
+                    "X-Bot-Id": botId || "",
+                    "X-Api-Key": secret || "",
+                }
+            };
+            runtime.log?.(`[${account.accountId}] Connecting to ${logUrl} ...`);
+            wsClient = new WebSocket(wsUrl, wsOptions);
+            setWebSocket(account.accountId, wsClient);
+            // 初始化消息队列
+            messageQueue = new MessageQueue(runtime);
+            wsClient.on("open", () => {
+                runtime.log?.(`[${account.accountId}] WebSocket connected successfully`);
+                reconnectAttempts = 0;
+                pingInterval = setInterval(() => {
+                    if (wsClient?.readyState === WebSocket.OPEN) {
+                        wsClient.ping();
+                    }
+                }, WS_HEARTBEAT_INTERVAL_MS);
+            });
+            wsClient.on("message", (data) => {
+                const rawPayload = data.toString();
+                runtime.log?.(`[${account.accountId}] Received WS message: ${rawPayload.substring(0, 200)}...`);
+                // 使用消息队列确保顺序处理，避免竞态条件
+                messageQueue?.enqueue(async () => {
+                    await processMessage({
+                        rawPayload,
+                        account,
+                        config,
+                        runtime,
+                        wsClient: wsClient,
+                    });
+                });
+            });
+            wsClient.on("error", (err) => {
+                runtime.error?.(`[${account.accountId}] WebSocket Error: ${String(err)}`);
+            });
+            wsClient.on("close", async (code, reason) => {
+                runtime.log?.(`[${account.accountId}] WebSocket closed. Code: ${code}, Reason: ${reason}`);
+                // 清理资源
+                if (pingInterval) {
+                    clearInterval(pingInterval);
+                    pingInterval = null;
+                }
+                if (messageQueue) {
+                    messageQueue.clear();
+                    messageQueue = null;
+                }
+                if (!isAborted && reconnectAttempts < WS_MAX_RECONNECT_ATTEMPTS) {
+                    reconnectAttempts++;
+                    const backoff = Math.min(WS_RECONNECT_BASE_DELAY_MS * Math.pow(2, reconnectAttempts), 30000);
+                    runtime.log?.(`[${account.accountId}] Reconnecting in ${backoff}ms... (attempt ${reconnectAttempts}/${WS_MAX_RECONNECT_ATTEMPTS})`);
+                    setTimeout(connect, backoff);
+                }
+                else if (!isAborted) {
+                    runtime.error?.(`[${account.accountId}] Max reconnect attempts (${WS_MAX_RECONNECT_ATTEMPTS}) reached`);
+                    await cleanup();
+                    reject(new Error(`Max reconnect attempts (${WS_MAX_RECONNECT_ATTEMPTS}) reached`));
+                }
+            });
+        };
+        if (abortSignal) {
+            abortSignal.addEventListener("abort", async () => {
+                isAborted = true;
+                await cleanup();
+                resolve();
+            });
+        }
+        warmupReqIdStore(account.accountId, (msg) => runtime.log?.(msg))
+            .then(() => connect())
+            .catch(async (err) => {
+            runtime.error?.(`[${account.accountId}] Failed to warmup ReqId store: ${String(err)}`);
+            await cleanup();
+            reject(err);
+        });
+    });
+}
+
+// ============================================================================
+// 配置解析函数
+// ============================================================================
+/**
+ * 解析账户配置
+ */
+function resolveAccount(cfg, accountId = DEFAULT_ACCOUNT_ID) {
+    const config = (cfg.channels?.[CHANNEL_ID] ?? {});
+    return {
+        accountId,
+        name: config.name ?? "53AIHub",
+        enabled: config.enabled !== false,
+        websocketUrl: config.websocketUrl || DEFAULT_WS_URL,
+        botId: config.botId ?? config.userId ?? "",
+        secret: config.secret ?? config.token ?? "",
+        token: config.token ?? config.secret ?? "",
+        sendThinkingMessage: config.sendThinkingMessage ?? true,
+        config,
+    };
+}
+/**
+ * 设置账户配置
+ */
+function setAccount(cfg, account) {
+    const existing = (cfg.channels?.[CHANNEL_ID] ?? {});
+    const merged = {
+        enabled: account.enabled ?? existing.enabled ?? true,
+        botId: account.botId ?? existing.botId ?? "",
+        secret: account.secret ?? existing.secret ?? "",
+        token: account.token ?? existing.token ?? "",
+        allowFrom: account.allowFrom ?? existing.allowFrom,
+        accessPolicy: account.accessPolicy ?? existing.accessPolicy,
+        sendThinkingMessage: account.sendThinkingMessage ?? existing.sendThinkingMessage,
+        ...(account.websocketUrl || existing.websocketUrl
+            ? { websocketUrl: account.websocketUrl ?? existing.websocketUrl }
+            : {}),
+        ...(account.name || existing.name
+            ? { name: account.name ?? existing.name }
+            : {}),
+    };
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            [CHANNEL_ID]: merged,
+        },
+    };
+}
+
+const channel = CHANNEL_ID;
+async function noteSetupHelp(prompter) {
+    await prompter.note([
+        "53AIHub 智能机器人需要以下配置信息：",
+        "1. Bot ID: 机器人标识",
+        "2. Secret: 机器人密钥",
+        "3. WebSocket URL: WebSocket 连接地址",
+    ].join("\n"), "53AIHub 设置");
+}
+async function promptBotId(prompter, account) {
+    return String(await prompter.text({
+        message: "53AIHub 机器人 Bot ID",
+        initialValue: account?.botId ?? "",
+        validate: (value) => (value?.trim() ? undefined : "必填"),
+    })).trim();
+}
+async function promptSecret(prompter, account) {
+    return String(await prompter.text({
+        message: "53AIHub 机器人 Secret",
+        initialValue: account?.secret ?? "",
+        validate: (value) => (value?.trim() ? undefined : "必填"),
+    })).trim();
+}
+async function promptWebsocketUrl(prompter, account) {
+    return String(await prompter.text({
+        message: "WebSocket URL (例如: ws://localhost:8080/ws)",
+        initialValue: account?.websocketUrl ?? "",
+        validate: (value) => {
+            const trimmed = value?.trim();
+            if (!trimmed)
+                return undefined;
+            if (!trimmed.startsWith("ws://") && !trimmed.startsWith("wss://")) {
+                return "URL 必须以 ws:// 或 wss:// 开头";
+            }
+            return undefined;
+        },
+    })).trim();
+}
+function setAccessPolicy(cfg, accessPolicy) {
+    const account = resolveAccount(cfg);
+    const existingAllowFrom = account.config.allowFrom ?? [];
+    const allowFrom = accessPolicy === "open"
+        ? addWildcardAllowFrom(existingAllowFrom.map((x) => String(x)))
+        : existingAllowFrom.map((x) => String(x));
+    return setAccount(cfg, {
+        accessPolicy,
+        allowFrom,
+    });
+}
+const dmPolicy = {
+    label: "53AIHub",
+    channel,
+    policyKey: `channels.${CHANNEL_ID}.accessPolicy`,
+    allowFromKey: `channels.${CHANNEL_ID}.allowFrom`,
+    getCurrent: (cfg) => {
+        const account = resolveAccount(cfg);
+        return account.config.accessPolicy ?? "open";
+    },
+    setPolicy: (cfg, policy) => {
+        return setAccessPolicy(cfg, policy);
+    },
+    promptAllowFrom: async ({ cfg, prompter }) => {
+        const account = resolveAccount(cfg);
+        const existingAllowFrom = account.config.allowFrom ?? [];
+        const entry = await prompter.text({
+            message: "允许使用的用户ID（每行一个）",
+            placeholder: "user123",
+            initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : undefined,
+        });
+        const allowFrom = String(entry ?? "")
+            .split(/[\n,;]+/g)
+            .map((s) => s.trim())
+            .filter(Boolean);
+        return setAccount(cfg, { allowFrom });
+    },
+};
+const aiHubOnboardingAdapter = {
+    channel,
+    getStatus: async ({ cfg }) => {
+        const account = resolveAccount(cfg);
+        const configured = Boolean(account.botId?.trim() &&
+            account.secret?.trim());
+        return {
+            channel,
+            configured,
+            statusLines: [`53AIHub: ${configured ? "已配置" : "需要 Bot ID 和 Secret"}`],
+            selectionHint: configured ? "已配置" : "需要设置",
+        };
+    },
+    configure: async ({ cfg, prompter, forceAllowFrom }) => {
+        const account = resolveAccount(cfg);
+        if (!account.botId?.trim() || !account.secret?.trim()) {
+            await noteSetupHelp(prompter);
+        }
+        const botId = await promptBotId(prompter, account);
+        const secret = await promptSecret(prompter, account);
+        const websocketUrl = await promptWebsocketUrl(prompter, account);
+        const cfgWithAccount = setAccount(cfg, {
+            botId,
+            secret,
+            websocketUrl: websocketUrl || undefined,
+            enabled: true,
+            accessPolicy: account.config.accessPolicy ?? "open",
+            allowFrom: account.config.allowFrom ?? [],
+            sendThinkingMessage: account.sendThinkingMessage ?? true,
+        });
+        return { cfg: cfgWithAccount };
+    },
+    dmPolicy,
+    disable: (cfg) => {
+        return setAccount(cfg, { enabled: false });
+    },
+};
+
+const meta = {
+    id: CHANNEL_ID,
+    label: "53AIHub",
+    selectionLabel: "53AIHub (AgentHub)",
+    detailLabel: "53AIHub 智能机器人",
+    docsPath: `/channels/${CHANNEL_ID}`,
+    docsLabel: CHANNEL_ID,
+    blurb: "53AIHub 智能机器人接入插件",
+    systemImage: "message.fill",
+};
+const aiHubPlugin = {
+    id: CHANNEL_ID,
+    meta: {
+        ...meta,
+        quickstartAllowFrom: true,
+    },
+    pairing: {
+        idLabel: "userId",
+        normalizeAllowEntry: (entry) => entry.replace(new RegExp(`^(${CHANNEL_ID}|user):`, "i"), "").trim(),
+        notifyApproval: async ({ cfg, id }) => {
+            console.log(`[53aihub] Pairing approved for user: ${id}`);
+        },
+    },
+    onboarding: aiHubOnboardingAdapter,
+    capabilities: {
+        chatTypes: ["direct"],
+        reactions: false,
+        threads: false,
+        media: true,
+        nativeCommands: false,
+        blockStreaming: true,
+    },
+    reload: { configPrefixes: [`channels.${CHANNEL_ID}`] },
+    config: {
+        listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+        resolveAccount: (cfg) => resolveAccount(cfg),
+        defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+        setAccountEnabled: ({ cfg, enabled }) => {
+            const config = (cfg.channels?.[CHANNEL_ID] ?? {});
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    [CHANNEL_ID]: { ...config, enabled },
+                },
+            };
+        },
+        deleteAccount: ({ cfg }) => {
+            const config = (cfg.channels?.[CHANNEL_ID] ?? {});
+            const { botId, secret, token, ...rest } = config;
+            return {
+                ...cfg,
+                channels: {
+                    ...cfg.channels,
+                    [CHANNEL_ID]: rest,
+                },
+            };
+        },
+        isConfigured: (account) => Boolean((account.botId?.trim() || account.token?.trim()) || account.secret?.trim()),
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: Boolean(account.botId?.trim() || account.token?.trim()),
+            botId: account.botId,
+            websocketUrl: account.websocketUrl,
+            accessPolicy: account.config.accessPolicy ?? "open",
+        }),
+        resolveAllowFrom: ({ cfg }) => {
+            const account = resolveAccount(cfg);
+            return (account.config.allowFrom ?? []).map((entry) => String(entry));
+        },
+        formatAllowFrom: ({ allowFrom }) => allowFrom.map((entry) => String(entry).trim()).filter(Boolean),
+    },
+    security: {
+        resolveDmPolicy: ({ account }) => {
+            const basePath = `channels.${CHANNEL_ID}.`;
+            const accessPolicy = account.config.accessPolicy ?? "open";
+            return {
+                policy: accessPolicy === "pairing" ? "pairing" : accessPolicy === "allowlist" ? "allowlist" : "open",
+                allowFrom: account.config.allowFrom ?? [],
+                policyPath: `${basePath}accessPolicy`,
+                allowFromPath: basePath,
+                approveHint: formatPairingApproveHint(CHANNEL_ID),
+                normalizeEntry: (raw) => raw.replace(new RegExp(`^${CHANNEL_ID}:`, "i"), "").trim(),
+            };
+        },
+        collectWarnings: ({ account }) => {
+            const warnings = [];
+            const accessPolicy = account.config.accessPolicy ?? "open";
+            if (accessPolicy === "open") {
+                warnings.push(`- 访问策略为 "open"，所有用户都可以使用机器人`);
+            }
+            return warnings;
+        },
+    },
+    messaging: {
+        normalizeTarget: (target) => {
+            const trimmed = target.trim();
+            if (!trimmed)
+                return undefined;
+            return trimmed;
+        },
+        targetResolver: {
+            looksLikeId: (id) => Boolean(id?.trim()),
+            hint: "<userId|chatId>",
+        },
+    },
+    directory: {
+        self: async () => null,
+        listPeers: async () => [],
+        listGroups: async () => [],
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: (text, limit) => getRuntime().channel.text.chunkMarkdownText(text, limit),
+        textChunkLimit: TEXT_CHUNK_LIMIT,
+        sendText: async ({ to, text, accountId, ...rest }) => {
+            const wsClient = getWebSocket(accountId ?? DEFAULT_ACCOUNT_ID);
+            if (!wsClient) {
+                throw new Error(`[53aihub] WS Client not connected for account ${accountId}`);
+            }
+            const channelPrefix = new RegExp(`^${CHANNEL_ID}:`, "i");
+            const targetId = to.replace(channelPrefix, "");
+            await sendDirectMessage(wsClient, targetId, text);
+            return {
+                channel: CHANNEL_ID,
+                messageId: `msg-${Date.now()}`,
+                chatId: targetId,
+            };
+        },
+        sendMedia: async ({ to, text, mediaUrl, accountId, ...rest }) => {
+            const wsClient = getWebSocket(accountId ?? DEFAULT_ACCOUNT_ID);
+            if (!wsClient) {
+                throw new Error(`[53aihub] WS Client not connected for account ${accountId}`);
+            }
+            const channelPrefix = new RegExp(`^${CHANNEL_ID}:`, "i");
+            const targetId = to.replace(channelPrefix, "");
+            const restAny = rest;
+            const mediaType = restAny.mediaType;
+            const isImage = mediaType?.startsWith("image/") ||
+                mediaUrl?.match(/\.(jpg|jpeg|png|gif|webp|heic|heif|avif)$/i);
+            const mediaCategory = isImage ? "image" : "file";
+            await sendMediaMessage(wsClient, targetId, {
+                type: mediaCategory,
+                url: mediaUrl,
+                mimeType: mediaType,
+            }, text);
+            return { channel: CHANNEL_ID, messageId: `msg-${Date.now()}`, chatId: targetId };
+        },
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+        },
+        collectStatusIssues: (accounts) => accounts.flatMap((entry) => {
+            const accountId = String(entry.accountId ?? DEFAULT_ACCOUNT_ID);
+            if (!entry.enabled)
+                return [];
+            const issues = [];
+            if (!entry.configured) {
+                issues.push({
+                    channel: CHANNEL_ID,
+                    accountId,
+                    kind: "config",
+                    message: "53AIHub 访问令牌未配置",
+                    fix: "Run: openclaw channels add 53aihub --token <your_token>",
+                });
+            }
+            return issues;
+        }),
+        buildChannelSummary: ({ snapshot }) => ({
+            configured: snapshot.configured ?? false,
+            running: snapshot.running ?? false,
+            lastStartAt: snapshot.lastStartAt ?? null,
+            lastStopAt: snapshot.lastStopAt ?? null,
+            lastError: snapshot.lastError ?? null,
+        }),
+        probeAccount: async () => ({ ok: true, status: 200 }),
+        buildAccountSnapshot: ({ account, runtime }) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: Boolean(account.botId?.trim() || account.token?.trim() || account.secret?.trim()),
+            running: runtime?.running ?? false,
+            lastStartAt: runtime?.lastStartAt ?? null,
+            lastStopAt: runtime?.lastStopAt ?? null,
+            lastError: runtime?.lastError ?? null,
+        }),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            return monitorProvider({
+                account: ctx.account,
+                config: ctx.cfg,
+                runtime: ctx.runtime,
+                abortSignal: ctx.abortSignal,
+            });
+        },
+        logoutAccount: async ({ cfg }) => {
+            const nextCfg = { ...cfg };
+            const config = (cfg.channels?.[CHANNEL_ID] ?? {});
+            const nextConfig = { ...config };
+            let cleared = false;
+            let changed = false;
+            if (nextConfig.botId || nextConfig.secret || nextConfig.token) {
+                delete nextConfig.botId;
+                delete nextConfig.secret;
+                delete nextConfig.token;
+                cleared = true;
+                changed = true;
+            }
+            if (changed) {
+                if (Object.keys(nextConfig).length > 0) {
+                    nextCfg.channels = { ...nextCfg.channels, [CHANNEL_ID]: nextConfig };
+                }
+                else {
+                    const nextChannels = { ...nextCfg.channels };
+                    delete nextChannels[CHANNEL_ID];
+                    nextCfg.channels = Object.keys(nextChannels).length > 0 ? nextChannels : undefined;
+                }
+                await getRuntime().config.writeConfigFile(nextCfg);
+            }
+            const resolved = resolveAccount(changed ? nextCfg : cfg);
+            const loggedOut = !resolved.botId && !resolved.secret && !resolved.config.token;
+            return { cleared, envToken: false, loggedOut };
+        },
+    },
+};
+
+const plugin = {
+    id: "53aihub-openclaw-plugin",
+    name: "53AIHub",
+    description: "53AIHub (AgentHub) OpenClaw 插件",
+    configSchema: emptyPluginConfigSchema(),
+    register(api) {
+        setRuntime(api.runtime);
+        api.registerChannel({ plugin: aiHubPlugin });
+    },
+};
+
+export { plugin as default };
+//# sourceMappingURL=index.esm.js.map