@next-open-ai/openbot 0.2.1 → 0.3.2

package/dist/core/agent/agent-manager.js

@@ -3,7 +3,8 @@ import { join } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
 import { createCompactionMemoryExtensionFactory } from "../memory/compaction-extension.js";
 import { getCompactionContextForSystemPrompt } from "../memory/index.js";
-import { createBrowserTool, createSaveExperienceTool, createInstallSkillTool } from "../tools/index.js";
+import { createBrowserTool, createSaveExperienceTool, createInstallSkillTool, createGetBookmarkTagsTool, createSaveBookmarkTool } from "../tools/index.js";
+import { createMcpToolsForSession } from "../mcp/index.js";
 import { registerBuiltInApiProviders } from "@mariozechner/pi-ai/dist/providers/register-builtins.js";
 import { getOpenbotAgentDir, getOpenbotWorkspaceDir, ensureDefaultAgentDir } from "./agent-dir.js";
 import { formatSkillsForPrompt } from "./skills.js";
@@ -233,6 +234,15 @@ For downloads, provide either a direct URL or a selector to click.`;
             grep: createGrepTool(sessionWorkspaceDir),
             ls: createLsTool(sessionWorkspaceDir),
         };
+        const mcpTools = await createMcpToolsForSession({ mcpServers: options.mcpServers });
+        const customTools = [
+            createBrowserTool(sessionWorkspaceDir),
+            createSaveExperienceTool(sessionId),
+            createInstallSkillTool(options.targetAgentId),
+            createGetBookmarkTagsTool(),
+            createSaveBookmarkTool(),
+            ...mcpTools,
+        ];
         const { session } = await createAgentSession({
             agentDir: this.agentDir,
             sessionManager: CoreSessionManager.inMemory(),
@@ -240,11 +250,7 @@ For downloads, provide either a direct URL or a selector to click.`;
             modelRegistry,
             cwd: sessionWorkspaceDir,
             resourceLoader: loader,
-            customTools: [
-                createBrowserTool(sessionWorkspaceDir),
-                createSaveExperienceTool(sessionId),
-                createInstallSkillTool(options.targetAgentId),
-            ],
+            customTools,
             baseToolsOverride: coreTools,
         });
         const model = modelRegistry.find(provider, modelId);

package/dist/core/config/desktop-config.d.ts

@@ -7,6 +7,8 @@ export interface RagEmbeddingConfig {
     apiKey?: string;
     baseUrl?: string;
 }
+/** MCP 服务器配置（与 core/mcp 类型一致，避免 core/config 依赖 core/mcp 实现） */
+export type DesktopMcpServerConfig = import("../mcp/index.js").McpServerConfig;
 /**
  * 同步读取桌面全局配置中的 maxAgentSessions 等。
  * Gateway 进程内使用，用于会话上限等。
@@ -22,6 +24,8 @@ export interface DesktopAgentConfig {
     apiKey?: string;
     /** 工作区名，来自 agents.json 的 agent.workspace 或 agent.id */
     workspace?: string;
