@next-open-ai/openclawx 0.8.40 → 0.8.58

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/core/memory/local-embedding.d.ts

@@ -1,10 +1,11 @@
 /**
- * 本地 embedding：仅 node-llama-cpp (GGUF)。不可用时返回 null，由上层决定是否使用在线 RAG。
+ * 本地 embedding：优先走本地 LLM 子进程服务（/v1/embeddings），
+ * 不可用时回退到 node-llama-cpp 直接加载（GGUF）。
  */
 import type { IEmbeddingProvider } from "./embedding-types.js";
 export declare function getLocalEmbeddingUnavailableReason(): string | null;
 /**
- * 获取本地 embedding 提供方（懒加载，失败后不再重试）。
- * 仅使用 node-llama-cpp (GGUF)。不可用时返回 null。
+ * 获取本地 embedding 提供方（懒加载）。
+ * 优先使用本地 LLM 子进程服务；不可用时回退到 node-llama-cpp 直接加载。
  */
 export declare function getLocalEmbeddingProvider(): Promise<IEmbeddingProvider | null>;

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

@@ -5,19 +5,59 @@ let envLogged = false;
 export function getLocalEmbeddingUnavailableReason() {
     return getLocalEmbeddingLlamaUnavailableReason();
 }
+/** 通过本地 LLM 子进程服务的 /v1/embeddings 接口获取向量 */
+function createLocalServerEmbeddingProvider(baseUrl) {
+    return {
+        name: "local-llm-server",
+        async embed(text) {
+            try {
+                const res = await fetch(`${baseUrl}/embeddings`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Authorization: "Bearer local" },
+                    body: JSON.stringify({ input: text }),
+                    signal: AbortSignal.timeout(30_000),
+                });
+                if (!res.ok)
+                    return null;
+                const data = await res.json();
+                const vec = data?.data?.[0]?.embedding;
+                return Array.isArray(vec) && vec.length > 0 ? vec : null;
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
 /**
- * 获取本地 embedding 提供方（懒加载，失败后不再重试）。
- * 仅使用 node-llama-cpp (GGUF)。不可用时返回 null。
+ * 获取本地 embedding 提供方（懒加载）。
+ * 优先使用本地 LLM 子进程服务；不可用时回退到 node-llama-cpp 直接加载。
  */
 export async function getLocalEmbeddingProvider() {
     if (cached)
         return cached;
+    // 优先：本地 LLM 子进程服务
+    const localBaseUrl = process.env.LOCAL_LLM_BASE_URL;
+    if (localBaseUrl) {
+        const serverProvider = createLocalServerEmbeddingProvider(localBaseUrl);
+        // 快速探测服务是否可用
+        const testVec = await serverProvider.embed("test");
+        if (testVec !== null) {
+            cached = serverProvider;
+            if (!envLogged) {
+                envLogged = true;
+                console.log("[RAG embedding] 使用本地 LLM 子进程服务");
+            }
+            return cached;
+        }
+    }
+    // 回退：node-llama-cpp 直接加载
     const provider = await getLocalEmbeddingLlamaProvider(getRagLocalModelPathSync());
     if (provider) {
         cached = provider;
         if (!envLogged) {
             envLogged = true;
-            console.warn("[RAG embedding] 本地模型使用 node-llama-cpp (GGUF)");
+            console.log("[RAG embedding] 使用 node-llama-cpp (GGUF) 直接加载");
         }
         return cached;
     }

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

@@ -9,6 +9,23 @@ import { consumePendingAgentReload } from "../../core/config/agent-reload-pendin
 import { registerProxyRunAbort } from "../proxy-run-abort.js";
 import { getSessionOutlet, sendSessionMessage } from "../../core/session-outlet/index.js";
 const COMPOSITE_KEY_SEP = "::";
+/** 将 delta/text 规范为字符串，避免 SDK 或上游返回对象时前端显示 [object Object] 或触发 Unknown value type */
+function normalizeChunkText(v) {
+    if (v == null)
+        return "";
+    if (typeof v === "string")
+        return v;
+    if (typeof v.content === "string")
+        return v.content;
+    if (typeof v.text === "string")
+        return v.text;
+    try {
+        return String(JSON.stringify(v));
+    }
+    catch {
+        return String(v);
+    }
+}
 /** 当前每个 session 的流式订阅（用于在 cancel 或新 run 前移除旧订阅，避免重复广播） */
 const sessionSubscriptionBySessionId = new Map();
 /**
@@ -40,7 +57,7 @@ const SYSTEM_MSG_PREFIX = "[System Message] ";
 const SYSTEM_MSG_SUFFIX = "\n";
 /**
  * 创建 Web 端会话消息消费者：将统一出口的 SessionMessage 转为 Gateway 事件并 broadcast。
- * 系统消息以 agent.chunk 形式发送，正文带 [System Message] 前缀且结尾换行，与当轮回复分行。
+ * 系统消息以独立事件 system_message 下发，前端做中间展示、不进入 session 聊天记录；各通道通过统一出口收到原始 system 消息后自行处理。
  */
 function createWebSessionConsumer(_sessionId) {
     return {
@@ -48,9 +65,8 @@ function createWebSessionConsumer(_sessionId) {
             const sid = msg.sessionId;
             if (msg.type === "system" && msg.code === "command.result") {
                 const raw = msg.payload?.text ?? "";
-                const text = raw ? SYSTEM_MSG_PREFIX + raw + SYSTEM_MSG_SUFFIX : "";
-                if (text)
-                    broadcastToSession(sid, createEvent("agent.chunk", { text, sessionId: sid }));
+                if (raw)
+                    broadcastToSession(sid, createEvent("system_message", { text: raw, code: "command.result", sessionId: sid }));
                 broadcastToSession(sid, createEvent("turn_end", { sessionId: sid, content: "" }));
                 broadcastToSession(sid, createEvent("message_complete", { sessionId: sid, content: "" }));
                 broadcastToSession(sid, createEvent("agent_end", { sessionId: sid }));
@@ -59,10 +75,8 @@ function createWebSessionConsumer(_sessionId) {
             }
             if (msg.type === "system" && msg.code === "mcp.progress") {
                 const raw = msg.payload?.message ?? msg.payload?.phase ?? "";
-                if (raw) {
-                    const text = SYSTEM_MSG_PREFIX + raw + SYSTEM_MSG_SUFFIX;
-                    broadcastToSession(sid, createEvent("agent.chunk", { text, sessionId: sid }));
-                }
+                if (raw)
+                    broadcastToSession(sid, createEvent("system_message", { text: raw, code: "mcp.progress", sessionId: sid }));
                 return;
             }
             if (msg.type === "chat") {
@@ -159,37 +173,40 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                 sendSessionMessage(targetSessionId, { type: "chat", code: "agent_end", payload: {} });
                 sendSessionMessage(targetSessionId, { type: "chat", code: "conversation_end", payload: {} });
             };
-            try {
-                await runForChannelStream({
-                    sessionId: targetSessionId,
-                    message,
-                    agentId: currentAgentId,
-                    signal,
-                }, {
-                    onChunk(delta) {
-                        sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: delta } });
-                    },
-                    onTurnEnd() {
-                        sendSessionMessage(targetSessionId, { type: "chat", code: "turn_end", payload: {} });
-                        sendSessionMessage(targetSessionId, { type: "chat", code: "message_complete", payload: {} });
-                    },
-                    onDone() {
-                        finishAndUnregister();
-                    },
-                });
-                return { status: "completed", sessionId: targetSessionId };
-            }
-            catch (error) {
+            runForChannelStream({
+                sessionId: targetSessionId,
+                message,
+                agentId: currentAgentId,
+                signal,
+            }, {
+                onChunk(delta) {
+                    sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: delta } });
+                },
+                onTurnEnd() {
+                    sendSessionMessage(targetSessionId, { type: "chat", code: "turn_end", payload: {} });
+                    sendSessionMessage(targetSessionId, { type: "chat", code: "message_complete", payload: {} });
+                },
+                onDone() {
+                    finishAndUnregister();
+                },
+            }).catch((error) => {
                 const isAbort = error?.name === "AbortError" || (typeof error?.message === "string" && error.message.includes("abort"));
                 if (!isAbort)
                     console.error(`Error in agent chat (proxy ${runnerType}):`, error);
                 finishAndUnregister();
                 if (!isAbort) {
-                    const errMsg = error?.message || String(error);
+                    let errMsg = error?.message || String(error);
+                    const needNormalize = typeof errMsg === "object" || (typeof errMsg === "string" && errMsg.includes("[object Object]"));
+                    if (needNormalize) {
+                        errMsg = normalizeChunkText(errMsg);
+                        if (typeof errMsg === "string" && errMsg.includes("Unknown value type") && errMsg.includes("[object Object]")) {
+                            errMsg = "模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
+                        }
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: `请求失败：${errMsg}` } });
                 }
-                return { status: "completed", sessionId: targetSessionId };
-            }
+            });
+            return { status: "streaming", sessionId: targetSessionId };
         }
         const isEphemeralSession = sessionType === "system" || sessionType === "scheduled";
         if (isEphemeralSession) {
@@ -250,10 +267,10 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                 const update = event;
                 if (update.assistantMessageEvent && update.assistantMessageEvent.type === "text_delta") {
                     hasReceivedAnyChunk = true;
-                    wsPayload = { type: "chat", code: "agent.chunk", payload: { text: update.assistantMessageEvent.delta } };
+                    wsPayload = { type: "chat", code: "agent.chunk", payload: { text: normalizeChunkText(update.assistantMessageEvent.delta) } };
                 }
                 else if (update.assistantMessageEvent && update.assistantMessageEvent.type === "thinking_delta") {
-                    wsPayload = { type: "chat", code: "agent.chunk", payload: { text: update.assistantMessageEvent.delta, isThinking: true } };
+                    wsPayload = { type: "chat", code: "agent.chunk", payload: { text: normalizeChunkText(update.assistantMessageEvent.delta), isThinking: true } };
                 }
                 else if (update.assistantMessageEvent?.type === "error" && update.assistantMessageEvent?.error?.errorMessage) {
                     console.warn("[agent.chat] model error:", update.assistantMessageEvent.error.errorMessage);
@@ -278,9 +295,21 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                     hasReceivedAnyChunk = true;
                 }
                 if (msg?.errorMessage) {
-                    const errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
+                    // 调试：定位本地 LLM 流式报错来源（pi-ai 等 SDK 抛出的原始 errorMessage）
+                    console.error("[agent.chat] message_end errorMessage:", msg.errorMessage);
+                    if (typeof msg.errorStack === "string")
+                        console.error("[agent.chat] message_end errorStack:", msg.errorStack);
+                    let errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
                         ? "API 余额不足，请到「设置」检查并充值后重试。"
-                        : `请求失败：${msg.errorMessage}`;
+                        : `请求失败：${normalizeChunkText(msg.errorMessage)}`;
+                    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;
@@ -298,9 +327,20 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
                     }
                 }
                 if (msg?.errorMessage) {
-                    const errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
+                    // 调试：定位 turn_end 时 SDK 传入的原始错误
+                    console.error("[agent.chat] turn_end errorMessage:", msg.errorMessage);
+                    if (typeof msg.errorStack === "string")
+                        console.error("[agent.chat] turn_end errorStack:", msg.errorStack);
+                    let errText = msg.errorMessage.includes("402") || msg.errorMessage.includes("Insufficient Balance")
                         ? "API 余额不足，请到「设置」检查并充值后重试。"
-                        : `请求失败：${msg.errorMessage}`;
+                        : `请求失败：${normalizeChunkText(msg.errorMessage)}`;
+                    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;
                 }
