ylib-wecom-openclaw-plugin 2026.4.29

package/dist/src/mcp/interceptors/smartsheet-upload.js

@@ -0,0 +1,388 @@
+"use strict";
+/**
+ * smartsheet_add_records / smartsheet_update_records 本地文件上传拦截器
+ *
+ * 核心逻辑：
+ * 大模型在调用 smartsheet_add_records / smartsheet_update_records 时，
+ * 可在 CellImageValue 中传入 image_path（本地图片路径）代替 image_url/title，
+ * 或在 CellAttachmentValue 中传入 file_path（本地文件路径）代替 file_id。
+ *
+ * 本拦截器在 beforeCall 阶段：
+ *   1. 深度扫描 records[].values 中的所有字段值，收集含 image_path / file_path 的单元格
+ *   2. 校验文件大小：单文件不超过 10MB，所有文件总计不超过 20MB
+ *   3. 并行读取本地文件 → base64 编码 → 调用 MCP 上传接口
+ *      - image_path → upload_doc_image → 获取 image_url
+ *      - file_path → upload_doc_file → 获取 file_id
+ *   4. 用上传结果替换原字段，移除 image_path / file_path
+ *   5. 返回修改后的完整 args
+ *
+ * 传给 MCP Server 的始终是标准协议格式（image_url / file_id），
+ * MCP Server 不需要感知 image_path / file_path 的存在。
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+exports.smartsheetUploadInterceptor = void 0;
+var fs = __importStar(require("node:fs/promises"));
+var path = __importStar(require("node:path"));
+var transport_js_1 = require("../transport.js");
+// ============================================================================
+// 常量
+// ============================================================================
+/** 单个文件大小上限：10MB */
+var MAX_SINGLE_FILE_SIZE = 10 * 1024 * 1024;
+/** 所有文件总大小上限：20MB */
+var MAX_TOTAL_FILE_SIZE = 20 * 1024 * 1024;
+/** 上传请求超时时间（毫秒）：单次上传最大 10MB base64，给足时间 */
+var UPLOAD_TIMEOUT_MS = 60000;
+/** beforeCall 整体超时延长到 120s（可能有多个文件并行上传） */
+var INTERCEPTOR_TIMEOUT_MS = 120000;
+/** 日志前缀 */
+var LOG_TAG = "[mcp] smartsheet-upload:";
+// ============================================================================
+// 内部辅助函数
+// ============================================================================
+/**
+ * 深度扫描 records 中所有含 image_path / file_path 的单元格值对象，
+ * 返回待上传任务列表。
+ *
+ * records 结构：
+ *   [{ values: { "字段A": [{ image_path: "..." }], "字段B": [{ file_path: "..." }] } }]
+ *
+ * 字段值可能是数组（图片/附件/文本等）或标量（数字/布尔等），
+ * 仅对数组中的对象元素进行扫描。
+ */
+function collectUploadTasks(records) {
+    var tasks = [];
+    for (var _i = 0, records_1 = records; _i < records_1.length; _i++) {
+        var record = records_1[_i];
+        var values = record.values;
+        if (!values || typeof values !== "object")
+            continue;
+        for (var _a = 0, _b = Object.keys(values); _a < _b.length; _a++) {
+            var fieldKey = _b[_a];
+            var fieldValue = values[fieldKey];
+            if (!Array.isArray(fieldValue))
+                continue;
+            for (var _c = 0, fieldValue_1 = fieldValue; _c < fieldValue_1.length; _c++) {
+                var cellValue = fieldValue_1[_c];
+                if (!cellValue || typeof cellValue !== "object")
+                    continue;
+                var cell = cellValue;
+                if (typeof cell.image_path === "string" && cell.image_path) {
+                    tasks.push({
+                        kind: "image",
+                        filePath: cell.image_path,
+                        title: typeof cell.title === "string" ? cell.title : undefined,
+                        cellValue: cell
+                    });
+                }
+                else if (typeof cell.file_path === "string" && cell.file_path) {
+                    tasks.push({
+                        kind: "file",
+                        filePath: cell.file_path,
+                        cellValue: cell
+                    });
+                }
+            }
+        }
+    }
+    return tasks;
+}
+/**
+ * 校验所有待上传文件的大小
+ *
+ * - 单文件 > 10MB → 报错
+ * - 所有文件累计 > 20MB → 报错
+ */
+function validateFileSizes(tasks) {
+    return __awaiter(this, void 0, void 0, function () {
+        var totalSize, i, task, stat, err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    totalSize = 0;
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < tasks.length)) return [3 /*break*/, 7];
+                    task = tasks[i];
+                    stat = void 0;
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, fs.stat(task.filePath)];
+                case 3:
+                    stat = _a.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    err_1 = _a.sent();
+                    throw new Error(LOG_TAG + " \u65E0\u6CD5\u8BBF\u95EE\u6587\u4EF6 \"" + task.filePath + "\": " + (err_1 instanceof Error ? err_1.message : String(err_1)));
+                case 5:
+                    if (!stat.isFile()) {
+                        throw new Error(LOG_TAG + " \"" + task.filePath + "\" \u4E0D\u662F\u4E00\u4E2A\u6587\u4EF6");
+                    }
+                    if (stat.size > MAX_SINGLE_FILE_SIZE) {
+                        throw new Error(LOG_TAG + " \u6587\u4EF6 \"" + task.filePath + "\" \u5927\u5C0F " + (stat.size / 1024 / 1024).toFixed(1) + "MB \u8D85\u8FC7\u5355\u6587\u4EF6\u4E0A\u9650 10MB");
+                    }
+                    totalSize += stat.size;
+                    if (totalSize > MAX_TOTAL_FILE_SIZE) {
+                        throw new Error(LOG_TAG + " \u7D2F\u8BA1\u6587\u4EF6\u5927\u5C0F " + (totalSize / 1024 / 1024).toFixed(1) + "MB \u8D85\u8FC7\u603B\u4E0A\u9650 20MB\uFF08\u5728\u6587\u4EF6 \"" + task.filePath + "\" \u5904\u8D85\u51FA\uFF09");
+                    }
+                    _a.label = 6;
+                case 6:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 7:
+                    if (totalSize > 0) {
+                        console.log(LOG_TAG + " \u6587\u4EF6\u5927\u5C0F\u6821\u9A8C\u901A\u8FC7\uFF0C\u5171 " + tasks.length + " \u4E2A\u6587\u4EF6\uFF0C\u603B\u8BA1 " + (totalSize / 1024 / 1024).toFixed(2) + "MB");
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * 执行单个图片上传任务
+ *
+ * 读取本地文件 → base64 → 调用 upload_doc_image → 替换 cellValue
+ */
+function executeImageUpload(task, docLocator) {
+    return __awaiter(this, void 0, void 0, function () {
+        var buffer, base64Content, fileName, result, bizData, imageUrl;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fs.readFile(task.filePath)];
+                case 1:
+                    buffer = _a.sent();
+                    base64Content = buffer.toString("base64");
+                    fileName = path.basename(task.filePath);
+                    console.log(LOG_TAG + " \u4E0A\u4F20\u56FE\u7247: \"" + task.filePath + "\" (" + (buffer.length / 1024).toFixed(0) + "KB)");
+                    return [4 /*yield*/, transport_js_1.sendJsonRpc("doc", "tools/call", {
+                            name: "upload_doc_image",
+                            arguments: __assign(__assign({}, docLocator), { base64_content: base64Content })
+                        }, { timeoutMs: UPLOAD_TIMEOUT_MS })];
+                case 2:
+                    result = _a.sent();
+                    bizData = extractBizData(result, "upload_doc_image");
+                    imageUrl = bizData.url;
+                    if (!imageUrl) {
+                        throw new Error(LOG_TAG + " upload_doc_image \u672A\u8FD4\u56DE url\uFF0C\u6587\u4EF6: \"" + task.filePath + "\"");
+                    }
+                    // 替换 cellValue：设置 image_url + title，移除 image_path
+                    task.cellValue.image_url = imageUrl;
+                    task.cellValue.title = task.title || fileName;
+                    delete task.cellValue.image_path;
+                    console.log(LOG_TAG + " \u56FE\u7247\u4E0A\u4F20\u6210\u529F: \"" + task.filePath + "\" \u2192 image_url=\"" + imageUrl + "\"");
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * 执行单个文件上传任务
+ *
+ * 读取本地文件 → base64 → 调用 upload_doc_file → 替换 cellValue
+ */
+function executeFileUpload(task) {
+    return __awaiter(this, void 0, void 0, function () {
+        var buffer, base64Content, fileName, result, bizData, fileId;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, fs.readFile(task.filePath)];
+                case 1:
+                    buffer = _a.sent();
+                    base64Content = buffer.toString("base64");
+                    fileName = path.basename(task.filePath);
+                    console.log(LOG_TAG + " \u4E0A\u4F20\u6587\u4EF6: \"" + task.filePath + "\" (" + (buffer.length / 1024).toFixed(0) + "KB)");
+                    return [4 /*yield*/, transport_js_1.sendJsonRpc("doc", "tools/call", {
+                            name: "upload_doc_file",
+                            arguments: {
+                                file_name: fileName,
+                                file_base64_content: base64Content
+                            }
+                        }, { timeoutMs: UPLOAD_TIMEOUT_MS })];
+                case 2:
+                    result = _a.sent();
+                    bizData = extractBizData(result, "upload_doc_file");
+                    fileId = bizData.fileid;
+                    if (!fileId) {
+                        throw new Error(LOG_TAG + " upload_doc_file \u672A\u8FD4\u56DE fileid\uFF0C\u6587\u4EF6: \"" + task.filePath + "\"");
+                    }
+                    // 替换 cellValue：设置 file_id，移除 file_path
+                    task.cellValue.file_id = fileId;
+                    delete task.cellValue.file_path;
+                    console.log(LOG_TAG + " \u6587\u4EF6\u4E0A\u4F20\u6210\u529F: \"" + task.filePath + "\" \u2192 file_id=\"" + fileId + "\"");
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+/**
+ * 从 MCP tools/call 返回结构中提取业务 JSON 数据
+ *
+ * MCP result 格式：{ content: [{ type: "text", text: "{...json...}" }] }
+ */
+function extractBizData(result, interfaceName) {
+    var _a, _b;
+    var content = (_a = result) === null || _a === void 0 ? void 0 : _a.content;
+    if (!Array.isArray(content)) {
+        throw new Error(LOG_TAG + " " + interfaceName + " \u54CD\u5E94\u683C\u5F0F\u5F02\u5E38\uFF1A\u7F3A\u5C11 content \u6570\u7EC4");
+    }
+    var textItem = content.find(function (c) { return c.type === "text" && typeof c.text === "string"; });
+    if (!textItem) {
+        throw new Error(LOG_TAG + " " + interfaceName + " \u54CD\u5E94\u683C\u5F0F\u5F02\u5E38\uFF1Acontent \u4E2D\u65E0 text \u7C7B\u578B\u6761\u76EE");
+    }
+    var bizData;
+    try {
+        bizData = JSON.parse(textItem.text);
+    }
+    catch (_c) {
+        throw new Error(LOG_TAG + " " + interfaceName + " \u54CD\u5E94\u975E JSON: " + textItem.text.slice(0, 200));
+    }
+    if (bizData.errcode !== 0) {
+        throw new Error(LOG_TAG + " " + interfaceName + " \u4E1A\u52A1\u9519\u8BEF: errcode=" + bizData.errcode + ", errmsg=" + ((_b = bizData.errmsg) !== null && _b !== void 0 ? _b : "unknown"));
+    }
+    return bizData;
+}
+/**
+ * 从 args 中提取文档定位参数（docid 或 url），用于 upload_doc_image
+ */
+function extractDocLocator(args) {
+    if (typeof args.docid === "string" && args.docid) {
+        return { docid: args.docid };
+    }
+    if (typeof args.url === "string" && args.url) {
+        return { url: args.url };
+    }
+    throw new Error(LOG_TAG + " args \u4E2D\u7F3A\u5C11 docid \u6216 url\uFF0C\u65E0\u6CD5\u8C03\u7528 upload_doc_image");
+}
+// ============================================================================
+// 拦截器实现
+// ============================================================================
+exports.smartsheetUploadInterceptor = {
+    name: "smartsheet-upload",
+    /** 对 doc 品类的 smartsheet_add_records / smartsheet_update_records 生效 */
+    match: function (ctx) {
+        return ctx.category === "doc" &&
+            (ctx.method === "smartsheet_add_records" || ctx.method === "smartsheet_update_records");
+    },
+    /** 扫描 records 中的 image_path / file_path，上传后替换为 image_url / file_id */
+    beforeCall: function (ctx) {
+        var records = ctx.args.records;
+        if (!Array.isArray(records) || records.length === 0) {
+            return undefined;
+        }
+        // 收集所有待上传任务
+        var tasks = collectUploadTasks(records);
+        if (tasks.length === 0) {
+            return undefined;
+        }
+        console.log(LOG_TAG + " \u68C0\u6D4B\u5230 " + tasks.length + " \u4E2A\u672C\u5730\u6587\u4EF6\u5F85\u4E0A\u4F20");
+        // 异步执行上传流程
+        return resolveUploads(ctx, tasks);
+    }
+};
+/**
+ * 执行文件校验和并行上传，返回替换后的 args
+ */
+function resolveUploads(ctx, tasks) {
+    return __awaiter(this, void 0, void 0, function () {
+        var hasImageTasks, docLocator, uploadStart, uploadMs;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: 
+                // 阶段 1：文件大小校验
+                return [4 /*yield*/, validateFileSizes(tasks)];
+                case 1:
+                    // 阶段 1：文件大小校验
+                    _a.sent();
+                    hasImageTasks = tasks.some(function (t) { return t.kind === "image"; });
+                    docLocator = {};
+                    if (hasImageTasks) {
+                        docLocator = extractDocLocator(ctx.args);
+                    }
+                    uploadStart = performance.now();
+                    return [4 /*yield*/, Promise.all(tasks.map(function (task) {
+                            if (task.kind === "image") {
+                                return executeImageUpload(task, docLocator);
+                            }
+                            return executeFileUpload(task);
+                        }))];
+                case 2:
+                    _a.sent();
+                    uploadMs = (performance.now() - uploadStart).toFixed(1);
+                    console.log(LOG_TAG + " \u5168\u90E8\u4E0A\u4F20\u5B8C\u6210\uFF0C\u5171 " + tasks.length + " \u4E2A\u6587\u4EF6\uFF0C\u8017\u65F6 " + uploadMs + "ms");
+                    // args 中的 records 已被原地修改，返回完整 args + 延长超时
+                    return [2 /*return*/, {
+                            args: __assign({}, ctx.args),
+                            timeoutMs: INTERCEPTOR_TIMEOUT_MS
+                        }];
+            }
+        });
+    });
+}

package/dist/src/mcp/interceptors/types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * MCP call 拦截器类型定义
+ *
+ * 拦截器用于在 tools/call 调用前后注入特殊逻辑，
+ * 如修改超时配置、变换响应结果等，避免在 tool.ts 中堆积 if/else。
+ */
+import type { SendJsonRpcOptions } from "../transport.js";
+/** MCP call 调用的上下文 */
+export interface CallContext {
+    /** MCP 品类，对应 mcpConfig 中的 key，如 doc、contact */
+    category: string;
+    /** 调用的 MCP 方法名 */
+    method: string;
+    /** 调用 MCP 方法的参数 */
+    args: Record<string, unknown>;
+    /** 当前会话对应的账户 ID（由工具工厂透传，用于精确清理缓存等场景） */
+    accountId?: string;
+    /** 当前会话的 chatId（群组 ID 或用户 ID），用于 aibot_send_biz_msg 等命令 */
+    chatId?: string;
+    /** 当前会话的聊天类型：single（单聊）或 group（群聊） */
+    chatType?: "single" | "group";
+    /** 当前会话可信的企业微信 userid */
+    requesterUserId?: string;
+}
+/**
+ * beforeCall 返回的选项
+ *
+ * 扩展 SendJsonRpcOptions，允许拦截器在调用前替换 args（如从本地文件读取请求体）。
+ */
+export interface BeforeCallOptions extends SendJsonRpcOptions {
+    /** 替换后的 args（可选，不返回则使用原 args） */
+    args?: Record<string, unknown>;
+}
+/**
+ * call 拦截器接口
+ *
+ * 每个拦截器通过 match 判断是否对当前调用生效，
+ * 生效时可在调用前（beforeCall）和调用后（afterCall）注入逻辑。
+ */
+export interface CallInterceptor {
+    /** 拦截器名称（用于日志） */
+    name: string;
+    /**
+     * 判断是否对当前调用生效
+     *
+     * 返回 true 时才会执行 beforeCall / afterCall
+     */
+    match(ctx: CallContext): boolean;
+    /**
+     * 在 sendJsonRpc 调用前修改请求选项和参数（可选）
+     *
+     * 如 get_msg_media 需要延长超时时间，
+     * 如 smartpage_create 需要从本地文件读取请求体替换 args。
+     * 返回的选项会与其他拦截器的结果合并（timeoutMs 取最大值，args 后者覆盖前者）。
+     */
+    beforeCall?(ctx: CallContext): BeforeCallOptions | Promise<BeforeCallOptions> | undefined;
+    /**
+     * 在 sendJsonRpc 返回后处理/变换结果（可选）
+     *
+     * 多个拦截器的 afterCall 按注册顺序管道式执行，
+     * 前一个的返回值作为下一个的输入。
+     */
+    afterCall?(ctx: CallContext, result: unknown): Promise<unknown> | unknown;
+}

package/dist/src/mcp/interceptors/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * MCP call 拦截器类型定义
+ *
+ * 拦截器用于在 tools/call 调用前后注入特殊逻辑，
+ * 如修改超时配置、变换响应结果等，避免在 tool.ts 中堆积 if/else。
+ */
+exports.__esModule = true;

package/dist/src/mcp/schema.d.ts

@@ -0,0 +1,11 @@
+/**
+ * MCP Schema 清洗模块
+ *
+ * 负责内联 $ref/$defs 引用并移除 Gemini 不支持的 JSON Schema 关键词，
+ * 防止 Gemini 模型解析 function response 时报 400 错误。
+ */
+/**
+ * 清洗 JSON Schema，内联 $ref 引用并移除 Gemini 不支持的关键词，
+ * 防止 Gemini 模型解析 function response 时报 400 错误。
+ */
+export declare function cleanSchemaForGemini(schema: unknown): unknown;

package/dist/src/mcp/schema.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * MCP Schema 清洗模块
+ *
+ * 负责内联 $ref/$defs 引用并移除 Gemini 不支持的 JSON Schema 关键词，
+ * 防止 Gemini 模型解析 function response 时报 400 错误。
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+exports.__esModule = true;
+exports.cleanSchemaForGemini = void 0;
+/** Gemini 不支持的 JSON Schema 关键词 */
+var GEMINI_UNSUPPORTED_KEYWORDS = new Set([
+    "patternProperties", "additionalProperties", "$schema", "$id", "$ref", "$defs",
+    "definitions", "examples", "minLength", "maxLength", "minimum", "maximum",
+    "multipleOf", "pattern", "format", "minItems", "maxItems", "uniqueItems",
+    "minProperties", "maxProperties",
+]);
+/**
+ * 清洗 JSON Schema，内联 $ref 引用并移除 Gemini 不支持的关键词，
+ * 防止 Gemini 模型解析 function response 时报 400 错误。
+ */
+function cleanSchemaForGemini(schema) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map(cleanSchemaForGemini);
+    var obj = schema;
+    // 收集 $defs/definitions 用于后续 $ref 内联解析
+    var defs = __assign(__assign({}, (obj.$defs && typeof obj.$defs === "object" ? obj.$defs : {})), (obj.definitions && typeof obj.definitions === "object" ? obj.definitions : {}));
+    return cleanWithDefs(obj, defs, new Set());
+}
+exports.cleanSchemaForGemini = cleanSchemaForGemini;
+function cleanWithDefs(schema, defs, refStack) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map(function (item) { return cleanWithDefs(item, defs, refStack); });
+    var obj = schema;
+    // 合并当前层级的 $defs/definitions 到 defs 中
+    if (obj.$defs && typeof obj.$defs === "object") {
+        Object.assign(defs, obj.$defs);
+    }
+    if (obj.definitions && typeof obj.definitions === "object") {
+        Object.assign(defs, obj.definitions);
+    }
+    // 处理 $ref 引用：尝试内联解析
+    if (typeof obj.$ref === "string") {
+        var ref = obj.$ref;
+        if (refStack.has(ref))
+            return {}; // 防止循环引用
+        var match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+        if (match && match[1] && defs[match[1]]) {
+            var nextStack = new Set(refStack);
+            nextStack.add(ref);
+            return cleanWithDefs(defs[match[1]], defs, nextStack);
+        }
+        return {}; // 无法解析的 $ref，返回空对象
+    }
+    var cleaned = {};
+    for (var _i = 0, _a = Object.entries(obj); _i < _a.length; _i++) {
+        var _b = _a[_i], key = _b[0], value = _b[1];
+        if (GEMINI_UNSUPPORTED_KEYWORDS.has(key))
+            continue;
+        if (key === "const") {
+            cleaned["enum"] = [value];
+            continue;
+        }
+        if (key === "properties" && value && typeof value === "object" && !Array.isArray(value)) {
+            cleaned[key] = Object.fromEntries(Object.entries(value).map(function (_a) {
+                var k = _a[0], v = _a[1];
+                return [
+                    k, cleanWithDefs(v, defs, refStack),
+                ];
+            }));
+        }
+        else if (key === "items" && value) {
+            cleaned[key] = Array.isArray(value)
+                ? value.map(function (item) { return cleanWithDefs(item, defs, refStack); })
+                : cleanWithDefs(value, defs, refStack);
+        }
+        else if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
+            // 过滤掉 null 类型的变体
+            var nonNull = value.filter(function (v) {
+                if (!v || typeof v !== "object")
+                    return true;
+                var r = v;
+                return r.type !== "null";
+            });
+            if (nonNull.length === 1) {
+                // 只剩一个变体时直接内联
+                var single = cleanWithDefs(nonNull[0], defs, refStack);
+                if (single && typeof single === "object" && !Array.isArray(single)) {
+                    Object.assign(cleaned, single);
+                }
+            }
+            else {
+                cleaned[key] = nonNull.map(function (v) { return cleanWithDefs(v, defs, refStack); });
+            }
+        }
+        else {
+            cleaned[key] = value;
+        }
+    }
+    return cleaned;
+}

