@wecom/wecom-openclaw-plugin 2026.3.31-beta.0 → 2026.4.1-beta.1

package/dist/{src → esm/src}/monitor.js

@@ -1,3 +1,21 @@
+import * as os from 'os';
+import * as path from 'path';
+import { WSClient, WSAuthFailureError, WSReconnectExhaustedError, generateReqId } from '@wecom/aibot-node-sdk';
+import { getWeComRuntime } from './runtime.js';
+import { getDefaultMediaLocalRoots } from './openclaw-compat.js';
+import { SCENE_WECOM_OPENCLAW, WS_MAX_AUTH_FAILURE_ATTEMPTS, WS_MAX_RECONNECT_ATTEMPTS, WS_HEARTBEAT_INTERVAL_MS, EVENT_ENTER_CHECK_UPDATE, CMD_ENTER_EVENT_REPLY, CHANNEL_ID, MEDIA_IMAGE_PLACEHOLDER, MEDIA_DOCUMENT_PLACEHOLDER, THINKING_MESSAGE } from './const.js';
+export { WeComCommand } from './const.js';
+import { parseMessageContent } from './message-parser.js';
+import { sendWeComReply, StreamExpiredError } from './message-sender.js';
+import { downloadAndSaveImages, downloadAndSaveFiles } from './media-handler.js';
+import { uploadAndSendMedia } from './media-uploader.js';
+import { maskTemplateCardBlocks, extractTemplateCards } from './template-card-parser.js';
+import { checkGroupPolicy } from './group-policy.js';
+import { checkDmPolicy } from './dm-policy.js';
+import { startMessageStateCleanup, setWeComWebSocket, warmupReqIdStore, stopMessageStateCleanup, cleanupAccount, setReqIdForChat, setMessageState, deleteMessageState } from './state-manager.js';
+export { getWeComWebSocket } from './state-manager.js';
+import { PLUGIN_VERSION } from './version.js';
+
 /**
  * 企业微信 WebSocket 监控器主模块
  *
@@ -15,22 +33,6 @@
  * - state-manager.ts   : 全局状态管理（带 TTL 清理）
  * - timeout.ts         : 超时工具
  */