@@ -342,9 +382,8 @@ async function handleAgentChatInner(client, targetSessionId, message, params) {
         sessionSubscriptionBySessionId.set(targetSessionId, unsubscribe);
         try {
             await session.sendUserMessage(message, { deliverAs: "followUp" });
-            await agentDonePromise;
-            console.log(`Agent chat completed for session ${targetSessionId}`);
-            return { status: "completed", sessionId: targetSessionId };
+            // 流已启动，立即返回；前端以 agent_end 判断整轮结束，超时以「首包」计算更优
+            return { status: "streaming", sessionId: targetSessionId };
         }
         catch (error) {
             console.error(`Error in agent chat:`, error);

package/dist/gateway/server.js

@@ -45,6 +45,7 @@ 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 } 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";
@@ -79,6 +80,15 @@ export async function startGatewayServer(port = 38080) {
     process.env.PORT = String(port);
     await ensureDesktopConfigInitialized();
     console.log(`Starting gateway server on port ${port}...`);
+    // 每次启动时按已保存配置尝试启动本地模型服务（不阻塞、不影响主进程；失败仅提示）
+    try {
+        console.log("[local-llm] 网关启动：按已保存配置尝试启动本地模型服务…");
+        await tryStartLocalModelFromSavedConfig();
+    }
+    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();
     try {

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

@@ -25,7 +25,7 @@ export declare class AgentConfigController {
         success: boolean;
         data: AgentConfigItem;
     }>;
-    updateAgent(id: string, body: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers' | 'mcpMaxResultTokens' | 'systemPrompt' | 'icon' | 'runnerType' | 'coze' | 'openclawx' | 'opencode' | 'claudeCode' | 'useLongMemory' | 'webSearch'>>): Promise<{
+    updateAgent(id: string, body: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers' | 'mcpMaxResultTokens' | 'systemPrompt' | 'icon' | 'runnerType' | 'coze' | 'openclawx' | 'opencode' | 'claudeCode' | 'useLongMemory' | 'webSearch' | 'contextSize'>>): Promise<{
         success: boolean;
         data: AgentConfigItem;
     }>;

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

@@ -86,6 +86,8 @@ export interface AgentConfigItem {
         provider?: 'brave' | 'duck-duck-scrape';
         maxResultTokens?: number;
     };
+    /** 本地模型上下文长度（token 数），仅 runnerType 为 local 时生效；默认 32768（32K） */
+    contextSize?: number;
 }
 export interface DeleteAgentOptions {
     /** 是否同时删除该工作区在磁盘上的目录及文件；默认 false（仅删数据库中的工作区相关数据，保留目录） */

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

@@ -217,6 +217,11 @@ let AgentConfigService = class AgentConfigService {
             agent.claudeCode = updates.claudeCode;
         if (updates.useLongMemory !== undefined)
             agent.useLongMemory = updates.useLongMemory;
+        if ('contextSize' in updates) {
+            const v = updates.contextSize;
+            agent.contextSize =
+                typeof v === 'number' && Number.isInteger(v) && v > 0 ? v : undefined;
+        }
         if (updates.webSearch !== undefined) {
             agent.webSearch =
                 updates.webSearch && (updates.webSearch.enabled || updates.webSearch.provider)

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,
     });