@next-open-ai/openclawx 0.8.40 → 0.8.58

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

@@ -0,0 +1,242 @@
+/**
+ * node-llama-cpp 模型实例管理。
+ * 可只加载 LLM、只加载 Embedding、或两者都加载；有一个就启动一个，不因缺另一个而失败。
+ */
+import { LOCAL_LLM_CACHE_DIR } from "./model-resolve.js";
+let llama = null;
+let llmModel = null;
+let embeddingModel = null;
+let embeddingCtx = null;
+/** 上下文窗口大小，initModels 时设置，用于 createContext；默认 32K 以容纳较长 system + tools */
+let storedContextSize = 32768;
+/** 串行锁：同一模型同一时间只处理一个推理请求 */
+let llmQueue = Promise.resolve();
+async function getLlamaInstance(gpuLayers) {
+    if (llama)
+        return llama;
+    const { getLlama, LlamaLogLevel } = await import("node-llama-cpp");
+    llama = await getLlama({
+        logLevel: LlamaLogLevel.warn,
+        ...(gpuLayers !== undefined ? { gpu: gpuLayers === 0 ? false : "auto" } : {}),
+    });
+    return llama;
+}
+export async function initModels(opts) {
+    storedContextSize = opts.contextSize ?? 32768;
+    const { resolveModelFile } = await import("node-llama-cpp");
+    const instance = await getLlamaInstance(opts.gpuLayers);
+    const cacheDir = LOCAL_LLM_CACHE_DIR;
+    if (opts.llmModelPath?.trim()) {
+        console.log("[local-llm] 加载 LLM 模型:", opts.llmModelPath);
+        const llmPath = await resolveModelFile(opts.llmModelPath, cacheDir);
+        llmModel = await instance.loadModel({ modelPath: llmPath });
+    }
+    else {
+        llmModel = null;
+    }
+    if (opts.embeddingModelPath?.trim()) {
+        console.log("[local-llm] 加载 Embedding 模型:", opts.embeddingModelPath);
+        const embPath = await resolveModelFile(opts.embeddingModelPath, cacheDir);
+        embeddingModel = await instance.loadModel({ modelPath: embPath });
+        embeddingCtx = await embeddingModel.createEmbeddingContext();
+    }
+    else {
+        embeddingModel = null;
+        embeddingCtx = null;
+    }
+    console.log("[local-llm] 模型加载完成", {
+        llm: !!llmModel,
+        embedding: !!embeddingCtx,
+    });
+}
+/** 将 API 可能传来的 content（string | array 如 [{ type: "text", text: "..." }]）规范为 string，避免 node-llama-cpp LlamaText.fromJSON 收到对象抛 "Unknown value type: [object Object]" */
+function contentToString(content) {
+    if (content == null)
+        return "";
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return String(content);
+    return content
+        .filter((part) => part != null && typeof part === "object")
+        .map((part) => (part.type === "text" && typeof part.text === "string" ? part.text : ""))
+        .join("");
+}
+/**
+ * 将 ChatMessage[] 转换为 node-llama-cpp 的 LlamaChatMessage[]。
+ * tool_calls 序列化为 assistant content；tool 结果作为 user content 回传。
+ * 入参 content 可能是 OpenAI 多段格式（content: [{ type: "text", text: "..." }]），必须规范为 string。
+ */
+function toLocalMessages(messages) {
+    return messages.map((m) => {
+        const rawContent = m.content;
+        const content = contentToString(rawContent);
+        if (m.role === "tool") {
+            return { role: "user", content: `[Tool result for ${m.name ?? m.tool_call_id ?? "tool"}]: ${content}` };
+        }
+        if (m.role === "assistant" && m.tool_calls?.length) {
+            const calls = JSON.stringify(m.tool_calls);
+            return { role: "assistant", content: content + `\n[tool_calls]: ${calls}` };
+        }
+        return { role: m.role, content };
+    });
+}
+/**
+ * 将 tools 定义转换为 grammar 约束描述，拼入 system prompt。
+ * node-llama-cpp v3 通过 LlamaGrammar 支持 JSON schema 约束输出，
+ * 这里用 prompt 方式描述工具，让模型以 JSON 格式输出 tool_calls。
+ */
+function buildToolSystemPrompt(tools) {
+    if (!tools.length)
+        return "";
+    const descs = tools.map((t) => {
+        const fn = t.function;
+        return `- ${fn.name}: ${fn.description ?? ""}\n  parameters: ${JSON.stringify(fn.parameters ?? {})}`;
+    }).join("\n");
+    return `\n\nYou have access to the following tools. When you need to call a tool, respond ONLY with a JSON object in this exact format (no other text):\n{"tool_calls":[{"id":"call_<random>","type":"function","function":{"name":"<tool_name>","arguments":"<json_string>"}}]}\n\nAvailable tools:\n${descs}`;
+}
+/** 尝试从模型输出中解析 tool_calls JSON */
+function parseToolCalls(text) {
+    const trimmed = text.trim();
+    // 匹配 {"tool_calls":[...]} 格式
+    const match = trimmed.match(/\{[\s\S]*"tool_calls"[\s\S]*\}/);
+    if (!match)
+        return null;
+    try {
+        const parsed = JSON.parse(match[0]);
+        if (Array.isArray(parsed.tool_calls) && parsed.tool_calls.length > 0) {
+            return parsed.tool_calls;
+        }
+    }
+    catch {
+        // 不是合法 JSON，当普通文本处理
+    }
+    return null;
+}
+/**
+ * 流式 chat completion。
+ * onChunk 每次收到新 token 时调用；结束后返回完整 finish_reason。
+ */
+export async function chatCompletionStream(messages, tools, onChunk, signal) {
+    if (!llmModel)
+        throw new Error("[local-llm] LLM 模型未初始化");
+    const { LlamaChatSession } = await import("node-llama-cpp");
+    // 串行排队
+    const run = async () => {
+        const ctx = await llmModel.createContext({ contextSize: storedContextSize });
+        // 注入历史消息（除最后一条 user 消息）
+        const localMsgs = toLocalMessages(messages);
+        let lastUser = -1;
+        for (let i = localMsgs.length - 1; i >= 0; i--) {
+            if (localMsgs[i].role === "user") {
+                lastUser = i;
+                break;
+            }
+        }
+        const history = lastUser > 0 ? localMsgs.slice(0, lastUser) : [];
+        const userPrompt = lastUser >= 0 ? localMsgs[lastUser].content : "";
+        // 找 system prompt，拼入 tool 描述（system 的 content 也可能是 array，需规范为 string）
+        const systemMsg = messages.find((m) => m.role === "system");
+        const toolSystemPrompt = buildToolSystemPrompt(tools);
+        const systemContent = contentToString(systemMsg?.content) + toolSystemPrompt;
+        // 创建带 systemPrompt 的 session，重建历史
+        const session = new LlamaChatSession({
+            contextSequence: ctx.getSequence(),
+            systemPrompt: systemContent || undefined,
+        });
+        for (const msg of history) {
+            if (msg.role === "user") {
+                await session.prompt(msg.content, { onTextChunk: () => { } });
+            }
+        }
+        let fullText = "";
+        let prevSentLength = 0;
+        let lastSent = ""; // 连续相同 delta 只发一次，缓解回复缓慢时「每个字显示两遍」
+        try {
+            await session.prompt(userPrompt, {
+                onTextChunk: (token) => {
+                    if (signal?.aborted)
+                        return;
+                    const s = typeof token === "string" ? token : (token != null ? String(token) : "");
+                    if (!s)
+                        return;
+                    // node-llama-cpp 在 detokenize(tokens, false, tokenTrail) 时可能返回带上下文的片段（含重复前缀），
+                    // 与 DeepSeek 等仅返回增量不同。只向下游发送增量，避免出现「你好你好！！我是我是...」式重复。
+                    if (s.startsWith(fullText)) {
+                        fullText = s;
+                    }
+                    else {
+                        fullText += s;
+                    }
+                    const toSend = fullText.slice(prevSentLength);
+                    prevSentLength = fullText.length;
+                    if (toSend && toSend !== lastSent) {
+                        lastSent = toSend;
+                        onChunk({ content: toSend });
+                    }
+                },
+                signal,
+            });
+        }
+        catch (e) {
+            // node-llama-cpp 在解析模型输出（如 segment/tool_call）时可能对 LlamaText.fromJSON 传入对象导致 "Unknown value type: [object Object]"
+            const msg = e instanceof Error ? e.message : String(e);
+            const stack = e instanceof Error ? e.stack : undefined;
+            console.error("[local-llm] chatCompletionStream session.prompt error:", msg);
+            if (stack)
+                console.error("[local-llm] stack:", stack);
+            throw e;
+        }
+        // 检查是否是 tool_calls 输出
+        const toolCalls = parseToolCalls(fullText);
+        if (toolCalls) {
+            onChunk({ tool_calls: toolCalls, finish_reason: "tool_calls" });
+        }
+        else {
+            onChunk({ finish_reason: "stop" });
+        }
+        await ctx.dispose();
+    };
+    llmQueue = llmQueue.then(run, run);
+    await llmQueue;
+}
+/**
+ * 非流式 chat completion（内部复用流式实现）。
+ */
+export async function chatCompletion(messages, tools, signal) {
+    let content = "";
+    let toolCalls;
+    let finishReason = "stop";
+    await chatCompletionStream(messages, tools, (chunk) => {
+        if (chunk.content)
+            content += chunk.content;
+        if (chunk.tool_calls)
+            toolCalls = chunk.tool_calls;
+        if (chunk.finish_reason)
+            finishReason = chunk.finish_reason;
+    }, signal);
+    return { content, tool_calls: toolCalls, finish_reason: finishReason };
+}
+/**
+ * 文本 embedding，返回 L2 归一化向量。
+ */
+export async function getEmbedding(text) {
+    if (!embeddingCtx)
+        throw new Error("[local-llm] Embedding 模型未初始化");
+    const result = await embeddingCtx.getEmbeddingFor(text);
+    const vec = Array.from(result.vector);
+    const norm = Math.sqrt(vec.reduce((s, v) => s + v * v, 0)) || 1;
+    return vec.map((v) => v / norm);
+}
+/** 是否至少加载了一个模型（LLM 或 Embedding） */
+export function isReady() {
+    return llmModel !== null || embeddingCtx !== null;
+}
+/** 是否有 LLM，可提供 chat/completions */
+export function isLlmReady() {
+    return llmModel !== null;
+}
+/** 是否有 Embedding，可提供 embeddings */
+export function isEmbeddingReady() {
+    return embeddingCtx !== null;
+}

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

