@ai-setting/roy-agent-cli 1.3.14 → 1.3.16

package/dist/cli/src/commands/sessions/messages.js

@@ -0,0 +1,228 @@
+/**
+ * @fileoverview Sessions Messages Command
+ *
+ * 命令：roy sessions messages <session-id>
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const MessagesCommand = {
+    command: "messages <session-id>",
+    aliases: ["msgs"],
+    describe: "查看会话消息",
+    builder: (yargs) => yargs
+        .positional("session-id", {
+        describe: "会话 ID",
+        type: "string",
+        demandOption: true,
+    })
+        .option("limit", { alias: "n", type: "number", demandOption: true, describe: "返回消息数量" })
+        .option("offset", { alias: "o", type: "number", demandOption: true, describe: "起始偏移量" })
+        .option("reverse", { alias: "r", type: "boolean", default: false })
+        .option("json", { alias: "j", type: "boolean", default: false }),
+    async handler(args) {
+        const a = args;
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: a.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const sessionComponent = env.getComponent("session");
+            if (!sessionComponent) {
+                output.error("SessionComponent not available");
+                process.exit(1);
+            }
+            const session = await sessionComponent.get(a.sessionId);
+            if (!session) {
+                output.error(`Session not found: ${a.sessionId}`);
+                process.exit(1);
+            }
+            // 并行获取消息和总数
+            const [messages, totalMessages] = await Promise.all([
+                sessionComponent.getMessages(a.sessionId, {
+                    offset: a.offset,
+                    limit: a.limit,
+                }),
+                sessionComponent.getMessageCount(a.sessionId),
+            ]);
+            if (a.reverse) {
+                messages.reverse();
+            }
+            if (a.json) {
+                output.json({
+                    sessionId: a.sessionId,
+                    messages: messages.map((m) => ({
+                        id: m.id,
+                        role: m.role,
+                        content: m.content,
+                        parts: m.parts, // 包含结构化 parts 信息
+                        timestamp: new Date(m.timestamp).toISOString(),
+                        isCheckpoint: m.metadata?.isCheckpoint,
+                    })),
+                    total: totalMessages,
+                    pagination: {
+                        offset: a.offset,
+                        limit: a.limit,
+                        hasMore: a.offset + a.limit < totalMessages,
+                    },
+                });
+            }
+            else {
+                // 检查点消息样式
+                const checkpointStyle = (content) => {
+                    const lines = content.split("\n");
+                    return lines.slice(0, 10).join("\n") + (lines.length > 10 ? "\n..." : "");
+                };
+                const roleColors = {
+                    user: chalk.blue,
+                    assistant: chalk.green,
+                    system: chalk.gray,
+                    tool: chalk.yellow,
+                };
+                /**
+                 * 格式化消息内容，支持 parts 结构化展示
+                 */
+                const formatMessageContent = (m) => {
+                    const lines = [];
+                    // 处理 parts（结构化内容）
+                    if (m.parts && m.parts.length > 0) {
+                        for (const part of m.parts) {
+                            if (part.type === "text") {
+                                const text = part.content?.length > 300
+                                    ? part.content.slice(0, 297) + "..."
+                                    : (part.content || "");
+                                lines.push(...text.split("\n").map((l) => l || " "));
+                            }
+                            else if (part.type === "tool-call") {
+                                lines.push(chalk.cyan(`[Tool Call] ${part.toolName}`));
+                                const argsStr = typeof part.arguments === 'string'
+                                    ? part.arguments
+                                    : JSON.stringify(part.arguments ?? null, null, 2);
+                                if (argsStr && argsStr.length > 200) {
+                                    lines.push(...argsStr.slice(0, 197).split("\n").map((l) => chalk.gray(l)));
+                                    lines.push(chalk.gray("..."));
+                                }
+                                else if (argsStr) {
+                                    lines.push(...argsStr.split("\n").map((l) => chalk.gray(l)));
+                                }
+                            }
+                            else if (part.type === "tool-result") {
+                                lines.push(chalk.yellow(`[Tool Result] ${part.toolName}`));
+                                const output = part.output?.length > 200
+                                    ? part.output.slice(0, 197) + "..."
+                                    : (part.output || "No output");
+                                lines.push(...output.split("\n").map((l) => chalk.gray(l)));
+                            }
+                            else if (part.type === "reasoning") {
+                                lines.push(chalk.magenta(`[Reasoning]`));
+                                lines.push(...(part.content || "").split("\n").slice(0, 5).map((l) => chalk.gray(l)));
+                            }
+                            else if (part.type === "checkpoint") {
+                                lines.push(chalk.cyan(`[Checkpoint]`));
+                            }
+                            // ==================== Workflow Node Types ====================
+                            else if (part.type === "workflow-node-call") {
+                                lines.push(chalk.blue(`[Node Call] ${part.nodeType}: ${part.nodeId}`));
+                                if (part.input && Object.keys(part.input).length > 0) {
+                                    const inputSummary = Object.entries(part.input)
+                                        .slice(0, 3)
+                                        .map(([k, v]) => `${k}: ${JSON.stringify(v).slice(0, 50)}`)
+                                        .join(", ");
+                                    lines.push(...inputSummary.split("\n").map((l) => chalk.gray(`  ${l}`)));
+                                }
+                                if (part.agentSessionId) {
+                                    lines.push(chalk.gray(`  agentSessionId: ${part.agentSessionId}`));
+                                }
+                            }
+                            else if (part.type === "workflow-node-interrupt") {
+                                lines.push(chalk.yellow(`[Node Interrupt] ${part.nodeType}: ${part.nodeId}`));
+                                lines.push(chalk.bold(`  Query: ${part.query}`));
+                                if (part.options && part.options.length > 0) {
+                                    lines.push(chalk.gray(`  Options: ${part.options.join(", ")}`));
+                                }
+                                if (part.agentSessionId) {
+                                    lines.push(chalk.gray(`  agentSessionId: ${part.agentSessionId}`));
+                                }
+                            }
+                            else if (part.type === "workflow-node-result") {
+                                const status = part.error ? "❌" : "✅";
+                                lines.push(chalk.green(`${status} [Node Result] ${part.nodeType}: ${part.nodeId}`));
+                                if (part.output) {
+                                    const outputStr = typeof part.output === 'string'
+                                        ? part.output
+                                        : JSON.stringify(part.output).slice(0, 200);
+                                    lines.push(...outputStr.split("\n").slice(0, 5).map((l) => chalk.gray(`  ${l}`)));
+                                }
+                                if (part.error) {
+                                    lines.push(chalk.red(`  Error: ${part.error}`));
+                                }
+                                if (part.durationMs !== undefined) {
+                                    lines.push(chalk.gray(`  Duration: ${part.durationMs}ms`));
+                                }
+                            }
+                            else if (part.type === "workflow-node-resume") {
+                                lines.push(chalk.green(`[Node Resume] Response: ${part.response}`));
+                            }
+                            else if (part.type === "workflow-node-start") {
+                                lines.push(chalk.blue(`[Node Start] ${part.nodeId}`));
+                            }
+                        }
+                    }
+                    else if (m.content) {
+                        // 纯文本内容（兼容旧格式）
+                        const content = m.content.length > 200
+                            ? m.content.slice(0, 197) + "..."
+                            : m.content;
+                        lines.push(...content.split("\n").map(l => l || " "));
+                    }
+                    return lines.length > 0 ? lines : ["(empty)"];
+                };
+                output.log(chalk.bold(`┌─ Messages (${a.sessionId}) ────────────────────────┐`));
+                messages.forEach((m, i) => {
+                    const roleColor = roleColors[m.role] || chalk.white;
+                    const time = new Date(m.timestamp).toLocaleTimeString("zh-CN", {
+                        hour: "2-digit",
+                        minute: "2-digit",
+                    });
+                    if (m.metadata?.isCheckpoint) {
+                        // Checkpoint 消息特殊样式
+                        output.log(chalk.cyan("├─ #" + (a.offset + i + 1) + "  checkpoint") + "  " + chalk.gray(time));
+                        output.log("│");
+                        output.log("│ " + checkpointStyle(m.content).split("\n").join("\n│ "));
+                        output.log("│");
+                    }
+                    else {
+                        output.log(chalk.cyan("├─ #" + (a.offset + i + 1) + "  ") + roleColor(m.role.padEnd(10)) + "  " + chalk.gray(time));
+                        // 使用格式化的内容（支持 parts）
+                        const contentLines = formatMessageContent(m);
+                        for (const line of contentLines.slice(0, 20)) { // 最多显示20行
+                            output.log("│ " + line);
+                        }
+                        if (contentLines.length > 20) {
+                            output.log("│ " + chalk.gray("... (truncated)"));
+                        }
+                        output.log("│");
+                    }
+                });
+                output.log("└" + "─".repeat(51) + "┘");
+                // 显示分页信息和总数
+                const hasMore = a.offset + a.limit < totalMessages;
+                const showingEnd = Math.min(a.offset + a.limit, totalMessages);
+                output.log(chalk.gray(`Showing ${a.offset + 1}-${showingEnd} of ${totalMessages} messages` +
+                    (hasMore ? " (more available)" : "")));
+            }
+        }
+        catch (error) {
+            output.error(`Failed to get messages: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=messages.js.map

package/dist/cli/src/commands/sessions/mock.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview Sessions Mock Command
+ *
+ * 命令：roy sessions mock <session-id>
+ *
+ * 插入模拟的交互消息（模拟一个完整的 agent 交互流程）
+ */
+import { CommandModule } from "yargs";
+export declare const MockCommand: CommandModule<object, object>;
+//# sourceMappingURL=mock.d.ts.map

package/dist/cli/src/commands/sessions/mock.js

@@ -0,0 +1,172 @@
+/**
+ * @fileoverview Sessions Mock Command
+ *
+ * 命令：roy sessions mock <session-id>
+ *
+ * 插入模拟的交互消息（模拟一个完整的 agent 交互流程）
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+// 模拟的消息序列（一个完整的 agent 交互）
+const MOCK_SEQUENCES = [
+    // 序列 1: 文件操作
+    {
+        name: "文件操作流程",
+        messages: [
+            { role: "user", content: "帮我查看一下当前目录有哪些文件" },
+            { role: "assistant", content: "", toolCalls: [{ name: "glob", args: { pattern: "**/*" } }] },
+            { role: "tool", content: "找到 5 个文件:\n- README.md\n- package.json\n- src/index.ts\n- src/app.ts\n- tsconfig.json" },
+            { role: "assistant", content: "当前目录包含以下文件：\n1. README.md - 项目说明\n2. package.json - 项目配置\n3. src/index.ts - 入口文件\n4. src/app.ts - 应用文件\n5. tsconfig.json - TypeScript 配置" },
+        ],
+    },
+    // 序列 2: 搜索代码
+    {
+        name: "代码搜索流程",
+        messages: [
+            { role: "user", content: "搜索一下代码中包含 'TODO' 的地方" },
+            { role: "assistant", content: "", toolCalls: [{ name: "grep", args: { pattern: "TODO" } }] },
+            { role: "tool", content: "找到 3 处 TODO:\n1. src/index.ts:15 - TODO: 实现错误处理\n2. src/app.ts:42 - TODO: 优化性能\n3. src/utils.ts:8 - TODO: 添加单元测试" },
+            { role: "assistant", content: "代码中发现 3 处 TODO 标记：\n\n| 文件 | 行号 | 内容 |\n|------|------|------|\n| src/index.ts | 15 | 实现错误处理 |\n| src/app.ts | 42 | 优化性能 |\n| src/utils.ts | 8 | 添加单元测试 |\n\n需要我帮你处理这些 TODO 吗？" },
+        ],
+    },
+    // 序列 3: 写文件
+    {
+        name: "写文件流程",
+        messages: [
+            { role: "user", content: "帮我创建一个新的配置文件 config.yaml" },
+            { role: "assistant", content: "", toolCalls: [{ name: "writeFile", args: { path: "config.yaml", content: "# 配置文件\nname: my-app\nversion: 1.0.0\n\ndatabase:\n  host: localhost\n  port: 5432" } }] },
+            { role: "tool", content: "文件 config.yaml 已创建成功" },
+            { role: "assistant", content: "已创建配置文件 `config.yaml`，包含：\n- 基本配置（name, version）\n- 数据库配置（host, port）\n\n你可以根据需要修改这些配置。" },
+        ],
+    },
+    // 序列 4: 读取文件
+    {
+        name: "读取文件流程",
+        messages: [
+            { role: "user", content: "看看 package.json 的内容" },
+            { role: "assistant", content: "", toolCalls: [{ name: "readFile", args: { path: "package.json" } }] },
+            { role: "tool", content: '{\n  "name": "my-app",\n  "version": "1.0.0",\n  "scripts": {\n    "dev": "bun run src/index.ts",\n    "build": "bun build"\n  }\n}' },
+            { role: "assistant", content: "package.json 内容如下：\n\n```json\n{\n  \"name\": \"my-app\",\n  \"version\": \"1.0.0\",\n  \"scripts\": {\n    \"dev\": \"bun run src/index.ts\",\n    \"build\": \"bun build\"\n  }\n}\n```\n\n这是一个标准的 Node.js 项目配置。" },
+        ],
+    },
+];
+export const MockCommand = {
+    command: "mock <session-id>",
+    describe: "插入模拟消息到会话（用于测试 checkpoint）",
+    builder: (yargs) => yargs
+        .positional("session-id", {
+        describe: "会话 ID",
+        type: "string",
+        demandOption: true,
+    })
+        .option("count", {
+        alias: "n",
+        type: "number",
+        default: 1,
+        description: "插入几组模拟消息（1-4）",
+    })
+        .option("json", { alias: "j", type: "boolean", default: false }),
+    async handler(args) {
+        const a = args;
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: a.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const sessionComponent = env.getComponent("session");
+            if (!sessionComponent) {
+                output.error("SessionComponent not available");
+                process.exit(1);
+            }
+            // 检查会话是否存在
+            const session = await sessionComponent.get(a.sessionId);
+            if (!session) {
+                output.error(`Session not found: ${a.sessionId}`);
+                process.exit(1);
+            }
+            const count = Math.min(Math.max(a.count || 1, 1), MOCK_SEQUENCES.length);
+            const addedMessages = [];
+            if (!a.json) {
+                output.info(`Inserting ${count} mock sequence(s) into session...`);
+                output.log("");
+            }
+            // 添加模拟消息
+            for (let seqIdx = 0; seqIdx < count; seqIdx++) {
+                const sequence = MOCK_SEQUENCES[seqIdx];
+                if (!a.json) {
+                    output.log(chalk.bold(`\n📝 Sequence ${seqIdx + 1}: ${sequence.name}`));
+                }
+                for (const msg of sequence.messages) {
+                    // 处理 tool call 消息
+                    if (msg.role === "assistant" && msg.toolCalls) {
+                        // 添加 assistant 消息（带 tool call）
+                        const toolCallText = msg.toolCalls
+                            .map((tc) => `🔧 Calling tool: ${tc.name}\n\`\`\`\n${JSON.stringify(tc.args, null, 2)}\n\`\`\``)
+                            .join("\n\n");
+                        const assistantMsgId = await sessionComponent.addMessage(a.sessionId, {
+                            role: "assistant",
+                            content: toolCallText,
+                        });
+                        if (assistantMsgId)
+                            addedMessages.push(assistantMsgId);
+                        if (!a.json) {
+                            output.log(chalk.cyan(`  [${addedMessages.length}] assistant: 🔧 Tool call`));
+                        }
+                        // 添加 tool result
+                        const toolMsgId = await sessionComponent.addMessage(a.sessionId, {
+                            role: "tool",
+                            content: msg.content,
+                        });
+                        if (toolMsgId)
+                            addedMessages.push(toolMsgId);
+                        if (!a.json) {
+                            output.log(chalk.yellow(`  [${addedMessages.length}] tool: ${msg.content.substring(0, 50)}...`));
+                        }
+                    }
+                    else {
+                        // 普通消息
+                        const msgId = await sessionComponent.addMessage(a.sessionId, {
+                            role: msg.role,
+                            content: msg.content,
+                        });
+                        if (msgId)
+                            addedMessages.push(msgId);
+                        if (!a.json) {
+                            const roleColor = msg.role === "user" ? chalk.green : msg.role === "assistant" ? chalk.cyan : chalk.gray;
+                            output.log(roleColor(`  [${addedMessages.length}] ${msg.role}: ${msg.content.substring(0, 50)}...`));
+                        }
+                    }
+                }
+            }
+            // 显示结果
+            if (a.json) {
+                output.json({
+                    success: true,
+                    sessionId: a.sessionId,
+                    sequencesAdded: count,
+                    messagesAdded: addedMessages.length,
+                    messageIds: addedMessages,
+                });
+            }
+            else {
+                output.log("\n" + chalk.bold.green("✅ Mock data inserted successfully!"));
+                output.log(`   Session: ${a.sessionId}`);
+                output.log(`   Sequences: ${count}`);
+                output.log(`   Messages: ${addedMessages.length}`);
+                output.log("");
+                output.log(chalk.gray("   Now run: "));
+                output.log(chalk.gray(`   roy sessions compact ${a.sessionId}`));
+                output.log(chalk.gray("   to trigger checkpoint generation"));
+            }
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=mock.js.map

package/dist/cli/src/commands/sessions/new.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Sessions New Command
+ *
+ * 命令：roy sessions new
+ */
+import { CommandModule } from "yargs";
+interface NewOptions {
+    title?: string;
+    directory?: string;
+    active?: boolean;
+    json?: boolean;
+    config?: string;
+}
+export declare const NewCommand: CommandModule<object, NewOptions>;
+export {};
+//# sourceMappingURL=new.d.ts.map

package/dist/cli/src/commands/sessions/new.js

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview Sessions New Command
+ *
+ * 命令：roy sessions new
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const NewCommand = {
+    command: "new [options]",
+    aliases: ["create"],
+    describe: "创建新会话",
+    builder: (yargs) => yargs
+        .option("title", { alias: "t", type: "string" })
+        .option("directory", { alias: "d", type: "string" })
+        .option("active", { alias: "s", type: "boolean", default: false })
+        .option("json", { type: "boolean", default: false }),
+    async handler(args) {
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: args.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const sessionComponent = env.getComponent("session");
+            if (!sessionComponent) {
+                output.error("SessionComponent not available");
+                process.exit(1);
+            }
+            const session = await sessionComponent.create({
+                title: args.title,
+                directory: args.directory || process.cwd(),
+            });
+            if (args.active) {
+                await sessionComponent.setActiveSession(session.id);
+            }
+            if (args.json) {
+                output.json({
+                    success: true,
+                    session: {
+                        id: session.id,
+                        title: session.title,
+                        directory: session.directory,
+                        createdAt: new Date(session.createdAt).toISOString(),
+                    },
+                });
+            }
+            else {
+                output.success(chalk.green("✓") + " Session created: " + session.id);
+                output.info("Title: " + session.title);
+                output.info("Directory: " + session.directory);
+            }
+        }
+        catch (error) {
+            output.error(`Failed to create session: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=new.js.map

package/dist/cli/src/commands/sessions/rename.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Sessions Rename Command
+ *
+ * 命令：roy sessions rename <session-id> <new-title>
+ */
+import { CommandModule } from "yargs";
+export declare const RenameCommand: CommandModule<object, object>;
+//# sourceMappingURL=rename.d.ts.map

package/dist/cli/src/commands/sessions/rename.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Sessions Rename Command
+ *
+ * 命令：roy sessions rename <session-id> <new-title>
+ */
+import { EnvironmentService } from "../../services/environment.service.js";
+import { OutputService } from "../../services/output.service.js";
+import chalk from "chalk";
+export const RenameCommand = {
+    command: "rename <session-id> <title>",
+    aliases: ["mv"],
+    describe: "更新会话标题",
+    builder: (yargs) => yargs
+        .positional("session-id", {
+        describe: "会话 ID",
+        type: "string",
+        demandOption: true,
+    })
+        .positional("title", {
+        describe: "新标题",
+        type: "string",
+        demandOption: true,
+    })
+        .option("json", {
+        describe: "JSON 格式输出",
+        type: "boolean",
+        default: false,
+    }),
+    async handler(args) {
+        const a = args;
+        const output = new OutputService();
+        const envService = new EnvironmentService(output);
+        try {
+            await envService.create({ configPath: a.config });
+            const env = envService.getEnvironment();
+            if (!env) {
+                output.error("Failed to create environment");
+                process.exit(1);
+            }
+            const sessionComponent = env.getComponent("session");
+            if (!sessionComponent) {
+                output.error("SessionComponent not available");
+                process.exit(1);
+            }
+            // 获取会话
+            const session = await sessionComponent.get(a.sessionId);
+            if (!session) {
+                output.error(`Session not found: ${a.sessionId}`);
+                process.exit(1);
+            }
+            // 更新标题
+            const success = await sessionComponent.update(a.sessionId, {
+                title: a.title,
+            });
+            if (!success) {
+                output.error("Failed to rename session");
+                process.exit(1);
+            }
+            if (a.json) {
+                output.json({
+                    success: true,
+                    session: {
+                        id: a.sessionId,
+                        title: a.title,
+                    },
+                });
+            }
+            else {
+                output.success(`Session renamed: ${chalk.green(a.title)}`);
+                output.info(`ID: ${a.sessionId}`);
+            }
+        }
+        catch (error) {
+            output.error(`Failed to rename session: ${error instanceof Error ? error.message : String(error)}`);
+            process.exit(1);
+        }
+        finally {
+            await envService.dispose();
+        }
+    },
+};
+//# sourceMappingURL=rename.js.map

package/dist/cli/src/commands/shared/event-handler.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview Event Handler
+ *
+ * 管理环境事件的订阅、队列和处理
+ */
+import type { BaseEnvironment } from "@ai-setting/roy-agent-core";
+import { EventMessageFormatter } from "./event-message-formatter";
+/**
+ * EventHandler 配置选项
+ */
+export interface EventHandlerOptions {
+    /** 环境实例 */
+    env: BaseEnvironment;
+    /** 监听的事件类型（支持通配符，如 'task.*'） */
+    eventTypes: string[];
+    /** 事件消息触发回调 */
+    onEvent: (message: string) => Promise<void>;
+    /** 消息格式化器 */
+    formatter?: EventMessageFormatter;
+    /** 检查 agent 是否空闲 */
+    isIdle?: () => boolean;
+    /** 空闲检查间隔（毫秒） */
+    idleCheckInterval?: number;
+}
+/**
+ * 事件处理器
+ *
+ * 订阅环境事件，格式化后通过队列管理，agent 空闲时触发处理
+ */
+export declare class EventHandler {
+    private env;
+    private eventTypes;
+    private onEvent;
+    private formatter;
+    private isIdle;
+    private idleCheckInterval;
+    private queue;
+    private isProcessing;
+    private isStopped;
+    private unsubscribe;
+    constructor(options: EventHandlerOptions);
+    /**
+     * 启动事件处理
+     * @returns 取消订阅函数
+     */
+    start(): () => void;
+    /**
+     * 检查事件类型是否匹配
+     */
+    private matchesEventType;
+    /**
+     * 通配符模式匹配
+     * 支持:
+     * - "task.*" 匹配 "task.started", "task.completed" 等
+     * - "task.started" 精确匹配
+     */
+    private matchPattern;
+    /**
+     * 停止事件处理
+     */
+    stop(): void;
+    /**
+     * 处理收到的事件
+     */
+    private handleEvent;
+    /**
+     * 将消息加入队列
+     */
+    enqueue(message: string): void;
+    /**
+     * 获取队列长度
+     */
+    getQueueLength(): number;
+    /**
+     * 检查队列是否为空
+     */
+    isQueueEmpty(): boolean;
+    /**
+     * 处理队列中的消息（使用 while 循环避免递归栈溢出）
+     */
+    private processQueue;
+    /**
+     * 等待 agent 空闲
+     */
+    private waitForIdle;
+    /**
+     * 睡眠工具函数
+     */
+    private sleep;
+}
+//# sourceMappingURL=event-handler.d.ts.map