@wecom/wecom-openclaw-plugin 2026.4.2 → 2026.4.3-beta.0

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

@@ -1,21 +1,3 @@
-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 监控器主模块
  *
@@ -33,156 +15,26 @@ import { PLUGIN_VERSION } from './version.js';
  * - state-manager.ts   : 全局状态管理（带 TTL 清理）
  * - timeout.ts         : 超时工具
  */
-/**
- * 去除文本中的 `<think>...</think>` 标签（支持跨行），返回剩余可见文本。
- * 用于判断大模型回复中是否包含实际用户可见内容（而非仅有 thinking 推理过程）。
- */
-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,
-    });
-}
+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, 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";
+import { processDynamicRouting } from "./dynamic-routing.js";
 // ============================================================================
 // 媒体本地路径白名单扩展
 // ============================================================================
-/**
- * 解析 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。
@@ -236,13 +88,17 @@ 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";
 // ============================================================================
 // 消息上下文构建
 // ============================================================================
 /**
  * 构建消息上下文
+ * @returns 消息上下文对象
  */
-function buildMessageContext(frame, account, config, text, mediaList, quoteContent) {
+function buildMessageContext(frame, account, config, text, mediaList, quoteContent, runtime) {
     const core = getWeComRuntime();
     const body = frame.body;
     const chatId = body.chatid || body.from.userid;
@@ -257,6 +113,24 @@ function buildMessageContext(frame, account, config, text, mediaList, quoteConte
             id: chatId,
         },
     });
+    // ===== 动态 Agent 路由注入 =====
+    const routingResult = processDynamicRouting({
+        route,
+        config,
+        core,
+        accountId: account.accountId,
+        chatType: chatType === "group" ? "group" : "dm",
+        chatId,
+        senderId: body.from.userid,
+        log: runtime?.log ? (...args) => runtime.log?.(...args) : undefined,
+        error: runtime?.error ? (...args) => runtime.error?.(...args) : undefined,
+    });
+    // 应用动态路由结果
+    if (routingResult.routeModified) {
+        route.agentId = routingResult.finalAgentId;
+        route.sessionKey = routingResult.finalSessionKey;
+    }
+    // ===== 动态 Agent 路由注入结束 =====
     // 构建会话标签
     const fromLabel = chatType === "group" ? `group:${chatId}` : `user:${body.from.userid}`;
     // 当只有媒体没有文本时，使用占位符标识媒体类型
@@ -267,8 +141,12 @@ 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,
+    });
     // 构建标准消息上下文
