@next-open-ai/openclawx 0.8.16 → 0.8.22

package/dist/core/agent/proxy/adapters/opencode-free-models.d.ts

@@ -0,0 +1,20 @@
+/**
+ * OpenCode 官方免费/推荐模型列表（OpenCode Zen 等），供配置界面下拉选择与本地/远程模式默认模型使用。
+ *
+ * 维护说明：
+ * - 唯一维护点：本文件。前端通过 GET /config/opencode-free-models 拉取，配置界面下拉与默认模型均来源于此。
+ * - 新增/下架模型：在 OPENCODE_FREE_MODELS 中增删或修改项；id 格式为 opencode/<model-id>，与 OpenCode Zen 文档一致。
+ * - 详见 https://opencode.ai/docs/zen
+ */
+export interface OpenCodeFreeModelOption {
+    /** 配置用 ID，如 opencode/minimax-m2.5-free */
+    id: string;
+    /** 界面展示名称 */
+    label: string;
+    /** 是否免费（Zen 免费额度内） */
+    free?: boolean;
+}
+/** OpenCode Zen 等提供的免费/推荐模型，按展示顺序 */
+export declare const OPENCODE_FREE_MODELS: OpenCodeFreeModelOption[];
+/** 仅免费项，用于界面“免费模型”分组 */
+export declare const OPENCODE_FREE_ONLY: OpenCodeFreeModelOption[];

package/dist/core/agent/proxy/adapters/opencode-free-models.js

@@ -0,0 +1,14 @@
+/** OpenCode Zen 等提供的免费/推荐模型，按展示顺序 */
+export const OPENCODE_FREE_MODELS = [
+    { id: "opencode/minimax-m2.5-free", label: "MiniMax M2.5 Free", free: true },
+    { id: "opencode/glm-5-free", label: "GLM 5 Free", free: true },
+    { id: "opencode/kimi-k2.5-free", label: "Kimi K2.5 Free", free: true },
+    { id: "opencode/big-pickle", label: "Big Pickle", free: true },
+    { id: "opencode/gpt-5-nano", label: "GPT 5 Nano", free: true },
+    { id: "opencode/minimax-m2.5", label: "MiniMax M2.5" },
+    { id: "opencode/glm-5", label: "GLM 5" },
+    { id: "opencode/gemini-3-flash", label: "Gemini 3 Flash" },
+    { id: "opencode/claude-haiku-4-5", label: "Claude Haiku 4.5" },
+];
+/** 仅免费项，用于界面“免费模型”分组 */
+export const OPENCODE_FREE_ONLY = OPENCODE_FREE_MODELS.filter((m) => m.free);

package/dist/core/agent/proxy/adapters/opencode-local-runner.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 确保本机 OpenCode 服务在指定端口运行，并使用给定默认模型与工作目录。
+ * 若已存在同端口、同工作目录进程则直接返回；否则启动 opencode serve 并轮询健康检查。
+ */
+export declare function ensureLocalOpencodeRunning(port: number, model?: string, workingDirectory?: string): Promise<void>;

package/dist/core/agent/proxy/adapters/opencode-local-runner.js

