evolclaw 2.1.2 → 2.2.0

package/README.md

@@ -35,7 +35,7 @@ EvolClaw 是一个轻量级 AI Agent 网关，基于 Claude Agent SDK 构建。
 
 ### 核心组件
 
-1. **消息渠道层** (`src/channels/`) - Feishu WebSocket + WeChat HTTP 长轮询
+1. **消息渠道层** (`src/channels/`) - Feishu WebSocket + WeChat HTTP 长轮询 + AUN Mesh 网络
 2. **消息队列层** (`src/core/message-queue.ts`) - 会话级串行处理 + 中断支持
 3. **命令处理层** (`src/core/command-handler.ts`) - 斜杠命令处理（CommandHandler 类）
 4. **消息处理层** (`src/core/message-processor.ts`) - 统一事件处理引擎
@@ -106,6 +106,9 @@ evolclaw init feishu
 
 # 单独配置微信（扫码登录）
 evolclaw init wechat
+
+# 单独配置 AUN（Mesh 网络通道）
+evolclaw init aun
 ```
 
 交互式引导完成以下配置：
@@ -173,7 +176,8 @@ evolclaw/
 │   │   └── message-cache.ts         # 消息缓存
 │   ├── channels/
 │   │   ├── feishu.ts               # 飞书 WebSocket 渠道
-│   │   └── wechat.ts               # 微信 ClawBot 渠道
+│   │   ├── wechat.ts               # 微信 ClawBot 渠道
+│   │   └── aun.ts                  # AUN Mesh 网络渠道
 │   ├── utils/                      # 工具函数
 │   ├── types.ts                    # 类型定义
 │   ├── config.ts                   # 配置加载
@@ -209,6 +213,8 @@ evolclaw/
 - `/clear` - 清空对话历史
 - `/compact` - 压缩会话上下文
 - `/stop` - 中断当前任务
+- `/send <文件路径>` - 发送文件给用户
+- `/check` - 系统健康检查面板
 - `/restart` - 重启服务（自愈机制）
 - `/repair` - 检查并修复会话
 - `/safe` - 进入安全模式
@@ -224,7 +230,7 @@ evolclaw/
 
 - **运行时**：Node.js >= 22 + TypeScript（ES modules）
 - **AI SDK**：@anthropic-ai/claude-agent-sdk >= 0.2.75
-- **消息渠道**：飞书（@larksuiteoapi/node-sdk）、微信（ClawBot ilink API）
+- **消息渠道**：飞书（@larksuiteoapi/node-sdk）、微信（ClawBot ilink API）、AUN Mesh 网络
 - **数据存储**：node:sqlite（内置模块）+ JSONL（CLI 共用）
 - **测试框架**：Vitest
 
@@ -232,6 +238,7 @@ evolclaw/
 
 - [x] Windows 系统 CLI 命令支持
 - [x] 微信插件支持图片/文件的收发
+- [x] AUN Mesh 网络通道接入
 - [ ] 自动授权可配置（自动放行/自动拒绝）
 - [ ] 手动授权支持（飞书卡片/文本回复）
 - [ ] ACP 协议支持（接入 Codex / Gemini CLI）

package/data/evolclaw.sample.json

@@ -2,9 +2,17 @@
   "agents": {
     "anthropic": {
       "model": "sonnet"
-    }
+    },
+    "openai": {
+      "apiKey": "your-openai-api-key",
+      "baseUrl": "https://api.openai.com/v1",
+      "model": "gpt-5.2-codex",
+      "effort": "medium"
+    },
+    "defaultAgent": "claude"
   },
   "channels": {
+    "defaultChannel": "feishu",
     "feishu": {
       "enabled": true,
       "appId": "",

package/dist/agents/claude-runner.js

@@ -0,0 +1,612 @@
+import { query, forkSession as sdkForkSession } from '@anthropic-ai/claude-agent-sdk';
+import { ensureDir, resolveAnthropicConfig } from '../config.js';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { logger } from '../utils/logger.js';
+import { checkBlacklist, summarizeToolInput } from '../utils/permission-utils.js';
+import { encodePath } from '../utils/cross-platform.js';
+class MessageStream {
+    queue = [];
+    waiting = null;
+    done = false;
+    push(text, images) {
+        let content;
+        if (images && images.length > 0) {
+            logger.debug('[MessageStream] Creating multimodal message with', images.length, 'images');
+            content = [
+                { type: 'text', text },
+                ...images.map((img) => ({
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: img.mimeType || 'image/png',
+                        data: img.data,
+                    },
+                })),
+            ];
+        }
+        else {
+            content = text;
+        }
+        const message = {
+            type: 'user',
+            message: { role: 'user', content },
+            parent_tool_use_id: null,
+            session_id: '',
+        };
+        this.queue.push(message);
+        this.waiting?.();
+    }
+    end() {
+        this.done = true;
+        this.waiting?.();
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            while (this.queue.length > 0) {
+                yield this.queue.shift();
+            }
+            if (this.done)
+                return;
+            await new Promise((r) => {
+                this.waiting = r;
+            });
+            this.waiting = null;
+        }
+    }
+}
+// ── 类型守卫 ──
+export function hasModelSwitcher(agent) {
+    return typeof agent.setModel === 'function' && typeof agent.listModels === 'function';
+}
+export function hasPermissionController(agent) {
+    return typeof agent.setMode === 'function' && typeof agent.listModes === 'function';
+}
+export function hasCompact(agent) {
+    return typeof agent.compact === 'function';
+}
+export class AgentRunner {
+    name = 'claude';
+    capabilities = { clear: true, compact: true, fork: true };
+    apiKey;
+    model;
+    effort;
+    permissionMode = 'default'; // default = 全部自动放行
+    baseUrl;
+    config;
+    activeSessions = new Map();
+    activeStreams = new Map();
+    interruptFns = new Map();
+    onSessionIdUpdate;
+    onCompactStart;
+    permissionGateway;
+    sendPromptFn;
+    constructor(apiKey, model, onSessionIdUpdate, baseUrl, config) {
+        this.apiKey = apiKey;
+        this.model = model || 'sonnet';
+        this.effort = undefined;
+        this.baseUrl = baseUrl;
+        this.config = config;
+        this.onSessionIdUpdate = onSessionIdUpdate;
+    }
+    getAgentEnv() {
+        return {
+            ...process.env,
+            ANTHROPIC_AUTH_TOKEN: this.apiKey,
+            PATH: process.env.PATH,
+            DISABLE_AUTOUPDATER: '1',
+            ...(this.baseUrl ? { ANTHROPIC_BASE_URL: this.baseUrl } : {})
+        };
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    getModel() {
+        return this.model;
+    }
+    listModels() {
+        return ['opus', 'sonnet', 'haiku'];
+    }
+    setEffort(effort) {
+        this.effort = effort;
+    }
+    getEffort() {
+        return this.effort;
+    }
+    // ── PermissionController 接口 ──
+    setMode(mode) {
+        this.permissionMode = mode;
+    }
+    getMode() {
+        return this.permissionMode;
+    }
+    listModes() {
+        return [
+            { key: 'default', nameZh: '默认', description: '全部自动放行', available: true },
+            { key: 'request', nameZh: '审批', description: '部分自动，部分询问', available: true },
+            { key: 'edit', nameZh: '编辑', description: '自动接受编辑，其他询问', available: true },
+            { key: 'plan', nameZh: '规划', description: '只规划不执行', available: true },
+            { key: 'noask', nameZh: '静默', description: '未批准则拒绝', available: true },
+        ];
+    }
+    setPermissionGateway(gateway) {
+        this.permissionGateway = gateway;
+    }
+    setSendPrompt(fn) {
+        this.sendPromptFn = fn;
+    }
+    toSdkPermissionMode() {
+        const map = {
+            'default': 'default', // 全部自动放行，靠 canUseTool 一律 allow 实现
+            'request': 'default', // 部分自动，部分询问
+            'edit': 'acceptEdits',
+            'plan': 'plan',
+            'noask': 'dontAsk',
+        };
+        return map[this.permissionMode] || 'default';
+    }
+    // ── Compactable 接口 ──
+    async compact(sessionId, agentSessionId, projectPath) {
+        return this.compactSession(sessionId, agentSessionId, projectPath);
+    }
+    syncFromUserSettings() {
+        try {
+            const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+            if (!fs.existsSync(settingsPath))
+                return;
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            if (settings.model && settings.model !== this.model) {
+                logger.info(`[AgentRunner] Synced model from ~/.claude/settings.json: ${settings.model}`);
+                this.model = settings.model;
+            }
+            const newEffort = settings.effortLevel || undefined;
+            if (newEffort !== this.effort) {
+                logger.info(`[AgentRunner] Synced effort from ~/.claude/settings.json: ${newEffort ?? 'auto'}`);
+                this.effort = newEffort;
+            }
+        }
+        catch (error) {
+            logger.debug(`[AgentRunner] Failed to sync from ~/.claude/settings.json:`, error);
+        }
+    }
+    setCompactStartCallback(callback) {
+        this.onCompactStart = callback;
+    }
+    /**
+     * SDK 原始事件 → 标准 AgentEvent 转换
+     * 所有 SDK 特有的事件类型引用封装在此方法内
+     */
+    async *transformStream(sdkStream, sessionId) {
+        let hasTextDelta = false;
+        let lastSessionId;
+        // tool_use_id → tool_name 映射，用于从 SDKUserMessage 的 tool_result 块中还原工具名
+        const toolUseNames = new Map();
+        for await (const event of sdkStream) {
+            // 提取 session_id（任意 SDK 事件都可能携带）
+            if (event.session_id && event.session_id !== lastSessionId) {
+                lastSessionId = event.session_id;
+                this.updateSessionId(sessionId, event.session_id);
+                yield { type: 'session_id', sessionId: event.session_id };
+            }
+            // text_delta → text
+            if (event.type === 'text_delta' && event.text) {
+                hasTextDelta = true;
+                yield { type: 'text', text: event.text };
+            }
+            // system: compact_boundary → compact
+            if (event.type === 'system' && event.subtype === 'compact_boundary') {
+                yield { type: 'compact', preTokens: event.compact_metadata?.pre_tokens || 0 };
+            }
+            // system: task_progress → task_progress
+            if (event.type === 'system' && event.subtype === 'task_progress') {
+                yield {
+                    type: 'task_progress',
+                    summary: event.summary,
+                    toolUses: event.tool_uses,
+                    durationMs: event.duration_ms,
+                };
+            }
+            // assistant: 提取 tool_use 和文本（仅无 text_delta 时提取文本）
+            if (event.type === 'assistant' && event.message?.content) {
+                for (const content of event.message.content) {
+                    if (content.type === 'tool_use') {
+                        // 记录 id → name 映射，供后续 tool_result 使用
+                        if (content.id)
+                            toolUseNames.set(content.id, content.name);
+                        yield { type: 'tool_use', name: content.name, input: content.input };
+                    }
+                    else if (content.type === 'text' && content.text && !hasTextDelta) {
+                        yield { type: 'text', text: content.text };
+                    }
+                }
+            }
+            // user: 提取 tool_result 块（SDK 将工具结果嵌套在 SDKUserMessage 中）
+            if (event.type === 'user' && event.message?.content) {
+                const contentArray = Array.isArray(event.message.content) ? event.message.content : [];
+                for (const block of contentArray) {
+                    if (typeof block === 'object' && block !== null && block.type === 'tool_result') {
+                        const toolName = toolUseNames.get(block.tool_use_id) || '';
+                        const resultContent = typeof block.content === 'string'
+                            ? block.content
+                            : block.content != null ? JSON.stringify(block.content) : '';
+                        yield {
+                            type: 'tool_result',
+                            name: toolName,
+                            result: resultContent,
+                            isError: block.is_error === true,
+                            error: block.is_error === true ? resultContent : undefined,
+                        };
+                    }
+                }
+            }
+            // result → complete（含 permission_denials 提取）
+            if (event.type === 'result') {
+                // 先发出被拒绝的权限事件
+                if (Array.isArray(event.permission_denials)) {
+                    for (const denial of event.permission_denials) {
+                        yield {
+                            type: 'tool_result',
+                            name: denial.tool_name || '',
+                            result: '',
+                            isError: true,
+                            error: `权限被拒绝: ${denial.tool_name}`,
+                        };
+                    }
+                }
+                yield {
+                    type: 'complete',
+                    result: event.result,
+                    subtype: event.subtype,
+                    isError: event.is_error,
+                    errors: event.errors,
+                    durationMs: event.duration_ms,
+                    costUsd: event.total_cost_usd,
+                };
+            }
+        }
+    }
+    async runQuery(sessionId, prompt, projectPath, initialClaudeSessionId, images, systemPromptAppend, sessionManager) {
+        // 同步用户级配置到内存
+        this.syncFromUserSettings();
+        ensureDir(projectPath);
+        ensureDir(path.join(projectPath, '.claude'));
+        // 优先使用传入的 agentSessionId（从数据库恢复），否则使用内存中的
+        let agentSessionId = initialClaudeSessionId || this.activeSessions.get(sessionId);
+        // 检查是否在安全模式
+        let skipResume = false;
+        if (sessionManager) {
+            const health = await sessionManager.getHealthStatus(sessionId);
+            if (health.safeMode) {
+                // 安全模式：不使用 resume，每次都是新对话
+                agentSessionId = undefined;
+                skipResume = true;
+                logger.warn(`[AgentRunner] Safe mode enabled for ${sessionId}, not resuming session`);
+            }
+        }
+        // 验证会话文件是否存在且有效（仅在非安全模式且有 agentSessionId 时）
+        if (agentSessionId && !skipResume) {
+            const homeDir = os.homedir();
+            const encodedProjectPath = encodePath(projectPath);
+            const sessionFile = path.join(homeDir, '.claude', 'projects', encodedProjectPath, `${agentSessionId}.jsonl`);
+            let isValid = false;
+            if (fs.existsSync(sessionFile)) {
+                try {
+                    const content = fs.readFileSync(sessionFile, 'utf-8');
+                    const lines = content.split('\n').filter(l => l.trim());
+                    // 查找第一个包含 sessionId 和 version 的行（跳过 queue-operation）
+                    for (const line of lines) {
+                        try {
+                            const data = JSON.parse(line);
+                            if (data.sessionId && data.version) {
+                                isValid = true;
+                                break;
+                            }
+                        }
+                        catch { }
+                    }
+                    if (!isValid) {
+                        logger.warn(`[AgentRunner] Session file missing session data: ${sessionFile}`);
+                    }
+                }
+                catch (error) {
+                    logger.warn(`[AgentRunner] Session file corrupted: ${sessionFile}`);
+                }
+            }
+            if (!isValid) {
+                logger.warn(`[AgentRunner] Invalid session file, starting new session`);
+                agentSessionId = undefined;
+                this.activeSessions.delete(sessionId);
+                if (this.onSessionIdUpdate) {
+                    this.onSessionIdUpdate(sessionId, '');
+                }
+            }
+        }
+        // PreCompact Hook - 在压缩开始时触发
+        const preCompactHook = async () => {
+            if (this.onCompactStart) {
+                this.onCompactStart(sessionId);
+            }
+            return {};
+        };
+        // PreToolUse Hook - 黑名单检查（不可绕过，所有模式都走）
+        const preToolUseHook = async (input) => {
+            const result = await checkBlacklist(input.tool_name, input.tool_input || {});
+            if (result.behavior === 'deny') {
+                return {
+                    decision: 'block',
+                    reason: result.message
+                };
+            }
+            return {};
+        };
+        // SDK-level canUseTool 回调：接入 PermissionGateway 的用户审批入口
+        // 只在 SDK 认为此工具需要用户确认时触发（黑名单已在 PreToolUse hook 拦截）
+        const canUseToolCallback = async (toolName, input, options) => {
+            // default 模式：一律 allow（替代有缺陷的 bypassPermissions）
+            if (this.permissionMode === 'default') {
+                return { behavior: 'allow', updatedInput: input };
+            }
+            // 如果 PermissionGateway 未设置（如测试环境），回退到一律 allow
+            if (!this.permissionGateway || !this.sendPromptFn) {
+                return { behavior: 'allow', updatedInput: input };
+            }
+            const summary = options.title
+                || options.description
+                || summarizeToolInput(toolName, input);
+            const approved = await this.permissionGateway.requestPermission(sessionId, toolName, input, this.sendPromptFn, summary, options.decisionReason);
+            return approved
+                ? { behavior: 'allow', updatedInput: input }
+                : { behavior: 'deny', message: '用户拒绝或审批超时' };
+        };
+        const useSettingSources = this.config?.agents?.anthropic?.useSettingSources !== false;
+        const enableSummaries = this.config?.agents?.anthropic?.agentProgressSummaries !== false;
+        // 公共 options（新旧模式共用）
+        const sdkPermissionMode = this.toSdkPermissionMode();
+        logger.info(`[AgentRunner] runQuery model=${this.model} effort=${this.effort ?? 'auto'} permMode=${this.permissionMode} sdkMode=${sdkPermissionMode}`);
+        const commonOptions = {
+            cwd: projectPath,
+            model: this.model,
+            ...(this.effort ? { effort: this.effort } : {}),
+            canUseTool: canUseToolCallback,
+            permissionMode: sdkPermissionMode,
+            persistSession: true,
+            hooks: {
+                PreCompact: [{ matcher: '.*', hooks: [preCompactHook] }],
+                PreToolUse: [{ matcher: '.*', hooks: [preToolUseHook] }]
+            },
+            ...(enableSummaries ? { agentProgressSummaries: true } : {}),
+            stderr: (msg) => {
+                if (msg.includes('[ERROR]') || msg.includes('[WARN]') || msg.includes('Stream started')) {
+                    logger.info(`[Claude-stderr] ${msg.trim()}`);
+                }
+                else {
+                    logger.debug(`[Claude-stderr] ${msg.trim()}`);
+                }
+            },
+            env: this.getAgentEnv()
+        };
+        const createQuery = (promptInput, resumeSessionId) => {
+            if (useSettingSources) {
+                // 新方式：SDK 自动加载 CLAUDE.md 和 MCP 配置
+                return query({
+                    prompt: promptInput,
+                    options: {
+                        ...commonOptions,
+                        settingSources: ['project', 'user'],
+                        systemPrompt: {
+                            type: 'preset',
+                            preset: 'claude_code',
+                            ...(systemPromptAppend ? { append: systemPromptAppend } : {})
+                        },
+                        ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+                    }
+                });
+            }
+            else {
+                // 旧方式：手动加载 CLAUDE.md 和 MCP 配置（保留用于回滚）
+                const globalClaudeMd = (() => {
+                    try {
+                        const globalPath = path.join(os.homedir(), '.claude', 'CLAUDE.md');
+                        if (fs.existsSync(globalPath)) {
+                            return fs.readFileSync(globalPath, 'utf-8').trim();
+                        }
+                    }
+                    catch { }
+                    return '';
+                })();
+                const projectClaudeMds = [
+                    path.join(projectPath, 'CLAUDE.md'),
+                    path.join(projectPath, '.claude', 'CLAUDE.md'),
+                ].map(p => {
+                    try {
+                        return fs.existsSync(p) ? fs.readFileSync(p, 'utf-8').trim() : '';
+                    }
+                    catch {
+                        return '';
+                    }
+                }).filter(Boolean);
+                const globalMcpServers = (() => {
+                    try {
+                        const mcpPath = path.join(os.homedir(), '.claude', 'mcp.json');
+                        if (fs.existsSync(mcpPath)) {
+                            const config = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+                            return config.mcpServers || {};
+                        }
+                    }
+                    catch { }
+                    return {};
+                })();
+                const fullAppend = [...projectClaudeMds, globalClaudeMd, systemPromptAppend].filter(Boolean).join('\n\n');
+                return query({
+                    prompt: promptInput,
+                    options: {
+                        ...commonOptions,
+                        ...(resumeSessionId ? { resume: resumeSessionId } : {}),
+                        ...(Object.keys(globalMcpServers).length > 0 ? { mcpServers: globalMcpServers } : {}),
+                        ...(fullAppend ? {
+                            systemPrompt: {
+                                type: 'preset',
+                                preset: 'claude_code',
+                                append: fullAppend
+                            }
+                        } : {}),
+                    }
+                });
+            }
+        };
+        let lastError;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                let sdkStream;
+                if (images && images.length > 0) {
+                    logger.debug('[AgentRunner] Creating query with images, images:', images.length);
+                    logger.debug('[AgentRunner] Skipping resume for image message to avoid history conflict');
+                    const stream = new MessageStream();
+                    stream.push(prompt, images);
+                    stream.end();
+                    sdkStream = createQuery(stream);
+                }
+                else {
+                    logger.debug('[AgentRunner] Creating query with text only, agentSessionId:', initialClaudeSessionId);
+                    sdkStream = createQuery(prompt, agentSessionId);
+                }
+                // 保存 interrupt 能力（不写 activeStreams，由 registerStream 管理活跃状态）
+                if ('interrupt' in sdkStream && typeof sdkStream.interrupt === 'function') {
+                    this.interruptFns.set(sessionId, () => sdkStream.interrupt());
+                }
+                // 返回标准 AgentEvent 流
+                return this.transformStream(sdkStream, sessionId);
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < 2) {
+                    await new Promise(resolve => setTimeout(resolve, (attempt + 1) * 1000));
+                }
+            }
+        }
+        throw lastError;
+    }
+    async interrupt(sessionId) {
+        const fn = this.interruptFns.get(sessionId);
+        if (fn) {
+            try {
+                await fn();
+                logger.info(`[AgentRunner] Interrupted session: ${sessionId}`);
+            }
+            catch (error) {
+                logger.warn(`[AgentRunner] Interrupt failed (transport closed): ${sessionId}`);
+            }
+        }
+        this.interruptFns.delete(sessionId);
+        this.activeStreams.delete(sessionId);
+    }
+    hasActiveStream(sessionId) {
+        return this.activeStreams.has(sessionId);
+    }
+    registerStream(key, stream) {
+        this.activeStreams.set(key, stream);
+    }
+    cleanupStream(sessionId) {
+        this.activeStreams.delete(sessionId);
+        this.interruptFns.delete(sessionId);
+    }
+    updateSessionId(sessionId, agentSessionId) {
+        logger.info(`[AgentRunner] updateSessionId called: sessionId=${sessionId}, agentSessionId=${agentSessionId}`);
+        this.activeSessions.set(sessionId, agentSessionId);
+        if (this.onSessionIdUpdate) {
+            this.onSessionIdUpdate(sessionId, agentSessionId);
+        }
+    }
+    runSessionCommand(prompt, agentSessionId, projectPath) {
+        return query({
+            prompt,
+            options: {
+                cwd: projectPath,
+                model: this.model,
+                resume: agentSessionId,
+                maxTurns: 1,
+                permissionMode: this.toSdkPermissionMode(),
+                env: this.getAgentEnv()
+            }
+        });
+    }
+    /**
+     * 主动压缩会话上下文
+     */
+    async compactSession(sessionId, agentSessionId, projectPath) {
+        try {
+            logger.info(`[AgentRunner] Compacting session: ${agentSessionId}`);
+            const stream = this.runSessionCommand('/compact', agentSessionId, projectPath);
+            this.activeStreams.set(sessionId, stream);
+            try {
+                for await (const event of stream) {
+                    if (event.type === 'system' && event.subtype === 'compact_boundary') {
+                        logger.info(`[AgentRunner] Compact completed, pre_tokens: ${event.compact_metadata?.pre_tokens}`);
+                        return true;
+                    }
+                }
+                return true;
+            }
+            finally {
+                this.activeStreams.delete(sessionId);
+            }
+        }
+        catch (error) {
+            logger.error('[AgentRunner] Compact failed:', error);
+            return false;
+        }
+    }
+    /**
+     * 通过 SDK /clear 命令清空会话历史
+     */
+    async clearSession(sessionId, agentSessionId, projectPath) {
+        try {
+            logger.info(`[AgentRunner] Clearing session via SDK: ${agentSessionId}`);
+            const stream = this.runSessionCommand('/clear', agentSessionId, projectPath);
+            this.activeStreams.set(sessionId, stream);
+            try {
+                for await (const event of stream) {
+                    logger.debug(`[AgentRunner] Clear event: type=${event.type}, subtype=${event.subtype || 'none'}`);
+                }
+                return true;
+            }
+            finally {
+                this.activeStreams.delete(sessionId);
+            }
+        }
+        catch (error) {
+            logger.error('[AgentRunner] Clear session failed:', error);
+            return false;
+        }
+    }
+    async closeSession(sessionId) {
+        this.activeSessions.delete(sessionId);
+        this.activeStreams.delete(sessionId);
+        this.interruptFns.delete(sessionId);
+    }
+    resolveSessionFile(agentSessionId, projectPath) {
+        const encodedProjectPath = encodePath(projectPath);
+        const sessionFile = path.join(os.homedir(), '.claude', 'projects', encodedProjectPath, `${agentSessionId}.jsonl`);
+        return fs.existsSync(sessionFile) ? sessionFile : null;
+    }
+    async forkSession(agentSessionId, projectPath, title) {
+        const result = await sdkForkSession(agentSessionId, { dir: projectPath, title });
+        return result.sessionId;
+    }
+}
+// Plugin implementation
+export class ClaudeAgentPlugin {
+    name = 'claude';
+    isEnabled(config) {
+        return true;
+    }
+    createAgent(config, callbacks) {
+        const anthropic = resolveAnthropicConfig(config);
+        const agentRunner = new AgentRunner(anthropic.apiKey, anthropic.model, callbacks.onSessionIdUpdate, anthropic.baseUrl, config);
+        if (anthropic.effort) {
+            agentRunner.setEffort(anthropic.effort);
+        }
+        return { agent: agentRunner };
+    }
+}