@next-open-ai/openclawx 0.6.6

package/dist/core/agent/agent-manager.js

@@ -0,0 +1,278 @@
+import { createAgentSession, AuthStorage, DefaultResourceLoader, ModelRegistry, SessionManager as CoreSessionManager, createReadTool, createWriteTool, createEditTool, createBashTool, createFindTool, createGrepTool, createLsTool } from "@mariozechner/pi-coding-agent";
+import { join } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import { createCompactionMemoryExtensionFactory } from "../memory/compaction-extension.js";
+import { getCompactionContextForSystemPrompt } from "../memory/index.js";
+import { createBrowserTool, createSaveExperienceTool, createInstallSkillTool, createGetBookmarkTagsTool, createSaveBookmarkTool } from "../tools/index.js";
+import { createMcpToolsForSession } from "../mcp/index.js";
+import { registerBuiltInApiProviders } from "@mariozechner/pi-ai/dist/providers/register-builtins.js";
+import { getOpenbotAgentDir, getOpenbotWorkspaceDir, ensureDefaultAgentDir } from "./agent-dir.js";
+import { formatSkillsForPrompt } from "./skills.js";
+// Ensure all built-in providers are registered
+registerBuiltInApiProviders();
+/** system prompt 中每个技能描述最大字符数，超出截断以省 token */
+const MAX_SKILL_DESC_IN_PROMPT = 250;
+/**
+ * Unified Agent Manager for both CLI and Gateway
+ */
+export class AgentManager {
+    sessions = new Map();
+    /** 每个 session 最后被使用的时间戳，用于 LRU 淘汰 */
+    sessionLastActiveAt = new Map();
+    agentDir;
+    workspaceDir;
+    skillPaths = [];
+    preLoadedSkills = [];
+    constructor(options = {}) {
+        this.agentDir = options.agentDir || getOpenbotAgentDir();
+        // Centralized workspace root: ~/.openbot/workspace/
+        const workspaceRoot = getOpenbotWorkspaceDir();
+        const workspaceName = options.workspace || "default";
+        this.workspaceDir = join(workspaceRoot, workspaceName);
+        this.skillPaths = options.skillPaths || [];
+        this.preLoadedSkills = options.skills || [];
+        // Ensure workspace directory exists
+        if (!existsSync(this.workspaceDir)) {
+            mkdirSync(this.workspaceDir, { recursive: true });
+        }
+    }
+    /**
+     * Re-configure the manager
+     */
+    configure(options) {
+        if (options.agentDir)
+            this.agentDir = options.agentDir;
+        if (options.workspace) {
+            const workspaceRoot = getOpenbotWorkspaceDir();
+            this.workspaceDir = join(workspaceRoot, options.workspace);
+            if (!existsSync(this.workspaceDir)) {
+                mkdirSync(this.workspaceDir, { recursive: true });
+            }
+        }
+        if (options.skillPaths)
+            this.skillPaths = options.skillPaths;
+        if (options.skills)
+            this.preLoadedSkills = options.skills;
+    }
+    /**
+     * Build system prompt with skills and browser tool description
+     */
+    buildSystemPrompt(skills) {
+        const shortSkills = skills.map((s) => ({
+            ...s,
+            description: s.description.length <= MAX_SKILL_DESC_IN_PROMPT
+                ? s.description
+                : s.description.slice(0, MAX_SKILL_DESC_IN_PROMPT) + "…",
+        }));
+        const skillsBlock = formatSkillsForPrompt(shortSkills);
+        const browserToolDesc = `
+## Browser Tool
+
+You have access to a \`browser\` tool for web automation:
+- **navigate**: Navigate to a URL
+- **snapshot**: Get page content with element refs (@e1, @e2, etc.)
+- **screenshot**: Capture page image
+- **click**: Click element (use selector or ref from snapshot)
+- **type**: Type text into element
+- **fill**: Clear and fill input field
+- **scroll**: Scroll page (up/down/left/right)
+- **extract**: Get text from element
+- **wait**: Wait for element to appear
+- **download**: Download file from URL or by clicking download button/link
+- **back/forward**: Navigate browser history
+- **close**: Close browser
+
+Use refs from snapshots (e.g., @e1) for reliable element selection.
+For downloads, provide either a direct URL or a selector to click.`;
+        const parts = [
+            "You are a helpful assistant. When users ask about skills, explain what skills are available.",
+            browserToolDesc,
+            skillsBlock,
+        ].filter(Boolean);
+        return parts.join("\n\n");
+    }
+    /**
+     * Get the initial context (prompt and skills)
+     */
+    async getContext() {
+        const loader = this.createResourceLoader(this.workspaceDir);
+        await loader.reload();
+        const loadedSkills = loader.getSkills().skills;
+        const systemPrompt = this.buildSystemPrompt(loadedSkills);
+        return { systemPrompt, skills: loadedSkills };
+    }
+    createResourceLoader(workspaceDir, sessionId, compactionBlock) {
+        const loader = new DefaultResourceLoader({
+            cwd: workspaceDir,
+            agentDir: this.agentDir,
+            noSkills: true, // Disable SDK's built-in skills logic to take full control
+            additionalSkillPaths: this.resolveSkillPaths(workspaceDir),
+            extensionFactories: sessionId ? [createCompactionMemoryExtensionFactory(sessionId)] : [],
+            systemPromptOverride: (base) => {
+                const loadedSkills = loader.getSkills().skills;
+                let customPrompt = this.buildSystemPrompt(loadedSkills);
+                if (compactionBlock?.trim()) {
+                    customPrompt = customPrompt + "\n\n" + compactionBlock.trim();
+                }
+                return customPrompt;
+            },
+        });
+        return loader;
+    }
+    /**
+     * Resolve all relevant skill paths (Global, Project, Workspace)
+     * @param workspaceDir 当前会话使用的工作区目录，不传则用 manager 默认
+     */
+    resolveSkillPaths(workspaceDir) {
+        const paths = new Set();
+        const wsDir = workspaceDir ?? this.workspaceDir;
+        // 1. Managed skills (Global: ~/.openbot/agent/skills)
+        const managedSkillsDir = join(this.agentDir, "skills");
+        if (existsSync(managedSkillsDir))
+            paths.add(managedSkillsDir);
+        // 2. Extra paths (CLI -s / Config)
+        this.skillPaths.forEach(p => paths.add(p));
+        // 3. Project skills (./skills)
+        const projectSkillsDir = join(process.cwd(), "skills");
+        if (existsSync(projectSkillsDir))
+            paths.add(projectSkillsDir);
+        // 4. Workspace skills (./workspace/<name>/skills)
+        const workspaceSkillsDir = join(wsDir, "skills");
+        if (existsSync(workspaceSkillsDir))
+            paths.add(workspaceSkillsDir);
+        return Array.from(paths);
+    }
+    /**
+     * Get or create an agent session.
+     * @param options.workspace 该会话绑定的工作区名（来自 agent 配置），不传则用 default，创建时 cwd/技能路径依此
+     * @param options.provider / options.modelId 来自 agent 配置的大模型，不传则用环境变量默认
+     * @param options.maxSessions 若提供且当前 session 数 >= 该值，会先淘汰最后调用时间最早的 session 再创建新的
+     * @param options.targetAgentId 创建时绑定到 install_skill 工具，用于安装目标（具体 agentId 或 global）
+     */
+    async getOrCreateSession(sessionId, options = {}) {
+        const now = Date.now();
+        if (this.sessions.has(sessionId)) {
+            this.sessionLastActiveAt.set(sessionId, now);
+            return this.sessions.get(sessionId);
+        }
+        const { maxSessions } = options;
+        if (typeof maxSessions === "number" && maxSessions > 0 && this.sessions.size >= maxSessions) {
+            let oldestId = null;
+            let oldestAt = Infinity;
+            for (const [id, at] of this.sessionLastActiveAt) {
+                if (this.sessions.has(id) && at < oldestAt) {
+                    oldestAt = at;
+                    oldestId = id;
+                }
+            }
+            if (oldestId != null) {
+                this.deleteSession(oldestId);
+            }
+        }
+        const workspaceRoot = getOpenbotWorkspaceDir();
+        const workspaceName = options.workspace ?? "default";
+        const sessionWorkspaceDir = join(workspaceRoot, workspaceName);
+        if (!existsSync(sessionWorkspaceDir)) {
+            mkdirSync(sessionWorkspaceDir, { recursive: true });
+        }
+        const provider = options.provider ?? process.env.OPENBOT_PROVIDER ?? "deepseek";
+        const modelId = options.modelId ?? process.env.OPENBOT_MODEL ?? "deepseek-chat";
+        const apiKey = options.apiKey;
+        ensureDefaultAgentDir(this.agentDir);
+        const authPath = join(this.agentDir, "auth.json");
+        const modelsPath = join(this.agentDir, "models.json");
+        const authStorage = new AuthStorage(authPath);
+        if (apiKey) {
+            authStorage.setRuntimeApiKey(provider, apiKey);
+        }
+        if (await authStorage.hasAuth(provider)) {
+            const key = await authStorage.getApiKey(provider);
+            if (key) {
+                if (provider === "deepseek") {
+                    process.env.OPENAI_API_KEY = key;
+                }
+                else if (provider === "dashscope") {
+                    process.env.DASHSCOPE_API_KEY = key;
+                }
+                else if (provider === "nvidia") {
+                    process.env.NVIDIA_API_KEY = key;
+                }
+                else if (provider === "kimi") {
+                    process.env.MOONSHOT_API_KEY = key;
+                }
+                else if (provider === "openai" || provider === "openai-custom") {
+                    process.env.OPENAI_API_KEY = key;
+                }
+                if (!process.env.OPENAI_API_KEY) {
+                    process.env.OPENAI_API_KEY = key;
+                }
+            }
+        }
+        const modelRegistry = new ModelRegistry(authStorage, modelsPath);
+        authStorage.setFallbackResolver((p) => {
+            if (p === "deepseek")
+                return process.env.OPENAI_API_KEY || process.env.DEEPSEEK_API_KEY;
+            if (p === "dashscope")
+                return process.env.DASHSCOPE_API_KEY || process.env.OPENAI_API_KEY;
+            if (p === "nvidia")
+                return process.env.NVIDIA_API_KEY || process.env.OPENAI_API_KEY;
+            if (p === "kimi")
+                return process.env.MOONSHOT_API_KEY || process.env.KIMI_API_KEY || process.env.OPENAI_API_KEY;
+            if (p === "openai" || p === "openai-custom")
+                return process.env.OPENAI_API_KEY;
+            return process.env.OPENAI_API_KEY;
+        });
+        const compactionBlock = await getCompactionContextForSystemPrompt(sessionId);
+        const loader = this.createResourceLoader(sessionWorkspaceDir, sessionId, compactionBlock);
+        await loader.reload();
+        const coreTools = {
+            read: createReadTool(sessionWorkspaceDir),
+            write: createWriteTool(sessionWorkspaceDir),
+            edit: createEditTool(sessionWorkspaceDir),
+            bash: createBashTool(sessionWorkspaceDir),
+            find: createFindTool(sessionWorkspaceDir),
+            grep: createGrepTool(sessionWorkspaceDir),
+            ls: createLsTool(sessionWorkspaceDir),
+        };
+        const mcpTools = await createMcpToolsForSession({ mcpServers: options.mcpServers });
+        const customTools = [
+            createBrowserTool(sessionWorkspaceDir),
+            createSaveExperienceTool(sessionId),
+            createInstallSkillTool(options.targetAgentId),
+            createGetBookmarkTagsTool(),
+            createSaveBookmarkTool(),
+            ...mcpTools,
+        ];
+        const { session } = await createAgentSession({
+            agentDir: this.agentDir,
+            sessionManager: CoreSessionManager.inMemory(),
+            authStorage,
+            modelRegistry,
+            cwd: sessionWorkspaceDir,
+            resourceLoader: loader,
+            customTools,
+            baseToolsOverride: coreTools,
+        });
+        const model = modelRegistry.find(provider, modelId);
+        if (model) {
+            console.log(`Setting model to ${model.provider}/${model.id} (workspace: ${workspaceName})`);
+            await session.setModel(model);
+        }
+        this.sessions.set(sessionId, session);
+        this.sessionLastActiveAt.set(sessionId, now);
+        return session;
+    }
+    getSession(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    deleteSession(sessionId) {
+        this.sessionLastActiveAt.delete(sessionId);
+        return this.sessions.delete(sessionId);
+    }
+    clearAll() {
+        this.sessions.clear();
+        this.sessionLastActiveAt.clear();
+    }
+}
+// Singleton for easy access (e.g., from Gateway)
+export const agentManager = new AgentManager();

package/dist/core/agent/config-manager.d.ts

@@ -0,0 +1,25 @@
+export interface ConfigInfo {
+    provider: string;
+    model: string;
+    hasKey: boolean;
+}
+/**
+ * Manage agent configuration (auth.json, models.json)
+ */
+export declare class ConfigManager {
+    private agentDir;
+    private authStorage;
+    constructor(agentDir?: string);
+    /**
+     * Save API key for a provider
+     */
+    login(provider: string, apiKey: string): Promise<void>;
+    /**
+     * Update default model for a provider in models.json
+     */
+    setModel(provider: string, modelId: string): Promise<void>;
+    /**
+     * List current configurations
+     */
+    list(): ConfigInfo[];
+}

package/dist/core/agent/config-manager.js

@@ -0,0 +1,84 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { AuthStorage } from "@mariozechner/pi-coding-agent";
+import { getOpenbotAgentDir, ensureDefaultAgentDir } from "./agent-dir.js";
+/**
+ * Manage agent configuration (auth.json, models.json)
+ */
+export class ConfigManager {
+    agentDir;
+    authStorage;
+    constructor(agentDir = getOpenbotAgentDir()) {
+        this.agentDir = agentDir;
+        ensureDefaultAgentDir(this.agentDir);
+        const authPath = join(this.agentDir, "auth.json");
+        this.authStorage = new AuthStorage(authPath);
+    }
+    /**
+     * Save API key for a provider
+     */
+    async login(provider, apiKey) {
+        this.authStorage.set(provider, {
+            type: "api_key",
+            key: apiKey
+        });
+        console.log(`[config] Successfully saved API key for provider: ${provider}`);
+    }
+    /**
+     * Update default model for a provider in models.json
+     */
+    async setModel(provider, modelId) {
+        const modelsPath = join(this.agentDir, "models.json");
+        if (!existsSync(modelsPath)) {
+            throw new Error(`models.json not found at ${modelsPath}`);
+        }
+        const config = JSON.parse(readFileSync(modelsPath, "utf-8"));
+        if (!config.providers[provider]) {
+            throw new Error(`Provider "${provider}" not found in models.json`);
+        }
+        // Check if model exists in that provider's list
+        const providerConfig = config.providers[provider];
+        const modelExists = providerConfig.models?.some((m) => m.id === modelId);
+        if (!modelExists) {
+            console.warn(`[config] Warning: Model "${modelId}" not found in the defined list for "${provider}". Adding it anyway.`);
+            if (!providerConfig.models)
+                providerConfig.models = [];
+            providerConfig.models.push({
+                id: modelId,
+                name: modelId,
+                contextWindow: 128000,
+                supportsTools: true
+            });
+        }
+        // In this simple implementation, we assume the first model in the list
+        // might be intended as default by some logic, although the registry 
+        // usually needs explicit selection.
+        // For now, let's just reorder so the selected model is first.
+        const modelIndex = providerConfig.models.findIndex((m) => m.id === modelId);
+        if (modelIndex > 0) {
+            const [model] = providerConfig.models.splice(modelIndex, 1);
+            providerConfig.models.unshift(model);
+        }
+        writeFileSync(modelsPath, JSON.stringify(config, null, 2), "utf-8");
+        console.log(`[config] Updated default model for "${provider}" to "${modelId}"`);
+    }
+    /**
+     * List current configurations
+     */
+    list() {
+        const modelsPath = join(this.agentDir, "models.json");
+        if (!existsSync(modelsPath))
+            return [];
+        const config = JSON.parse(readFileSync(modelsPath, "utf-8"));
+        const results = [];
+        for (const [providerId, providerConfig] of Object.entries(config.providers)) {
+            const firstModel = providerConfig.models?.[0]?.id || "none";
+            results.push({
+                provider: providerId,
+                model: firstModel,
+                hasKey: this.authStorage.has(providerId)
+            });
+        }
+        return results;
+    }
+}

package/dist/core/agent/run.d.ts

@@ -0,0 +1,26 @@
+export interface RunOptions {
+    /** Workspace name (e.g. "default") */
+    workspace?: string;
+    /** Additional skill paths */
+    skillPaths?: string[];
+    /** 用户提示词 */
+    userPrompt: string;
+    /** 是否仅打印组装后的内容，不调 LLM */
+    dryRun?: boolean;
+    /** API key，不传则从 pi 的 auth 或 OPENAI_API_KEY 读取 */
+    apiKey?: string;
+    /** 模型 ID（如 deepseek-chat、qwen-max） */
+    model?: string;
+    /** Provider（如 deepseek、dashscope、openai） */
+    provider?: string;
+    /** Agent 配置目录，默认 ~/.openbot/agent */
+    agentDir?: string;
+}
+export interface RunResult {
+    systemPrompt: string;
+    userPrompt: string;
+    /** 若调用了 API，则为助手回复 */
+    assistantContent?: string;
+    dryRun: boolean;
+}
+export declare function run(options: RunOptions): Promise<RunResult>;

package/dist/core/agent/run.js

@@ -0,0 +1,65 @@
+import { getOpenbotAgentDir } from "./agent-dir.js";
+import { AgentManager } from "./agent-manager.js";
+export async function run(options) {
+    const { workspace = "default", skillPaths = [], userPrompt, dryRun: explicitDryRun, apiKey, model: modelId = "deepseek-chat", provider = "deepseek", agentDir = getOpenbotAgentDir(), } = options;
+    const manager = new AgentManager({ agentDir, workspace, skillPaths });
+    const { systemPrompt } = await manager.getContext();
+    // Determine dry run
+    const dryRun = !!explicitDryRun; // Ensure boolean
+    const result = {
+        systemPrompt,
+        userPrompt,
+        dryRun,
+    };
+    if (dryRun) {
+        return result;
+    }
+    // Create a temporary session for this run
+    const sessionId = `cli-${Date.now()}`;
+    const session = await manager.getOrCreateSession(sessionId, {
+        provider,
+        modelId,
+        apiKey,
+    });
+    // Collect assistant response
+    let assistantContent = "";
+    session.subscribe((event) => {
+        switch (event.type) {
+            case "message_update": {
+                const evt = event.assistantMessageEvent;
+                if (evt.type === "text_delta") {
+                    assistantContent += evt.delta;
+                    process.stdout.write(evt.delta);
+                }
+                else if (evt.type === "thinking_delta") {
+                    process.stdout.write(evt.delta);
+                }
+                else if (evt.type === "error") {
+                    console.error(`\n[model:error] ${evt.error.errorMessage || "Unknown error"}`);
+                }
+                break;
+            }
+            case "message_end": {
+                if (event.message.role === "assistant" && event.message.errorMessage) {
+                    console.error(`\n[message:error] ${event.message.errorMessage}`);
+                }
+                break;
+            }
+            case "tool_execution_start": {
+                console.log(`\n[tool:start] ${event.toolName}(${JSON.stringify(event.args)})`);
+                break;
+            }
+            case "tool_execution_end": {
+                const status = event.isError ? "failed" : "ok";
+                console.log(`[tool:end] ${event.toolName} -> ${status}`);
+                break;
+            }
+        }
+    });
+    // Send prompt and wait for completion
+    await session.prompt(userPrompt);
+    // Clean up session
+    manager.deleteSession(sessionId);
+    result.assistantContent = assistantContent.trim();
+    return result;
+}

package/dist/core/agent/skills.d.ts

@@ -0,0 +1,20 @@
+import { type Skill } from "@mariozechner/pi-coding-agent";
+export type { Skill };
+export interface LoadSkillsFromDirOptions {
+    dir: string;
+    source: string;
+}
+/**
+ * 从目录加载 skills（委托给 pi-coding-agent，规则与其一致）
+ */
+export declare function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Skill[];
+/**
+ * 从多个路径加载 skills（文件或目录），合并去重（按 name）
+ * 目录使用 pi-coding-agent 的 loadSkillsFromDir，单文件使用本地解析
+ */
+export declare function loadSkillsFromPaths(paths: string[], source?: string): Skill[];
+/**
+ * 将 Skill[] 格式化为系统提示中的一段（委托给 pi-coding-agent，对齐 agentskills.io）
+ */
+declare function formatSkillsForPrompt(skills: Skill[]): string;
+export { formatSkillsForPrompt };

package/dist/core/agent/skills.js

@@ -0,0 +1,86 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join, dirname, basename } from "node:path";
+import { formatSkillsForPrompt as piFormatSkillsForPrompt, loadSkillsFromDir as piLoadSkillsFromDir, } from "@mariozechner/pi-coding-agent";
+/**
+ * 简单 frontmatter 解析：--- 与 --- 之间的 YAML 风格键值
+ */
+function parseFrontmatter(raw) {
+    const match = raw.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match)
+        return {};
+    const block = match[1];
+    const out = {};
+    for (const line of block.split("\n")) {
+        const m = line.match(/^\s*([a-z-]+)\s*:\s*(.*)$/);
+        if (m)
+            out[m[1].trim()] = m[2].trim().replace(/^["']|["']$/g, "");
+    }
+    return {
+        name: out.name,
+        description: out.description,
+    };
+}
+/**
+ * 从单文件加载一个 Skill（与 pi-coding-agent Skill 结构一致）
+ */
+function loadSkillFromFile(filePath, source) {
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        const { name, description } = parseFrontmatter(raw);
+        const skillDir = dirname(filePath);
+        const parentDirName = basename(skillDir);
+        const finalName = (name || parentDirName).trim();
+        const finalDesc = (description || "").trim();
+        if (!finalDesc)
+            return null;
+        return {
+            name: finalName,
+            description: finalDesc,
+            filePath,
+            baseDir: skillDir,
+            source,
+            disableModelInvocation: false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 从目录加载 skills（委托给 pi-coding-agent，规则与其一致）
+ */
+export function loadSkillsFromDir(options) {
+    const result = piLoadSkillsFromDir(options);
+    return result.skills ?? [];
+}
+/**
+ * 从多个路径加载 skills（文件或目录），合并去重（按 name）
+ * 目录使用 pi-coding-agent 的 loadSkillsFromDir，单文件使用本地解析
+ */
+export function loadSkillsFromPaths(paths, source = "user") {
+    const byName = new Map();
+    for (const p of paths) {
+        const resolved = p.startsWith("~") ? join(process.env.HOME || "", p.slice(1)) : p;
+        if (!existsSync(resolved))
+            continue;
+        const stat = statSync(resolved);
+        if (stat.isFile() && resolved.endsWith(".md")) {
+            const skill = loadSkillFromFile(resolved, source);
+            if (skill)
+                byName.set(skill.name, skill);
+        }
+        else if (stat.isDirectory()) {
+            for (const skill of loadSkillsFromDir({ dir: resolved, source })) {
+                byName.set(skill.name, skill);
+            }
+        }
+    }
+    return Array.from(byName.values());
+}
+/**
+ * 将 Skill[] 格式化为系统提示中的一段（委托给 pi-coding-agent，对齐 agentskills.io）
+ */
+function formatSkillsForPrompt(skills) {
+    return piFormatSkillsForPrompt(skills);
+}
+export { formatSkillsForPrompt };

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

@@ -0,0 +1,90 @@
+import { type ProviderSupport, type ProviderSupportEntry, type ProviderSupportModel, type ModelSupportType } from "./provider-support-default.js";
+export type { ProviderSupport, ProviderSupportEntry, ProviderSupportModel, ModelSupportType };
+/** RAG 长记忆：使用远端 embedding 模型；未配置时基于 RAG 的长记忆空转 */
+export interface RagEmbeddingConfig {
+    provider: string;
+    modelId: string;
+    apiKey?: string;
+    baseUrl?: string;
+}
+/** MCP 服务器配置（与 core/mcp 类型一致，避免 core/config 依赖 core/mcp 实现） */
+export type DesktopMcpServerConfig = import("../mcp/index.js").McpServerConfig;
+/**
+ * 同步读取桌面全局配置中的 maxAgentSessions 等。
+ * Gateway 进程内使用，用于会话上限等。
+ */
+export declare function getDesktopConfig(): {
+    maxAgentSessions: number;
+};
+/** 同步读取 RAG embedding 配置；未配置或无效时返回 null，长记忆将空转 */
+export declare function getRagEmbeddingConfigSync(): RagEmbeddingConfig | null;
+export interface DesktopAgentConfig {
+    provider: string;
+    model: string;
+    apiKey?: string;
+    /** 工作区名，来自 agents.json 的 agent.workspace 或 agent.id */
+    workspace?: string;
+    /** MCP 服务器配置，创建 Session 时传入 */
+    mcpServers?: DesktopMcpServerConfig[];
+}
+/**
+ * 从 config.json 读取缺省智能体 id（defaultAgentId）。
+ * 若未配置、或该 id 在 agents.json 中不存在，则返回 default。
+ */
+export declare function getBoundAgentIdForCli(): Promise<string>;
+/**
+ * 根据 agentId 从桌面配置中读取该 agent 的 provider、model 及 API Key。
+ * 若文件不存在或解析失败返回 null，调用方使用环境变量或默认值。
+ */
+export declare function loadDesktopAgentConfig(agentId: string): Promise<DesktopAgentConfig | null>;
+/** 供 CLI config list 使用：从桌面 config 读出的配置列表项 */
+export interface DesktopConfigListEntry {
+    provider: string;
+    defaultModel: string;
+    hasKey: boolean;
+}
+/** 供 CLI config list 使用：桌面配置列表（中心化配置源） */
+export interface DesktopConfigList {
+    defaultProvider: string;
+    defaultModel: string;
+    defaultModelItemCode?: string;
+    providers: DesktopConfigListEntry[];
+}
+/**
+ * 将某 provider 的 API Key 写入桌面 config（中心化配置源）。
+ * openbot login 使用：缺省 alias 与 provider 同名；若有 baseUrl 则一并写入。
+ * 若传入 modelId 或未传则取该 provider 第一个模型，会补齐 defaultProvider/defaultModel、configuredModels、agents 默认智能体，后续可直接运行。
+ */
+export declare function setProviderApiKey(provider: string, apiKey: string, modelId?: string): Promise<void>;
+/**
+ * 将全局默认 provider/model 写入桌面 config，并在 configuredModels 中增加/更新对应项，agents.json 中缺省智能体写入 modelItemCode。
+ * openbot config set-model 使用此方法。
+ */
+export declare function setDefaultModel(provider: string, modelId: string): Promise<void>;
+/**
+ * 供 CLI config list 使用，从桌面 config 读出配置列表。
+ */
+export declare function getDesktopConfigList(): Promise<DesktopConfigList>;
+/**
+ * 确保桌面目录下存在 provider-support.json（不存在则写入默认内容）。
+ * 供配置供应商时作备选下拉列表项。
+ */
+export declare function ensureProviderSupportFile(): Promise<void>;
+/**
+ * CLI / Gateway 运行时调用，确保 config.json、provider-support.json、agents.json 均完成初始化。
+ */
+export declare function ensureDesktopConfigInitialized(): Promise<void>;
+/**
+ * 取某 provider 在 provider-support 中的第一个 llm 模型 id；若无则返回第一个模型 id。
+ */
+export declare function getFirstModelForProvider(provider: string): Promise<string | null>;
+/**
+ * 读取桌面 provider-support.json（流行 provider 及模型目录）。
+ * 若文件不存在则先写入默认内容再返回；若存在则与默认合并，补全默认中已有而文件中缺失的 provider（如新增的 openai-custom）。
+ */
+export declare function getProviderSupport(): Promise<ProviderSupport>;
+/**
+ * 根据桌面 config（已配置的 providers + configuredModels）与 provider-support，生成并写入 agent 目录的 models.json。
+ * 仅包含在 config 的 providers 中已配置的 provider；每个 provider 的 models 来自 configuredModels，结构含 reasoning、cost 等。
+ */
+export declare function syncDesktopConfigToModelsJson(): Promise<void>;