@@ -0,0 +1,86 @@
+/**
+ * 本地 OpenCode 进程：在 mode=local 且配置了默认模型时，由本应用按需启动 opencode serve，
+ * 并通过 OPENCODE_CONFIG_CONTENT 注入默认模型与端口；可选设置工作目录（cwd）。
+ */
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { resolve } from "path";
+const HEALTH_PATH = "/global/health";
+const POLL_INTERVAL_MS = 500;
+const STARTUP_TIMEOUT_MS = 30_000;
+let running = null;
+function isPortHealthy(port) {
+    const url = `http://127.0.0.1:${port}${HEALTH_PATH}`;
+    return fetch(url, { signal: AbortSignal.timeout(3000) })
+        .then((r) => r.ok)
+        .catch(() => false);
+}
+/**
+ * 确保本机 OpenCode 服务在指定端口运行，并使用给定默认模型与工作目录。
+ * 若已存在同端口、同工作目录进程则直接返回；否则启动 opencode serve 并轮询健康检查。
+ */
+export async function ensureLocalOpencodeRunning(port, model, workingDirectory) {
+    const cwd = workingDirectory?.trim() ? resolve(workingDirectory.trim()) : undefined;
+    if (running) {
+        if (running.port === port &&
+            (running.model === model || (!model && !running.model)) &&
+            (running.cwd === cwd || (!cwd && !running.cwd))) {
+            return;
+        }
+        if (running.port === port)
+            return;
+    }
+    const alreadyUp = await isPortHealthy(port);
+    if (alreadyUp) {
+        return;
+    }
+    const config = { server: { port } };
+    if (model && model.trim())
+        config.model = model.trim();
+    const env = {
+        ...process.env,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
+    };
+    const child = spawn("opencode", ["serve", "--port", String(port), "--hostname", "127.0.0.1"], {
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        ...(cwd && { cwd }),
+    });
+    const stdout = createInterface({ input: child.stdout });
+    const stderr = createInterface({ input: child.stderr });
+    stdout.on("line", (line) => {
+        if (process.env.DEBUG_OPENCODE)
+            console.log("[opencode]", line);
+    });
+    stderr.on("line", (line) => {
+        if (process.env.DEBUG_OPENCODE)
+            console.warn("[opencode stderr]", line);
+    });
+    child.on("error", (err) => {
+        if (running?.process === child)
+            running = null;
+        console.warn("[OpenCode local runner] spawn error:", err.message);
+    });
+    child.on("exit", (code, signal) => {
+        if (running?.process === child)
+            running = null;
+        if (code != null && code !== 0 && process.env.DEBUG_OPENCODE) {
+            console.warn("[OpenCode local runner] exit", { code, signal });
+        }
+    });
+    running = { port, model, cwd, process: child };
+    const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+        if (await isPortHealthy(port))
+            return;
+        if (child.exitCode != null) {
+            running = null;
+            throw new Error(`OpenCode 本地进程已退出（code=${child.exitCode}）。请确认已安装 opencode CLI 且可执行 opencode serve。`);
+        }
+    }
+    running = null;
+    child.kill("SIGTERM");
+    throw new Error(`OpenCode 本地服务在 ${STARTUP_TIMEOUT_MS / 1000} 秒内未就绪（端口 ${port}）。请检查 opencode 是否已安装并可用。`);
+}

package/dist/core/agent/proxy/index.js

@@ -1,14 +1,16 @@
 /**
  * AgentProxy 模块：统一执行入口与适配器注册。
  * 使用前需确保已通过 registerAgentProxyAdapter 注册各类型适配器；
- * 本模块在加载时注册内置的 local、coze、openclawx 适配器。
+ * 本模块在加载时注册内置的 local、coze、openclawx、opencode 适配器。
  */
 import { registerAgentProxyAdapter } from "./registry.js";
 import { localAdapter } from "./adapters/local-adapter.js";
 import { cozeAdapter } from "./adapters/coze-adapter.js";
 import { openclawxAdapter } from "./adapters/openclawx-adapter.js";
+import { opencodeAdapter } from "./adapters/opencode-adapter.js";
 registerAgentProxyAdapter(localAdapter);
 registerAgentProxyAdapter(cozeAdapter);
 registerAgentProxyAdapter(openclawxAdapter);
+registerAgentProxyAdapter(opencodeAdapter);
 export { runForChannelStream, runForChannelCollect } from "./run-for-channel.js";
 export { registerAgentProxyAdapter, getAgentProxyAdapter, listAgentProxyAdapterTypes } from "./registry.js";

package/dist/core/agent/proxy/run-for-channel.js