-    return core.channel.reply.finalizeInboundContext({
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
         Body: messageBody,
         RawBody: messageBody,
         CommandBody: messageBody,
@@ -277,7 +155,7 @@ function buildMessageContext(frame, account, config, text, mediaList, quoteConte
         To: `${CHANNEL_ID}:${chatId}`,
         SenderId: body.from.userid,
         SessionKey: route.sessionKey,
-        AccountId: account.accountId,
+        AccountId: route.accountId,
         ChatType: chatType,
         ConversationLabel: fromLabel,
         Timestamp: Date.now(),
@@ -296,6 +174,7 @@ function buildMessageContext(frame, account, config, text, mediaList, quoteConte
         MediaUrls: mediaPaths,
         ReplyToBody: quoteContent,
     });
+    return { ctxPayload, route, storePath, chatId, chatType };
 }
 /**
  * 发送"思考中"消息
@@ -367,68 +246,38 @@ async function sendMediaBatch(ctx, mediaUrls) {
  *    替换掉 thinking 动画，否则 thinking 会一直残留。
  *
  * 关闭策略（按优先级）：
- * 0. [新增] 有模板卡片代码块 → 提取卡片并主动发送，用剩余文本关闭流
  * 1. 有可见文本 → 用完整文本关闭
- * 2. 有媒体成功发送（通过 deliver 回调） → 用友好提示"文件已发送"
- * 3. 媒体发送失败 → 直接用错误摘要替换 thinking
- * 4. 其他 → 用通用"处理完成"提示
- *    （agent 可能已通过内置 message 工具直接发送了文件，
- *    该路径走 outbound.sendMedia 完全绕过 deliver 回调，
- *    所以 state 中无记录，但文件已实际送达）
+ * 2. 有模板卡片发送成功 → "📋 卡片消息已发送。"
+ * 3. 有媒体成功发送（通过 deliver 回调） → 用友好提示"文件已发送"
+ * 4. 媒体发送失败 → 直接用错误摘要替换 thinking
  *
  * 降级策略：
  * - 当 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`);
-    }
-    // ── 模板卡片检测结束 ────────────────────────────────────────────────
+    const visibleText = state.accumulatedText;
     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;
@@ -454,46 +303,11 @@ 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, config, account, wsClient, frame, state, runtime, onCleanup } = params;
+    const { ctxPayload, route, storePath, chatId, chatType, config, account, wsClient, frame, state, runtime, onCleanup } = params;
     const core = getWeComRuntime();
     const ctx = { wsClient, frame, state, account, runtime };
     // 防止 onCleanup 被多次调用（onError 回调与 catch 块可能重复触发）
@@ -506,23 +320,26 @@ 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,
-            // 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) {
@@ -536,11 +353,10 @@ 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 ?? [])}`);
+                    runtime.log?.(`[openclaw -> plugin] kind=${info.kind}, text=${payload.text ?? ''}, mediaUrl=${payload.mediaUrl ?? ''}, mediaUrls=${JSON.stringify(payload.mediaUrls ?? [])}`);
                     // 累积文本
                     if (payload.text) {
-                        state.accumulatedText += (payload.text || '');
+                        state.accumulatedText += `${payload.text || ''}`;
                     }
                     // 发送媒体（统一走主动发送）
                     const mediaUrls = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
@@ -563,12 +379,12 @@ async function routeAndDispatchMessage(params) {
                     // 中间帧：有可见文本时流式更新（流式过期后跳过，等 deliver 完成后主动发送）
                     // 使用 maskTemplateCardBlocks 遮罩正在构建中的模板卡片代码块，
                     // 避免 JSON 源码在流式输出过程中暴露给终端用户
-                    if (info.kind !== "final" && state.accumulatedText && !state.streamExpired) {
+                    if (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`);
-                            }
+                            // 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 });
                         }
                         catch (err) {
@@ -587,15 +403,24 @@ async function routeAndDispatchMessage(params) {
                 },
             },
         });
+        // 模板卡片检测与发送（在关闭 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 流，
-        // 避免 deliver 已成功发送媒体但后续出错时 thinking 消息残留或被错误文案覆盖
+        // 即使 dispatch 抛异常，也需要处理卡片和关闭 thinking 流
         try {
+            const cardResult = await processTemplateCardsIfNeeded({ wsClient, frame, state, account, runtime });
+            if (cardResult) {
+                state.accumulatedText = cardResult.remainingText;
+            }
             await finishThinkingStream(ctx);
         }
         catch (finishErr) {
@@ -605,20 +430,12 @@ async function routeAndDispatchMessage(params) {
     }
 }
 /**
- * 处理企业微信消息（主函数）
- *
- * 处理流程：
- * 1. 解析消息内容（文本、图片、引用）
- * 2. 群组策略检查（仅群聊）
- * 3. DM Policy 访问控制检查（仅私聊）
- * 4. 下载并保存图片
- * 5. 初始化消息状态
- * 6. 发送"思考中"消息
- * 7. 路由消息到核心处理流程
+ * 解析并校验企业微信消息（防抖前阶段：Step 1-4）
  *
- * 整体带超时保护，防止单条消息处理阻塞过久
+ * 执行消息解析、策略检查、媒体下载等前置操作，
+ * 返回一个可用于防抖缓冲的 entry，或 null（消息被过滤/跳过时）。
  */
-async function processWeComMessage(params) {
+async function prepareWeComMessage(params) {
     const { frame, account, config, runtime, wsClient } = params;
     const body = frame.body;
     const chatId = body.chatid || body.from.userid;
@@ -640,7 +457,7 @@ async function processWeComMessage(params) {
     // 如果既没有文本也没有图片也没有文件也没有引用内容，则跳过
     if (!text && imageUrls.length === 0 && fileUrls.length === 0) {
         runtime.log?.("[wecom][plugin] Skipping empty message (no text, image, file or quote)");
-        return;
+        return null;
     }
     // Step 2: 群组策略检查（仅群聊）
     if (chatType === "group") {
@@ -652,7 +469,7 @@ async function processWeComMessage(params) {
             runtime,
         });
         if (!groupPolicyResult.allowed) {
-            return;
+            return null;
         }
     }
     // Step 3: DM Policy 访问控制检查（仅私聊）
@@ -665,7 +482,7 @@ async function processWeComMessage(params) {
         runtime,
     });
     if (!dmPolicyResult.allowed) {
-        return;
+        return null;
     }
     // Step 4: 下载并保存图片和文件
     const [imageMediaList, fileMediaList] = await Promise.all([
@@ -687,6 +504,28 @@ async function processWeComMessage(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");
@@ -701,11 +540,15 @@ async function processWeComMessage(params) {
     //   await sendThinkingReply({ wsClient, frame, streamId, runtime });
     // }
     // Step 7: 构建上下文并路由到核心处理流程（带整体超时保护）
-    const ctxPayload = buildMessageContext(frame, account, config, text, mediaList, quoteContent);
+    const { ctxPayload, route, storePath, chatId: resolvedChatId, chatType } = buildMessageContext(frame, account, config, text, mediaList, quoteContent, runtime);
     // 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,
@@ -749,10 +592,9 @@ function createSdkLogger(runtime, accountId) {
  * 监听企业微信 WebSocket 连接
  * 使用 aibot-node-sdk 简化连接管理
  */
-async function monitorWeComProvider(options) {
+export 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`);
     // 启动消息状态定期清理
     startMessageStateCleanup();
     return new Promise((resolve, reject) => {
@@ -894,13 +736,26 @@ async function monitorWeComProvider(options) {
         // 监听普通消息
         wsClient.on("message", async (frame) => {
             try {
-                await processWeComMessage({
+                const entry = await prepareWeComMessage({
                     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)}`);
@@ -913,7 +768,6 @@ async function monitorWeComProvider(options) {
                 const eventBody = frame.body;
                 const eventType = eventBody.event?.eventtype;
                 runtime.log?.(`[${account.accountId}] Received event callback: eventtype=${eventType ?? ""}, msgid=${eventBody.msgid ?? ""}`);
-                runtime.error?.(`[${account.accountId}] [diag] event-listener fired: eventtype=${eventType ?? ""}, msgid=${eventBody.msgid ?? ""}`);
                 if (eventType !== "template_card_event") {
                     return;
                 }
@@ -930,20 +784,22 @@ async function monitorWeComProvider(options) {
                 catch (updateErr) {
                     runtime.error?.(`[${account.accountId}] [template-card-update] Failed to update template card: ${String(updateErr)}`);
                 }
-                await processWeComMessage({
+                const entry = await prepareWeComMessage({
                     frame,
                     account,
                     config,
                     runtime,
                     wsClient,
                 });
+                if (entry) {
+                    await processWeComMessageNow(entry);
+                }
             }
             catch (err) {
                 runtime.error?.(`[${account.accountId}] Failed to process template_card_event: ${String(err)}`);
             }
         });
         runtime.log?.(`[${account.accountId}] Event listeners attached: message + event(template_card_event)`);
-        runtime.error?.(`[${account.accountId}] [diag] listeners-ready marker`);
         // 启动前预热 reqId 缓存，确保完成后再建立连接，避免 getSync 在预热完成前返回 undefined
         warmupReqIdStore(account.accountId, (...args) => runtime.log?.(...args))
             .then((count) => {
@@ -958,6 +814,3 @@ async function monitorWeComProvider(options) {
         });
     });
 }
-
-export { monitorWeComProvider, sendWeComReply, setReqIdForChat, warmupReqIdStore };
-//# sourceMappingURL=monitor.js.map