+    /** MCP 服务器配置，创建 Session 时传入 */
+    mcpServers?: DesktopMcpServerConfig[];
 }
 /**
  * 从 config.json 读取缺省智能体 id（defaultAgentId）。

package/dist/core/config/desktop-config.js

@@ -145,6 +145,7 @@ export async function loadDesktopAgentConfig(agentId) {
         }
     }
     let workspaceName = resolvedAgentId;
+    let mcpServers;
     if (existsSync(agentsPath)) {
         try {
             const raw = await readFile(agentsPath, "utf-8");
@@ -156,6 +157,9 @@ export async function loadDesktopAgentConfig(agentId) {
                     workspaceName = agent.workspace;
                 else if (agent.id)
                     workspaceName = agent.id;
+                if (agent.mcpServers && Array.isArray(agent.mcpServers)) {
+                    mcpServers = agent.mcpServers;
+                }
                 if (agent.modelItemCode && Array.isArray(config.configuredModels)) {
                     const configured = config.configuredModels.find((m) => m.modelItemCode === agent.modelItemCode);
                     if (configured) {
@@ -185,7 +189,7 @@ export async function loadDesktopAgentConfig(agentId) {
     const apiKey = provConfig?.apiKey && typeof provConfig.apiKey === "string" && provConfig.apiKey.trim()
         ? provConfig.apiKey.trim()
         : undefined;
-    return { provider, model, apiKey: apiKey ?? undefined, workspace: workspaceName };
+    return { provider, model, apiKey: apiKey ?? undefined, workspace: workspaceName, mcpServers };
 }
 function ensureDesktopDir() {
     const desktopDir = getDesktopDir();

package/dist/core/installer/index.d.ts

@@ -1 +1 @@
-export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, type InstallByUrlOptions, type InstallByUrlResult, type InstallFromPathOptions, type InstallFromPathResult, } from "./skill-installer.js";
+export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, installSkillFromUpload, type InstallByUrlOptions, type InstallByUrlResult, type InstallFromPathOptions, type InstallFromPathResult, type InstallFromUploadOptions, } from "./skill-installer.js";

package/dist/core/installer/index.js

@@ -1 +1 @@
-export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, } from "./skill-installer.js";
+export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, installSkillFromUpload, } from "./skill-installer.js";

package/dist/core/installer/skill-installer.d.ts

@@ -28,3 +28,12 @@ export interface InstallFromPathResult {
  * 从本地目录安装技能：将指定目录复制到目标 skills 目录。
  */
 export declare function installSkillFromPath(localPath: string, options?: InstallFromPathOptions): Promise<InstallFromPathResult>;
+export interface InstallFromUploadOptions {
+    scope: "global" | "workspace";
+    workspace?: string;
+}
+/**
+ * 从上传的 zip 安装技能：解压到临时目录，校验为单个技能目录（含 SKILL.md），再复制到目标。
+ * 支持两种 zip 结构：① 单个顶层目录且内含 SKILL.md；② 根目录直接含 SKILL.md（将视为技能根目录）。
+ */
+export declare function installSkillFromUpload(zipBuffer: Buffer, options?: InstallFromUploadOptions): Promise<InstallFromPathResult>;

package/dist/core/installer/skill-installer.js

@@ -7,6 +7,7 @@ import { existsSync } from "fs";
 import { join, resolve, basename } from "path";
 import { tmpdir } from "os";
 import { randomUUID } from "crypto";
+import AdmZip from "adm-zip";
 import { exec } from "child_process";
 import { promisify } from "util";
 import { homedir } from "os";
