@53ai/53ai-openclaw 1.0.9 → 1.1.0

package/dist/index.esm.js

@@ -36,6 +36,12 @@ const WS_RECONNECT_BASE_DELAY_MS = 1000;
 const TEXT_CHUNK_LIMIT = 4000;
 /** 消息处理超时（毫秒） */
 const MESSAGE_PROCESS_TIMEOUT_MS = 120000;
+/**
+ * 消息缓存 TTL（毫秒）
+ * 设为 35 分钟，确保覆盖最大重连时间（约 28.5 分钟）+ 缓冲
+ * @see WS_MAX_RECONNECT_ATTEMPTS - 60 次，指数退避最大 30s
+ */
+const MESSAGE_CACHE_TTL_MS = 35 * 60 * 1000;
 // ============================================================================
 // 媒体处理配置
 // ============================================================================
@@ -314,8 +320,9 @@ async function sendReply(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;
+        const errorMsg = `WebSocket not connected (readyState=${wsClient.readyState}), cannot send message to ${toChatId}`;
+        runtime.error?.(`[53aihub] ${errorMsg}`);
+        throw new Error(`[53aihub] ${errorMsg}`);
     }
     if (isError) {
         runtime.error?.(`[53aihub] sendReply ERROR: reqId=${reqId}, code=${errorCode}, text=${text?.substring(0, 100)}`);
@@ -426,8 +433,9 @@ 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;
+        const errorMsg = `WebSocket not ready (state=${wsState})`;
+        runtime?.error?.(`[53aihub] sendThinkingMessage FAILED: ${errorMsg}`);
+        throw new Error(`[53aihub] ${errorMsg}`);
     }
     // 使用 OpenAI 兼容格式，确保 Go 后端能正确解析
     // 关键：req_id 必须使用原始消息的 msgId，这样 Go 后端才能关联请求和响应
@@ -662,7 +670,7 @@ async function warmupReqIdStore(accountId = "default", log) {
     const store = getOrCreateReqIdStore(accountId);
     return store.warmup((err) => log?.(`ReqId warmup error: ${String(err)}`));
 }
