@cicctencent/agent-server 0.1.1

package/README.md

@@ -0,0 +1,235 @@
+# @cicctencent/agent-server
+
+Server-layer toolkit for `@cicctencent/agent-core` — Agent 初始化、SSE 流式推送、内置工具、沙箱、MCP 桥接、知识库、Chat/Settings/Memory/Security 服务，通过 SPI 接口实现可定制性。
+
+**框架无关**：不依赖 Express/Fastify/Koa，通过 `SSEResponse` 接口适配任意 HTTP 框架。
+
+## 架构
+
+```
+┌─────────────────────────────────────────────────┐
+│  Layer 3: 应用层 (如 workai)                    │
+│  路由、认证、DB 模型、业务逻辑、doc-generator    │
+├─────────────────────────────────────────────────┤
+│  Layer 2: @cicctencent/agent-server (本包)      │
+│  Agent 初始化、SSE、Chat、工具、沙箱、MCP 桥接   │
+│  KB、安全审计、连接器框架，通过 SPI 自定义        │
+├─────────────────────────────────────────────────┤
+│  Layer 1: @cicctencent/agent-core               │
+│  纯引擎：LLM 编排、工具执行、MCP、Memory、A2A     │
+└─────────────────────────────────────────────────┘
+```
+
+## 快速开始
+
+```typescript
+import { createAgentServer, createBuiltinTools, createSafetyAuditMiddleware } from '@cicctencent/agent-server';
+import { createLLMProvider } from '@cicctencent/agent-core';
+import express from 'express';
+
+const app = express();
+
+const server = createAgentServer({
+  llmProvider: createLLMProvider({
+    provider: 'openai',
+    model: 'gpt-4',
+    apiKey: process.env.OPENAI_API_KEY!,
+  }),
+  tools: createBuiltinTools(),
+  middleware: [createSafetyAuditMiddleware()],
+});
+
+// runAgentStream 接收 SSEResponse 接口，Express Response 天然兼容
+app.post('/api/work/chat/stream', async (req, res) => {
+  await server.runAgentStream(res, {
+    content: req.body.content,
+    threadId: req.body.threadId,
+  });
+});
+
+app.listen(3000);
+```
+
+## 框架无关
+
+`agent-server` 不依赖任何 HTTP 框架。`runAgentStream` / `reconnectAgentStream` 接收 `SSEResponse` 接口：
+
+```typescript
+interface SSEResponse {
+  write(data: string): void;
+  end(): void;
+  readonly writableEnded: boolean;
+  setHeader(name: string, value: string | number): void;
+  flushHeaders?(): void;
+  status?(code: number): void;
+  json?(data: any): void;
+}
+```
+
+Express `Response`、Fastify `Reply`（适配后）、原生 `http.ServerResponse` 均可适配。
+
+## SPI 自定义
+
+```typescript
+import {
+  createAgentServer,
+  DefaultSettingsProvider,
+  DefaultChatStoreProvider,
+  createBuiltinTools,
+  createSafetyAuditMiddleware,
+} from '@cicctencent/agent-server';
+
+const server = createAgentServer({
+  llmProvider,
+  settingsProvider: new MyDbSettingsProvider(),
+  chatStoreProvider: new MyDbChatStore(),
+  promptBuilder: new MyPromptBuilder(),
+  tools: [...createBuiltinTools(), myCustomTool],
+  middleware: [createSafetyAuditMiddleware(), myAuthMiddleware],
+  connectors: [myCustomAdapter],
+  dataDir: './data',
+});
+```
+
+## SPI 接口
+
+| 接口 | 默认实现 | 用途 |
+|------|---------|------|
+| `SettingsProvider` | `DefaultSettingsProvider` | 设置持久化 |
+| `ChatStoreProvider` | `DefaultChatStoreProvider` | 对话 CRUD + 历史重建 |
+| `PromptBuilderProvider` | `DefaultPromptBuilder` | 系统提示词构建 |
+| `ModelConfigResolver` | — | 模型配置解析 |
+| `MCPServiceProvider` | — | MCP 服务器管理 |
+| `SkillServiceProvider` | — | 技能 CRUD 管理 |
+| `ConnectorServiceProvider` | — | 数据源连接器管理 |
+| `AgentProfileProvider` | `DefaultAgentProfileProvider` | 多 Agent 配置管理 |
+
+## 模块清单
+
+### 核心工厂
+- `createAgentServer(options)` — 创建 AgentServer 实例
+
+### 默认 SPI 实现
+- `DefaultSettingsProvider` — JSON 文件设置存储
+- `DefaultChatStoreProvider` — JSON 文件对话存储 + 历史重建
+- `DefaultAgentProfileProvider` — JSON 文件 Agent Profile 管理
+- `DefaultPromptBuilder` — 系统提示词构建器
+
+### 服务
+- `MemoryService` / `getMemoryService()` — 长期记忆持久化
+- `getEnginePool()` — AgentEngine 实例复用池
+- `getRunRegistry()` — Agent 运行会话注册表
+- `getSecurityPolicy()` / `updateSecurityPolicy()` — 安全策略管理
+- `assessToolRisk()` / `isLowRiskTool()` — 工具风险评估
+- `createPermissionRequest()` / `findApprovedPermission()` — 权限审批
+- `appendAuditLog()` / `listAuditLogs()` — 审计日志
+- `createSafetyAuditMiddleware()` — 安全审计中间件
+- `logEvent()` / `setLogTransport()` — 可观测性
+- `saveArtifact()` / `resolveArtifactPath()` / `getMimeType()` — Artifact 存储
+- `getWorkspaces()` / `createWorkspace()` / `ensureDefaultWorkspace()` — 工作空间 CRUD
+
+### SSE
+- `writeSSE()` / `initSSEResponse()` — SSE 事件写入（框架无关）
+- `runAgentSSEStream()` — Agent SSE 流式推送
+
+### 内置工具
+- `createBuiltinTools()` — 聚合所有内置工具
+- `createFilesystemTools()` — execute_command, read_terminal, write_file, read_file, search_code, edit_file, append_file
+- `createDiscoveryTools()` — read_tool_doc, load_skill, read_tool_result, read_offload
+- `createWebTools()` — web_fetch, http_request, browser_navigate
+- `createMemoryTools()` — save_memory, recall_memory, delete_memory
+- `createSandboxTools()` — run_script, show_widget, save_artifact
+- `createCommunicationTools()` — send_email, create_event, list_events
+- `createAutomationTools()` — create_automation, list_automations, delete_automation
+- `createGitTools()` — git_status, git_diff, git_commit, git_log
+
+### 工具执行器
+- `LocalShellExecutor` — 基于 child_process 的 Shell 执行器
+- `LocalFileSystemExecutor` — 基于 fs/promises 的文件系统执行器
+
+### 沙箱
+- `LocalSandbox` — 进程级沙箱实例（隔离文件系统 + Shell + 脚本执行）
+- `LocalSandboxManager` / `getSandboxManager()` — 沙箱生命周期管理器
+- `ProcessCodeSandbox` — 结构化代码执行沙箱（stdout/stderr/files/charts）
+- `SandboxFileSystemExecutor` — 沙箱内文件系统执行器（路径穿越防护）
+- `SandboxShellExecutor` — 沙箱内 Shell 执行器（命令黑名单 + 环境变量过滤）
+
+### MCP 桥接
+- `ApiBridgeClient` — HTTP API → MCP 桥接客户端
+- `buildFromTemplate` — 通用模板请求构建器（配置驱动）
+- `resolveBodyTemplate()` — `${param|default}` 模板解析
+- `importFromOpenAPI()` — OpenAPI 3.x / Swagger 2.0 → MCP 工具定义
+- 类型：`RequestBuilderFn`, `AuthConfig`, `ResponseConfig`, `TemplateBuilderExtra`
+
+### 知识库
+- `FileKnowledgeBase` — 基于文件的知识库（文档分块 + embedding 存储）
+- `EmbeddingVectorIndex` — 基于 Embedding 的向量索引
+- `parseDocument()` — 文档解析与分块（Markdown/TXT/JSON）
+
+### 连接器
+- `registerAdapter()` / `getAdapter()` — 数据源适配器注册表
+
+### 存储
+- `JsonStore` / `JsonListStore` — 通用 JSON 文件存储
+- `McpServerStore` — 目录型 MCP 服务器存储
+- `getToolResultStore()` — 工具结果存储单例
+- `FileNoteStore` — 工作空间笔记存储（agent.md）
+- `WorkspaceStore` / `getWorkspaceStore()` — 工作空间存储
+- `AutomationStore` / `getAutomationStore()` — 自动化任务存储
+- `AutomationRunStore` / `getAutomationRunStore()` — 自动化执行记录存储
+
+### 数据模型
+- `AutomationEntity` / `AutomationRunEntity` / `AutomationStatus` — 自动化任务类型
+
+### 工具函数
+- `getProjectDataPath()` / `ensureDataDir()` — 数据目录管理
+- `expandEnvVars()` — 环境变量展开
+- `setAppName()` / `getAppName()` — 应用名设置
+- `ensureDefaultData()` — 默认数据文件复制
+
+## AgentServer API
+
+```typescript
+interface AgentServer {
+  agentSystem: AgentSystem;
+  registerTool(tool): void;
+  unregisterTool(name): void;
+  registerMiddleware(mw): void;
+  unregisterMiddleware(name): void;
+  runAgentStream(res: SSEResponse, params, signal?): Promise<void>;
+  reconnectAgentStream(res: SSEResponse, threadId): Promise<void>;
+  getEngineForProfile(profileId?): AgentEngine;
+  abortAgent(threadId): boolean;
+  steerAgent(sessionId, message): boolean;
+  clearEnginePool(): void;
+  refreshLLMConfig(): void;
+  refreshAgentConfig(): void;
+  getRegisteredTools(): ToolInfo[];
+  getLoadedSkills(): SkillInfo[];
+  isAgentAvailable(): boolean;
+  checkRunStatus(threadId): RunStatus;
+  providers: { ... };
+}
+```
+
+## Optional Dependencies
+
+以下依赖为可选（`optionalDependencies`），仅在用到对应功能时需要安装：
+
+| 依赖 | 用途 |
+|------|------|
+| `jsonpath-plus` | MCP api-bridge 响应提取 |
+| `@apidevtools/swagger-parser` | OpenAPI 导入 |
+| `fast-glob` | search_code 工具 |
+| `turndown` / `html-to-text` | web_fetch 工具 HTML 转换 |
+| `cheerio` / `axios` / `socks-proxy-agent` | web_fetch / http_request 工具 |
+| `simple-git` | git 工具 |
+
+未安装时对应工具会在运行时报错，不影响其他功能。
+
+## 构建
+
+```bash
+cd packages/agent-server
+npm run build
+```