@@ -119,3 +120,96 @@ export async function installSkillFromPath(localPath, options = { scope: "global
     await cp(srcResolved, destPath, { recursive: true });
     return { installDir: targetDir, name: baseName };
 }
+/** 上传 zip 包最大体积（字节） */
+const MAX_UPLOAD_ZIP_BYTES = 10 * 1024 * 1024;
+/** 解压后忽略的条目（系统/打包产生的噪音） */
+const IGNORED_ZIP_ENTRIES = new Set(["__MACOSX", ".DS_Store", ".git", "Thumbs.db"]);
+function isIgnoredZipEntry(name) {
+    if (!name || name.includes(".."))
+        return true;
+    if (IGNORED_ZIP_ENTRIES.has(name))
+        return true;
+    if (name.startsWith("."))
+        return true;
+    return false;
+}
+/**
+ * 从上传的 zip 安装技能：解压到临时目录，校验为单个技能目录（含 SKILL.md），再复制到目标。
+ * 支持两种 zip 结构：① 单个顶层目录且内含 SKILL.md；② 根目录直接含 SKILL.md（将视为技能根目录）。
+ */
+export async function installSkillFromUpload(zipBuffer, options = { scope: "global", workspace: "default" }) {
+    if (zipBuffer.length > MAX_UPLOAD_ZIP_BYTES) {
+        throw new Error("zip 包不能超过 10MB");
+    }
+    const tempDir = join(tmpdir(), `openbot-upload-${randomUUID()}`);
+    try {
+        await mkdir(tempDir, { recursive: true });
+        const zip = new AdmZip(zipBuffer);
+        zip.extractAllTo(tempDir, true);
+        const allEntries = await readdir(tempDir);
+        const entries = allEntries.filter((e) => !isIgnoredZipEntry(e));
+        let skillPath;
+        if (entries.length === 0) {
+            throw new Error("zip 解压后未得到有效内容，请检查 zip 是否包含技能目录或 SKILL.md");
+        }
+        if (entries.length === 1) {
+            const singleName = entries[0];
+            const candidatePath = join(tempDir, singleName);
+            const statEntry = await stat(candidatePath);
+            if (statEntry.isDirectory()) {
+                const skillMdInDir = join(candidatePath, "SKILL.md");
+                if (existsSync(skillMdInDir)) {
+                    skillPath = candidatePath;
+                }
+                else {
+                    throw new Error("该目录下未找到 SKILL.md，请确保 zip 内技能目录根目录含有 SKILL.md 文件");
+                }
+            }
+            else {
+                if (existsSync(join(tempDir, "SKILL.md"))) {
+                    throw new Error("zip 根目录含有 SKILL.md，但根目录下还有其它文件，请将整个技能放在一个子目录内再打包");
+                }
+                throw new Error("zip 内未找到包含 SKILL.md 的技能目录，请检查打包方式");
+            }
+        }
+        else {
+            const skillMdAtRoot = existsSync(join(tempDir, "SKILL.md"));
+            const dirsWithSkillMd = [];
+            for (const e of entries) {
+                const p = join(tempDir, e);
+                const st = await stat(p).catch(() => null);
+                if (st?.isDirectory() && existsSync(join(p, "SKILL.md")))
+                    dirsWithSkillMd.push(p);
+            }
+            if (dirsWithSkillMd.length === 1) {
+                skillPath = dirsWithSkillMd[0];
+            }
+            else if (dirsWithSkillMd.length > 1) {
+                throw new Error("zip 内包含多个技能目录，请只保留一个技能目录再打包");
+            }
+            else if (skillMdAtRoot) {
+                skillPath = tempDir;
+            }
+            else {
+                throw new Error("zip 内未找到包含 SKILL.md 的技能目录；若为多文件打包，请将 SKILL.md 放在 zip 根目录或单个子目录内");
+            }
+        }
+        if (skillPath === tempDir) {
+            const baseName = "skill";
+            const wrappedDir = join(tmpdir(), `openbot-skill-wrap-${randomUUID()}`);
+            try {
+                await mkdir(wrappedDir, { recursive: true });
+                const destPath = join(wrappedDir, baseName);
+                await cp(tempDir, destPath, { recursive: true });
+                return await installSkillFromPath(destPath, options);
+            }
+            finally {
+                await rm(wrappedDir, { recursive: true, force: true }).catch(() => { });
+            }
+        }
+        return await installSkillFromPath(skillPath, options);
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true }).catch(() => { });
+    }
+}

package/dist/core/mcp/adapter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MCP Tool 转为 pi-coding-agent ToolDefinition 的适配层。
+ */
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+import type { McpTool } from "./types.js";
+import type { McpClient } from "./client.js";
+/**
+ * 将单个 MCP 工具封装为 pi-coding-agent 的 ToolDefinition。
+ * @param tool MCP tools/list 返回的项
+ * @param client 已连接的 McpClient，用于 callTool
+ * @param serverId 可选前缀，用于避免多 MCP 时工具名冲突
+ */
+export declare function mcpToolToToolDefinition(tool: McpTool, client: McpClient, serverId?: string): ToolDefinition;
+/**
+ * 将某 MCP 客户端的全部工具转为 ToolDefinition 数组。
+ */
+export declare function mcpToolsToToolDefinitions(tools: McpTool[], client: McpClient, serverId?: string): ToolDefinition[];

package/dist/core/mcp/adapter.js