-async function cleanupAccount(accountId) {
+async function cleanupAccount(accountId, clearCache = false) {
     const wsClient = wsClientInstances.get(accountId);
     if (wsClient) {
         try {
@@ -676,6 +684,10 @@ async function cleanupAccount(accountId) {
     const store = reqIdStores.get(accountId);
     if (store)
         await store.flush();
+    if (clearCache) {
+        const { clearAccountCache } = await Promise.resolve().then(function () { return messageCache; });
+        clearAccountCache(accountId);
+    }
 }
 
 /**
@@ -783,41 +795,288 @@ async function downloadAndSaveFiles(params) {
     return mediaList;
 }
 
-// 消息队列处理器 - 确保消息按顺序处理，避免竞态条件
+const DEFAULT_CONFIG = {
+    maxEntries: 100,
+    ttlMs: MESSAGE_CACHE_TTL_MS,
+    maxRetries: 3,
+};
+/**
+ * 按 accountId 隔离的消息缓存管理器
+ */
+class MessageCache {
+    cache = new Map();
+    config;
+    accountId;
+    runtime;
+    constructor(accountId, config = {}, runtime) {
+        this.accountId = accountId;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.runtime = runtime;
+    }
+    /**
+     * 生成唯一缓存 key
+     */
+    generateCacheKey(reqId) {
+        return `${this.accountId}:${reqId}:${Date.now()}:${Math.random().toString(36).slice(2, 8)}`;
+    }
+    /**
+     * 添加消息到缓存，返回缓存 key
+     */
+    add(params) {
+        this.prune();
+        if (this.cache.size >= this.config.maxEntries) {
+            // 优先淘汰非终态消息（finish=false 且 isError=false），保留终态消息
+            const entries = [...this.cache.entries()];
+            // 先找最老的非终态消息
+            const oldestNonFinal = entries
+                .filter(([, entry]) => !entry.finish && !entry.isError)
+                .sort((a, b) => a[1].createdAt - b[1].createdAt)[0];
+            if (oldestNonFinal) {
+                this.cache.delete(oldestNonFinal[0]);
+                this.runtime?.log?.(`[53aihub] MessageCache: evicted oldest non-final entry ${oldestNonFinal[0]}`);
+            }
+            else {
+                // 所有消息都是终态，才淘汰最老的
+                const oldest = entries.sort((a, b) => a[1].createdAt - b[1].createdAt)[0];
+                if (oldest) {
+                    this.cache.delete(oldest[0]);
+                    this.runtime?.log?.(`[53aihub] MessageCache: evicted oldest final entry ${oldest[0]} (all entries are final)`);
+                }
+            }
+        }
+        const cacheKey = this.generateCacheKey(params.reqId);
+        this.cache.set(cacheKey, {
+            cacheKey,
+            ...params,
+            createdAt: Date.now(),
+            retryCount: 0,
+        });
+        this.runtime?.log?.(`[53aihub] MessageCache: cached message reqId=${params.reqId}, cacheKey=${cacheKey}, cacheSize=${this.cache.size}`);
+        return cacheKey;
+    }
+    /**
+     * 获取所有待重试的消息，返回 cacheKey + entry
+     */
+    getPendingMessages() {
+        const now = Date.now();
+        const pending = [];
+        for (const [key, entry] of this.cache) {
+            if (now - entry.createdAt > this.config.ttlMs) {
+                this.cache.delete(key);
+                continue;
+            }
+            if (entry.retryCount >= this.config.maxRetries) {
+                this.cache.delete(key);
+                this.runtime?.log?.(`[53aihub] MessageCache: dropped message after max retries cacheKey=${key}`);
+                continue;
+            }
+            pending.push(entry);
+        }
+        return pending;
+    }
+    /**
+     * 按 cacheKey 标记消息为已发送
+     */
+    markSent(cacheKey) {
+        if (this.cache.has(cacheKey)) {
+            this.cache.delete(cacheKey);
+            this.runtime?.log?.(`[53aihub] MessageCache: marked as sent cacheKey=${cacheKey}`);
+        }
+    }
+    /**
+     * 按 cacheKey 增加重试计数
+     */
+    incrementRetry(cacheKey) {
+        const entry = this.cache.get(cacheKey);
+        if (entry) {
+            entry.retryCount++;
+        }
+    }
+    /**
+     * 清理过期条目
+     */
+    prune() {
+        const now = Date.now();
+        let pruned = 0;
+        for (const [key, entry] of this.cache) {
+            if (now - entry.createdAt > this.config.ttlMs) {
+                this.cache.delete(key);
+                pruned++;
+            }
+        }
+        if (pruned > 0) {
+            this.runtime?.log?.(`[53aihub] MessageCache: pruned ${pruned} expired entries`);
+        }
+    }
+    size() {
+        return this.cache.size;
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+// 按 accountId 隔离的缓存实例
+const cacheInstances = new Map();
+/**
+ * 获取或创建按账号隔离的缓存实例
+ */
+function getMessageCache(accountId, runtime) {
+    let cache = cacheInstances.get(accountId);
+    if (!cache) {
+        cache = new MessageCache(accountId, {}, runtime);
+        cacheInstances.set(accountId, cache);
+    }
+    return cache;
+}
+/**
+ * 清理指定账号的缓存
+ */
+function clearAccountCache(accountId) {
+    const cache = cacheInstances.get(accountId);
+    if (cache) {
+        cache.clear();
+        cacheInstances.delete(accountId);
+    }
+}
+/**
+ * 缓存感知的消息发送器
+ * 返回 [success, cacheKey?] - 成功时 cacheKey 为 undefined，失败时返回缓存 key
+ */
+async function sendWithCache(accountId, params, sendFn) {
+    const { wsClient, replyToMsgId, streamId, text, toChatId, finish, isError, errorCode, errorDetails, isThinking, runtime } = params;
+    const reqId = replyToMsgId || streamId;
+    if (wsClient.readyState !== 1) {
+        const cache = getMessageCache(accountId, runtime);
+        const cacheKey = cache.add({
+            reqId,
+            toChatId,
+            text,
+            finish,
+            isError,
+            errorCode,
+            errorDetails,
+            isThinking,
+        });
+        runtime.error?.(`[53aihub] sendWithCache: WebSocket not ready, cached message cacheKey=${cacheKey}`);
+        return { success: false, cacheKey };
+    }
+    try {
+        await sendFn(params);
+        return { success: true };
+    }
+    catch (err) {
+        const cache = getMessageCache(accountId, runtime);
+        const cacheKey = cache.add({
+            reqId,
+            toChatId,
+            text,
+            finish,
+            isError,
+            errorCode,
+            errorDetails,
+            isThinking,
+        });
+        runtime.error?.(`[53aihub] sendWithCache: send failed, cached message cacheKey=${cacheKey}, error=${String(err)}`);
+        return { success: false, cacheKey };
+    }
+}
+/**
+ * 重放缓存的消息
+ */
+async function replayCachedMessages(accountId, wsClient, runtime, sendFn) {
+    const cache = getMessageCache(accountId, runtime);
+    const pending = cache.getPendingMessages();
+    if (pending.length === 0) {
+        return 0;
+    }
+    runtime.log?.(`[53aihub] replayCachedMessages: replaying ${pending.length} cached messages for account=${accountId}`);
+    let successCount = 0;
+    for (const entry of pending) {
+        if (wsClient.readyState !== 1) {
+            runtime.error?.(`[53aihub] replayCachedMessages: WebSocket not ready, stopping replay`);
+            break;
+        }
+        try {
+            await sendFn({
+                wsClient,
+                text: entry.text,
+                toChatId: entry.toChatId,
+                replyToMsgId: entry.reqId,
+                runtime,
+                finish: entry.finish,
+                streamId: entry.reqId,
+                isError: entry.isError,
+                errorCode: entry.errorCode,
+                errorDetails: entry.errorDetails,
+                isThinking: entry.isThinking,
+            });
+            cache.markSent(entry.cacheKey);
+            successCount++;
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        catch (err) {
+            const newRetryCount = entry.retryCount + 1;
+            cache.incrementRetry(entry.cacheKey);
+            runtime.error?.(`[53aihub] replayCachedMessages: failed to send cacheKey=${entry.cacheKey}, retryCount=${newRetryCount}`);
+        }
+    }
+    runtime.log?.(`[53aihub] replayCachedMessages: completed, ${successCount}/${pending.length} sent`);
+    return successCount;
+}
+
+var messageCache = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    clearAccountCache: clearAccountCache,
+    getMessageCache: getMessageCache,
+    replayCachedMessages: replayCachedMessages,
+    sendWithCache: sendWithCache
+});
+
+// 按 chatId 分队列的消息处理器 - 同一会话串行，不同会话并行
 class MessageQueue {
-    queue = [];
-    processing = false;
+    queues = new Map();
+    processing = new Map();
     runtime;
     constructor(runtime) {
         this.runtime = runtime;
     }
-    enqueue(task) {
-        this.queue.push(task);
-        this.process();
+    enqueue(chatId, task) {
+        if (!this.queues.has(chatId)) {
+            this.queues.set(chatId, []);
+            this.processing.set(chatId, false);
+        }
+        this.queues.get(chatId).push(task);
+        this.process(chatId);
     }
-    async process() {
-        if (this.processing || this.queue.length === 0)
+    async process(chatId) {
+        const queue = this.queues.get(chatId);
+        const isProcessing = this.processing.get(chatId);
+        if (!queue || isProcessing || queue.length === 0)
             return;
-        this.processing = true;
+        this.processing.set(chatId, true);
         try {
-            const task = this.queue.shift();
+            const task = queue.shift();
             if (task) {
                 await task();
             }
         }
         catch (err) {
-            this.runtime.error?.(`[53aihub] MessageQueue error: ${String(err)}`);
+            this.runtime.error?.(`[53aihub] MessageQueue error (chatId=${chatId}): ${String(err)}`);
         }
         finally {
-            this.processing = false;
-            // 继续处理队列中的下一条消息
-            if (this.queue.length > 0) {
-                this.process();
+            this.processing.set(chatId, false);
+            if (queue.length > 0) {
+                this.process(chatId);
+            }
+            else {
+                this.queues.delete(chatId);
+                this.processing.delete(chatId);
             }
         }
     }
     clear() {
-        this.queue = [];
+        this.queues.clear();
+        this.processing.clear();
     }
 }
 function buildMessageContext(body, account, config, mediaList) {
@@ -882,20 +1141,26 @@ async function processMessage(params) {
     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()}`;
+    // 缓存感知的消息发送器 - 必须在所有 sendReply 调用前定义
+    const cachedSend = async (sendParams) => {
+        await sendWithCache(account.accountId, {
+            ...sendParams,
+            wsClient,
+            runtime,
+        }, sendReply);
+    };
     const accessResult = await checkAccessPolicy({
         userId: body.userId,
         account,
         runtime,
     });
     if (!accessResult.allowed) {
-        await sendReply({
-            wsClient,
+        await cachedSend({
             text: accessResult.reason === "Pairing required"
                 ? "您尚未获得授权使用此机器人，请联系管理员进行审核。"
                 : `⚠️ 访问被拒绝: ${accessResult.reason || "未知原因"}`,
             toChatId: chatId,
             replyToMsgId: body.msgId,
-            runtime,
             finish: true,
             streamId,
             isError: true,
@@ -954,12 +1219,10 @@ async function processMessage(params) {
                         const errorMsg = payload.text || "Unknown error";
                         const errorCode = inferErrorCode(errorMsg);
                         runtime.error?.(`[53aihub] deliver ERROR: ${errorMsg}`);
-                        await sendReply({
-                            wsClient,
+                        await cachedSend({
                             text: `⚠️ ${errorMsg}`,
                             toChatId: chatId,
                             replyToMsgId: body.msgId,
-                            runtime,
                             finish: true,
                             streamId: state.streamId,
                             isError: true,
@@ -972,12 +1235,10 @@ async function processMessage(params) {
                         state.accumulatedText.startsWith("🧹 Compacting context");
                     if (isCompaction && info.kind !== "final") {
                         runtime.log?.(`[53aihub] deliver COMPACTION: text preview=${payload.text?.substring(0, 50)}...`);
-                        await sendReply({
-                            wsClient,
+                        await cachedSend({
                             text: payload.text || "",
                             toChatId: chatId,
                             replyToMsgId: body.msgId,
-                            runtime,
                             finish: false,
                             streamId: state.streamId,
                             isThinking: true,
@@ -987,12 +1248,10 @@ async function processMessage(params) {
                     state.accumulatedText += payload.text;
                     if (info.kind !== "final") {
                         runtime.log?.(`[53aihub] deliver STREAMING: accumulatedText preview=${state.accumulatedText.substring(0, 50)}...`);
-                        await sendReply({
-                            wsClient,
+                        await cachedSend({
                             text: state.accumulatedText,
                             toChatId: chatId,
                             replyToMsgId: body.msgId,
-                            runtime,
                             finish: false,
                             streamId: state.streamId,
                         });
@@ -1002,47 +1261,36 @@ async function processMessage(params) {
                     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)}`);
-                    }
+                    await cachedSend({
+                        text: `⚠️ 系统错误: ${errorText}`,
+                        toChatId: chatId,
+                        replyToMsgId: body.msgId,
+                        finish: true,
+                        streamId: state.streamId,
+                        isError: true,
+                        errorCode,
+                        errorDetails: `kind=${info.kind}, error=${errorText}`,
+                    });
                 },
             },
         }), 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,
+            await cachedSend({
                 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,
+            await cachedSend({
                 text: "",
                 toChatId: chatId,
                 replyToMsgId: body.msgId,
-                runtime,
                 finish: true,
                 streamId: state.streamId,
             });
@@ -1055,12 +1303,10 @@ async function processMessage(params) {
         const errorCode = inferErrorCode(errorText);
         if (!cleanedUp) {
             try {
-                await sendReply({
-                    wsClient,
+                await cachedSend({
                     text: `⚠️ 处理请求时发生异常: ${errorText}`,
                     toChatId: chatId,
                     replyToMsgId: body.msgId,
-                    runtime,
                     finish: true,
                     streamId: state.streamId,
                     isError: true,
@@ -1085,17 +1331,6 @@ async function monitorProvider(options) {
         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;
@@ -1120,9 +1355,18 @@ async function monitorProvider(options) {
             setWebSocket(account.accountId, wsClient);
             // 初始化消息队列
             messageQueue = new MessageQueue(runtime);
-            wsClient.on("open", () => {
+            wsClient.on("open", async () => {
                 runtime.log?.(`[${account.accountId}] WebSocket connected successfully`);
                 reconnectAttempts = 0;
+                try {
+                    const replayedCount = await replayCachedMessages(account.accountId, wsClient, runtime, sendReply);
+                    if (replayedCount > 0) {
+                        runtime.log?.(`[${account.accountId}] Replayed ${replayedCount} cached messages`);
+                    }
+                }
+                catch (err) {
+                    runtime.error?.(`[${account.accountId}] Failed to replay cached messages: ${String(err)}`);
+                }
                 pingInterval = setInterval(() => {
                     if (wsClient?.readyState === WebSocket.OPEN) {
                         wsClient.ping();
@@ -1132,8 +1376,20 @@ async function monitorProvider(options) {
             wsClient.on("message", (data) => {
                 const rawPayload = data.toString();
                 runtime.log?.(`[${account.accountId}] Received WS message: ${rawPayload.substring(0, 200)}...`);
-                // 使用消息队列确保顺序处理，避免竞态条件
-                messageQueue?.enqueue(async () => {
+                let chatId = "unknown";
+                try {
+                    const msg = JSON.parse(rawPayload);
+                    if (msg.action === "chat") {
+                        chatId = msg.data?.conversation_id || msg.data?.user || "unknown";
+                    }
+                    else {
+                        chatId = msg.data?.chatId || msg.data?.userId || "unknown";
+                    }
+                }
+                catch {
+                    chatId = "unknown";
+                }
+                messageQueue?.enqueue(chatId, async () => {
                     await processMessage({
                         rawPayload,
                         account,
@@ -1164,8 +1420,8 @@ async function monitorProvider(options) {
                     setTimeout(connect, backoff);
                 }
                 else if (!isAborted) {
-                    runtime.error?.(`[${account.accountId}] Max reconnect attempts (${WS_MAX_RECONNECT_ATTEMPTS}) reached`);
-                    await cleanup();
+                    runtime.error?.(`[${account.accountId}] Max reconnect attempts (${WS_MAX_RECONNECT_ATTEMPTS}) reached, preserving cache for external recovery`);
+                    await cleanupAccount(account.accountId, false);
                     reject(new Error(`Max reconnect attempts (${WS_MAX_RECONNECT_ATTEMPTS}) reached`));
                 }
             });
@@ -1173,15 +1429,23 @@ async function monitorProvider(options) {
         if (abortSignal) {
             abortSignal.addEventListener("abort", async () => {
                 isAborted = true;
-                await cleanup();
+                if (pingInterval) {
+                    clearInterval(pingInterval);
+                    pingInterval = null;
+                }
+                if (messageQueue) {
+                    messageQueue.clear();
+                    messageQueue = null;
+                }
+                await cleanupAccount(account.accountId, true);
                 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();
+            runtime.error?.(`[${account.accountId}] Failed to warmup ReqId store: ${String(err)}, preserving cache for retry`);
+            await cleanupAccount(account.accountId, false);
             reject(err);
         });
     });