@next-open-ai/openclawx 0.6.6

package/dist/gateway/paths.js

@@ -0,0 +1,19 @@
+/**
+ * Gateway 路径常量：各模块使用独立 path 端点，便于路由与扩展。
+ */
+export const PATHS = {
+    /** 业务 REST API（Nest） */
+    SERVER_API: '/server-api',
+    /** Agent 对话 WebSocket */
+    WS: '/ws',
+    /** 语音通道 WebSocket（扩展占位） */
+    WS_VOICE: '/ws/voice',
+    /** Agent 流式 SSE（占位） */
+    SSE: '/sse',
+    /** 通道模块（webhook / 回调） */
+    CHANNEL: '/channel',
+    /** 健康检查 */
+    HEALTH: '/health',
+    /** 定时任务执行（Nest 回调 Gateway） */
+    RUN_SCHEDULED_TASK: '/run-scheduled-task',
+};

package/dist/gateway/server.d.ts

@@ -0,0 +1,8 @@
+import { type Server } from "http";
+import { WebSocketServer } from "ws";
+export declare function startGatewayServer(port?: number): Promise<{
+    httpServer: Server;
+    wss: WebSocketServer;
+    port: number;
+    close: () => Promise<void>;
+}>;

package/dist/gateway/server.js

@@ -0,0 +1,190 @@
+/**
+ * Gateway 单进程入口：内嵌 Nest，按 path 分流。
+ * - /server-api → Nest（业务 REST）
+ * - /ws → Agent 对话 WebSocket
+ * - /ws/voice → 语音通道（占位）
+ * - /sse → SSE（占位）
+ * - /channel → 通道模块（占位）
+ * - 其余 → 静态资源
+ */
+/* Avoid MaxListenersExceededWarning */
+const Et = globalThis.EventTarget;
+if (Et?.prototype?.addEventListener && Et.prototype.setMaxListeners) {
+    const add = Et.prototype.addEventListener;
+    Et.prototype.addEventListener = function (type, listener, options) {
+        if (type === "abort" && typeof this.setMaxListeners === "function") {
+            this.setMaxListeners(32);
+        }
+        return add.call(this, type, listener, options);
+    };
+}
+import express from "express";
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+import { readFile, stat } from "fs/promises";
+import { join, extname, dirname } from "path";
+import { fileURLToPath } from "node:url";
+import { PATHS } from "./paths.js";
+import { authHookServerApi, authHookChannel, authHookSse, authHookWs } from "./auth-hooks.js";
+import { handleChannel } from "./channel-handler.js";
+import { handleSse } from "./sse-handler.js";
+import { handleVoiceUpgrade } from "./voice-handler.js";
+import { handleConnection } from "./connection-handler.js";
+import { handleRunScheduledTask } from "./methods/run-scheduled-task.js";
+import multer from "multer";
+import { handleInstallSkillFromPath } from "./methods/install-skill-from-path.js";
+import { handleInstallSkillFromUpload } from "./methods/install-skill-from-upload.js";
+import { setBackendBaseUrl } from "./backend-url.js";
+import { ensureDesktopConfigInitialized } from "../core/config/desktop-config.js";
+import { createNestAppEmbedded } from "../server/bootstrap.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = join(__dirname, "..", "..");
+/** 内嵌到 Electron 时由主进程设置 OPENBOT_STATIC_DIR，指向打包后的 renderer/dist */
+const STATIC_DIR = process.env.OPENBOT_STATIC_DIR || join(PACKAGE_ROOT, "apps", "desktop", "renderer", "dist");
+const MIME_TYPES = {
+    ".html": "text/html",
+    ".js": "text/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".eot": "application/vnd.ms-fontobject",
+};
+export async function startGatewayServer(port = 38080) {
+    await ensureDesktopConfigInitialized();
+    console.log(`Starting gateway server on port ${port}...`);
+    setBackendBaseUrl(`http://localhost:${port}`);
+    const { app: nestApp, express: nestExpress } = await createNestAppEmbedded();
+    const gatewayExpress = express();
+    gatewayExpress.get(PATHS.HEALTH, (_req, res) => {
+        res.status(200).json({ status: "ok", timestamp: Date.now() });
+    });
+    gatewayExpress.post(PATHS.RUN_SCHEDULED_TASK, async (req, res) => {
+        await handleRunScheduledTask(req, res);
+    });
+    const uploadZip = multer({
+        storage: multer.memoryStorage(),
+        limits: { fileSize: 10 * 1024 * 1024 },
+    });
+    gatewayExpress.post(`${PATHS.SERVER_API}/skills/install-from-path`, async (req, res) => {
+        const body = await new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on("data", (chunk) => chunks.push(chunk));
+            req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+            req.on("error", reject);
+        });
+        try {
+            const parsed = JSON.parse(body || "{}");
+            const result = await handleInstallSkillFromPath({
+                path: parsed.path ?? "",
+                scope: parsed.scope === "workspace" ? "workspace" : "global",
+                workspace: parsed.workspace,
+            });
+            res.status(200).json(result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const code = message.includes("required") || message.includes("不存在") || message.includes("SKILL.md") || message.includes("目录名") ? 400 : 500;
+            res.status(code).json({ success: false, message });
+        }
+    });
+    gatewayExpress.post(`${PATHS.SERVER_API}/skills/install-from-upload`, authHookServerApi, uploadZip.single("file"), async (req, res) => {
+        try {
+            const file = req.file;
+            const buffer = file?.buffer;
+            if (!buffer || !Buffer.isBuffer(buffer)) {
+                return res.status(400).json({ success: false, message: "请上传 zip 文件" });
+            }
+            const scope = req.body?.scope === "workspace" ? "workspace" : "global";
+            const workspace = req.body?.workspace ?? "default";
+            const result = await handleInstallSkillFromUpload({ buffer, scope, workspace });
+            res.status(200).json(result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const code = message.includes("请上传") || message.includes("SKILL.md") || message.includes("目录") || message.includes("10MB") ? 400 : 500;
+            res.status(code).json({ success: false, message });
+        }
+    });
+    gatewayExpress.use(PATHS.SERVER_API, authHookServerApi, nestExpress);
+    gatewayExpress.use(PATHS.CHANNEL, authHookChannel, (req, res) => handleChannel(req, res));
+    gatewayExpress.use(PATHS.SSE, authHookSse, (req, res) => handleSse(req, res));
+    gatewayExpress.use(async (req, res) => {
+        const staticDir = STATIC_DIR;
+        const urlPath = req.url?.split("?")[0] || "/";
+        let filePath = join(staticDir, urlPath === "/" ? "index.html" : urlPath);
+        try {
+            const stats = await stat(filePath);
+            if (stats.isDirectory()) {
+                filePath = join(filePath, "index.html");
+                await stat(filePath);
+            }
+        }
+        catch {
+            if (req.headers.accept?.includes("text/html") && req.method === "GET") {
+                filePath = join(staticDir, "index.html");
+            }
+            else {
+                res.writeHead(404, { "Content-Type": "text/plain" });
+                res.end("Not Found");
+                return;
+            }
+        }
+        try {
+            const content = await readFile(filePath);
+            const ext = extname(filePath).toLowerCase();
+            const contentType = MIME_TYPES[ext] || "application/octet-stream";
+            res.writeHead(200, { "Content-Type": contentType });
+            res.end(content);
+        }
+        catch (error) {
+            console.error("Static file error:", error);
+            res.writeHead(500, { "Content-Type": "text/plain" });
+            res.end("Internal Server Error");
+        }
+    });
+    const httpServer = createServer(gatewayExpress);
+    const wss = new WebSocketServer({ noServer: true });
+    wss.on("connection", (ws, req) => handleConnection(ws, req));
+    httpServer.on("upgrade", (req, socket, head) => {
+        const path = req.url?.split("?")[0] || "";
+        if (handleVoiceUpgrade(req, socket, head)) {
+            return;
+        }
+        const isAgentWs = path === PATHS.WS || path === "/";
+        if (isAgentWs && authHookWs(req, path)) {
+            wss.handleUpgrade(req, socket, head, (ws) => {
+                wss.emit("connection", ws, req);
+            });
+        }
+        else {
+            socket.destroy();
+        }
+    });
+    const actualPort = await new Promise((resolve) => {
+        httpServer.listen(port, () => {
+            const addr = httpServer.address();
+            const p = typeof addr === "object" && addr && "port" in addr ? addr.port : port;
+            console.log(`✅ Gateway server listening on ws://localhost:${p}`);
+            console.log(`   Health: http://localhost:${p}${PATHS.HEALTH}`);
+            console.log(`   API:    http://localhost:${p}${PATHS.SERVER_API}`);
+            console.log(`   WS:     ws://localhost:${p}${PATHS.WS}`);
+            resolve(p);
+        });
+    });
+    const close = async () => {
+        console.log("Closing gateway server...");
+        await nestApp.close();
+        wss.clients.forEach((c) => c.close());
+        await new Promise((r) => wss.close(() => r()));
+        await new Promise((r) => httpServer.close(() => r()));
+        console.log("Gateway server closed");
+    };
+    return { httpServer, wss, port: actualPort, close };
+}