@@ -0,0 +1,49 @@
+/**
+ * MCP Tool 转为 pi-coding-agent ToolDefinition 的适配层。
+ */
+import { Type } from "@sinclair/typebox";
+/** 通用参数：MCP 工具接受任意 JSON 对象作为 arguments */
+const McpToolParamsSchema = Type.Record(Type.String(), Type.Any());
+/**
+ * 将单个 MCP 工具封装为 pi-coding-agent 的 ToolDefinition。
+ * @param tool MCP tools/list 返回的项
+ * @param client 已连接的 McpClient，用于 callTool
+ * @param serverId 可选前缀，用于避免多 MCP 时工具名冲突
+ */
+export function mcpToolToToolDefinition(tool, client, serverId) {
+    const name = serverId ? `${serverId}_${tool.name}` : tool.name;
+    const description = (tool.description ?? "").trim() || `MCP tool: ${tool.name}`;
+    return {
+        name,
+        label: tool.name,
+        description,
+        parameters: McpToolParamsSchema,
+        execute: async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+            const args = params && typeof params === "object" ? params : {};
+            try {
+                const result = await client.callTool(tool.name, args);
+                const text = result.content
+                    ?.filter((c) => c.type === "text")
+                    .map((c) => c.text)
+                    .join("\n") ?? (result.isError ? "MCP 调用返回错误" : "");
+                return {
+                    content: [{ type: "text", text }],
+                    details: result.isError ? { isError: true } : undefined,
+                };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `MCP 调用失败: ${msg}` }],
+                    details: undefined,
+                };
+            }
+        },
+    };
+}
+/**
+ * 将某 MCP 客户端的全部工具转为 ToolDefinition 数组。
+ */
+export function mcpToolsToToolDefinitions(tools, client, serverId) {
+    return tools.map((t) => mcpToolToToolDefinition(t, client, serverId));
+}

package/dist/core/mcp/client.d.ts

@@ -0,0 +1,24 @@
+/**
+ * MCP 客户端：连接、list_tools、call_tool、断开。
+ * 支持 stdio（本地进程）与 sse（远程 HTTP）两种传输。
+ */
+import type { McpTool, McpToolCallResult, IMcpTransport } from "./types.js";
+import type { McpServerConfig } from "./types.js";
+export interface McpClientOptions {
+    initTimeoutMs?: number;
+    requestTimeoutMs?: number;
+}
+export declare class McpClient {
+    private transport;
+    private _tools;
+    private _requestId;
+    constructor(configOrTransport: McpServerConfig | IMcpTransport, options?: McpClientOptions);
+    /** 建立连接并完成握手；成功后可使用 listTools / callTool */
+    connect(): Promise<void>;
+    /** 获取工具列表（会缓存；断开重连后需重新 list） */
+    listTools(): Promise<McpTool[]>;
+    /** 调用指定工具 */
+    callTool(name: string, args: Record<string, unknown>): Promise<McpToolCallResult>;
+    close(): Promise<void>;
+    get isConnected(): boolean;
+}

package/dist/core/mcp/client.js

@@ -0,0 +1,70 @@
+/**
+ * MCP 客户端：连接、list_tools、call_tool、断开。
+ * 支持 stdio（本地进程）与 sse（远程 HTTP）两种传输。
+ */
+import { createTransport } from "./transport/index.js";
+export class McpClient {
+    transport;
+    _tools = null;
+    _requestId = 0;
+    constructor(configOrTransport, options = {}) {
+        if (typeof configOrTransport.request === "function" &&
+            typeof configOrTransport.start === "function") {
+            this.transport = configOrTransport;
+        }
+        else {
+            this.transport = createTransport(configOrTransport, {
+                initTimeoutMs: options.initTimeoutMs,
+                requestTimeoutMs: options.requestTimeoutMs,
+            });
+        }
+    }
+    /** 建立连接并完成握手；成功后可使用 listTools / callTool */
+    async connect() {
+        await this.transport.start();
+    }
+    /** 获取工具列表（会缓存；断开重连后需重新 list） */
+    async listTools() {
+        if (this._tools !== null) {
+            return this._tools;
+        }
+        const res = await this.transport.request({
+            jsonrpc: "2.0",
+            id: ++this._requestId,
+            method: "tools/list",
+        });
+        if (res.error) {
+            throw new Error(`MCP tools/list failed: ${res.error.message}`);
+        }
+        const list = res.result?.tools;
+        this._tools = Array.isArray(list) ? list : [];
+        return this._tools;
+    }
+    /** 调用指定工具 */
+    async callTool(name, args) {
+        const res = await this.transport.request({
+            jsonrpc: "2.0",
+            id: ++this._requestId,
+            method: "tools/call",
+            params: { name, arguments: args ?? {} },
+        });
+        if (res.error) {
+            return {
+                content: [{ type: "text", text: `MCP call_tool error: ${res.error.message}` }],
+                isError: true,
+            };
+        }
+        const result = res.result;
+        if (!result || !Array.isArray(result.content)) {
+            return { content: [{ type: "text", text: "Invalid MCP tools/call result" }], isError: true };
+        }
+        return result;
+    }
+    async close() {
+        this._tools = null;
+        await this.transport.close();
+    }
+    get isConnected() {
+        return this.transport.isConnected;
+    }
+}