@@ -0,0 +1,27 @@
+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（文件名形式取最后一段 _ 之后）
+ */
+export declare function modelUriBasename(modelUri: string): string;
+/**
+ * 将 modelUri（hf:owner/repo/file.gguf）或文件名转为缓存目录下的文件名。
+ * 与 LocalModelsService.predictFilename 逻辑一致。
+ */
+export declare function modelUriToFilename(modelUri: string): string;
+/**
+ * 在缓存目录中解析出实际存在的模型文件路径。
+ * 先尝试精确文件名，若无则按「以 modelUri 的末尾文件名结尾」匹配（与「已安装的本地模型」逻辑一致）。
+ */
+export declare function resolveModelPathInCache(modelIdOrUri: string, cacheDir?: string): string;
+/**
+ * 检查指定模型（uri 或文件名）是否已存在于本地缓存目录。
+ * 支持精确文件名 或 以末尾 .gguf 文件名结尾的灵活匹配，与「已安装的本地模型」展示一致。
+ */
+export declare function isModelFileInCache(modelIdOrUri: string, cacheDir?: string): boolean;
+/**
+ * 将前端传入的模型标识（hf: URI 或已安装文件名）转为可传给 node-llama-cpp 的路径或 URI。
+ * 若为纯文件名（如 hf_xxx.gguf），则返回缓存目录下的绝对路径；若实际磁盘文件名与配置不一致（如 node-llama-cpp 命名），则解析为真实路径。
+ */
+export declare function toModelPathForStart(uriOrFilename: string, cacheDir?: string): string;

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