package/dist/gateway/sse-handler.d.ts

@@ -0,0 +1,6 @@
+/**
+ * SSE 端点（占位）。
+ * 后续：Agent 流式输出；当前返回 501 或简单说明。
+ */
+import type { Request, Response } from 'express';
+export declare function handleSse(_req: Request, res: Response): void;

package/dist/gateway/sse-handler.js

@@ -0,0 +1,3 @@
+export function handleSse(_req, res) {
+    res.status(501).setHeader('Content-Type', 'application/json').end(JSON.stringify({ ok: false, message: 'SSE endpoint not implemented yet' }));
+}

package/dist/gateway/types.d.ts

@@ -0,0 +1,90 @@
+import type { WebSocket } from "ws";
+/** 会话类型：chat 普通对话，scheduled 定时任务，system 系统/临时 */
+export type SessionType = "chat" | "scheduled" | "system";
+/**
+ * Gateway client connection
+ */
+export interface GatewayClient {
+    id: string;
+    ws: WebSocket;
+    authenticated: boolean;
+    sessionId?: string;
+    /** 建连时客户端传入的 session 绑定 agentId，用于取配置，不再请求 Nest */
+    agentId?: string;
+    /** 建连时客户端传入的 session 类型 */
+    sessionType?: SessionType;
+    connectedAt: number;
+}
+/**
+ * Gateway message types
+ */
+export type GatewayMessageType = "request" | "response" | "event";
+/**
+ * Base gateway message
+ */
+export interface GatewayMessage {
+    type: GatewayMessageType;
+    id?: string;
+    method?: string;
+    params?: any;
+    result?: any;
+    error?: {
+        message: string;
+        code?: string;
+    };
+    event?: string;
+    payload?: any;
+}
+/**
+ * Request message
+ */
+export interface GatewayRequest extends GatewayMessage {
+    type: "request";
+    id: string;
+    method: string;
+    params?: any;
+}
+/**
+ * Response message
+ */
+export interface GatewayResponse extends GatewayMessage {
+    type: "response";
+    id: string;
+    result?: any;
+    error?: {
+        message: string;
+        code?: string;
+    };
+}
+/**
+ * Event message
+ */
+export interface GatewayEvent extends GatewayMessage {
+    type: "event";
+    event: string;
+    payload?: any;
+}
+/**
+ * Connect params
+ */
+export interface ConnectParams {
+    sessionId?: string;
+    /** 当前 session 绑定的 agentId，Gateway 用其本地取配置，不请求 Nest */
+    agentId?: string;
+    /** 当前 session 类型：chat | scheduled | system */
+    sessionType?: SessionType;
+    nonce?: string;
+}
+/**
+ * Agent chat params
+ */
+export interface AgentChatParams {
+    message: string;
+    sessionId?: string;
+    /** 当前 session 绑定的 agentId，不传则用 connect 时存的 client.agentId，再缺省 default */
+    agentId?: string;
+    /** 当前 session 类型，不传则用 connect 时存的 client.sessionType，再缺省 chat */
+    sessionType?: SessionType;
+    /** 对话/安装目标：具体 agentId，或 "global"|"all" 表示全局；用于 install_skill 等隔离 */
+    targetAgentId?: string;
+}