package/dist/core/mcp/config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * MCP 配置解析与校验。
+ * 从 getOrCreateSession 的 options.mcpServers 中取出并规范化，支持 stdio 与 sse。
+ */
+import type { McpServerConfig, McpServerConfigStdio, McpServerConfigSse } from "./types.js";
+/**
+ * 从会话选项里解析出本会话启用的 MCP 服务器配置列表。
+ * 支持 stdio（本地进程）与 sse（远程 HTTP）。
+ */
+export declare function resolveMcpServersForSession(mcpServers: McpServerConfig[] | undefined): McpServerConfig[];
+/**
+ * 为 stdio 配置生成缓存键（用于 Operator 复用同一进程连接）
+ */
+export declare function stdioConfigKey(config: McpServerConfigStdio): string;
+/**
+ * 为 sse 配置生成缓存键
+ */
+export declare function sseConfigKey(config: McpServerConfigSse): string;
+/**
+ * 任意 MCP 配置的缓存键
+ */
+export declare function mcpConfigKey(config: McpServerConfig): string;

package/dist/core/mcp/config.js

@@ -0,0 +1,69 @@
+/**
+ * MCP 配置解析与校验。
+ * 从 getOrCreateSession 的 options.mcpServers 中取出并规范化，支持 stdio 与 sse。
+ */
+/**
+ * 从会话选项里解析出本会话启用的 MCP 服务器配置列表。
+ * 支持 stdio（本地进程）与 sse（远程 HTTP）。
+ */
+export function resolveMcpServersForSession(mcpServers) {
+    if (!Array.isArray(mcpServers) || mcpServers.length === 0) {
+        return [];
+    }
+    const result = [];
+    for (const s of mcpServers) {
+        if (!s || typeof s !== "object")
+            continue;
+        if (s.transport === "stdio") {
+            if (typeof s.command !== "string" || !s.command.trim()) {
+                console.warn("[mcp] 跳过无效 stdio 配置：缺少或无效 command");
+                continue;
+            }
+            result.push({
+                transport: "stdio",
+                command: s.command.trim(),
+                args: Array.isArray(s.args) ? s.args : undefined,
+                env: s.env && typeof s.env === "object" ? s.env : undefined,
+            });
+        }
+        else if (s.transport === "sse") {
+            const url = s.url?.trim();
+            if (!url) {
+                console.warn("[mcp] 跳过无效 sse 配置：缺少或无效 url");
+                continue;
+            }
+            result.push({
+                transport: "sse",
+                url,
+                headers: s.headers && typeof s.headers === "object" ? s.headers : undefined,
+            });
+        }
+        else {
+            console.warn("[mcp] 未知 transport:", s.transport);
+        }
+    }
+    return result;
+}
+/**
+ * 为 stdio 配置生成缓存键（用于 Operator 复用同一进程连接）
+ */
+export function stdioConfigKey(config) {
+    const args = (config.args ?? []).join(" ");
+    const envStr = config.env ? JSON.stringify(config.env) : "";
+    return `stdio:${config.command}\0${args}\0${envStr}`;
+}
+/**
+ * 为 sse 配置生成缓存键
+ */
+export function sseConfigKey(config) {
+    const headersStr = config.headers ? JSON.stringify(config.headers) : "";
+    return `sse:${config.url}\0${headersStr}`;
+}
+/**
+ * 任意 MCP 配置的缓存键
+ */
+export function mcpConfigKey(config) {
+    if (config.transport === "stdio")
+        return stdioConfigKey(config);
+    return sseConfigKey(config);
+}