@@ -0,0 +1,90 @@
+/**
+ * 本地模型路径解析与文件存在性检查。
+ * 缓存目录：~/.openbot/.cached_models/，与 openbot 配置同目录便于管理。
+ * 与「已安装的本地模型」展示一致：支持精确文件名 或 以末尾 .gguf 文件名结尾的灵活匹配（兼容 node-llama-cpp 不同命名）。
+ */
+import { join } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+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（文件名形式取最后一段 _ 之后）
+ */
+export function modelUriBasename(modelUri) {
+    const s = (modelUri || "").trim();
+    if (!s)
+        return "";
+    const parts = s.replace(/\\/g, "/").split("/");
+    const last = parts[parts.length - 1] || s;
+    // 仅对无 "/" 的文件名形式（如 hf_X_Y_Z.gguf）取最后 _ 之后一段，以匹配 node-llama-cpp 可能生成的短文件名
+    if (!s.includes("/") && last.includes("_") && last.endsWith(".gguf")) {
+        const fromUnderscore = last.slice(last.lastIndexOf("_") + 1);
+        if (fromUnderscore.endsWith(".gguf"))
+            return fromUnderscore;
+    }
+    return last;
+}
+/**
+ * 将 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;
+}
+/**
+ * 在缓存目录中解析出实际存在的模型文件路径。
+ * 先尝试精确文件名，若无则按「以 modelUri 的末尾文件名结尾」匹配（与「已安装的本地模型」逻辑一致）。
+ */
+export function resolveModelPathInCache(modelIdOrUri, cacheDir = LOCAL_LLM_CACHE_DIR) {
+    const filename = modelUriToFilename(modelIdOrUri);
+    if (!filename || !filename.endsWith(".gguf"))
+        return "";
+    const exactPath = join(cacheDir, filename);
+    if (existsSync(exactPath))
+        return exactPath;
+    const suffix = modelUriBasename(modelIdOrUri);
+    if (!suffix)
+        return "";
+    try {
+        const files = readdirSync(cacheDir);
+        const found = files.find((f) => f.endsWith(".gguf") && (f === suffix || f.endsWith(suffix)));
+        return found ? join(cacheDir, found) : "";
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * 检查指定模型（uri 或文件名）是否已存在于本地缓存目录。
+ * 支持精确文件名 或 以末尾 .gguf 文件名结尾的灵活匹配，与「已安装的本地模型」展示一致。
+ */
+export function isModelFileInCache(modelIdOrUri, cacheDir = LOCAL_LLM_CACHE_DIR) {
+    return resolveModelPathInCache(modelIdOrUri, cacheDir) !== "";
+}
+/**
+ * 将前端传入的模型标识（hf: URI 或已安装文件名）转为可传给 node-llama-cpp 的路径或 URI。
+ * 若为纯文件名（如 hf_xxx.gguf），则返回缓存目录下的绝对路径；若实际磁盘文件名与配置不一致（如 node-llama-cpp 命名），则解析为真实路径。
+ */
+export function toModelPathForStart(uriOrFilename, cacheDir = LOCAL_LLM_CACHE_DIR) {
+    const s = (uriOrFilename || "").trim();
+    if (!s)
+        return "";
+    if (s.startsWith("hf:"))
+        return s;
+    const resolved = resolveModelPathInCache(s, cacheDir);
+    if (resolved)
+        return resolved;
+    const filename = modelUriToFilename(s);
+    return filename ? join(cacheDir, filename) : s;
+}

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,234 @@
+/**
+ * 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, 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) {
+    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 (!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");
+    }
+    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 (!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");
+    }
+    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) {
+    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) => {
+        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/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;