-import * as os from "os";
-import * as path from "path";
-import { WSClient, generateReqId, WSAuthFailureError, WSReconnectExhaustedError } from "@wecom/aibot-node-sdk";
-import { getWeComRuntime } from "./runtime.js";
-import { getDefaultMediaLocalRoots, resolveStateDir } from "./openclaw-compat.js";
-import { CHANNEL_ID, THINKING_MESSAGE, MEDIA_IMAGE_PLACEHOLDER, MEDIA_DOCUMENT_PLACEHOLDER, WS_HEARTBEAT_INTERVAL_MS, WS_MAX_RECONNECT_ATTEMPTS, WS_MAX_AUTH_FAILURE_ATTEMPTS, EVENT_ENTER_CHECK_UPDATE, CMD_ENTER_EVENT_REPLY, SCENE_WECOM_OPENCLAW, } from "./const.js";
-import { parseMessageContent } from "./message-parser.js";
-import { sendWeComReply, sendWeComReplyNonBlocking, StreamExpiredError } from "./message-sender.js";
-import { downloadAndSaveImages, downloadAndSaveFiles } from "./media-handler.js";
-import { uploadAndSendMedia } from "./media-uploader.js";
-import { maskTemplateCardBlocks } from "./template-card-parser.js";
-import { updateTemplateCardOnEvent, processTemplateCardsIfNeeded, } from "./template-card-manager.js";
-import { checkGroupPolicy } from "./group-policy.js";
-import { checkDmPolicy } from "./dm-policy.js";
-import { setWeComWebSocket, setMessageState, deleteMessageState, setReqIdForChat, warmupReqIdStore, startMessageStateCleanup, stopMessageStateCleanup, cleanupAccount, } from "./state-manager.js";
-import { PLUGIN_VERSION } from "./version.js";
 /**
  * 去除文本中的 `<think>...</think>` 标签（支持跨行），返回剩余可见文本。
  * 用于判断大模型回复中是否包含实际用户可见内容（而非仅有 thinking 推理过程）。
@@ -39,9 +41,148 @@ function stripThinkTags(text) {
     return text;
     // return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
 }
+const sentTemplateCardByTaskId = new Map();
+const TEMPLATE_CARD_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const TEMPLATE_CARD_CACHE_MAX_SIZE = 300;
+function getTemplateCardCacheKey(accountId, taskId) {
+    return `${accountId}:${taskId}`;
+}
+function pruneTemplateCardCache() {
+    const now = Date.now();
+    for (const [key, entry] of sentTemplateCardByTaskId) {
+        if (now - entry.createdAt >= TEMPLATE_CARD_CACHE_TTL_MS) {
+            sentTemplateCardByTaskId.delete(key);
+        }
+    }
+    if (sentTemplateCardByTaskId.size <= TEMPLATE_CARD_CACHE_MAX_SIZE) {
+        return;
+    }
+    const sortedEntries = [...sentTemplateCardByTaskId.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt);
+    const removeCount = sentTemplateCardByTaskId.size - TEMPLATE_CARD_CACHE_MAX_SIZE;
+    for (const [key] of sortedEntries.slice(0, removeCount)) {
+        sentTemplateCardByTaskId.delete(key);
+    }
+}
+function cloneTemplateCard(card) {
+    return JSON.parse(JSON.stringify(card));
+}
+function saveTemplateCardToCache(params) {
+    const { accountId, templateCard, runtime } = params;
+    const taskId = templateCard.task_id;
+    if (!taskId) {
+        runtime.log?.("[wecom][template-card] Skip cache: template card has no task_id");
+        return;
+    }
+    sentTemplateCardByTaskId.set(getTemplateCardCacheKey(accountId, taskId), {
+        templateCard: cloneTemplateCard(templateCard),
+        createdAt: Date.now(),
+    });
+    pruneTemplateCardCache();
+}
+function getTemplateCardFromCache(accountId, taskId) {
+    pruneTemplateCardCache();
+    const cached = sentTemplateCardByTaskId.get(getTemplateCardCacheKey(accountId, taskId));
+    if (!cached) {
+        return undefined;
+    }
+    return cloneTemplateCard(cached.templateCard);
+}
+function buildSelectedOptionMap(templateCardEvent) {
+    const selectedMap = new Map();
+    const selectedItems = templateCardEvent?.selected_items?.selected_item ?? [];
+    for (const item of selectedItems) {
+        const questionKey = item.question_key?.trim();
+        if (!questionKey) {
+            continue;
+        }
+        const optionIds = item.option_ids?.option_id?.filter(Boolean) ?? [];
+        selectedMap.set(questionKey, optionIds);
+    }
+    return selectedMap;
+}
+function applySelectedStateToTemplateCard(params) {
+    const { templateCard, selectedMap, templateCardEvent } = params;
+    const nextCard = cloneTemplateCard(templateCard);
+    if (templateCardEvent?.task_id) {
+        nextCard.task_id = templateCardEvent.task_id;
+    }
+    if (templateCardEvent?.card_type) {
+        nextCard.card_type = templateCardEvent.card_type;
+    }
+    // 交互完成后将提交按钮文案更新为已提交，提升用户感知
+    if (nextCard.submit_button?.text) {
+        nextCard.submit_button.text = "已提交";
+    }
+    if (nextCard.checkbox?.question_key) {
+        const selectedIds = selectedMap.get(nextCard.checkbox.question_key) ?? [];
+        nextCard.checkbox.disable = true;
+        if (Array.isArray(nextCard.checkbox.option_list)) {
+            nextCard.checkbox.option_list = nextCard.checkbox.option_list.map((option) => ({
+                ...option,
+                is_checked: selectedIds.includes(option.id),
+            }));
+        }
+    }
+    if (Array.isArray(nextCard.select_list)) {
+        nextCard.select_list = nextCard.select_list.map((selection) => {
+            const selectedIds = selectedMap.get(selection.question_key) ?? [];
+            return {
+                ...selection,
+                disable: true,
+                selected_id: selectedIds[0] ?? selection.selected_id,
+            };
+        });
+    }
+    if (nextCard.button_selection?.question_key) {
+        const selectedIds = selectedMap.get(nextCard.button_selection.question_key) ?? [];
+        nextCard.button_selection.disable = true;
+        if (selectedIds[0]) {
+            nextCard.button_selection.selected_id = selectedIds[0];
+        }
+    }
+    return nextCard;
+}
+async function updateTemplateCardOnEvent(params) {
+    const { frame, accountId, runtime, wsClient } = params;
+    const body = frame.body;
+    const templateCardEvent = body.event?.template_card_event;
+    const taskId = templateCardEvent?.task_id;
+    if (!taskId) {
+        runtime.log?.(`[${accountId}] [template-card-update] Skip update: missing task_id in callback`);
+        return;
+    }
+    const cachedCard = getTemplateCardFromCache(accountId, taskId);
+    if (!cachedCard) {
+        runtime.log?.(`[${accountId}] [template-card-update] Skip update: task_id=${taskId} not found in cache`);
+        return;
+    }
+    const selectedMap = buildSelectedOptionMap(templateCardEvent);
+    const updatedCard = applySelectedStateToTemplateCard({
+        templateCard: cachedCard,
+        selectedMap,
+        templateCardEvent,
+    });
+    await wsClient.updateTemplateCard(frame, updatedCard, [body.from.userid]);
+    runtime.log?.(`[${accountId}] [template-card-update] Updated card by task_id=${taskId}`);
+    // 将更新后的卡片写回缓存，后续多次点击时状态保持一致
+    saveTemplateCardToCache({
+        accountId,
+        templateCard: updatedCard,
+        runtime,
+    });
+}
 // ============================================================================
 // 媒体本地路径白名单扩展
 // ============================================================================
+/**
+ * 解析 openclaw 状态目录（与 plugin-sdk 内部逻辑保持一致）
+ */
+function resolveStateDir() {
+    const stateOverride = process.env.OPENCLAW_STATE_DIR?.trim() || process.env.CLAWDBOT_STATE_DIR?.trim();
+    if (stateOverride)
+        return stateOverride;
+    return path.join(os.homedir(), ".openclaw");
+}
 /**
  * 在 getDefaultMediaLocalRoots() 基础上，将 stateDir 本身也加入白名单，
  * 并合并用户在 WeComConfig 中配置的自定义 mediaLocalRoots。
@@ -95,9 +236,6 @@ function buildMediaErrorSummary(mediaUrl, result) {
     }
     return `⚠️ 文件发送失败：无法处理文件 ${mediaUrl}，请稍后再试。`;
 }
-export { WeComCommand } from "./const.js";
-export { getWeComWebSocket, setReqIdForChat, getReqIdForChatAsync, getReqIdForChat, deleteReqIdForChat, warmupReqIdStore, flushReqIdStore, } from "./state-manager.js";
-export { sendWeComReply } from "./message-sender.js";
 // ============================================================================
 // 消息上下文构建
 // ============================================================================
@@ -129,12 +267,8 @@ function buildMessageContext(frame, account, config, text, mediaList, quoteConte
     const mediaTypes = mediaList.length > 0
         ? mediaList.map((m) => m.contentType).filter(Boolean)
         : undefined;
-    // 使用 route.agentId 解析 storePath（多 agent 场景下 session 路径隔离）
-    const storePath = core.channel.session.resolveStorePath(config.session?.store, {
-        agentId: route.agentId,
-    });
     // 构建标准消息上下文
-    const ctxPayload = core.channel.reply.finalizeInboundContext({
+    return core.channel.reply.finalizeInboundContext({
         Body: messageBody,
         RawBody: messageBody,
         CommandBody: messageBody,
@@ -143,7 +277,7 @@ function buildMessageContext(frame, account, config, text, mediaList, quoteConte
         To: `${CHANNEL_ID}:${chatId}`,
         SenderId: body.from.userid,
         SessionKey: route.sessionKey,
-        AccountId: route.accountId,
+        AccountId: account.accountId,
         ChatType: chatType,
         ConversationLabel: fromLabel,
         Timestamp: Date.now(),
@@ -162,7 +296,6 @@ function buildMessageContext(frame, account, config, text, mediaList, quoteConte
         MediaUrls: mediaPaths,
         ReplyToBody: quoteContent,
     });
-    return { ctxPayload, route, storePath, chatId, chatType };
 }
 /**
  * 发送"思考中"消息
@@ -234,38 +367,68 @@ async function sendMediaBatch(ctx, mediaUrls) {
  *    替换掉 thinking 动画，否则 thinking 会一直残留。
  *
  * 关闭策略（按优先级）：
+ * 0. [新增] 有模板卡片代码块 → 提取卡片并主动发送，用剩余文本关闭流
  * 1. 有可见文本 → 用完整文本关闭
- * 2. 有模板卡片发送成功 → "📋 卡片消息已发送。"
- * 3. 有媒体成功发送（通过 deliver 回调） → 用友好提示"文件已发送"
- * 4. 媒体发送失败 → 直接用错误摘要替换 thinking
+ * 2. 有媒体成功发送（通过 deliver 回调） → 用友好提示"文件已发送"
+ * 3. 媒体发送失败 → 直接用错误摘要替换 thinking
+ * 4. 其他 → 用通用"处理完成"提示
+ *    （agent 可能已通过内置 message 工具直接发送了文件，
+ *    该路径走 outbound.sendMedia 完全绕过 deliver 回调，
+ *    所以 state 中无记录，但文件已实际送达）
  *
  * 降级策略：
  * - 当 streamExpired=true（errcode 846608）时，流式通道已不可用（>6分钟），
  *   改用 wsClient.sendMessage 主动发送完整文本。
- *
- * 注意：模板卡片的检测和发送已在 finishThinkingStream 之前由
- *       processTemplateCardsIfNeeded 完成，此处只关心最后的消息发送。
  */
 async function finishThinkingStream(ctx) {
     const { wsClient, frame, state, runtime } = ctx;
     const body = frame.body;
     const chatId = body.chatid || body.from.userid;
     const visibleText = stripThinkTags(state.accumulatedText);
+    // ── 模板卡片检测与发送 ──────────────────────────────────────────────
+    // 在确定 finishText 之前，先检查累积文本中是否包含模板卡片 JSON 代码块。
+    // 若检测到合法卡片，通过 sendMessage 主动发送后，用剩余文本关闭流。
+    if (visibleText) {
+        runtime.log?.(`[wecom][template-card] finishThinkingStream: visibleText exists, length=${visibleText.length}, running extractTemplateCards...`);
+        const logFn = (...args) => {
+            runtime.log?.(...args);
+        };
+        const { cards, remainingText } = extractTemplateCards(state.accumulatedText, logFn);
+        runtime.log?.(`[wecom][template-card] finishThinkingStream: extractTemplateCards result — cards=${cards.length}, remainingTextLength=${remainingText.length}`);
+        if (cards.length > 0) {
+            runtime.log?.(`[wecom][template-card] finishThinkingStream: ${cards.length} card(s) detected, card_types=[${cards.map(c => c.cardType).join(", ")}]`);
+            await sendTemplateCards(ctx, cards);
+            // 用剩余文本关闭流（可能为空）
+            const trimmedRemaining = stripThinkTags(remainingText);
+            const finishText = trimmedRemaining
+                ? remainingText
+                : (state.hasTemplateCard ? "📋 卡片消息已发送。" : "");
+            runtime.log?.(`[wecom][template-card] finishThinkingStream: closing stream with finishText="${finishText.slice(0, 100)}...", hasTemplateCard=${state.hasTemplateCard}`);
+            await sendWeComReply({ wsClient, frame, text: finishText, runtime, finish: true, streamId: state.streamId });
+            return;
+        }
+    }
+    else {
+        runtime.log?.(`[wecom][template-card] finishThinkingStream: no visibleText, skipping template card extraction`);
+    }
+    // ── 模板卡片检测结束 ────────────────────────────────────────────────
     let finishText = state.accumulatedText;
     if (visibleText) {
+        // 有可见文本：用完整文本关闭流（覆盖 thinking 为真实内容）
         finishText = state.accumulatedText;
     }
-    else if (state.hasTemplateCard) {
-        finishText = "📋 卡片消息已发送。";
-    }
     else if (state.hasMedia) {
         if (state.hasMediaFailed && state.mediaErrorSummary) {
+            // 媒体成功发送：用友好提示告知用户
             finishText = finishText ? `${finishText}\n\n${state.mediaErrorSummary}` : state.mediaErrorSummary;
         }
         else if (!finishText) {
             finishText = "📎 文件已发送，请查收。";
         }
     }
+    // if (!finishText) {
+    //   finishText = "✅ 处理完成。";
+    // }
     if (finishText) {
         // 尝试流式发送；若已知过期或发送时发现过期，统一降级为主动发送
         let expired = state.streamExpired;
@@ -291,11 +454,46 @@ async function finishThinkingStream(ctx) {
         }
     }
 }
