@wecom/wecom-openclaw-plugin 2026.4.10-beta.1 → 2026.4.21-beta.0

package/dist/src/mcp/transport.js

@@ -26,6 +26,8 @@ const HTTP_REQUEST_TIMEOUT_MS = 30_000;
 export const MEDIA_DOWNLOAD_TIMEOUT_MS = 120_000;
 /** 日志前缀 */
 const LOG_TAG = "[mcp]";
+/** 请求 MCP Server 时透传可信企业微信 userid 的 header 名 */
+export const WECOM_USERID_HEADER = "x-openclaw-wecom-userid";
 /**
  * MCP JSON-RPC 错误
  *
@@ -68,13 +70,22 @@ export class McpHttpError extends Error {
  * - -32003: 认证失败（Auth Failed）
  */
 const CACHE_CLEAR_ERROR_CODES = new Set([-32001, -32002, -32003]);
-/** MCP 配置缓存：category → response.body（完整配置） */
+/**
+ * 生成多账号感知的缓存 key
+ *
+ * 不同账号的同一 category 对应不同的 MCP Server（URL、凭据均不同），
+ * 必须用 accountId:category 的复合键隔离，避免跨账号缓存污染。
+ */
+function cacheKey(accountId, category) {
+    return `${accountId}:${category}`;
+}
+/** MCP 配置缓存：accountId:category → response.body（完整配置） */
 const mcpConfigCache = new Map();
-/** Streamable HTTP 会话缓存：category → session */
+/** Streamable HTTP 会话缓存：accountId:category → session */
 const mcpSessionCache = new Map();
-/** 已确认为无状态的 MCP Server 品类集合（跳过后续握手） */
+/** 已确认为无状态的 MCP Server 集合（跳过后续握手），key 为 accountId:category */
 const statelessCategories = new Set();
-/** 正在进行中的 initialize 请求（防止并发重复初始化），key 为 category */
+/** 正在进行中的 initialize 请求（防止并发重复初始化），key 为 accountId:category */
 const inflightInitRequests = new Map();
 // ============================================================================
 // MCP 配置拉取与缓存