@@ -14,7 +14,7 @@ export async function runForChannelStream(options, callbacks) {
     if (!adapter) {
         throw new Error(`No AgentProxy adapter registered for type: "${runnerType}"`);
     }
-    await adapter.runStream({ ...options, agentId }, config, callbacks);
+    await adapter.runStream({ ...options, agentId, signal: options.signal }, config, callbacks);
 }
 export async function runForChannelCollect(options) {
     const agentId = options.agentId ?? "default";

package/dist/core/agent/proxy/types.d.ts

@@ -6,6 +6,8 @@ export interface RunAgentForChannelOptions {
     sessionId: string;
     message: string;
     agentId: string;
+    /** When aborted (e.g. user clicked stop), adapters should stop the run. */
+    signal?: AbortSignal;
 }
 export interface RunAgentStreamCallbacks {
     onChunk(delta: string): void;

package/dist/core/agent/run.js

@@ -59,7 +59,7 @@ export async function run(options) {
     });
     // Send prompt and wait for completion
     await session.prompt(userPrompt);
-    manager.deleteSession(sessionId + "::" + "default");
+    await manager.deleteSession(sessionId + "::" + "default");
     result.assistantContent = assistantContent.trim();
     return result;
 }

package/dist/core/config/desktop-config.d.ts

@@ -1,5 +1,25 @@
 import { type ProviderSupport, type ProviderSupportEntry, type ProviderSupportModel, type ModelSupportType } from "./provider-support-default.js";
 export type { ProviderSupport, ProviderSupportEntry, ProviderSupportModel, ModelSupportType };
+/** 知识库 RAG 配置（config.json.rag） */
+export interface RagConfig {
+    /** 向量模型来源：local=本地 GGUF，online=在线 OpenAPI */
+    embeddingSource?: "local" | "online";
+    /** 在线时：从已配置模型中选的 embedding 项，对应 modelItemCode */
+    embeddingModelItemCode?: string;
+    /** 本地时：GGUF 模型路径；优先用 node-llama-cpp */
+    localModelPath?: string;
+    /** 兼容旧配置：在线时的 provider+model */
+    embeddingProvider?: string;
+    embeddingModel?: string;
+    /** 向量库类型：local=本地 Vectra，qdrant=远程 Qdrant */
+    vectorStore?: "local" | "qdrant";
+    /** 远程 Qdrant 配置 */
+    qdrant?: {
+        url: string;
+        apiKey?: string;
+        collection?: string;
+    };
+}
 /** RAG 长记忆：使用远端 embedding 模型；未配置时基于 RAG 的长记忆空转 */
 export interface RagEmbeddingConfig {
     provider: string;
@@ -26,11 +46,16 @@ export interface ChannelsConfig {
         botToken?: string;
         defaultAgentId?: string;
     };
+    wechat?: {
+        enabled?: boolean;
+        puppet?: string;
+        defaultAgentId?: string;
+    };
 }
 /** MCP 服务器配置（与 core/mcp 类型一致，避免 core/config 依赖 core/mcp 实现） */
 export type DesktopMcpServerConfig = import("../mcp/index.js").McpServerConfig;
-/** Agent 执行器类型：local=本机 pi-coding-agent，coze/openclawx=远程代理 */
-export type AgentRunnerType = "local" | "coze" | "openclawx";
+/** Agent 执行器类型：local=本机 pi-coding-agent，coze/openclawx/opencode=远程代理 */
+export type AgentRunnerType = "local" | "coze" | "openclawx" | "opencode";
 /** Coze 站点：国内站 api.coze.cn / 国际站 api.coze.com，凭证不通用 */
 export type CozeRegion = "cn" | "com";
 /** 某站点的 Bot 凭证（国内/国际各自独立） */
@@ -61,6 +86,34 @@ export interface AgentOpenClawXConfig {
     baseUrl: string;
     apiKey?: string;
 }