package/dist/gateway/types.js

@@ -0,0 +1 @@
+export {};

package/dist/gateway/utils.d.ts

@@ -0,0 +1,22 @@
+import type { WebSocket } from "ws";
+import type { GatewayMessage } from "./types.js";
+/**
+ * Send JSON message to WebSocket client
+ */
+export declare function send(ws: WebSocket, message: GatewayMessage): void;
+/**
+ * Parse incoming WebSocket message
+ */
+export declare function parseMessage(data: Buffer | string): GatewayMessage | null;
+/**
+ * Create error response
+ */
+export declare function createErrorResponse(id: string, message: string, code?: string): GatewayMessage;
+/**
+ * Create success response
+ */
+export declare function createSuccessResponse(id: string, result: any): GatewayMessage;
+/**
+ * Create event message
+ */
+export declare function createEvent(event: string, payload: any): GatewayMessage;

package/dist/gateway/utils.js

@@ -0,0 +1,67 @@
+/**
+ * Send JSON message to WebSocket client
+ */
+export function send(ws, message) {
+    try {
+        ws.send(JSON.stringify(message));
+    }
+    catch (error) {
+        console.error("Failed to send message:", error);
+    }
+}
+/**
+ * Parse incoming WebSocket message
+ */
+export function parseMessage(data) {
+    try {
+        const text = typeof data === "string" ? data : data.toString();
+        const obj = JSON.parse(text);
+        // If type is missing, try to infer it
+        if (!obj.type) {
+            if (obj.method) {
+                obj.type = "request";
+            }
+            else if (obj.event) {
+                obj.type = "event";
+            }
+            else if (obj.result !== undefined || obj.error !== undefined) {
+                obj.type = "response";
+            }
+        }
+        return obj;
+    }
+    catch (error) {
+        console.error("Failed to parse message:", error);
+        return null;
+    }
+}
+/**
+ * Create error response
+ */
+export function createErrorResponse(id, message, code) {
+    return {
+        type: "response",
+        id,
+        error: { message, code },
+    };
+}
+/**
+ * Create success response
+ */
+export function createSuccessResponse(id, result) {
+    return {
+        type: "response",
+        id,
+        result,
+    };
+}
+/**
+ * Create event message
+ */
+export function createEvent(event, payload) {
+    return {
+        type: "event",
+        event,
+        payload,
+    };
+}

