@wecom/wecom-openclaw-plugin 2026.3.31-beta.3 → 2026.3.31-beta.5

package/dist/src/dynamic-routing.js

@@ -3,54 +3,14 @@
  * 提供统一的路由注入接口。
  */
 import { shouldUseDynamicAgent, generateAgentId } from "./dynamic-agent.js";
-import { shouldRejectWecomDefaultRoute } from "./routing.js";
-/**
- * 根据 matchedBy 和配置内容判断是否应该跳过动态路由
- * **重要**：即使 matchedBy=binding.peer，也需要检查配置的 peer.kind 是否与实际聊天类型匹配
- * @param params 判断参数
- * @returns 是否跳过动态路由
- */
-function shouldSkipDynamicRouting(params) {
-    const { matchedBy, config, route, chatType, log } = params;
-    // 只有精确匹配到 peer 时才可能跳过动态路由
-    if (matchedBy !== "binding.peer" && matchedBy !== "binding.peer.parent") {
-        return false;
-    }
-    const binding = config.bindings?.find(b => b.agentId === route.agentId);
-    if (!binding) {
-        log?.(`[dynamic-routing] ⚠️  警告：matchedBy=binding.peer，但在配置中找不到 agentId=${route.agentId} 的 binding`);
-        return false;
-    }
-    // 检查配置的 peer.kind 是否与实际聊天类型匹配
-    const configuredKind = binding.match?.peer?.kind;
-    if (!configuredKind) {
-        // 配置中没有指定 kind，使用动态路由
-        log?.(`[dynamic-routing] ℹ️  binding 未指定`);
-        return false;
-    }
-    const actualKind = chatType === "group" ? "group" : "direct";
-    if (configuredKind !== actualKind) {
-        // 类型不匹配，继续使用动态路由
-        log?.(`[dynamic-routing] ⚠️  binding 配置的聊天类型 (${configuredKind}) 与实际类型 (${actualKind}) 不匹配，继续使用动态路由`);
-        return false;
-    }
-    // 类型匹配，跳过动态路由
-    return true;
-}
 /**
  * 统一处理动态路由注入逻辑
  *
  * 功能：
  * 1. 判断是否需要使用动态 Agent
  * 2. 根据 matchedBy 判断配置类型
- * 3. 检查是否被默认路由拦截（fail-closed 策略）
- * 4. 返回最终的路由信息（不修改传入的 route 对象）
- * 5. 输出详细的调试日志
- *
- * **重要规则**：
- * - matchedBy = "binding.peer" 或 "binding.peer.parent" → 跳过动态路由
- * - matchedBy = "binding.account" 或其他 → 继续使用动态路由
- * - matchedBy = "default" → 检查 fail-closed 策略
+ * 3. 返回最终的路由信息（不修改传入的 route 对象）
+ * 4. 输出详细的调试日志
  *
  * @param params 动态路由处理参数
  * @returns 处理结果
@@ -59,22 +19,13 @@ export function processDynamicRouting(params) {
     const { route, config, accountId, chatType, chatId, senderId, log } = params;
     log?.(`[dynamic-routing] 🔍 调试 - matchedBy=${route.matchedBy}, agentId=${route.agentId}`);
     if (route.matchedBy !== "default") {
-        // 根据 matchedBy 和配置内容判断是否跳过动态路由
-        if (shouldSkipDynamicRouting({ matchedBy: route.matchedBy, config, route, chatType, log })) {
-            // 精确配置（binding.peer）且类型匹配，跳过动态路由
-            log?.(`[dynamic-routing] ℹ️  检测到精确配置的 bindings (matchedBy=${route.matchedBy})，且聊天类型匹配，跳过动态路由`);
-            return {
-                useDynamicAgent: false,
-                rejected: false,
-                finalAgentId: route.agentId,
-                finalSessionKey: route.sessionKey,
-                routeModified: false,
-            };
-        }
-        else {
-            // 其他类型的配置（binding.account、binding.channel 等），继续使用动态路由
-            log?.(`[dynamic-routing] ℹ️  检测到非精确配置的 bindings (matchedBy=${route.matchedBy})，继续使用动态路由`);
-        }
+        log?.(`[dynamic-routing] ℹ️  检测到匹配的 bindings (matchedBy=${route.matchedBy})，跳过动态路由`);
+        return {
+            useDynamicAgent: false,
+            finalAgentId: route.agentId,
+            finalSessionKey: route.sessionKey,
+            routeModified: false,
+        };
     }
     // 判断是否使用动态 Agent
     const useDynamicAgent = shouldUseDynamicAgent({
@@ -82,23 +33,7 @@ export function processDynamicRouting(params) {
         senderId,
         config,
     });
-    // 检查是否被默认路由拦截
-    const rejected = shouldRejectWecomDefaultRoute({
-        cfg: config,
-        matchedBy: route.matchedBy,
-        useDynamicAgent,
-    });
-    if (rejected) {
-        const rejectReason = `当前账号（${accountId}）未绑定 OpenClaw Agent，已拒绝回退到默认主智能体。请在 bindings 中添加：{"agentId":"你的Agent","match":{"channel":"wecom","accountId":"${accountId}"}}`;
-        return {
-            useDynamicAgent,
-            rejected: true,
-            rejectReason,
-            finalAgentId: route.agentId,
-            finalSessionKey: route.sessionKey,
-            routeModified: false,
-        };
-    }
+    log?.(`[dynamic-routing] 是否使用动态路由: useDynamicAgent=${useDynamicAgent}`);
     // 使用动态 Agent
     if (useDynamicAgent) {
         log?.(`[dynamic-routing] 原始路由信息: agentId=${route.agentId}, matchedBy=${route.matchedBy}, sessionKey=${route.sessionKey}`);
@@ -107,16 +42,15 @@ export function processDynamicRouting(params) {
         log?.(`[dynamic-routing] 🔄 路由注入: agentId=${targetAgentId}, sessionKey=${targetSessionKey}`);
         return {
             useDynamicAgent: true,
-            rejected: false,
             finalAgentId: targetAgentId,
             finalSessionKey: targetSessionKey,
             routeModified: true,
         };
     }
+    log?.('[dynamic-routing] 🔄不使用动态路由');
     // 不使用动态 Agent，返回原始路由
     return {
         useDynamicAgent: false,
-        rejected: false,
         finalAgentId: route.agentId,
         finalSessionKey: route.sessionKey,
         routeModified: false,

package/dist/src/group-policy.js

@@ -76,21 +76,11 @@ function isGroupSenderAllowed(params) {
  * @returns 检查结果，包含是否允许继续处理
  */
 export function checkGroupPolicy(params) {
-    const { chatId, senderId, account, config, runtime } = params;
-    const wecomConfig = (config.channels?.[CHANNEL_ID] ?? {});
-    const defaultGroupPolicy = config.channels?.[CHANNEL_ID]?.groupPolicy;
-    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "open";
-    // const { groupPolicy, providerMissingFallbackApplied } = resolveOpenProviderRuntimeGroupPolicy({
-    //   providerConfigPresent: config.channels?.[CHANNEL_ID] !== undefined,
-    //   groupPolicy: wecomConfig.groupPolicy,
-    //   defaultGroupPolicy,
-    // });
-    // warnMissingProviderGroupPolicyFallbackOnce({
-    //   providerMissingFallbackApplied,
-    //   providerKey: CHANNEL_ID,
-    //   accountId: account.accountId,
-    //   log: (msg) => runtime.log?.(msg),
-    // });
+    const { chatId, senderId, account, runtime } = params;
+    // 使用 account.config（已经过多账号合并），而非顶层 config.channels.wecom
+    // 避免多账户模式下 groupAllowFrom / groups 等字段取不到账号级配置
+    const wecomConfig = account.config;
+    const groupPolicy = wecomConfig.groupPolicy ?? "open";
     const groupAllowFrom = wecomConfig.groupAllowFrom ?? [];
     const groupAllowed = isWeComGroupAllowed({
         groupPolicy,

package/dist/src/monitor.js

@@ -22,7 +22,7 @@ import { getWeComRuntime } from "./runtime.js";
 import { getDefaultMediaLocalRoots, resolveStateDir } from "./openclaw-compat.js";
 import { CHANNEL_ID, THINKING_MESSAGE, MEDIA_IMAGE_PLACEHOLDER, MEDIA_DOCUMENT_PLACEHOLDER, WS_HEARTBEAT_INTERVAL_MS, WS_MAX_RECONNECT_ATTEMPTS, WS_MAX_AUTH_FAILURE_ATTEMPTS, EVENT_ENTER_CHECK_UPDATE, CMD_ENTER_EVENT_REPLY, SCENE_WECOM_OPENCLAW, } from "./const.js";
 import { parseMessageContent } from "./message-parser.js";
-import { sendWeComReply, sendWeComReplyNonBlocking, StreamExpiredError } from "./message-sender.js";
+import { 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";
@@ -32,14 +32,6 @@ 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";
-/**
- * 去除文本中的 `<think>...</think>` 标签（支持跨行），返回剩余可见文本。
- * 用于判断大模型回复中是否包含实际用户可见内容（而非仅有 thinking 推理过程）。
- */
-function stripThinkTags(text) {
-    return text;
-    // return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
-}
 // ============================================================================
 // 媒体本地路径白名单扩展
 // ============================================================================
@@ -99,9 +91,12 @@ function buildMediaErrorSummary(mediaUrl, result) {
 export { WeComCommand } from "./const.js";
 export { getWeComWebSocket, setReqIdForChat, getReqIdForChatAsync, getReqIdForChat, deleteReqIdForChat, warmupReqIdStore, flushReqIdStore, } from "./state-manager.js";
 export { sendWeComReply } from "./message-sender.js";
+// ============================================================================
+// 消息上下文构建
+// ============================================================================
 /**
  * 构建消息上下文
- * @returns 消息上下文对象，或路由拒绝信息（当路由被拦截时）
+ * @returns 消息上下文对象
  */
 function buildMessageContext(frame, account, config, text, mediaList, quoteContent, runtime) {
     const core = getWeComRuntime();
@@ -130,14 +125,6 @@ function buildMessageContext(frame, account, config, text, mediaList, quoteConte
         log: runtime?.log ? (...args) => runtime.log?.(...args) : undefined,
         error: runtime?.error ? (...args) => runtime.error?.(...args) : undefined,
     });
-    // 处理路由拦截
-    if (routingResult.rejected) {
-        runtime?.error?.(`[wecom] 🚫 routing guard: blocked default fallback accountId=${account.accountId} matchedBy=${route.matchedBy}`);
-        return {
-            rejected: true,
-            rejectReason: routingResult.rejectReason,
-        };
-    }
     // 应用动态路由结果
     if (routingResult.routeModified) {
         route.agentId = routingResult.finalAgentId;
@@ -187,7 +174,7 @@ function buildMessageContext(frame, account, config, text, mediaList, quoteConte
         MediaUrls: mediaPaths,
         ReplyToBody: quoteContent,
     });
-    return { rejected: false, ctxPayload, route, storePath, chatId, chatType };
+    return { ctxPayload, route, storePath, chatId, chatType };
 }
 /**
  * 发送"思考中"消息
@@ -275,7 +262,7 @@ 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);
+    const visibleText = state.accumulatedText;
     let finishText = state.accumulatedText;
     if (visibleText) {
         finishText = state.accumulatedText;
@@ -353,20 +340,6 @@ async function routeAndDispatchMessage(params) {
         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) {
@@ -380,10 +353,10 @@ async function routeAndDispatchMessage(params) {
                     }
                 },
                 deliver: async (payload, info) => {
-                    // runtime.log?.(`[openclaw -> plugin] kind=${info.kind}, text=${payload.text ?? ''}, mediaUrl=${payload.mediaUrl ?? ''}, mediaUrls=${JSON.stringify(payload.mediaUrls ?? [])}`);
-                    // 累积文本（快速指令等非流式回复只走 deliver，不走 onPartialReply）
+                    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] : [];
@@ -403,41 +376,30 @@ async function routeAndDispatchMessage(params) {
                             runtime.error?.(`[wecom] sendMediaBatch threw: ${errMsg}`);
                         }
                     }
-                    // 中间帧流式更新已迁移到 onPartialReply（token 级别，更细粒度）
-                    // deliver 只负责文本累积和媒体发送
-                },
-                onError: (err, info) => {
-                    runtime.error?.(`[wecom] ${info.kind} reply failed: ${String(err)}`);
-                },
-            },
-            // onPartialReply：token 级别的流式 UI 刷新
-            // 使用 SDK 的 replyStreamNonBlocking：上一条同 reqId 的消息未收到 ack 时跳过本次发送，
-            // 避免流式中间帧排队积压导致延迟。丢帧在流式场景下可接受（text 是累积文本，最终由 finishThinkingStream 兜底）。
-            replyOptions: {
-                onPartialReply: (data) => {
-                    // 累积文本
-                    if (data.text) {
-                        state.accumulatedText = (data.text || '');
-                    }
-                    if (!state.streamId || !data.text || state.streamExpired)
-                        return;
+                    // 中间帧：有可见文本时流式更新（流式过期后跳过，等 deliver 完成后主动发送）
                     // 使用 maskTemplateCardBlocks 遮罩正在构建中的模板卡片代码块，
                     // 避免 JSON 源码在流式输出过程中暴露给终端用户
-                    const displayText = maskTemplateCardBlocks(data.text, (...args) => runtime.log?.(...args));
-                    if (displayText !== data.text) {
-                        // runtime.log?.(`[wecom][template-card] Partial-reply masked: original=${data.text.length}chars, masked=${displayText.length}chars`);
-                    }
-                    // fire-and-forget：不阻塞 onPartialReply 回调
-                    sendWeComReplyNonBlocking({
-                        wsClient, frame, text: displayText, runtime,
-                        streamId: state.streamId,
-                    }).catch((err) => {
-                        if (err instanceof StreamExpiredError) {
-                            state.streamExpired = true;
-                            runtime.log?.(`[wecom] Stream expired during partial reply, will fallback to proactive send`);
+                    if (state.accumulatedText && !state.streamExpired) {
+                        try {
+                            const displayText = maskTemplateCardBlocks(state.accumulatedText, (...args) => runtime.log?.(...args));
+                            // if (displayText !== state.accumulatedText) {
+                            //   runtime.log?.(`[wecom][template-card] Mid-frame masked: original=${state.accumulatedText.length}chars, masked=${displayText.length}chars`);
+                            // }
+                            await sendWeComReply({ wsClient, frame, text: displayText, runtime, finish: false, streamId: state.streamId });
                         }
-                        // 其他错误静默忽略，不影响主流程（deliver + finishThinkingStream 兜底）
-                    });
+                        catch (err) {
+                            if (err instanceof StreamExpiredError) {
+                                state.streamExpired = true;
+                                runtime.log?.(`[wecom] Stream expired during intermediate reply, will fallback to proactive send`);
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                    }
+                },
+                onError: (err, info) => {
+                    runtime.error?.(`[wecom] ${info.kind} reply failed: ${String(err)}`);
                 },
             },
         });
@@ -578,24 +540,7 @@ async function processWeComMessageNow(entry) {
     //   await sendThinkingReply({ wsClient, frame, streamId, runtime });
     // }
     // Step 7: 构建上下文并路由到核心处理流程（带整体超时保护）
-    const contextResult = buildMessageContext(frame, account, config, text, mediaList, quoteContent, runtime);
-    // 处理路由拦截
-    if (contextResult.rejected) {
-        runtime.log?.(`[wecom] Routing guard: sending rejection prompt to user`);
-        try {
-            await wsClient.sendMessage(chatId, {
-                msgtype: "markdown",
-                markdown: { content: contextResult.rejectReason },
-            });
-            runtime.log?.(`[wecom] Routing guard prompt delivered`);
-        }
-        catch (err) {
-            runtime.error?.(`[wecom] Routing guard prompt failed: ${String(err)}`);
-        }
-        cleanupState();
-        return;
-    }
-    const { ctxPayload, route, storePath, chatId: resolvedChatId, chatType } = contextResult;
+    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({
@@ -650,7 +595,6 @@ function createSdkLogger(runtime, accountId) {
 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) => {
@@ -824,7 +768,6 @@ 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 ?? ""}`);
-                runtime.error?.(`[${account.accountId}] [diag] event-listener fired: eventtype=${eventType ?? ""}, msgid=${eventBody.msgid ?? ""}`);
                 if (eventType !== "template_card_event") {
                     return;
                 }
@@ -857,7 +800,6 @@ export async function monitorWeComProvider(options) {
             }
         });
         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) => {

package/dist/src/types/config.d.ts

@@ -78,15 +78,6 @@ export type WecomAgentConfig = {
     /** 允许的用户列表，为空表示允许所有人 */
     allowFrom?: Array<string | number>;
 };
-/** 路由行为配置 */
-export type WecomRoutingConfig = {
-    /**
-     * 当路由未命中 bindings（matchedBy=default）时是否拒绝继续处理。
-     * - true: fail-closed（推荐于多账号）
-     * - false: 允许回退默认 agent（历史兼容）
-     */
-    failClosedOnDefaultRoute?: boolean;
-};
 /** 动态 Agent 配置 */
 export type WecomDynamicAgentsConfig = {
     /** 是否启用动态 Agent */

package/dist/src/utils.d.ts

@@ -3,7 +3,7 @@
  */
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { ResolvedAgentAccount } from "./types/account.js";
-import type { WecomAgentConfig, WecomNetworkConfig, WecomMediaConfig } from "./types/config.js";
+import type { WecomAgentConfig, WecomNetworkConfig, WecomMediaConfig, WecomDynamicAgentsConfig } from "./types/config.js";
 /**
  * 企业微信群组配置
  */
@@ -38,6 +38,8 @@ export interface WeComConfig {
     network?: WecomNetworkConfig;
     /** 媒体处理配置 */
     media?: WecomMediaConfig;
+    /** 动态 Agent 配置 */
+    dynamicAgents?: WecomDynamicAgentsConfig;
     /** 连接模式：webhook | websocket（默认 websocket） */
     connectionMode?: "webhook" | "websocket";
     /** Webhook 验证 token */

package/dist/src/webhook/gateway.js

@@ -15,6 +15,7 @@ import { monitorState } from "./state.js";
 import { registerWecomWebhookTarget, hasActiveTargets } from "./target.js";
 import { startAgentForStream } from "./monitor.js";
 import { hasMultiAccounts } from "../accounts.js";
+import { DEFAULT_ACCOUNT_ID } from "../openclaw-compat.js";
 import { getWeComRuntime } from "../runtime.js";
 // ============================================================================
 // 全局状态
@@ -51,7 +52,14 @@ function resolveBotRegistrationPaths(params) {
             WEBHOOK_PATHS.BOT_ALT,
         ]);
     }
-    return uniquePaths([WEBHOOK_PATHS.BOT_PLUGIN, WEBHOOK_PATHS.BOT, WEBHOOK_PATHS.BOT_ALT]);
+    // 单账号模式：同时注册 /default 路径以支持显式指定
+    return uniquePaths([
+        WEBHOOK_PATHS.BOT_PLUGIN,
+        WEBHOOK_PATHS.BOT,
+        WEBHOOK_PATHS.BOT_ALT,
+        `${WEBHOOK_PATHS.BOT_PLUGIN}/${DEFAULT_ACCOUNT_ID}`,
+        `${WEBHOOK_PATHS.BOT_ALT}/${DEFAULT_ACCOUNT_ID}`,
+    ]);
 }
 // ============================================================================
 // 公共 API

package/dist/src/webhook/monitor.js

@@ -503,25 +503,6 @@ export async function startAgentForStream(params) {
         log: (msg) => target.runtime.log?.(msg.replace(/^\[dynamic-routing\]/, "[webhook]")),
         error: (msg) => target.runtime.error?.(msg.replace(/^\[dynamic-routing\]/, "[webhook]")),
     });
-    // 处理路由拦截
-    if (routingResult.rejected) {
-        target.runtime.error?.(`[wecom] routing guard: blocked default fallback accountId=${account.accountId} matchedBy=${route.matchedBy} streamId=${streamId}`);
-        if (account.agent) {
-            try {
-                await sendAgentText({
-                    agent: account.agent,
-                    toUser: chatType === "direct" ? userid : undefined,
-                    chatId: chatType === "group" ? chatId : undefined,
-                    text: routingResult.rejectReason,
-                });
-                target.runtime.log?.(`[webhook] routing guard prompt delivered to ${chatType === "direct" ? userid : chatId}`);
-            }
-            catch (err) {
-                target.runtime.error?.(`[webhook] routing guard prompt failed: ${String(err)}`);
-            }
-        }
-        return;
-    }
     // 应用动态路由结果
     if (routingResult.routeModified) {
         route.agentId = routingResult.finalAgentId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wecom/wecom-openclaw-plugin",
-  "version": "2026.3.31-beta.3",
+  "version": "2026.3.31-beta.5",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/skills/wecom-doc-manager/references/api-edit-doc-content.md

@@ -65,4 +65,4 @@
 
 - `content_type` 当前仅支持 `1`（Markdown 格式）
 - 此操作为**覆写**，会替换文档全部内容
-- 建议先调用 `get_document` 了解当前内容再编辑
+- 建议先调用 `get_doc_content` 了解当前内容再编辑

package/skills/wecom-meeting-create/SKILL.md

@@ -39,7 +39,7 @@ wecom-meeting-create 提供企业微信预约会议的创建能力, 支持设置
 | `meeting_duration`       | integer | 是   | 会议持续时长 (秒), 例如 3600 = 1 小时             |
 | `description`            | string  | 否   | 会议描述                                          |
 | `location`               | string  | 否   | 会议地点                                          |
-| `invitees`               | object  | 是   | 被邀请人, 格式:`{"userid": ["lisi", "wangwu"]}` |
+| `invitees`               | object  | 否   | 被邀请人, 格式:`{"userid": ["lisi", "wangwu"]}` |
 | `settings`               | object  | 否   | 会议设置 (详见下方)                               |
 
 > 被邀请人 userid 通过 `wecom-contact-lookup` 技能获取

package/skills/wecom-meeting-manage/SKILL.md

@@ -63,7 +63,7 @@ wecom-meeting-manage 提供企业微信会议管理能力, 包含以下功能:
 | 参数          | 类型   | 必填 | 说明                                   |
 | ------------- | ------ | ---- | -------------------------------------- |
 | `meetingid` | string | 是   | 会议 ID, 通过 `wecom-meeting-query` 技能获取                          |
-| `invitees`  | array  | 否   | 受邀成员列表, 每项包含 `userid` 字段 |
+| `invitees`  | array  | 是   | 受邀成员列表, 每项包含 `userid` 字段 |
 
 > **注意**: invitees 为全量覆盖, 传入的列表将替换现有成员列表.
 > invitees 的 userid 通过 `wecom-contact-lookup` 技能获取
@@ -92,7 +92,7 @@ wecom-meeting-manage 提供企业微信会议管理能力, 包含以下功能:
 
 使用 `wecom_mcp` tool 调用 `wecom_mcp call meeting cancel_meeting '{"meetingid": "<target_meetingid>"}'`
 
-4. **展示结果**:
+3. **展示结果**:
 
 ```
 ✅ 会议已取消: 技术方案评审
@@ -107,7 +107,7 @@ wecom-meeting-manage 提供企业微信会议管理能力, 包含以下功能:
 **步骤:**
 
 1. **定位会议**: 通过 `wecom-meeting-query` 技能查询会议列表 + 匹配找到目标会议.
-2. **获取当前受邀成员**: `set_invite_members` 为全量覆盖, 必须先通过 `wecom-meeting-query` 技能的 `get_meeting_info` 获取会议详情, 获取现有成员后再合并.
+2. **获取当前受邀成员**: `set_invite_meeting_members` 为全量覆盖, 必须先通过 `wecom-meeting-query` 技能的 `get_meeting_info` 获取会议详情, 获取现有成员后再合并.
 3. **通讯录查询**: 调用 `wecom-contact-lookup` 技能获取通讯录成员, 按姓名筛选出王五的 userid.
 
 使用 `wecom_mcp` tool 调用 `wecom_mcp call contact get_userlist '{}'`
@@ -119,7 +119,7 @@ wecom-meeting-manage 提供企业微信会议管理能力, 包含以下功能:
 
 使用 `wecom_mcp` tool 调用 `wecom_mcp call meeting set_invite_meeting_members '{"meetingid": "<target_meetingid>", "invitees": [{"userid": "zhangsan"}, {"userid": "lisi"}, {"userid": "wangwu"}]}'`
 
-7. **展示结果**:
+6. **展示结果**:
 
 ```
 ✅ 会议成员已更新: 技术方案评审
@@ -133,4 +133,4 @@ wecom-meeting-manage 提供企业微信会议管理能力, 包含以下功能:
 - **参与人仅支持企业内成员**, 不支持外部人员
 - **通讯录查询**: 涉及参与人时, 需先通过 `wecom-contact-lookup` 技能的 `get_userlist` 接口获取全量通讯录成员, 再按姓名/别名本地筛选匹配出对应的 `userid`. 该接口无入参, 返回当前用户可见范围内的成员列表 (含 `userid`, `name`, `alias`)
 - **定位会议**: 管理操作需先通过 `wecom-meeting-query` 技能查询到目标会议的 meetingid
-- **成员更新为全量覆盖**: `set_invite_members` 传入的列表将替换现有成员列表, 需先获取当前成员再合并
+- **成员更新为全量覆盖**: `set_invite_meeting_members` 传入的列表将替换现有成员列表, 需先获取当前成员再合并

package/skills/wecom-schedule/SKILL.md

@@ -64,9 +64,9 @@ metadata:
 - 添加参与人：使用 `wecom_mcp` tool 调用 `wecom_mcp call schedule add_schedule_attendees '{"schedule_id": "SCHEDULE_ID", "attendees": [{"userid": "USER_ID"}]}'`
 - 移除参与人：使用 `wecom_mcp` tool 调用 `wecom_mcp call schedule del_schedule_attendees '{"schedule_id": "SCHEDULE_ID", "attendees": [{"userid": "USER_ID"}]}'`
 
-### check_availablity — 查询闲忙
+### check_availability — 查询闲忙
 
-使用 `wecom_mcp` tool 调用 `wecom_mcp call schedule check_availablity '{"check_user_list": ["USER_ID_1", "USER_ID_2"], "start_time": "YYYY-MM-DD HH:MM:SS", "end_time": "YYYY-MM-DD HH:MM:SS"}'`
+使用 `wecom_mcp` tool 调用 `wecom_mcp call schedule check_availability '{"check_user_list": ["USER_ID_1", "USER_ID_2"], "start_time": "YYYY-MM-DD HH:MM:SS", "end_time": "YYYY-MM-DD HH:MM:SS"}'`
 
 支持 1~10 个用户，返回各用户的忙碌时段列表。参见 [API 详情](references/api-check-availability.md)。
 
@@ -156,6 +156,6 @@ metadata:
 
 **流程：**
 1. 通过 **wecom-contact-lookup** 获取相关人员 userid
-2. 调用 `check_availablity` 查询指定时间范围内各用户的忙碌时段
+2. 调用 `check_availability` 查询指定时间范围内各用户的忙碌时段
 3. 分析所有用户的忙碌时段，计算出共同空闲时段并推荐给用户
 4. 用户确认时段后，调用 `create_schedule` 创建会议并自动添加参与人

package/skills/wecom-schedule/references/api-check-availability.md

@@ -1,4 +1,4 @@
-# check_availablity API
+# check_availability API
 
 查询指定用户在某时间范围内的忙碌时段。
 
@@ -12,7 +12,7 @@
 
 ## 请求示例
 
-使用 `wecom_mcp` tool 调用 `wecom_mcp call schedule check_availablity '{"check_user_list": ["USER_ID_1", "USER_ID_2"], "start_time": "YYYY-MM-DD HH:MM:SS", "end_time": "YYYY-MM-DD HH:MM:SS"}'`
+使用 `wecom_mcp` tool 调用 `wecom_mcp call schedule check_availability '{"check_user_list": ["USER_ID_1", "USER_ID_2"], "start_time": "YYYY-MM-DD HH:MM:SS", "end_time": "YYYY-MM-DD HH:MM:SS"}'`
 
 ## 返回字段
 

package/skills/wecom-smartsheet-data/SKILL.md

@@ -32,7 +32,7 @@ description: 企业微信智能表格数据（记录）管理技能。提供智
 
 查询子表全部记录。
 
-- 使用 `wecom_mcp` tool 调用 `wecom_mcp call doc smartsheet_get_records '{"docid": "DOCID", "sheet_id": "SHEETID"}'`
+- 通过 sheetid：使用 `wecom_mcp` tool 调用 `wecom_mcp call doc smartsheet_get_records '{"docid": "DOCID", "sheet_id": "SHEETID"}'`
 - 或通过 URL：使用 `wecom_mcp` tool 调用 `wecom_mcp call doc smartsheet_get_records '{"url": "https://doc.weixin.qq.com/smartsheet/xxx", "sheet_id": "SHEETID"}'`
 
 参见 [API 详情](references/api-get-records.md)。
@@ -49,7 +49,10 @@ description: 企业微信智能表格数据（记录）管理技能。提供智
 
 ### smartsheet_update_records
 
-更新一行或多行记录，单次必须在 500 行内。需提供 record_id（通过 `smartsheet_get_records` 获取）。
+更新一行或多行记录，单次建议在 500 行内。需提供 record_id（通过 `smartsheet_get_records` 获取）。支持通过 `key_type` 指定 values 的 key 使用字段标题或字段 ID：
+
+- `CELL_VALUE_KEY_TYPE_FIELD_TITLE`：key 为字段标题
+- `CELL_VALUE_KEY_TYPE_FIELD_ID`：key 为字段 ID
 
 使用 `wecom_mcp` tool 调用 `wecom_mcp call doc smartsheet_update_records '{"docid": "DOCID", "sheet_id": "SHEETID", "key_type": "CELL_VALUE_KEY_TYPE_FIELD_ID", "records": [{"record_id": "RECORDID", "values": {"FIELDID": [{"type": "text", "text": "更新后的内容"}]}}]}'`
 

package/skills/wecom-smartsheet-data/references/api-get-records.md

@@ -59,3 +59,4 @@
     "sheet_id": "123Abc"
 }
 ```
+

package/skills/wecom-smartsheet-data/references/cell-value-formats.md

@@ -1,6 +1,7 @@
 # 单元格值格式参考
 
-在 `smartsheet_add_records` 和 `smartsheet_update_records` 中，`values` 的 key **必须是字段标题（field_title）**，不能使用字段 ID。
+`smartsheet_add_records` 仅支持**字段标题**作为key。
+`smartsheet_update_records` 支持通过 `key_type` 参数指定使用字段标题（`CELL_VALUE_KEY_TYPE_FIELD_TITLE`）或字段 ID（`CELL_VALUE_KEY_TYPE_FIELD_ID`）。
 
 ## 各字段类型的值格式
 
@@ -36,10 +37,40 @@
 
 ```json
 "优先级": [{"text": "高"}],
-"标签": [{"text": "紧急"}, {"text": "重要"}]
+"标签": [{"text": "紧急", "style": 17}, {"text": "重要", "style": 12}]
 ```
 
-选项可附带 `id`（已存在选项）和 `style`（颜色 1-27）。
+已存在的选项应通过 `id` 匹配（`id` 可从 `smartsheet_get_fields` 返回中获取），新增选项时不填 `id`。可附带 `style`（颜色 1-27），对照表如下：
+
+| style | 颜色 |
+|-------|------|
+| 1 | 浅红1 |
+| 2 | 浅橙1 |
+| 3 | 浅天蓝1 |
+| 4 | 浅绿1 |
+| 5 | 浅紫1 |
+| 6 | 浅粉红1 |
+| 7 | 浅灰1 |
+| 8 | 白 |
+| 9 | 灰 |
+| 10 | 浅蓝1 |
+| 11 | 浅蓝2 |
+| 12 | 蓝 |
+| 13 | 浅天蓝2 |
+| 14 | 天蓝 |
+| 15 | 浅绿2 |
+| 16 | 绿 |
+| 17 | 浅红2 |
+| 18 | 红 |
+| 19 | 浅橙2 |
+| 20 | 橙 |
+| 21 | 浅黄1 |
+| 22 | 浅黄2 |
+| 23 | 黄 |
+| 24 | 浅紫2 |
+| 25 | 紫 |
+| 26 | 浅粉红2 |
+| 27 | 粉红 |
 
 ### 5. 日期时间 (DATE_TIME)
 
@@ -118,3 +149,4 @@
     }]
 }
 ```
+