@shuttl-io/core 0.2.0

package/dist/tests/agentStreamer.test.js

@@ -0,0 +1,530 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("events");
+// Create mock stdout before imports
+const mockStdoutWrite = jest.fn();
+// Mock process module
+jest.mock("process", () => ({
+    stdin: new events_1.EventEmitter(),
+    stdout: {
+        write: (data) => mockStdoutWrite(data),
+    },
+}));
+const agent_1 = require("../src/agent");
+const tool_1 = require("../src/tools/tool");
+const toolkit_1 = require("../src/tools/toolkit");
+// Mock tool implementation for testing
+class MockTool {
+    constructor(name, description) {
+        this.executeResult = { result: "success" };
+        this.name = name;
+        this.description = description;
+        this.schema = tool_1.Schema.objectValue({});
+    }
+    execute(_args) {
+        return this.executeResult;
+    }
+}
+// Mock model for testing
+class MockModel {
+    constructor() {
+        this.threadId = "mock-thread-id";
+        this.invokedWith = [];
+    }
+    async invoke(prompt, _streamer) {
+        this.invokedWith.push(prompt);
+    }
+}
+// Mock model factory
+class MockModelFactory {
+    constructor(model) {
+        this.mockModel = model ?? new MockModel();
+    }
+    async create(_props) {
+        return this.mockModel;
+    }
+}
+describe("AgentStreamer", () => {
+    beforeEach(() => {
+        mockStdoutWrite.mockClear();
+    });
+    // Helper to parse stdout writes
+    const getWrittenMessages = () => {
+        return mockStdoutWrite.mock.calls.map((call) => {
+            const json = call[0].replace(/\n$/, "");
+            return JSON.parse(json);
+        });
+    };
+    const getLastMessage = () => {
+        const messages = getWrittenMessages();
+        return messages[messages.length - 1];
+    };
+    describe("constructor", () => {
+        it("should create an AgentStreamer with agent and controlID", () => {
+            const mockFactory = new MockModelFactory();
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test prompt",
+                model: mockFactory,
+            });
+            const streamer = new agent_1.AgentStreamer(agent, "control-123");
+            expect(streamer).toBeInstanceOf(agent_1.AgentStreamer);
+        });
+    });
+    describe("recieve()", () => {
+        let agent;
+        let streamer;
+        let mockModel;
+        beforeEach(() => {
+            mockModel = new MockModel();
+            const mockFactory = new MockModelFactory(mockModel);
+            const tool = new MockTool("test_tool", "A test tool");
+            const toolkit = new toolkit_1.Toolkit({
+                name: "TestToolkit",
+                tools: [tool],
+            });
+            agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [toolkit],
+                systemPrompt: "Test prompt",
+                model: mockFactory,
+            });
+            streamer = new agent_1.AgentStreamer(agent, "test-control-id");
+        });
+        it("should handle undefined data", async () => {
+            const response = {
+                eventName: "response.something",
+                data: undefined,
+            };
+            await streamer.recieve(mockModel, response);
+            // Should not write anything for undefined data
+            expect(mockStdoutWrite).not.toHaveBeenCalled();
+        });
+        describe("tool_call handling", () => {
+            it("should write tool_call event to stdout", async () => {
+                const response = {
+                    eventName: "response.function_call",
+                    data: {
+                        typeName: "tool_call",
+                        toolCall: {
+                            outputType: "tool_call",
+                            name: "test_tool",
+                            arguments: { arg: "value" },
+                            callId: "call-1",
+                        },
+                    },
+                };
+                await streamer.recieve(mockModel, response);
+                const message = getLastMessage();
+                expect(message.id).toBe("test-control-id");
+                expect(message.type).toBe("tool_call");
+                expect(message.success).toBe(true);
+                expect(message.result.typeName).toBe("tool_call");
+            });
+        });
+        describe("output_text handling", () => {
+            it("should write output_text event to stdout", async () => {
+                const response = {
+                    eventName: "response.output_text.done",
+                    data: {
+                        typeName: "output_text",
+                        outputText: {
+                            outputType: "output_text",
+                            text: "Hello, world!",
+                        },
+                    },
+                };
+                await streamer.recieve(mockModel, response);
+                const message = getLastMessage();
+                expect(message.id).toBe("test-control-id");
+                expect(message.type).toBe("output_text");
+                expect(message.success).toBe(true);
+            });
+        });
+        describe("output_text_delta handling", () => {
+            it("should write output_text_delta event to stdout", async () => {
+                const response = {
+                    eventName: "response.output_text.delta",
+                    data: {
+                        typeName: "output_text_delta",
+                        outputTextDelta: {
+                            outputType: "output_text_delta",
+                            delta: "Hello",
+                            sequenceNumber: 1,
+                        },
+                    },
+                };
+                await streamer.recieve(mockModel, response);
+                const message = getLastMessage();
+                expect(message.type).toBe("output_text_delta");
+                expect(message.success).toBe(true);
+            });
+        });
+        describe("output_text.part.done handling", () => {
+            it("should write output_text.part.done event to stdout", async () => {
+                const response = {
+                    eventName: "response.output_item.done",
+                    data: {
+                        typeName: "output_text.part.done",
+                        outputText: {
+                            outputType: "output_text",
+                            text: "Complete text",
+                        },
+                    },
+                };
+                await streamer.recieve(mockModel, response);
+                const message = getLastMessage();
+                expect(message.type).toBe("output_text.part.done");
+                expect(message.success).toBe(true);
+            });
+        });
+        describe("response.requested handling", () => {
+            it("should write response.requested event to stdout", async () => {
+                const response = {
+                    eventName: "response.requested",
+                    data: {
+                        typeName: "response.requested",
+                        requested: { model: "gpt-4" },
+                    },
+                };
+                await streamer.recieve(mockModel, response);
+                const message = getLastMessage();
+                expect(message.type).toBe("response.requested");
+                expect(message.success).toBe(true);
+            });
+        });
+        describe("array data handling", () => {
+            it("should process each item in data array", async () => {
+                const response = {
+                    eventName: "response.completed",
+                    data: [
+                        {
+                            typeName: "output_text",
+                            outputText: {
+                                outputType: "output_text",
+                                text: "First",
+                            },
+                        },
+                        {
+                            typeName: "output_text",
+                            outputText: {
+                                outputType: "output_text",
+                                text: "Second",
+                            },
+                        },
+                    ],
+                };
+                await streamer.recieve(mockModel, response);
+                const messages = getWrittenMessages();
+                // Should have written twice for the two data items
+                expect(messages.filter(m => m.type === "output_text").length).toBe(2);
+            });
+        });
+    });
+    describe("write() output format", () => {
+        let agent;
+        let streamer;
+        let mockModel;
+        beforeEach(() => {
+            mockModel = new MockModel();
+            const mockFactory = new MockModelFactory(mockModel);
+            agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test prompt",
+                model: mockFactory,
+            });
+            streamer = new agent_1.AgentStreamer(agent, "control-id-456");
+        });
+        it("should output valid JSON with newline", async () => {
+            const response = {
+                eventName: "test",
+                data: {
+                    typeName: "output_text",
+                    outputText: { outputType: "output_text", text: "test" },
+                },
+            };
+            await streamer.recieve(mockModel, response);
+            const call = mockStdoutWrite.mock.calls[0][0];
+            expect(call.endsWith("\n")).toBe(true);
+            expect(() => JSON.parse(call)).not.toThrow();
+        });
+        it("should include controlID as id in output", async () => {
+            const response = {
+                eventName: "test",
+                data: {
+                    typeName: "output_text",
+                    outputText: { outputType: "output_text", text: "test" },
+                },
+            };
+            await streamer.recieve(mockModel, response);
+            const message = getLastMessage();
+            expect(message.id).toBe("control-id-456");
+        });
+        it("should include success: true for successful messages", async () => {
+            const response = {
+                eventName: "test",
+                data: {
+                    typeName: "output_text",
+                    outputText: { outputType: "output_text", text: "test" },
+                },
+            };
+            await streamer.recieve(mockModel, response);
+            const message = getLastMessage();
+            expect(message.success).toBe(true);
+        });
+        it("should include result field with data", async () => {
+            const response = {
+                eventName: "test",
+                data: {
+                    typeName: "output_text",
+                    outputText: { outputType: "output_text", text: "the text" },
+                },
+            };
+            await streamer.recieve(mockModel, response);
+            const message = getLastMessage();
+            expect(message.result).toBeDefined();
+            expect(message.result.typeName).toBe("output_text");
+        });
+    });
+    describe("integration with Agent", () => {
+        it("should be created by Agent.invoke when no streamer provided", async () => {
+            const mockModel = new MockModel();
+            const mockFactory = new MockModelFactory(mockModel);
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test prompt",
+                model: mockFactory,
+            });
+            // When invoke is called without a streamer, a default AgentStreamer should be created
+            await agent.invoke("Test prompt");
+            expect(mockModel.invokedWith.length).toBeGreaterThan(0);
+        });
+        it("should be used by Agent.invoke when provided", async () => {
+            const mockModel = new MockModel();
+            const mockFactory = new MockModelFactory(mockModel);
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test prompt",
+                model: mockFactory,
+            });
+            const customStreamer = new agent_1.AgentStreamer(agent, "custom-control");
+            await agent.invoke("Test prompt", undefined, customStreamer);
+            expect(mockModel.invokedWith.length).toBeGreaterThan(0);
+        });
+    });
+});
+describe("Agent additional tests", () => {
+    describe("getTool()", () => {
+        it("should return a tool by name", () => {
+            const tool = new MockTool("my_tool", "My tool");
+            const toolkit = new toolkit_1.Toolkit({
+                name: "MyToolkit",
+                tools: [tool],
+            });
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [toolkit],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            const foundTool = agent.getTool("my_tool");
+            expect(foundTool).toBe(tool);
+        });
+        it("should throw error if tool not found", () => {
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            expect(() => agent.getTool("nonexistent")).toThrow("Tool nonexistent not found");
+        });
+        it("should find tools from multiple toolkits", () => {
+            const tool1 = new MockTool("tool1", "Tool 1");
+            const tool2 = new MockTool("tool2", "Tool 2");
+            const toolkit1 = new toolkit_1.Toolkit({ name: "Toolkit1", tools: [tool1] });
+            const toolkit2 = new toolkit_1.Toolkit({ name: "Toolkit2", tools: [tool2] });
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [toolkit1, toolkit2],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            expect(agent.getTool("tool1")).toBe(tool1);
+            expect(agent.getTool("tool2")).toBe(tool2);
+        });
+    });
+    describe("getToolCallResult()", () => {
+        it("should format tool call result correctly", () => {
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            const result = agent.getToolCallResult("call-123", { data: "value" });
+            expect(result.call_id).toBe("call-123");
+            expect(result.type).toBe("function_call_output");
+            expect(result.output).toBe(JSON.stringify({ data: "value" }));
+        });
+        it("should stringify complex results", () => {
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            const complexResult = {
+                items: [1, 2, 3],
+                nested: { key: "value" },
+                bool: true,
+            };
+            const result = agent.getToolCallResult("call-456", complexResult);
+            expect(JSON.parse(result.output)).toEqual(complexResult);
+        });
+        it("should handle null results", () => {
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            const result = agent.getToolCallResult("call-null", null);
+            expect(result.output).toBe("null");
+        });
+        it("should handle string results", () => {
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            const result = agent.getToolCallResult("call-str", "simple string");
+            expect(result.output).toBe('"simple string"');
+        });
+    });
+    describe("invoke() with threadId", () => {
+        it("should throw error for non-existent threadId", async () => {
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            await expect(agent.invoke("Hello", "nonexistent-thread")).rejects.toThrow("Model instance with threadId nonexistent-thread not found");
+        });
+        it("should reuse model instance for existing threadId", async () => {
+            const mockModel = new MockModel();
+            const mockFactory = new MockModelFactory(mockModel);
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: mockFactory,
+            });
+            // First invoke creates the model
+            const model1 = await agent.invoke("First message");
+            const threadId = model1.threadId;
+            // Second invoke with same threadId should reuse
+            const model2 = await agent.invoke("Second message", threadId);
+            expect(model1).toBe(model2);
+            expect(mockModel.invokedWith.length).toBe(2);
+        });
+    });
+    describe("triggers and outcomes", () => {
+        it("should initialize with default ApiTrigger when no triggers provided", () => {
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            expect(agent.triggers).toHaveLength(1);
+            expect(agent.triggers[0].triggerType).toBe("api");
+        });
+        it("should initialize with default StreamingOutcome when no outcomes provided", () => {
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+            });
+            expect(agent.outcomes).toHaveLength(1);
+            expect(agent.outcomes[0]).toBeDefined();
+        });
+        it("should store provided triggers", () => {
+            const trigger = {
+                name: "test",
+                triggerType: "event",
+                triggerConfig: {},
+                activate: jest.fn(),
+                validate: jest.fn(),
+                outcome: undefined,
+                bindOutcome: jest.fn().mockReturnThis(),
+                withName: jest.fn().mockReturnThis(),
+            };
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+                triggers: [trigger],
+            });
+            expect(agent.triggers).toHaveLength(1);
+            expect(agent.triggers[0]).toBe(trigger);
+        });
+        it("should store provided outcomes", () => {
+            const outcome = { send: jest.fn(), bindToRequest: jest.fn() };
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+                outcomes: [outcome],
+            });
+            expect(agent.outcomes).toHaveLength(1);
+            expect(agent.outcomes[0]).toBe(outcome);
+        });
+    });
+    describe("tools from props", () => {
+        it("should accept standalone tools in addition to toolkit tools", () => {
+            const toolkitTool = new MockTool("toolkit_tool", "From toolkit");
+            const standaloneTool = new MockTool("standalone_tool", "Standalone");
+            const toolkit = new toolkit_1.Toolkit({
+                name: "TestToolkit",
+                tools: [toolkitTool],
+            });
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [toolkit],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+                tools: [standaloneTool],
+            });
+            expect(agent.tools).toContain(standaloneTool);
+            expect(agent.tools).toContain(toolkitTool);
+        });
+        it("should be able to find both toolkit and standalone tools", () => {
+            const toolkitTool = new MockTool("toolkit_tool", "From toolkit");
+            const standaloneTool = new MockTool("standalone_tool", "Standalone");
+            const toolkit = new toolkit_1.Toolkit({
+                name: "TestToolkit",
+                tools: [toolkitTool],
+            });
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [toolkit],
+                systemPrompt: "Test",
+                model: new MockModelFactory(),
+                tools: [standaloneTool],
+            });
+            expect(agent.getTool("toolkit_tool")).toBe(toolkitTool);
+            expect(agent.getTool("standalone_tool")).toBe(standaloneTool);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agentStreamer.test.js","sourceRoot":"","sources":["../../tests/agentStreamer.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { EventEmitter } from \"events\";\n\n// Create mock stdout before imports\nconst mockStdoutWrite = jest.fn();\n\n// Mock process module\njest.mock(\"process\", () => ({\n    stdin: new EventEmitter(),\n    stdout: {\n        write: (data: string) => mockStdoutWrite(data),\n    },\n}));\n\nimport { Agent, AgentStreamer } from \"../src/agent\";\nimport { IModel, IModelFactory, IModelStreamer, ModelContent, ModelResponse, ToolCallResponse } from \"../src/models/types\";\nimport { ITool, Schema } from \"../src/tools/tool\";\nimport { Toolkit } from \"../src/tools/toolkit\";\n\n// Mock tool implementation for testing\nclass MockTool implements ITool {\n    public name: string;\n    public description: string;\n    public schema: Schema;\n    public executeResult: unknown = { result: \"success\" };\n\n    constructor(name: string, description: string) {\n        this.name = name;\n        this.description = description;\n        this.schema = Schema.objectValue({});\n    }\n\n    execute(_args: Record<string, unknown>): unknown {\n        return this.executeResult;\n    }\n}\n\n// Mock model for testing\nclass MockModel implements IModel {\n    public readonly threadId?: string = \"mock-thread-id\";\n    public invokedWith: (ModelContent | ToolCallResponse)[][] = [];\n\n    async invoke(prompt: (ModelContent | ToolCallResponse)[], _streamer: IModelStreamer): Promise<void> {\n        this.invokedWith.push(prompt);\n    }\n}\n\n// Mock model factory\nclass MockModelFactory implements IModelFactory {\n    private mockModel: MockModel;\n\n    constructor(model?: MockModel) {\n        this.mockModel = model ?? new MockModel();\n    }\n\n    async create(_props: { systemPrompt: string }): Promise<IModel> {\n        return this.mockModel;\n    }\n}\n\ndescribe(\"AgentStreamer\", () => {\n    beforeEach(() => {\n        mockStdoutWrite.mockClear();\n    });\n\n    // Helper to parse stdout writes\n    const getWrittenMessages = () => {\n        return mockStdoutWrite.mock.calls.map((call) => {\n            const json = call[0].replace(/\\n$/, \"\");\n            return JSON.parse(json);\n        });\n    };\n\n    const getLastMessage = () => {\n        const messages = getWrittenMessages();\n        return messages[messages.length - 1];\n    };\n\n    describe(\"constructor\", () => {\n        it(\"should create an AgentStreamer with agent and controlID\", () => {\n            const mockFactory = new MockModelFactory();\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test prompt\",\n                model: mockFactory,\n            });\n\n            const streamer = new AgentStreamer(agent, \"control-123\");\n\n            expect(streamer).toBeInstanceOf(AgentStreamer);\n        });\n    });\n\n    describe(\"recieve()\", () => {\n        let agent: Agent;\n        let streamer: AgentStreamer;\n        let mockModel: MockModel;\n\n        beforeEach(() => {\n            mockModel = new MockModel();\n            const mockFactory = new MockModelFactory(mockModel);\n            const tool = new MockTool(\"test_tool\", \"A test tool\");\n            const toolkit = new Toolkit({\n                name: \"TestToolkit\",\n                tools: [tool],\n            });\n\n            agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [toolkit],\n                systemPrompt: \"Test prompt\",\n                model: mockFactory,\n            });\n\n            streamer = new AgentStreamer(agent, \"test-control-id\");\n        });\n\n        it(\"should handle undefined data\", async () => {\n            const response: ModelResponse = {\n                eventName: \"response.something\",\n                data: undefined as any,\n            };\n\n            await streamer.recieve(mockModel, response);\n\n            // Should not write anything for undefined data\n            expect(mockStdoutWrite).not.toHaveBeenCalled();\n        });\n\n        describe(\"tool_call handling\", () => {\n            it(\"should write tool_call event to stdout\", async () => {\n                const response: ModelResponse = {\n                    eventName: \"response.function_call\",\n                    data: {\n                        typeName: \"tool_call\",\n                        toolCall: {\n                            outputType: \"tool_call\",\n                            name: \"test_tool\",\n                            arguments: { arg: \"value\" },\n                            callId: \"call-1\",\n                        },\n                    },\n                };\n\n                await streamer.recieve(mockModel, response);\n\n                const message = getLastMessage();\n                expect(message.id).toBe(\"test-control-id\");\n                expect(message.type).toBe(\"tool_call\");\n                expect(message.success).toBe(true);\n                expect(message.result.typeName).toBe(\"tool_call\");\n            });\n        });\n\n        describe(\"output_text handling\", () => {\n            it(\"should write output_text event to stdout\", async () => {\n                const response: ModelResponse = {\n                    eventName: \"response.output_text.done\",\n                    data: {\n                        typeName: \"output_text\",\n                        outputText: {\n                            outputType: \"output_text\",\n                            text: \"Hello, world!\",\n                        },\n                    },\n                };\n\n                await streamer.recieve(mockModel, response);\n\n                const message = getLastMessage();\n                expect(message.id).toBe(\"test-control-id\");\n                expect(message.type).toBe(\"output_text\");\n                expect(message.success).toBe(true);\n            });\n        });\n\n        describe(\"output_text_delta handling\", () => {\n            it(\"should write output_text_delta event to stdout\", async () => {\n                const response: ModelResponse = {\n                    eventName: \"response.output_text.delta\",\n                    data: {\n                        typeName: \"output_text_delta\",\n                        outputTextDelta: {\n                            outputType: \"output_text_delta\",\n                            delta: \"Hello\",\n                            sequenceNumber: 1,\n                        },\n                    },\n                };\n\n                await streamer.recieve(mockModel, response);\n\n                const message = getLastMessage();\n                expect(message.type).toBe(\"output_text_delta\");\n                expect(message.success).toBe(true);\n            });\n        });\n\n        describe(\"output_text.part.done handling\", () => {\n            it(\"should write output_text.part.done event to stdout\", async () => {\n                const response: ModelResponse = {\n                    eventName: \"response.output_item.done\",\n                    data: {\n                        typeName: \"output_text.part.done\",\n                        outputText: {\n                            outputType: \"output_text\",\n                            text: \"Complete text\",\n                        },\n                    },\n                };\n\n                await streamer.recieve(mockModel, response);\n\n                const message = getLastMessage();\n                expect(message.type).toBe(\"output_text.part.done\");\n                expect(message.success).toBe(true);\n            });\n        });\n\n        describe(\"response.requested handling\", () => {\n            it(\"should write response.requested event to stdout\", async () => {\n                const response: ModelResponse = {\n                    eventName: \"response.requested\",\n                    data: {\n                        typeName: \"response.requested\",\n                        requested: { model: \"gpt-4\" },\n                    },\n                };\n\n                await streamer.recieve(mockModel, response);\n\n                const message = getLastMessage();\n                expect(message.type).toBe(\"response.requested\");\n                expect(message.success).toBe(true);\n            });\n        });\n\n        describe(\"array data handling\", () => {\n            it(\"should process each item in data array\", async () => {\n                const response: ModelResponse = {\n                    eventName: \"response.completed\",\n                    data: [\n                        {\n                            typeName: \"output_text\",\n                            outputText: {\n                                outputType: \"output_text\",\n                                text: \"First\",\n                            },\n                        },\n                        {\n                            typeName: \"output_text\",\n                            outputText: {\n                                outputType: \"output_text\",\n                                text: \"Second\",\n                            },\n                        },\n                    ],\n                };\n\n                await streamer.recieve(mockModel, response);\n\n                const messages = getWrittenMessages();\n                // Should have written twice for the two data items\n                expect(messages.filter(m => m.type === \"output_text\").length).toBe(2);\n            });\n        });\n    });\n\n    describe(\"write() output format\", () => {\n        let agent: Agent;\n        let streamer: AgentStreamer;\n        let mockModel: MockModel;\n\n        beforeEach(() => {\n            mockModel = new MockModel();\n            const mockFactory = new MockModelFactory(mockModel);\n\n            agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test prompt\",\n                model: mockFactory,\n            });\n\n            streamer = new AgentStreamer(agent, \"control-id-456\");\n        });\n\n        it(\"should output valid JSON with newline\", async () => {\n            const response: ModelResponse = {\n                eventName: \"test\",\n                data: {\n                    typeName: \"output_text\",\n                    outputText: { outputType: \"output_text\", text: \"test\" },\n                },\n            };\n\n            await streamer.recieve(mockModel, response);\n\n            const call = mockStdoutWrite.mock.calls[0][0];\n            expect(call.endsWith(\"\\n\")).toBe(true);\n            expect(() => JSON.parse(call)).not.toThrow();\n        });\n\n        it(\"should include controlID as id in output\", async () => {\n            const response: ModelResponse = {\n                eventName: \"test\",\n                data: {\n                    typeName: \"output_text\",\n                    outputText: { outputType: \"output_text\", text: \"test\" },\n                },\n            };\n\n            await streamer.recieve(mockModel, response);\n\n            const message = getLastMessage();\n            expect(message.id).toBe(\"control-id-456\");\n        });\n\n        it(\"should include success: true for successful messages\", async () => {\n            const response: ModelResponse = {\n                eventName: \"test\",\n                data: {\n                    typeName: \"output_text\",\n                    outputText: { outputType: \"output_text\", text: \"test\" },\n                },\n            };\n\n            await streamer.recieve(mockModel, response);\n\n            const message = getLastMessage();\n            expect(message.success).toBe(true);\n        });\n\n        it(\"should include result field with data\", async () => {\n            const response: ModelResponse = {\n                eventName: \"test\",\n                data: {\n                    typeName: \"output_text\",\n                    outputText: { outputType: \"output_text\", text: \"the text\" },\n                },\n            };\n\n            await streamer.recieve(mockModel, response);\n\n            const message = getLastMessage();\n            expect(message.result).toBeDefined();\n            expect(message.result.typeName).toBe(\"output_text\");\n        });\n    });\n\n    describe(\"integration with Agent\", () => {\n        it(\"should be created by Agent.invoke when no streamer provided\", async () => {\n            const mockModel = new MockModel();\n            const mockFactory = new MockModelFactory(mockModel);\n\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test prompt\",\n                model: mockFactory,\n            });\n\n            // When invoke is called without a streamer, a default AgentStreamer should be created\n            await agent.invoke(\"Test prompt\");\n\n            expect(mockModel.invokedWith.length).toBeGreaterThan(0);\n        });\n\n        it(\"should be used by Agent.invoke when provided\", async () => {\n            const mockModel = new MockModel();\n            const mockFactory = new MockModelFactory(mockModel);\n\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test prompt\",\n                model: mockFactory,\n            });\n\n            const customStreamer = new AgentStreamer(agent, \"custom-control\");\n\n            await agent.invoke(\"Test prompt\", undefined, customStreamer);\n\n            expect(mockModel.invokedWith.length).toBeGreaterThan(0);\n        });\n    });\n});\n\ndescribe(\"Agent additional tests\", () => {\n    describe(\"getTool()\", () => {\n        it(\"should return a tool by name\", () => {\n            const tool = new MockTool(\"my_tool\", \"My tool\");\n            const toolkit = new Toolkit({\n                name: \"MyToolkit\",\n                tools: [tool],\n            });\n\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [toolkit],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            const foundTool = agent.getTool(\"my_tool\");\n\n            expect(foundTool).toBe(tool);\n        });\n\n        it(\"should throw error if tool not found\", () => {\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            expect(() => agent.getTool(\"nonexistent\")).toThrow(\n                \"Tool nonexistent not found\"\n            );\n        });\n\n        it(\"should find tools from multiple toolkits\", () => {\n            const tool1 = new MockTool(\"tool1\", \"Tool 1\");\n            const tool2 = new MockTool(\"tool2\", \"Tool 2\");\n            const toolkit1 = new Toolkit({ name: \"Toolkit1\", tools: [tool1] });\n            const toolkit2 = new Toolkit({ name: \"Toolkit2\", tools: [tool2] });\n\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [toolkit1, toolkit2],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            expect(agent.getTool(\"tool1\")).toBe(tool1);\n            expect(agent.getTool(\"tool2\")).toBe(tool2);\n        });\n    });\n\n    describe(\"getToolCallResult()\", () => {\n        it(\"should format tool call result correctly\", () => {\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            const result = agent.getToolCallResult(\"call-123\", { data: \"value\" });\n\n            expect(result.call_id).toBe(\"call-123\");\n            expect(result.type).toBe(\"function_call_output\");\n            expect(result.output).toBe(JSON.stringify({ data: \"value\" }));\n        });\n\n        it(\"should stringify complex results\", () => {\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            const complexResult = {\n                items: [1, 2, 3],\n                nested: { key: \"value\" },\n                bool: true,\n            };\n\n            const result = agent.getToolCallResult(\"call-456\", complexResult);\n\n            expect(JSON.parse(result.output as string)).toEqual(complexResult);\n        });\n\n        it(\"should handle null results\", () => {\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            const result = agent.getToolCallResult(\"call-null\", null);\n\n            expect(result.output).toBe(\"null\");\n        });\n\n        it(\"should handle string results\", () => {\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            const result = agent.getToolCallResult(\"call-str\", \"simple string\");\n\n            expect(result.output).toBe('\"simple string\"');\n        });\n    });\n\n    describe(\"invoke() with threadId\", () => {\n        it(\"should throw error for non-existent threadId\", async () => {\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            await expect(\n                agent.invoke(\"Hello\", \"nonexistent-thread\")\n            ).rejects.toThrow(\"Model instance with threadId nonexistent-thread not found\");\n        });\n\n        it(\"should reuse model instance for existing threadId\", async () => {\n            const mockModel = new MockModel();\n            const mockFactory = new MockModelFactory(mockModel);\n\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: mockFactory,\n            });\n\n            // First invoke creates the model\n            const model1 = await agent.invoke(\"First message\");\n            const threadId = model1.threadId;\n\n            // Second invoke with same threadId should reuse\n            const model2 = await agent.invoke(\"Second message\", threadId);\n\n            expect(model1).toBe(model2);\n            expect(mockModel.invokedWith.length).toBe(2);\n        });\n    });\n\n    describe(\"triggers and outcomes\", () => {\n        it(\"should initialize with default ApiTrigger when no triggers provided\", () => {\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            expect(agent.triggers).toHaveLength(1);\n            expect(agent.triggers[0].triggerType).toBe(\"api\");\n        });\n\n        it(\"should initialize with default StreamingOutcome when no outcomes provided\", () => {\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n            });\n\n            expect(agent.outcomes).toHaveLength(1);\n            expect(agent.outcomes[0]).toBeDefined();\n        });\n\n        it(\"should store provided triggers\", () => {\n            const trigger = { \n                name: \"test\", \n                triggerType: \"event\", \n                triggerConfig: {}, \n                activate: jest.fn(), \n                validate: jest.fn(),\n                outcome: undefined,\n                bindOutcome: jest.fn().mockReturnThis(),\n                withName: jest.fn().mockReturnThis(),\n            };\n\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n                triggers: [trigger],\n            });\n\n            expect(agent.triggers).toHaveLength(1);\n            expect(agent.triggers[0]).toBe(trigger);\n        });\n\n        it(\"should store provided outcomes\", () => {\n            const outcome = { send: jest.fn(), bindToRequest: jest.fn() };\n\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n                outcomes: [outcome],\n            });\n\n            expect(agent.outcomes).toHaveLength(1);\n            expect(agent.outcomes[0]).toBe(outcome);\n        });\n    });\n\n    describe(\"tools from props\", () => {\n        it(\"should accept standalone tools in addition to toolkit tools\", () => {\n            const toolkitTool = new MockTool(\"toolkit_tool\", \"From toolkit\");\n            const standaloneTool = new MockTool(\"standalone_tool\", \"Standalone\");\n            const toolkit = new Toolkit({\n                name: \"TestToolkit\",\n                tools: [toolkitTool],\n            });\n\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [toolkit],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n                tools: [standaloneTool],\n            });\n\n            expect(agent.tools).toContain(standaloneTool);\n            expect(agent.tools).toContain(toolkitTool);\n        });\n\n        it(\"should be able to find both toolkit and standalone tools\", () => {\n            const toolkitTool = new MockTool(\"toolkit_tool\", \"From toolkit\");\n            const standaloneTool = new MockTool(\"standalone_tool\", \"Standalone\");\n            const toolkit = new Toolkit({\n                name: \"TestToolkit\",\n                tools: [toolkitTool],\n            });\n\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [toolkit],\n                systemPrompt: \"Test\",\n                model: new MockModelFactory(),\n                tools: [standaloneTool],\n            });\n\n            expect(agent.getTool(\"toolkit_tool\")).toBe(toolkitTool);\n            expect(agent.getTool(\"standalone_tool\")).toBe(standaloneTool);\n        });\n    });\n});\n\n"]}

package/dist/tests/app.test.d.ts

@@ -0,0 +1 @@
+export {};