package/dist/gateway/voice-handler.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 语音通道 WebSocket（占位）。
+ * 后续：/ws/voice 建连、二进制/信令、与语音服务对接；当前仅关闭连接并返回 400 或不做 upgrade。
+ */
+import type { IncomingMessage } from 'http';
+import type { Duplex } from 'stream';
+/**
+ * 处理 /ws/voice 的 upgrade 请求（占位）。
+ * 返回 true 表示已处理（例如拒绝并关闭），调用方不必再交给 agent /ws；
+ * 返回 false 表示未处理。
+ */
+export declare function handleVoiceUpgrade(req: IncomingMessage, socket: Duplex, _head: Buffer): boolean;

package/dist/gateway/voice-handler.js

@@ -0,0 +1,18 @@
+import { PATHS } from './paths.js';
+/**
+ * 处理 /ws/voice 的 upgrade 请求（占位）。
+ * 返回 true 表示已处理（例如拒绝并关闭），调用方不必再交给 agent /ws；
+ * 返回 false 表示未处理。
+ */
+export function handleVoiceUpgrade(req, socket, _head) {
+    const path = req.url?.split('?')[0] || '';
+    if (path !== PATHS.WS_VOICE) {
+        return false;
+    }
+    socket.write('HTTP/1.1 501 Not Implemented\r\n' +
+        'Content-Type: application/json\r\n' +
+        'Connection: close\r\n\r\n' +
+        JSON.stringify({ ok: false, message: 'Voice WebSocket not implemented yet' }));
+    socket.destroy();
+    return true;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { loadSkillsFromDir, loadSkillsFromPaths, formatSkillsForPrompt, type Skill, type LoadSkillsFromDirOptions, } from "./core/agent/skills.js";
+export { run, type RunOptions, type RunResult } from "./core/agent/run.js";
+export { getOpenbotAgentDir, ensureDefaultAgentDir } from "./core/agent/agent-dir.js";
+export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, type InstallByUrlOptions, type InstallByUrlResult, type InstallFromPathOptions, type InstallFromPathResult, } from "./core/installer/index.js";
+export { getProviderSupport, ensureProviderSupportFile, syncDesktopConfigToModelsJson, type ProviderSupport, type ProviderSupportEntry, type ProviderSupportModel, type ModelSupportType, } from "./core/config/desktop-config.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { loadSkillsFromDir, loadSkillsFromPaths, formatSkillsForPrompt, } from "./core/agent/skills.js";
+export { run } from "./core/agent/run.js";
+export { getOpenbotAgentDir, ensureDefaultAgentDir } from "./core/agent/agent-dir.js";
+export { resolveInstallTarget, installSkillByUrl, installSkillFromPath, } from "./core/installer/index.js";
+export { getProviderSupport, ensureProviderSupportFile, syncDesktopConfigToModelsJson, } from "./core/config/desktop-config.js";

