@wecom/wecom-openclaw-plugin 2026.3.24 → 2026.3.25-beta.1

package/README.md

@@ -4,7 +4,16 @@
 >
 > 💬 扫码加入企业微信交流群：
 >
-> <img src="https://wwcdn.weixin.qq.com/node/wework/images/202603181801.a77d987fb8.png" alt="扫码入群交流" width="200" />
+> <img src="https://wwcdn.weixin.qq.com/node/wework/images/202603241759.3fb01c32cc.png" alt="扫码入群交流" width="200" />
+
+# 特别说明
+> ****2026.3.22 版本 OpenClaw 兼容说明****
+> 
+> 如果你的 OpenClaw 是 2026.3.22 及以上的版本，请升级插件到 2026.3.24 及以上版本。
+> 
+> 如果你的 OpenClaw 是 2026.3.22 以下的版本，请保持插件版本在 2026.3.20 版本。
+> 
+> 你可以使用以下命令快速安装： `npx -y @wecom/wecom-openclaw-cli install --force`
 
 # 🤖 WeCom OpenClaw Plugin
 

package/dist/index.cjs.js

@@ -447,8 +447,6 @@ const IMAGE_DOWNLOAD_TIMEOUT_MS = 30000;
 const FILE_DOWNLOAD_TIMEOUT_MS = 60000;
 /** 消息发送超时时间（毫秒） */
 const REPLY_SEND_TIMEOUT_MS = 15000;
-/** 消息处理总超时时间（毫秒） */
-const MESSAGE_PROCESS_TIMEOUT_MS = 5 * 60 * 1000;
 /** WebSocket 心跳间隔（毫秒） */
 const WS_HEARTBEAT_INTERVAL_MS = 30000;
 /** WebSocket 连接断开时的最大重连次数 */