package/dist/src/mcp/tool.d.ts

@@ -0,0 +1,63 @@
+/**
+ * wecom_mcp — 模拟 MCP 调用的 Agent Tool
+ *
+ * 通过 MCP Streamable HTTP 传输协议调用企业微信 MCP Server，
+ * 提供 list（列出所有工具）和 call（调用工具）两个操作。
+ *
+ * 在 skills 中的使用方式：
+ *   wecom_mcp list <category>
+ *   wecom_mcp call <category> <method> '<jsonArgs>'
+ *
+ * 示例：
+ *   wecom_mcp list contact
+ *   wecom_mcp call contact getContact '{}'
+ */
+interface CreateWeComMcpToolOptions {
+    /** 当前会话可信的企业微信 userid */
+    requesterUserId?: string;
+    /** 当前会话对应的账户 ID（来自 ctx.agentAccountId） */
+    accountId?: string;
+    /** 当前会话的 chatId（群组 ID 或用户 ID），用于 aibot_send_biz_msg 等命令 */
+    chatId?: string;
+    /** 当前会话的聊天类型：single（单聊）或 group（群聊） */
+    chatType?: "single" | "group";
+}
+/**
+ * 创建 wecom_mcp Agent Tool 定义
+ */
+export declare function createWeComMcpTool(options?: CreateWeComMcpToolOptions): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            category: {
+                type: string;
+                description: string;
+            };
+            method: {
+                type: string;
+                description: string;
+            };
+            args: {
+                type: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(_toolCallId: string, params: unknown): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: unknown;
+    }>;
+};
+export {};