package/dist/server/agent-config/agent-config.controller.d.ts

@@ -0,0 +1,30 @@
+import { AgentConfigService, AgentConfigItem } from './agent-config.service.js';
+export declare class AgentConfigController {
+    private readonly agentConfigService;
+    constructor(agentConfigService: AgentConfigService);
+    listAgents(): Promise<{
+        success: boolean;
+        data: AgentConfigItem[];
+    }>;
+    getAgent(id: string): Promise<{
+        success: boolean;
+        data: null;
+    } | {
+        success: boolean;
+        data: AgentConfigItem;
+    }>;
+    createAgent(body: {
+        name: string;
+        workspace: string;
+    }): Promise<{
+        success: boolean;
+        data: AgentConfigItem;
+    }>;
+    updateAgent(id: string, body: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers'>>): Promise<{
+        success: boolean;
+        data: AgentConfigItem;
+    }>;
+    deleteAgent(id: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/server/agent-config/agent-config.controller.js

@@ -0,0 +1,83 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Get, Post, Put, Delete, Body, Param } from '@nestjs/common';
+import { AgentConfigService } from './agent-config.service.js';
+let AgentConfigController = class AgentConfigController {
+    agentConfigService;
+    constructor(agentConfigService) {
+        this.agentConfigService = agentConfigService;
+    }
+    async listAgents() {
+        const agents = await this.agentConfigService.listAgents();
+        return { success: true, data: agents };
+    }
+    async getAgent(id) {
+        const agent = await this.agentConfigService.getAgent(id);
+        if (!agent) {
+            return { success: false, data: null };
+        }
+        return { success: true, data: agent };
+    }
+    async createAgent(body) {
+        const agent = await this.agentConfigService.createAgent(body);
+        return { success: true, data: agent };
+    }
+    async updateAgent(id, body) {
+        const agent = await this.agentConfigService.updateAgent(id, body);
+        return { success: true, data: agent };
+    }
+    async deleteAgent(id) {
+        await this.agentConfigService.deleteAgent(id);
+        return { success: true };
+    }
+};
+__decorate([
+    Get(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "listAgents", null);
+__decorate([
+    Get(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "getAgent", null);
+__decorate([
+    Post(),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "createAgent", null);
+__decorate([
+    Put(':id'),
+    __param(0, Param('id')),
+    __param(1, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "updateAgent", null);
+__decorate([
+    Delete(':id'),
+    __param(0, Param('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AgentConfigController.prototype, "deleteAgent", null);
+AgentConfigController = __decorate([
+    Controller('agent-config'),
+    __metadata("design:paramtypes", [AgentConfigService])
+], AgentConfigController);
+export { AgentConfigController };

package/dist/server/agent-config/agent-config.module.d.ts

@@ -0,0 +1,2 @@
+export declare class AgentConfigModule {
+}

package/dist/server/agent-config/agent-config.module.js

@@ -0,0 +1,19 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Module } from '@nestjs/common';
+import { AgentConfigService } from './agent-config.service.js';
+import { AgentConfigController } from './agent-config.controller.js';
+let AgentConfigModule = class AgentConfigModule {
+};
+AgentConfigModule = __decorate([
+    Module({
+        controllers: [AgentConfigController],
+        providers: [AgentConfigService],
+        exports: [AgentConfigService],
+    })
+], AgentConfigModule);
+export { AgentConfigModule };

package/dist/server/agent-config/agent-config.service.d.ts

@@ -0,0 +1,53 @@
+import type { McpServerConfig } from '../../core/mcp/index.js';
+/** 缺省智能体 ID / 工作空间名，不可删除；对应目录 ~/.openbot/workspace/default */
+export declare const DEFAULT_AGENT_ID = "default";
+/**
+ * 智能体列表与配置使用文件存储（~/.openbot/desktop/agents.json），不使用 SQLite。
+ * 会话与消息历史使用 SQLite；Skills、工作空间文档为目录文件管理。
+ */
+export interface AgentConfigItem {
+    id: string;
+    name: string;
+    workspace: string;
+    provider?: string;
+    model?: string;
+    /** 匹配 config.configuredModels 中的 modelItemCode，优先于 provider/model */
+    modelItemCode?: string;
+    /** 是否为系统缺省智能体（主智能体），不可删除 */
+    isDefault?: boolean;
+    /** MCP 服务器配置列表，创建 Session 时传入（与 Skill 类似） */
+    mcpServers?: McpServerConfig[];
+}
+export declare class AgentConfigService {
+    private configDir;
+    private agentsPath;
+    constructor();
+    private ensureConfigDir;
+    private readAgentsFile;
+    private writeAgentsFile;
+    /** 确保 default 工作空间目录存在 */
+    private ensureDefaultWorkspace;
+    private defaultAgent;
+    listAgents(): Promise<AgentConfigItem[]>;
+    getAgent(id: string): Promise<AgentConfigItem | null>;
+    createAgent(params: {
+        name: string;
+        workspace: string;
+    }): Promise<AgentConfigItem>;
+    updateAgent(id: string, updates: Partial<Pick<AgentConfigItem, 'name' | 'provider' | 'model' | 'modelItemCode' | 'mcpServers'>>): Promise<AgentConfigItem>;
+    deleteAgent(id: string): Promise<void>;
+    /**
+     * 根据 config 的 defaultProvider / defaultModel / defaultModelItemCode 及 configuredModels 同步 agents.json 中缺省智能体的 provider、model、modelItemCode。
+     * 在桌面保存配置（如修改默认模型）后调用，保证 agents 与 config 一致。
+     */
+    syncDefaultAgentFromConfig(config: {
+        defaultProvider?: string;
+        defaultModel?: string;
+        defaultModelItemCode?: string;
+        configuredModels?: Array<{
+            provider: string;
+            modelId: string;
+            modelItemCode?: string;
+        }>;
+    }): Promise<void>;
+}