@next-open-ai/openclawx 0.8.40 → 0.8.48

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

@@ -0,0 +1,58 @@
+/**
+ * 本地模型路径解析与文件存在性检查（与 ~/.cache/llama 及 node-llama-cpp 命名一致）。
+ */
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+export const LOCAL_LLM_CACHE_DIR = join(homedir(), ".cache", "llama");
+/**
+ * 取 modelUri 的末尾文件名（用于与已安装文件灵活匹配：不同 node-llama-cpp 版本可能生成不同前缀）。
+ * 例：hf:Qwen/Qwen3-4B-GGUF/Qwen3-4B-Q4_K_M.gguf → Qwen3-4B-Q4_K_M.gguf
+ */
+export function modelUriBasename(modelUri) {
+    const s = (modelUri || "").trim();
+    if (!s)
+        return "";
+    const parts = s.replace(/\\/g, "/").split("/");
+    return parts[parts.length - 1] || s;
+}
+/**
+ * 将 modelUri（hf:owner/repo/file.gguf）或文件名转为缓存目录下的文件名。
+ * 与 LocalModelsService.predictFilename 逻辑一致。
+ */
+export function modelUriToFilename(modelUri) {
+    const s = (modelUri || "").trim();
+    if (!s)
+        return "";
+    if (s.startsWith("hf:")) {
+        const parts = s.slice(3).split("/");
+        return "hf_" + parts.slice(0, -1).join("_") + "_" + parts[parts.length - 1];
+    }
+    // 已是文件名或路径，只取 basename
+    const last = s.replace(/\\/g, "/").split("/").pop();
+    return last ?? s;
+}
+/**
+ * 检查指定模型（uri 或文件名）是否已存在于本地缓存目录。
+ */
+export function isModelFileInCache(modelIdOrUri, cacheDir = LOCAL_LLM_CACHE_DIR) {
+    const filename = modelUriToFilename(modelIdOrUri);
+    if (!filename || !filename.endsWith(".gguf"))
+        return false;
+    return existsSync(join(cacheDir, filename));
+}
+/**
+ * 将前端传入的模型标识（hf: URI 或已安装文件名）转为可传给 node-llama-cpp 的路径或 URI。
+ * 若为纯文件名（如 hf_xxx.gguf），则返回缓存目录下的绝对路径。
+ */
+export function toModelPathForStart(uriOrFilename, cacheDir = LOCAL_LLM_CACHE_DIR) {
+    const s = (uriOrFilename || "").trim();
+    if (!s)
+        return "";
+    if (s.startsWith("hf:"))
+        return s;
+    const filename = modelUriToFilename(s);
+    if (!filename)
+        return s;
+    return join(cacheDir, filename);
+}

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

@@ -0,0 +1 @@
+export declare function createOpenAICompatServer(port: number): Promise<void>;

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

