@wwlocal/aibot-plugin-node 20260409.20.0

package/dist/cjs/src/monitor.js

@@ -0,0 +1,849 @@
+'use strict';
+
+var aibotNodeSdk = require('@wecom/aibot-node-sdk');
+var _const = require('./const.js');
+var messageParser = require('./message-parser.js');
+var messageSender = require('./message-sender.js');
+var mediaHandler = require('./media-handler.js');
+var mediaUploader = require('./media-uploader.js');
+var templateCardParser = require('./template-card-parser.js');
+var groupPolicy = require('./group-policy.js');
+var dmPolicy = require('./dm-policy.js');
+var stateManager = require('./state-manager.js');
+var caCert = require('./ca-cert.js');
+var version = require('./version.js');
+var agentForwarder = require('./agent-forwarder.js');
+
+/**
+ * 企业微信私有部署 WebSocket 监控器主模块
+ *
+ * 负责：
+ * - 建立和管理 WebSocket 连接
+ * - 协调消息处理流程（解析→策略检查→下载图片→智能体转发→流式回复）
+ * - 资源生命周期管理
+ *
+ * 子模块：
+ * - message-parser.ts       : 消息内容解析
+ * - message-sender.ts       : 消息发送（带超时保护）
+ * - media-handler.ts        : 图片/文件下载和保存（带超时保护）
+ * - media-uploader.ts       : 出站媒体上传+发送
+ * - group-policy.ts         : 群组访问控制
+ * - dm-policy.ts            : 私聊访问控制
+ * - state-manager.ts        : 全局状态管理（带 TTL 清理）
+ * - agent-forwarder.ts      : OpenAI API 兼容智能体转发
+ * - template-card-parser.ts : 模板卡片提取/遮罩
+ * - timeout.ts              : 超时工具
+ */
+/**
+ * 去除文本中的 `<think>...</think>` 标签（支持跨行），返回剩余可见文本。
+ * 用于判断大模型回复中是否包含实际用户可见内容（而非仅有 thinking 推理过程）。
+ */
+function stripThinkTags(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,
+    });
+}
+// ============================================================================
+// 媒体发送错误提示
+// ============================================================================
+/**
+ * 根据媒体发送结果生成纯文本错误摘要（用于替换 thinking 流式消息展示给用户）。
+ *
+ * 使用纯文本而非 markdown 格式，因为 replyStream 只支持纯文本。
+ */
+function buildMediaErrorSummary(mediaUrl, result) {
+    if (result.error?.includes("LocalMediaAccessError")) {
+        return `⚠️ 文件发送失败：没有权限访问路径 ${mediaUrl}\n请在配置文件的 mediaLocalRoots 中添加该路径的父目录后重启生效。`;
+    }
+    if (result.rejectReason) {
+        return `⚠️ 文件发送失败：${result.rejectReason}`;
+    }
+    return `⚠️ 文件发送失败：无法处理文件 ${mediaUrl}，请稍后再试。`;
+}
+/**
+ * 发送"思考中"消息
+ */
+async function sendThinkingReply(params) {
+    const { wsClient, frame, streamId, runtime, state } = params;
+    try {
+        await messageSender.sendWeComReply({
+            wsClient,
+            frame,
+            text: _const.THINKING_MESSAGE,
+            runtime,
+            finish: false,
+            streamId,
+        });
+    }
+    catch (err) {
+        if (err instanceof messageSender.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)}`);
+        }
+    }
+}
+/**
+ * 上传并发送一批媒体文件（统一走主动发送通道）
+ *
+ * replyMedia（被动回复）无法覆盖 replyStream 发出的 thinking 流式消息，
+ * 因此所有媒体统一走 aibot_send_msg 主动发送。
+ */
+async function sendMediaBatch(ctx, mediaUrls) {
+    const { wsClient, frame, state, account, runtime } = ctx;
+    const body = frame.body;
+    const chatId = body.chatid || body.from.userid;
+    const mediaLocalRoots = account.mediaLocalRoots;
+    runtime.log?.(`[wecom][debug] mediaLocalRoots=${JSON.stringify(mediaLocalRoots)}, mediaUrls=${JSON.stringify(mediaUrls)}`);
+    for (const mediaUrl of mediaUrls) {
+        const result = await mediaUploader.uploadAndSendMedia({
+            wsClient,
+            mediaUrl,
+            chatId,
+            mediaLocalRoots,
+            log: (...args) => runtime.log?.(...args),
+            errorLog: (...args) => runtime.error?.(...args),
+        });
+        if (result.ok) {
+            state.hasMedia = true;
+        }
+        else {
+            state.hasMediaFailed = true;
+            runtime.error?.(`[wecom] Media send failed: url=${mediaUrl}, reason=${result.rejectReason || result.error}`);
+            // 收集错误摘要，后续在 finishThinkingStream 中直接替换 thinking 流展示给用户
+            const summary = buildMediaErrorSummary(mediaUrl, result);
+            state.mediaErrorSummary = state.mediaErrorSummary
+                ? `${state.mediaErrorSummary}\n\n${summary}`
+                : summary;
+        }
+    }
+}
+/**
+ * 关闭 thinking 流（发送 finish=true 的流式消息）
+ *
+ * thinking 是通过 replyStream 用 streamId 发的流式消息，
+ * 只有同一 streamId 的 replyStream(finish=true) 才能关闭它。
+ *
+ * ⚠️ 注意：企微会忽略空格等不可见内容，必须用有可见字符的文案才能真正
+ *    替换掉 thinking 动画，否则 thinking 会一直残留。
+ *
+ * 关闭策略（按优先级）：
+ * 0. 有模板卡片代码块 → 提取卡片并主动发送，用剩余文本关闭流
+ * 1. 有可见文本 → 用完整文本关闭
+ * 2. 有媒体成功发送（通过 deliver 回调） → 用友好提示"文件已发送"
+ * 3. 媒体发送失败 → 直接用错误摘要替换 thinking
+ * 4. 其他 → 用通用"处理完成"提示
+ *
+ * 降级策略：
+ * - 当 streamExpired=true（errcode 846608）时，流式通道已不可用（>6分钟），
+ *   改用 wsClient.sendMessage 主动发送完整文本。
+ */
+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);
+    // ── 模板卡片检测与发送 ──────────────────────────────────────────────
+    if (visibleText) {
+        runtime.log?.(`[wecom][template-card] finishThinkingStream: visibleText exists, length=${visibleText.length}, running extractTemplateCards...`);
+        const logFn = (...args) => {
+            runtime.log?.(...args);
+        };
+        const { cards, remainingText } = templateCardParser.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(", ")}]`);
+            // 方案C：先关闭 thinking 流，再发模板卡片
+            //
+            // 原因：sendMessage(template_card) 和 replyStream(finish=true) 都会写会话的
+            // 消息版本号。若先发卡片再关流，两个操作几乎同时触达服务端，导致 errcode=6000
+            // "data version conflict"。调换顺序后，流关闭完成（版本号落定）再追加发卡片，
+            // 两个写操作严格串行，不存在竞争。
+            const trimmedRemaining = stripThinkTags(remainingText);
+            const streamFinishText = trimmedRemaining ? remainingText : "📋 正在发送卡片消息…";
+            runtime.log?.(`[wecom][template-card] finishThinkingStream: closing stream first, finishText="${streamFinishText.slice(0, 100)}"`);
+            await messageSender.sendWeComReply({ wsClient, frame, text: streamFinishText, runtime, finish: true, streamId: state.streamId });
+            // 流已关闭，再发卡片，无版本竞争
+            await sendTemplateCards(ctx, cards);
+            return;
+        }
+    }
+    else {
+        runtime.log?.(`[wecom][template-card] finishThinkingStream: no visibleText, skipping template card extraction`);
+    }
+    // ── 模板卡片检测结束 ────────────────────────────────────────────────
+    let finishText = state.accumulatedText;
+    if (visibleText) {
+        finishText = state.accumulatedText;
+    }
+    else if (state.hasMedia) {
+        if (state.hasMediaFailed && state.mediaErrorSummary) {
+            finishText = finishText ? `${finishText}\n\n${state.mediaErrorSummary}` : state.mediaErrorSummary;
+        }
+        else if (!finishText) {
+            finishText = "📎 文件已发送，请查收。";
+        }
+    }
+    if (finishText) {
+        // 尝试流式发送；若已知过期或发送时发现过期，统一降级为主动发送
+        let expired = state.streamExpired;
+        if (!expired) {
+            try {
+                await messageSender.sendWeComReply({ wsClient, frame, text: finishText, runtime, finish: true, streamId: state.streamId });
+            }
+            catch (err) {
+                if (err instanceof messageSender.StreamExpiredError) {
+                    expired = true;
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        if (expired) {
+            // 降级走 sendMessage：企微 markdown 消息不支持 <think> 标签渲染，
+            // 使用 stripThinkTags 后的纯可见文本，避免 thinking 内容裸露显示
+            const proactiveText = stripThinkTags(finishText) || finishText;
+            runtime.log?.(`[wecom] Stream expired, sending final text via sendMessage (proactive), length=${proactiveText.length}`);
+            await wsClient.sendMessage(chatId, {
+                msgtype: "markdown",
+                markdown: { content: proactiveText },
+            });
+        }
+    }
+}
+/**
+ * 逐个发送已提取的模板卡片（通过 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)}`);
+        }
+    }
+}
+/**
+ * 将消息转发到智能体并处理回复
+ *
+ * 替换原 OpenClaw 的 routeAndDispatchMessage:
+ * - resolveAgentRoute → 直接使用配置中的 agent 端点
+ * - dispatchReplyWithBufferedBlockDispatcher → forwardToAgent + deliver 回调
+ * - finalizeInboundContext → 直接构建转发参数
+ */
+async function routeAndDispatchToAgent(params) {
+    const { text, mediaPaths, quoteContent, account, wsClient, frame, state, runtime, onCleanup } = params;
+    const ctx = { wsClient, frame, state, account, runtime };
+    const body = frame.body;
+    // 提取聊天上下文（用于对话历史管理）
+    const chatId = body.chatid || body.from.userid;
+    const userId = body.from.userid;
+    const chatType = body.chattype === "group" ? "group" : "single";
+    // 防止 onCleanup 被多次调用
+    let cleanedUp = false;
+    const safeCleanup = () => {
+        if (!cleanedUp) {
+            cleanedUp = true;
+            onCleanup();
+        }
+    };
+    let isShowThink = !(account.sendThinkingMessage ?? true);
+    // monitor 层统一节流：闭包变量
+    let lastDeliverTime = 0;
+    let lastDeliverLen = 0;
+    try {
+        await agentForwarder.forwardToAgent({
+            text,
+            mediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+            quoteContent,
+            agent: account.agent,
+            runtime,
+            abortSignal: undefined,
+            context: {
+                accountId: account.accountId,
+                chatId,
+                userId,
+                chatType,
+            },
+            onReplyStart: async () => {
+                // 首次收到 AI 回复时发送 thinking 消息
+                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;
+                // 累积文本（适配器传入完整累积文本，直接赋值）
+                if (payload.text) {
+                    state.accumulatedText = payload.text;
+                }
+                // 仅在 final 帧输出详细日志
+                if (info.kind === "final") {
+                    runtime.log?.(`[wecom][deliver] kind=${info.kind}, textLen=${payload.text?.length ?? 0}, accLen=${state.accumulatedText.length}`);
+                }
+                // 发送媒体（统一走主动发送）
+                const mediaUrls = payload.mediaUrls?.length ? payload.mediaUrls : payload.mediaUrl ? [payload.mediaUrl] : [];
+                if (mediaUrls.length > 0) {
+                    try {
+                        await sendMediaBatch(ctx, mediaUrls);
+                    }
+                    catch (mediaErr) {
+                        state.hasMediaFailed = true;
+                        const errMsg = String(mediaErr);
+                        const summary = `⚠️ 文件发送失败：内部处理异常，请稍后重试。\n错误详情：${errMsg}`;
+                        state.mediaErrorSummary = state.mediaErrorSummary
+                            ? `${state.mediaErrorSummary}\n\n${summary}`
+                            : summary;
+                        runtime.error?.(`[wecom] sendMediaBatch threw: ${errMsg}`);
+                    }
+                }
+                // 中间帧：有可见内容时流式更新（流式过期后跳过）
+                // 关键说明：
+                // 1. 用 stripThinkTags 判断是否已进入 text 阶段（纯 thinking 阶段跳过，让企微继续显示 thinking 动画）
+                // 2. 实际发送的是完整的 accumulatedText（含 <think> 标签），保证企微客户端在整个流式过程中
+                //    都能正确识别和渲染 thinking 折叠块。如果中间帧发纯 content，final 帧再发含 <think> 的
+                //    完整文本，企微客户端将无法正确渲染 thinking 内容。
+                // 3. monitor 层统一节流（时间+增量双重条件），替代各适配器的分散节流
+                // 4. 首帧立即发送，不受节流限制
+                if (info.kind !== "final" && state.accumulatedText && !state.streamExpired) {
+                    const visibleText = stripThinkTags(state.accumulatedText);
+                    // 只有有可见内容才发送（纯 thinking 阶段跳过，企微继续显示 thinking 动画）
+                    if (visibleText) {
+                        // monitor 层统一节流
+                        const now = Date.now();
+                        const isFirst = lastDeliverTime === 0;
+                        const elapsed = now - lastDeliverTime;
+                        const delta = visibleText.length - lastDeliverLen;
+                        if (isFirst || (elapsed >= _const.MONITOR_DELIVER_THROTTLE_MS && delta >= _const.MONITOR_DELIVER_MIN_DELTA)) {
+                            try {
+                                // 中间帧发送完整的 accumulatedText（含 <think> 标签），对其中非 think 部分做模板卡片遮罩
+                                const displayText = templateCardParser.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 messageSender.sendWeComReply({ wsClient, frame, text: displayText, runtime, finish: false, streamId: state.streamId });
+                                lastDeliverTime = Date.now();
+                                lastDeliverLen = visibleText.length;
+                            }
+                            catch (err) {
+                                if (err instanceof messageSender.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 流
+        await finishThinkingStream(ctx);
+        safeCleanup();
+    }
+    catch (err) {
+        runtime.error?.(`[wecom][plugin] Failed to process message: ${String(err)}`);
+        // 即使转发抛异常，也需要关闭 thinking 流
+        try {
+            await finishThinkingStream(ctx);
+        }
+        catch (finishErr) {
+            runtime.error?.(`[wecom] Failed to finish thinking stream after dispatch error: ${String(finishErr)}`);
+        }
+        safeCleanup();
+    }
+}
+/**
+ * 处理企业微信消息（主函数）
+ *
+ * 处理流程：
+ * 1. 解析消息内容（文本、图片、引用）
+ * 2. 群组策略检查（仅群聊）
+ * 3. DM Policy 访问控制检查（仅私聊）
+ * 4. 下载并保存图片和文件
+ * 5. 初始化消息状态
+ * 6. 转发到智能体并流式回复
+ *
+ * 整体带超时保护，防止单条消息处理阻塞过久
+ */
+async function processWeComMessage(params) {
+    const { frame, account, config, runtime, wsClient } = params;
+    const body = frame.body;
+    const chatId = body.chatid || body.from.userid;
+    const chatType = body.chattype === "group" ? "group" : "direct";
+    const messageId = body.msgid;
+    const reqId = frame.headers.req_id;
+    // Step 1: 解析消息内容
+    const { textParts, imageUrls, imageAesKeys, fileUrls, fileAesKeys, quoteContent } = messageParser.parseMessageContent(body);
+    let text = textParts.join("\n").trim();
+    // 如果文本为空但存在引用消息，使用引用消息内容
+    if (!text && quoteContent) {
+        text = quoteContent;
+        runtime.log?.("[wecom][plugin] Using quote content as message body (user only mentioned bot)");
+    }
+    // 如果既没有文本也没有图片也没有文件也没有引用内容，则跳过
+    if (!text && imageUrls.length === 0 && fileUrls.length === 0) {
+        runtime.log?.("[wecom][plugin] Skipping empty message (no text, image, file or quote)");
+        return;
+    }
+    // Step 2: 群组策略检查（仅群聊）
+    if (chatType === "group") {
+        const groupPolicyResult = groupPolicy.checkGroupPolicy({
+            chatId,
+            senderId: body.from.userid,
+            account,
+            runtime,
+        });
+        if (!groupPolicyResult.allowed) {
+            return;
+        }
+    }
+    // Step 3: DM Policy 访问控制检查（仅私聊）
+    const dmPolicyResult = await dmPolicy.checkDmPolicy({
+        senderId: body.from.userid,
+        isGroup: chatType === "group",
+        account,
+        runtime,
+    });
+    if (!dmPolicyResult.allowed) {
+        return;
+    }
+    // Step 4: 下载并保存图片和文件
+    const [imageMediaList, fileMediaList] = await Promise.all([
+        mediaHandler.downloadAndSaveImages({
+            imageUrls,
+            imageAesKeys,
+            account,
+            config,
+            runtime,
+            wsClient,
+        }),
+        mediaHandler.downloadAndSaveFiles({
+            fileUrls,
+            fileAesKeys,
+            account,
+            config,
+            runtime,
+            wsClient,
+        }),
+    ]);
+    const mediaList = [...imageMediaList, ...fileMediaList];
+    // Step 5: 初始化消息状态
+    stateManager.setReqIdForChat(chatId, reqId, account.accountId);
+    const streamId = aibotNodeSdk.generateReqId("stream");
+    const state = { accumulatedText: "", streamId };
+    stateManager.setMessageState(messageId, state);
+    const cleanupState = () => {
+        stateManager.deleteMessageState(messageId);
+    };
+    // Step 6: 转发到智能体并处理回复（带整体超时保护）
+    try {
+        await routeAndDispatchToAgent({
+            text,
+            mediaPaths: mediaList,
+            quoteContent,
+            account,
+            config,
+            wsClient,
+            frame,
+            state,
+            runtime,
+            onCleanup: cleanupState,
+        });
+    }
+    catch (err) {
+        runtime.error?.(`[wecom][plugin] Message processing failed: ${String(err)}`);
+        cleanupState();
+    }
+}
+// ============================================================================
+// 创建 SDK Logger 适配器
+// ============================================================================
+/**
+ * 创建适配 RuntimeLogger 的 SDK Logger
+ */
+function createSdkLogger(runtime, accountId) {
+    return {
+        debug: (message, ...args) => {
+            runtime.log?.(`[${accountId}] ${message}`, ...args);
+        },
+        info: (message, ...args) => {
+            runtime.log?.(`[${accountId}] ${message}`, ...args);
+        },
+        warn: (message, ...args) => {
+            runtime.log?.(`[${accountId}] WARN: ${message}`, ...args);
+        },
+        error: (message, ...args) => {
+            runtime.error?.(`[${accountId}] ${message}`, ...args);
+        },
+    };
+}
+// ============================================================================
+// 主函数
+// ============================================================================
+/**
+ * 监听企业微信私有部署 WebSocket 连接
+ * 使用 aibot-node-sdk 简化连接管理
+ */
+async function monitorWeComProvider(options) {
+    const { account, config, runtime, abortSignal, setStatus } = options;
+    runtime.log?.(`[${account.accountId}] [${version.PLUGIN_VERSION}] Initializing WSClient with SDK...`);
+    // 前置校验：websocketUrl 为空时无法建立连接，直接报错退出
+    if (!account.websocketUrl?.trim()) {
+        const errorMsg = `WebSocket URL 未配置，无法启动连接。请在配置文件的 accounts 中配置有效的 websocketUrl 地址。`;
+        runtime.error?.(`[${account.accountId}] ${errorMsg}`);
+        setStatus?.({
+            accountId: account.accountId,
+            running: false,
+            lastError: errorMsg,
+            lastStopAt: Date.now(),
+        });
+        return;
+    }
+    // 如果配置了自签名 CA 证书，在创建任何网络连接之前注入到 Node.js 全局 TLS 层
+    if (account.caCert) {
+        const injected = caCert.injectCaCert(account.caCert, (...args) => runtime.log?.(...args));
+        if (!injected) {
+            runtime.log?.(`[${account.accountId}] ⚠️ CA 证书注入失败，TLS 连接到私有部署服务可能会失败。请检查证书文件是否存在且为有效 PEM 格式。`);
+        }
+    }
+    // 启动消息状态定期清理
+    stateManager.startMessageStateCleanup();
+    return new Promise((resolve, reject) => {
+        const logger = createSdkLogger(runtime, account.accountId);
+        const wsClient = new aibotNodeSdk.WSClient({
+            botId: account.botId,
+            secret: account.secret,
+            wsUrl: account.websocketUrl,
+            logger,
+            heartbeatInterval: _const.WS_HEARTBEAT_INTERVAL_MS,
+            maxReconnectAttempts: _const.WS_MAX_RECONNECT_ATTEMPTS,
+            maxAuthFailureAttempts: _const.WS_MAX_AUTH_FAILURE_ATTEMPTS,
+            scene: _const.SCENE_WECOM_AIBOT,
+            plug_version: version.PLUGIN_VERSION,
+        });
+        // 防止 cleanup 被多次调用
+        let cleanedUp = false;
+        const cleanup = async () => {
+            if (cleanedUp)
+                return;
+            cleanedUp = true;
+            stateManager.stopMessageStateCleanup();
+            if (account.caCert) {
+                caCert.removeCaCertPatch((...args) => runtime.log?.(...args));
+            }
+            await stateManager.cleanupAccount(account.accountId);
+        };
+        // 处理中止信号
+        if (abortSignal) {
+            abortSignal.addEventListener("abort", async () => {
+                runtime.log?.(`[${account.accountId}] Connection aborted`);
+                wsClient.disconnect();
+                await cleanup();
+                resolve();
+            });
+        }
+        // 监听连接事件
+        wsClient.on("connected", () => {
+            runtime.log?.(`[${account.accountId}] WebSocket connected`);
+            setStatus?.({
+                accountId: account.accountId,
+                running: true,
+                lastConnectedAt: Date.now(),
+            });
+        });
+        // 监听认证成功事件
+        wsClient.on("authenticated", () => {
+            runtime.log?.(`[${account.accountId}] Authentication successful`);
+            stateManager.setWeComWebSocket(account.accountId, wsClient);
+        });
+        // 监听断开事件
+        wsClient.on("disconnected", (reason) => {
+            runtime.log?.(`[${account.accountId}] WebSocket disconnected: ${reason}`);
+        });
+        // 监听被踢下线事件
+        wsClient.on("event.disconnected_event", async () => {
+            const errorMsg = `Kicked by server: a new connection was established elsewhere. Auto-restart is suppressed to avoid mutual kicking. Please check for duplicate instances.`;
+            runtime.error?.(`[${account.accountId}] ${errorMsg}`);
+            wsClient.disconnect();
+            await cleanup();
+            setStatus?.({
+                accountId: account.accountId,
+                running: false,
+                lastError: errorMsg,
+                lastStopAt: Date.now(),
+            });
+            // Promise 保持 pending，不触发 auto-restart
+        });
+        // 监听重连事件
+        wsClient.on("reconnecting", (attempt) => {
+            runtime.log?.(`[${account.accountId}] Reconnecting attempt ${attempt}...`);
+        });
+        // 监听错误事件
+        wsClient.on("error", async (error) => {
+            runtime.error?.(`[${account.accountId}] WebSocket error: ${error.message}`);
+            if (error instanceof aibotNodeSdk.WSAuthFailureError) {
+                const errorMsg = `Auth failure attempts exhausted (${_const.WS_MAX_AUTH_FAILURE_ATTEMPTS} attempts). Please check botId/secret configuration.`;
+                runtime.error?.(`[${account.accountId}] ${errorMsg}`);
+                wsClient.disconnect();
+                await cleanup();
+                setStatus?.({
+                    accountId: account.accountId,
+                    running: false,
+                    lastError: errorMsg,
+                    lastStopAt: Date.now(),
+                });
+                return;
+            }
+            if (error instanceof aibotNodeSdk.WSReconnectExhaustedError) {
+                wsClient.disconnect();
+                cleanup().finally(() => reject(error));
+                return;
+            }
+        });
+        // 监听版本检查事件
+        wsClient.on(_const.EVENT_ENTER_CHECK_UPDATE, async (frame) => {
+            try {
+                await wsClient.reply(frame, { version: version.PLUGIN_VERSION }, _const.CMD_ENTER_EVENT_REPLY);
+            }
+            catch (err) {
+                // 版本检查回复失败不影响主流程
+            }
+        });
+        // 监听普通消息
+        wsClient.on("message", async (frame) => {
+            try {
+                await processWeComMessage({
+                    frame,
+                    account,
+                    config,
+                    runtime,
+                    wsClient,
+                });
+            }
+            catch (err) {
+                runtime.error?.(`[${account.accountId}] Failed to process message: ${String(err)}`);
+            }
+        });
+        // 监听事件回调（aibot_event_callback）
+        wsClient.on("event", async (frame) => {
+            try {
+                const eventBody = frame.body;
+                const eventType = eventBody.event?.eventtype;
+                runtime.log?.(`[${account.accountId}] Received event callback: eventtype=${eventType ?? ""}, msgid=${eventBody.msgid ?? ""}`);
+                if (eventType !== "template_card_event") {
+                    return;
+                }
+                const templateCardEvent = eventBody.event?.template_card_event;
+                runtime.log?.(`[${account.accountId}] Received template_card_event: event_key=${templateCardEvent?.event_key ?? ""}, task_id=${templateCardEvent?.task_id ?? ""}`);
+                try {
+                    await updateTemplateCardOnEvent({
+                        frame,
+                        accountId: account.accountId,
+                        runtime,
+                        wsClient,
+                    });
+                }
+                catch (updateErr) {
+                    runtime.error?.(`[${account.accountId}] [template-card-update] Failed to update template card: ${String(updateErr)}`);
+                }
+                await processWeComMessage({
+                    frame,
+                    account,
+                    config,
+                    runtime,
+                    wsClient,
+                });
+            }
+            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)`);
+        // 启动前预热 reqId 缓存
+        stateManager.warmupReqIdStore(account.accountId, (...args) => runtime.log?.(...args))
+            .then((count) => {
+            runtime.log?.(`[${account.accountId}] Warmed up ${count} reqId entries from disk`);
+        })
+            .catch((err) => {
+            runtime.error?.(`[${account.accountId}] Failed to warmup reqId store: ${String(err)}`);
+        })
+            .finally(() => {
+            wsClient.connect();
+        });
+    });
+}
+
+Object.defineProperty(exports, "WeComCommand", {
+    enumerable: true,
+    get: function () { return _const.WeComCommand; }
+});
+exports.sendWeComReply = messageSender.sendWeComReply;
+exports.setReqIdForChat = stateManager.setReqIdForChat;
+exports.warmupReqIdStore = stateManager.warmupReqIdStore;
+exports.monitorWeComProvider = monitorWeComProvider;