@next-open-ai/openbot 0.1.1

package/README.md

@@ -0,0 +1,212 @@
+# OpenBot
+
+[![Node.js](https://img.shields.io/badge/Node.js-20+-green.svg)](https://nodejs.org/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue.svg)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**OpenBot** 是基于 Agent Skills 与编码智能体（Coding Agent）的**一体化 AI 助手平台**，支持 CLI、WebSocket 网关与桌面端。通过可插拔技能（Skills）、浏览器自动化、代码执行与长期记忆，为开发与日常任务提供可扩展的 AI 工作流。
+
+---
+
+## 特性概览
+
+| 能力 | 说明 |
+|------|------|
+| **技能架构** | 基于 Cursor Agent Skills 规范，支持多路径加载、本地安装与动态扩展 |
+| **编码智能体** | 集成 [pi-coding-agent](https://www.npmjs.com/package/@mariozechner/pi-coding-agent)，支持多轮工具调用与代码执行 |
+| **浏览器自动化** | 内置 [agent-browser](https://www.npmjs.com/package/agent-browser)，可导航、填表、截图与数据抓取 |
+| **长期记忆** | 向量存储（Vectra）+ 本地嵌入，支持经验总结与会话压缩（compaction） |
+| **多端接入** | CLI、WebSocket 网关、Electron 桌面端，同一套 Agent 核心 |
+
+---
+
+## 技术架构
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                              客户端 / 接入层                                  │
+├─────────────────┬─────────────────────────────┬─────────────────────────────┤
+│   CLI (openbot) │   WebSocket Gateway (JSON-RPC)  │   OpenBot Desktop (Electron)  │
+│   Commander     │   ws, 端口 3000               │   Vue 3 + Pinia + Vite       │
+└────────┬────────┴──────────────┬──────────────┴──────────────┬──────────────┘
+         │                        │                             │
+         │                        │  HTTP + Socket.io            │
+         ▼                        ▼                             ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                            Gateway Server (Node)                             │
+│  • 静态资源 • 自动发现端口 • 子进程拉起 Desktop Server                        │
+└────────────────────────────────────┬────────────────────────────────────────┘
+                                      │
+         ┌────────────────────────────┼────────────────────────────┐
+         ▼                            ▼                            ▼
+┌─────────────────┐    ┌─────────────────────────────┐    ┌─────────────────────┐
+│  Agent 核心      │    │  Desktop Backend (NestJS)   │    │  Memory / 向量存储   │
+│  AgentManager   │    │  server-api/*               │    │  Vectra + 嵌入       │
+│  pi-coding-agent│    │  Agents · Skills · Tasks    │    │  compaction 扩展     │
+│  pi-ai 多模型   │    │  Auth · Users · Workspace   │    │  better-sqlite3      │
+└────────┬────────┘    └─────────────────────────────┘    └─────────────────────┘
+         │
+         ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│  Tools: read/write/edit · bash · find/grep/ls · browser · install-skill ·   │
+│         save-experience (写入记忆)                                            │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+- **CLI**：直接调用 Agent 核心，单次提示或批量脚本。
+- **Gateway**：对外提供 WebSocket（JSON-RPC），供 Web/移动端连接；内部负责起端口、拉 Nest 后端、路由请求。
+- **Desktop**：Electron 包一层 Vue 前端 + 本地 Nest 后端，通过 Gateway 或直连后端与 Agent 通信；技能、会话、任务、工作区等由 Nest 模块管理。
+- **Agent 核心**：统一由 `AgentManager` 管理会话、技能注入与工具注册；记忆与 compaction 作为扩展参与 system prompt 与经验写入。
+
+---
+
+## 各端技术栈
+
+### CLI
+
+| 类别 | 技术 |
+|------|------|
+| 运行时 | Node.js 20+ |
+| 语言 | TypeScript 5.7 |
+| 入口 | `openbot`（bin → `dist/cli.js`） |
+| 框架 | Commander（子命令：`gateway`、`login`、`config`） |
+| 配置 | `~/.openbot/agent`（API Key、模型、技能等） |
+
+### WebSocket Gateway
+
+| 类别 | 技术 |
+|------|------|
+| 协议 | JSON-RPC over WebSocket（`ws`） |
+| 端口 | 默认 3000，可 `-p` 指定 |
+| 职责 | 连接管理、消息路由、静态资源、拉 Nest 子进程 |
+| 方法 | `connect`、`agent.chat`、`agent.cancel`、`subscribe_session`、`unsubscribe_session` 等 |
+
+### Agent 核心
+
+| 类别 | 技术 |
+|------|------|
+| 智能体 | @mariozechner/pi-coding-agent |
+| 模型/Provider | @mariozechner/pi-ai（DeepSeek、DashScope、OpenAI 等） |
+| 工具 | read/write/edit、bash、find/grep/ls、browser、install-skill、save-experience |
+| 技能 | SKILL.md 规范，多路径加载，formatSkillsForPrompt 注入 system prompt |
+
+### Desktop 后端（NestJS）
+
+| 类别 | 技术 |
+|------|------|
+| 框架 | NestJS 10、Express、Socket.io |
+| 前缀 | `server-api` |
+| 模块 | Database · Agents · AgentConfig · Skills · Config · Auth · Users · Workspace · Tasks · Usage |
+| 数据 | better-sqlite3（若使用本地库） |
+
+### Desktop 前端（Electron + Vue）
+
+| 类别 | 技术 |
+|------|------|
+| 壳子 | Electron 28 |
+| 前端 | Vue 3、Vue Router、Pinia |
+| 构建 | Vite 5 |
+| 通信 | axios、socket.io-client |
+| 视图 | Dashboard、Agents、AgentChat/AgentDetail、Sessions、Skills、Settings、Tasks、WorkResults、Workspace、Login |
+| 国际化 | 自研 useI18n + locales (zh/en) |
+
+### 记忆与向量
+
+| 类别 | 技术 |
+|------|------|
+| 向量索引 | Vectra（LocalIndex） |
+| 嵌入 | @xenova/transformers（本地模型） |
+| 扩展 | compaction-extension（会话压缩、摘要入 prompt） |
+| 持久化 | 与 agent 目录一致的 memory 目录、better-sqlite3（若用于元数据） |
+
+### 内置技能
+
+| 技能 | 说明 |
+|------|------|
+| find-skills | 发现与安装 Cursor/Agent 技能 |
+| agent-browser | 浏览器自动化（Playwright/agent-browser CLI） |
+
+---
+
+## 快速开始
+
+### 环境要求
+
+- **Node.js** ≥ 20
+- 可选：`OPENAI_API_KEY` 或 `DEEPSEEK_API_KEY` 等（按所用 provider 配置）
+
+### 安装与构建
+
+```bash
+npm install
+npm run build
+```
+
+### CLI 使用
+
+```bash
+# 直接对话（使用默认 workspace 与技能）
+openbot "总结一下当前有哪些技能"
+
+# 指定技能路径
+openbot -s ./skills "用 find-skills 搜一下 PDF 相关技能"
+
+# 仅打印 system/user prompt，不调 LLM
+openbot --dry-run --prompt "查北京天气"
+
+# 指定模型与 provider
+openbot --model deepseek-chat --provider deepseek "写一段 TypeScript 示例"
+```
+
+### 启动 WebSocket 网关
+
+```bash
+openbot gateway --port 3000
+```
+
+客户端通过 `ws://localhost:3000` 连接，使用 JSON-RPC 调用 `connect`、`agent.chat` 等。
+
+### 启动桌面端
+
+```bash
+# 先构建核心（若未构建）
+npm run build
+
+# 开发模式（Vite 热更 + Electron）
+npm run desktop:dev
+
+# 仅安装桌面依赖
+npm run desktop:install
+```
+
+---
+
+## Gateway API 简述
+
+- **请求**：`{ "type": "request", "id": "<id>", "method": "<method>", "params": { ... } }`
+- **成功响应**：`{ "type": "response", "id": "<id>", "result": { ... } }`
+- **错误响应**：`{ "type": "response", "id": "<id>", "error": { "message": "..." } }`
+- **服务端事件**：如 `agent.chunk`（流式输出）、`agent.tool`（工具调用）等，格式为 `{ "type": "event", "event": "...", "payload": { ... } }`
+
+常用方法：先 `connect` 建立会话，再通过 `agent.chat` 发送消息并接收流式/事件；`agent.cancel` 取消当前任务。
+
+---
+
+## 开发
+
+```bash
+# 单元/集成测试
+npm test
+
+# 仅 e2e
+npm run test:e2e
+
+# 记忆相关测试
+npm run test:memory
+```
+
+---
+
+## 许可证
+
+MIT

package/dist/agent/agent-dir.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 获取 openbot agent 配置目录（默认 ~/.openbot/agent）
+ * 可通过环境变量 OPENBOT_AGENT_DIR 覆盖
+ */
+export declare function getOpenbotAgentDir(): string;
+/**
+ * 获取 openbot 工作空间根目录（默认 ~/.openbot/workspace）
+ * 可通过环境变量 OPENBOT_WORKSPACE_DIR 覆盖
+ */
+export declare function getOpenbotWorkspaceDir(): string;
+/**
+ * 确保 agent 目录存在，并创建默认配置文件
+ */
+export declare function ensureDefaultAgentDir(agentDir: string): void;

package/dist/agent/agent-dir.js

@@ -0,0 +1,75 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * 获取 openbot agent 配置目录（默认 ~/.openbot/agent）
+ * 可通过环境变量 OPENBOT_AGENT_DIR 覆盖
+ */
+export function getOpenbotAgentDir() {
+    return process.env.OPENBOT_AGENT_DIR ?? join(homedir(), ".openbot", "agent");
+}
+/**
+ * 获取 openbot 工作空间根目录（默认 ~/.openbot/workspace）
+ * 可通过环境变量 OPENBOT_WORKSPACE_DIR 覆盖
+ */
+export function getOpenbotWorkspaceDir() {
+    return process.env.OPENBOT_WORKSPACE_DIR ?? join(homedir(), ".openbot", "workspace");
+}
+/**
+ * 确保 agent 目录存在，并创建默认配置文件
+ */
+export function ensureDefaultAgentDir(agentDir) {
+    if (!existsSync(agentDir)) {
+        mkdirSync(agentDir, { recursive: true });
+    }
+    const modelsJsonPath = join(agentDir, "models.json");
+    if (!existsSync(modelsJsonPath)) {
+        const defaultModels = {
+            providers: {
+                deepseek: {
+                    name: "DeepSeek",
+                    apiKey: "OPENAI_API_KEY",
+                    api: "openai-completions",
+                    baseUrl: "https://api.deepseek.com/v1",
+                    authHeader: true,
+                    models: [
+                        {
+                            id: "deepseek-chat",
+                            name: "DeepSeek Chat",
+                            contextWindow: 64000,
+                            supportsTools: true
+                        },
+                        {
+                            id: "deepseek-reasoner",
+                            name: "DeepSeek Reasoner",
+                            contextWindow: 64000,
+                            supportsTools: true
+                        }
+                    ]
+                },
+                dashscope: {
+                    name: "DashScope (Alibaba)",
+                    apiKey: "DASHSCOPE_API_KEY",
+                    api: "openai-completions",
+                    baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+                    authHeader: true,
+                    models: [
+                        {
+                            id: "qwen-max",
+                            name: "Qwen Max",
+                            contextWindow: 30000,
+                            supportsTools: true
+                        },
+                        {
+                            id: "qwen-plus",
+                            name: "Qwen Plus",
+                            contextWindow: 128000,
+                            supportsTools: true
+                        }
+                    ]
+                }
+            }
+        };
+        writeFileSync(modelsJsonPath, JSON.stringify(defaultModels, null, 2), "utf-8");
+    }
+}

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

@@ -0,0 +1,61 @@
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { Skill } from "./skills.js";
+export interface AgentManagerOptions {
+    agentDir?: string;
+    workspace?: string;
+    skillPaths?: string[];
+    skills?: Skill[];
+}
+/**
+ * Unified Agent Manager for both CLI and Gateway
+ */
+export declare class AgentManager {
+    private sessions;
+    /** 每个 session 最后被使用的时间戳，用于 LRU 淘汰 */
+    private sessionLastActiveAt;
+    private agentDir;
+    private workspaceDir;
+    private skillPaths;
+    private preLoadedSkills;
+    constructor(options?: AgentManagerOptions);
+    /**
+     * Re-configure the manager
+     */
+    configure(options: AgentManagerOptions): void;
+    /**
+     * Build system prompt with skills and browser tool description
+     */
+    buildSystemPrompt(skills: Skill[]): string;
+    /**
+     * Get the initial context (prompt and skills)
+     */
+    getContext(): Promise<{
+        systemPrompt: string;
+        skills: Skill[];
+    }>;
+    private createResourceLoader;
+    /**
+     * Resolve all relevant skill paths (Global, Project, Workspace)
+     * @param workspaceDir 当前会话使用的工作区目录，不传则用 manager 默认
+     */
+    private resolveSkillPaths;
+    /**
+     * 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）
+     */
+    getOrCreateSession(sessionId: string, options?: {
+        workspace?: string;
+        provider?: string;
+        modelId?: string;
+        apiKey?: string;
+        maxSessions?: number;
+        targetAgentId?: string;
+    }): Promise<AgentSession>;
+    getSession(sessionId: string): AgentSession | undefined;
+    deleteSession(sessionId: string): boolean;
+    clearAll(): void;
+}
+export declare const agentManager: AgentManager;

package/dist/agent/agent-manager.js

@@ -0,0 +1,257 @@
+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 } from "../tools/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;
+                }
+                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;
+            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 { session } = await createAgentSession({
+            agentDir: this.agentDir,
+            sessionManager: CoreSessionManager.inMemory(),
+            authStorage,
+            modelRegistry,
+            cwd: sessionWorkspaceDir,
+            resourceLoader: loader,
+            customTools: [
+                createBrowserTool(sessionWorkspaceDir),
+                createSaveExperienceTool(sessionId),
+                createInstallSkillTool(options.targetAgentId),
+            ],
+            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/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[];
+}