@lwmxiaobei/xbcode 1.0.0

package/dist/mcp/manager.js

@@ -0,0 +1,275 @@
+import { McpClientConnection } from "./client.js";
+import { McpRuntimeError } from "./types.js";
+import { ellipsize } from "../utils.js";
+// 状态报告里把时间戳统一格式化为 ISO，便于日志和排查问题时直接比对。
+function formatTimestamp(value) {
+    if (!value) {
+        return "never";
+    }
+    return new Date(value).toISOString();
+}
+// 报告里只展示少量名字，避免大量工具或资源把输出刷满。
+function joinNames(values, limit = 4) {
+    if (values.length === 0) {
+        return "(none)";
+    }
+    const preview = values.slice(0, limit);
+    const suffix = values.length > limit ? `, +${values.length - limit} more` : "";
+    return `${preview.join(", ")}${suffix}`;
+}
+// McpManager 管理“多个服务连接”的生命周期。
+// 它本身不直接和 SDK 通信，而是把工作分发给每个 McpClientConnection。
+export class McpManager {
+    connections = new Map();
+    configWarnings = [];
+    initialized = false;
+    configSignature = "";
+    // 根据最新配置增删改连接对象。
+    // 如果配置签名没变，直接跳过，避免重复关闭和重建连接。
+    async configure(configs, configWarnings = []) {
+        const signature = JSON.stringify({ configs, configWarnings });
+        if (signature === this.configSignature) {
+            return;
+        }
+        const nextConnections = new Map();
+        for (const config of configs) {
+            const existing = this.connections.get(config.name);
+            if (existing) {
+                existing.updateConfig(config);
+                nextConnections.set(config.name, existing);
+            }
+            else {
+                nextConnections.set(config.name, new McpClientConnection(config));
+            }
+        }
+        const removed = [...this.connections.entries()]
+            .filter(([name]) => !nextConnections.has(name))
+            .map(([, connection]) => connection);
+        await Promise.allSettled(removed.map((connection) => connection.close()));
+        const disabled = [...nextConnections.values()]
+            .filter((connection) => !connection.getState().enabled);
+        await Promise.allSettled(disabled.map((connection) => connection.close()));
+        this.connections = nextConnections;
+        this.configWarnings = [...configWarnings];
+        this.configSignature = signature;
+        this.initialized = false;
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    // 仅初始化启用的服务，并容忍个别服务初始化失败。
+    async initializeAll() {
+        if (this.initialized) {
+            return;
+        }
+        const enabledConnections = [...this.connections.values()]
+            .filter((connection) => connection.getState().enabled);
+        await Promise.allSettled(enabledConnections.map((connection) => connection.initialize()));
+        this.initialized = true;
+    }
+    // 刷新单个服务时做精确刷新；不传名称时刷新全部服务缓存和连接状态。
+    async refresh(serverName) {
+        if (serverName) {
+            const connection = this.connections.get(serverName);
+            if (!connection) {
+                throw new McpRuntimeError("server_not_found", `MCP server "${serverName}" is not configured.`);
+            }
+            await connection.refresh();
+            this.initialized = true;
+            return;
+        }
+        await Promise.allSettled([...this.connections.values()].map((connection) => connection.refresh()));
+        this.initialized = true;
+    }
+    // 返回排序后的服务状态，保证上层展示稳定，不受 Map 插入顺序影响。
+    listServers() {
+        return [...this.connections.values()]
+            .map((connection) => connection.getState())
+            .sort((left, right) => left.name.localeCompare(right.name));
+    }
+    // 把完整状态裁剪成更适合模型消费的能力摘要。
+    listCapabilities() {
+        return this.listServers().map((state) => ({
+            server: state.name,
+            status: state.status,
+            supportedKinds: this.getSupportedKinds(state),
+            toolCount: state.cache.tools.length,
+            resourceCount: state.cache.resources.length,
+            promptCount: state.cache.prompts.length,
+            tools: state.cache.tools.map((tool) => tool.name),
+            resources: state.cache.resources.map((resource) => resource.uri),
+            prompts: state.cache.prompts.map((prompt) => prompt.name),
+            error: state.error,
+        }));
+    }
+    getStatusSummary() {
+        return this.computeStatusSummary(this.listServers());
+    }
+    getConfigWarnings() {
+        return [...this.configWarnings];
+    }
+    // 生成简短的提示词摘要，告诉模型当前有哪些 MCP 服务和能力可用。
+    buildPromptSummary() {
+        const states = this.listServers().filter((state) => state.enabled);
+        if (states.length === 0) {
+            return "MCP runtime: no configured servers.";
+        }
+        const lines = [
+            "MCP runtime:",
+            "- MCP tools are exposed as regular function tools. Call those tools directly.",
+            "- Use `list_mcp_resources` and `read_mcp_resource` for MCP resource access.",
+            "- Use `mcp_call` only for MCP prompt access.",
+            "- Unsupported in this client: sampling, roots, elicitation.",
+            "- Use exact cached server, resource, and prompt names. Do not guess missing names.",
+        ];
+        for (const state of states.slice(0, 6)) {
+            const supportedKinds = this.getSupportedKinds(state);
+            const capabilities = supportedKinds.join(", ") || "none";
+            const resources = joinNames(state.cache.resources.map((resource) => resource.uri));
+            const prompts = joinNames(state.cache.prompts.map((prompt) => prompt.name));
+            const errorSuffix = state.error ? ` error=${ellipsize(state.error, 120)}` : "";
+            lines.push(`- ${state.name} [${state.status}] capabilities=${capabilities} tools=${state.cache.tools.length} resources=${resources} prompts=${prompts}${errorSuffix}`);
+        }
+        if (states.length > 6) {
+            lines.push(`- ${states.length - 6} more MCP server(s) omitted from prompt summary.`);
+        }
+        if (this.configWarnings.length > 0) {
+            lines.push(`- Config warnings present. Use /mcp to inspect them.`);
+        }
+        return lines.join("\n");
+    }
+    // 启动摘要聚焦“有哪些可用 server 和 tool”，方便用户一眼确认当前连接面。
+    formatStartupReport() {
+        const states = this.listServers().filter((state) => state.enabled);
+        const lines = ["MCP servers on startup:"];
+        if (states.length === 0) {
+            lines.push("(no enabled MCP servers)");
+        }
+        else {
+            for (const state of states) {
+                lines.push(`- ${state.name} [${state.status}] ${state.transport}`);
+                if (state.error) {
+                    lines.push(`  error: ${ellipsize(state.error, 240)}`);
+                }
+            }
+        }
+        if (this.configWarnings.length > 0) {
+            lines.push("", "warnings:");
+            for (const warning of this.configWarnings) {
+                lines.push(`- ${warning}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    // 生成人类可读的完整状态报告，主要用于命令行诊断。
+    formatStatusReport() {
+        const states = this.listServers();
+        const summary = this.computeStatusSummary(states);
+        const lines = [
+            `MCP servers: configured ${summary.configured} | enabled ${summary.enabled} | connected ${summary.connected} | degraded ${summary.degraded} | disconnected ${summary.disconnected} | disabled ${summary.disabled}`,
+        ];
+        if (this.configWarnings.length > 0) {
+            lines.push("");
+            for (const warning of this.configWarnings) {
+                lines.push(`warning: ${warning}`);
+            }
+        }
+        if (states.length === 0) {
+            lines.push("", "(no MCP servers configured)");
+            return lines.join("\n");
+        }
+        for (const state of states) {
+            const supportedKinds = this.getSupportedKinds(state);
+            const capabilities = supportedKinds.join(", ") || "none";
+            const cacheLine = `  cache: tools=${state.cache.tools.length} [${joinNames(state.cache.tools.map((tool) => tool.name))}] | resources=${state.cache.resources.length} [${joinNames(state.cache.resources.map((resource) => resource.uri))}] | prompts=${state.cache.prompts.length} [${joinNames(state.cache.prompts.map((prompt) => prompt.name))}]`;
+            lines.push("", `- ${state.name} [${state.status}] ${state.transport}`, `  location: ${state.location}`, `  timeout: ${state.timeoutMs}ms`, `  capabilities: ${capabilities}`, cacheLine, `  last connected: ${formatTimestamp(state.lastConnectedAt)}`, `  last refresh: ${formatTimestamp(state.lastRefreshAt)}`);
+            if (state.error) {
+                lines.push(`  error: ${ellipsize(state.error, 320)}`);
+            }
+            if (state.lastStderr) {
+                lines.push(`  stderr: ${ellipsize(state.lastStderr.replaceAll(/\s+/g, " ").trim(), 320)}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    // 以下三个方法是面向上层的统一分发入口。
+    async callTool(server, tool, args) {
+        return this.getConnection(server).callTool(tool, args);
+    }
+    async readResource(server, uri) {
+        return this.getConnection(server).readResource(uri);
+    }
+    async getPrompt(server, name, args) {
+        return this.getConnection(server).getPrompt(name, args);
+    }
+    listResourceDefinitions(server) {
+        if (server) {
+            const state = this.getConnection(server).getState();
+            return state.cache.resources.map((resource) => ({
+                server: state.name,
+                uri: resource.uri,
+                name: resource.name,
+                description: resource.description,
+                mimeType: resource.mimeType,
+            }));
+        }
+        return this.listServers().flatMap((state) => state.cache.resources.map((resource) => ({
+            server: state.name,
+            uri: resource.uri,
+            name: resource.name,
+            description: resource.description,
+            mimeType: resource.mimeType,
+        })));
+    }
+    // 统一做服务存在性校验，避免每个调用入口重复写同样逻辑。
+    getConnection(serverName) {
+        const connection = this.connections.get(serverName);
+        if (!connection) {
+            throw new McpRuntimeError("server_not_found", `MCP server "${serverName}" is not configured.`);
+        }
+        return connection;
+    }
+    // 聚合各服务状态，便于上层快速判断 MCP 整体健康度。
+    computeStatusSummary(states) {
+        const summary = {
+            configured: 0,
+            enabled: 0,
+            connected: 0,
+            degraded: 0,
+            disabled: 0,
+            disconnected: 0,
+        };
+        for (const state of states) {
+            summary.configured += 1;
+            if (!state.enabled || state.status === "disabled") {
+                summary.disabled += 1;
+                continue;
+            }
+            summary.enabled += 1;
+            if (state.status === "connected") {
+                summary.connected += 1;
+            }
+            else if (state.status === "degraded") {
+                summary.degraded += 1;
+            }
+            else if (state.status === "disconnected") {
+                summary.disconnected += 1;
+            }
+        }
+        return summary;
+    }
+    // 从服务能力对象中提取当前客户端真正支持的调用种类。
+    getSupportedKinds(state) {
+        const supported = [];
+        if (state.capabilities?.tools) {
+            supported.push("tool");
+        }
+        if (state.capabilities?.resources) {
+            supported.push("resource");
+        }
+        if (state.capabilities?.prompts) {
+            supported.push("prompt");
+        }
+        return supported;
+    }
+}

package/dist/mcp/runtime.js

@@ -0,0 +1,420 @@
+import { getSettingsWarnings, loadSettings, reloadSettings } from "../config.js";
+import { McpManager } from "./manager.js";
+import { McpRuntimeError } from "./types.js";
+import { isPlainRecord } from "../utils.js";
+const OUTPUT_LIMIT = 50_000;
+const DYNAMIC_MCP_TOOL_NAME_LIMIT = 64;
+// 运行时只维护一个全局 McpManager，供工具调用和命令共享。
+export const mcpManager = new McpManager();
+// 初始化过程可能被多个并发调用触发，这里用 promise 去重。
+let initializePromise = null;
+// 把基础标量类型稳定转成字符串；复杂对象交给 JSON 格式化处理。
+function stringifyScalar(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+        return `${value}`;
+    }
+    if (typeof value === "symbol") {
+        return value.toString();
+    }
+    if (value === undefined || value === null) {
+        return "";
+    }
+    return formatJson(value);
+}
+// 工具参数里的 server/kind/name/uri 理论上都应是字符串，这里统一做裁剪和兜底转换。
+function normalizeStringInput(value) {
+    return stringifyScalar(value).trim();
+}
+function stableHash(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(36);
+}
+function sanitizeDynamicToolSegment(value) {
+    const sanitized = value
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9_]+/g, "_")
+        .replaceAll(/^_+|_+$/g, "");
+    return sanitized || "tool";
+}
+function buildDynamicToolName(server, tool) {
+    const readable = `mcp__${sanitizeDynamicToolSegment(server)}__${sanitizeDynamicToolSegment(tool)}`;
+    const trimmed = readable.slice(0, DYNAMIC_MCP_TOOL_NAME_LIMIT).replaceAll(/_+$/g, "") || "mcp";
+    return trimmed;
+}
+function normalizeDynamicToolSchema(schema) {
+    if (!schema) {
+        return {
+            type: "object",
+            properties: {},
+            additionalProperties: true,
+        };
+    }
+    if (schema.type === undefined) {
+        return {
+            type: "object",
+            ...schema,
+        };
+    }
+    return schema;
+}
+function buildDynamicToolDescription(server, tool, description) {
+    const prefix = `MCP tool "${tool}" from server "${server}".`;
+    const suffix = description?.trim();
+    return suffix ? `${prefix} ${suffix}` : prefix;
+}
+function ensureUniqueDynamicToolName(name, usedNames, server, tool) {
+    if (!usedNames.has(name)) {
+        usedNames.add(name);
+        return name;
+    }
+    const hash = stableHash(`${server}\u0000${tool}`);
+    const maxBaseLength = Math.max(1, DYNAMIC_MCP_TOOL_NAME_LIMIT - hash.length - 2);
+    const trimmed = name.slice(0, maxBaseLength).replaceAll(/_+$/g, "") || "mcp";
+    const fallback = `${trimmed}__${hash}`;
+    usedNames.add(fallback);
+    return fallback;
+}
+// 限制最终字符串输出长度，避免工具结果把上下文窗口塞满。
+function limitText(text, maxLength = OUTPUT_LIMIT) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxLength - 30))}\n... (truncated)`;
+}
+// 统一 JSON 格式化入口；遇到循环引用等情况时退化成普通字符串。
+function formatJson(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return Object.prototype.toString.call(value);
+    }
+}
+// 资源内容既可能是纯文本，也可能是 base64 二进制，这里统一转成人类可读文本。
+function formatEmbeddedResource(resource) {
+    const mime = resource?.mimeType ? ` (${resource.mimeType})` : "";
+    if (typeof resource?.text === "string") {
+        return `resource ${resource.uri}${mime}\n${resource.text}`;
+    }
+    if (typeof resource?.blob === "string") {
+        return `resource ${resource?.uri ?? "(unknown)"}${mime}\n[binary data: ${resource.blob.length} base64 chars]`;
+    }
+    return formatJson(resource);
+}
+// MCP content item 是一个联合类型，这里把不同类型收敛到统一字符串表示。
+function formatContentItem(item) {
+    switch (item?.type) {
+        case "text":
+            return String(item.text ?? "");
+        case "image":
+            return `[image ${item.mimeType ?? "unknown"}, ${String(item.data ?? "").length} base64 chars]`;
+        case "audio":
+            return `[audio ${item.mimeType ?? "unknown"}, ${String(item.data ?? "").length} base64 chars]`;
+        case "resource":
+            return formatEmbeddedResource(item.resource);
+        case "resource_link": {
+            const description = item.description ? `\n${item.description}` : "";
+            return `resource link: ${item.name ?? "(unnamed)"} -> ${item.uri ?? "(unknown)"}${description}`;
+        }
+        default:
+            return formatJson(item);
+    }
+}
+// 把 content 列表拼成统一文本块，空内容时返回 undefined 让上层省略该段。
+function formatContentList(items) {
+    const parts = items
+        .map((item) => formatContentItem(item).trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        return undefined;
+    }
+    return `content:\n${parts.join("\n\n")}`;
+}
+function formatSchemaSummary(value) {
+    if (value === null)
+        return "null";
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return "[]";
+        return `[${formatSchemaSummary(value[0])}]`;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value).slice(0, 8);
+        const suffix = Object.keys(value).length > entries.length ? ", ..." : "";
+        return `{${entries.map(([key, item]) => `${key}: ${formatSchemaSummary(item)}`).join(", ")}${suffix}}`;
+    }
+    return typeof value;
+}
+// tool 调用结果通常最复杂，可能同时带 content、structuredContent、toolResult 和 _meta。
+function formatToolResult(server, name, result) {
+    const lines = [
+        `server: ${server}`,
+        "kind: tool",
+        `tool: ${name}`,
+    ];
+    if ("isError" in result) {
+        lines.push(`status: ${result.isError ? "error" : "ok"}`);
+    }
+    if ("content" in result && Array.isArray(result.content)) {
+        const content = formatContentList(result.content);
+        if (content) {
+            lines.push("", content);
+        }
+    }
+    if ("structuredContent" in result && result.structuredContent !== undefined) {
+        lines.push("", `structuredContent (${formatSchemaSummary(result.structuredContent)}):`, formatJson(result.structuredContent));
+    }
+    if ("toolResult" in result && result.toolResult !== undefined) {
+        lines.push("", `toolResult (${formatSchemaSummary(result.toolResult)}):`, formatJson(result.toolResult));
+    }
+    if (result._meta) {
+        lines.push("", "_meta:", formatJson(result._meta));
+    }
+    return limitText(lines.join("\n"));
+}
+// resource 读取结果可能返回多个内容块，这里逐个展开。
+function formatReadResourceResult(server, uri, result) {
+    const lines = [
+        `server: ${server}`,
+        "kind: resource",
+        `uri: ${uri}`,
+    ];
+    const contents = result.contents
+        .map((content) => formatEmbeddedResource(content).trim())
+        .filter(Boolean);
+    if (contents.length > 0) {
+        lines.push("", "contents:", contents.join("\n\n"));
+    }
+    if (result._meta) {
+        lines.push("", "_meta:", formatJson(result._meta));
+    }
+    return limitText(lines.join("\n"));
+}
+// prompt 结果本质上是一组 role + content 的消息，用文本视图展开便于模型继续消费。
+function formatPromptResult(server, name, result) {
+    const lines = [
+        `server: ${server}`,
+        "kind: prompt",
+        `prompt: ${name}`,
+    ];
+    if (result.description) {
+        lines.push(`description: ${result.description}`);
+    }
+    if (Array.isArray(result.messages) && result.messages.length > 0) {
+        lines.push("", "messages:");
+        for (const message of result.messages) {
+            lines.push(`[${message.role}]`, formatContentItem(message.content), "");
+        }
+        if (lines.at(-1) === "") {
+            lines.pop();
+        }
+    }
+    if (result._meta) {
+        lines.push("", "_meta:", formatJson(result._meta));
+    }
+    return limitText(lines.join("\n"));
+}
+function formatResourceList(server) {
+    const items = mcpManager.listResourceDefinitions(server);
+    const lines = [
+        `kind: resource_list`,
+        `scope: ${server ?? "all"}`,
+        `count: ${items.length}`,
+    ];
+    if (items.length === 0) {
+        lines.push("", "(no resources found)");
+        return lines.join("\n");
+    }
+    lines.push("", "resources:");
+    for (const item of items) {
+        const mime = item.mimeType ? ` mime=${item.mimeType}` : "";
+        const description = item.description ? `\n  description: ${item.description}` : "";
+        lines.push(`- [${item.server}] ${item.name} -> ${item.uri}${mime}${description}`);
+    }
+    return limitText(lines.join("\n"));
+}
+async function handleDynamicMcpToolCall(server, name, args) {
+    try {
+        await ensureMcpInitialized();
+        if (!isPlainRecord(args)) {
+            throw new McpRuntimeError("invalid_arguments", `MCP tool "${name}" arguments must be an object.`);
+        }
+        const result = await mcpManager.callTool(server, name, args);
+        return formatToolResult(server, name, result);
+    }
+    catch (error) {
+        return formatRuntimeError(error);
+    }
+}
+// MCP prompt 的参数要求是 string map；外部传入 unknown 时需要先做归一化。
+function normalizePromptArguments(args) {
+    if (!args || Object.keys(args).length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(Object.entries(args).map(([key, value]) => {
+        if (typeof value === "string") {
+            return [key, value];
+        }
+        if (value === undefined || value === null) {
+            return [key, ""];
+        }
+        if (typeof value === "object") {
+            return [key, formatJson(value)];
+        }
+        return [key, stringifyScalar(value)];
+    }));
+}
+// 对外统一错误字符串格式，避免底层异常对象直接泄漏给工具层。
+function formatRuntimeError(error) {
+    if (error instanceof McpRuntimeError) {
+        return `Error: [${error.code}] ${error.message}`;
+    }
+    if (error instanceof Error) {
+        return `Error: ${error.message}`;
+    }
+    return `Error: ${stringifyScalar(error) || "Unknown error"}`;
+}
+// 对 mcp_call 的工具参数做严格校验，尽量在发请求前就拦住明显错误。
+function validateMcpCallArgs(args) {
+    const server = normalizeStringInput(args.server);
+    const kind = normalizeStringInput(args.kind);
+    const name = normalizeStringInput(args.name);
+    if (!server) {
+        throw new McpRuntimeError("invalid_arguments", "mcp_call requires a non-empty server.");
+    }
+    if (kind !== "prompt") {
+        throw new McpRuntimeError("invalid_arguments", `mcp_call kind must be "prompt". Received "${kind || "(empty)"}".`);
+    }
+    if (args.arguments !== undefined && !isPlainRecord(args.arguments)) {
+        throw new McpRuntimeError("invalid_arguments", "mcp_call arguments must be an object when provided.");
+    }
+    if (!name) {
+        throw new McpRuntimeError("invalid_arguments", "mcp_call kind=prompt requires name.");
+    }
+    return {
+        server,
+        kind: "prompt",
+        name: name || undefined,
+        arguments: args.arguments,
+    };
+}
+// 从配置系统同步 MCP 设置，并按需决定是否立刻初始化连接。
+async function syncFromSettings(options) {
+    const settings = options?.reload ? reloadSettings() : loadSettings();
+    const warnings = getSettingsWarnings().filter((warning) => warning.startsWith("[mcp]"));
+    await mcpManager.configure(settings.mcp?.servers ?? [], warnings);
+    if (options?.initialize) {
+        await mcpManager.initializeAll();
+    }
+    return mcpManager;
+}
+// 确保 MCP 至少初始化一次；并发场景下复用同一个初始化 promise。
+export async function ensureMcpInitialized() {
+    if (mcpManager.isInitialized()) {
+        return mcpManager;
+    }
+    initializePromise ??= syncFromSettings({ initialize: true }).finally(() => {
+        initializePromise = null;
+    });
+    return initializePromise;
+}
+// 配置热更新入口：先重读配置，再刷新一个或全部服务。
+export async function refreshMcpFromSettings(serverName) {
+    await syncFromSettings({ reload: true, initialize: false });
+    await mcpManager.refresh(serverName);
+    return mcpManager;
+}
+// 在后台悄悄触发一次初始化，适合程序启动时预热。
+export function primeMcpRuntime() {
+    void ensureMcpInitialized();
+}
+// 给主提示词拼接 MCP 能力摘要。
+export function getMcpPromptInstructions() {
+    return mcpManager.buildPromptSummary();
+}
+export async function getDynamicMcpToolSurface() {
+    await ensureMcpInitialized();
+    const responseTools = [];
+    const handlers = {};
+    const usedNames = new Set();
+    for (const state of mcpManager.listServers()) {
+        if (!state.enabled || state.cache.tools.length === 0) {
+            continue;
+        }
+        for (const tool of state.cache.tools) {
+            const dynamicName = ensureUniqueDynamicToolName(buildDynamicToolName(state.name, tool.name), usedNames, state.name, tool.name);
+            const parameters = normalizeDynamicToolSchema(tool.inputSchema);
+            responseTools.push({
+                type: "function",
+                name: dynamicName,
+                description: buildDynamicToolDescription(state.name, tool.name, tool.description),
+                parameters,
+            });
+            handlers[dynamicName] = (args) => handleDynamicMcpToolCall(state.name, tool.name, args);
+        }
+    }
+    const chatTools = responseTools.map((tool) => ({
+        type: "function",
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        },
+    }));
+    return {
+        responseTools,
+        chatTools,
+        handlers,
+    };
+}
+// mcp_call 工具的统一执行入口。
+// 这里负责初始化、参数校验、按 kind 分发，以及最终结果格式化。
+export async function handleMcpCall(args) {
+    try {
+        await ensureMcpInitialized();
+        const call = validateMcpCallArgs(args);
+        const result = await mcpManager.getPrompt(call.server, call.name ?? "", normalizePromptArguments(call.arguments));
+        return formatPromptResult(call.server, call.name ?? "", result);
+    }
+    catch (error) {
+        return formatRuntimeError(error);
+    }
+}
+export async function handleListMcpResources(args) {
+    try {
+        await ensureMcpInitialized();
+        const server = args.server === undefined ? undefined : normalizeStringInput(args.server);
+        if (args.server !== undefined && !server) {
+            throw new McpRuntimeError("invalid_arguments", "list_mcp_resources server must be a non-empty string when provided.");
+        }
+        return formatResourceList(server);
+    }
+    catch (error) {
+        return formatRuntimeError(error);
+    }
+}
+export async function handleReadMcpResource(args) {
+    try {
+        await ensureMcpInitialized();
+        const server = normalizeStringInput(args.server);
+        const uri = normalizeStringInput(args.uri);
+        if (!server) {
+            throw new McpRuntimeError("invalid_arguments", "read_mcp_resource requires a non-empty server.");
+        }
+        if (!uri) {
+            throw new McpRuntimeError("invalid_arguments", "read_mcp_resource requires a non-empty uri.");
+        }
+        const result = await mcpManager.readResource(server, uri);
+        return formatReadResourceResult(server, uri, result);
+    }
+    catch (error) {
+        return formatRuntimeError(error);
+    }
+}