@next-open-ai/openbot 0.6.8 → 0.6.66

package/dist/core/local-llm-server/start-from-config.js

@@ -0,0 +1,50 @@
+/**
+ * 通用「按当前已保存配置启动本地模型服务」逻辑。
+ * 供网关启动与 API 复用：读取默认智能体配置，尝试启动；失败只设 env 与日志，不抛错、不影响主进程。
+ * LLM/Embedding 任一存在即可启动，只提示不报错。
+ */
+import { loadDesktopAgentConfig } from "../config/desktop-config.js";
+import { startLocalLlmServer } from "./index.js";
+import { resolveModelPathInCache, LOCAL_LLM_CACHE_DIR } from "./model-resolve.js";
+/**
+ * 按已保存的配置（默认智能体的 local 模型与上下文长度）尝试启动本地模型服务。
+ * 仅当已下载的模型文件存在时才启动；不抛错；失败时设置 process.env.LOCAL_LLM_START_FAILED 并打日志。
+ */
+export async function tryStartLocalModelFromSavedConfig() {
+    try {
+        const agent = await loadDesktopAgentConfig("default");
+        if (!agent || agent.provider !== "local" || !agent.model?.trim()) {
+            // 默认智能体未使用 local 时仅跳过启动，不设置 LOCAL_LLM_START_FAILED，避免 Ollama/openai-custom 等连接失败时被误报为「未配置本地模型」
+            delete process.env.LOCAL_LLM_START_FAILED;
+            console.log("[local-llm] 提示：未配置默认本地模型，跳过启动。");
+            return;
+        }
+        const llmResolved = resolveModelPathInCache(agent.model.trim(), LOCAL_LLM_CACHE_DIR);
+        if (!llmResolved) {
+            process.env.LOCAL_LLM_START_FAILED =
+                "缺省模型文件未下载，请先在「模型管理」中下载后点击「启动本地模型服务」";
+            console.log("[local-llm] 提示：缺省模型文件未下载，跳过启动。");
+            return;
+        }
+        const contextSize = process.env.LOCAL_LLM_CONTEXT_MAX != null && String(process.env.LOCAL_LLM_CONTEXT_MAX).trim() !== ""
+            ? parseInt(process.env.LOCAL_LLM_CONTEXT_MAX, 10) || 32768
+            : (agent.contextSize ?? 32768);
+        const opts = { llmModelPath: llmResolved, contextSize };
+        startLocalLlmServer(opts)
+            .then((handle) => {
+            process.env.LOCAL_LLM_BASE_URL = handle.baseUrl;
+            delete process.env.LOCAL_LLM_START_FAILED;
+            console.log("[local-llm] 已就绪:", handle.baseUrl);
+        })
+            .catch((e) => {
+            const msg = e instanceof Error ? e.message : String(e);
+            process.env.LOCAL_LLM_START_FAILED = msg;
+            console.log("[local-llm] 提示：启动未成功（如模型未下载请先在「模型管理」中下载）。", msg);
+        });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        process.env.LOCAL_LLM_START_FAILED = msg;
+        console.log("[local-llm] 提示：启动时发生异常，已跳过。", msg);
+    }
+}

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

@@ -9,9 +9,11 @@ import type { McpClient } from "./client.js";
  * @param tool MCP tools/list 返回的项
  * @param client 已连接的 McpClient，用于 callTool
  * @param serverId 可选前缀，用于避免多 MCP 时工具名冲突
+ * @param maxResultTokens 可选，单次返回最大 token；超过则从尾部裁剪并打日志；不配置则不限制
  */
-export declare function mcpToolToToolDefinition(tool: McpTool, client: McpClient, serverId?: string): ToolDefinition;
+export declare function mcpToolToToolDefinition(tool: McpTool, client: McpClient, serverId?: string, maxResultTokens?: number): ToolDefinition;
 /**
  * 将某 MCP 客户端的全部工具转为 ToolDefinition 数组。
+ * @param maxResultTokens 可选，单次返回最大 token；不配置则不限制
  */