+/** OpenCode 启动模式：local=由本应用按需启动本机服务；remote=连接已运行的远端服务 */
+export type OpenCodeServerMode = "local" | "remote";
+/** OpenCode 代理配置：仅对接 [OpenCode 官方 Server API](https://opencode.ai/docs/server)（Session/Message + HTTP Basic） */
+export interface AgentOpenCodeConfig {
+    /** 启动模式：local=本应用控制启动并可选设置默认模型；remote=连接已有服务 */
+    mode?: OpenCodeServerMode;
+    /** 地址（仅 remote 必填；local 时固定为 127.0.0.1） */
+    address?: string;
+    /** 端口（opencode serve 默认 4096） */
+    port: number;
+    /** HTTP Basic 认证密码（见 OPENCODE_SERVER_PASSWORD） */
+    password?: string;
+    /** HTTP Basic 认证用户名（默认 opencode） */
+    username?: string;
+    /** @deprecated 仅保留向后兼容，产品仅支持官方 Server API */
+    apiStyle?: "server" | "openai";
+    /** @deprecated 仅保留向后兼容 */
+    path?: string;
+    /** @deprecated 仅保留向后兼容 */
+    streamPath?: string;
+    /**
+     * 默认模型：local 时由本应用启动服务时写入 OpenCode 配置；remote 时作为请求 model 发送。
+     * 不填则 local 使用本机已有 OpenCode 配置、remote 使用服务端默认。
+     */
+    model?: string;
+    /** 工作目录（仅 local 模式生效）：启动 opencode serve 时使用的 cwd，留空则使用进程当前目录 */
+    workingDirectory?: string;
+}
 /**
  * 同步读取桌面全局配置中的 maxAgentSessions 等。
  * Gateway 进程内使用，用于会话上限等。
@@ -70,8 +123,16 @@ export declare function getDesktopConfig(): {
 };
 /** 同步读取通道配置（Gateway 启动时用） */
 export declare function getChannelsConfigSync(): ChannelsConfig;
-/** 同步读取 RAG embedding 配置；未配置或无效时返回 null，长记忆将空转 */
+/** 同步读取 RAG embedding 配置；embeddingSource 为 local 或未配置在线模型时返回 null，长记忆将空转 */
 export declare function getRagEmbeddingConfigSync(): RagEmbeddingConfig | null;
