@ai-setting/roy-agent-cli 1.3.18 → 1.3.22

package/dist/core/src/env/agent/agent-component.test.js

@@ -1,1169 +0,0 @@
-/**
- * @fileoverview AgentComponent Tests
- *
- * 使用 TDD 方法测试 AgentComponent
- */
-import { describe, it, expect, vi, beforeEach, afterEach, test } from "vitest";
-import { AgentComponent } from "./agent-component.js";
-import { ConfigComponent } from "../../config/config-component.js";
-import * as fsSync from "fs";
-import * as path from "path";
-import * as os from "os";
-// ============================================================================
-// Mock Environment
-// ============================================================================
-function createMockEnvironment() {
-    return {
-        name: "test-env",
-        version: "1.0.0",
-        getConfig: vi.fn(() => ({ name: "test-env", version: "1.0.0", enabled: true })),
-        registerComponent: vi.fn(),
-        unregisterComponent: vi.fn(),
-        getComponent: vi.fn(),
-        listComponents: vi.fn(() => []),
-        handle_query: vi.fn(),
-        handle_action: vi.fn(),
-        subscribe: vi.fn(() => () => { }),
-        subscribeTo: vi.fn(() => () => { }),
-        subscribeAll: vi.fn(() => () => { }),
-        pushEnvEvent: vi.fn(),
-    };
-}
-// ============================================================================
-// Tests
-// ============================================================================
-describe("AgentComponent", () => {
-    let agentComponent;
-    let mockEnv;
-    let configComponent;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        agentComponent = new AgentComponent();
-        configComponent = new ConfigComponent();
-        // Create mockEnv with configComponent
-        mockEnv = {
-            name: "test-env",
-            version: "1.0.0",
-            getConfig: vi.fn(() => ({ name: "test-env", version: "1.0.0", enabled: true })),
-            registerComponent: vi.fn(),
-            unregisterComponent: vi.fn(),
-            getComponent: vi.fn((name) => {
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            }),
-            hasComponent: vi.fn((name) => name === "config"),
-            listComponents: vi.fn(() => []),
-            handle_query: vi.fn(),
-            handle_action: vi.fn(),
-            subscribe: vi.fn(() => () => { }),
-            subscribeTo: vi.fn(() => () => { }),
-            subscribeAll: vi.fn(() => () => { }),
-            pushEnvEvent: vi.fn(),
-        };
-    });
-    afterEach(() => {
-        // Clean up environment variables
-        delete process.env.AGENT_AGENT_DEFAULT_AGENT_MAX_ITERATIONS;
-    });
-    describe("constructor and initialization", () => {
-        it("should create AgentComponent instance", () => {
-            expect(agentComponent).toBeDefined();
-            expect(agentComponent.name).toBe("agent");
-            expect(agentComponent.version).toBe("1.0.0");
-        });
-        it("should initialize with default config", async () => {
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-            expect(agentComponent.getStatus()).toBe("running");
-        });
-        it("should init with env (env is optional)", async () => {
-            // env is optional, but configComponent is required
-            const component = new AgentComponent();
-            await expect(component.init({ env: mockEnv, options: { configComponent } })).resolves.toBeUndefined();
-            expect(component.getStatus()).toBe("running");
-        });
-    });
-    describe("Agent registration", () => {
-        beforeEach(async () => {
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-        });
-        it("should register a new agent", () => {
-            const agent = agentComponent.registerAgent("test-agent", {
-                type: "primary",
-                systemPrompt: "You are a helpful assistant.",
-            });
-            expect(agent).toBeDefined();
-            expect(agent.name).toBe("test-agent");
-            expect(agent.config.type).toBe("primary");
-        });
-        it("should get registered agent", () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            const agent = agentComponent.getAgent("test-agent");
-            expect(agent).toBeDefined();
-            expect(agent.name).toBe("test-agent");
-        });
-        it("should return undefined for non-existent agent", () => {
-            const agent = agentComponent.getAgent("non-existent");
-            expect(agent).toBeUndefined();
-        });
-        it("should list all agents", () => {
-            agentComponent.registerAgent("agent1", { type: "primary" });
-            agentComponent.registerAgent("agent2", { type: "sub" });
-            const agents = agentComponent.listAgents();
-            expect(agents).toHaveLength(2);
-        });
-        it("should unregister agent", () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            const deleted = agentComponent.unregisterAgent("test-agent");
-            expect(deleted).toBe(true);
-            expect(agentComponent.getAgent("test-agent")).toBeUndefined();
-        });
-        it("should return false when unregistering non-existent agent", () => {
-            const deleted = agentComponent.unregisterAgent("non-existent");
-            expect(deleted).toBe(false);
-        });
-        it("should use passed config over defaultAgent (PromptComponent priority)", async () => {
-            // 模拟 ConfigComponent 中有 systemPrompt 配置
-            const configWithPrompt = new ConfigComponent();
-            await configWithPrompt.set("agent.defaultAgent.systemPrompt", "From ConfigComponent");
-            await configWithPrompt.set("agent.defaultAgent.maxIterations", 50);
-            // 通过构造函数传入 config，模拟从配置文件加载的配置
-            agentComponent = new AgentComponent({
-                config: {
-                    defaultAgent: {
-                        systemPrompt: "From ConfigComponent (defaultAgent)",
-                        maxIterations: 50,
-                    },
-                },
-            });
-            await agentComponent.init({ env: mockEnv, options: { configComponent: configWithPrompt } });
-            // 模拟 environment.ts 从 PromptComponent 获取的 systemPrompt
-            const promptFromPromptComponent = "From PromptComponent";
-            // 注册 agent，传入 PromptComponent 的 systemPrompt
-            const agent = agentComponent.registerAgent("default", {
-                type: "primary",
-                systemPrompt: promptFromPromptComponent,
-                maxIterations: 100, // 传入的 maxIterations 应该覆盖 defaultAgent 的 50
-            });
-            // 验证：传入的 config (PromptComponent) 优先级最高
-            expect(agent.config.systemPrompt).toBe(promptFromPromptComponent);
-            expect(agent.config.maxIterations).toBe(100); // 传入的覆盖 defaultAgent 的 50
-        });
-        it("should fill missing config from defaultAgent", async () => {
-            // 当传入的 config 缺失某些字段时，从 defaultAgent 填充
-            // 通过构造函数传入默认值
-            agentComponent = new AgentComponent({
-                config: {
-                    defaultAgent: {
-                        systemPrompt: "Default System Prompt",
-                        maxIterations: 50,
-                        model: "gpt-4",
-                    },
-                },
-            });
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-            // 只传入 type，其他字段缺失
-            const agent = agentComponent.registerAgent("test-agent", {
-                type: "primary",
-            });
-            // 验证：从 defaultAgent 填充缺失的字段
-            expect(agent.config.systemPrompt).toBe("Default System Prompt");
-            expect(agent.config.maxIterations).toBe(50);
-            expect(agent.config.model).toBe("gpt-4");
-        });
-    });
-    describe("Plugin registration", () => {
-        beforeEach(async () => {
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-        });
-        it("should register plugin to agent", () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            const plugin = {
-                name: "test-plugin",
-                version: "1.0.0",
-                hooks: [{ point: "agent:before.llm" }],
-                execute: vi.fn(async () => ({ continue: true })),
-            };
-            agentComponent.registerPlugin("test-agent", plugin);
-            const agent = agentComponent.getAgent("test-agent");
-            expect(agent.plugins.has("test-plugin")).toBe(true);
-        });
-        it("should throw error when registering plugin to non-existent agent", () => {
-            const plugin = {
-                name: "test-plugin",
-                version: "1.0.0",
-                hooks: [{ point: "agent:before.llm" }],
-                execute: vi.fn(),
-            };
-            expect(() => agentComponent.registerPlugin("non-existent", plugin)).toThrow();
-        });
-        it("should unregister plugin", () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            const plugin = {
-                name: "test-plugin",
-                version: "1.0.0",
-                hooks: [{ point: "agent:before.llm" }],
-                execute: vi.fn(),
-            };
-            agentComponent.registerPlugin("test-agent", plugin);
-            const deleted = agentComponent.unregisterPlugin("test-agent", "test-plugin");
-            expect(deleted).toBe(true);
-        });
-    });
-    describe("abort functionality", () => {
-        beforeEach(async () => {
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-        });
-        it("should abort running agent", async () => {
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            // Start aborting
-            agentComponent.abort("test-agent");
-            // Check abort was registered
-            // This would need integration with actual run
-            expect(true).toBe(true);
-        });
-    });
-    describe("Agent execution (run)", () => {
-        beforeEach(async () => {
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-        });
-        it("should throw error for non-existent agent", async () => {
-            await expect(agentComponent.run("non-existent", "test query")).rejects.toThrow();
-        });
-        it("should execute agent and return result", async () => {
-            agentComponent.registerAgent("test-agent", {
-                type: "primary",
-                systemPrompt: "You are a helpful assistant.",
-            });
-            const result = await agentComponent.run("test-agent", "Say hello");
-            expect(result).toBeDefined();
-            expect(result.iterations).toBe(1);
-            expect(result.finalText).toBeDefined();
-        });
-        it("should respect maxIterations config", async () => {
-            agentComponent.registerAgent("test-agent", {
-                type: "primary",
-                maxIterations: 5,
-            });
-            // Mock LLM to always return tool calls
-            const mockLLMComponent = {
-                invoke: vi.fn(() => Promise.resolve({
-                    output: {
-                        content: "",
-                        toolCalls: [{
-                                id: "call_1",
-                                function: { name: "test_tool", arguments: "{}" }
-                            }]
-                    }
-                }))
-            };
-            mockEnv.getComponent.mockReturnValue(mockLLMComponent);
-            const result = await agentComponent.run("test-agent", "Test max iterations");
-            expect(result.iterations).toBeLessThanOrEqual(5);
-        });
-    });
-    describe("Plugin hooks", () => {
-        beforeEach(async () => {
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-        });
-        it("should execute before.llm hook", async () => {
-            const hookCalled = vi.fn();
-            const plugin = {
-                name: "before-llm-hook",
-                version: "1.0.0",
-                hooks: [{ point: "agent:before.llm" }],
-                execute: hookCalled,
-            };
-            agentComponent.registerPlugin("test-agent", plugin);
-            await agentComponent.run("test-agent", "Test hook");
-            expect(hookCalled).toHaveBeenCalled();
-        });
-        it("should allow hook to stop execution", async () => {
-            const plugin = {
-                name: "stopper",
-                version: "1.0.0",
-                hooks: [{ point: "agent:before.llm" }],
-                execute: vi.fn(() => Promise.resolve({ continue: false })),
-            };
-            agentComponent.registerPlugin("test-agent", plugin);
-            const result = await agentComponent.run("test-agent", "Test stop");
-            expect(result.stopped).toBe(true);
-        });
-        it("should allow hook to modify messages", async () => {
-            let capturedCtx;
-            const plugin = {
-                name: "message-modifier",
-                version: "1.0.0",
-                hooks: [{ point: "agent:before.llm" }],
-                execute: vi.fn((ctx) => {
-                    capturedCtx = ctx;
-                    return { continue: true };
-                }),
-            };
-            agentComponent.registerPlugin("test-agent", plugin);
-            await agentComponent.run("test-agent", "Test");
-            expect(capturedCtx.messages).toBeDefined();
-            expect(capturedCtx.messages.length).toBeGreaterThan(0);
-        });
-    });
-    describe("Multiple queries in same session", () => {
-        beforeEach(async () => {
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-        });
-        it("should add user message for every query (not skip when session has history)", async () => {
-            // Create a mock session component that returns existing messages
-            const sessionMessages = [
-                { role: "user", content: "first query" },
-                { role: "assistant", content: "first response" },
-            ];
-            const mockSessionComponent = {
-                addMessage: vi.fn(async () => { }),
-                getContext: vi.fn(async () => ({
-                    messages: sessionMessages,
-                    checkpoint: undefined,
-                })),
-            };
-            // Update mock env to return session component
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "session")
-                    return mockSessionComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-            agentComponent.registerAgent("test-agent", {
-                type: "primary",
-                systemPrompt: "You are a helpful assistant.",
-            });
-            // First run - session is empty
-            const result1 = await agentComponent.run("test-agent", "first query", { sessionId: "session_1" });
-            expect(result1).toBeDefined();
-            // Verify user message was added to session
-            expect(mockSessionComponent.addMessage).toHaveBeenCalled();
-            const firstCallArgs = mockSessionComponent.addMessage.mock.calls[0];
-            expect(firstCallArgs[1].role).toBe("user");
-            expect(firstCallArgs[1].content).toBe("first query");
-            // Second run - session has history, but user message SHOULD still be added
-            const result2 = await agentComponent.run("test-agent", "second query", { sessionId: "session_1" });
-            expect(result2).toBeDefined();
-            // Key assertion: user message should be added for the second query
-            const allCalls = mockSessionComponent.addMessage.mock.calls;
-            const userMessages = allCalls
-                .filter((call) => call[1].role === "user")
-                .map((call) => call[1].content);
-            // This is the critical test - second query's user message MUST be added
-            expect(userMessages).toContain("second query");
-        });
-    });
-    describe("Tool handling", () => {
-        // Note: Tool execution is tested via executeTool method directly
-        // since mock LLM integration requires more complex setup
-        it("should have default tools available", () => {
-            const mockTool = {
-                name: "test_tool",
-                description: "A test tool",
-                execute: vi.fn(() => Promise.resolve({ success: true, output: "tool result" })),
-            };
-            agentComponent.setDefaultTools([mockTool]);
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            const agent = agentComponent.getAgent("test-agent");
-            const tools = agentComponent.getAvailableTools(agent);
-            expect(tools.find(t => t.name === "test_tool")).toBeDefined();
-        });
-        it("should filter tools by name", () => {
-            const mockTool1 = { name: "tool1", execute: vi.fn() };
-            const mockTool2 = { name: "tool2", execute: vi.fn() };
-            agentComponent.setDefaultTools([mockTool1, mockTool2]);
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            const agent = agentComponent.getAgent("test-agent");
-            const tools = agentComponent.getAvailableTools(agent);
-            expect(tools).toHaveLength(2);
-            expect(tools.map(t => t.name)).toContain("tool1");
-            expect(tools.map(t => t.name)).toContain("tool2");
-        });
-    });
-    describe("Default tools", () => {
-        beforeEach(async () => {
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-        });
-        it("should set and get default tools", () => {
-            const tools = [
-                { name: "tool1", execute: vi.fn() },
-                { name: "tool2", execute: vi.fn() },
-            ];
-            agentComponent.setDefaultTools(tools);
-            agentComponent.registerAgent("test-agent", { type: "primary" });
-            const agent = agentComponent.getAgent("test-agent");
-            const availableTools = agentComponent.getAvailableTools(agent);
-            expect(availableTools).toHaveLength(2);
-        });
-        it("should filter tools by allowedTools", () => {
-            agentComponent.setDefaultTools([
-                { name: "tool1", execute: vi.fn() },
-                { name: "tool2", execute: vi.fn() },
-                { name: "tool3", execute: vi.fn() },
-            ]);
-            agentComponent.registerAgent("test-agent", {
-                type: "primary",
-                allowedTools: ["tool1", "tool2"],
-            });
-            const agent = agentComponent.getAgent("test-agent");
-            const availableTools = agentComponent.getAvailableTools(agent);
-            expect(availableTools).toHaveLength(2);
-            expect(availableTools.every(t => ["tool1", "tool2"].includes(t.name))).toBe(true);
-        });
-        it("should filter tools by deniedTools", () => {
-            agentComponent.setDefaultTools([
-                { name: "tool1", execute: vi.fn() },
-                { name: "tool2", execute: vi.fn() },
-                { name: "tool3", execute: vi.fn() },
-            ]);
-            agentComponent.registerAgent("test-agent", {
-                type: "primary",
-                deniedTools: ["tool3"],
-            });
-            const agent = agentComponent.getAgent("test-agent");
-            const availableTools = agentComponent.getAvailableTools(agent);
-            expect(availableTools).toHaveLength(2);
-            expect(availableTools.find(t => t.name === "tool3")).toBeUndefined();
-        });
-    });
-});
-// ============================================================================
-// AgentComponent Config Loading Tests (TDD)
-// ============================================================================
-describe("AgentComponent Config Loading", () => {
-    let component;
-    let configComponent;
-    let mockEnv;
-    let tempDir;
-    beforeEach(() => {
-        component = new AgentComponent();
-        configComponent = new ConfigComponent();
-        // Create temp directory for config files
-        tempDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "agent-config-test-"));
-        // Set XDG_DATA_HOME to temp directory so ConfigComponent can find config files
-        configComponent.setXdgDataHome(tempDir);
-        // Mock environment
-        mockEnv = {
-            name: "test-env",
-            version: "1.0.0",
-            getComponent: vi.fn((name) => {
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            }),
-            hasComponent: vi.fn((name) => name === "config"),
-            logger: vi.fn(),
-            trace: vi.fn(),
-        };
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-        // Clean up environment variables
-        delete process.env.AGENT_AGENT_DEFAULT_AGENT_MAX_ITERATIONS;
-        // Clean up temp directory
-        try {
-            fsSync.rmSync(tempDir, { recursive: true });
-        }
-        catch { }
-    });
-    describe("AgentComponentOptions", () => {
-        test("should accept configComponent only", async () => {
-            await component.init({
-                name: "agent",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent }
-            });
-            expect(component.getStatus()).toBe("running");
-        });
-        test("should accept configPath option", async () => {
-            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
-                agent: {
-                    defaultAgent: {
-                        maxIterations: 50
-                    }
-                }
-            }), "utf-8");
-            await component.init({
-                name: "agent",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent, configPath: "config.jsonc" }
-            });
-            expect(component.getStatus()).toBe("running");
-        });
-        test("should accept envPrefix option", async () => {
-            process.env.AGENT_AGENT_DEFAULT_AGENT_MAX_ITERATIONS = "75";
-            await component.init({
-                name: "agent",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent, envPrefix: "AGENT" }
-            });
-            expect(component.getStatus()).toBe("running");
-            delete process.env.AGENT_AGENT_DEFAULT_AGENT_MAX_ITERATIONS;
-        });
-        test("should accept config option with direct object", async () => {
-            await component.init({
-                name: "agent",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: {
-                    configComponent,
-                    config: {
-                        defaultAgent: {
-                            maxIterations: 25
-                        }
-                    }
-                }
-            });
-            expect(component.getStatus()).toBe("running");
-        });
-    });
-    describe("config priority: Object > Env > File", () => {
-        test("should Object config override Env config", async () => {
-            // Set environment variable
-            process.env.AGENT_AGENT_DEFAULT_AGENT_MAX_ITERATIONS = "50";
-            // Create file config
-            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
-                agent: { defaultAgent: { maxIterations: 100 } }
-            }), "utf-8");
-            await component.init({
-                name: "agent",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: {
-                    configComponent,
-                    configPath: "config.jsonc",
-                    envPrefix: "AGENT",
-                    config: { defaultAgent: { maxIterations: 25 } } // Object has highest priority
-                }
-            });
-            // Object config should have highest priority
-            expect(configComponent.get("agent.defaultAgent.maxIterations")).toBe(25);
-            delete process.env.AGENT_AGENT_DEFAULT_AGENT_MAX_ITERATIONS;
-        });
-        test("should Env config override File config", async () => {
-            // Set environment variable
-            process.env.AGENT_AGENT_DEFAULT_AGENT_MAX_ITERATIONS = "50";
-            // Create file config
-            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
-                agent: { defaultAgent: { maxIterations: 100 } }
-            }), "utf-8");
-            await component.init({
-                name: "agent",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: {
-                    configComponent,
-                    configPath: "config.jsonc",
-                    envPrefix: "AGENT"
-                }
-            });
-            // Env should override file
-            expect(configComponent.get("agent.defaultAgent.maxIterations")).toBe("50");
-        });
-        test("should File config be loaded when present", async () => {
-            fsSync.writeFileSync(path.join(tempDir, "config.jsonc"), JSON.stringify({
-                agent: {
-                    defaultAgent: {
-                        maxIterations: 100,
-                        maxErrorRetries: 5
-                    }
-                }
-            }), "utf-8");
-            await component.init({
-                name: "agent",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: {
-                    configComponent,
-                    configPath: "config.jsonc"
-                }
-            });
-            expect(configComponent.get("agent.defaultAgent.maxIterations")).toBe(100);
-            expect(configComponent.get("agent.defaultAgent.maxErrorRetries")).toBe(5);
-        });
-        test("should use default values when no config provided", async () => {
-            await component.init({
-                name: "agent",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent }
-            });
-            // Default values should be used (配置统一化后应返回默认值)
-            // 注意：AGENT_DEFAULTS 中定义的是 200
-            expect(configComponent.get("agent.defaultAgent.maxIterations")).toBe(200);
-            // maxErrorRetries 没有默认值，所以应该是 undefined
-            expect(configComponent.get("agent.defaultAgent.maxErrorRetries")).toBeUndefined();
-        });
-    });
-    describe("config hot reload", () => {
-        test("should register config watcher for hot reload", async () => {
-            const watcherFn = vi.fn();
-            vi.spyOn(configComponent, "watch").mockReturnValue(watcherFn);
-            await component.init({
-                name: "agent",
-                version: "1.0.0",
-                enabled: true,
-                env: mockEnv,
-                options: { configComponent }
-            });
-            expect(configComponent.watch).toHaveBeenCalledWith("agent.*", expect.any(Function));
-        });
-    });
-    // ============================================================================
-    // TDD: Tool Results Completeness Tests
-    // 
-    // Bug: AI SDK v6 requires 1:1 correspondence between tool-calls and tool-results
-    // Error: "Tool results are missing for tool calls call_function_xxx_1, _2, _3"
-    //
-    // When processing multiple tool calls, if abort/doom-loop/hook-stopped occurs
-    // mid-processing, remaining tool calls don't get results, causing AI SDK errors.
-    // ============================================================================
-    describe("Tool Results Completeness (TDD)", () => {
-        let agentComponent;
-        let mockEnv;
-        let configComponent;
-        beforeEach(async () => {
-            vi.clearAllMocks();
-            agentComponent = new AgentComponent();
-            configComponent = new ConfigComponent();
-            mockEnv = {
-                name: "test-env",
-                version: "1.0.0",
-                getConfig: vi.fn(() => ({ name: "test-env", version: "1.0.0", enabled: true })),
-                registerComponent: vi.fn(),
-                unregisterComponent: vi.fn(),
-                getComponent: vi.fn((name) => {
-                    if (name === "config")
-                        return configComponent;
-                    return undefined;
-                }),
-                hasComponent: vi.fn((name) => name === "config"),
-                listComponents: vi.fn(() => []),
-                handle_query: vi.fn(),
-                handle_action: vi.fn(),
-                subscribe: vi.fn(() => () => { }),
-                subscribeTo: vi.fn(() => () => { }),
-                subscribeAll: vi.fn(() => () => { }),
-                pushEnvEvent: vi.fn(),
-            };
-            await agentComponent.init({ env: mockEnv, options: { configComponent } });
-        });
-        afterEach(() => {
-            delete process.env.AGENT_AGENT_DEFAULT_AGENT_MAX_ITERATIONS;
-        });
-        describe("addRemainingToolResults helper", () => {
-            it("should add placeholder results for all remaining tool calls", () => {
-                // Register agent
-                agentComponent.registerAgent("test-agent", { type: "primary" });
-                // Access private method for testing
-                const agent = agentComponent.getAgent("test-agent");
-                const messages = [];
-                const allToolCalls = [
-                    { id: "call_1", function: { name: "tool1" } },
-                    { id: "call_2", function: { name: "tool2" } },
-                    { id: "call_3", function: { name: "tool3" } },
-                ];
-                // Call the helper (we'll test via run() method behavior instead)
-                // For now, just verify the structure
-                expect(allToolCalls).toHaveLength(3);
-            });
-        });
-        describe("abort during tool call processing", () => {
-            it("should add placeholder results for unprocessed tool calls when abort occurs", async () => {
-                agentComponent.registerAgent("test-agent", {
-                    type: "primary",
-                    maxIterations: 10,
-                });
-                // Mock LLMComponent that returns 3 tool calls
-                const mockLLMComponent = {
-                    invoke: vi.fn(() => Promise.resolve({
-                        output: {
-                            content: "",
-                            toolCalls: [
-                                { id: "call_1", function: { name: "tool1", arguments: "{}" } },
-                                { id: "call_2", function: { name: "tool2", arguments: "{}" } },
-                                { id: "call_3", function: { name: "tool3", arguments: "{}" } },
-                            ]
-                        }
-                    }))
-                };
-                mockEnv.getComponent.mockReturnValue(mockLLMComponent);
-                // Mock tool execution - execute first tool, then abort
-                const mockTool = {
-                    name: "tool1",
-                    execute: vi.fn(async () => {
-                        // Simulate abort after first tool
-                        agentComponent.abort("test-agent");
-                        return { success: true, output: "result1" };
-                    }),
-                };
-                const mockTool2 = { name: "tool2", execute: vi.fn() };
-                const mockTool3 = { name: "tool3", execute: vi.fn() };
-                agentComponent.setDefaultTools([mockTool, mockTool2, mockTool3]);
-                // Run agent
-                const result = await agentComponent.run("test-agent", "Execute multiple tools and abort");
-                // Verify: result should indicate stopped
-                expect(result.stopped).toBe(true);
-                // The key test: run() should complete without throwing MissingToolResultsError
-                // This is verified by the fact that we reach here without error
-                expect(true).toBe(true);
-                // The key assertion: there should be no MissingToolResultsError
-                // This is verified by the fact that run() completed without throwing
-                expect(true).toBe(true); // If we reach here, the bug is fixed
-            });
-        });
-        describe("doom loop detection during tool call processing", () => {
-            it("should add placeholder results for unprocessed tool calls when doom loop detected", async () => {
-                agentComponent.registerAgent("test-agent", {
-                    type: "primary",
-                    maxIterations: 10,
-                    doomLoopThreshold: 2, // Trigger doom loop quickly
-                });
-                // Mock LLMComponent that returns same tool call repeatedly
-                const mockLLMComponent = {
-                    invoke: vi.fn(() => Promise.resolve({
-                        output: {
-                            content: "",
-                            toolCalls: [
-                                { id: "call_1", function: { name: "repeat_tool", arguments: '{"key":"value"}' } },
-                                { id: "call_2", function: { name: "repeat_tool", arguments: '{"key":"value"}' } },
-                                { id: "call_3", function: { name: "repeat_tool", arguments: '{"key":"value"}' } },
-                            ]
-                        }
-                    }))
-                };
-                mockEnv.getComponent.mockReturnValue(mockLLMComponent);
-                // Mock tool that returns same result (causing doom loop)
-                const mockTool = {
-                    name: "repeat_tool",
-                    execute: vi.fn(() => Promise.resolve({ success: true, output: "same_result" })),
-                };
-                agentComponent.setDefaultTools([mockTool]);
-                // Run agent - should trigger doom loop detection
-                // After doom loop, remaining tool calls should get placeholder results
-                // This should not throw MissingToolResultsError
-                try {
-                    const result = await agentComponent.run("test-agent", "Trigger doom loop");
-                    // If we reach here without error, the fix is working
-                    expect(result.error).toContain("Doom loop");
-                }
-                catch (error) {
-                    // Should NOT contain MissingToolResultsError
-                    expect(error.message).not.toContain("Tool results are missing");
-                }
-            });
-            it("should reset doom loop count across iterations (not accumulate across iterations)", async () => {
-                agentComponent.registerAgent("test-agent", {
-                    type: "primary",
-                    maxIterations: 10,
-                    doomLoopThreshold: 3, // Need 3+ same calls within one iteration to trigger
-                });
-                let invokeCount = 0;
-                // Mock LLMComponent: 
-                // - Iteration 1: returns same tool call once (count=1, not enough to trigger)
-                // - Iteration 2: returns same tool call once (count should reset to 1, not 2!)
-                // - Iteration 3: returns same tool call once (count should reset to 1, not 3!)
-                // If doom loop count accumulates across iterations, iteration 3 would trigger doom loop
-                // If doom loop count resets per iteration, it should NOT trigger doom loop
-                const mockLLMComponent = {
-                    invoke: vi.fn(() => {
-                        invokeCount++;
-                        return Promise.resolve({
-                            output: {
-                                content: invokeCount >= 4 ? "done" : "", // Stop after 3 iterations
-                                toolCalls: [
-                                    { id: `call_${invokeCount}`, function: { name: "repeat_tool", arguments: '{"key":"value"}' } },
-                                ]
-                            }
-                        });
-                    })
-                };
-                mockEnv.getComponent.mockReturnValue(mockLLMComponent);
-                // Mock tool that returns same result
-                const mockTool = {
-                    name: "repeat_tool",
-                    execute: vi.fn(() => Promise.resolve({ success: true, output: "same_result" })),
-                };
-                agentComponent.setDefaultTools([mockTool]);
-                const result = await agentComponent.run("test-agent", "Test doom loop reset across iterations");
-                // Should NOT trigger doom loop because count should reset each iteration
-                // If this test fails, it means doom loop count accumulated across iterations
-                expect(result.error).toBeUndefined();
-                // Should complete with max iterations reached or text response
-                expect(result.iterations).toBeGreaterThanOrEqual(3);
-            });
-        });
-        describe("hook _stopped during tool call processing", () => {
-            it("should add placeholder results when before.tool hook stops execution", async () => {
-                agentComponent.registerAgent("test-agent", {
-                    type: "primary",
-                    maxIterations: 10,
-                });
-                // Mock LLMComponent that returns 3 tool calls
-                const mockLLMComponent = {
-                    invoke: vi.fn(() => Promise.resolve({
-                        output: {
-                            content: "",
-                            toolCalls: [
-                                { id: "call_1", function: { name: "tool1", arguments: "{}" } },
-                                { id: "call_2", function: { name: "tool2", arguments: "{}" } },
-                                { id: "call_3", function: { name: "tool3", arguments: "{}" } },
-                            ]
-                        }
-                    }))
-                };
-                mockEnv.getComponent.mockReturnValue(mockLLMComponent);
-                // Mock tool
-                const mockTool = { name: "tool1", execute: vi.fn() };
-                const mockTool2 = { name: "tool2", execute: vi.fn() };
-                const mockTool3 = { name: "tool3", execute: vi.fn() };
-                agentComponent.setDefaultTools([mockTool, mockTool2, mockTool3]);
-                // Register plugin that stops execution after first tool
-                const plugin = {
-                    name: "stop-after-first-tool",
-                    version: "1.0.0",
-                    hooks: [{ point: "agent:before.tool" }],
-                    execute: vi.fn((ctx) => {
-                        // Stop after processing tool1
-                        if (ctx.currentToolCall?.name === "tool2") {
-                            return { continue: false };
-                        }
-                        return { continue: true };
-                    }),
-                };
-                agentComponent.registerPlugin("test-agent", plugin);
-                // Run agent - should not throw MissingToolResultsError
-                try {
-                    const result = await agentComponent.run("test-agent", "Execute with stopping hook");
-                    // If we reach here without error, the fix is working
-                    expect(result.stopped).toBe(true);
-                }
-                catch (error) {
-                    // Should NOT contain MissingToolResultsError
-                    expect(error.message).not.toContain("Tool results are missing");
-                }
-            });
-        });
-        describe("_stopped state propagation to next iteration", () => {
-            it("should break while loop when _stopped is set by hook in previous iteration", async () => {
-                agentComponent.registerAgent("test-agent", {
-                    type: "primary",
-                    maxIterations: 10,
-                });
-                let iteration = 0;
-                const mockLLMComponent = {
-                    invoke: vi.fn(() => {
-                        iteration++;
-                        if (iteration === 1) {
-                            // First iteration: returns tool call and sets _stopped via hook
-                            return Promise.resolve({
-                                output: {
-                                    content: "",
-                                    toolCalls: [
-                                        { id: "call_1", function: { name: "tool1", arguments: "{}" } },
-                                    ]
-                                }
-                            });
-                        }
-                        // Second iteration should NOT happen
-                        return Promise.resolve({
-                            output: {
-                                content: "should not reach here",
-                                toolCalls: []
-                            }
-                        });
-                    })
-                };
-                mockEnv.getComponent.mockReturnValue(mockLLMComponent);
-                const mockTool = {
-                    name: "tool1",
-                    execute: vi.fn(() => Promise.resolve({ success: true, output: "result" }))
-                };
-                agentComponent.setDefaultTools([mockTool]);
-                // Register hook that sets _stopped after first iteration's on.iteration
-                let firstIterationComplete = false;
-                const plugin = {
-                    name: "stop-after-first-iteration",
-                    version: "1.0.0",
-                    hooks: [{ point: "agent:on.iteration" }],
-                    execute: vi.fn((ctx) => {
-                        if (!firstIterationComplete) {
-                            firstIterationComplete = true;
-                            ctx._stopped = true;
-                            ctx._stopReason = "stopped by hook";
-                        }
-                        return { continue: true };
-                    }),
-                };
-                agentComponent.registerPlugin("test-agent", plugin);
-                // Run agent
-                const result = await agentComponent.run("test-agent", "Test _stopped propagation");
-                // Verify: should only run 1 iteration (not 2)
-                expect(result.iterations).toBe(1);
-                expect(mockLLMComponent.invoke).toHaveBeenCalledTimes(1);
-            });
-        });
-    });
-    describe("getConversationHistory", () => {
-        let mockSessionComponent;
-        let agent;
-        beforeEach(async () => {
-            agent = new AgentComponent();
-            await agent.init({ env: mockEnv, options: { configComponent } });
-            // Create mock session component with getContext (new implementation)
-            mockSessionComponent = {
-                getContext: vi.fn(),
-            };
-            // Update mockEnv to return our mock session component
-            mockEnv.getComponent.mockImplementation((name) => {
-                if (name === "session")
-                    return mockSessionComponent;
-                if (name === "config")
-                    return configComponent;
-                return undefined;
-            });
-        });
-        it("应该返回空数组当会话没有消息", async () => {
-            mockSessionComponent.getContext.mockResolvedValue({
-                messages: []
-            });
-            const history = await agent.getConversationHistory(mockSessionComponent, "session_123", { minUserMessages: 5 });
-            expect(history).toEqual([]);
-        });
-        it("应该使用 getContext 获取消息并从 user 消息边界截取", async () => {
-            const sessionId = "session_123";
-            // getContext 已经处理了 minUserMessages 逻辑，直接返回从 user 边界截取后的消息
-            const mockMessages = [
-                { id: "msg_3", role: "user", content: "User 2", metadata: {} },
-                { id: "msg_4", role: "assistant", content: "Assistant 2", metadata: {} },
-                { id: "msg_5", role: "user", content: "User 3", metadata: {} },
-                { id: "msg_6", role: "assistant", content: "Assistant 3", metadata: {} },
-            ];
-            mockSessionComponent.getContext.mockResolvedValue({
-                messages: mockMessages
-            });
-            const history = await agent.getConversationHistory(mockSessionComponent, sessionId, { minUserMessages: 2 });
-            // Verify: getContext should be called with fullHistory=false and minUserMessages
-            expect(mockSessionComponent.getContext).toHaveBeenCalledWith(sessionId, {
-                fullHistory: false,
-                minUserMessages: 2,
-            });
-            expect(history).toHaveLength(4);
-            expect(history.map((m) => m.content)).toEqual([
-                "User 2", "Assistant 2", "User 3", "Assistant 3"
-            ]);
-        });
-        it("应该正确处理 filterHistory=true 时过滤 tool 消息", async () => {
-            const mockMessages = [
-                { id: "msg_0", role: "user", content: "User 1", metadata: {} },
-                { id: "msg_1", role: "assistant", content: "Assistant 1", metadata: {} },
-                { id: "msg_2", role: "tool", content: "tool result", metadata: { type: "tool_result" } },
-                { id: "msg_3", role: "assistant", content: "Assistant 2", metadata: {} },
-            ];
-            mockSessionComponent.getContext.mockResolvedValue({
-                messages: mockMessages
-            });
-            const history = await agent.getConversationHistory(mockSessionComponent, "session_123", { filterHistory: true });
-            // Should filter out tool messages
-            expect(history).toHaveLength(3);
-            expect(history.map((m) => m.role)).toEqual(["user", "assistant", "assistant"]);
-            expect(history.find((m) => m.role === "tool")).toBeUndefined();
-        });
-        it("应该正确处理 filterHistory=false 时保留所有消息", async () => {
-            const mockMessages = [
-                { id: "msg_0", role: "user", content: "User 1", metadata: {} },
-                { id: "msg_1", role: "assistant", content: "Assistant 1", metadata: {} },
-                { id: "msg_2", role: "tool", content: "tool result", metadata: { type: "tool_result" } },
-                { id: "msg_3", role: "assistant", content: "Assistant 2", metadata: {} },
-            ];
-            mockSessionComponent.getContext.mockResolvedValue({
-                messages: mockMessages
-            });
-            const history = await agent.getConversationHistory(mockSessionComponent, "session_123", { filterHistory: false });
-            // Should keep all messages including tool
-            expect(history).toHaveLength(4);
-            expect(history.map((m) => m.role)).toEqual(["user", "assistant", "tool", "assistant"]);
-        });
-        it("默认 filterHistory=false（不指定时）", async () => {
-            const mockMessages = [
-                { id: "msg_0", role: "user", content: "User 1", metadata: {} },
-                { id: "msg_1", role: "assistant", content: "Assistant 1", metadata: {} },
-                { id: "msg_2", role: "tool", content: "tool result", metadata: { type: "tool_result" } },
-                { id: "msg_3", role: "assistant", content: "Assistant 2", metadata: {} },
-            ];
-            mockSessionComponent.getContext.mockResolvedValue({
-                messages: mockMessages
-            });
-            // 不指定 filterHistory 参数
-            const history = await agent.getConversationHistory(mockSessionComponent, "session_123", {});
-            // 默认应该保留所有消息（包括 tool 消息）
-            expect(history).toHaveLength(4);
-            expect(history.map((m) => m.role)).toEqual(["user", "assistant", "tool", "assistant"]);
-        });
-        it("应该正确处理消息少于 minUserMessages 的情况", async () => {
-            const mockMessages = [
-                { id: "msg_0", role: "user", content: "User 1", metadata: {} },
-                { id: "msg_1", role: "assistant", content: "Assistant 1", metadata: {} },
-            ];
-            mockSessionComponent.getContext.mockResolvedValue({
-                messages: mockMessages
-            });
-            // 当消息少于 minUserMessages 时，getContext 会返回所有消息
-            const history = await agent.getConversationHistory(mockSessionComponent, "session_123", { minUserMessages: 5 });
-            expect(mockSessionComponent.getContext).toHaveBeenCalledWith("session_123", {
-                fullHistory: false,
-                minUserMessages: 5,
-            });
-            expect(history).toHaveLength(2);
-        });
-    });
-});
-// ============================================================================
-// toLLMMessage Tests
-// ============================================================================
-describe("toLLMMessage (message conversion)", () => {
-    // Helper function extracted from agent-component.ts for testing
-    function toLLMMessage(msg) {
-        let content;
-        let toolCallId;
-        let toolName;
-        let toolCalls;
-        if (typeof msg.content === "string") {
-            content = msg.content;
-            if (msg.role === "tool") {
-                toolCallId = msg.toolCallId;
-                toolName = msg.toolName;
-            }
-            if (msg.role === "assistant" && msg.toolCalls) {
-                toolCalls = msg.toolCalls;
-            }
-        }
-        else if (Array.isArray(msg.content)) {
-            if (msg.role === "tool") {
-                const toolResult = msg.content.find((part) => part.type === "tool-result");
-                const output = toolResult?.output;
-                if (typeof output === "string") {
-                    content = output;
-                }
-                else if (output && typeof output === "object" && "value" in output) {
-                    content = output.value?.toString() || "";
-                }
-                else {
-                    content = JSON.stringify(output) || "";
-                }
-                toolCallId = toolResult?.toolCallId;
-                toolName = toolResult?.toolName;
-            }
-            else {
-                const textParts = msg.content.filter((part) => part.type === "text");
-                const toolCallParts = msg.content.filter((part) => part.type === "tool-call");
-                content = textParts.map((part) => part.text || "").join("");
-                // Fixed: handle flat tool-call format from toModelMessage
-                if (msg.role === "assistant" && toolCallParts.length > 0) {
-                    toolCalls = toolCallParts.map((part) => {
-                        const argsString = typeof part.input === "string"
-                            ? part.input
-                            : JSON.stringify(part.input || {});
-                        const name = part.toolName || "unknown";
-                        return {
-                            id: part.toolCallId,
-                            name: name,
-                            arguments: argsString,
-                            function: {
-                                name: name,
-                                arguments: argsString,
-                            },
-                        };
-                    });
-                }
-            }
-        }
-        else {
-            content = "";
-        }
-        return {
-            role: msg.role,
-            content,
-            ...(toolCallId ? { toolCallId } : {}),
-            ...(toolName ? { name: toolName } : {}),
-            ...(toolCalls && toolCalls.length > 0 ? { toolCalls } : {}),
-        };
-    }
-    it("should convert assistant message with tool-call parts (flat format from toModelMessage)", () => {
-        // Simulate the format generated by SessionMessageConverter.toModelMessage
-        const modelMessage = {
-            role: "assistant",
-            content: [
-                { type: "text", text: "I'll search for that" },
-                { type: "tool-call", toolCallId: "call_123", toolName: "search", input: { query: "test" } }
-            ]
-        };
-        const result = toLLMMessage(modelMessage);
-        expect(result.role).toBe("assistant");
-        expect(result.content).toBe("I'll search for that");
-        expect(result.toolCalls).toBeDefined();
-        expect(result.toolCalls).toHaveLength(1);
-        expect(result.toolCalls[0]).toEqual({
-            id: "call_123",
-            name: "search",
-            arguments: '{"query":"test"}',
-            function: {
-                name: "search",
-                arguments: '{"query":"test"}',
-            },
-        });
-    });
-    it("should convert tool message with tool-result part", () => {
-        const modelMessage = {
-            role: "tool",
-            content: [
-                { type: "tool-result", toolCallId: "call_123", toolName: "search", output: "search results" }
-            ]
-        };
-        const result = toLLMMessage(modelMessage);
-        expect(result.role).toBe("tool");
-        expect(result.content).toBe("search results");
-        expect(result.toolCallId).toBe("call_123");
-        expect(result.name).toBe("search");
-    });
-    it("should convert tool message with nested output format", () => {
-        const modelMessage = {
-            role: "tool",
-            content: [
-                { type: "tool-result", toolCallId: "call_456", toolName: "bash", output: { type: "text", value: "command output" } }
-            ]
-        };
-        const result = toLLMMessage(modelMessage);
-        expect(result.role).toBe("tool");
-        expect(result.content).toBe("command output");
-    });
-    it("should preserve text content when tool-call parts are present", () => {
-        const modelMessage = {
-            role: "assistant",
-            content: [
-                { type: "reasoning", text: "I need to run a command" },
-                { type: "text", text: "Running the command now" },
-                { type: "tool-call", toolCallId: "call_789", toolName: "bash", input: { command: "ls" } }
-            ]
-        };
-        const result = toLLMMessage(modelMessage);
-        expect(result.content).toBe("Running the command now");
-        expect(result.toolCalls).toHaveLength(1);
-        expect(result.toolCalls[0].name).toBe("bash");
-    });
-});
-//# sourceMappingURL=agent-component.test.js.map