package/dist/cjs/agent/agent-server.d.ts

@@ -0,0 +1,6 @@
+import type { AgentServer, AgentServerOptions } from '../types.js';
+/**
+ * 创建 AgentServer 实例
+ */
+export declare function createAgentServer(options: AgentServerOptions): AgentServer;
+//# sourceMappingURL=agent-server.d.ts.map

package/dist/cjs/agent/agent-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-server.d.ts","sourceRoot":"","sources":["../../../src/agent/agent-server.ts"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EACV,WAAW,EACX,kBAAkB,EAKnB,MAAM,aAAa,CAAC;AAarB;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAgV1E"}

package/dist/cjs/agent/agent-server.js

@@ -0,0 +1,412 @@
+"use strict";
+// ============================================================
+// AgentServer Factory — createAgentServer
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAgentServer = createAgentServer;
+const agent_core_1 = require("@cicctencent/agent-core");
+const settings_service_ts_1 = require("../service/settings.service.js");
+const chat_service_ts_1 = require("../service/chat.service.js");
+const agent_profile_service_ts_1 = require("../service/agent-profile.service.js");
+const prompt_builder_ts_1 = require("../prompt/prompt-builder.js");
+const memory_service_ts_1 = require("../service/memory.service.js");
+const engine_pool_ts_1 = require("../service/engine-pool.js");
+const run_registry_ts_1 = require("../service/run-registry.js");
+const sse_handler_ts_1 = require("../sse/sse-handler.js");
+const local_executors_ts_1 = require("../tool/local-executors.js");
+const index_ts_1 = require("../connectors/index.js");
+/**
+ * 创建 AgentServer 实例
+ */
+function createAgentServer(options) {
+    const dataDir = options.dataDir;
+    // ---- 初始化 SPI 提供者 ----
+    const settingsProvider = options.settingsProvider ?? new settings_service_ts_1.DefaultSettingsProvider(dataDir);
+    const chatStoreProvider = options.chatStoreProvider ?? new chat_service_ts_1.DefaultChatStoreProvider(dataDir);
+    const agentProfileProvider = options.agentProfileProvider ?? new agent_profile_service_ts_1.DefaultAgentProfileProvider(dataDir);
+    const promptBuilder = options.promptBuilder ?? new prompt_builder_ts_1.DefaultPromptBuilder();
+    const memoryService = (0, memory_service_ts_1.getMemoryService)(dataDir);
+    // ---- 注册自定义连接器 ----
+    if (options.connectors) {
+        for (const adapter of options.connectors) {
+            (0, index_ts_1.registerAdapter)(adapter);
+        }
+    }
+    // ---- 中间件注册表 ----
+    const registeredMiddlewares = [...(options.middleware || [])];
+    // ---- 共享实例 ----
+    const historyPersistence = new agent_core_1.JsonlHistoryPersistence({ dir: dataDir ? `${dataDir}/history` : 'history' });
+    const usageTracker = new agent_core_1.InMemoryUsageTracker();
+    const shellExecutor = new local_executors_ts_1.LocalShellExecutor();
+    const fsExecutor = new local_executors_ts_1.LocalFileSystemExecutor();
+    let engine = null;
+    let toolRegistry = null;
+    let skillManager = null;
+    let contextManager = null;
+    let llmProvider = options.llmProvider;
+    function getAgentSystem() {
+        if (engine) {
+            return { engine, toolRegistry: toolRegistry, skillManager: skillManager, contextManager: contextManager, llmProvider };
+        }
+        const settings = settingsProvider.getSettings();
+        toolRegistry = new agent_core_1.ToolRegistry();
+        const builtinTools = options.tools ?? [];
+        const extraTools = options.extraTools ?? [];
+        toolRegistry.registerAll([...builtinTools, ...extraTools]);
+        skillManager = new agent_core_1.SkillManager();
+        const skillsDir = options.skillsDir || process.env.SKILLS_DIR || './data/skills';
+        try {
+            skillManager.loadFromDir(skillsDir, 'system');
+        }
+        catch (e) {
+            console.warn('[AgentServer] Failed to load skills from', skillsDir, e);
+        }
+        contextManager = new agent_core_1.ContextManager();
+        const securityGuard = new agent_core_1.SecurityGuard();
+        const config = {
+            llmProvider,
+            toolRegistry,
+            contextManager,
+            skillManager,
+            securityGuard,
+            maxIterations: options.maxIterations ?? 15,
+            maxMessages: options.maxMessages ?? 50,
+            toolTimeout: options.toolTimeout ?? 30000,
+            llmTimeout: options.llmTimeout ?? 120000,
+            basePrompt: options.basePrompt ?? settings.agentConfig?.basePrompt ?? 'You are a helpful AI assistant with access to tools. Use tools when needed to accomplish tasks. Always explain your actions clearly. Respond in the same language as the user.',
+            contextBudget: settings.agentConfig?.contextBudget ?? { maxToolOutput: 8000 },
+            retryPolicy: settings.agentConfig?.retryPolicy ?? { maxRetries: 1, initialDelay: 1000, maxDelay: 30000, backoffFactor: 2 },
+            historyPersistence,
+            usageTracker,
+            middleware: [...registeredMiddlewares],
+        };
+        engine = new agent_core_1.AgentRuntimeBuilder()
+            .withLLMProvider(llmProvider, options.fallbackProvider)
+            .withTools(toolRegistry)
+            .withSkills(skillManager)
+            .withConfig(config)
+            .build().engine;
+        return { engine, toolRegistry, skillManager, contextManager, llmProvider };
+    }
+    function getEngineForProfile(profileId, profileOverride, skipCache = false) {
+        const numericProfileId = profileId != null ? Number(profileId) : undefined;
+        if (numericProfileId !== undefined && (isNaN(numericProfileId) || numericProfileId <= 0)) {
+            return getEngineForProfile(undefined, profileOverride, skipCache);
+        }
+        const pool = (0, engine_pool_ts_1.getEnginePool)();
+        if (!skipCache) {
+            const cached = pool.get(numericProfileId);
+            if (cached)
+                return cached;
+        }
+        const { toolRegistry: baseRegistry, skillManager: baseSkillManager, contextManager: ctxManager } = getAgentSystem();
+        const profile = profileOverride || (numericProfileId ? agentProfileProvider.getProfile(numericProfileId) : agentProfileProvider.getDefaultProfile());
+        if (!profile)
+            return engine;
+        const isDefaultAgent = profile.isDefault === true || profile.agentType === 'default';
+        const agentToolRegistry = new agent_core_1.ToolRegistry();
+        baseRegistry.getDefinitions().forEach(def => {
+            const tool = baseRegistry.get(def.function.name);
+            if (tool && tool.category !== 'mcp')
+                agentToolRegistry.register(tool);
+        });
+        const agentSkillManager = new agent_core_1.SkillManager();
+        const profileSkillIds = new Set(profile.selectedSkills || []);
+        for (const skillId of profileSkillIds) {
+            const skill = baseSkillManager.get(skillId);
+            if (skill)
+                agentSkillManager.register(skill);
+        }
+        const skillRouter = agentSkillManager.getAll().length > 0 ? new agent_core_1.SkillRouter(agentSkillManager) : undefined;
+        const securityGuard = new agent_core_1.SecurityGuard();
+        const memoryPrompt = memoryService.getAllForPrompt(10) || undefined;
+        const settings = settingsProvider.getSettings();
+        const config = {
+            llmProvider,
+            toolRegistry: agentToolRegistry,
+            contextManager: ctxManager,
+            skillManager: agentSkillManager,
+            skillRouter,
+            securityGuard,
+            maxIterations: profile.maxIterations || 15,
+            maxMessages: profile.maxMessages || 50,
+            toolTimeout: profile.toolTimeout || 30000,
+            llmTimeout: 120000,
+            basePrompt: isDefaultAgent
+                ? promptBuilder.buildDefaultPrompt(profile, agentToolRegistry, memoryPrompt)
+                : promptBuilder.buildSpecialistPrompt(profile, agentToolRegistry, agentSkillManager, memoryPrompt),
+            contextBudget: settings.agentConfig?.contextBudget,
+            deniedTools: [...(settings.agentConfig?.deniedTools || []), ...(profile.disabledTools || [])].filter(Boolean),
+            retryPolicy: settings.agentConfig?.retryPolicy || { maxRetries: 1, initialDelay: 1000, maxDelay: 30000, backoffFactor: 2 },
+            historyPersistence,
+            usageTracker,
+            middleware: [...registeredMiddlewares],
+        };
+        const newEngine = new agent_core_1.AgentRuntimeBuilder()
+            .withLLMProvider(llmProvider, options.fallbackProvider)
+            .withTools(agentToolRegistry)
+            .withSkills(agentSkillManager)
+            .withProfile({
+            id: profile.id, name: profile.name, description: profile.description,
+            agentType: profile.agentType, isDefault: profile.isDefault,
+            disabledTools: profile.disabledTools,
+            selectedSkills: profileSkillIds.size > 0 ? [...profileSkillIds] : undefined,
+            alwaysInjectSkills: profile.alwaysInjectSkills,
+            maxIterations: profile.maxIterations || 15, maxMessages: profile.maxMessages || 50,
+            toolTimeout: profile.toolTimeout || 30000, model: profile.model,
+        })
+            .withConfig(config)
+            .build().engine;
+        if (!skipCache)
+            pool.set(numericProfileId, newEngine);
+        return newEngine;
+    }
+    const DB_FLUSH_INTERVAL = 5000;
+    const DB_FLUSH_CHARS = 500;
+    async function runAgentStream(res, params, abortSignal) {
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no');
+        res.flushHeaders();
+        const rawProfileId = params.agentProfileId;
+        const requestedAgentProfileId = rawProfileId != null && rawProfileId !== '' ? Number(rawProfileId) : undefined;
+        const engineInstance = getEngineForProfile(requestedAgentProfileId);
+        const sessionId = params.threadId || `session_${Date.now()}`;
+        const traceId = params.traceId || `trace_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const threadIdNum = Number(sessionId);
+        const registry = (0, run_registry_ts_1.getRunRegistry)(dataDir);
+        const run = registry.startRun(threadIdNum, sessionId, traceId);
+        (0, agent_core_1.logEvent)({ event: 'agent.stream.open', sessionId, data: { threadId: threadIdNum, agentProfileId: requestedAgentProfileId } });
+        if (!isNaN(threadIdNum)) {
+            try {
+                const preMsg = chatStoreProvider.addMessage({ threadId: threadIdNum, role: 'assistant', content: '', type: 'text', meta: { status: 'streaming' } });
+                run.messageId = preMsg.id;
+                registry.setMessageId(threadIdNum, preMsg.id);
+            }
+            catch (err) {
+                console.warn('[AgentServer] Pre-save failed:', err?.message);
+            }
+        }
+        try {
+            if (!isNaN(threadIdNum)) {
+                const history = chatStoreProvider.buildThreadHistory(threadIdNum);
+                if (history.length > 0)
+                    engineInstance.setHistory(sessionId, history);
+            }
+        }
+        catch (err) {
+            console.warn('[AgentServer] History restore failed:', err?.message);
+        }
+        const customContext = { traceId };
+        customContext.toolRegistry = engineInstance.getToolRegistry();
+        customContext.skillManager = engineInstance.getSkillManager();
+        customContext.shell = shellExecutor;
+        customContext.fs = fsExecutor;
+        let memoryOverride;
+        try {
+            const allEntries = memoryService.getAllEntries();
+            if (allEntries.length > 0) {
+                const recallEngine = new agent_core_1.MemoryRecallEngine();
+                const recallResult = await recallEngine.recall((0, agent_core_1.extractTextFromContent)(params.content), allEntries, { maxResults: 5 });
+                const recalled = (0, agent_core_1.formatRecallForPrompt)(recallResult);
+                if (recalled)
+                    memoryOverride = recalled;
+            }
+        }
+        catch (err) {
+            console.warn('[AgentServer] Memory recall failed:', err?.message);
+        }
+        const emitSubEvent = (evt) => { registry.addEvent(threadIdNum, 'sub-agent', evt); };
+        customContext.emitSubEvent = emitSubEvent;
+        const emitWidget = (evt) => { run.widgets.push(evt); registry.addEvent(threadIdNum, 'html-widget', evt); };
+        customContext.emitWidget = emitWidget;
+        const emitArtifact = (artifact) => { run.artifacts.push(artifact); registry.addEvent(threadIdNum, 'file-artifact', artifact); };
+        customContext.emitArtifact = emitArtifact;
+        const unsubscribe = registry.subscribe(threadIdNum, (evt) => {
+            if (!res.writableEnded) {
+                try {
+                    (0, sse_handler_ts_1.writeSSE)(res, evt.event, evt.data);
+                }
+                catch { }
+            }
+        });
+        if (run.messageId)
+            registry.addEvent(threadIdNum, 'message-id', { messageId: run.messageId });
+        let lastFlushedLen = 0;
+        const flushToDB = () => {
+            if (!run.messageId || isNaN(threadIdNum))
+                return;
+            if (run.fullContent.length === lastFlushedLen && run.status === 'running')
+                return;
+            lastFlushedLen = run.fullContent.length;
+            try {
+                chatStoreProvider.updateMessage(threadIdNum, run.messageId, {
+                    content: run.fullContent,
+                    meta: { status: 'streaming', reasoning: run.reasoningText || undefined, toolCalls: run.toolCalls.length > 0 ? run.toolCalls.map(tc => ({ ...tc })) : undefined, widgets: run.widgets.length > 0 ? [...run.widgets] : undefined, artifacts: run.artifacts.length > 0 ? [...run.artifacts] : undefined },
+                });
+            }
+            catch (err) {
+                console.warn('[AgentServer] DB flush failed:', err?.message);
+            }
+        };
+        const dbFlushTimer = setInterval(flushToDB, DB_FLUSH_INTERVAL);
+        if (dbFlushTimer && typeof dbFlushTimer === 'object' && 'unref' in dbFlushTimer)
+            dbFlushTimer.unref();
+        const eventAdapterState = (0, agent_core_1.createAgentEventCollectorState)();
+        if (engineInstance.getHistoryLength(sessionId) === 0) {
+            try {
+                await engineInstance.loadHistory(sessionId);
+            }
+            catch (e) {
+                console.warn(`[AgentServer] History load failed:`, e?.message);
+            }
+        }
+        try {
+            for await (const event of engineInstance.run({ sessionId, message: params.content, abortSignal, context: { sessionId, custom: customContext }, systemPromptOverride: memoryOverride })) {
+                const mapped = (0, agent_core_1.mapAgentEvent)(event, eventAdapterState, { preset: 'sse', toolRegistry: engineInstance.getToolRegistry(), resolveToolDisplayName: (toolName) => promptBuilder.resolveToolDisplayName(toolName, engineInstance.getToolRegistry()) });
+                if (event.type === 'done')
+                    registry.setStepCount(threadIdNum, event.iterations || 0);
+                if (mapped) {
+                    const doneData = mapped.event === 'done' && typeof mapped.data === 'object' && mapped.data ? { ...mapped.data, messageId: run.messageId, reasoning: run.reasoningText || undefined, toolCallDetails: run.toolCalls.length > 0 ? run.toolCalls.map(tc => ({ ...tc })) : undefined } : mapped.data;
+                    registry.addEvent(threadIdNum, mapped.event, doneData);
+                }
+                if (run.fullContent.length - lastFlushedLen >= DB_FLUSH_CHARS)
+                    flushToDB();
+            }
+            registry.finishRun(threadIdNum, 'done');
+            (0, agent_core_1.logEvent)({ event: 'agent.stream.done', sessionId, data: { threadId: threadIdNum, steps: run.stepCount, toolCalls: run.toolCallCount } });
+            if (run.messageId && !isNaN(threadIdNum)) {
+                try {
+                    chatStoreProvider.updateMessage(threadIdNum, run.messageId, { content: run.fullContent, meta: { reasoning: run.reasoningText || undefined, toolCalls: run.toolCalls.length > 0 ? run.toolCalls.map(tc => ({ ...tc })) : undefined, widgets: run.widgets.length > 0 ? [...run.widgets] : undefined, artifacts: run.artifacts.length > 0 ? [...run.artifacts] : undefined } });
+                }
+                catch { }
+            }
+        }
+        catch (err) {
+            registry.finishRun(threadIdNum, 'error', err.message || 'Agent stream failed');
+            (0, agent_core_1.logEvent)({ event: 'agent.stream.error', level: 'error', traceId, sessionId, data: { threadId: threadIdNum, error: err.message || 'Agent stream failed' } });
+            if (run.messageId && !isNaN(threadIdNum)) {
+                try {
+                    chatStoreProvider.updateMessage(threadIdNum, run.messageId, { content: run.fullContent || `Error: ${err.message}`, meta: { status: 'error', error: err.message } });
+                }
+                catch { }
+            }
+        }
+        finally {
+            if (dbFlushTimer)
+                clearInterval(dbFlushTimer);
+            unsubscribe();
+            if (!res.writableEnded)
+                res.end();
+        }
+    }
+    async function reconnectAgentStream(res, threadId) {
+        const registry = (0, run_registry_ts_1.getRunRegistry)(dataDir);
+        const run = registry.getRun(threadId);
+        if (!run) {
+            res.status?.(404);
+            res.json?.({ ret: -1, data: null, msg: 'No active run for this thread' });
+            res.end();
+            return;
+        }
+        (0, agent_core_1.logEvent)({ event: 'agent.stream.reconnect', data: { threadId } });
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no');
+        res.flushHeaders();
+        const replayBound = run.eventBuffer.length;
+        const unsubscribe = registry.subscribe(threadId, (evt) => { if (!res.writableEnded) {
+            try {
+                (0, sse_handler_ts_1.writeSSE)(res, evt.event, evt.data);
+            }
+            catch { }
+        } });
+        for (let i = 0; i < replayBound; i++) {
+            if (res.writableEnded) {
+                unsubscribe();
+                return;
+            }
+            const evt = run.eventBuffer[i];
+            if (evt)
+                (0, sse_handler_ts_1.writeSSE)(res, evt.event, evt.data);
+        }
+        if (run.status !== 'running') {
+            unsubscribe();
+            if (!res.writableEnded)
+                res.end();
+            return;
+        }
+        try {
+            while (!res.writableEnded) {
+                const currentRun = registry.getRun(threadId);
+                if (!currentRun || currentRun.status !== 'running') {
+                    if (currentRun && !res.writableEnded) {
+                        const finalEvt = currentRun.status === 'error' ? { event: 'error', data: { error: currentRun.error || 'Agent execution failed' } } : { event: 'done', data: { text: currentRun.fullContent || '', steps: currentRun.stepCount, toolCalls: currentRun.toolCallCount } };
+                        try {
+                            (0, sse_handler_ts_1.writeSSE)(res, finalEvt.event, finalEvt.data);
+                        }
+                        catch { }
+                    }
+                    break;
+                }
+                await new Promise(r => setTimeout(r, 500));
+            }
+        }
+        finally {
+            unsubscribe();
+            if (!res.writableEnded)
+                res.end();
+        }
+    }
+    const server = {
+        agentSystem: { get engine() { return getAgentSystem().engine; }, get toolRegistry() { return getAgentSystem().toolRegistry; }, get skillManager() { return getAgentSystem().skillManager; }, get contextManager() { return getAgentSystem().contextManager; }, get llmProvider() { return getAgentSystem().llmProvider; } },
+        registerTool(tool) { const { toolRegistry: reg } = getAgentSystem(); if (!reg.has(tool.definition.function.name))
+            reg.register(tool); },
+        unregisterTool(name) { const { toolRegistry: reg } = getAgentSystem(); reg.unregister(name); },
+        registerMiddleware(mw) { if (registeredMiddlewares.some(m => m.name === mw.name))
+            return; registeredMiddlewares.push(mw); if (engine)
+            engine.config.middleware = [...registeredMiddlewares]; },
+        unregisterMiddleware(name) { const idx = registeredMiddlewares.findIndex(m => m.name === name); if (idx >= 0) {
+            registeredMiddlewares.splice(idx, 1);
+            if (engine)
+                engine.config.middleware = [...registeredMiddlewares];
+        } },
+        runAgentStream, reconnectAgentStream, getEngineForProfile,
+        getEngine() { return engine; },
+        abortAgent(threadId) { const registry = (0, run_registry_ts_1.getRunRegistry)(dataDir); const run = registry.getRun(threadId); if (!run)
+            return false; if (engine)
+            engine.abort(String(threadId)); registry.finishRun(threadId, 'error', 'Aborted by user'); return true; },
+        steerAgent(sessionId, message) { if (!engine)
+            return false; return engine.steer(sessionId, message); },
+        clearEnginePool() { (0, engine_pool_ts_1.getEnginePool)().clear(); },
+        refreshLLMConfig() { (0, engine_pool_ts_1.getEnginePool)().clear(); console.log('[AgentServer] LLM config refreshed — engine pool cleared'); },
+        refreshAgentConfig() { if (!engine)
+            return; const settings = settingsProvider.getSettings(); const securityGuard = new agent_core_1.SecurityGuard(); const config = { llmProvider, toolRegistry: toolRegistry, contextManager: contextManager, skillManager: skillManager, securityGuard, maxIterations: settings.agentConfig?.maxIterations || 15, maxMessages: settings.agentConfig?.maxMessages || 50, toolTimeout: settings.agentConfig?.toolTimeout || 30000, llmTimeout: 120000, basePrompt: settings.agentConfig?.basePrompt || 'You are a helpful AI assistant with access to tools. Use tools when needed to accomplish tasks. Always explain your actions clearly. Respond in the same language as the user.', historyPersistence, usageTracker, middleware: [...registeredMiddlewares] }; engine.destroy(); engine = new agent_core_1.AgentRuntimeBuilder().withLLMProvider(llmProvider).withTools(toolRegistry).withSkills(skillManager).withConfig(config).build().engine; console.log('[AgentServer] Agent engine refreshed'); },
+        async refreshMCPTools() { return { connected: 0, tools: 0, errors: ['MCP sync not configured'] }; },
+        getRegisteredTools() { const { toolRegistry: reg } = getAgentSystem(); return reg.getDefinitions().map(d => { const tool = reg.get(d.function.name); return { name: d.function.name, description: d.function.description, category: tool?.category || 'builtin' }; }); },
+        getLoadedSkills() { const { skillManager: sm } = getAgentSystem(); return sm.getAll().map(s => ({ id: s.id, name: s.name, description: s.description, tags: s.tags, content: s.content })); },
+        getRegisteredMiddlewares() { return registeredMiddlewares; },
+        getUsageStats(filter) { return usageTracker.stats(filter); },
+        isAgentAvailable() { const settings = settingsProvider.getSettings(); if (settings.modelProviders && settings.modelProviders.length > 0) {
+            return !!settings.modelProviders.find(mp => mp.apiKey || mp.provider === 'ollama');
+        } return !!(settings.apiKeys.openai || settings.apiKeys.anthropic || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY); },
+        getAgentUnavailableReason() { const settings = settingsProvider.getSettings(); if (!settings.modelProviders || settings.modelProviders.length === 0)
+            return '未配置任何模型供应商。请在「设置」页面添加模型配置。'; const available = settings.modelProviders.find(mp => mp.apiKey || mp.provider === 'ollama'); if (!available)
+            return '已配置模型供应商，但缺少 API Key。请在「设置」页面填写 API Key。'; return 'AI 服务不可用，请检查设置中的供应商和 API Key 配置'; },
+        checkRunStatus(threadId) { const registry = (0, run_registry_ts_1.getRunRegistry)(dataDir); const run = registry.getRun(threadId); if (!run) {
+            const snapshot = registry.getRunSnapshot(threadId);
+            return { hasActiveRun: false, status: snapshot?.status || 'no_run', messageId: snapshot?.messageId, eventCount: 0, checkpointCount: 0 };
+        } return { hasActiveRun: run.status === 'running', status: run.status, messageId: run.messageId, eventCount: run.eventBuffer.length, checkpointCount: run.checkpoints.length }; },
+        providers: { settings: settingsProvider, chatStore: chatStoreProvider, promptBuilder, modelConfigResolver: options.modelConfigResolver, mcpService: options.mcpServiceProvider, skillService: options.skillServiceProvider, connectorService: options.connectorServiceProvider, agentProfile: agentProfileProvider },
+    };
+    setTimeout(() => { try {
+        getAgentSystem();
+    }
+    catch { } }, 2000);
+    if (options.onInit)
+        options.onInit(server);
+    return server;
+}
+//# sourceMappingURL=agent-server.js.map