@yanhaidao/wecom 2.4.120 → 2.5.110

package/dist/src/capability/doc/types.js

@@ -0,0 +1,113 @@
+export var NodeType;
+(function (NodeType) {
+    NodeType["Document"] = "Document";
+    NodeType["MainStory"] = "MainStory";
+    NodeType["Section"] = "Section";
+    NodeType["Paragraph"] = "Paragraph";
+    NodeType["Table"] = "Table";
+    NodeType["TableRow"] = "TableRow";
+    NodeType["TableCell"] = "TableCell";
+    NodeType["Text"] = "Text";
+    NodeType["Drawing"] = "Drawing";
+})(NodeType || (NodeType = {}));
+export var LineSpacingRule;
+(function (LineSpacingRule) {
+    LineSpacingRule["UNSPECIFIED"] = "LINE_SPACING_RULE_UNSPECIFIED";
+    LineSpacingRule["AUTO"] = "LINE_SPACING_RULE_AUTO";
+    LineSpacingRule["EXACT"] = "LINE_SPACING_RULE_EXACT";
+    LineSpacingRule["AT_LEAST"] = "LINE_SPACING_RULE_AT_LEAST";
+})(LineSpacingRule || (LineSpacingRule = {}));
+export var AlignmentType;
+(function (AlignmentType) {
+    AlignmentType["UNSPECIFIED"] = "ALIGNMENT_TYPE_UNSPECIFIED";
+    AlignmentType["CENTER"] = "ALIGNMENT_TYPE_CENTER";
+    AlignmentType["BOTH"] = "ALIGNMENT_TYPE_BOTH";
+    AlignmentType["DISTRIBUTE"] = "ALIGNMENT_TYPE_DISTRIBUTE";
+    AlignmentType["LEFT"] = "ALIGNMENT_TYPE_LEFT";
+    AlignmentType["RIGHT"] = "ALIGNMENT_TYPE_RIGHT";
+})(AlignmentType || (AlignmentType = {}));
+export var TextDirection;
+(function (TextDirection) {
+    TextDirection["UNSPECIFIED"] = "TEXT_DIRECTION_UNSPECIFIED";
+    TextDirection["RTL"] = "TEXT_DIRECTION_RIGHT_TO_LEFT";
+    TextDirection["LTR"] = "TEXT_DIRECTION_LEFT_TO_RIGHT";
+})(TextDirection || (TextDirection = {}));
+export var TextVerticalAlign;
+(function (TextVerticalAlign) {
+    TextVerticalAlign["UNSPECIFIED"] = "RUN_VERTICAL_ALIGN_UNSPECIFIED";
+    TextVerticalAlign["BASELINE"] = "RUN_VERTICAL_ALIGN_BASELINE";
+    TextVerticalAlign["SUPER_SCRIPT"] = "RUN_VERTICAL_ALIGN_SUPER_SCRIPT";
+    TextVerticalAlign["SUB_SCRIPT"] = "RUN_VERTICAL_ALIGN_SUB_SCRIPT";
+})(TextVerticalAlign || (TextVerticalAlign = {}));
+export var TableHorizontalAlignmentType;
+(function (TableHorizontalAlignmentType) {
+    TableHorizontalAlignmentType["UNSPECIFIED"] = "TABLE_HORIZONTAL_ALIGNMENT_TYPE_UNSPECIFIED";
+    TableHorizontalAlignmentType["CENTER"] = "TABLE_HORIZONTAL_ALIGNMENT_TYPE_CENTER";
+    TableHorizontalAlignmentType["LEFT"] = "TABLE_HORIZONTAL_ALIGNMENT_TYPE_LEFT";
+    TableHorizontalAlignmentType["START"] = "TABLE_HORIZONTAL_ALIGNMENT_TYPE_START";
+})(TableHorizontalAlignmentType || (TableHorizontalAlignmentType = {}));
+export var TableLayoutType;
+(function (TableLayoutType) {
+    TableLayoutType["UNSPECIFIED"] = "TABLE_LAYOUT_TYPE_UNSPECIFIED";
+    TableLayoutType["FIXED"] = "TABLE_LAYOUT_TYPE_FIXED";
+    TableLayoutType["AUTO_FIT"] = "TABLE_LAYOUT_TYPE_AUTO_FIT";
+})(TableLayoutType || (TableLayoutType = {}));
+export var TableWidthType;
+(function (TableWidthType) {
+    TableWidthType["UNSPECIFIED"] = "TABLE_LAYOUT_TYPE_UNSPECIFIED";
+    TableWidthType["FIXED"] = "TABLE_LAYOUT_TYPE_FIXED";
+    TableWidthType["AUTO_FIT"] = "TABLE_LAYOUT_TYPE_AUTO_FIT";
+})(TableWidthType || (TableWidthType = {}));
+export var VerticalAlignment;
+(function (VerticalAlignment) {
+    VerticalAlignment["UNSPECIFIED"] = "VERTICAL_ALIGNMENT__UNSPECIFIED";
+    VerticalAlignment["TOP"] = "VERTICAL_ALIGNMENT_TOP";
+    VerticalAlignment["CENTER"] = "VERTICAL_ALIGNMENT_CENTER";
+    VerticalAlignment["BOTH"] = "VERTICAL_ALIGNMENT_BOTH";
+    VerticalAlignment["BOTTOM"] = "VERTICAL_ALIGNMENT_BOTTOM";
+})(VerticalAlignment || (VerticalAlignment = {}));
+export var AddonSourceType;
+(function (AddonSourceType) {
+    AddonSourceType["UNSPECIFIED"] = "ADDON_SOURCE_TYPE_UNSPECIFIED";
+    AddonSourceType["NONE"] = "ADDON_SOURCE_TYPE_NONE";
+    AddonSourceType["LATEX"] = "ADDON_SOURCE_TYPE_LATEX";
+    AddonSourceType["SIGN"] = "ADDON_SOURCE_TYPE_SIGN";
+    AddonSourceType["SIGN_BAR"] = "ADDON_SOURCE_TYPE_SIGN_BAR";
+})(AddonSourceType || (AddonSourceType = {}));
+export var RelativeFromHorizontal;
+(function (RelativeFromHorizontal) {
+    RelativeFromHorizontal["UNSPECIFIED"] = "RELATIVE_FROM_HORIZONTAL_UNSPECIFIED";
+    RelativeFromHorizontal["MARGIN"] = "RELATIVE_FROM_HORIZONTAL_MARGIN";
+    RelativeFromHorizontal["PAGE"] = "RELATIVE_FROM_HORIZONTAL_PAGE";
+    RelativeFromHorizontal["COLUMN"] = "RELATIVE_FROM_HORIZONTAL_COLUMN";
+    RelativeFromHorizontal["CHARACTER"] = "RELATIVE_FROM_HORIZONTAL_CHARACTER";
+    RelativeFromHorizontal["LEFT_MARGIN"] = "RELATIVE_FROM_HORIZONTAL_LEFT_MARGIN";
+    RelativeFromHorizontal["RIGHT_MARGIN"] = "RELATIVE_FROM_HORIZONTAL_RIGHT_MARGIN";
+    RelativeFromHorizontal["INSIDE_MARGIN"] = "RELATIVE_FROM_HORIZONTAL_INSIDE_MARGIN";
+    RelativeFromHorizontal["OUTSIDE_MARGIN"] = "RELATIVE_FROM_HORIZONTAL_OUTSIDE_MARGIN";
+})(RelativeFromHorizontal || (RelativeFromHorizontal = {}));
+export var RelativeFromVertical;
+(function (RelativeFromVertical) {
+    RelativeFromVertical["UNSPECIFIED"] = "RELATIVE_FROM_VERTICAL_UNSPECIFIED";
+    RelativeFromVertical["MARGIN"] = "RELATIVE_FROM_VERTICAL_MARGIN";
+    RelativeFromVertical["PAGE"] = "RELATIVE_FROM_VERTICAL_PAGE";
+    RelativeFromVertical["PARAGRAPH"] = "RELATIVE_FROM_VERTICAL_PARAGRAPH";
+    RelativeFromVertical["LINE"] = "RELATIVE_FROM_VERTICAL_LINE";
+    RelativeFromVertical["TOP_MARGIN"] = "RELATIVE_FROM_VERTICAL_TOP_MARGIN";
+    RelativeFromVertical["BOTTOM_MARGIN"] = "RELATIVE_FROM_VERTICAL_BOTTOM_MARGIN";
+    RelativeFromVertical["INSIDE_MARGIN"] = "RELATIVE_FROM_VERTICAL_INSIDE_MARGIN";
+    RelativeFromVertical["OUTSIDE_MARGIN"] = "RELATIVE_FROM_VERTICAL_OUTSIDE_MARGIN";
+})(RelativeFromVertical || (RelativeFromVertical = {}));
+export var WrapText;
+(function (WrapText) {
+    WrapText["UNSPECIFIED"] = "WRAP_TEXT_BOTH_UNSPECIFIED";
+    WrapText["BOTH_SIDES"] = "WRAP_TEXT_BOTH_SIDES";
+    WrapText["LEFT"] = "WRAP_TEXT_LEFT";
+    WrapText["RIGHT"] = "WRAP_TEXT_RIGHT";
+    WrapText["LARGEST"] = "WRAP_TEXT_LARGEST";
+})(WrapText || (WrapText = {}));
+export var Dimension;
+(function (Dimension) {
+    Dimension["ROW"] = "ROW";
+    Dimension["COLUMN"] = "COLUMN"; // 列
+})(Dimension || (Dimension = {}));

