@next-open-ai/openclawx 0.8.36 → 0.8.48

package/dist/core/extensions/load.js

@@ -0,0 +1,101 @@
+/**
+ * 从 ~/.openbot/plugins 目录加载通过 openbot extension install 安装的 npm 包，
+ * 将每个包的默认导出规范为 ExtensionFactory 并返回，供 AgentManager 注入到 DefaultResourceLoader.extensionFactories。
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { getOpenbotPluginsDir } from "../agent/agent-dir.js";
+let cachedFactories = null;
+/**
+ * 从插件目录的 package.json 读取 dependencies（及 optionalDependencies）的包名列表。
+ * 仅返回在 node_modules 中实际存在的包名。
+ */
+function getInstalledPluginNames(pluginsDir) {
+    const pkgPath = join(pluginsDir, "package.json");
+    if (!existsSync(pkgPath))
+        return [];
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+    const deps = {
+        ...pkg.dependencies,
+        ...pkg.optionalDependencies,
+    };
+    const names = Object.keys(deps || {});
+    return names.filter((name) => {
+        const dir = join(pluginsDir, "node_modules", name);
+        return existsSync(dir);
+    });
+}
+/**
+ * 将包默认导出规范为 ExtensionFactory：(pi) => void。
+ * 插件可导出 (pi) => void 或 () => (pi) => void（工厂），此处统一为 (pi) => void。
+ */
+function toExtensionFactory(fn) {
+    if (typeof fn !== "function")
+        return null;
+    if (fn.length === 1)
+        return fn; // (pi) => void
+    if (fn.length === 0) {
+        const result = fn();
+        if (typeof result === "function")
+            return result; // () => (pi) => void
+    }
+    return null;
+}
+/**
+ * 加载单个插件包，返回 ExtensionFactory 或 null（失败时打日志并返回 null）。
+ * 使用 require(pkgName) 从 plugins 目录的 node_modules 解析，以便插件自身依赖正确解析。
+ */
+function loadOnePlugin(pluginsDir, pkgName) {
+    const require = createRequire(join(pluginsDir, "package.json"));
+    let mod;
+    try {
+        mod = require(pkgName);
+    }
+    catch (err) {
+        console.warn(`[extensions] Failed to load plugin "${pkgName}":`, err);
+        return null;
+    }
+    const def = mod && typeof mod === "object" && "default" in mod ? mod.default : mod;
+    const factory = toExtensionFactory(def);
+    if (!factory) {
+        console.warn(`[extensions] Plugin "${pkgName}" default export is not a function; skipped.`);
+        return null;
+    }
+    return factory;
+}
+/**
+ * 扫描 ~/.openbot/plugins，加载所有已安装的扩展包，返回 ExtensionFactory 数组。
+ * 进程内缓存结果；若需重载可调用 clearExtensionFactoriesCache()。
+ */
+export function loadExtensionFactories() {
+    if (cachedFactories !== null)
+        return cachedFactories;
+    const pluginsDir = getOpenbotPluginsDir();
+    if (!existsSync(pluginsDir)) {
+        cachedFactories = [];
+        return cachedFactories;
+    }
+    const names = getInstalledPluginNames(pluginsDir);
+    const factories = [];
+    for (const name of names) {
+        const factory = loadOnePlugin(pluginsDir, name);
+        if (factory)
+            factories.push(factory);
+    }
+    cachedFactories = factories;
+    return factories;
+}
+/**
+ * 清除扩展 factory 缓存，下次 loadExtensionFactories() 时会重新扫描并加载。
+ * 用于安装/卸载扩展后希望不重启即生效的场景（若调用方在适当时机调用）。
+ */
+export function clearExtensionFactoriesCache() {
+    cachedFactories = null;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * local-llm-server 入口。
+ *
+ * 两种运行模式：
+ * 1. 子进程模式（--child）：直接加载模型并启动 HTTP 服务，由主进程 fork 调用。
+ * 2. 主进程模式（默认导出）：fork 子进程，管理其生命周期，提供 baseUrl 给调用方。
+ *
+ * 主进程通过 startLocalLlmServer() 启动，返回 { baseUrl, stop }。
+ * 子进程就绪后通过 IPC 发送 { type: "ready" } 通知主进程。
+ */
+export interface LocalLlmServerOptions {
+    port?: number;
+    llmModelPath?: string;
+    embeddingModelPath?: string;
+    /** 上下文窗口 token 数，默认 32768（32K），需能容纳 system + tools + 对话 */
+    contextSize?: number;
+    /** 等待子进程就绪的超时毫秒数，默认 300000（5 分钟，冷启/大模型加载可能较慢） */
+    readyTimeoutMs?: number;
+}
+export interface LocalLlmServerHandle {
+    baseUrl: string;
+    stop: () => void;
+}
+/**
+ * 停止本地 LLM 子进程服务（若正在运行）。用于切换模型前先停止再启动。
+ */
+export declare function stopLocalLlmServer(): void;
+/**
+ * 启动本地 LLM 子进程服务。
+ * 已启动时直接返回已有 handle（单例）。需先 stop 再传新参数重启。
+ */
+export declare function startLocalLlmServer(opts?: LocalLlmServerOptions): Promise<LocalLlmServerHandle>;

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

@@ -0,0 +1,126 @@
+/**
+ * local-llm-server 入口。
+ *
+ * 两种运行模式：
+ * 1. 子进程模式（--child）：直接加载模型并启动 HTTP 服务，由主进程 fork 调用。
+ * 2. 主进程模式（默认导出）：fork 子进程，管理其生命周期，提供 baseUrl 给调用方。
+ *
+ * 主进程通过 startLocalLlmServer() 启动，返回 { baseUrl, stop }。
+ * 子进程就绪后通过 IPC 发送 { type: "ready" } 通知主进程。
+ */
+import { fileURLToPath } from "node:url";
+// ─── 子进程模式 ───────────────────────────────────────────────────────────────
+async function runChildProcess() {
+    const port = parseInt(process.env.LOCAL_LLM_PORT ?? "11435", 10);
+    const llmModelPath = process.env.LOCAL_LLM_MODEL ?? "hf:Qwen/Qwen3-4B-GGUF/Qwen3-4B-Q4_K_M.gguf";
+    const embModelPath = process.env.LOCAL_EMB_MODEL ?? "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf";
+    const contextSize = process.env.LOCAL_LLM_CONTEXT_SIZE != null ? parseInt(process.env.LOCAL_LLM_CONTEXT_SIZE, 10) : undefined;
+    const { initModels } = await import("./llm-context.js");
+    const { createOpenAICompatServer } = await import("./server.js");
+    try {
+        await initModels({ llmModelPath, embeddingModelPath: embModelPath, contextSize: contextSize ?? 32768 });
+        await createOpenAICompatServer(port);
+        // 通知主进程已就绪
+        if (process.send) {
+            process.send({ type: "ready", port });
+        }
+    }
+    catch (e) {
+        console.error("[local-llm] 子进程启动失败:", e);
+        if (process.send) {
+            process.send({ type: "error", message: String(e) });
+        }
+        process.exit(1);
+    }
+}
+let serverHandle = null;
+/**
+ * 停止本地 LLM 子进程服务（若正在运行）。用于切换模型前先停止再启动。
+ */
+export function stopLocalLlmServer() {
+    if (serverHandle) {
+        serverHandle.stop();
+        serverHandle = null;
+    }
+}
+/**
+ * 启动本地 LLM 子进程服务。
+ * 已启动时直接返回已有 handle（单例）。需先 stop 再传新参数重启。
+ */
+export async function startLocalLlmServer(opts = {}) {
+    if (serverHandle)
+        return serverHandle;
+    const { fork } = await import("node:child_process");
+    const port = opts.port ?? 11435;
+    const readyTimeoutMs = opts.readyTimeoutMs ?? 300_000;
+    const env = {
+        ...process.env,
+        LOCAL_LLM_PORT: String(port),
+        LOCAL_LLM_CHILD: "1",
+    };
+    if (opts.llmModelPath)
+        env.LOCAL_LLM_MODEL = opts.llmModelPath;
+    if (opts.embeddingModelPath)
+        env.LOCAL_EMB_MODEL = opts.embeddingModelPath;
+    if (opts.contextSize != null)
+        env.LOCAL_LLM_CONTEXT_SIZE = String(opts.contextSize);
+    const childPath = fileURLToPath(import.meta.url);
+    const child = fork(childPath, ["--child"], {
+        env,
+        stdio: ["ignore", "inherit", "inherit", "ipc"],
+        execArgv: [],
+    });
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`[local-llm] 子进程启动超时（${readyTimeoutMs}ms）`));
+        }, readyTimeoutMs);
+        child.on("message", (msg) => {
+            if (msg?.type === "ready") {
+                clearTimeout(timer);
+                resolve();
+            }
+            else if (msg?.type === "error") {
+                clearTimeout(timer);
+                reject(new Error(`[local-llm] 子进程错误: ${msg.message}`));
+            }
+        });
+        child.on("exit", (code) => {
+            clearTimeout(timer);
+            if (code !== 0)
+                reject(new Error(`[local-llm] 子进程意外退出，code=${code}`));
+        });
+        child.on("error", (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+    // 主进程退出时清理子进程
+    const cleanup = () => { try {
+        child.kill();
+    }
+    catch { /* ignore */ } };
+    process.on("exit", cleanup);
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    serverHandle = {
+        baseUrl: `http://127.0.0.1:${port}/v1`,
+        stop: () => {
+            serverHandle = null;
+            try {
+                child.kill();
+            }
+            catch { /* ignore */ }
+        },
+    };
+    console.log(`[local-llm] 本地服务就绪: ${serverHandle.baseUrl}`);
+    return serverHandle;
+}
+// ─── 入口判断 ─────────────────────────────────────────────────────────────────
+// 子进程模式：被 fork 时带 --child 参数或设置了 LOCAL_LLM_CHILD 环境变量
+if (process.argv.includes("--child") || process.env.LOCAL_LLM_CHILD === "1") {
+    runChildProcess().catch((e) => {
+        console.error("[local-llm] 致命错误:", e);
+        process.exit(1);
+    });
+}

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

@@ -0,0 +1,60 @@
+export interface LlmContextOptions {
+    /** LLM 推理模型路径或 hf: URI */
+    llmModelPath: string;
+    /** Embedding 模型路径或 hf: URI */
+    embeddingModelPath: string;
+    /** GPU layers，-1 表示全部卸载到 GPU（Metal），0 表示纯 CPU */
+    gpuLayers?: number;
+    /** 上下文窗口大小，默认 32768（32K） */
+    contextSize?: number;
+}
+export interface ChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | null;
+    /** tool_calls（assistant 发起工具调用时） */
+    tool_calls?: ToolCall[];
+    /** tool_call_id（role=tool 时，对应哪个 tool_call） */
+    tool_call_id?: string;
+    /** tool 消息的函数名 */
+    name?: string;
+}
+export interface ToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+}
+export interface ToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ChatCompletionChunk {
+    content?: string;
+    tool_calls?: ToolCall[];
+    finish_reason?: "stop" | "tool_calls" | "length";
+}
+export declare function initModels(opts: LlmContextOptions): Promise<void>;
+/**
+ * 流式 chat completion。
+ * onChunk 每次收到新 token 时调用；结束后返回完整 finish_reason。
+ */
+export declare function chatCompletionStream(messages: ChatMessage[], tools: ToolDefinition[], onChunk: (chunk: ChatCompletionChunk) => void, signal?: AbortSignal): Promise<void>;
+/**
+ * 非流式 chat completion（内部复用流式实现）。
+ */
+export declare function chatCompletion(messages: ChatMessage[], tools: ToolDefinition[], signal?: AbortSignal): Promise<{
+    content: string;
+    tool_calls?: ToolCall[];
+    finish_reason: string;
+}>;
+/**
+ * 文本 embedding，返回 L2 归一化向量。
+ */
+export declare function getEmbedding(text: string): Promise<number[]>;
+export declare function isReady(): boolean;

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