package/dist/core/mcp/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Core MCP 模块：为 SessionAgent 提供 MCP Tools 能力（Client 端）。
+ * 配置在创建 Session 时通过 options.mcpServers 传入，与 Skill 类似。
+ */
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+import type { McpServerConfig } from "./types.js";
+export type { McpServerConfig, McpServerConfigStdio, McpServerConfigSse, McpTool } from "./types.js";
+export { resolveMcpServersForSession, stdioConfigKey, sseConfigKey, mcpConfigKey } from "./config.js";
+export { McpClient } from "./client.js";
+export { getMcpToolDefinitions, shutdownMcpClients } from "./operator.js";
+export { mcpToolToToolDefinition, mcpToolsToToolDefinitions } from "./adapter.js";
+/**
+ * 根据会话选项中的 mcpServers 配置，返回该会话可用的 MCP 工具（ToolDefinition 数组）。
+ * 在 AgentManager.getOrCreateSession 中调用，并入 customTools。
+ */
+export declare function createMcpToolsForSession(options: {
+    mcpServers?: McpServerConfig[];
+}): Promise<ToolDefinition[]>;

package/dist/core/mcp/index.js

@@ -0,0 +1,20 @@
+/**
+ * Core MCP 模块：为 SessionAgent 提供 MCP Tools 能力（Client 端）。
+ * 配置在创建 Session 时通过 options.mcpServers 传入，与 Skill 类似。
+ */
+import { resolveMcpServersForSession } from "./config.js";
+import { getMcpToolDefinitions } from "./operator.js";
+export { resolveMcpServersForSession, stdioConfigKey, sseConfigKey, mcpConfigKey } from "./config.js";
+export { McpClient } from "./client.js";
+export { getMcpToolDefinitions, shutdownMcpClients } from "./operator.js";
+export { mcpToolToToolDefinition, mcpToolsToToolDefinitions } from "./adapter.js";
+/**
+ * 根据会话选项中的 mcpServers 配置，返回该会话可用的 MCP 工具（ToolDefinition 数组）。
+ * 在 AgentManager.getOrCreateSession 中调用，并入 customTools。
+ */
+export async function createMcpToolsForSession(options) {
+    const configs = resolveMcpServersForSession(options.mcpServers);
+    if (configs.length === 0)
+        return [];
+    return getMcpToolDefinitions(configs);
+}

package/dist/core/mcp/operator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP Operator：管理 MCP 客户端生命周期，按配置为会话提供 ToolDefinition 列表。
+ * 支持 stdio（本地）与 sse（远程）两种传输。
+ */
+import type { McpServerConfig } from "./types.js";
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/**
+ * 为给定 MCP 服务器配置列表获取或创建客户端，并返回其工具对应的 ToolDefinition 数组。
+ * 连接失败或 list_tools 失败的 server 会被跳过并打日志，不阻塞整体。
+ */
+export declare function getMcpToolDefinitions(serverConfigs: McpServerConfig[]): Promise<ToolDefinition[]>;
+/**
+ * 关闭并移除所有缓存的 MCP 客户端（进程退出或显式清理时调用）。
+ */
+export declare function shutdownMcpClients(): Promise<void>;

package/dist/core/mcp/operator.js