package/dist/src/capability/mcp/index.js

@@ -0,0 +1,3 @@
+export { createWeComMcpToolFactory } from "./tool.js";
+export { clearWecomMcpAccountCache, clearWecomMcpCategoryCache, McpHttpError, McpRpcError, sendJsonRpc, } from "./transport.js";
+export { cleanSchemaForGemini } from "./schema.js";

package/dist/src/capability/mcp/schema.js

@@ -0,0 +1,102 @@
+const 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",
+]);
+export function cleanSchemaForGemini(schema) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map(cleanSchemaForGemini);
+    const obj = schema;
+    const defs = {
+        ...(obj.$defs && typeof obj.$defs === "object" ? obj.$defs : {}),
+        ...(obj.definitions && typeof obj.definitions === "object"
+            ? obj.definitions
+            : {}),
+    };
+    return cleanWithDefs(obj, defs, new Set());
+}
+function cleanWithDefs(schema, defs, refStack) {
+    if (!schema || typeof schema !== "object")
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map((item) => cleanWithDefs(item, defs, refStack));
+    const obj = schema;
+    if (obj.$defs && typeof obj.$defs === "object") {
+        Object.assign(defs, obj.$defs);
+    }
+    if (obj.definitions && typeof obj.definitions === "object") {
+        Object.assign(defs, obj.definitions);
+    }
+    if (typeof obj.$ref === "string") {
+        const ref = obj.$ref;
+        if (refStack.has(ref))
+            return {};
+        const match = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+        if (match?.[1] && defs[match[1]]) {
+            const nextStack = new Set(refStack);
+            nextStack.add(ref);
+            return cleanWithDefs(defs[match[1]], defs, nextStack);
+        }
+        return {};
+    }
+    const cleaned = {};
+    for (const [key, value] of Object.entries(obj)) {
+        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(([propKey, propValue]) => [
+                propKey,
+                cleanWithDefs(propValue, defs, refStack),
+            ]));
+            continue;
+        }
+        if (key === "items" && value) {
+            cleaned[key] = Array.isArray(value)
+                ? value.map((item) => cleanWithDefs(item, defs, refStack))
+                : cleanWithDefs(value, defs, refStack);
+            continue;
+        }
+        if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
+            const nonNull = value.filter((variant) => {
+                if (!variant || typeof variant !== "object")
+                    return true;
+                return variant.type !== "null";
+            });
+            if (nonNull.length === 1) {
+                const single = cleanWithDefs(nonNull[0], defs, refStack);
+                if (single && typeof single === "object" && !Array.isArray(single)) {
+                    Object.assign(cleaned, single);
+                }
+            }
+            else {
+                cleaned[key] = nonNull.map((variant) => cleanWithDefs(variant, defs, refStack));
+            }
+            continue;
+        }
+        cleaned[key] = value;
+    }
+    return cleaned;
+}