@@ -0,0 +1,221 @@
+/**
+ * node-llama-cpp 模型实例管理。
+ * 同时持有一个 LLM chat 模型和一个 embedding 模型，各自独立上下文。
+ * 推理和 embedding 请求串行处理（同一模型不支持并发），两个模型之间可并发。
+ */
+import { join } from "node:path";
+import { homedir } from "node:os";
+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 cacheDir = join(homedir(), ".cache", "llama");
+    const instance = await getLlamaInstance(opts.gpuLayers);
+    console.log("[local-llm] 加载 LLM 模型:", opts.llmModelPath);
+    const llmPath = await resolveModelFile(opts.llmModelPath, cacheDir);
+    llmModel = await instance.loadModel({ modelPath: llmPath });
+    console.log("[local-llm] 加载 Embedding 模型:", opts.embeddingModelPath);
+    const embPath = await resolveModelFile(opts.embeddingModelPath, cacheDir);
+    embeddingModel = await instance.loadModel({ modelPath: embPath });
+    embeddingCtx = await embeddingModel.createEmbeddingContext();
+    console.log("[local-llm] 模型加载完成");
+}
+/** 将 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);
+}
+export function isReady() {
+    return llmModel !== null && embeddingCtx !== null;
+}

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

@@ -0,0 +1,20 @@
+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
+ */
+export declare function modelUriBasename(modelUri: string): string;
+/**
+ * 将 modelUri（hf:owner/repo/file.gguf）或文件名转为缓存目录下的文件名。
+ * 与 LocalModelsService.predictFilename 逻辑一致。
+ */
+export declare function modelUriToFilename(modelUri: string): string;
+/**
+ * 检查指定模型（uri 或文件名）是否已存在于本地缓存目录。
+ */
+export declare function isModelFileInCache(modelIdOrUri: string, cacheDir?: string): boolean;
+/**
+ * 将前端传入的模型标识（hf: URI 或已安装文件名）转为可传给 node-llama-cpp 的路径或 URI。
+ * 若为纯文件名（如 hf_xxx.gguf），则返回缓存目录下的绝对路径。
+ */
+export declare function toModelPathForStart(uriOrFilename: string, cacheDir?: string): string;

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>;