+/** 同步读取 RAG 本地 GGUF 模型路径；embeddingSource 非 local 或未填时返回 null，调用方使用默认模型（如 embeddinggemma）。 */
+export declare function getRagLocalModelPathSync(): string | null;
+/** 同步读取 RAG 向量库配置；vectorStore 为 qdrant 且 url 有效时返回，否则为 null（使用本地向量库）。 */
+export declare function getRagQdrantConfigSync(): {
+    url: string;
+    apiKey?: string;
+    collection?: string;
+} | null;
 export interface DesktopAgentConfig {
     provider: string;
     model: string;
@@ -88,6 +149,10 @@ export interface DesktopAgentConfig {
     coze?: CozeResolvedConfig;
     /** OpenClawX 代理配置 */
     openclawx?: AgentOpenClawXConfig;
+    /** OpenCode 代理配置 */
+    opencode?: AgentOpenCodeConfig;
+    /** 是否使用经验（长记忆）；默认 true */
+    useLongMemory?: boolean;
 }
 /**
  * 从 config.json 读取缺省智能体 id（defaultAgentId）。
@@ -131,6 +196,9 @@ export declare function getDesktopConfigList(): Promise<DesktopConfigList>;
  * 确保桌面目录下存在 provider-support.json（不存在则写入默认内容）。
  * 供配置供应商时作备选下拉列表项。
  */
+/**
+ * 确保桌面目录下存在 provider-support.json，并与预装的最新供应商列表合并。
+ */
 export declare function ensureProviderSupportFile(): Promise<void>;
 /**
  * CLI / Gateway 运行时调用，确保 config.json、provider-support.json、agents.json 均完成初始化。

package/dist/core/config/desktop-config.js

@@ -3,7 +3,7 @@
  * 供 CLI、WebSocket Gateway 等读取与写入，与 Nest Desktop Backend 使用的 config.json / agents.json 一致。
  * provider-support.json 提供流行 provider 及模型目录，供配置时下拉备选；配置完成后可同步到 agent 目录 models.json 供 pi 使用。
  */
-import { readFile, writeFile } from "fs/promises";
+import { readFile, writeFile, cp, mkdir } from "fs/promises";
 import { readFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
@@ -13,6 +13,10 @@ function getDesktopDir() {
     const home = process.env.HOME || process.env.USERPROFILE || homedir();
     return join(home, ".openbot", "desktop");
 }
+/** 获取预装资源目录（打包后在 Resources/presets，dev 时在仓库根 presets） */
+function getPresetsDir() {
+    return process.env.OPENBOT_PRESETS_DIR || join(process.cwd(), "presets");
+}
 const DEFAULT_AGENT_ID = "default";
 const DEFAULT_MAX_AGENT_SESSIONS = 5;
 /** 同步读取桌面全局配置（Gateway 等需要同步读的场景） */
@@ -57,7 +61,7 @@ export function getChannelsConfigSync() {
         return {};
     }
 }
-/** 同步读取 RAG embedding 配置；未配置或无效时返回 null，长记忆将空转 */
+/** 同步读取 RAG embedding 配置；embeddingSource 为 local 或未配置在线模型时返回 null，长记忆将空转 */
 export function getRagEmbeddingConfigSync() {
     try {
         const configPath = getConfigPath();
@@ -65,8 +69,27 @@ export function getRagEmbeddingConfigSync() {
             return null;
         const content = readFileSync(configPath, "utf-8");
         const data = JSON.parse(content);
-        const provider = data.rag?.embeddingProvider?.trim();
-        const modelId = data.rag?.embeddingModel?.trim();
+        const rag = data.rag;
+        if (rag?.embeddingSource === "local")
+            return null;
+        let provider;
+        let modelId;
+        if (rag?.embeddingModelItemCode && Array.isArray(data.configuredModels)) {
+            const code = rag.embeddingModelItemCode;
+            const item = data.configuredModels.find((m) => {
+                if (m.type !== "embedding")
+                    return false;
+                return m.modelItemCode === code || (m.provider && m.modelId && `${m.provider}:${m.modelId}` === code);
+            });
+            if (item && item.provider) {
+                provider = item.provider;
+                modelId = item.modelId;
+            }
+        }
+        if (!provider || !modelId) {
+            provider = rag?.embeddingProvider?.trim();
+            modelId = rag?.embeddingModel?.trim();
+        }
         if (!provider || !modelId)
             return null;
         const prov = data.providers?.[provider];
@@ -86,6 +109,43 @@ export function getRagEmbeddingConfigSync() {
         return null;
     }
 }
+/** 同步读取 RAG 本地 GGUF 模型路径；embeddingSource 非 local 或未填时返回 null，调用方使用默认模型（如 embeddinggemma）。 */
+export function getRagLocalModelPathSync() {
+    try {
+        const configPath = getConfigPath();
+        if (!existsSync(configPath))
+            return null;
+        const content = readFileSync(configPath, "utf-8");
+        const data = JSON.parse(content);
+        if (data.rag?.embeddingSource !== "local")
+            return null;
+        const modelPath = data.rag?.localModelPath?.trim();
+        return modelPath || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 同步读取 RAG 向量库配置；vectorStore 为 qdrant 且 url 有效时返回，否则为 null（使用本地向量库）。 */
+export function getRagQdrantConfigSync() {
+    try {
+        const configPath = getConfigPath();
+        if (!existsSync(configPath))
+            return null;
+        const content = readFileSync(configPath, "utf-8");
+        const data = JSON.parse(content);
+        if (data.rag?.vectorStore !== "qdrant" || !data.rag?.qdrant?.url?.trim())
+            return null;
+        return {
+            url: data.rag.qdrant.url.trim().replace(/\/$/, ""),
+            apiKey: data.rag.qdrant.apiKey?.trim(),
+            collection: data.rag.qdrant.collection?.trim(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 const EMBEDDING_DEFAULT_BASE_URL = {
     openai: "https://api.openai.com/v1",
     "openai-custom": "",
@@ -161,6 +221,7 @@ export async function loadDesktopAgentConfig(agentId) {
     let workspaceName = resolvedAgentId;
     let mcpServers;
     let systemPrompt;
+    let useLongMemory = true;
     if (existsSync(agentsPath)) {
         try {
             const raw = await readFile(agentsPath, "utf-8");
@@ -178,6 +239,8 @@ export async function loadDesktopAgentConfig(agentId) {
                 if (agent.systemPrompt && typeof agent.systemPrompt === "string") {
                     systemPrompt = agent.systemPrompt.trim();
                 }
+                if (agent.useLongMemory !== undefined)
+                    useLongMemory = !!agent.useLongMemory;
                 if (agent.modelItemCode && Array.isArray(config.configuredModels)) {
                     const configured = config.configuredModels.find((m) => m.modelItemCode === agent.modelItemCode);
                     if (configured) {
@@ -210,6 +273,7 @@ export async function loadDesktopAgentConfig(agentId) {
     let runnerType = "local";
     let coze;
     let openclawx;
+    let opencode;
     if (existsSync(agentsPath)) {
         try {
             const rawAgents = await readFile(agentsPath, "utf-8");
@@ -217,7 +281,9 @@ export async function loadDesktopAgentConfig(agentId) {
             const agentsList = Array.isArray(dataAgents.agents) ? dataAgents.agents : [];
             const agentRow = agentsList.find((a) => a.id === resolvedAgentId);
             if (agentRow) {
-                if (agentRow.runnerType === "coze" || agentRow.runnerType === "openclawx") {
+                if (agentRow.runnerType === "coze" ||
+                    agentRow.runnerType === "openclawx" ||
+                    agentRow.runnerType === "opencode") {
                     runnerType = agentRow.runnerType;
                 }
                 if (agentRow.coze) {
@@ -254,6 +320,37 @@ export async function loadDesktopAgentConfig(agentId) {
                         apiKey: agentRow.openclawx.apiKey?.trim(),
                     };
                 }
+                if (agentRow.opencode?.port != null) {
+                    const raw = agentRow.opencode;
+                    const port = Number(raw.port);
+                    if (!Number.isNaN(port) && port > 0) {
+                        const mode = raw.mode === "local" || raw.mode === "remote"
+                            ? raw.mode
+                            : raw.address != null && String(raw.address).trim()
+                                ? "remote"
+                                : "local";
+                        const address = mode === "remote" && raw.address != null
+                            ? String(raw.address).trim()
+                            : "127.0.0.1";
+                        if (mode === "local" || address) {
+                            const apiStyle = raw.apiStyle === "openai" ? "openai" : "server";
+                            opencode = {
+                                mode,
+                                address: mode === "remote" ? address : "127.0.0.1",
+                                port,
+                                password: raw.password != null ? String(raw.password).trim() : undefined,
+                                username: raw.username != null ? String(raw.username).trim() || undefined : undefined,
+                                apiStyle,
+                                path: raw.path != null ? String(raw.path).trim() || undefined : undefined,
+                                streamPath: raw.streamPath != null
+                                    ? String(raw.streamPath).trim() || undefined
+                                    : undefined,
+                                model: raw.model != null ? String(raw.model).trim() || undefined : undefined,
+                                workingDirectory: raw.workingDirectory != null ? String(raw.workingDirectory).trim() || undefined : undefined,
+                            };
+                        }
+                    }
+                }
             }
         }
         catch {
@@ -270,6 +367,8 @@ export async function loadDesktopAgentConfig(agentId) {
         runnerType,
         coze,
         openclawx,
+        opencode,
+        useLongMemory,
     };
 }
 function ensureDesktopDir() {
@@ -420,20 +519,57 @@ export async function getDesktopConfigList() {
  * 确保桌面目录下存在 provider-support.json（不存在则写入默认内容）。
  * 供配置供应商时作备选下拉列表项。
  */
+/**
+ * 确保桌面目录下存在 provider-support.json，并与预装的最新供应商列表合并。
+ */
 export async function ensureProviderSupportFile() {
+    const presetPath = join(getPresetsDir(), "preset-providers.json");
+    let presetData = { providers: DEFAULT_PROVIDER_SUPPORT };
+    if (existsSync(presetPath)) {
+        try {
+            presetData = JSON.parse(await readFile(presetPath, "utf-8"));
+        }
+        catch { }
+    }
+    const presetProviders = presetData.providers || DEFAULT_PROVIDER_SUPPORT;
     const path = getProviderSupportPath();
-    if (existsSync(path))
-        return;
     ensureDesktopDir();
-    await writeFile(path, JSON.stringify(DEFAULT_PROVIDER_SUPPORT, null, 2), "utf-8");
+    if (!existsSync(path)) {
+        await writeFile(path, JSON.stringify(presetProviders, null, 2), "utf-8");
+        return;
+    }
+    try {
+        const userContent = await readFile(path, "utf-8");
+        const userProviders = JSON.parse(userContent);
+        let changed = false;
+        for (const [providerId, presetEntry] of Object.entries(presetProviders)) {
+            if (!userProviders[providerId]) {
+                userProviders[providerId] = presetEntry;
+                changed = true;
+            }
+            else {
+                const userModels = userProviders[providerId].models || [];
+                for (const presetModel of presetEntry.models) {
+                    if (!userModels.some((m) => m.id === presetModel.id)) {
+                        userModels.push(presetModel);
+                        changed = true;
+                    }
+                }
+                userProviders[providerId].models = userModels;
+            }
+        }
+        if (changed) {
+            await writeFile(path, JSON.stringify(userProviders, null, 2), "utf-8");
+        }
+    }
+    catch {
+        await writeFile(path, JSON.stringify(presetProviders, null, 2), "utf-8");
+    }
 }
-/** 若 config.json 不存在则写入默认结构，供 CLI/Gateway 启动时初始化 */
+/** 若 config.json 不存在则用 preset-config.json 初始化，若存在则浅合并补充新基础键值 */
 async function ensureConfigJsonInitialized() {
-    const configPath = getConfigPath();
-    if (existsSync(configPath))
-        return;
-    ensureDesktopDir();
-    const defaultConfig = {
+    const presetPath = join(getPresetsDir(), "preset-config.json");
+    let presetConfig = {
         defaultProvider: "deepseek",
         defaultModel: "deepseek-chat",
         defaultAgentId: DEFAULT_AGENT_ID,
@@ -441,20 +577,82 @@ async function ensureConfigJsonInitialized() {
         providers: {},
         configuredModels: [],
     };
-    await writeFile(configPath, JSON.stringify(defaultConfig, null, 2), "utf-8");
+    if (existsSync(presetPath)) {
+        try {
+            const data = JSON.parse(await readFile(presetPath, "utf-8"));
+            if (data.config)
+                presetConfig = data.config;
+        }
+        catch { }
+    }
+    const configPath = getConfigPath();
+    ensureDesktopDir();
+    if (!existsSync(configPath)) {
+        await writeFile(configPath, JSON.stringify(presetConfig, null, 2), "utf-8");
+        return;
+    }
+    try {
+        const userConfig = JSON.parse(await readFile(configPath, "utf-8"));
+        let changed = false;
+        for (const [key, value] of Object.entries(presetConfig)) {
+            if (userConfig[key] === undefined) {
+                userConfig[key] = value;
+                changed = true;
+            }
+        }
+        if (changed) {
+            await writeFile(configPath, JSON.stringify(userConfig, null, 2), "utf-8");
+        }
+    }
+    catch { }
 }
-/** 若 agents.json 不存在则写入默认智能体，供 CLI/Gateway 启动时初始化 */
+/** 合并 preset-agents.json 中的预置智能体，并随之释放对应的工作区技能 */
 async function ensureAgentsJsonInitialized() {
+    const presetPath = join(getPresetsDir(), "preset-agents.json");
+    let presetAgents = [];
+    if (existsSync(presetPath)) {
+        try {
+            const data = JSON.parse(await readFile(presetPath, "utf-8"));
+            if (Array.isArray(data.agents))
+                presetAgents = data.agents;
+        }
+        catch { }
+    }
     const agentsPath = join(getDesktopDir(), "agents.json");
-    if (existsSync(agentsPath))
-        return;
     ensureDesktopDir();
-    const defaultAgents = {
-        agents: [
-            { id: DEFAULT_AGENT_ID, name: "主智能体", workspace: DEFAULT_AGENT_ID },
-        ],
-    };
-    await writeFile(agentsPath, JSON.stringify(defaultAgents, null, 2), "utf-8");
+    let currentData = { agents: [] };
+    if (existsSync(agentsPath)) {
+        try {
+            currentData = JSON.parse(await readFile(agentsPath, "utf-8"));
+            if (!Array.isArray(currentData.agents))
+                currentData.agents = [];
+        }
+        catch { }
+    }
+    let changed = false;
+    for (const pa of presetAgents) {
+        if (!currentData.agents.some((a) => a.id === pa.id)) {
+            currentData.agents.push(pa);
+            changed = true;
+            try {
+                const srcSkillsDir = join(getPresetsDir(), "workspaces", pa.id, "skills");
+                const homeDir = process.env.HOME || process.env.USERPROFILE || homedir();
+                const destSkillsDir = join(homeDir, ".openbot", "workspace", pa.id, "skills");
+                if (existsSync(srcSkillsDir)) {
+                    if (!existsSync(destSkillsDir)) {
+                        await mkdir(destSkillsDir, { recursive: true });
+                    }
+                    await cp(srcSkillsDir, destSkillsDir, { recursive: true, force: false, errorOnExist: false });
+                }
+            }
+            catch (err) {
+                console.error(`Failed to copy preset skills for agent ${pa.id}:`, err);
+            }
+        }
+    }
+    if (changed || !existsSync(agentsPath)) {
+        await writeFile(agentsPath, JSON.stringify(currentData, null, 2), "utf-8");
+    }
 }
 /**
  * CLI / Gateway 运行时调用，确保 config.json、provider-support.json、agents.json 均完成初始化。

package/dist/core/memory/compaction-extension.d.ts

@@ -1,6 +1,7 @@
 import type { ExtensionFactory } from "@mariozechner/pi-coding-agent";
 /**
- * 创建用于在 session_compact 事件时把 compaction summary 写入向量库的 extension factory。
- * 在 AgentSession 发生 compaction（自动或手动）后触发，无需等到关闭会话。
+ * 创建用于在 session_compact 事件时更新「当前 session 最新 compaction」的 extension factory。
+ * 发生 compaction 时只回调 onUpdateLatestCompaction(summary)，由调用方保存；
+ * 向量库写入推迟到 SessionAgent 关闭时由 AgentManager 统一执行。
  */
-export declare function createCompactionMemoryExtensionFactory(sessionId: string): ExtensionFactory;
+export declare function createCompactionMemoryExtensionFactory(_sessionId: string, onUpdateLatestCompaction: (summary: string) => void): ExtensionFactory;