@@ -641,6 +639,23 @@ class TimeoutError extends Error {
  * 负责通过 WSClient 发送回复消息，包含超时保护
  */
 // ============================================================================
+// 流式过期错误（errcode 846608）
+// ============================================================================
+/** 流式回复超时错误码（>6分钟未更新，服务端拒绝继续流式更新） */
+const STREAM_EXPIRED_ERRCODE = 846608;
+/**
+ * 流式回复过期错误
+ * 当服务端返回 errcode=846608 时抛出，表示流式消息已超过6分钟无法更新，
+ * 调用方需降级为主动发送（sendMessage）方式回复。
+ */
+class StreamExpiredError extends Error {
+    constructor(message) {
+        super(message ?? `Stream message update expired (errcode=${STREAM_EXPIRED_ERRCODE})`);
+        this.errcode = STREAM_EXPIRED_ERRCODE;
+        this.name = "StreamExpiredError";
+    }
+}
+// ============================================================================
 // 消息发送
 // ============================================================================
 /**
@@ -660,7 +675,18 @@ async function sendWeComReply(params) {
         throw new Error("WSClient not connected");
     }
     // 使用 SDK 的 replyStream 方法发送消息，带超时保护
-    await withTimeout(wsClient.replyStream(frame, streamId, text, finish), REPLY_SEND_TIMEOUT_MS, `Reply send timed out (streamId=${streamId})`);
+    try {
+        await withTimeout(wsClient.replyStream(frame, streamId, text, finish), REPLY_SEND_TIMEOUT_MS, `Reply send timed out (streamId=${streamId})`);
+    }
+    catch (err) {
+        // 服务端返回 846608：流式消息超过6分钟无法更新，需降级为主动发送
+        const errMsg = err?.errmsg || err?.message || (typeof err === "object" ? JSON.stringify(err) : String(err));
+        if (err?.errcode === STREAM_EXPIRED_ERRCODE ||
+            errMsg.includes(String(STREAM_EXPIRED_ERRCODE))) {
+            throw new StreamExpiredError(errMsg);
+        }
+        throw err;
+    }
     runtime.log?.(`[plugin -> server] streamId=${streamId}, finish=${finish}`);
     return streamId;
 }
@@ -1525,14 +1551,6 @@ const PLUGIN_VERSION = getVersion();
  * - state-manager.ts   : 全局状态管理（带 TTL 清理）
  * - timeout.ts         : 超时工具
  */
-/**
- * 去除文本中的 `<think>...</think>` 标签（支持跨行），返回剩余可见文本。
- * 用于判断大模型回复中是否包含实际用户可见内容（而非仅有 thinking 推理过程）。
- */
-function stripThinkTags(text) {
-    return text;
-    // return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
-}
 // ============================================================================
 // 媒体本地路径白名单扩展
 // ============================================================================
@@ -1663,7 +1681,7 @@ function buildMessageContext(frame, account, config, text, mediaList, quoteConte
  * 发送"思考中"消息
  */
 async function sendThinkingReply(params) {
-    const { wsClient, frame, streamId, runtime } = params;
+    const { wsClient, frame, streamId, runtime, state } = params;
     try {
         await sendWeComReply({
             wsClient,
@@ -1675,16 +1693,13 @@ async function sendThinkingReply(params) {
         });
     }
     catch (err) {
-        runtime.error?.(`[wecom] Failed to send thinking message: ${String(err)}`);
-    }
-}
-/**
- * 累积文本并判断是否有可见内容（去除 <think> 标签后）
- */
-function accumulateText(state, text) {
-    state.accumulatedText += text;
-    if (!state.hasText && stripThinkTags(state.accumulatedText)) {
-        state.hasText = true;
+        if (err instanceof StreamExpiredError && state) {
+            state.streamExpired = true;
+            runtime.log?.(`[wecom] Stream expired during thinking reply, will fallback to proactive send`);
+        }
+        else {
+            runtime.error?.(`[wecom] Failed to send thinking message: ${String(err)}`);
+        }
     }
 }
 /**
@@ -1739,33 +1754,52 @@ async function sendMediaBatch(ctx, mediaUrls) {
  *    （agent 可能已通过内置 message 工具直接发送了文件，
  *    该路径走 outbound.sendMedia 完全绕过 deliver 回调，
  *    所以 state 中无记录，但文件已实际送达）
+ *
+ * 降级策略：
+ * - 当 streamExpired=true（errcode 846608）时，流式通道已不可用（>6分钟），
+ *   改用 wsClient.sendMessage 主动发送完整文本。
  */
 async function finishThinkingStream(ctx) {
     const { wsClient, frame, state, runtime } = ctx;
-    const visibleText = stripThinkTags(state.accumulatedText);
-    let finishText;
-    if (visibleText) {
-        // 有可见文本：用完整文本关闭流（覆盖 thinking 为真实内容）
-        finishText = state.accumulatedText;
-    }
-    else if (state.hasMedia) {
-        // 媒体成功发送：用友好提示告知用户
-        finishText = "📎 文件已发送，请查收。";
-    }
-    else if (state.hasMediaFailed && state.mediaErrorSummary) {
-        // 媒体发送失败：直接用错误摘要替换 thinking 流（不再额外发 sendMessage）
-        finishText = state.mediaErrorSummary;
+    const body = frame.body;
+    const chatId = body.chatid || body.from.userid;
+    let finishText = state.accumulatedText;
+    if (state.hasMedia) {
+        if (state.hasMediaFailed && state.mediaErrorSummary) {
+            // 媒体成功发送：用友好提示告知用户
+            finishText = finishText ? `${finishText}\n\n${state.mediaErrorSummary}` : state.mediaErrorSummary;
+        }
+        else if (!finishText) {
+            finishText = "📎 文件已发送，请查收。";
+        }
     }
-    else {
-        // 核心无可见文本且 deliver 中未处理过媒体。
-        //
-        // 不使用错误提示，因为 agent 可能已通过内置 message 工具直接调用
-        // outbound.sendMedia 成功发送了文件——该路径完全绕过 monitor 的 deliver
-        // 回调，所以 state.deliverCalled / state.hasMedia 均为 false，但文件
-        // 实际已送达用户。此时显示 "未生成回复" 会误导用户。
-        finishText = "✅ 处理完成。";
+    // if (!finishText) {
+    //   finishText = "✅ 处理完成。";
+    // }
+    if (finishText) {
+        // 尝试流式发送；若已知过期或发送时发现过期，统一降级为主动发送
+        let expired = state.streamExpired;
+        if (!expired) {
+            try {
+                await sendWeComReply({ wsClient, frame, text: finishText, runtime, finish: true, streamId: state.streamId });
+            }
+            catch (err) {
+                if (err instanceof StreamExpiredError) {
+                    expired = true;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        if (expired) {
+            runtime.log?.(`[wecom] Stream expired, sending final text via sendMessage (proactive)`);
+            await wsClient.sendMessage(chatId, {
+                msgtype: "markdown",
+                markdown: { content: finishText },
+            });
+        }
     }
-    await sendWeComReply({ wsClient, frame, text: finishText, runtime, finish: true, streamId: state.streamId });
 }
 /**
  * 路由消息到核心处理流程并处理回复
@@ -1782,17 +1816,43 @@ async function routeAndDispatchMessage(params) {
             onCleanup();
         }
     };
+    let isShowThink = !(account.sendThinkingMessage ?? true);
     try {
         await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
             ctx: ctxPayload,
             cfg: config,
+            // replyResolver: async (ctx, opts) => {
+            //   const startTime = Date.now();
+            //   const TEN_MINUTES = 7 * 60 * 1000;
+            //
+            //   console.log('开始输出内容');
+            //
+            //   while (Date.now() - startTime < TEN_MINUTES) {
+            //     // 每隔一段时间发送一个 block reply
+            //     await opts?.onBlockReply?.({ text: `输出内容 ${new Date().toISOString()}` });
+            //     await new Promise(resolve => setTimeout(resolve, 30 * 1000)); // 每5秒输出一次
+            //   }
+            //
+            //   return { text: "10分钟输出完成" }; // 最终回复
+            // },
             dispatcherOptions: {
+                onReplyStart: async () => {
+                    if (!isShowThink && state.streamId && !state.accumulatedText) {
+                        try {
+                            await sendThinkingReply({ wsClient, frame, streamId: state.streamId, runtime, state });
+                        }
+                        catch (e) {
+                            runtime.error?.(`[wecom] sendThinkingReply threw err: ${String(e)}`);
+                        }
+                        isShowThink = true;
+                    }
+                },
                 deliver: async (payload, info) => {
                     state.deliverCalled = true;
                     // runtime.log?.(`[openclaw -> plugin] kind=${info.kind}, text=${payload.text ?? ''}, mediaUrl=${payload.mediaUrl ?? ''}, mediaUrls=${JSON.stringify(payload.mediaUrls ?? [])}`);
                     // 累积文本
                     if (payload.text) {
-                        accumulateText(state, payload.text);
+                        state.accumulatedText += (payload.text || '');
                     }
                     // 发送媒体（统一走主动发送）
                     const mediaUrls = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
@@ -1812,9 +1872,20 @@ async function routeAndDispatchMessage(params) {
                             runtime.error?.(`[wecom] sendMediaBatch threw: ${errMsg}`);
                         }
                     }
-                    // 中间帧：有可见文本时流式更新
-                    if (info.kind !== "final" && state.hasText && state.accumulatedText) {
-                        await sendWeComReply({ wsClient, frame, text: state.accumulatedText, runtime, finish: false, streamId: state.streamId });
+                    // 中间帧：有可见文本时流式更新（流式过期后跳过，等 deliver 完成后主动发送）
+                    if (info.kind !== "final" && state.hasText && state.accumulatedText && !state.streamExpired) {
+                        try {
+                            await sendWeComReply({ wsClient, frame, text: state.accumulatedText, runtime, finish: false, streamId: state.streamId });
+                        }
+                        catch (err) {
+                            if (err instanceof StreamExpiredError) {
+                                state.streamExpired = true;
+                                runtime.log?.(`[wecom] Stream expired during intermediate reply, will fallback to proactive send`);
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
                     }
                 },
                 onError: (err, info) => {
@@ -1930,16 +2001,16 @@ async function processWeComMessage(params) {
     const cleanupState = () => {
         deleteMessageState(messageId);
     };
-    // Step 6: 发送"思考中"消息
-    const shouldSendThinking = account.sendThinkingMessage ?? true;
-    if (shouldSendThinking) {
-        await sendThinkingReply({ wsClient, frame, streamId, runtime });
-    }
+    // // Step 6: 发送"思考中"消息
+    // const shouldSendThinking = account.sendThinkingMessage ?? true;
+    // if (shouldSendThinking) {
+    //   await sendThinkingReply({ wsClient, frame, streamId, runtime });
+    // }
     // Step 7: 构建上下文并路由到核心处理流程（带整体超时保护）
     const ctxPayload = buildMessageContext(frame, account, config, text, mediaList, quoteContent);
     // runtime.log?.(`[plugin -> openclaw] body=${text}, mediaPaths=${JSON.stringify(mediaList.map(m => m.path))}${quoteContent ? `, quote=${quoteContent}` : ''}`);
     try {
-        await withTimeout(routeAndDispatchMessage({
+        await routeAndDispatchMessage({
             ctxPayload,
             config,
             account,
@@ -1948,26 +2019,10 @@ async function processWeComMessage(params) {
             state,
             runtime,
             onCleanup: cleanupState,
-        }), MESSAGE_PROCESS_TIMEOUT_MS, `Message processing timed out (msgId=${messageId})`);
+        });
     }
     catch (err) {
-        runtime.error?.(`[wecom][plugin] Message processing failed or timed out: ${String(err)}`);
-        // 确保 thinking 流被关闭，防止异常/超时时 thinking 消息一直残留
-        try {
-            if (shouldSendThinking) {
-                await sendWeComReply({
-                    wsClient,
-                    frame,
-                    text: "处理消息时出现异常，请稍后重试。",
-                    runtime,
-                    finish: true,
-                    streamId: state.streamId,
-                });
-            }
-        }
-        catch (finishErr) {
-            runtime.error?.(`[wecom] Failed to finish thinking stream on error: ${String(finishErr)}`);
-        }
+        runtime.error?.(`[wecom][plugin] Message processing failed: ${String(err)}`);
         cleanupState();
     }
 }