package/dist/src/capability/mcp/tool.js

@@ -0,0 +1,146 @@
+import { resolveWecomSourceSnapshot } from "../../runtime/source-registry.js";
+import { cleanSchemaForGemini } from "./schema.js";
+import { clearWecomMcpCategoryCache, sendJsonRpc } from "./transport.js";
+const BIZ_CACHE_CLEAR_ERROR_CODES = new Set([850002]);
+function textResult(data) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+        details: data,
+    };
+}
+function errorResult(error) {
+    if (error && typeof error === "object" && "errcode" in error) {
+        const errcode = Number(error.errcode ?? 0);
+        const errmsg = String(error.errmsg ?? `错误码: ${errcode}`);
+        return textResult({ error: errmsg, errcode });
+    }
+    return textResult({
+        error: error instanceof Error ? error.message : String(error),
+    });
+}
+function parseArgs(args) {
+    if (!args)
+        return {};
+    if (typeof args === "object")
+        return args;
+    try {
+        return JSON.parse(args);
+    }
+    catch (error) {
+        const detail = error instanceof SyntaxError ? error.message : String(error);
+        throw new Error(`args 不是合法的 JSON: ${args} (${detail})`);
+    }
+}
+function extractToolAccountId(ctx) {
+    const explicit = String(ctx.accountId ?? "").trim();
+    if (explicit)
+        return explicit;
+    const agentAccountId = String(ctx.agentAccountId ?? "").trim();
+    return agentAccountId || undefined;
+}
+async function handleList(accountId, category) {
+    const result = (await sendJsonRpc(accountId, category, "tools/list"));
+    const tools = result?.tools ?? [];
+    return {
+        accountId,
+        category,
+        count: tools.length,
+        tools: tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description ?? "",
+            inputSchema: tool.inputSchema ? cleanSchemaForGemini(tool.inputSchema) : undefined,
+        })),
+    };
+}
+function checkBizErrorAndClearCache(result, accountId, category) {
+    if (!result || typeof result !== "object")
+        return;
+    const content = result.content;
+    if (!Array.isArray(content))
+        return;
+    for (const item of content) {
+        if (item.type !== "text" || !item.text)
+            continue;
+        try {
+            const parsed = JSON.parse(item.text);
+            if (typeof parsed.errcode === "number" && BIZ_CACHE_CLEAR_ERROR_CODES.has(parsed.errcode)) {
+                clearWecomMcpCategoryCache(accountId, category);
+                return;
+            }
+        }
+        catch {
+            // Ignore non-JSON content.
+        }
+    }
+}
+async function handleCall(accountId, category, method, args) {
+    const result = await sendJsonRpc(accountId, category, "tools/call", {
+        name: method,
+        arguments: args,
+    });
+    checkBizErrorAndClearCache(result, accountId, category);
+    return result;
+}
+export function createWeComMcpToolFactory() {
+    return (toolContext) => {
+        if (toolContext.messageChannel !== "wecom") {
+            return null;
+        }
+        const accountId = extractToolAccountId(toolContext);
+        const source = resolveWecomSourceSnapshot({
+            accountId,
+            sessionKey: toolContext.sessionKey,
+            sessionId: toolContext.sessionId,
+        });
+        if (!source || source.source !== "bot-ws") {
+            return null;
+        }
+        return {
+            name: "wecom_mcp",
+            label: "WeCom MCP",
+            description: "企业微信 Bot WS MCP 工具。仅在 WeCom Bot WS 会话中可用，用于列出和调用企业微信 MCP 能力。",
+            parameters: {
+                type: "object",
+                properties: {
+                    action: {
+                        type: "string",
+                        enum: ["list", "call"],
+                        description: "操作类型：list 或 call",
+                    },
+                    category: {
+                        type: "string",
+                        description: "MCP 品类，如 contact、todo、meeting、doc",
+                    },
+                    method: {
+                        type: "string",
+                        description: "action=call 时要调用的工具方法名",
+                    },
+                    args: {
+                        type: "string",
+                        description: "action=call 时传入的 JSON 字符串参数，默认 {}",
+                    },
+                },
+                required: ["action", "category"],
+            },
+            async execute(_toolCallId, rawParams) {
+                try {
+                    const params = rawParams;
+                    const effectiveAccountId = extractToolAccountId(toolContext);
+                    if (!effectiveAccountId) {
+                        throw new Error("当前会话缺少 WeCom accountId，无法调用 wecom_mcp。");
+                    }
+                    if (params.action === "list") {
+                        return textResult(await handleList(effectiveAccountId, params.category));
+                    }
+                    if (!params.method) {
+                        return textResult({ error: "action=call 时必须提供 method" });
+                    }
+                    return textResult(await handleCall(effectiveAccountId, params.category, params.method, parseArgs(params.args)));
+                }
+                catch (error) {
+                    return errorResult(error);
+                }
+            },
+        };
+    };
+}

