@next-open-ai/openclawx 0.8.58 → 0.9.6

package/dist/core/config/provider-support-default.js

@@ -28,6 +28,7 @@ export const DEFAULT_PROVIDER_SUPPORT = {
     "openai-custom": {
         name: "OpenAI (自定义)",
         models: [
+            { id: "qwen3.5:4b", name: "Qwen3.5 4B", types: ["llm"] },
             { id: "gpt-4o", name: "GPT-4o", types: ["llm"] },
             { id: "gpt-4o-mini", name: "GPT-4o Mini", types: ["llm"] },
             { id: "gpt-4-turbo", name: "GPT-4 Turbo", types: ["llm"] },

package/dist/core/local-llm-server/download-model.d.ts

@@ -1,4 +1,4 @@
-export declare const DEFAULT_LLM_MODEL_URI = "hf:Qwen/Qwen3-4B-GGUF/Qwen3-4B-Q4_K_M.gguf";
+export declare const DEFAULT_LLM_MODEL_URI = "hf:unsloth/Qwen3.5-4B-GGUF/Qwen3.5-4B-Q5_K_M.gguf";
 export interface DownloadModelOptions {
     useMirror?: boolean;
     signal?: AbortSignal;

package/dist/core/local-llm-server/download-model.js

@@ -4,7 +4,7 @@
  */
 import { basename } from "node:path";
 import { LOCAL_LLM_CACHE_DIR } from "./model-resolve.js";
-export const DEFAULT_LLM_MODEL_URI = "hf:Qwen/Qwen3-4B-GGUF/Qwen3-4B-Q4_K_M.gguf";
+export const DEFAULT_LLM_MODEL_URI = "hf:unsloth/Qwen3.5-4B-GGUF/Qwen3.5-4B-Q5_K_M.gguf";
 /**
  * 下载模型到本地缓存目录。
  * @returns 解析后的本地文件路径

package/dist/core/local-llm-server/index.d.ts

@@ -12,7 +12,7 @@ export interface LocalLlmServerOptions {
     port?: number;
     llmModelPath?: string;
     embeddingModelPath?: string;
-    /** 上下文窗口 token 数，默认 32768（32K），需能容纳 system + tools + 对话 */
+    /** 上下文窗口 token 数，默认 32768（32K），需能容纳 system + tools + 对话；显存不足时在智能体配置中调小 */
     contextSize?: number;
     /** 等待子进程就绪的超时毫秒数，默认 300000（5 分钟，冷启/大模型加载可能较慢） */
     readyTimeoutMs?: number;

package/dist/core/local-llm-server/llm-context.d.ts

@@ -43,6 +43,7 @@ export declare function initModels(opts: LlmContextOptions): Promise<void>;
 /**
  * 流式 chat completion。
  * onChunk 每次收到新 token 时调用；结束后返回完整 finish_reason。
+ * 本地模型若输出 <think>...</think> 块，会从流中过滤，不展示思考过程。
  */
 export declare function chatCompletionStream(messages: ChatMessage[], tools: ToolDefinition[], onChunk: (chunk: ChatCompletionChunk) => void, signal?: AbortSignal): Promise<void>;
 /**

package/dist/core/local-llm-server/llm-context.js

@@ -113,9 +113,35 @@ function parseToolCalls(text) {
     }
     return null;
 }
+/**
+ * 从累积文本中移除 <think>...</think> 块，只保留对外可见的正文（关闭本地模型“思考过程”的展示）。
+ * 若存在未闭合的 <think>，则从 <think> 起至末尾均视为思考内容不输出。
+ */
+function getVisibleWithoutThinking(text) {
+    let out = "";
+    let i = 0;
+    const openTag = "<think>";
+    const closeTag = "</think>";
+    while (i < text.length) {
+        const open = text.indexOf(openTag, i);
+        if (open === -1) {
+            out += text.slice(i);
+            break;
+        }
+        out += text.slice(i, open);
+        const close = text.indexOf(closeTag, open + openTag.length);
+        if (close === -1) {
+            // 思考块未闭合，剩余不输出
+            break;
+        }
+        i = close + closeTag.length;
+    }
+    return out;
+}
 /**
  * 流式 chat completion。
  * onChunk 每次收到新 token 时调用；结束后返回完整 finish_reason。
+ * 本地模型若输出 <think>...</think> 块，会从流中过滤，不展示思考过程。
  */
 export async function chatCompletionStream(messages, tools, onChunk, signal) {
     if (!llmModel)
@@ -150,7 +176,7 @@ export async function chatCompletionStream(messages, tools, onChunk, signal) {
             }
         }
         let fullText = "";
-        let prevSentLength = 0;
+        let prevSentVisibleLength = 0;
         let lastSent = ""; // 连续相同 delta 只发一次，缓解回复缓慢时「每个字显示两遍」
         try {
             await session.prompt(userPrompt, {
@@ -168,8 +194,10 @@ export async function chatCompletionStream(messages, tools, onChunk, signal) {
                     else {
                         fullText += s;
                     }
-                    const toSend = fullText.slice(prevSentLength);
-                    prevSentLength = fullText.length;
+                    // 过滤 <think>...</think> 块，不向客户端输出思考过程
+                    const visibleText = getVisibleWithoutThinking(fullText);
+                    const toSend = visibleText.slice(prevSentVisibleLength);
+                    prevSentVisibleLength = visibleText.length;
                     if (toSend && toSend !== lastSent) {
                         lastSent = toSend;
                         onChunk({ content: toSend });

package/dist/core/local-llm-server/model-resolve.d.ts

@@ -1,8 +1,8 @@
 export declare const LOCAL_LLM_CACHE_DIR: string;
 /**
  * 取 modelUri 的末尾文件名（用于与已安装文件灵活匹配：不同 node-llama-cpp 版本可能生成不同前缀）。
- * 例：hf:Qwen/Qwen3-4B-GGUF/Qwen3-4B-Q4_K_M.gguf → Qwen3-4B-Q4_K_M.gguf
- * 例：hf_Qwen_Qwen3-4B-GGUF_Qwen3-4B-Q4_K_M.gguf → Qwen3-4B-Q4_K_M.gguf（文件名形式取最后一段 _ 之后）
+ * 例：hf:unsloth/Qwen3.5-4B-GGUF/Qwen3.5-4B-Q5_K_M.gguf → Qwen3.5-4B-Q5_K_M.gguf
+ * 例：hf_unsloth_Qwen3.5-4B-GGUF_Qwen3.5-4B-Q5_K_M.gguf → Qwen3.5-4B-Q5_K_M.gguf（文件名形式取最后一段 _ 之后）
  */
 export declare function modelUriBasename(modelUri: string): string;
 /**

package/dist/core/local-llm-server/model-resolve.js

@@ -9,8 +9,8 @@ import { homedir } from "node:os";
 export const LOCAL_LLM_CACHE_DIR = join(homedir(), ".openbot", ".cached_models");
 /**
  * 取 modelUri 的末尾文件名（用于与已安装文件灵活匹配：不同 node-llama-cpp 版本可能生成不同前缀）。
- * 例：hf:Qwen/Qwen3-4B-GGUF/Qwen3-4B-Q4_K_M.gguf → Qwen3-4B-Q4_K_M.gguf
- * 例：hf_Qwen_Qwen3-4B-GGUF_Qwen3-4B-Q4_K_M.gguf → Qwen3-4B-Q4_K_M.gguf（文件名形式取最后一段 _ 之后）
+ * 例：hf:unsloth/Qwen3.5-4B-GGUF/Qwen3.5-4B-Q5_K_M.gguf → Qwen3.5-4B-Q5_K_M.gguf
+ * 例：hf_unsloth_Qwen3.5-4B-GGUF_Qwen3.5-4B-Q5_K_M.gguf → Qwen3.5-4B-Q5_K_M.gguf（文件名形式取最后一段 _ 之后）
  */
 export function modelUriBasename(modelUri) {
     const s = (modelUri || "").trim();

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

@@ -14,8 +14,8 @@ export async function tryStartLocalModelFromSavedConfig() {
     try {
         const agent = await loadDesktopAgentConfig("default");
         if (!agent || agent.provider !== "local" || !agent.model?.trim()) {
-            process.env.LOCAL_LLM_START_FAILED =
-                "未配置默认本地模型，请在「模型配置」中选择 LLM 后点击「启动本地模型服务」";
+            // 默认智能体未使用 local 时仅跳过启动，不设置 LOCAL_LLM_START_FAILED，避免 Ollama/openai-custom 等连接失败时被误报为「未配置本地模型」
+            delete process.env.LOCAL_LLM_START_FAILED;
             console.log("[local-llm] 提示：未配置默认本地模型，跳过启动。");
             return;
         }

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

@@ -30,3 +30,12 @@ export declare function getMcpToolDefinitions(serverConfigs: McpServerConfig[],
  * 关闭并移除所有缓存的 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

@@ -13,14 +13,13 @@ function configLabel(config) {
         return config.command;
     return config.url;
 }
-/** 用于系统消息展示的 MCP 名称：stdio 优先用首参（如 akshare-tools），否则 command；sse 用 URL 主机或路径末段 */
+/** 用于系统消息展示的 MCP 名称：stdio 优先用首个非选项参数（如 akshare-tools），否则 command；sse 用 URL 主机或路径末段 */
 function mcpDisplayName(config) {
     if (config.transport === "stdio") {
         const args = config.args;
-        const first = args?.[0];
-        if (typeof first === "string" && first.trim() && !first.includes("/") && !first.includes("\\")) {
-            return first.trim();
-        }
+        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 {
@@ -94,8 +93,13 @@ export async function getMcpToolDefinitions(serverConfigs, options = {}) {
                         }
                         catch { }
                     if (attempt === connectRetries) {
-                        console.warn(`[mcp] 连接失败 (${label}):`, err instanceof Error ? err.message : err);
                         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);
                     }
                 }
@@ -137,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/stdio.js

@@ -21,7 +21,9 @@ export class StdioTransport {
     }
     constructor(config, options = {}) {
         this.config = config;
-        this.initTimeoutMs = options.initTimeoutMs ?? 20_000;
+        const isUvx = /^uvx?$/i.test((config.command || "").trim().replace(/^.*[/\\]/, ""));
+        const defaultInitMs = isUvx ? 60_000 : 20_000;
+        this.initTimeoutMs = options.initTimeoutMs ?? defaultInitMs;
         this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
         this.initRetries = options.initRetries ?? 1;
         this.initRetryDelayMs = options.initRetryDelayMs ?? 3_000;
@@ -52,7 +54,12 @@ export class StdioTransport {
             if (env.UV_SILENT === undefined)
                 env.UV_SILENT = "1";
         }
-        this.process = spawn(this.config.command, this.config.args ?? [], {
+        // uvx/uv 不支持 -y 参数（与 npx -y 不同），自动去掉以免报错 "unexpected argument '-y' found"
+        let args = this.config.args ?? [];
+        if (cmdBase === "uvx" || cmdBase === "uv") {
+            args = args.filter((a) => a !== "-y" && a !== "--yes");
+        }
+        this.process = spawn(this.config.command, args, {
             env,
             stdio: ["pipe", "pipe", "pipe"],
         });
@@ -74,6 +81,16 @@ export class StdioTransport {
             this.rejectAll(new Error(`MCP process error: ${err.message}`));
         });
         child.on("exit", (code, signal) => {
+            if (code !== 0 && code !== null) {
+                const cmd = this.config.command;
+                const args = JSON.stringify(this.config.args ?? []);
+                // 延后读取 stderr，以便管道中尚未 flush 的输出先写入 stderrBuffer
+                setImmediate(() => {
+                    const stderrTail = this.stderrBuffer.trim().slice(-2048) || "(无 stderr 输出)";
+                    console.warn(`[mcp stdio] 子进程异常退出 command=${cmd} args=${args} code=${code} signal=${signal}`);
+                    console.warn("[mcp stdio] 子进程 stderr 末尾:", stderrTail);
+                });
+            }
             this.rejectAll(new Error(`MCP process exited: code=${code} signal=${signal}`));
             this.process = null;
         });

package/dist/core/tools/windows-shell.d.ts

@@ -0,0 +1,6 @@
+import type { BashOperations } from "@mariozechner/pi-coding-agent";
+/**
+ * 返回在 Windows 上使用 cmd.exe 的 BashOperations，供 createBashTool(..., { operations }) 使用。
+ * 这样在未安装 Git Bash 的 Windows 上也能执行 dir、cd、整理文件夹等命令。
+ */
+export declare function createWindowsShellOperations(): BashOperations;

package/dist/core/tools/windows-shell.js

@@ -0,0 +1,85 @@
+/**
+ * Windows 下无 Git Bash 时，使用 cmd.exe 执行 CLI 命令，避免 "No bash shell found" 报错。
+ * 桌面端打包后在 Windows 上运行时，bash 工具会使用本实现，支持 dir、cd、PowerShell 等常用命令。
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+function killProcessTreeWin32(pid) {
+    try {
+        spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+            stdio: "ignore",
+            detached: true,
+        });
+    }
+    catch {
+        // ignore
+    }
+}
+/**
+ * 返回在 Windows 上使用 cmd.exe 的 BashOperations，供 createBashTool(..., { operations }) 使用。
+ * 这样在未安装 Git Bash 的 Windows 上也能执行 dir、cd、整理文件夹等命令。
+ */
+export function createWindowsShellOperations() {
+    return {
+        exec: (command, cwd, { onData, signal, timeout, env }) => {
+            return new Promise((resolve, reject) => {
+                if (!existsSync(cwd)) {
+                    reject(new Error(`Working directory does not exist: ${cwd}\nCannot execute shell commands.`));
+                    return;
+                }
+                const child = spawn("cmd.exe", ["/c", command], {
+                    cwd,
+                    detached: true,
+                    env: env ?? process.env,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    shell: false,
+                });
+                let timedOut = false;
+                let timeoutHandle;
+                if (timeout !== undefined && timeout > 0) {
+                    timeoutHandle = setTimeout(() => {
+                        timedOut = true;
+                        if (child.pid)
+                            killProcessTreeWin32(child.pid);
+                    }, timeout * 1000);
+                }
+                if (child.stdout)
+                    child.stdout.on("data", onData);
+                if (child.stderr)
+                    child.stderr.on("data", onData);
+                child.on("error", (err) => {
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                    if (signal)
+                        signal.removeEventListener("abort", onAbort);
+                    reject(err);
+                });
+                const onAbort = () => {
+                    if (child.pid)
+                        killProcessTreeWin32(child.pid);
+                };
+                if (signal) {
+                    if (signal.aborted)
+                        onAbort();
+                    else
+                        signal.addEventListener("abort", onAbort, { once: true });
+                }
+                child.on("close", (code) => {
+                    if (timeoutHandle)
+                        clearTimeout(timeoutHandle);
+                    if (signal)
+                        signal.removeEventListener("abort", onAbort);
+                    if (signal?.aborted) {
+                        reject(new Error("aborted"));
+                        return;
+                    }
+                    if (timedOut) {
+                        reject(new Error(`timeout:${timeout}`));
+                        return;
+                    }
+                    resolve({ exitCode: code });
+                });
+            });
+        },
+    };
+}

package/dist/gateway/methods/agent-chat.js

@@ -305,11 +305,24 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                     if (errText.includes("Unknown value type") && errText.includes("[object Object]")) {
                         errText = "请求失败：模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
                     }
-                    // 本地模型子进程退出后，SDK 会报 terminated/Connection error，用 env 中的说明替换为可操作提示
+                    const isConnErr = /Connection error|ECONNREFUSED|fetch failed/i.test(msg.errorMessage);
                     const localFailed = process.env.LOCAL_LLM_START_FAILED;
-                    if (localFailed && (msg.errorMessage === "terminated" || /Connection error|ECONNREFUSED|fetch failed/i.test(msg.errorMessage))) {
+                    const isLocalProvider = provider === "local";
+                    const isModelRequired = /model is required|400.*model/i.test(msg.errorMessage);
+                    if (isLocalProvider && localFailed && (msg.errorMessage === "terminated" || isConnErr)) {
                         errText = `请求失败：${localFailed}`;
                     }
+                    else if ((provider === "openai-custom" || provider === "ollama") && isConnErr) {
+                        errText = "请求失败：无法连接到模型服务（若使用 Ollama 请确认已启动且 baseUrl 为 http://localhost:11434/v1，或改用「Ollama」Provider）。";
+                    }
+                    else if (isModelRequired && (provider === "openai-custom" || provider === "ollama")) {
+                        errText =
+                            "请求失败：模型名称未被服务端识别。若使用 Ollama，请确保「模型配置」中的模型名与终端中 `ollama list` 显示的名称完全一致（如 qwen3:4b）。";
+                    }
+                    else if (provider === "local" && /context size.*too large|VRAM|显存/i.test(msg.errorMessage)) {
+                        errText =
+                            "请求失败：显存/内存不足，当前上下文长度过大。请在「智能体配置」中将该智能体的「上下文长度」调小（如 8192 或 4096）后重新启动本地模型服务再试。";
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: errText } });
                 }
                 wsPayload = null;
@@ -337,10 +350,24 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                     if (errText.includes("Unknown value type") && errText.includes("[object Object]")) {
                         errText = "请求失败：模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
                     }
+                    const isConnErr = /Connection error|ECONNREFUSED|fetch failed/i.test(msg.errorMessage);
                     const localFailed = process.env.LOCAL_LLM_START_FAILED;
-                    if (localFailed && (msg.errorMessage === "terminated" || /Connection error|ECONNREFUSED|fetch failed/i.test(msg.errorMessage))) {
+                    const isLocalProvider = provider === "local";
+                    const isModelRequired = /model is required|400.*model/i.test(msg.errorMessage);
+                    if (isLocalProvider && localFailed && (msg.errorMessage === "terminated" || isConnErr)) {
                         errText = `请求失败：${localFailed}`;
                     }
+                    else if ((provider === "openai-custom" || provider === "ollama") && isConnErr) {
+                        errText = "请求失败：无法连接到模型服务（若使用 Ollama 请确认已启动且 baseUrl 为 http://localhost:11434/v1，或改用「Ollama」Provider）。";
+                    }
+                    else if (isModelRequired && (provider === "openai-custom" || provider === "ollama")) {
+                        errText =
+                            "请求失败：模型名称未被服务端识别。若使用 Ollama，请确保「模型配置」中的模型名与终端中 `ollama list` 显示的名称完全一致（如 qwen3:4b）。";
+                    }
+                    else if (provider === "local" && /context size.*too large|VRAM|显存/i.test(msg.errorMessage)) {
+                        errText =
+                            "请求失败：显存/内存不足，当前上下文长度过大。请在「智能体配置」中将该智能体的「上下文长度」调小（如 8192 或 4096）后重新启动本地模型服务再试。";
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: errText } });
                     hasReceivedAnyChunk = true;
                 }

package/dist/gateway/server.js

@@ -61,6 +61,46 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = join(__dirname, "..", "..");
 /** 内嵌到 Electron 时由主进程设置 OPENBOT_STATIC_DIR，指向打包后的 renderer/dist */
 const STATIC_DIR = process.env.OPENBOT_STATIC_DIR || join(PACKAGE_ROOT, "apps", "desktop", "renderer", "dist");
+/** 端口被占用时依次尝试的最大个数（38080, 38081, ...） */
+const MAX_PORT_ATTEMPTS = 20;
+/**
+ * 尝试将 httpServer 绑定到某端口；若被占用则尝试下一端口，返回实际绑定端口。
+ * @param server 已挂好路由的 HTTP Server
+ * @param startPort 首选端口
+ * @returns 实际监听的端口
+ */
+function listenOnPreferredOrNextPort(server, startPort) {
+    return new Promise((resolve, reject) => {
+        let tryPort = startPort;
+        const attempt = () => {
+            if (tryPort - startPort >= MAX_PORT_ATTEMPTS) {
+                reject(new Error(`No available port in range ${startPort}–${startPort + MAX_PORT_ATTEMPTS - 1}`));
+                return;
+            }
+            const onListen = () => {
+                server.off("error", onError);
+                const addr = server.address();
+                const p = typeof addr === "object" && addr && "port" in addr ? addr.port : tryPort;
+                resolve(p);
+            };
+            const onError = (err) => {
+                server.off("listening", onListen);
+                if (err?.code === "EADDRINUSE") {
+                    console.log(`Port ${tryPort} in use, trying ${tryPort + 1}...`);
+                    tryPort += 1;
+                    attempt();
+                }
+                else {
+                    reject(err);
+                }
+            };
+            server.once("listening", onListen);
+            server.once("error", onError);
+            server.listen(tryPort);
+        };
+        attempt();
+    });
+}
 const MIME_TYPES = {
     ".html": "text/html",
     ".js": "text/javascript",
@@ -77,7 +117,6 @@ const MIME_TYPES = {
     ".eot": "application/vnd.ms-fontobject",
 };
 export async function startGatewayServer(port = 38080) {
-    process.env.PORT = String(port);
     await ensureDesktopConfigInitialized();
     console.log(`Starting gateway server on port ${port}...`);
     // 每次启动时按已保存配置尝试启动本地模型服务（不阻塞、不影响主进程；失败仅提示）
@@ -89,7 +128,6 @@ export async function startGatewayServer(port = 38080) {
         const msg = e instanceof Error ? e.message : String(e);
         console.log("[local-llm] 提示：启动时发生异常，已跳过。", msg);
     }
-    setBackendBaseUrl(`http://localhost:${port}`);
     const { app: nestApp, express: nestExpress } = await createNestAppEmbedded();
     try {
         const agentsService = nestApp.get(AgentsService);
@@ -249,17 +287,16 @@ export async function startGatewayServer(port = 38080) {
             socket.destroy();
         }
     });
-    const actualPort = await new Promise((resolve) => {
-        httpServer.listen(port, () => {
-            const addr = httpServer.address();
-            const p = typeof addr === "object" && addr && "port" in addr ? addr.port : port;
-            console.log(`✅ Gateway server listening on ws://localhost:${p}`);
-            console.log(`   Health: http://localhost:${p}${PATHS.HEALTH}`);
-            console.log(`   API:    http://localhost:${p}${PATHS.SERVER_API}`);
-            console.log(`   WS:     ws://localhost:${p}${PATHS.WS}`);
-            resolve(p);
-        });
-    });
+    const actualPort = await listenOnPreferredOrNextPort(httpServer, port);
+    process.env.PORT = String(actualPort);
+    setBackendBaseUrl(`http://localhost:${actualPort}`);
+    if (actualPort !== port) {
+        console.log(`Using port ${actualPort} (preferred ${port} was in use).`);
+    }
+    console.log(`✅ Gateway server listening on ws://localhost:${actualPort}`);
+    console.log(`   Health: http://localhost:${actualPort}${PATHS.HEALTH}`);
+    console.log(`   API:    http://localhost:${actualPort}${PATHS.SERVER_API}`);
+    console.log(`   WS:     ws://localhost:${actualPort}${PATHS.WS}`);
     // 通道：根据配置注册并启动（飞书 WebSocket、钉钉 Stream 等）
     const channelsConfig = getChannelsConfigSync();
     const feishuCfg = channelsConfig.feishu;

package/dist/server/agent-config/agent-config.controller.d.ts

@@ -1,7 +1,15 @@
+import type { McpServerConfigStandardEntry } from '../../core/mcp/types.js';
 import { AgentConfigService, AgentConfigItem } from './agent-config.service.js';
 export declare class AgentConfigController {
     private readonly agentConfigService;
     constructor(agentConfigService: AgentConfigService);
+    testMcp(body: {
+        mcpServer: McpServerConfigStandardEntry;
+    }): Promise<{
+        success: boolean;
+        error: string | undefined;
+        toolsCount: number | undefined;
+    }>;
     listAgents(): Promise<{
         success: boolean;
         data: AgentConfigItem[];

package/dist/server/agent-config/agent-config.controller.js

@@ -17,6 +17,10 @@ let AgentConfigController = class AgentConfigController {
     constructor(agentConfigService) {
         this.agentConfigService = agentConfigService;
     }
+    async testMcp(body) {
+        const result = await this.agentConfigService.testMcpServer(body?.mcpServer ?? {});
+        return { success: result.success, error: result.error, toolsCount: result.toolsCount };
+    }
     async listAgents() {
         const agents = await this.agentConfigService.listAgents();
         return { success: true, data: agents };
@@ -44,6 +48,13 @@ let AgentConfigController = class AgentConfigController {
         return { success: true };
     }
 };
+__decorate([
+    Post('mcp/test'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "testMcp", null);
 __decorate([
     Get(),
     __metadata("design:type", Function),

package/dist/server/agent-config/agent-config.service.d.ts

@@ -1,4 +1,5 @@
 import type { McpServerConfig, McpServersStandardFormat } from '../../core/mcp/index.js';
+import type { McpServerConfigStandardEntry } from '../../core/mcp/types.js';
 import { DatabaseService } from '../database/database.service.js';
 import { WorkspaceService } from '../workspace/workspace.service.js';
 /** 缺省智能体 ID / 工作空间名，不可删除；对应目录 ~/.openbot/workspace/default */
@@ -136,4 +137,13 @@ export declare class AgentConfigService {
             modelItemCode?: string;
         }>;
     }): Promise<void>;
+    /**
+     * 测试单条 MCP 配置是否可用（连接并拉取工具列表后断开）。
+     * 用于配置界面「测试」按钮，可提前触发 uvx/npx 依赖安装。
+     */
+    testMcpServer(entry: McpServerConfigStandardEntry): Promise<{
+        success: boolean;
+        error?: string;
+        toolsCount?: number;
+    }>;
 }

package/dist/server/agent-config/agent-config.service.js

@@ -12,7 +12,10 @@ import { readFile, writeFile, mkdir } from 'fs/promises';
 import { join } from 'path';
 import { existsSync } from 'fs';
 import { homedir } from 'os';
-import { addPendingAgentReload } from '../../core/config/agent-reload-pending.js';
+import { testMcpConnection } from '../../core/mcp/operator.js';
+import { standardFormatToArray } from '../../core/mcp/config.js';
+import { addPendingAgentReload, consumePendingAgentReload } from '../../core/config/agent-reload-pending.js';
+import { agentManager } from '../../core/agent/agent-manager.js';
 import { DatabaseService } from '../database/database.service.js';
 import { WorkspaceService } from '../workspace/workspace.service.js';
 /** 工作空间名仅允许英文、数字、下划线、连字符 */
@@ -238,6 +241,9 @@ let AgentConfigService = class AgentConfigService {
         }
         await this.writeAgentsFile(file);
         await addPendingAgentReload(id).catch(() => { });
+        // 立即使该智能体下所有运行中的 AgentSession 失效，下次请求将用新配置创建新会话（安全：先持久化 compaction 再移除）
+        await agentManager.deleteSessionsByAgentId(id).catch(() => { });
+        await consumePendingAgentReload(id).catch(() => { });
         return { ...agent, isDefault: agent.id === DEFAULT_AGENT_ID };
     }
     async deleteAgent(id, options) {
@@ -306,6 +312,17 @@ let AgentConfigService = class AgentConfigService {
         }
         await this.writeAgentsFile(file);
     }
+    /**
+     * 测试单条 MCP 配置是否可用（连接并拉取工具列表后断开）。
+     * 用于配置界面「测试」按钮，可提前触发 uvx/npx 依赖安装。
+     */
+    async testMcpServer(entry) {
+        const configs = standardFormatToArray({ test: entry });
+        if (configs.length === 0) {
+            return { success: false, error: '无效配置：需 command（本地进程）或 url（远程服务）' };
+        }
+        return testMcpConnection(configs[0], { initTimeoutMs: 60_000 });
+    }
 };
 AgentConfigService = __decorate([
     Injectable(),

package/dist/server/agents/agents.gateway.js

@@ -108,7 +108,7 @@ __decorate([
 AgentsGateway = __decorate([
     WebSocketGateway({
         cors: {
-            origin: ['http://localhost:5173', 'http://localhost:38081'],
+            origin: ['http://localhost:5173', 'http://127.0.0.1:5173', 'http://localhost:38080', 'http://localhost:38081', 'http://127.0.0.1:38080', 'http://127.0.0.1:38081'],
             credentials: true,
         },
     }),