-export declare function mcpToolsToToolDefinitions(tools: McpTool[], client: McpClient, serverId?: string): ToolDefinition[];
+export declare function mcpToolsToToolDefinitions(tools: McpTool[], client: McpClient, serverId?: string, maxResultTokens?: number): ToolDefinition[];

package/dist/core/mcp/adapter.js

@@ -2,6 +2,7 @@
  * MCP Tool 转为 pi-coding-agent ToolDefinition 的适配层。
  */
 import { Type } from "@sinclair/typebox";
+import { truncateTextToMaxTokens } from "../tools/truncate-result.js";
 /** 通用参数：MCP 工具接受任意 JSON 对象作为 arguments */
 const McpToolParamsSchema = Type.Record(Type.String(), Type.Any());
 /**
@@ -9,8 +10,9 @@ const McpToolParamsSchema = Type.Record(Type.String(), Type.Any());
  * @param tool MCP tools/list 返回的项
  * @param client 已连接的 McpClient，用于 callTool
  * @param serverId 可选前缀，用于避免多 MCP 时工具名冲突
+ * @param maxResultTokens 可选，单次返回最大 token；超过则从尾部裁剪并打日志；不配置则不限制
  */
-export function mcpToolToToolDefinition(tool, client, serverId) {
+export function mcpToolToToolDefinition(tool, client, serverId, maxResultTokens) {
     const name = serverId ? `${serverId}_${tool.name}` : tool.name;
     const description = (tool.description ?? "").trim() || `MCP tool: ${tool.name}`;
     return {
@@ -22,10 +24,13 @@ export function mcpToolToToolDefinition(tool, client, serverId) {
             const args = params && typeof params === "object" ? params : {};
             try {
                 const result = await client.callTool(tool.name, args);
-                const text = result.content
+                let text = result.content
                     ?.filter((c) => c.type === "text")
                     .map((c) => c.text)
                     .join("\n") ?? (result.isError ? "MCP 调用返回错误" : "");
+                if (typeof maxResultTokens === "number" && maxResultTokens > 0) {
+                    text = truncateTextToMaxTokens(text, maxResultTokens, `MCP ${name}`);
+                }
                 return {
                     content: [{ type: "text", text }],
                     details: result.isError ? { isError: true } : undefined,
@@ -43,7 +48,8 @@ export function mcpToolToToolDefinition(tool, client, serverId) {
 }
 /**
  * 将某 MCP 客户端的全部工具转为 ToolDefinition 数组。
+ * @param maxResultTokens 可选，单次返回最大 token；不配置则不限制
  */
-export function mcpToolsToToolDefinitions(tools, client, serverId) {
-    return tools.map((t) => mcpToolToToolDefinition(t, client, serverId));
+export function mcpToolsToToolDefinitions(tools, client, serverId, maxResultTokens) {
+    return tools.map((t) => mcpToolToToolDefinition(t, client, serverId, maxResultTokens));
 }

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

@@ -7,6 +7,10 @@ import type { McpServerConfig } from "./types.js";
 export interface McpClientOptions {
     initTimeoutMs?: number;
     requestTimeoutMs?: number;
+    /** stdio：初始化失败时的重试次数（默认 1） */
+    initRetries?: number;
+    /** stdio：初始化重试间隔毫秒（默认 3000） */
+    initRetryDelayMs?: number;
 }
 export declare class McpClient {
     private transport;

package/dist/core/mcp/client.js

@@ -16,6 +16,8 @@ export class McpClient {
             this.transport = createTransport(configOrTransport, {
                 initTimeoutMs: options.initTimeoutMs,
                 requestTimeoutMs: options.requestTimeoutMs,
+                initRetries: options.initRetries,
+                initRetryDelayMs: options.initRetryDelayMs,
             });
         }
     }

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

@@ -1,13 +1,24 @@
 /**
  * MCP 配置解析与校验。
  * 从 getOrCreateSession 的 options.mcpServers 中取出并规范化，支持 stdio 与 sse。
+ * 支持两种输入：数组（含 transport）或标准 JSON 对象（key 为名称，由 command/url 推断 transport）。
  */
-import type { McpServerConfig, McpServerConfigStdio, McpServerConfigSse } from "./types.js";
+import type { McpServerConfig, McpServerConfigStdio, McpServerConfigSse, McpServersStandardFormat } from "./types.js";
+/**
+ * 将标准格式（mcpServers 对象）转为内部数组格式。
+ * 有 command 视为 stdio，有 url 视为 sse；无效项跳过。
+ */
+export declare function standardFormatToArray(mcpServers: McpServersStandardFormat): McpServerConfig[];
+/**
+ * 将内部数组格式转为标准 JSON 对象（用于展示/编辑）。
+ * 无名称的项使用 "MCP Server 1"、"MCP Server 2" 等占位 key。
+ */
+export declare function arrayToStandardFormat(mcpServers: McpServerConfig[]): McpServersStandardFormat;
 /**
  * 从会话选项里解析出本会话启用的 MCP 服务器配置列表。
- * 支持 stdio（本地进程）与 sse（远程 HTTP）。
+ * 支持：数组（含 transport）、标准 JSON 对象（key 为名称，由 command/url 推断）。
  */
-export declare function resolveMcpServersForSession(mcpServers: McpServerConfig[] | undefined): McpServerConfig[];
+export declare function resolveMcpServersForSession(mcpServers: McpServerConfig[] | McpServersStandardFormat | undefined): McpServerConfig[];
 /**
  * 为 stdio 配置生成缓存键（用于 Operator 复用同一进程连接）
  */

package/dist/core/mcp/config.js

@@ -1,15 +1,80 @@
 /**
  * MCP 配置解析与校验。
  * 从 getOrCreateSession 的 options.mcpServers 中取出并规范化，支持 stdio 与 sse。
+ * 支持两种输入：数组（含 transport）或标准 JSON 对象（key 为名称，由 command/url 推断 transport）。
  */
+/**
+ * 将标准格式（mcpServers 对象）转为内部数组格式。
+ * 有 command 视为 stdio，有 url 视为 sse；无效项跳过。
+ */
+export function standardFormatToArray(mcpServers) {
+    const result = [];
+    for (const [_, entry] of Object.entries(mcpServers)) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const cmd = typeof entry.command === "string" ? entry.command.trim() : "";
+        const url = typeof entry.url === "string" ? entry.url.trim() : "";
+        if (cmd) {
+            result.push({
+                transport: "stdio",
+                command: cmd,
+                args: Array.isArray(entry.args) ? entry.args : undefined,
+                env: entry.env && typeof entry.env === "object" ? entry.env : undefined,
+            });
+        }
+        else if (url) {
+            result.push({
+                transport: "sse",
+                url,
+                headers: entry.headers && typeof entry.headers === "object" ? entry.headers : undefined,
+            });
+        }
+        else {
+            console.warn("[mcp] 跳过无效标准格式项：需 command（stdio）或 url（sse）");
+        }
+    }
+    return result;
+}
+/**
+ * 将内部数组格式转为标准 JSON 对象（用于展示/编辑）。
+ * 无名称的项使用 "MCP Server 1"、"MCP Server 2" 等占位 key。
+ */
+export function arrayToStandardFormat(mcpServers) {
+    const out = {};
+    mcpServers.forEach((s, i) => {
+        const name = `MCP Server ${i + 1}`;
+        if (s.transport === "stdio") {
+            const e = {
+                command: s.command,
+                args: s.args,
+                env: s.env,
+            };
+            out[name] = e;
+        }
+        else {
+            const e = {
+                url: s.url,
+                headers: s.headers,
+            };
+            out[name] = e;
+        }
+    });
+    return out;
+}
+function isStandardFormat(obj) {
+    return obj !== null && typeof obj === "object" && !Array.isArray(obj);
+}
 /**
  * 从会话选项里解析出本会话启用的 MCP 服务器配置列表。
- * 支持 stdio（本地进程）与 sse（远程 HTTP）。
+ * 支持：数组（含 transport）、标准 JSON 对象（key 为名称，由 command/url 推断）。
  */
 export function resolveMcpServersForSession(mcpServers) {
-    if (!Array.isArray(mcpServers) || mcpServers.length === 0) {
+    if (mcpServers == null)
+        return [];
+    if (isStandardFormat(mcpServers))
+        return standardFormatToArray(mcpServers);
+    if (!Array.isArray(mcpServers) || mcpServers.length === 0)
         return [];
-    }
     const result = [];
     for (const s of mcpServers) {
         if (!s || typeof s !== "object")

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

@@ -3,16 +3,20 @@
  * 配置在创建 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";
+import type { McpServerConfig, McpServersStandardFormat } from "./types.js";
+export type { McpServerConfig, McpServerConfigStdio, McpServerConfigSse, McpServerConfigStandardEntry, McpServersStandardFormat, McpTool, } from "./types.js";
+export { resolveMcpServersForSession, standardFormatToArray, arrayToStandardFormat, stdioConfigKey, sseConfigKey, mcpConfigKey, } from "./config.js";
 export { McpClient } from "./client.js";
-export { getMcpToolDefinitions, shutdownMcpClients } from "./operator.js";
+export { getMcpToolDefinitions, shutdownMcpClients, type GetMcpToolDefinitionsOptions } from "./operator.js";
 export { mcpToolToToolDefinition, mcpToolsToToolDefinitions } from "./adapter.js";
 /**
  * 根据会话选项中的 mcpServers 配置，返回该会话可用的 MCP 工具（ToolDefinition 数组）。
- * 在 AgentManager.getOrCreateSession 中调用，并入 customTools。
+ * 支持数组或标准 JSON 对象格式；在 AgentManager.getOrCreateSession 中调用，并入 customTools。
+ * 若提供 sessionId，MCP 连接/重试进度将经全局 sendSessionMessage 以系统消息推送。
  */
 export declare function createMcpToolsForSession(options: {
-    mcpServers?: McpServerConfig[];
+    mcpServers?: McpServerConfig[] | McpServersStandardFormat;
+    sessionId?: string;
+    /** 单次 MCP 工具返回最大 token；不配置则不限制 */
+    mcpMaxResultTokens?: number;
 }): Promise<ToolDefinition[]>;

package/dist/core/mcp/index.js

@@ -4,17 +4,21 @@
  */
 import { resolveMcpServersForSession } from "./config.js";
 import { getMcpToolDefinitions } from "./operator.js";
-export { resolveMcpServersForSession, stdioConfigKey, sseConfigKey, mcpConfigKey } from "./config.js";
+export { resolveMcpServersForSession, standardFormatToArray, arrayToStandardFormat, 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。
+ * 支持数组或标准 JSON 对象格式；在 AgentManager.getOrCreateSession 中调用，并入 customTools。
+ * 若提供 sessionId，MCP 连接/重试进度将经全局 sendSessionMessage 以系统消息推送。
  */
 export async function createMcpToolsForSession(options) {
     const configs = resolveMcpServersForSession(options.mcpServers);
     if (configs.length === 0)
         return [];
-    return getMcpToolDefinitions(configs);
+    return getMcpToolDefinitions(configs, {
+        sessionId: options.sessionId,
+        maxResultTokens: options.mcpMaxResultTokens,
+    });
 }

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

@@ -4,12 +4,38 @@
  */
 import type { McpServerConfig } from "./types.js";
 import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+/** getMcpToolDefinitions 的可选参数：超时、重试与 sessionId（用于经 sendSessionMessage 推送进度） */
+export interface GetMcpToolDefinitionsOptions {
+    /** 连接或 list_tools 失败时的重试次数（不含首次，默认 1） */
+    connectRetries?: number;
+    /** 重试间隔（毫秒，默认 3000） */
+    retryDelayMs?: number;
+    /** stdio 初始化超时（毫秒） */
+    initTimeoutMs?: number;
+    /** stdio 初始化重试次数（默认 1） */
+    initRetries?: number;
+    /** stdio 初始化重试间隔（毫秒，默认 3000） */
+    initRetryDelayMs?: number;
+    /** 会话 ID，用于经全局 sendSessionMessage 推送 MCP 进度系统消息 */
+    sessionId?: string;
+    /** 单次 MCP 工具返回最大 token；超过则从尾部裁剪并打日志；不配置则不限制 */
+    maxResultTokens?: number;
+}
 /**
  * 为给定 MCP 服务器配置列表获取或创建客户端，并返回其工具对应的 ToolDefinition 数组。
- * 连接失败或 list_tools 失败的 server 会被跳过并打日志，不阻塞整体。
+ * 连接失败或 list_tools 失败的 server 会按 options 重试，仍失败则跳过并打日志，不阻塞整体。
  */
-export declare function getMcpToolDefinitions(serverConfigs: McpServerConfig[]): Promise<ToolDefinition[]>;
+export declare function getMcpToolDefinitions(serverConfigs: McpServerConfig[], options?: GetMcpToolDefinitionsOptions): Promise<ToolDefinition[]>;
 /**
  * 关闭并移除所有缓存的 MCP 客户端（进程退出或显式清理时调用）。
  */
 export declare function shutdownMcpClients(): Promise<void>;
+/**
+ * 测试单条 MCP 配置是否可用：连接、拉取工具列表后断开。
+ * 不写入 clientCache，用于配置界面「测试」按钮，可提前触发 uvx/npx 依赖安装。
+ */
+export declare function testMcpConnection(config: McpServerConfig, options?: GetMcpToolDefinitionsOptions): Promise<{
+    success: boolean;
+    error?: string;
+    toolsCount?: number;
+}>;

package/dist/core/mcp/operator.js

@@ -5,6 +5,7 @@
 import { mcpConfigKey } from "./config.js";
 import { McpClient } from "./client.js";
 import { mcpToolsToToolDefinitions } from "./adapter.js";
+import { sendSessionMessage } from "../session-outlet/index.js";
 /** 按配置键缓存的客户端 */
 const clientCache = new Map();
 function configLabel(config) {
@@ -12,53 +13,123 @@ function configLabel(config) {
         return config.command;
     return config.url;
 }
+/** 用于系统消息展示的 MCP 名称：stdio 优先用首个非选项参数（如 akshare-tools），否则 command；sse 用 URL 主机或路径末段 */
+function mcpDisplayName(config) {
+    if (config.transport === "stdio") {
+        const args = config.args;
+        const nameArg = (args ?? []).find((a) => typeof a === "string" && a.trim() && !a.startsWith("-") && !a.includes("/") && !a.includes("\\"));
+        if (nameArg)
+            return nameArg.trim();
+        return config.command;
+    }
+    try {
+        const u = new URL(config.url);
+        const host = u.hostname || u.pathname?.replace(/\/$/, "").split("/").pop() || "MCP";
+        return host;
+    }
+    catch {
+        return config.url;
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
 /**
  * 为给定 MCP 服务器配置列表获取或创建客户端，并返回其工具对应的 ToolDefinition 数组。
- * 连接失败或 list_tools 失败的 server 会被跳过并打日志，不阻塞整体。
+ * 连接失败或 list_tools 失败的 server 会按 options 重试，仍失败则跳过并打日志，不阻塞整体。
  */
-export async function getMcpToolDefinitions(serverConfigs) {
+export async function getMcpToolDefinitions(serverConfigs, options = {}) {
+    const connectRetries = options.connectRetries ?? 1;
+    const retryDelayMs = options.retryDelayMs ?? 3_000;
+    const sessionId = options.sessionId;
+    const clientOptions = {
+        initTimeoutMs: options.initTimeoutMs,
+        initRetries: options.initRetries,
+        initRetryDelayMs: options.initRetryDelayMs,
+    };
+    const emitProgress = (displayMessage, phase, detail) => {
+        if (sessionId) {
+            sendSessionMessage(sessionId, {
+                type: "system",
+                code: "mcp.progress",
+                payload: { phase, message: displayMessage, serverLabel: detail },
+            });
+        }
+    };
     const allTools = [];
     for (let i = 0; i < serverConfigs.length; i++) {
         const config = serverConfigs[i];
         const key = mcpConfigKey(config);
+        const label = configLabel(config);
+        const displayName = mcpDisplayName(config);
         let client = clientCache.get(key);
-        if (!client) {
-            client = new McpClient(config);
-            try {
-                await client.connect();
-                clientCache.set(key, client);
+        if (!client || !client.isConnected) {
+            if (client) {
+                clientCache.delete(key);
+                try {
+                    await client.close();
+                }
+                catch { }
             }
-            catch (err) {
-                console.warn(`[mcp] 连接失败 (${configLabel(config)}):`, err instanceof Error ? err.message : err);
-                continue;
+            emitProgress(`${displayName} MCP connecting`, "connecting");
+            let connected = false;
+            for (let attempt = 0; attempt <= connectRetries; attempt++) {
+                if (attempt > 0) {
+                    emitProgress(`${displayName} MCP retrying (${attempt + 1}/${connectRetries + 1})`, "retrying", "connect");
+                    await sleep(retryDelayMs);
+                }
+                try {
+                    client = new McpClient(config, clientOptions);
+                    await client.connect();
+                    clientCache.set(key, client);
+                    connected = true;
+                    emitProgress(`${displayName} MCP ready`, "ready");
+                    break;
+                }
+                catch (err) {
+                    if (client)
+                        try {
+                            await client.close();
+                        }
+                        catch { }
+                    if (attempt === connectRetries) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        console.warn(`[mcp] 连接失败 (${label}):`, errMsg);
+                        const enoentHint = /ENOENT/.test(errMsg) && /uvx|npx/.test(errMsg)
+                            ? " 若在 Docker 中运行，请使用已安装 uv/npx 的镜像（Dockerfile 中需安装 uv 并设置 PATH=/root/.local/bin）并重新构建。"
+                            : "";
+                        if (enoentHint)
+                            console.warn(`[mcp]`, enoentHint.trim());
+                        emitProgress(`${displayName} MCP failed: ${errMsg}`, "skipped", errMsg);
+                    }
+                }
             }
+            if (!connected)
+                continue;
         }
-        if (!client.isConnected) {
-            clientCache.delete(key);
-            try {
-                await client.close();
+        client = clientCache.get(key);
+        let toolsListed = false;
+        for (let attempt = 0; attempt <= connectRetries; attempt++) {
+            if (attempt > 0) {
+                emitProgress(`${displayName} MCP retrying list tools (${attempt + 1}/${connectRetries + 1})`, "retrying", "list_tools");
+                await sleep(retryDelayMs);
             }
-            catch { }
-            const newClient = new McpClient(config);
             try {
-                await newClient.connect();
-                clientCache.set(key, newClient);
-                client = newClient;
+                const tools = await client.listTools();
+                const serverId = `mcp${i}`;
+                const definitions = mcpToolsToToolDefinitions(tools, client, serverId, options.maxResultTokens);
+                allTools.push(...definitions);
+                toolsListed = true;
+                break;
             }
             catch (err) {
-                console.warn(`[mcp] 重连失败 (${configLabel(config)}):`, err instanceof Error ? err.message : err);
-                continue;
+                if (attempt === connectRetries) {
+                    console.warn(`[mcp] list_tools 失败 (${label}):`, err instanceof Error ? err.message : err);
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    emitProgress(`${displayName} MCP list tools failed: ${errMsg}`, "skipped", errMsg);
+                }
             }
         }
-        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;
 }
@@ -70,3 +141,33 @@ export async function shutdownMcpClients() {
     clientCache.clear();
     await Promise.all(closeAll);
 }
+/**
+ * 测试单条 MCP 配置是否可用：连接、拉取工具列表后断开。
+ * 不写入 clientCache，用于配置界面「测试」按钮，可提前触发 uvx/npx 依赖安装。
+ */
+export async function testMcpConnection(config, options = {}) {
+    const clientOptions = {
+        initTimeoutMs: options.initTimeoutMs,
+        initRetries: options.initRetries ?? 1,
+        initRetryDelayMs: options.initRetryDelayMs,
+    };
+    let client = null;
+    try {
+        client = new McpClient(config, clientOptions);
+        await client.connect();
+        const tools = await client.listTools();
+        const count = Array.isArray(tools) ? tools.length : 0;
+        await client.close();
+        return { success: true, toolsCount: count };
+    }
+    catch (err) {
+        if (client) {
+            try {
+                await client.close();
+            }
+            catch { }
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return { success: false, error: message };
+    }
+}

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

@@ -2,6 +2,10 @@ import type { McpServerConfig, IMcpTransport } from "../types.js";
 export interface TransportOptions {
     initTimeoutMs?: number;
     requestTimeoutMs?: number;
+    /** stdio：初始化失败时的重试次数（默认 1） */
+    initRetries?: number;
+    /** stdio：初始化重试间隔毫秒（默认 3000） */
+    initRetryDelayMs?: number;
 }
 /**
  * 根据配置创建对应的传输层实例。

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

@@ -5,7 +5,12 @@ import { SseTransport } from "./sse.js";
  */
 export function createTransport(config, options) {
     if (config.transport === "stdio") {
-        return new StdioTransport(config, options);
+        return new StdioTransport(config, {
+            initTimeoutMs: options?.initTimeoutMs,
+            requestTimeoutMs: options?.requestTimeoutMs,
+            initRetries: options?.initRetries,
+            initRetryDelayMs: options?.initRetryDelayMs,
+        });
     }
     if (config.transport === "sse") {
         return new SseTransport(config, options);

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

@@ -8,19 +8,31 @@ export interface StdioTransportOptions {
     initTimeoutMs?: number;
     /** 单次请求超时（毫秒） */
     requestTimeoutMs?: number;
+    /** 初始化失败时的重试次数（不含首次，默认 1，即最多 2 次尝试） */
+    initRetries?: number;
+    /** 初始化重试间隔（毫秒，默认 3000） */
+    initRetryDelayMs?: number;
 }
 export declare class StdioTransport {
     private process;
     private config;
     private initTimeoutMs;
     private requestTimeoutMs;
+    private initRetries;
+    private initRetryDelayMs;
     private nextId;
     private pending;
     private buffer;
+    private stderrBuffer;
+    private static pendingKey;
     constructor(config: McpServerConfigStdio, options?: StdioTransportOptions);
     /** 启动子进程并完成 MCP initialize 握手 */
     start(): Promise<void>;
+    /** 从一行中解析 JSON-RPC 响应：整行即 JSON，或从第一个 { 开始提取到匹配的 }（兼容 npx/uvx 等前缀输出） */
+    private static parseJsonRpcResponse;
     private flushLines;
+    private flushStderrLines;
+    private flushLinesFromBuffer;
     private rejectAll;
     private initialize;
     private sendNotification;