package/dist/src/capability/mcp/transport.js

@@ -0,0 +1,293 @@
+import { generateReqId } from "@wecom/aibot-node-sdk";
+import { getBotWsPushHandle } from "../../runtime.js";
+const HTTP_REQUEST_TIMEOUT_MS = 30_000;
+const MCP_CONFIG_FETCH_TIMEOUT_MS = 15_000;
+const MCP_GET_CONFIG_CMD = "aibot_get_mcp_config";
+const MCP_PLUGIN_VERSION = "wecom-dual-plane";
+const LOG_TAG = "[wecom-mcp]";
+const CACHE_CLEAR_ERROR_CODES = new Set([-32001, -32002, -32003]);
+const mcpConfigCache = new Map();
+const mcpSessionCache = new Map();
+const statelessKeys = new Set();
+const inflightInitRequests = new Map();
+function cacheKey(accountId, category) {
+    return `${accountId}::${category}`;
+}
+function withTimeout(promise, timeoutMs, message) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).finally(() => {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    });
+}
+export class McpRpcError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "McpRpcError";
+    }
+}
+export class McpHttpError extends Error {
+    statusCode;
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "McpHttpError";
+    }
+}
+async function fetchMcpConfig(accountId, category) {
+    const handle = getBotWsPushHandle(accountId);
+    if (!handle?.isConnected()) {
+        throw new Error(`当前企微账号 MCP 服务未就绪：account=${accountId} 的 Bot WS 未连接。`);
+    }
+    const response = await withTimeout(handle.replyCommand({
+        cmd: MCP_GET_CONFIG_CMD,
+        body: {
+            biz_type: category,
+            plugin_version: MCP_PLUGIN_VERSION,
+        },
+        headers: {
+            req_id: generateReqId("mcp_config"),
+        },
+    }), MCP_CONFIG_FETCH_TIMEOUT_MS, `MCP config fetch timed out after ${MCP_CONFIG_FETCH_TIMEOUT_MS}ms`);
+    const errcode = Number(response.errcode ?? 0);
+    if (errcode !== 0) {
+        throw new Error(`MCP 配置请求失败: errcode=${String(response.errcode)} errmsg=${String(response.errmsg ?? "unknown")}`);
+    }
+    const body = response.body;
+    if (!body?.url) {
+        throw new Error(`MCP 配置响应缺少 url 字段 (account=${accountId}, category=${category})`);
+    }
+    console.log(`${LOG_TAG} config ready account=${accountId} category=${category} url=${body.url}`);
+    return body;
+}
+async function getMcpUrl(accountId, category) {
+    const key = cacheKey(accountId, category);
+    const cached = mcpConfigCache.get(key);
+    if (cached?.url) {
+        return String(cached.url);
+    }
+    const body = await fetchMcpConfig(accountId, category);
+    mcpConfigCache.set(key, body);
+    return String(body.url);
+}
+async function sendRawJsonRpc(url, session, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), HTTP_REQUEST_TIMEOUT_MS);
+    try {
+        const headers = {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+        };
+        if (session.sessionId) {
+            headers["Mcp-Session-Id"] = session.sessionId;
+        }
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        const newSessionId = response.headers.get("mcp-session-id");
+        if (!response.ok) {
+            throw new McpHttpError(response.status, `MCP HTTP 请求失败: ${response.status} ${response.statusText}`);
+        }
+        const contentLength = response.headers.get("content-length");
+        if (response.status === 204 || contentLength === "0") {
+            return { rpcResult: undefined, newSessionId };
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("text/event-stream")) {
+            return {
+                rpcResult: await parseSseResponse(response),
+                newSessionId,
+            };
+        }
+        const text = await response.text();
+        if (!text.trim()) {
+            return { rpcResult: undefined, newSessionId };
+        }
+        const rpc = JSON.parse(text);
+        if (rpc.error) {
+            throw new McpRpcError(rpc.error.code, `MCP 调用错误 [${rpc.error.code}]: ${rpc.error.message}`, rpc.error.data);
+        }
+        return { rpcResult: rpc.result, newSessionId };
+    }
+    catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+            throw new Error(`MCP 请求超时 (${HTTP_REQUEST_TIMEOUT_MS}ms)`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+async function initializeSession(accountId, category, url) {
+    const key = cacheKey(accountId, category);
+    const session = { sessionId: null, initialized: false, stateless: false };
+    const initializeRequest = {
+        jsonrpc: "2.0",
+        id: generateReqId("mcp_init"),
+        method: "initialize",
+        params: {
+            protocolVersion: "2025-03-26",
+            capabilities: {},
+            clientInfo: { name: "wecom_mcp", version: MCP_PLUGIN_VERSION },
+        },
+    };
+    const initResult = await sendRawJsonRpc(url, session, initializeRequest);
+    if (initResult.newSessionId) {
+        session.sessionId = initResult.newSessionId;
+    }
+    if (!session.sessionId) {
+        session.stateless = true;
+        session.initialized = true;
+        statelessKeys.add(key);
+        mcpSessionCache.set(key, session);
+        return session;
+    }
+    const notifyRequest = {
+        jsonrpc: "2.0",
+        method: "notifications/initialized",
+    };
+    const notifyResult = await sendRawJsonRpc(url, session, notifyRequest);
+    if (notifyResult.newSessionId) {
+        session.sessionId = notifyResult.newSessionId;
+    }
+    session.initialized = true;
+    mcpSessionCache.set(key, session);
+    return session;
+}
+async function getOrCreateSession(accountId, category, url) {
+    const key = cacheKey(accountId, category);
+    if (statelessKeys.has(key)) {
+        const cached = mcpSessionCache.get(key);
+        if (cached)
+            return cached;
+    }
+    const cached = mcpSessionCache.get(key);
+    if (cached?.initialized) {
+        return cached;
+    }
+    const inflight = inflightInitRequests.get(key);
+    if (inflight) {
+        return inflight;
+    }
+    const promise = initializeSession(accountId, category, url).finally(() => {
+        inflightInitRequests.delete(key);
+    });
+    inflightInitRequests.set(key, promise);
+    return promise;
+}
+async function rebuildSession(accountId, category, url) {
+    const key = cacheKey(accountId, category);
+    const inflight = inflightInitRequests.get(key);
+    if (inflight)
+        return inflight;
+    const promise = initializeSession(accountId, category, url).finally(() => {
+        inflightInitRequests.delete(key);
+    });
+    inflightInitRequests.set(key, promise);
+    return promise;
+}
+async function parseSseResponse(response) {
+    const text = await response.text();
+    const lines = text.split("\n");
+    let currentParts = [];
+    let lastEventData = "";
+    for (const line of lines) {
+        if (line.startsWith("data: ")) {
+            currentParts.push(line.slice(6));
+            continue;
+        }
+        if (line.startsWith("data:")) {
+            currentParts.push(line.slice(5));
+            continue;
+        }
+        if (line.trim() === "" && currentParts.length > 0) {
+            lastEventData = currentParts.join("\n").trim();
+            currentParts = [];
+        }
+    }
+    if (currentParts.length > 0) {
+        lastEventData = currentParts.join("\n").trim();
+    }
+    if (!lastEventData) {
+        throw new Error("SSE 响应中未包含有效数据");
+    }
+    const rpc = JSON.parse(lastEventData);
+    if (rpc.error) {
+        throw new McpRpcError(rpc.error.code, `MCP 调用错误 [${rpc.error.code}]: ${rpc.error.message}`, rpc.error.data);
+    }
+    return rpc.result;
+}
+export function clearWecomMcpCategoryCache(accountId, category) {
+    const key = cacheKey(accountId, category);
+    console.log(`${LOG_TAG} clear cache account=${accountId} category=${category}`);
+    mcpConfigCache.delete(key);
+    mcpSessionCache.delete(key);
+    statelessKeys.delete(key);
+    inflightInitRequests.delete(key);
+}
+export function clearWecomMcpAccountCache(accountId) {
+    const prefix = `${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 [...statelessKeys]) {
+        if (key.startsWith(prefix))
+            statelessKeys.delete(key);
+    }
+    for (const key of [...inflightInitRequests.keys()]) {
+        if (key.startsWith(prefix))
+            inflightInitRequests.delete(key);
+    }
+}
+export async function sendJsonRpc(accountId, category, method, params) {
+    const url = await getMcpUrl(accountId, category);
+    const body = {
+        jsonrpc: "2.0",
+        id: generateReqId("mcp_rpc"),
+        method,
+        ...(params !== undefined ? { params } : {}),
+    };
+    let session = await getOrCreateSession(accountId, category, url);
+    try {
+        const result = await sendRawJsonRpc(url, session, body);
+        if (result.newSessionId) {
+            session.sessionId = result.newSessionId;
+        }
+        return result.rpcResult;
+    }
+    catch (error) {
+        if (error instanceof McpRpcError && CACHE_CLEAR_ERROR_CODES.has(error.code)) {
+            clearWecomMcpCategoryCache(accountId, category);
+        }
+        if (session.stateless) {
+            throw error;
+        }
+        if (error instanceof McpHttpError && error.statusCode === 404) {
+            mcpSessionCache.delete(cacheKey(accountId, category));
+            session = await rebuildSession(accountId, category, url);
+            const result = await sendRawJsonRpc(url, session, body);
+            if (result.newSessionId) {
+                session.sessionId = result.newSessionId;
+            }
+            return result.rpcResult;
+        }
+        console.error(`${LOG_TAG} rpc failed account=${accountId} category=${category} method=${method} error=${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+}