@next-open-ai/openclawx 0.8.48 → 0.8.58

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

@@ -6,7 +6,7 @@
  */
 import { createServer } from "node:http";
 import { randomUUID } from "node:crypto";
-import { chatCompletionStream, chatCompletion, getEmbedding, isReady, } from "./llm-context.js";
+import { chatCompletionStream, chatCompletion, getEmbedding, isLlmReady, isEmbeddingReady, } from "./llm-context.js";
 const LLM_MODEL_ID = process.env.LOCAL_LLM_MODEL_ID ?? "local-llm";
 const EMB_MODEL_ID = process.env.LOCAL_EMB_MODEL_ID ?? "local-embedding";
 function readBody(req) {
@@ -67,8 +67,8 @@ async function handleChatCompletions(req, res) {
     catch {
         return sendError(res, 400, "Invalid JSON body");
     }
-    if (!isReady())
-        return sendError(res, 503, "模型尚未加载完成，请稍后重试", "server_error");
+    if (!isLlmReady())
+        return sendError(res, 503, "LLM 模型未加载，请先启动本地模型服务并选择 LLM 模型", "server_error");
     if (!Array.isArray(body.messages)) {
         return sendError(res, 400, "Missing or invalid 'messages' (must be an array)", "invalid_request_error");
     }
@@ -157,8 +157,8 @@ async function handleEmbeddings(req, res) {
     catch {
         return sendError(res, 400, "Invalid JSON body", "invalid_request_error");
     }
-    if (!isReady())
-        return sendError(res, 503, "模型尚未加载完成，请稍后重试", "server_error");
+    if (!isEmbeddingReady())
+        return sendError(res, 503, "Embedding 模型未加载，请先启动本地模型服务并选择 Embedding 模型", "server_error");
     const input = body.input;
     if (input === undefined || input === null) {
         return sendError(res, 400, "Missing 'input' (string or array of strings)", "invalid_request_error");
@@ -186,13 +186,12 @@ async function handleEmbeddings(req, res) {
     }
 }
 function handleModels(_req, res) {
-    sendJson(res, 200, {
-        object: "list",
-        data: [
-            { id: LLM_MODEL_ID, object: "model", created: 0, owned_by: "local" },
-            { id: EMB_MODEL_ID, object: "model", created: 0, owned_by: "local" },
-        ],
-    });
+    const data = [];
+    if (isLlmReady())
+        data.push({ id: LLM_MODEL_ID, object: "model", created: 0, owned_by: "local" });
+    if (isEmbeddingReady())
+        data.push({ id: EMB_MODEL_ID, object: "model", created: 0, owned_by: "local" });
+    sendJson(res, 200, { object: "list", data });
 }
 export function createOpenAICompatServer(port) {
     return new Promise((resolve, reject) => {

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

@@ -0,0 +1,5 @@
+/**
+ * 按已保存的配置（默认智能体的 local 模型与上下文长度）尝试启动本地模型服务。
+ * 仅当已下载的模型文件存在时才启动；不抛错；失败时设置 process.env.LOCAL_LLM_START_FAILED 并打日志。
+ */
+export declare function tryStartLocalModelFromSavedConfig(): Promise<void>;

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()) {
+            process.env.LOCAL_LLM_START_FAILED =
+                "未配置默认本地模型，请在「模型配置」中选择 LLM 后点击「启动本地模型服务」";
+            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/transport/stdio.d.ts

@@ -23,10 +23,16 @@ export declare class StdioTransport {
     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;

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

@@ -13,9 +13,15 @@ export class StdioTransport {
     nextId = 1;
     pending = new Map();
     buffer = "";
+    stderrBuffer = "";
+    static pendingKey(id) {
+        if (id === undefined || id === null)
+            return "";
+        return String(id);
+    }
     constructor(config, options = {}) {
         this.config = config;
-        this.initTimeoutMs = options.initTimeoutMs ?? 10_000;
+        this.initTimeoutMs = options.initTimeoutMs ?? 20_000;
         this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
         this.initRetries = options.initRetries ?? 1;
         this.initRetryDelayMs = options.initRetryDelayMs ?? 3_000;
@@ -26,6 +32,26 @@ export class StdioTransport {
             return;
         }
         const env = { ...process.env, ...this.config.env };
+        // 避免 Python 类 MCP 在 pipe 下全缓冲 stdout，导致 initialize 响应迟迟不到而超时
+        if (env.PYTHONUNBUFFERED === undefined)
+            env.PYTHONUNBUFFERED = "1";
+        // npx/uvx 可能向 stdout 输出安装/进度等，污染 Newline-delimited JSON，导致无法解析；设为静默
+        const cmd = (this.config.command || "").trim().toLowerCase();
+        const cmdBase = cmd.includes("/") ? cmd.split("/").pop() : cmd;
+        if (cmdBase === "npx" || cmdBase === "npm") {
+            if (env.CI === undefined)
+                env.CI = "1";
+            if (env.NO_UPDATE_NOTIFIER === undefined)
+                env.NO_UPDATE_NOTIFIER = "1";
+            if (env.npm_config_loglevel === undefined)
+                env.npm_config_loglevel = "silent";
+        }
+        else if (cmdBase === "uvx" || cmdBase === "uv") {
+            if (env.CI === undefined)
+                env.CI = "1";
+            if (env.UV_SILENT === undefined)
+                env.UV_SILENT = "1";
+        }
         this.process = spawn(this.config.command, this.config.args ?? [], {
             env,
             stdio: ["pipe", "pipe", "pipe"],
@@ -35,10 +61,14 @@ export class StdioTransport {
             this.buffer += chunk.toString("utf-8");
             this.flushLines();
         });
+        // 部分 MCP 实现或包装可能把 JSON-RPC 写到 stderr，单独按行解析以尝试匹配响应（不混入 stdout 避免交叉破坏 JSON）
         child.stderr?.on("data", (data) => {
-            const msg = data.toString("utf-8").trim();
-            if (msg)
-                console.warn("[mcp stdio stderr]", msg);
+            const raw = data.toString("utf-8");
+            const trimmed = raw.trim();
+            if (trimmed && !raw.includes("jsonrpc"))
+                console.warn("[mcp stdio stderr]", trimmed);
+            this.stderrBuffer += raw;
+            this.flushStderrLines();
         });
         child.on("error", (err) => {
             this.rejectAll(new Error(`MCP process error: ${err.message}`));
@@ -66,31 +96,76 @@ export class StdioTransport {
             }
         }
     }
-    flushLines() {
-        const lines = this.buffer.split("\n");
-        this.buffer = lines.pop() ?? "";
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const msg = JSON.parse(trimmed);
-                if ("id" in msg && msg.id !== undefined) {
-                    const pending = this.pending.get(msg.id);
-                    if (pending) {
-                        clearTimeout(pending.timer);
-                        this.pending.delete(msg.id);
-                        if (msg.error) {
-                            pending.reject(new Error(msg.error.message));
-                        }
-                        else {
-                            pending.resolve(msg);
-                        }
+    /** 从一行中解析 JSON-RPC 响应：整行即 JSON，或从第一个 { 开始提取到匹配的 }（兼容 npx/uvx 等前缀输出） */
+    static parseJsonRpcResponse(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return null;
+        try {
+            const msg = JSON.parse(trimmed);
+            if ("id" in msg && msg.id !== undefined)
+                return msg;
+            return null;
+        }
+        catch {
+            const start = trimmed.indexOf("{");
+            if (start === -1)
+                return null;
+            let depth = 0;
+            let end = -1;
+            for (let i = start; i < trimmed.length; i++) {
+                const c = trimmed[i];
+                if (c === "{")
+                    depth++;
+                else if (c === "}") {
+                    depth--;
+                    if (depth === 0) {
+                        end = i;
+                        break;
                     }
                 }
             }
+            if (end === -1)
+                return null;
+            try {
+                const msg = JSON.parse(trimmed.slice(start, end + 1));
+                if ("id" in msg && msg.id !== undefined)
+                    return msg;
+                return null;
+            }
             catch {
-                // 忽略非 JSON 行
+                return null;
+            }
+        }
+    }
+    flushLines() {
+        this.flushLinesFromBuffer(this.buffer, (rest) => {
+            this.buffer = rest;
+        });
+    }
+    flushStderrLines() {
+        this.flushLinesFromBuffer(this.stderrBuffer, (rest) => {
+            this.stderrBuffer = rest;
+        });
+    }
+    flushLinesFromBuffer(buf, setRest) {
+        const lines = buf.split("\n");
+        setRest(lines.pop() ?? "");
+        for (const line of lines) {
+            const msg = StdioTransport.parseJsonRpcResponse(line);
+            if (!msg)
+                continue;
+            const key = StdioTransport.pendingKey(msg.id);
+            const pending = key ? this.pending.get(key) : undefined;
+            if (pending) {
+                clearTimeout(pending.timer);
+                this.pending.delete(key);
+                if (msg.error) {
+                    pending.reject(new Error(msg.error.message));
+                }
+                else {
+                    pending.resolve(msg);
+                }
             }
         }
     }
@@ -129,13 +204,18 @@ export class StdioTransport {
                 reject(new Error("MCP transport not connected"));
                 return;
             }
+            const key = StdioTransport.pendingKey(req.id);
+            if (!key) {
+                reject(new Error("MCP request id is required"));
+                return;
+            }
             const t = timeoutMs ?? this.requestTimeoutMs;
             const timer = setTimeout(() => {
-                if (this.pending.delete(req.id)) {
+                if (this.pending.delete(key)) {
                     reject(new Error(`MCP request timeout (${t}ms)`));
                 }
             }, t);
-            this.pending.set(req.id, { resolve, reject, timer });
+            this.pending.set(key, { resolve, reject, timer });
             this.process.stdin.write(JSON.stringify(req) + "\n", "utf-8");
         });
     }

package/dist/core/memory/local-embedding-llama.js

@@ -1,5 +1,3 @@
-import { join } from "path";
-import { homedir } from "os";
 let cached = null;
 let initError = null;
 let lastQueryError = null;
@@ -34,9 +32,9 @@ export async function getLocalEmbeddingLlamaProvider(modelPath) {
             await Promise.resolve(nodeModule.register(loaderUrl, import.meta.url));
         }
         const { getLlama, resolveModelFile, LlamaLogLevel } = await import("node-llama-cpp");
+        const { LOCAL_LLM_CACHE_DIR } = await import("../local-llm-server/model-resolve.js");
         const llama = await getLlama({ logLevel: LlamaLogLevel.error });
-        const cacheDir = join(homedir(), ".cache", "llama");
-        const resolved = await resolveModelFile(effectivePath, cacheDir);
+        const resolved = await resolveModelFile(effectivePath, LOCAL_LLM_CACHE_DIR);
         const model = await llama.loadModel({ modelPath: resolved });
         const embeddingCtx = await model.createEmbeddingContext();
         const provider = {

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

@@ -305,6 +305,11 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                     if (errText.includes("Unknown value type") && errText.includes("[object Object]")) {
                         errText = "请求失败：模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
                     }
+                    // 本地模型子进程退出后，SDK 会报 terminated/Connection error，用 env 中的说明替换为可操作提示
+                    const localFailed = process.env.LOCAL_LLM_START_FAILED;
+                    if (localFailed && (msg.errorMessage === "terminated" || /Connection error|ECONNREFUSED|fetch failed/i.test(msg.errorMessage))) {
+                        errText = `请求失败：${localFailed}`;
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: errText } });
                 }
                 wsPayload = null;
@@ -332,6 +337,10 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                     if (errText.includes("Unknown value type") && errText.includes("[object Object]")) {
                         errText = "请求失败：模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
                     }
+                    const localFailed = process.env.LOCAL_LLM_START_FAILED;
+                    if (localFailed && (msg.errorMessage === "terminated" || /Connection error|ECONNREFUSED|fetch failed/i.test(msg.errorMessage))) {
+                        errText = `请求失败：${localFailed}`;
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: errText } });
                     hasReceivedAnyChunk = true;
                 }

package/dist/gateway/server.js

@@ -44,9 +44,8 @@ import multer from "multer";
 import { handleInstallSkillFromPath } from "./methods/install-skill-from-path.js";
 import { handleInstallSkillFromUpload } from "./methods/install-skill-from-upload.js";
 import { setBackendBaseUrl } from "./backend-url.js";
-import { ensureDesktopConfigInitialized, getChannelsConfigSync, loadDesktopAgentConfig } from "../core/config/desktop-config.js";
-import { startLocalLlmServer } from "../core/local-llm-server/index.js";
-import { isModelFileInCache } from "../core/local-llm-server/model-resolve.js";
+import { ensureDesktopConfigInitialized, getChannelsConfigSync } from "../core/config/desktop-config.js";
+import { tryStartLocalModelFromSavedConfig } from "../core/local-llm-server/start-from-config.js";
 import { createNestAppEmbedded } from "../server/bootstrap.js";
 import { registerChannel, startAllChannels, stopAllChannels } from "./channel/registry.js";
 import { createFeishuChannel } from "./channel/adapters/feishu.js";
@@ -81,56 +80,14 @@ export async function startGatewayServer(port = 38080) {
     process.env.PORT = String(port);
     await ensureDesktopConfigInitialized();
     console.log(`Starting gateway server on port ${port}...`);
-    // 若默认智能体或环境变量指定为 local provider，后台启动本地 LLM 子进程（不阻塞主服务启动）
-    // 仅读 env 时，桌面端选「本机」默认 agent 时可能未设 OPENBOT_PROVIDER，导致本地服务未启、出现 Connection error
-    const envProvider = process.env.OPENBOT_PROVIDER ?? "";
-    let shouldStartLocal = envProvider === "local";
-    let defaultLocalModel;
-    let defaultAgentContextSize;
+    // 每次启动时按已保存配置尝试启动本地模型服务（不阻塞、不影响主进程；失败仅提示）
     try {
-        const defaultAgent = await loadDesktopAgentConfig("default");
-        if (defaultAgent) {
-            defaultAgentContextSize = defaultAgent.contextSize;
-            if (!shouldStartLocal) {
-                shouldStartLocal =
-                    defaultAgent.provider === "local" &&
-                        defaultAgent.runnerType !== "coze" &&
-                        defaultAgent.runnerType !== "openclawx" &&
-                        defaultAgent.runnerType !== "opencode" &&
-                        defaultAgent.runnerType !== "claude_code";
-            }
-            if (shouldStartLocal && defaultAgent.provider === "local" && defaultAgent.model?.trim()) {
-                defaultLocalModel = defaultAgent.model.trim();
-            }
-        }
+        console.log("[local-llm] 网关启动：按已保存配置尝试启动本地模型服务…");
+        await tryStartLocalModelFromSavedConfig();
     }
-    catch {
-        // ignore
-    }
-    if (shouldStartLocal) {
-        // 若缺省模型已指定但文件不在缓存中，不启动本地服务，标记不可用，由用户在设置中下载后手动启动
-        const llmFileExists = !defaultLocalModel || isModelFileInCache(defaultLocalModel);
-        if (!llmFileExists) {
-            process.env.LOCAL_LLM_START_FAILED = `缺省模型文件不存在: ${defaultLocalModel}，请先在「模型管理」中下载或选择已安装模型后点击「启动本地模型服务」`;
-            console.warn("[local-llm] 未启动:", process.env.LOCAL_LLM_START_FAILED);
-        }
-        else {
-            const opts = {
-                ...(defaultLocalModel ? { llmModelPath: defaultLocalModel } : {}),
-                contextSize: defaultAgentContextSize ?? 32768,
-            };
-            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.warn("[local-llm] 启动失败:", msg);
-            });
-        }
+    catch (e) {
+        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();

package/dist/server/bootstrap.d.ts

@@ -11,5 +11,6 @@ export interface NestAppResult {
 export declare function createNestAppEmbedded(): Promise<NestAppResult>;
 /**
  * 独立启动时使用：设置 globalPrefix 并监听端口。
+ * 先执行桌面配置初始化，保证首次启动即有 local provider 与缺省模型。
  */
 export declare function createNestAppStandalone(port?: number): Promise<INestApplication>;

package/dist/server/bootstrap.js

@@ -6,6 +6,7 @@
 import { NestFactory } from '@nestjs/core';
 import express from 'express';
 import { AppModule } from './app.module.js';
+import { ensureDesktopConfigInitialized } from '../core/config/desktop-config.js';
 const BODY_LIMIT = '10mb';
 /**
  * 创建 Nest 应用（内嵌模式）：不 listen，不设置 globalPrefix。
@@ -27,8 +28,10 @@ export async function createNestAppEmbedded() {
 }
 /**
  * 独立启动时使用：设置 globalPrefix 并监听端口。
+ * 先执行桌面配置初始化，保证首次启动即有 local provider 与缺省模型。
  */
 export async function createNestAppStandalone(port = 38081) {
+    await ensureDesktopConfigInitialized();
     const app = await NestFactory.create(AppModule, {
         cors: true,
     });

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

@@ -153,25 +153,48 @@ export declare class ConfigController {
             baseUrl: string | undefined;
         };
     };
-    /** 启动本地模型服务：可选指定 LLM 与 Embedding 模型（文件名或 hf: URI），先停后启 */
+    /** 启动本地模型服务：LLM/Embedding 任一已下载即可启动，只启动已存在的模型并提示；失败仅返回错误信息不抛错 */
     startLocalLlm(body: {
         llmModelUri?: string;
         embeddingModelUri?: string;
     }): Promise<{
+        success: boolean;
+        data: {
+            error: string;
+            baseUrl?: undefined;
+            message?: undefined;
+        };
+    } | {
         success: boolean;
         data: {
             baseUrl: string;
+            message: string;
+            error?: undefined;
         };
     }>;
-    /** 开始后台下载模型（立即返回，进度通过 GET local-models/progress/:uri 轮询） */
+    /** 开始后台下载模型（立即返回，进度通过 GET local-models/progress 轮询）。useMirror=true 使用国内镜像。 */
     startDownload(body: {
         modelUri: string;
+        useMirror?: boolean;
     }): Promise<{
         success: boolean;
         data: {
             filename: string;
         };
     }>;
+    /** 取消指定模型的下载 */
+    cancelDownload(body: {
+        modelUri: string;
+    }): {
+        success: boolean;
+    };
+    /** 推荐模型列表（含是否已安装），用于展示「已下载」或中国/全球下载按钮 */
+    getRecommendedWithStatus(): Promise<{
+        success: boolean;
+        data: (import("./local-models.service.js").RecommendedModel & {
+            isInstalled: boolean;
+        })[];
+    }>;
     /** 查询下载进度 */
     getDownloadProgress(uri: string): {
         success: boolean;

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

@@ -12,9 +12,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Controller, Get, Put, Body, Param, Query, Delete, Post } from '@nestjs/common';
 import { OPENCODE_FREE_MODELS } from '../../core/agent/proxy/adapters/opencode-free-models.js';
-import { loadDesktopAgentConfig } from '../../core/config/desktop-config.js';
+import { loadDesktopAgentConfig, setDefaultModel } from '../../core/config/desktop-config.js';
 import { startLocalLlmServer, stopLocalLlmServer } from '../../core/local-llm-server/index.js';
-import { toModelPathForStart, LOCAL_LLM_CACHE_DIR } from '../../core/local-llm-server/model-resolve.js';
+import { resolveModelPathInCache, LOCAL_LLM_CACHE_DIR } from '../../core/local-llm-server/model-resolve.js';
 import { ConfigService } from './config.service.js';
 import { LocalModelsService } from './local-models.service.js';
 let ConfigController = class ConfigController {
@@ -93,12 +93,30 @@ let ConfigController = class ConfigController {
             data: { available, error: error || undefined, baseUrl: baseUrl || undefined },
         };
     }
-    /** 启动本地模型服务：可选指定 LLM 与 Embedding 模型（文件名或 hf: URI），先停后启 */
+    /** 启动本地模型服务：LLM/Embedding 任一已下载即可启动，只启动已存在的模型并提示；失败仅返回错误信息不抛错 */
     async startLocalLlm(body) {
         stopLocalLlmServer();
         delete process.env.LOCAL_LLM_BASE_URL;
         delete process.env.LOCAL_LLM_START_FAILED;
-        let contextSize = 32768;
+        const llmPath = body.llmModelUri?.trim();
+        const embPath = body.embeddingModelUri?.trim();
+        if (!llmPath && !embPath) {
+            return { success: false, data: { error: '请至少选择 LLM 或 Embedding 模型之一' } };
+        }
+        const llmResolved = llmPath ? resolveModelPathInCache(llmPath, LOCAL_LLM_CACHE_DIR) : '';
+        const embResolved = embPath ? resolveModelPathInCache(embPath, LOCAL_LLM_CACHE_DIR) : '';
+        if (!llmResolved && !embResolved) {
+            return { success: false, data: { error: '未找到已下载的模型文件，请先在「模型管理」中下载' } };
+        }
+        if (llmPath) {
+            try {
+                await setDefaultModel('local', llmPath);
+            }
+            catch {
+                // 保存失败不阻断启动
+            }
+        }
+        let contextSize;
         try {
             const defaultAgent = await loadDesktopAgentConfig('default');
             if (defaultAgent?.contextSize != null && defaultAgent.contextSize > 0) {
@@ -108,29 +126,48 @@ let ConfigController = class ConfigController {
         catch {
             // ignore
         }
-        const llmPath = body.llmModelUri?.trim();
-        const embPath = body.embeddingModelUri?.trim();
+        if (contextSize == null) {
+            const envMax = process.env.LOCAL_LLM_CONTEXT_MAX;
+            contextSize = envMax != null && String(envMax).trim() !== '' ? parseInt(envMax, 10) || 32768 : 32768;
+        }
         const opts = {
-            ...(llmPath ? { llmModelPath: toModelPathForStart(llmPath, LOCAL_LLM_CACHE_DIR) } : {}),
-            ...(embPath ? { embeddingModelPath: toModelPathForStart(embPath, LOCAL_LLM_CACHE_DIR) } : {}),
+            ...(llmResolved ? { llmModelPath: llmResolved } : {}),
+            ...(embResolved ? { embeddingModelPath: embResolved } : {}),
             contextSize,
         };
         try {
             const handle = await startLocalLlmServer(opts);
             process.env.LOCAL_LLM_BASE_URL = handle.baseUrl;
-            return { success: true, data: { baseUrl: handle.baseUrl } };
+            const message = llmResolved && embResolved
+                ? '已启动 LLM + Embedding'
+                : llmResolved
+                    ? '已启动 LLM 模型（当前未使用 Embedding）'
+                    : '已启动 Embedding 模型（当前未使用 LLM）';
+            return { success: true, data: { baseUrl: handle.baseUrl, message } };
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
             process.env.LOCAL_LLM_START_FAILED = msg;
-            throw new Error(msg);
+            return { success: false, data: { error: msg } };
         }
     }
-    /** 开始后台下载模型（立即返回，进度通过 GET local-models/progress/:uri 轮询） */
+    /** 开始后台下载模型（立即返回，进度通过 GET local-models/progress 轮询）。useMirror=true 使用国内镜像。 */
     async startDownload(body) {
-        const result = await this.localModelsService.startDownload(body.modelUri);
+        const result = await this.localModelsService.startDownload(body.modelUri, {
+            useMirror: body.useMirror === true,
+        });
         return { success: true, data: result };
     }
+    /** 取消指定模型的下载 */
+    cancelDownload(body) {
+        this.localModelsService.cancelDownload(body.modelUri);
+        return { success: true };
+    }
+    /** 推荐模型列表（含是否已安装），用于展示「已下载」或中国/全球下载按钮 */
+    async getRecommendedWithStatus() {
+        const models = await this.localModelsService.getRecommendedWithStatus();
+        return { success: true, data: models };
+    }
     /** 查询下载进度 */
     getDownloadProgress(uri) {
         const progress = this.localModelsService.getDownloadProgress(uri);
@@ -219,6 +256,19 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], ConfigController.prototype, "startDownload", null);
+__decorate([
+    Post('local-models/cancel-download'),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], ConfigController.prototype, "cancelDownload", null);
+__decorate([
+    Get('local-models/recommended-with-status'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ConfigController.prototype, "getRecommendedWithStatus", null);
 __decorate([
     Get('local-models/progress'),
     __param(0, Query('uri')),

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

@@ -91,11 +91,14 @@ export declare class ConfigService {
     private configPath;
     private config;
     constructor(agentConfigService: AgentConfigService);
+    /** 预装本地推理缺省：与 desktop-config 的 DEFAULT_LOCAL_LLM_MODEL_ID / DEFAULT_LOCAL_MODEL_ITEM_CODE 一致 */
+    private static readonly DEFAULT_LOCAL_MODEL_ID;
+    private static readonly DEFAULT_LOCAL_MODEL_ITEM_CODE;
     private getDefaultConfig;
     /** 当前缺省智能体 id */
     getDefaultAgentId(config?: AppConfig): string;
     private loadConfig;
-    /** 每次获取前从磁盘重新读取，保证打开配置界面时显示最新（含 CLI 写入的配置） */
+    /** 每次获取前从磁盘重新读取，保证打开配置界面时显示最新（含 CLI 写入的配置）。本地 LLM 可用时注入 local 与缺省模型项，供所有智能体使用。 */
     getConfig(): Promise<AppConfig>;
     updateConfig(updates: Partial<AppConfig>): Promise<AppConfig>;
     private saveConfig;