@@ -118,7 +129,7 @@ function resolveMcpAccountId(cfg) {
  * 2. 第一个配置了 botId + secret 的长连接账户
  * 3. 无可用长连接账户时回退到默认账户（会导致后续 WSClient 获取失败）
  */
-function resolveCurrentAccountId() {
+export function resolveCurrentAccountId() {
     try {
         const core = getWeComRuntime();
         const cfg = core.config.loadConfig();
@@ -138,13 +149,11 @@ function resolveCurrentAccountId() {
 /**
  * 通过 WSClient 拉取指定 category 的 MCP 完整配置
  *
- * 自动根据 defaultAccount 配置获取对应账户的 WSClient，无需手动传入 accountId。
- *
+ * @param accountId - 账户 ID，决定使用哪个 WSClient
  * @param category - MCP 品类名称，如 doc、contact
  * @returns 完整的 response.body 配置对象（至少包含 url 字段）
  */
-async function fetchMcpConfig(category) {
-    const accountId = resolveCurrentAccountId();
+async function fetchMcpConfig(accountId, category) {
     const wsClient = getWeComWebSocket(accountId);
     if (!wsClient) {
         throw new Error(`WSClient 未连接 (accountId="${accountId}")，无法拉取 MCP 配置`);
@@ -168,19 +177,21 @@ async function fetchMcpConfig(category) {
  *
  * 优先从内存缓存中读取，未命中时通过 WSClient 拉取并缓存。
  *
+ * @param accountId - 账户 ID
  * @param category - MCP 品类名称
  * @returns MCP Server URL
  */
-async function getMcpUrl(category) {
+async function getMcpUrl(accountId, category) {
+    const key = cacheKey(accountId, category);
     // 查内存缓存
-    const cached = mcpConfigCache.get(category);
+    const cached = mcpConfigCache.get(key);
     if (cached)
         return cached.url;
     // 缓存未命中，通过 WSClient 拉取
-    const body = await fetchMcpConfig(category);
+    const body = await fetchMcpConfig(accountId, category);
     // 写入缓存
-    mcpConfigCache.set(category, body);
-    console.log(`${LOG_TAG} getMcpUrl ${category}: ${body.url}`);
+    mcpConfigCache.set(key, body);
+    console.log(`${LOG_TAG} getMcpUrl ${accountId}/${category}: ${body.url}`);
     return body.url;
 }
 // ============================================================================
@@ -192,7 +203,7 @@ async function getMcpUrl(category) {
  * 自动携带 Mcp-Session-Id 请求头（如果有），
  * 并从响应头中更新 sessionId。
  */
-async function sendRawJsonRpc(url, session, body, timeoutMs = HTTP_REQUEST_TIMEOUT_MS) {
+async function sendRawJsonRpc(url, session, body, timeoutMs = HTTP_REQUEST_TIMEOUT_MS, requesterUserId) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     const headers = {
@@ -203,6 +214,11 @@ async function sendRawJsonRpc(url, session, body, timeoutMs = HTTP_REQUEST_TIMEO
     if (session.sessionId) {
         headers["Mcp-Session-Id"] = session.sessionId;
     }
+    const normalizedRequesterUserId = requesterUserId?.trim();
+    if (normalizedRequesterUserId) {
+        headers[WECOM_USERID_HEADER] = normalizedRequesterUserId;
+    }
+    console.log(`${LOG_TAG} sendRawJsonRpc → ${body.method} | ${WECOM_USERID_HEADER}: ${headers[WECOM_USERID_HEADER] ?? "(not set)"}`);
     let response;
     try {
         response = await fetch(url, {
@@ -256,9 +272,10 @@ async function sendRawJsonRpc(url, session, body, timeoutMs = HTTP_REQUEST_TIMEO
  * 发送 initialize → 接收 serverInfo → 发送 initialized 通知。
  * 如果服务端未返回 Mcp-Session-Id，则标记为无状态模式，后续请求跳过 session 管理。
  */
-async function initializeSession(url, category) {
+async function initializeSession(url, accountId, category, requesterUserId) {
+    const key = cacheKey(accountId, category);
     const session = { sessionId: null, initialized: false, stateless: false };
-    console.log(`${LOG_TAG} 开始 initialize 握手 (category="${category}")`);
+    console.log(`${LOG_TAG} 开始 initialize 握手 (accountId="${accountId}", category="${category}")`);
     // 1. 发送 initialize 请求
     const initBody = {
         jsonrpc: "2.0",
@@ -270,7 +287,7 @@ async function initializeSession(url, category) {
             clientInfo: { name: "wecom_mcp", version: "1.0.0" },
         },
     };
-    const { newSessionId: initSessionId } = await sendRawJsonRpc(url, session, initBody);
+    const { newSessionId: initSessionId } = await sendRawJsonRpc(url, session, initBody, HTTP_REQUEST_TIMEOUT_MS, requesterUserId);
     // 用返回的 newSessionId 更新 session（不再依赖副作用修改）
     if (initSessionId) {
         session.sessionId = initSessionId;
@@ -280,9 +297,9 @@ async function initializeSession(url, category) {
     if (!session.sessionId) {
         session.stateless = true;
         session.initialized = true;
-        statelessCategories.add(category);
-        mcpSessionCache.set(category, session);
-        console.log(`${LOG_TAG} 无状态 Server 确认 (category="${category}")`);
+        statelessCategories.add(key);
+        mcpSessionCache.set(key, session);
+        console.log(`${LOG_TAG} 无状态 Server 确认 (accountId="${accountId}", category="${category}")`);
         return session;
     }
     // 2. 发送 initialized 通知（JSON-RPC notification 不带 id 字段）
@@ -291,14 +308,14 @@ async function initializeSession(url, category) {
         method: "notifications/initialized",
     };
     // initialized 通知不需要等待响应，但 Streamable HTTP 要求通过 POST 发送
-    const { newSessionId: notifySessionId } = await sendRawJsonRpc(url, session, notifyBody);
+    const { newSessionId: notifySessionId } = await sendRawJsonRpc(url, session, notifyBody, HTTP_REQUEST_TIMEOUT_MS, requesterUserId);
     // 如果 initialized 通知的响应也携带了 sessionId，以最新的为准
     if (notifySessionId) {
         session.sessionId = notifySessionId;
     }
     session.initialized = true;
-    mcpSessionCache.set(category, session);
-    console.log(`${LOG_TAG} 有状态 Session 建立成功 (category="${category}", sessionId="${session.sessionId}")`);
+    mcpSessionCache.set(key, session);
+    console.log(`${LOG_TAG} 有状态 Session 建立成功 (accountId="${accountId}", category="${category}", sessionId="${session.sessionId}")`);
     return session;
 }
 /**
@@ -308,25 +325,26 @@ async function initializeSession(url, category) {
  * - 已有可用有状态会话：直接返回缓存
  * - 其他情况：执行 initialize 握手，并发请求会被合并
  */
-async function getOrCreateSession(url, category) {
+async function getOrCreateSession(url, accountId, category, requesterUserId) {
+    const key = cacheKey(accountId, category);
     // 已确认为无状态的 Server，直接返回空 session 跳过握手
-    if (statelessCategories.has(category)) {
-        const cached = mcpSessionCache.get(category);
+    if (statelessCategories.has(key)) {
+        const cached = mcpSessionCache.get(key);
         if (cached)
             return cached;
         // 首次发现被清除（理论上不会走到这里），重新走握手探测
     }
-    const cached = mcpSessionCache.get(category);
+    const cached = mcpSessionCache.get(key);
     if (cached?.initialized)
         return cached;
     // 防止并发重复初始化
-    const inflight = inflightInitRequests.get(category);
+    const inflight = inflightInitRequests.get(key);
     if (inflight)
         return inflight;
-    const promise = initializeSession(url, category).finally(() => {
-        inflightInitRequests.delete(category);
+    const promise = initializeSession(url, accountId, category, requesterUserId).finally(() => {
+        inflightInitRequests.delete(key);
     });
-    inflightInitRequests.set(category, promise);
+    inflightInitRequests.set(key, promise);
     return promise;
 }
 // ============================================================================
@@ -383,18 +401,47 @@ async function parseSseResponse(response) {
 // 公共 API
 // ============================================================================
 /**
- * 清理指定品类的所有 MCP 缓存（配置、会话、无状态标记）
+ * 清理指定账户+品类的所有 MCP 缓存（配置、会话、无状态标记）
  *
  * 当 MCP Server 返回特定错误码时调用，确保下次请求重新拉取配置并重建会话。
  *
+ * @param accountId - 账户 ID
  * @param category - MCP 品类名称
  */
-export function clearCategoryCache(category) {
-    console.log(`${LOG_TAG} 清理缓存 (category="${category}")`);
-    mcpConfigCache.delete(category);
-    mcpSessionCache.delete(category);
-    statelessCategories.delete(category);
-    inflightInitRequests.delete(category);
+export function clearCategoryCache(accountId, category) {
+    const key = cacheKey(accountId, category);
+    console.log(`${LOG_TAG} 清理缓存 (accountId="${accountId}", category="${category}")`);
+    mcpConfigCache.delete(key);
+    mcpSessionCache.delete(key);
+    statelessCategories.delete(key);
+    inflightInitRequests.delete(key);
+}
+/**
+ * 清理指定账户下所有品类的 MCP 缓存
+ *
+ * 适用于账户掉线、凭据变更等需要整体清理的场景。
+ *
+ * @param accountId - 账户 ID
+ */
+export function clearAccountCache(accountId) {
+    const prefix = `${accountId}:`;
+    console.log(`${LOG_TAG} 清理账户所有缓存 (accountId="${accountId}")`);
+    for (const key of mcpConfigCache.keys()) {
+        if (key.startsWith(prefix))
+            mcpConfigCache.delete(key);
+    }
+    for (const key of mcpSessionCache.keys()) {
+        if (key.startsWith(prefix))
+            mcpSessionCache.delete(key);
+    }
+    for (const key of statelessCategories) {
+        if (key.startsWith(prefix))
+            statelessCategories.delete(key);
+    }
+    for (const key of inflightInitRequests.keys()) {
+        if (key.startsWith(prefix))
+            inflightInitRequests.delete(key);
+    }
 }
 /**
  * 发送 JSON-RPC 请求到 MCP Server（Streamable HTTP 协议）
@@ -403,24 +450,30 @@ export function clearCategoryCache(category) {
  * - 无状态 Server：跳过 session 管理，直接发送请求
  * - 有状态 Server：首次调用先执行 initialize 握手，session 失效（404）时自动重建并重试
  *
+ * accountId 优先使用 options.accountId（由工具工厂从 ctx.agentAccountId 传入），
+ * 未提供时 fallback 到 resolveCurrentAccountId()。解析结果贯穿整条调用链，避免跨账号污染。
+ *
  * @param category - MCP 品类名称
  * @param method - JSON-RPC 方法名
  * @param params - JSON-RPC 参数
- * @param options - 可选配置（如自定义超时）
+ * @param options - 可选配置（如自定义超时、指定账户）
  * @returns JSON-RPC result
  */
 export async function sendJsonRpc(category, method, params, options) {
-    const url = await getMcpUrl(category);
+    const accountId = options?.accountId?.trim() || resolveCurrentAccountId();
+    const key = cacheKey(accountId, category);
+    const url = await getMcpUrl(accountId, category);
     const timeoutMs = options?.timeoutMs;
+    const requesterUserId = options?.requesterUserId;
     const body = {
         jsonrpc: "2.0",
         id: generateReqId("mcp_rpc"),
         method,
         ...(params !== undefined ? { params } : {}),
     };
-    let session = await getOrCreateSession(url, category);
+    let session = await getOrCreateSession(url, accountId, category, requesterUserId);
     try {
-        const { rpcResult, newSessionId } = await sendRawJsonRpc(url, session, body, timeoutMs);
+        const { rpcResult, newSessionId } = await sendRawJsonRpc(url, session, body, timeoutMs, requesterUserId);
         // 用最新的 sessionId 更新 session
         if (newSessionId) {
             session.sessionId = newSessionId;
@@ -430,7 +483,7 @@ export async function sendJsonRpc(category, method, params, options) {
     catch (err) {
         // 特定 JSON-RPC 错误码触发缓存清理（统一在传输层处理，上层无需关心）
         if (err instanceof McpRpcError && CACHE_CLEAR_ERROR_CODES.has(err.code)) {
-            clearCategoryCache(category);
+            clearCategoryCache(accountId, category);
         }
         // 无状态 Server 不存在 session 失效问题，直接抛出错误
         if (session.stateless)
@@ -438,18 +491,18 @@ export async function sendJsonRpc(category, method, params, options) {
         // 有状态 Server：session 失效时服务端返回 404，需要重新初始化并重试一次
         // 使用 McpHttpError.statusCode 精确匹配，避免字符串匹配 "404" 导致误判
         if (err instanceof McpHttpError && err.statusCode === 404) {
-            console.log(`${LOG_TAG} Session 失效 (category="${category}")，开始重建...`);
-            mcpSessionCache.delete(category);
+            console.log(`${LOG_TAG} Session 失效 (accountId="${accountId}", category="${category}")，开始重建...`);
+            mcpSessionCache.delete(key);
             // 使用 rebuildSession 合并并发的 session 重建请求，避免竞态条件
-            session = await rebuildSession(url, category);
-            const { rpcResult, newSessionId } = await sendRawJsonRpc(url, session, body, timeoutMs);
+            session = await rebuildSession(url, accountId, category, requesterUserId);
+            const { rpcResult, newSessionId } = await sendRawJsonRpc(url, session, body, timeoutMs, requesterUserId);
             if (newSessionId) {
                 session.sessionId = newSessionId;
             }
             return rpcResult;
         }
         // 其他错误记录日志后抛出
-        console.error(`${LOG_TAG} RPC 请求失败 (category="${category}", method="${method}"): ${err instanceof Error ? err.message : String(err)}`);
+        console.error(`${LOG_TAG} RPC 请求失败 (accountId="${accountId}", category="${category}", method="${method}"): ${err instanceof Error ? err.message : String(err)}`);
         throw err;
     }
 }
@@ -459,13 +512,14 @@ export async function sendJsonRpc(category, method, params, options) {
  * 与 getOrCreateSession 类似，使用 inflightInitRequests 防止
  * 多个并发请求同时遇到 404 时重复执行 initialize 握手。
  */
-async function rebuildSession(url, category) {
-    const inflight = inflightInitRequests.get(category);
+async function rebuildSession(url, accountId, category, requesterUserId) {
+    const key = cacheKey(accountId, category);
+    const inflight = inflightInitRequests.get(key);
     if (inflight)
         return inflight;
-    const promise = initializeSession(url, category).finally(() => {
-        inflightInitRequests.delete(category);
+    const promise = initializeSession(url, accountId, category, requesterUserId).finally(() => {
+        inflightInitRequests.delete(key);
     });
-    inflightInitRequests.set(category, promise);
+    inflightInitRequests.set(key, promise);
     return promise;
 }

package/dist/src/message-parser.d.ts

@@ -11,6 +11,8 @@ export interface MessageBody {
     from: {
         corpid?: string;
         userid: string;
+        /** 会话 ID（权限变更事件回调中携带） */
+        chat_id?: string;
     };
     response_url?: string;
     msgtype: string;
@@ -72,6 +74,11 @@ export interface MessageBody {
                 }>;
             };
         };
+        /** 权限变更事件回调（如文档授权） */
+        auth_change_event?: {
+            /** 当前权限列表：1-新建和编辑文档；2-获取成员文档内容 */
+            auth_list?: number[];
+        };
     };
 }
 export interface ParsedMessageContent {

package/dist/src/message-parser.js

@@ -46,6 +46,74 @@ function buildTemplateCardEventText(body) {
         .filter((line) => Boolean(line))
         .join("\n");
 }
+// ============================================================================
+// 权限类型映射
+// ============================================================================
+/** 权限类型枚举 */
+var AuthType;
+(function (AuthType) {
+    /** 新建和编辑文档 */
+    AuthType[AuthType["CREATE_AND_EDIT_DOC"] = 1] = "CREATE_AND_EDIT_DOC";
+    /** 获取成员文档内容 */
+    AuthType[AuthType["GET_DOC_CONTENT"] = 2] = "GET_DOC_CONTENT";
+})(AuthType || (AuthType = {}));
+/** 权限类型值 → 中文描述 */
+const AUTH_TYPE_MAP = {
+    [AuthType.CREATE_AND_EDIT_DOC]: "新建和编辑文档",
+    [AuthType.GET_DOC_CONTENT]: "获取成员文档内容",
+};
+/**
+ * 将权限变更事件回调格式化为可继续路由给大模型的文本。
+ *
+ * 当管理员在授权页面变更权限后，系统收到 auth_change_event 回调，
+ * 根据 auth_list 生成对应的提示文本，引导 Agent 继续操作。
+ */
+function buildAuthChangeEventText(body) {
+    console.log("authChangeEventCheck", body.event);
+    const authChangeEvent = body.event?.auth_change_event;
+    if (body.msgtype !== "event" ||
+        body.event?.eventtype !== "auth_change_event" ||
+        !authChangeEvent) {
+        return undefined;
+    }
+    const authList = authChangeEvent.auth_list ?? [];
+    const authDescriptions = authList
+        .map((code) => AUTH_TYPE_MAP[code] || `未知权限(${code})`)
+        .join("、");
+    // 根据权限列表内容生成不同的操作指引
+    const hasDocContentAuth = authList.includes(AuthType.GET_DOC_CONTENT);
+    let actionHint;
+    if (hasDocContentAuth) {
+        // 包含"获取成员文档内容"权限，引导 Agent 继续文档操作
+        actionHint = "用户已授予文档内容读取权限，请继续之前的文档操作。";
+    }
+    else if (authList.length > 0) {
+        // 有其他权限但没有文档内容读取权限
+        actionHint = "当前授权不包含文档内容读取权限，无法继续文档操作。请引导用户授予「获取成员文档内容」权限，该权限需要向管理员申请，管理员审批通过后可使用。";
+    }
+    else {
+        // 权限列表为空
+        actionHint = "当前无任何文档权限，无法继续文档操作。请引导用户完成文档授权。";
+    }
+    const senderUserId = body.from?.userid || "";
+    const senderCorpId = body.from?.corpid || "";
+    const chatId = body.from?.chat_id || body.chatid || senderUserId;
+    return [
+        "[企业微信文档权限变更回调]",
+        `event_type(事件类型): auth_change_event`,
+        `auth_list(当前权限列表): [${authList.join(", ")}] (${authDescriptions || "无"})`,
+        body.msgid ? `msgid(消息 id): ${body.msgid}` : undefined,
+        body.aibotid ? `aibotid(机器人 id): ${body.aibotid}` : undefined,
+        body.chattype ? `chat_type(会话类型): ${body.chattype}` : undefined,
+        chatId ? `chat_id(会话 id): ${chatId}` : undefined,
+        senderCorpId ? `from.corpid(企业 id): ${senderCorpId}` : undefined,
+        senderUserId ? `from.userid(发送人 id): ${senderUserId}` : undefined,
+        "",
+        `[操作指引] ${actionHint}`,
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n");
+}
 /**
  * 解析消息内容（支持单条消息、图文混排、事件回调和引用消息）
  * @returns 提取的文本数组、图片URL数组和引用消息内容
@@ -57,8 +125,14 @@ export function parseMessageContent(body) {
     const fileUrls = [];
     const fileAesKeys = new Map();
     let quoteContent;
-    // 处理模板卡片事件回调
     if (body.msgtype === "event") {
+        // 处理权限变更事件回调（如文档授权）
+        const authChangeText = buildAuthChangeEventText(body);
+        if (authChangeText) {
+            textParts.push(authChangeText);
+            return { textParts, imageUrls, imageAesKeys, fileUrls, fileAesKeys, quoteContent };
+        }
+        // 处理模板卡片事件回调
         const eventText = buildTemplateCardEventText(body);
         if (eventText) {
             textParts.push(eventText);

package/dist/src/monitor.js

@@ -29,7 +29,7 @@ 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 { setWeComWebSocket, setMessageState, deleteMessageState, setReqIdForChat, setSessionChatInfo, warmupReqIdStore, startMessageStateCleanup, stopMessageStateCleanup, cleanupAccount, } from "./state-manager.js";
 import { PLUGIN_VERSION } from "./version.js";
 import { processDynamicRouting } from "./dynamic-routing.js";
 // ============================================================================
@@ -340,6 +340,13 @@ async function routeAndDispatchMessage(params) {
         await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
             ctx: ctxPayload,
             cfg: config,
+            replyOptions: {
+                // 打印 LLM 返回的原始分片内容（在 openclaw 核心对 MEDIA: 指令解析之前），
+                // 用于排查流式分片导致 MEDIA 指令被切断、识别丢失等问题
+                onPartialReply: (payload) => {
+                    runtime.log?.(`[openclaw -> plugin][partial] payload=${JSON.stringify(payload)}`);
+                },
+            },
             dispatcherOptions: {
                 onReplyStart: async () => {
                     if (!isShowThink && state.streamId && !state.accumulatedText) {
@@ -353,7 +360,7 @@ async function routeAndDispatchMessage(params) {
                     }
                 },
                 deliver: async (payload, info) => {
-                    runtime.log?.(`[openclaw -> plugin] kind=${info.kind}, text=${JSON.stringify(payload.text ?? '')}, mediaUrl=${payload.mediaUrl ?? ''}, mediaUrls=${JSON.stringify(payload.mediaUrls ?? [])}`);
+                    runtime.log?.(`[openclaw -> plugin] kind=${info.kind}, payload=${JSON.stringify(payload)}, info=${JSON.stringify(info)}`);
                     // 累积文本
                     if (payload.text) {
                         state.accumulatedText += `${payload.text || ''}`;
@@ -541,6 +548,17 @@ async function processWeComMessageNow(entry) {
     // }
     // Step 7: 构建上下文并路由到核心处理流程（带整体超时保护）
     const { ctxPayload, route, storePath, chatId: resolvedChatId, chatType } = buildMessageContext(frame, account, config, text, mediaList, quoteContent, runtime);
+    // 以 sessionKey 为键记录「原始大小写」的 chatId 与 chatType，
+    // 供 MCP 工具工厂（index.ts:registerTool）在构造工具闭包时取回，
+    // 进而传递给需要原始 chatId 的拦截器（如 doc-auth-error 发送 biz_msg）。
+    //
+    // 注意：不要使用 parseSessionKeyChat 反解 sessionKey —— OpenClaw core
+    //       构建 sessionKey 时会将 peer.id 强制小写化，会导致企业微信
+    //       aibot_send_biz_msg 报 errcode=93006 invalid chatid。
+    setSessionChatInfo(route.sessionKey, {
+        chatId: resolvedChatId,
+        chatType: chatType === "group" ? "group" : "single",
+    });
     // runtime.log?.(`[plugin -> openclaw] body=${text}, mediaPaths=${JSON.stringify(mediaList.map(m => m.path))}${quoteContent ? `, quote=${quoteContent}` : ''}`);
     try {
         await routeAndDispatchMessage({
@@ -768,21 +786,28 @@ export 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 ?? ""}`);
-                if (eventType !== "template_card_event") {
-                    return;
+                if (eventType === "template_card_event") {
+                    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)}`);
+                    }
                 }
-                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,
-                    });
+                else if (eventType === "auth_change_event") {
+                    const authChangeEvent = eventBody.event?.auth_change_event;
+                    runtime.log?.(`[${account.accountId}] Received auth_change_event: auth_list=[${authChangeEvent?.auth_list?.join(", ") ?? ""}]`);
                 }
-                catch (updateErr) {
-                    runtime.error?.(`[${account.accountId}] [template-card-update] Failed to update template card: ${String(updateErr)}`);
+                else {
+                    // 其他未识别的事件类型，跳过
+                    return;
                 }
                 const entry = await prepareWeComMessage({
                     frame,
@@ -796,10 +821,10 @@ export async function monitorWeComProvider(options) {
                 }
             }
             catch (err) {
-                runtime.error?.(`[${account.accountId}] Failed to process template_card_event: ${String(err)}`);
+                runtime.error?.(`[${account.accountId}] Failed to process event callback (${frame.body?.event?.eventtype ?? "unknown"}): ${String(err)}`);
             }
         });
-        runtime.log?.(`[${account.accountId}] Event listeners attached: message + event(template_card_event)`);
+        runtime.log?.(`[${account.accountId}] Event listeners attached: message + event(template_card_event, auth_change_event)`);
         // 启动前预热 reqId 缓存，确保完成后再建立连接，避免 getSync 在预热完成前返回 undefined
         warmupReqIdStore(account.accountId, (...args) => runtime.log?.(...args))
             .then((count) => {

package/dist/src/openclaw-compat.js

@@ -446,7 +446,7 @@ function buildAccountScopedDmSecurityPolicyFallback(params) {
 const _sdkPolicyReady = (async () => {
     try {
         // 尝试从主 SDK 包导入
-        const sdk = await import("openclaw/plugin-sdk");
+        const sdk = await import("openclaw/plugin-sdk/channel-policy");
         if (typeof sdk.buildAccountScopedDmSecurityPolicy === "function") {
             return { buildAccountScopedDmSecurityPolicy: sdk.buildAccountScopedDmSecurityPolicy };
         }

package/dist/src/shared/command-auth.d.ts

@@ -1,4 +1,4 @@
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
+import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk/core";
 import type { WecomAgentConfig, WecomBotConfig } from "../types/index.js";
 type WecomCommandAuthAccountConfig = Pick<WecomBotConfig, "dmPolicy" | "allowFrom"> | Pick<WecomAgentConfig, "dmPolicy" | "allowFrom">;
 export declare function resolveWecomCommandAuthorization(params: {

package/dist/src/state-manager.d.ts

@@ -70,6 +70,25 @@ export declare function warmupReqIdStore(accountId?: string, log?: (...args: unk
  * 注意：由于移除了磁盘存储，此函数现在是无操作
  */
 export declare function flushReqIdStore(accountId?: string): Promise<void>;
+/** 会话 chat 信息 */
+export interface SessionChatInfo {
+    /** 原始大小写的 chatId（群 ID 或用户 ID） */
+    chatId: string;
+    /** 聊天类型：single（单聊）或 group（群聊） */
+    chatType: "single" | "group";
+}
+/**
+ * 记录 sessionKey 对应的原始会话信息（由 monitor.ts 在消息入站时调用）
+ */
+export declare function setSessionChatInfo(sessionKey: string, info: SessionChatInfo): void;
+/**
+ * 获取 sessionKey 对应的原始会话信息（由 registerTool 闭包调用）
+ */
+export declare function getSessionChatInfo(sessionKey: string | undefined): SessionChatInfo | undefined;
+/**
+ * 删除 sessionKey 对应的会话信息（会话结束时可选调用）
+ */
+export declare function deleteSessionChatInfo(sessionKey: string): void;
 /**
  * 清理指定账户的所有资源
  */

package/dist/src/state-manager.js

@@ -174,8 +174,41 @@ export async function warmupReqIdStore(accountId = "default", log) {
 export async function flushReqIdStore(accountId = "default") {
     // 由于移除了磁盘存储，不再需要刷写操作
 }
+/** sessionKey → SessionChatInfo 映射 */
+const sessionChatInfoMap = new Map();
+/** 容量上限，超出按插入顺序淘汰最旧项，避免长时间运行内存增长 */
+const SESSION_CHAT_INFO_MAX_SIZE = 5000;
+/**
+ * 记录 sessionKey 对应的原始会话信息（由 monitor.ts 在消息入站时调用）
+ */
+export function setSessionChatInfo(sessionKey, info) {
+    if (!sessionKey)
+        return;
+    // 容量控制：超限时淘汰最早插入的条目（Map 保留插入顺序）
+    if (sessionChatInfoMap.size >= SESSION_CHAT_INFO_MAX_SIZE && !sessionChatInfoMap.has(sessionKey)) {
+        const oldestKey = sessionChatInfoMap.keys().next().value;
+        if (oldestKey !== undefined) {
+            sessionChatInfoMap.delete(oldestKey);
+        }
+    }
+    sessionChatInfoMap.set(sessionKey, info);
+}
+/**
+ * 获取 sessionKey 对应的原始会话信息（由 registerTool 闭包调用）
+ */
+export function getSessionChatInfo(sessionKey) {
+    if (!sessionKey)
+        return undefined;
+    return sessionChatInfoMap.get(sessionKey);
+}
+/**
+ * 删除 sessionKey 对应的会话信息（会话结束时可选调用）
+ */
+export function deleteSessionChatInfo(sessionKey) {
+    sessionChatInfoMap.delete(sessionKey);
+}
 // ============================================================================
-// 全局 cleanup（断开连接时释放所有资源）
+// 全局 cleanup 原始位置
 // ============================================================================
 /**
  * 清理指定账户的所有资源

package/dist/src/webhook/command-auth.d.ts

@@ -4,7 +4,7 @@
  * 从 lh 版 shared/command-auth.ts 迁移。
  * 适配新版 WeComConfig（dmPolicy / allowFrom 扁平化在顶层）。
  */
-import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
+import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk/core";
 import type { WeComConfig } from "../utils.js";
 /** 命令授权结果 */
 export interface WecomCommandAuthResult {

package/dist/src/webhook/helpers.d.ts

@@ -4,7 +4,7 @@
  * 从 @mocrane/wecom monitor.ts 迁移的辅助工具函数集合。
  * 包含：文本截断、兜底提示构建、本机路径提取、MIME 推断等。
  */
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { StreamState, WecomWebhookTarget, WebhookInboundMessage, WebhookInboundQuote } from "./types.js";
 /** DM 文本最大字节数上限 */
 export declare const STREAM_MAX_DM_BYTES = 200000;