@@ -0,0 +1,72 @@
+/**
+ * MCP Operator：管理 MCP 客户端生命周期，按配置为会话提供 ToolDefinition 列表。
+ * 支持 stdio（本地）与 sse（远程）两种传输。
+ */
+import { mcpConfigKey } from "./config.js";
+import { McpClient } from "./client.js";
+import { mcpToolsToToolDefinitions } from "./adapter.js";
+/** 按配置键缓存的客户端 */
+const clientCache = new Map();
+function configLabel(config) {
+    if (config.transport === "stdio")
+        return config.command;
+    return config.url;
+}
+/**
+ * 为给定 MCP 服务器配置列表获取或创建客户端，并返回其工具对应的 ToolDefinition 数组。
+ * 连接失败或 list_tools 失败的 server 会被跳过并打日志，不阻塞整体。
+ */
+export async function getMcpToolDefinitions(serverConfigs) {
+    const allTools = [];
+    for (let i = 0; i < serverConfigs.length; i++) {
+        const config = serverConfigs[i];
+        const key = mcpConfigKey(config);
+        let client = clientCache.get(key);
+        if (!client) {
+            client = new McpClient(config);
+            try {
+                await client.connect();
+                clientCache.set(key, client);
+            }
+            catch (err) {
+                console.warn(`[mcp] 连接失败 (${configLabel(config)}):`, err instanceof Error ? err.message : err);
+                continue;
+            }
+        }
+        if (!client.isConnected) {
+            clientCache.delete(key);
+            try {
+                await client.close();
+            }
+            catch { }
+            const newClient = new McpClient(config);
+            try {
+                await newClient.connect();
+                clientCache.set(key, newClient);
+                client = newClient;
+            }
+            catch (err) {
+                console.warn(`[mcp] 重连失败 (${configLabel(config)}):`, err instanceof Error ? err.message : err);
+                continue;
+            }
+        }
+        try {
+            const tools = await client.listTools();
+            const serverId = `mcp${i}`;
+            const definitions = mcpToolsToToolDefinitions(tools, client, serverId);
+            allTools.push(...definitions);
+        }
+        catch (err) {
+            console.warn(`[mcp] list_tools 失败 (${configLabel(config)}):`, err instanceof Error ? err.message : err);
+        }
+    }
+    return allTools;
+}
+/**
+ * 关闭并移除所有缓存的 MCP 客户端（进程退出或显式清理时调用）。
+ */
+export async function shutdownMcpClients() {
+    const closeAll = Array.from(clientCache.values()).map((c) => c.close().catch(() => { }));
+    clientCache.clear();
+    await Promise.all(closeAll);
+}

package/dist/core/mcp/transport/index.d.ts

@@ -0,0 +1,11 @@
+import type { McpServerConfig, IMcpTransport } from "../types.js";
+export interface TransportOptions {
+    initTimeoutMs?: number;
+    requestTimeoutMs?: number;
+}
+/**
+ * 根据配置创建对应的传输层实例。
+ */
+export declare function createTransport(config: McpServerConfig, options?: TransportOptions): IMcpTransport;
+export { StdioTransport } from "./stdio.js";
+export { SseTransport } from "./sse.js";

package/dist/core/mcp/transport/index.js

@@ -0,0 +1,16 @@
+import { StdioTransport } from "./stdio.js";
+import { SseTransport } from "./sse.js";
+/**
+ * 根据配置创建对应的传输层实例。
+ */
+export function createTransport(config, options) {
+    if (config.transport === "stdio") {
+        return new StdioTransport(config, options);
+    }
+    if (config.transport === "sse") {
+        return new SseTransport(config, options);
+    }
+    throw new Error(`Unsupported MCP transport: ${config.transport}`);
+}
+export { StdioTransport } from "./stdio.js";
+export { SseTransport } from "./sse.js";

package/dist/core/mcp/transport/sse.d.ts

@@ -0,0 +1,20 @@
+/**
+ * MCP SSE/HTTP 传输：通过 HTTP POST 向远程 URL 发送 JSON-RPC 请求，响应在 response body。
+ */
+import type { McpServerConfigSse } from "../types.js";
+import type { JsonRpcRequest, JsonRpcResponse } from "../types.js";
+export interface SseTransportOptions {
+    initTimeoutMs?: number;
+    requestTimeoutMs?: number;
+}
+export declare class SseTransport {
+    private config;
+    private initTimeoutMs;
+    private requestTimeoutMs;
+    private _connected;
+    constructor(config: McpServerConfigSse, options?: SseTransportOptions);
+    start(): Promise<void>;
+    request(req: JsonRpcRequest, timeoutMs?: number): Promise<JsonRpcResponse>;
+    close(): Promise<void>;
+    get isConnected(): boolean;
+}