+/**
+ * 逐个发送已提取的模板卡片（通过 wsClient.sendMessage 主动推送）
+ *
+ * 发送失败不阻塞流程，仅记录错误日志。
+ */
+async function sendTemplateCards(ctx, cards) {
+    const { wsClient, frame, state, runtime, account } = ctx;
+    const body = frame.body;
+    const chatId = body.chatid || body.from.userid;
+    for (const card of cards) {
+        try {
+            runtime.log?.(`[wecom][template-card] Sending card_type=${card.cardType} to chatId=${chatId}`);
+            const rawTemplateCard = card.cardJson;
+            if (typeof rawTemplateCard.card_type !== "string") {
+                runtime.error?.("[wecom][template-card] Skip sending invalid card: missing card_type");
+                continue;
+            }
+            const templateCard = rawTemplateCard;
+            await wsClient.sendMessage(chatId, {
+                msgtype: "template_card",
+                template_card: templateCard,
+            });
+            state.hasTemplateCard = true;
+            saveTemplateCardToCache({
+                accountId: account.accountId,
+                templateCard,
+                runtime,
+            });
+            runtime.log?.(`[wecom][template-card] Card sent successfully: card_type=${card.cardType}`);
+        }
+        catch (err) {
+            runtime.error?.(`[wecom][template-card] Failed to send card: card_type=${card.cardType}, error=${JSON.stringify(err)}`);
+        }
+    }
+}
 /**
  * 路由消息到核心处理流程并处理回复
  */
 async function routeAndDispatchMessage(params) {
-    const { ctxPayload, route, storePath, chatId, chatType, config, account, wsClient, frame, state, runtime, onCleanup } = params;
+    const { ctxPayload, config, account, wsClient, frame, state, runtime, onCleanup } = params;
     const core = getWeComRuntime();
     const ctx = { wsClient, frame, state, account, runtime };
     // 防止 onCleanup 被多次调用（onError 回调与 catch 块可能重复触发）
@@ -308,23 +506,6 @@ async function routeAndDispatchMessage(params) {
     };
     let isShowThink = !(account.sendThinkingMessage ?? true);
     try {
-        // 记录 inbound session 元数据（session 追踪）
-        await core.channel.session.recordInboundSession({
-            storePath,
-            sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
-            ctx: ctxPayload,
-            updateLastRoute: chatType !== "group"
-                ? {
-                    sessionKey: route.mainSessionKey,
-                    channel: CHANNEL_ID,
-                    to: `${CHANNEL_ID}:${chatId}`,
-                    accountId: route.accountId,
-                }
-                : undefined,
-            onRecordError: (err) => {
-                runtime.error?.(`[wecom] failed updating session meta: ${String(err)}`);
-            },
-        });
         await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
             ctx: ctxPayload,
             cfg: config,
@@ -355,10 +536,11 @@ async function routeAndDispatchMessage(params) {
                     }
                 },
                 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 ?? [])}`);
-                    // 累积文本（快速指令等非流式回复只走 deliver，不走 onPartialReply）
+                    // 累积文本
                     if (payload.text) {
-                        state.accumulatedText = payload.text;
+                        state.accumulatedText += (payload.text || '');
                     }
                     // 发送媒体（统一走主动发送）
                     const mediaUrls = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
@@ -378,62 +560,42 @@ async function routeAndDispatchMessage(params) {
                             runtime.error?.(`[wecom] sendMediaBatch threw: ${errMsg}`);
                         }
                     }
-                    // 中间帧流式更新已迁移到 onPartialReply（token 级别，更细粒度）
-                    // deliver 只负责文本累积和媒体发送
-                },
-                onError: (err, info) => {
-                    runtime.error?.(`[wecom] ${info.kind} reply failed: ${String(err)}`);
-                },
-            },
-            // onPartialReply：token 级别的流式 UI 刷新
-            // 使用 SDK 的 replyStreamNonBlocking：上一条同 reqId 的消息未收到 ack 时跳过本次发送，
-            // 避免流式中间帧排队积压导致延迟。丢帧在流式场景下可接受（text 是累积文本，最终由 finishThinkingStream 兜底）。
-            replyOptions: {
-                onPartialReply: (data) => {
-                    // 累积文本
-                    if (data.text) {
-                        state.accumulatedText = (data.text || '');
-                    }
-                    if (!state.streamId || !data.text || state.streamExpired)
-                        return;
+                    // 中间帧：有可见文本时流式更新（流式过期后跳过，等 deliver 完成后主动发送）
                     // 使用 maskTemplateCardBlocks 遮罩正在构建中的模板卡片代码块，
                     // 避免 JSON 源码在流式输出过程中暴露给终端用户
-                    const displayText = maskTemplateCardBlocks(data.text, (...args) => runtime.log?.(...args));
-                    if (displayText !== data.text) {
-                        // runtime.log?.(`[wecom][template-card] Partial-reply masked: original=${data.text.length}chars, masked=${displayText.length}chars`);
-                    }
-                    // fire-and-forget：不阻塞 onPartialReply 回调
-                    sendWeComReplyNonBlocking({
-                        wsClient, frame, text: displayText, runtime,
-                        streamId: state.streamId,
-                    }).catch((err) => {
-                        if (err instanceof StreamExpiredError) {
-                            state.streamExpired = true;
-                            runtime.log?.(`[wecom] Stream expired during partial reply, will fallback to proactive send`);
+                    if (info.kind !== "final" && state.accumulatedText && !state.streamExpired) {
+                        try {
+                            const displayText = maskTemplateCardBlocks(state.accumulatedText, (...args) => runtime.log?.(...args));
+                            if (displayText !== state.accumulatedText) {
+                                runtime.log?.(`[wecom][template-card] Mid-frame masked: original=${state.accumulatedText.length}chars, masked=${displayText.length}chars`);
+                            }
+                            await sendWeComReply({ wsClient, frame, text: displayText, runtime, finish: false, streamId: state.streamId });
                         }
-                        // 其他错误静默忽略，不影响主流程（deliver + finishThinkingStream 兜底）
-                    });
+                        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) => {
+                    runtime.error?.(`[wecom] ${info.kind} reply failed: ${String(err)}`);
                 },
             },
         });
-        // 模板卡片检测与发送（在关闭 thinking 流之前独立处理）
-        const cardResult = await processTemplateCardsIfNeeded({ wsClient, frame, state, account, runtime });
-        if (cardResult) {
-            // 卡片已发送，用剩余文本替换累积文本
-            state.accumulatedText = cardResult.remainingText;
-        }
         // 关闭 thinking 流
         await finishThinkingStream(ctx);
         safeCleanup();
     }
     catch (err) {
         runtime.error?.(`[wecom][plugin] Failed to process message: ${String(err)}`);
-        // 即使 dispatch 抛异常，也需要处理卡片和关闭 thinking 流
+        // 即使 dispatch 抛异常，也需要关闭 thinking 流，
+        // 避免 deliver 已成功发送媒体但后续出错时 thinking 消息残留或被错误文案覆盖
         try {
-            const cardResult = await processTemplateCardsIfNeeded({ wsClient, frame, state, account, runtime });
-            if (cardResult) {
-                state.accumulatedText = cardResult.remainingText;
-            }
             await finishThinkingStream(ctx);
         }
         catch (finishErr) {
@@ -443,12 +605,20 @@ async function routeAndDispatchMessage(params) {
     }
 }
 /**
- * 解析并校验企业微信消息（防抖前阶段：Step 1-4）
+ * 处理企业微信消息（主函数）
  *
- * 执行消息解析、策略检查、媒体下载等前置操作，
- * 返回一个可用于防抖缓冲的 entry，或 null（消息被过滤/跳过时）。
+ * 处理流程：
+ * 1. 解析消息内容（文本、图片、引用）
+ * 2. 群组策略检查（仅群聊）
+ * 3. DM Policy 访问控制检查（仅私聊）
+ * 4. 下载并保存图片
+ * 5. 初始化消息状态
+ * 6. 发送"思考中"消息
+ * 7. 路由消息到核心处理流程
+ *
+ * 整体带超时保护，防止单条消息处理阻塞过久
  */
-async function prepareWeComMessage(params) {
+async function processWeComMessage(params) {
     const { frame, account, config, runtime, wsClient } = params;
     const body = frame.body;
     const chatId = body.chatid || body.from.userid;
@@ -470,7 +640,7 @@ async function prepareWeComMessage(params) {
     // 如果既没有文本也没有图片也没有文件也没有引用内容，则跳过
     if (!text && imageUrls.length === 0 && fileUrls.length === 0) {
         runtime.log?.("[wecom][plugin] Skipping empty message (no text, image, file or quote)");
-        return null;
+        return;
     }
     // Step 2: 群组策略检查（仅群聊）
     if (chatType === "group") {
@@ -482,7 +652,7 @@ async function prepareWeComMessage(params) {
             runtime,
         });
         if (!groupPolicyResult.allowed) {
-            return null;
+            return;
         }
     }
     // Step 3: DM Policy 访问控制检查（仅私聊）
@@ -495,7 +665,7 @@ async function prepareWeComMessage(params) {
         runtime,
     });
     if (!dmPolicyResult.allowed) {
-        return null;
+        return;
     }
     // Step 4: 下载并保存图片和文件
     const [imageMediaList, fileMediaList] = await Promise.all([
@@ -517,28 +687,6 @@ async function prepareWeComMessage(params) {
         }),
     ]);
     const mediaList = [...imageMediaList, ...fileMediaList];
-    return {
-        frame,
-        account,
-        config,
-        runtime,
-        wsClient,
-        text,
-        mediaList,
-        quoteContent,
-        messageId,
-        chatId,
-        reqId,
-    };
-}
-/**
- * 处理企业微信消息（Step 5-7）
- *
- * 接收解析后的消息数据，执行初始化状态、发送 thinking、路由到核心。
- * 同一会话中的消息通过串行队列保证按序执行。
- */
-async function processWeComMessageNow(entry) {
-    const { frame, account, config, runtime, wsClient, text, mediaList, quoteContent, messageId, chatId, reqId } = entry;
     // Step 5: 初始化消息状态
     setReqIdForChat(chatId, reqId, account.accountId);
     const streamId = generateReqId("stream");
@@ -553,15 +701,11 @@ async function processWeComMessageNow(entry) {
     //   await sendThinkingReply({ wsClient, frame, streamId, runtime });
     // }
     // Step 7: 构建上下文并路由到核心处理流程（带整体超时保护）
-    const { ctxPayload, route, storePath, chatId: resolvedChatId, chatType } = buildMessageContext(frame, account, config, text, mediaList, quoteContent);
+    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 routeAndDispatchMessage({
             ctxPayload,
-            route,
-            storePath,
-            chatId: resolvedChatId,
-            chatType,
             config,
             account,
             wsClient,
@@ -605,7 +749,7 @@ function createSdkLogger(runtime, accountId) {
  * 监听企业微信 WebSocket 连接
  * 使用 aibot-node-sdk 简化连接管理
  */
-export async function monitorWeComProvider(options) {
+async function monitorWeComProvider(options) {
     const { account, config, runtime, abortSignal, setStatus } = options;
     runtime.log?.(`[${account.accountId}] [${PLUGIN_VERSION}] Initializing WSClient with SDK...`);
     runtime.error?.(`[${account.accountId}] [diag] monitor boot marker: build=20260325-event-debug-1`);
@@ -750,26 +894,13 @@ export async function monitorWeComProvider(options) {
         // 监听普通消息
         wsClient.on("message", async (frame) => {
             try {
-                const entry = await prepareWeComMessage({
+                await processWeComMessage({
                     frame,
                     account,
                     config,
                     runtime,
                     wsClient,
                 });
-                if (!entry)
-                    return;
-                // 排队逻辑暂时关闭，直接处理消息
-                // const { status } = enqueueWeComChatTask({
-                //   accountId: entry.account.accountId,
-                //   chatId: entry.chatId,
-                //   task: () => processWeComMessageNow(entry),
-                // });
-                //
-                // if (status === "queued") {
-                //   runtime.log?.(`[wecom] Chat task queued for chat=${entry.chatId} (previous task still running)`);
-                // }
-                await processWeComMessageNow(entry);
             }
             catch (err) {
                 runtime.error?.(`[${account.accountId}] Failed to process message: ${String(err)}`);
@@ -799,16 +930,13 @@ export async function monitorWeComProvider(options) {
                 catch (updateErr) {
                     runtime.error?.(`[${account.accountId}] [template-card-update] Failed to update template card: ${String(updateErr)}`);
                 }
-                const entry = await prepareWeComMessage({
+                await processWeComMessage({
                     frame,
                     account,
                     config,
                     runtime,
                     wsClient,
                 });
-                if (entry) {
-                    await processWeComMessageNow(entry);
-                }
             }
             catch (err) {
                 runtime.error?.(`[${account.accountId}] Failed to process template_card_event: ${String(err)}`);
@@ -830,3 +958,6 @@ export async function monitorWeComProvider(options) {
         });
     });
 }
+
+export { monitorWeComProvider, sendWeComReply, setReqIdForChat, warmupReqIdStore };
+//# sourceMappingURL=monitor.js.map