@wu529778790/open-im 1.8.1-beta.9 → 1.8.2

package/dist/telegram/event-handler.js

@@ -110,7 +110,9 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             try {
                 await sendTextReply(chatId, "启动 AI 处理失败，请重试。");
             }
-            catch { /* ignore */ }
+            catch (err) {
+                log.warn('Failed to send startup error reply:', err);
+            }
             return;
         }
         const stopTyping = startTypingLoop(chatId);
@@ -180,7 +182,8 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     throttle.recordSuccess();
                     lastUpdateTime = Date.now();
                 }
-                catch {
+                catch (err) {
+                    log.debug('Stream update failed:', err);
                     throttle.recordError();
                 }
                 finally {
@@ -194,7 +197,7 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     }
                 }
             };
-            return (content, toolNote) => {
+            const wrapper = (content, toolNote) => {
                 if (content.startsWith("💭 **思考中...**")) {
                     return;
                 }
@@ -215,6 +218,17 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
                     performUpdate(content, toolNote);
                 }, Math.max(DEBOUNCE_MS, baseDelay));
             };
+            // flush 排队的 debounce 更新，防止 sendComplete 时仍有 streaming 更新在排队
+            wrapper.flush = async () => {
+                if (debounceTimer) {
+                    clearTimeout(debounceTimer);
+                    debounceTimer = null;
+                }
+                while (updateInProgress) {
+                    await new Promise((resolve) => setTimeout(resolve, 50));
+                }
+            };
+            return wrapper;
         };
         const streamUpdateWrapper = createStreamUpdateWrapper();
         await runAITask({ config, sessionManager }, {
@@ -232,12 +246,30 @@ export function setupTelegramHandlers(bot, config, sessionManager) {
             },
             sendComplete: async (content, note) => {
                 throttle.reset();
-                try {
-                    await sendFinalMessages(chatId, msgId, content, note, toolId);
-                }
-                catch (err) {
-                    log.error("Failed to send complete message:", err);
-                    await updateMessage(chatId, msgId, content, "done", note, toolId);
+                // 先 flush 排队的 streaming 更新，防止它覆盖后续的 done 消息
+                await streamUpdateWrapper.flush?.();
+                const maxAttempts = 3;
+                for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                    try {
+                        await sendFinalMessages(chatId, msgId, content, note, toolId);
+                        return;
+                    }
+                    catch (err) {
+                        log.error(`Failed to send complete message (attempt ${attempt}/${maxAttempts}):`, err);
+                        if (attempt < maxAttempts) {
+                            await new Promise((r) => setTimeout(r, 2000 * attempt));
+                        }
+                        else {
+                            // 最终失败：尝试发送纯文本作为最后手段
+                            try {
+                                await sendTextReply(chatId, `⚠️ 消息更新失败（网络异常），以下是 AI 回复：\n\n${content.slice(0, 4000)}`);
+                            }
+                            catch (fallbackErr) {
+                                log.error("All send attempts failed:", fallbackErr);
+                                throw err;
+                            }
+                        }
+                    }
                 }
             },
             sendError: async (error) => {

package/dist/telegram/message-sender.js

@@ -9,6 +9,15 @@ import { MAX_TELEGRAM_MESSAGE_LENGTH } from "../constants.js";
 import { listDirectories, buildDirectoryKeyboard, } from "../commands/handler.js";
 const log = createLogger("TgSender");
 const lastSentByMsg = new Map();
+// Periodic cleanup of orphaned entries (entries not cleaned by done/error)
+const LAST_SENT_MAX_AGE_MS = 30 * 60 * 1000; // 30 minutes
+setInterval(() => {
+    // lastSentByMsg doesn't store timestamps, so clear all entries periodically
+    // since they are just dedup cache entries, clearing is safe
+    if (lastSentByMsg.size > 0) {
+        lastSentByMsg.clear();
+    }
+}, LAST_SENT_MAX_AGE_MS);
 const STATUS_ICONS = {
     thinking: "🔵",
     streaming: "🔵",
@@ -85,6 +94,10 @@ export async function updateMessage(chatId, messageId, content, status, note, to
         }
         else {
             log.error("Failed to update message:", err);
+            // 对 done/error 状态的更新失败必须 throw，否则消息永远卡在 streaming
+            if (status === "done" || status === "error") {
+                throw err;
+            }
         }
     }
     if (status === "done" || status === "error") {

package/dist/wechat/auth/qclaw-api.js

@@ -14,7 +14,7 @@ function nested(obj, ...keys) {
 export class QClawAPI {
     env;
     guid;
-    loginKey = 'm83qdao0AmE5';
+    loginKey = process.env.QCLAW_LOGIN_KEY || 'm83qdao0AmE5';
     jwtToken = '';
     userId = '';
     constructor(env, guid, jwtToken = '') {

package/dist/wechat/client.js

@@ -8,6 +8,7 @@ import { createLogger } from '../logger.js';
 const log = createLogger('WeChat');
 const TOKEN_FILE = 'wechat-token.json';
 const DEFAULT_WECHAT_WS_URL = 'wss://openclau-wechat.henryxiaoyang.workers.dev';
+const PONG_TIMEOUT_FACTOR = 3; // 3倍心跳间隔无响应则判定连接死亡
 // Global state
 let ws = null;
 let channelState = 'disconnected';
@@ -16,6 +17,9 @@ let heartbeatTimer = null;
 let reconnectAttempts = 0;
 let currentToken = null;
 let tokenStoragePath = null;
+let lastServerResponseTime = 0; // 上次收到服务端消息的时间
+let wsConfigRef = null; // 保存配置供心跳重连使用
+let isStopping = false; // 防止 stop 后重连定时器继续触发
 // Event handlers
 let messageHandler = null;
 let stateChangeHandler = null;
@@ -70,6 +74,7 @@ export async function initWeChat(config, eventHandler, onStateChange) {
     }
     messageHandler = eventHandler;
     stateChangeHandler = onStateChange ?? null;
+    isStopping = false;
     // Set up token storage path
     const baseDir = config.logDir ?? join(process.env.HOME ?? '', '.open-im');
     tokenStoragePath = join(baseDir, 'data');
@@ -92,15 +97,35 @@ export async function initWeChat(config, eventHandler, onStateChange) {
  * Connect to AGP WebSocket server
  */
 async function connectWebSocket(config) {
+    wsConfigRef = config;
     if (channelState === 'connecting') {
         log.warn('WebSocket connection already in progress');
         return;
     }
     updateState('connecting');
     return new Promise((resolve, reject) => {
+        let settled = false;
+        // Connection timeout to prevent promise from hanging forever
+        const connectionTimeout = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            const err = new Error('WeChat WebSocket connection timeout');
+            log.error(err.message);
+            updateState('error');
+            try {
+                ws?.close();
+            }
+            catch { /* ignore */ }
+            reject(err);
+        }, 30000);
         try {
             ws = new WebSocket(config.url);
             ws.on('open', () => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(connectionTimeout);
                 log.info('WeChat WebSocket connected');
                 reconnectAttempts = 0;
                 updateState('connected');
@@ -108,6 +133,7 @@ async function connectWebSocket(config) {
                 resolve();
             });
             ws.on('message', async (data) => {
+                lastServerResponseTime = Date.now();
                 try {
                     const envelope = JSON.parse(data.toString());
                     log.debug('Received AGP message:', envelope.method);
@@ -118,18 +144,33 @@ async function connectWebSocket(config) {
                 }
             });
             ws.on('error', (err) => {
+                if (settled) {
+                    // Late error after connection was established — just log it
+                    log.error('WeChat WebSocket error (after open):', err);
+                    return;
+                }
+                settled = true;
+                clearTimeout(connectionTimeout);
                 log.error('WeChat WebSocket error:', err);
                 updateState('error');
                 reject(err);
             });
             ws.on('close', () => {
+                clearTimeout(connectionTimeout);
                 log.info('WeChat WebSocket closed');
                 stopHeartbeat();
                 updateState('disconnected');
+                if (!settled) {
+                    settled = true;
+                    reject(new Error('WeChat WebSocket closed before open'));
+                    return;
+                }
                 scheduleReconnect(config);
             });
         }
         catch (err) {
+            settled = true;
+            clearTimeout(connectionTimeout);
             log.error('Error creating WebSocket connection:', err);
             updateState('error');
             reject(err);
@@ -190,11 +231,35 @@ function updateState(state) {
 }
 /**
  * Start heartbeat to keep connection alive
+ * 同时检测服务端是否响应，超时无响应则主动断开触发重连
  */
 function startHeartbeat(interval) {
     stopHeartbeat();
+    lastServerResponseTime = Date.now();
     heartbeatTimer = setInterval(() => {
         if (channelState === 'connected') {
+            // 检测连接是否已死：长时间未收到任何服务端响应
+            const elapsed = Date.now() - lastServerResponseTime;
+            const pongTimeout = interval * PONG_TIMEOUT_FACTOR;
+            if (lastServerResponseTime > 0 && elapsed > pongTimeout) {
+                log.warn(`No server response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
+                stopHeartbeat();
+                if (ws) {
+                    try {
+                        ws.removeAllListeners();
+                        ws.close();
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                    ws = null;
+                }
+                updateState('disconnected');
+                if (wsConfigRef) {
+                    scheduleReconnect(wsConfigRef);
+                }
+                return;
+            }
             sendAGPMessage('ping', { timestamp: Date.now() });
         }
     }, interval);
@@ -210,17 +275,28 @@ function stopHeartbeat() {
 }
 /**
  * Schedule reconnection attempt
+ * 超过 maxAttempts 后自动重置计数器继续重试，避免永久断连
  */
 function scheduleReconnect(config) {
+    if (isStopping)
+        return;
     const maxAttempts = config.maxReconnectAttempts ?? 10;
-    if (reconnectAttempts >= maxAttempts) {
-        log.error('Max reconnect attempts reached');
+    if (reconnectTimer) {
         return;
     }
-    const interval = config.reconnectInterval ?? 5000;
+    // 超过最大重试次数后重置计数器，降低频率继续重试
+    if (reconnectAttempts >= maxAttempts) {
+        log.warn(`Max reconnect attempts (${maxAttempts}) reached, resetting counter and retrying at lower frequency`);
+        reconnectAttempts = 0;
+    }
+    const baseInterval = config.reconnectInterval ?? 5000;
+    // 超过一半次数后逐渐增加间隔，最大 60 秒
+    const backoff = Math.min(baseInterval * Math.pow(1.5, Math.floor(reconnectAttempts / 3)), 60000);
+    const interval = Math.round(backoff);
     reconnectTimer = setTimeout(async () => {
+        reconnectTimer = null;
         reconnectAttempts++;
-        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${maxAttempts}`);
+        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${maxAttempts} (interval: ${interval}ms)`);
         try {
             await connectWebSocket(config);
         }
@@ -274,6 +350,7 @@ function saveToken() {
  * Stop WeChat client
  */
 export function stopWeChat() {
+    isStopping = true;
     stopHeartbeat();
     if (reconnectTimer) {
         clearTimeout(reconnectTimer);

package/dist/wechat/event-handler.js

@@ -53,7 +53,8 @@ export function setupWeChatHandlers(config, sessionManager) {
             }
             return parsed;
         }
-        catch {
+        catch (err) {
+            log.debug('Failed to parse WeChat incoming message JSON:', err);
             return null;
         }
     }
@@ -90,8 +91,8 @@ export function setupWeChatHandlers(config, sessionManager) {
                     text: contextText,
                 });
             }
-            catch {
-                // Fall through to metadata-only prompt.
+            catch (err) {
+                log.warn('Failed to download WeChat media, falling back to metadata-only prompt:', err);
             }
         }
         return buildMediaMetadataPrompt({
@@ -133,7 +134,9 @@ export function setupWeChatHandlers(config, sessionManager) {
             try {
                 await sendTextReply(chatId, '启动 AI 处理失败，请重试。');
             }
-            catch { /* ignore */ }
+            catch (err) {
+                log.warn('Failed to send startup error reply:', err);
+            }
             return;
         }
         const stopTyping = startTypingLoop(chatId);

package/dist/wework/client.js

@@ -13,6 +13,7 @@ import { createLogger } from '../logger.js';
 const log = createLogger('WeWork');
 const DEFAULT_WS_URL = 'wss://openws.work.weixin.qq.com';
 const HEARTBEAT_INTERVAL = 30000; // 30秒
+const PONG_TIMEOUT = HEARTBEAT_INTERVAL * 3; // 90秒无任何服务端响应则判定连接死亡
 const MAX_RECONNECT_ATTEMPTS = 100;
 // Global state
 let ws = null;
@@ -22,6 +23,7 @@ let heartbeatTimer = null;
 let reconnectAttempts = 0;
 let shouldReconnect = false;
 let isStopping = false;
+let lastServerResponseTime = 0; // 上次收到服务端消息的时间
 // Event handlers
 let messageHandler = null;
 let stateChangeHandler = null;
@@ -173,6 +175,7 @@ async function connectWebSocket() {
                 }
             });
             ws.on('message', async (data) => {
+                lastServerResponseTime = Date.now();
                 try {
                     const message = JSON.parse(data.toString());
                     await handleMessage(message);
@@ -326,11 +329,30 @@ function updateState(state) {
 }
 /**
  * Start heartbeat to keep connection alive
+ * 同时检测服务端是否响应，超时无响应则主动断开触发重连
  */
 function startHeartbeat() {
     stopHeartbeat();
+    lastServerResponseTime = Date.now();
     heartbeatTimer = setInterval(() => {
         if (connectionState === 'connected' && ws) {
+            // 检测连接是否已死：长时间未收到任何服务端响应
+            const elapsed = Date.now() - lastServerResponseTime;
+            if (lastServerResponseTime > 0 && elapsed > PONG_TIMEOUT) {
+                log.warn(`No server response for ${Math.round(elapsed / 1000)}s, forcing reconnect`);
+                stopHeartbeat();
+                try {
+                    ws.removeAllListeners();
+                    ws.close();
+                }
+                catch {
+                    /* ignore */
+                }
+                ws = null;
+                updateState('disconnected');
+                scheduleReconnect();
+                return;
+            }
             const pingMessage = {
                 cmd: "ping" /* WeWorkCommand.PING */,
                 headers: {
@@ -359,23 +381,27 @@ function stopHeartbeat() {
 }
 /**
  * Schedule reconnection attempt
+ * 超过 MAX_RECONNECT_ATTEMPTS 后自动重置计数器继续重试，避免永久断连
  */
 function scheduleReconnect() {
     if (isStopping || !shouldReconnect) {
         return;
     }
-    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-        log.error('Max reconnect attempts reached');
-        return;
-    }
-    const interval = 5000; // 5秒后重连
     if (reconnectTimer) {
         return;
     }
+    // 超过最大重试次数后重置计数器，降低频率继续重试
+    if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+        log.warn(`Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached, resetting counter and retrying at lower frequency`);
+        reconnectAttempts = 0;
+    }
+    // 逐步增加间隔，5s → 7.5s → 11s → ... 最大 60s
+    const backoff = Math.min(5000 * Math.pow(1.5, Math.floor(reconnectAttempts / 5)), 60000);
+    const interval = Math.round(backoff);
     reconnectTimer = setTimeout(async () => {
         reconnectTimer = null;
         reconnectAttempts++;
-        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}`);
+        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS} (interval: ${interval}ms)`);
         try {
             await connectWebSocket();
         }

package/dist/wework/event-handler.js

@@ -21,6 +21,8 @@ import { buildMediaContext } from '../shared/media-context.js';
 import { buildErrorNote, buildProgressNote } from '../shared/message-note.js';
 const log = createLogger('WeWorkHandler');
 const WEWORK_MEDIA_TIMEOUT_MS = 60_000;
+// Safety timeout: abort hung tasks before stream expires (5 min TTL → 4.5 min safety)
+const WEWORK_TASK_SAFETY_TIMEOUT_MS = 4.5 * 60 * 1000;
 async function saveWeWorkUrlMedia(payload, fallbackExtension) {
     if (!payload.url) {
         throw new Error("Missing WeWork media URL");
@@ -119,7 +121,8 @@ export async function buildMediaPrompt(data, kind) {
                     text: contextText,
                 });
             }
-            catch {
+            catch (err) {
+                log.warn('Failed to download WeWork image, falling back to URL reference:', err);
                 imageReference = `Remote image URL: ${imagePayload.url}`;
             }
         }
@@ -144,8 +147,8 @@ export async function buildMediaPrompt(data, kind) {
                 text: contextText,
             });
         }
-        catch {
-            // Fall back to metadata-only prompt.
+        catch (err) {
+            log.warn('Failed to download WeWork media, falling back to metadata-only prompt:', err);
         }
     }
     return buildMediaMetadataPrompt({
@@ -194,11 +197,31 @@ export function setupWeWorkHandlers(config, sessionManager) {
                 try {
                     await sendTextReply(chatId, '启动 AI 处理失败，请重试。', reqId);
                 }
-                catch { /* ignore */ }
+                catch (err) {
+                    log.warn('Failed to send startup error reply:', err);
+                }
                 return;
             }
             const stopTyping = startTypingLoop(chatId);
             const taskKey = `${userId}:${msgId}`;
+            // Safety timeout: abort hung tasks before stream expires, unblocking the queue
+            let safetyTimer = setTimeout(() => {
+                safetyTimer = null;
+                const state = runningTasks.get(taskKey);
+                if (state) {
+                    log.warn(`[SAFETY_TIMEOUT] Task ${taskKey} exceeded ${WEWORK_TASK_SAFETY_TIMEOUT_MS}ms, aborting`);
+                    state.handle.abort();
+                    runningTasks.delete(taskKey);
+                    stopTyping();
+                    sendTextReply(chatId, `AI 处理超时（${Math.round(WEWORK_TASK_SAFETY_TIMEOUT_MS / 1000)}s），已自动取消。请重试。`, reqId).catch(() => { });
+                }
+            }, WEWORK_TASK_SAFETY_TIMEOUT_MS);
+            const clearSafetyTimer = () => {
+                if (safetyTimer) {
+                    clearTimeout(safetyTimer);
+                    safetyTimer = null;
+                }
+            };
             await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'wework', taskKey }, prompt, toolAdapter, {
                 throttleMs: WEWORK_THROTTLE_MS,
                 streamUpdate: async (content, toolNote) => {
@@ -217,6 +240,7 @@ export function setupWeWorkHandlers(config, sessionManager) {
                     await updateMessage(chatId, msgId, `Error: ${error}`, 'error', buildErrorNote(), toolId, reqId);
                 },
                 extraCleanup: () => {
+                    clearSafetyTimer();
                     stopTyping();
                     runningTasks.delete(taskKey);
                 },

package/dist/wework/message-sender.js

@@ -101,6 +101,18 @@ function formatWeWorkMessage(title, content, status, note) {
     return message;
 }
 const streamStates = new Map();
+// Periodic cleanup of expired/orphaned stream states
+const STREAM_CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, state] of streamStates) {
+        if (now - state.createdAt >= STREAM_SAFE_TTL_MS) {
+            state.closed = true;
+            streamStates.delete(id);
+            log.info(`Cleaned up expired stream state: ${id}`);
+        }
+    }
+}, STREAM_CLEANUP_INTERVAL_MS);
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -187,6 +199,12 @@ export async function updateMessage(chatId, streamId, content, status, note, too
             return;
         if (Date.now() - state.createdAt >= STREAM_SAFE_TTL_MS) {
             markExpired(state, streamId);
+            // Stream expired - fall back to text delivery for errors and final states
+            if (status === 'error' || status === 'done') {
+                const reqIdUsed = getReqId(reqId);
+                sendText(reqIdUsed, message);
+                log.info(`Stream expired, sent ${status} via text fallback: streamId=${streamId}`);
+            }
             return;
         }
         state.pendingUpdate = { message, status, reqId };
@@ -207,17 +225,24 @@ export async function sendFinalMessages(chatId, streamId, fullContent, note, too
     const title = getToolTitle(toolId, 'done');
     const parts = splitLongContent(contentToSend, MAX_WEWORK_MESSAGE_LENGTH);
     const finalMessage = formatWeWorkMessage(title, parts[0], 'done', parts.length > 1 ? `内容较长，已分段发送 (1/${parts.length})` : note);
-    try {
-        const state = streamStates.get(streamId);
-        const shouldFallbackToText = !!state && (state.expired || Date.now() - state.createdAt >= STREAM_SAFE_TTL_MS);
-        if (!shouldFallbackToText && state && contentToSend.length > 0) {
-            // 先发一条「输出中」带正文，再发 finish 的最终条，避免企微端一直停在「思考中」不刷新
+    const state = streamStates.get(streamId);
+    const shouldFallbackToText = !!state && (state.expired || Date.now() - state.createdAt >= STREAM_SAFE_TTL_MS);
+    // 先发一条「输出中」带正文，再发 finish 的最终条，避免企微端一直停在「思考中」不刷新
+    // 独立 try-catch：即使此步失败，仍须发送 finish=true，否则企微永远卡在「正在思考」
+    if (!shouldFallbackToText && state && contentToSend.length > 0) {
+        try {
             await updateMessage(chatId, streamId, contentToSend, 'streaming', note, toolId, reqId);
         }
-        if (state) {
-            state.closed = true;
-            state.pendingUpdate = undefined;
+        catch (err) {
+            log.warn('Pre-finish streaming update failed, will still send finish=true:', err);
         }
+    }
+    if (state) {
+        state.closed = true;
+        state.pendingUpdate = undefined;
+    }
+    // finish=true 是关键：必须保证发出，否则企微 UI 永远停留在「正在思考」
+    try {
         if (!shouldFallbackToText) {
             if (state) {
                 const elapsed = Date.now() - state.lastSentAt;
@@ -232,21 +257,28 @@ export async function sendFinalMessages(chatId, streamId, fullContent, note, too
             sendText(getReqId(reqId), finalMessage);
             log.info(`Final stream expired, sent text fallback instead: streamId=${streamId}`);
         }
-        streamStates.delete(streamId);
-        for (let i = 1; i < parts.length; i++) {
-            try {
-                const partContent = `${parts[i]}\n\n_*(续 ${i + 1}/${parts.length})*_`;
-                const partMessage = formatWeWorkMessage(title, partContent, 'done', i === parts.length - 1 ? note : undefined);
-                sendText(getReqId(reqId), partMessage);
-                log.info(`Final message part ${i + 1}/${parts.length} sent`);
-            }
-            catch (err) {
-                log.error(`Failed to send part ${i + 1}:`, err);
-            }
-        }
     }
     catch (err) {
-        log.error('Failed to send final messages:', err);
+        log.warn('Primary finish send failed, trying text fallback:', err);
+        try {
+            sendText(getReqId(reqId), finalMessage);
+            log.info(`Fallback text sent after primary finish failure, streamId=${streamId}`);
+        }
+        catch (fallbackErr) {
+            log.error('Both primary and fallback finish sends failed:', fallbackErr);
+        }
+    }
+    streamStates.delete(streamId);
+    for (let i = 1; i < parts.length; i++) {
+        try {
+            const partContent = `${parts[i]}\n\n_*(续 ${i + 1}/${parts.length})*_`;
+            const partMessage = formatWeWorkMessage(title, partContent, 'done', i === parts.length - 1 ? note : undefined);
+            sendText(getReqId(reqId), partMessage);
+            log.info(`Final message part ${i + 1}/${parts.length} sent`);
+        }
+        catch (err) {
+            log.error(`Failed to send part ${i + 1}:`, err);
+        }
     }
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.8.1-beta.9",
+  "version": "1.8.2",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",
@@ -46,7 +46,7 @@
     "url": "https://github.com/wu529778790/open-im/issues"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.76",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.86",
     "@larksuiteoapi/node-sdk": "^1.59.0",
     "@wu529778790/open-im": "^1.8.1-beta.8",
     "centrifuge": "^5.3.0",