@@ -0,0 +1,235 @@
+/**
+ * OpenAI 兼容 HTTP 服务（严格对齐 [OpenAI Chat Completions / Embeddings API](https://platform.openai.com/docs/api-reference)）。
+ * 实现：GET /v1/models；POST /v1/chat/completions（流式/非流式，tool_calls）；POST /v1/embeddings。
+ * - 错误统一为 { error: { message, type } }，流式错误以 SSE 事件发送后结束。
+ * - 流式 delta 仅含规范字段：role、content（必为 string）、tool_calls（规范结构），避免客户端解析到未知类型。
+ */
+import { createServer } from "node:http";
+import { randomUUID } from "node:crypto";
+import { chatCompletionStream, chatCompletion, getEmbedding, isReady, } 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) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        req.on("data", (chunk) => (data += chunk));
+        req.on("end", () => {
+            try {
+                resolve(data ? JSON.parse(data) : {});
+            }
+            catch {
+                reject(new Error("Invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+function sendJson(res, status, body) {
+    const json = JSON.stringify(body);
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(json);
+}
+/** OpenAI 规范错误体：{ error: { message, type } } */
+function sendError(res, status, message, type = status >= 500 ? "server_error" : "invalid_request_error") {
+    sendJson(res, status, { error: { message: String(message), type } });
+}
+/** 构造 OpenAI 格式的 chat completion 响应对象 */
+function buildCompletionResponse(content, tool_calls, finish_reason, model) {
+    const message = { role: "assistant", content: tool_calls ? null : content };
+    if (tool_calls?.length)
+        message.tool_calls = tool_calls;
+    return {
+        id: `chatcmpl-${randomUUID()}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [{ index: 0, message, finish_reason, logprobs: null }],
+        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+    };
+}
+/** 构造 SSE delta chunk，仅含 OpenAI 流式规范字段，不包含 logprobs 避免下游解析异常 */
+function buildStreamChunk(id, model, delta, finish_reason) {
+    const choice = { index: 0, delta, finish_reason };
+    const chunk = {
+        id,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [choice],
+    };
+    return `data: ${JSON.stringify(chunk)}\n\n`;
+}
+async function handleChatCompletions(req, res) {
+    let body;
+    try {
+        body = await readBody(req);
+    }
+    catch {
+        return sendError(res, 400, "Invalid JSON body");
+    }
+    if (!isReady())
+        return sendError(res, 503, "模型尚未加载完成，请稍后重试", "server_error");
+    if (!Array.isArray(body.messages)) {
+        return sendError(res, 400, "Missing or invalid 'messages' (must be an array)", "invalid_request_error");
+    }
+    if (body.messages.length === 0) {
+        return sendError(res, 400, "'messages' must contain at least one message", "invalid_request_error");
+    }
+    const messages = body.messages;
+    const tools = Array.isArray(body.tools) ? body.tools : [];
+    const stream = body.stream === true;
+    const model = typeof body.model === "string" && body.model.trim() ? body.model.trim() : LLM_MODEL_ID;
+    const abortCtrl = new AbortController();
+    req.on("close", () => abortCtrl.abort());
+    if (stream) {
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        });
+        const id = `chatcmpl-${randomUUID()}`;
+        // 首包：role + content 占位，与 DeepSeek 等一致，避免仅 role 时下游对 delta 的严格校验
+        res.write(buildStreamChunk(id, model, { role: "assistant", content: "" }, null));
+        let pendingToolCalls;
+        let finishReason = "stop";
+        try {
+            await chatCompletionStream(messages, tools, (chunk) => {
+                if (abortCtrl.signal.aborted)
+                    return;
+                if (chunk.content != null && chunk.content !== "") {
+                    const text = typeof chunk.content === "string" ? chunk.content : String(chunk.content);
+                    res.write(buildStreamChunk(id, model, { content: text }, null));
+                }
+                if (chunk.tool_calls?.length) {
+                    pendingToolCalls = chunk.tool_calls;
+                }
+                if (chunk.finish_reason) {
+                    finishReason = chunk.finish_reason;
+                }
+            }, abortCtrl.signal);
+        }
+        catch (e) {
+            if (!abortCtrl.signal.aborted) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                const stack = e instanceof Error ? e.stack : undefined;
+                console.error("[local-llm] stream error:", errMsg);
+                if (stack)
+                    console.error("[local-llm] stream stack:", stack);
+                res.write(`data: ${JSON.stringify({ error: { message: errMsg, type: "server_error" } })}\n\n`);
+            }
+            res.end();
+            return;
+        }
+        // 若有 tool_calls，按 OpenAI 流式规范发一条 delta（含 index/id/type/function），与 DeepSeek 等一致
+        if (pendingToolCalls?.length) {
+            const deltaToolCalls = pendingToolCalls.map((tc, i) => ({
+                index: i,
+                id: typeof tc.id === "string" ? tc.id : `call_${i}`,
+                type: "function",
+                function: {
+                    name: typeof tc.function?.name === "string" ? tc.function.name : "",
+                    arguments: typeof tc.function?.arguments === "string" ? tc.function.arguments : "",
+                },
+            }));
+            res.write(buildStreamChunk(id, model, { tool_calls: deltaToolCalls }, null));
+            finishReason = "tool_calls";
+        }
+        res.write(buildStreamChunk(id, model, {}, finishReason));
+        res.write("data: [DONE]\n\n");
+        res.end();
+    }
+    else {
+        try {
+            const result = await chatCompletion(messages, tools, abortCtrl.signal);
+            sendJson(res, 200, buildCompletionResponse(result.content, result.tool_calls, result.finish_reason, model));
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            sendError(res, 500, msg, "server_error");
+        }
+    }
+}
+async function handleEmbeddings(req, res) {
+    let body;
+    try {
+        body = await readBody(req);
+    }
+    catch {
+        return sendError(res, 400, "Invalid JSON body", "invalid_request_error");
+    }
+    if (!isReady())
+        return sendError(res, 503, "模型尚未加载完成，请稍后重试", "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");
+    }
+    const inputs = Array.isArray(input) ? input : [input];
+    if (inputs.length === 0 || inputs.some((x) => typeof x !== "string")) {
+        return sendError(res, 400, "'input' must be a non-empty string or array of strings", "invalid_request_error");
+    }
+    try {
+        const data = await Promise.all(inputs.map(async (text, i) => ({
+            object: "embedding",
+            index: i,
+            embedding: await getEmbedding(text),
+        })));
+        sendJson(res, 200, {
+            object: "list",
+            data,
+            model: body.model ?? EMB_MODEL_ID,
+            usage: { prompt_tokens: 0, total_tokens: 0 },
+        });
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        sendError(res, 500, msg, "server_error");
+    }
+}
+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" },
+        ],
+    });
+}
+export function createOpenAICompatServer(port) {
+    return new Promise((resolve, reject) => {
+        const server = createServer(async (req, res) => {
+            const url = req.url ?? "";
+            const method = req.method ?? "";
+            // CORS
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+            if (method === "OPTIONS") {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            try {
+                if (method === "GET" && url === "/v1/models") {
+                    handleModels(req, res);
+                }
+                else if (method === "POST" && url === "/v1/chat/completions") {
+                    await handleChatCompletions(req, res);
+                }
+                else if (method === "POST" && url === "/v1/embeddings") {
+                    await handleEmbeddings(req, res);
+                }
+                else {
+                    sendError(res, 404, `Not found: ${method} ${url}`, "invalid_request_error");
+                }
+            }
+            catch (e) {
+                if (!res.headersSent)
+                    sendError(res, 500, String(e));
+            }
+        });
+        server.listen(port, "127.0.0.1", () => {
+            console.log(`[local-llm] OpenAI 兼容服务已启动: http://127.0.0.1:${port}/v1`);
+            resolve();
+        });
+        server.on("error", reject);
+    });
+}

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,16 @@ 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 = "请求失败：模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: errText } });
                 }
                 wsPayload = null;
@@ -298,9 +322,16 @@ 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 = "请求失败：模型返回了不支持的数据结构（如工具调用流），请尝试关闭工具或更换模型。";
+                    }
                     sendSessionMessage(targetSessionId, { type: "chat", code: "agent.chunk", payload: { text: errText } });
                     hasReceivedAnyChunk = true;
                 }
@@ -342,9 +373,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

@@ -44,7 +44,9 @@ 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 } from "../core/config/desktop-config.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 { createNestAppEmbedded } from "../server/bootstrap.js";
 import { registerChannel, startAllChannels, stopAllChannels } from "./channel/registry.js";
 import { createFeishuChannel } from "./channel/adapters/feishu.js";
@@ -79,6 +81,57 @@ 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();
+            }
+        }
+    }
+    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);
+            });
+        }
+    }
     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（仅删数据库中的工作区相关数据，保留目录） */