@shuttl-io/core 0.2.0

package/dist/tests/app.test.js

@@ -0,0 +1,423 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const app_1 = require("../src/app");
+const agent_1 = require("../src/agent");
+const model_1 = require("../src/model");
+const secrets_1 = require("../src/secrets");
+const toolkit_1 = require("../src/tools/toolkit");
+const tool_1 = require("../src/tools/tool");
+// Mock tool implementation for testing
+class MockTool {
+    constructor(name, description, args = {}) {
+        this.name = name;
+        this.description = description;
+        this.schema = tool_1.Schema.objectValue(args);
+    }
+    execute(_args) {
+        return { executed: true };
+    }
+}
+// Mock server implementation for testing
+class MockServer {
+    constructor() {
+        this.acceptedApp = null;
+        this.started = false;
+        this.stopped = false;
+        this.acceptCalls = 0;
+        this.startCalls = 0;
+        this.stopCalls = 0;
+    }
+    accept(app) {
+        this.acceptedApp = app;
+        this.acceptCalls++;
+    }
+    async start() {
+        this.started = true;
+        this.startCalls++;
+    }
+    async stop() {
+        this.stopped = true;
+        this.stopCalls++;
+    }
+}
+// Mock streamer for testing
+class MockStreamer {
+    constructor() {
+        this.receivedResponses = [];
+        this.receivedModels = [];
+    }
+    async recieve(model, content) {
+        this.receivedModels.push(model);
+        this.receivedResponses.push(content);
+    }
+}
+// Mock model for testing without real API calls
+class MockModel {
+    constructor() {
+        this.threadId = "mock-thread-id";
+    }
+    async invoke(prompt, streamer) {
+        await streamer.recieve(this, {
+            eventName: "response.output_text.done",
+            data: {
+                typeName: "output_text",
+                outputText: {
+                    outputType: "output_text",
+                    text: `Mock response to: ${prompt[0]?.content || "empty"}`,
+                },
+            },
+        });
+    }
+}
+// Mock factory for testing
+class MockModelFactory {
+    async create(_props) {
+        return new MockModel();
+    }
+}
+describe("App", () => {
+    let mockServer;
+    let defaultModelFactory;
+    beforeEach(() => {
+        mockServer = new MockServer();
+        defaultModelFactory = model_1.Model.openAI("gpt-4", secrets_1.Secret.fromEnv("OPENAI_API_KEY"));
+    });
+    describe("constructor", () => {
+        it("should create an App with name and server", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            expect(app.name).toBe("TestApp");
+            expect(app.server).toBe(mockServer);
+            expect(app.agents).toEqual([]);
+            expect(app.toolkits.size).toBe(0);
+        });
+        it("should call server.accept() during construction", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            expect(mockServer.acceptCalls).toBe(1);
+            expect(mockServer.acceptedApp).toBe(app);
+        });
+        it("should create an App with empty string name", () => {
+            const app = new app_1.App("", mockServer);
+            expect(app.name).toBe("");
+        });
+        it("should initialize agents as empty array", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            expect(app.agents).toBeDefined();
+            expect(Array.isArray(app.agents)).toBe(true);
+            expect(app.agents).toHaveLength(0);
+        });
+        it("should initialize toolkits as empty Set", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            expect(app.toolkits).toBeDefined();
+            expect(app.toolkits).toBeInstanceOf(Set);
+            expect(app.toolkits.size).toBe(0);
+        });
+    });
+    describe("addAgent()", () => {
+        it("should add an agent to the app", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test prompt",
+                model: defaultModelFactory,
+            });
+            app.addAgent(agent);
+            expect(app.agents).toHaveLength(1);
+            expect(app.agents[0]).toBe(agent);
+        });
+        it("should add multiple agents", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const agent1 = new agent_1.Agent({
+                name: "Agent1",
+                toolkits: [],
+                systemPrompt: "Prompt 1",
+                model: defaultModelFactory,
+            });
+            const agent2 = new agent_1.Agent({
+                name: "Agent2",
+                toolkits: [],
+                systemPrompt: "Prompt 2",
+                model: defaultModelFactory,
+            });
+            app.addAgent(agent1);
+            app.addAgent(agent2);
+            expect(app.agents).toHaveLength(2);
+            expect(app.agents[0]).toBe(agent1);
+            expect(app.agents[1]).toBe(agent2);
+        });
+        it("should add agent toolkits to app toolkits", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const toolkit = new toolkit_1.Toolkit({ name: "TestToolkit" });
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [toolkit],
+                systemPrompt: "Test prompt",
+                model: defaultModelFactory,
+            });
+            app.addAgent(agent);
+            expect(app.toolkits.size).toBe(1);
+            expect(app.toolkits.has(toolkit)).toBe(true);
+        });
+        it("should add multiple toolkits from agent", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const toolkit1 = new toolkit_1.Toolkit({ name: "Toolkit1" });
+            const toolkit2 = new toolkit_1.Toolkit({ name: "Toolkit2" });
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [toolkit1, toolkit2],
+                systemPrompt: "Test prompt",
+                model: defaultModelFactory,
+            });
+            app.addAgent(agent);
+            expect(app.toolkits.size).toBe(2);
+            expect(app.toolkits.has(toolkit1)).toBe(true);
+            expect(app.toolkits.has(toolkit2)).toBe(true);
+        });
+        it("should not duplicate toolkits when adding same toolkit from multiple agents", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const sharedToolkit = new toolkit_1.Toolkit({ name: "SharedToolkit" });
+            const agent1 = new agent_1.Agent({
+                name: "Agent1",
+                toolkits: [sharedToolkit],
+                systemPrompt: "Prompt 1",
+                model: defaultModelFactory,
+            });
+            const agent2 = new agent_1.Agent({
+                name: "Agent2",
+                toolkits: [sharedToolkit],
+                systemPrompt: "Prompt 2",
+                model: defaultModelFactory,
+            });
+            app.addAgent(agent1);
+            app.addAgent(agent2);
+            expect(app.toolkits.size).toBe(1);
+            expect(app.toolkits.has(sharedToolkit)).toBe(true);
+        });
+        it("should allow adding the same agent twice", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const agent = new agent_1.Agent({
+                name: "TestAgent",
+                toolkits: [],
+                systemPrompt: "Test prompt",
+                model: defaultModelFactory,
+            });
+            app.addAgent(agent);
+            app.addAgent(agent);
+            expect(app.agents).toHaveLength(2);
+            expect(app.agents[0]).toBe(agent);
+            expect(app.agents[1]).toBe(agent);
+        });
+        it("should handle agent with no toolkits", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const agent = new agent_1.Agent({
+                name: "NoToolkitAgent",
+                toolkits: [],
+                systemPrompt: "No toolkits",
+                model: defaultModelFactory,
+            });
+            app.addAgent(agent);
+            expect(app.agents).toHaveLength(1);
+            expect(app.toolkits.size).toBe(0);
+        });
+    });
+    describe("addToolkit()", () => {
+        it("should add a toolkit to the app", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const toolkit = new toolkit_1.Toolkit({ name: "TestToolkit" });
+            app.addToolkit(toolkit);
+            expect(app.toolkits.size).toBe(1);
+            expect(app.toolkits.has(toolkit)).toBe(true);
+        });
+        it("should add multiple toolkits", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const toolkit1 = new toolkit_1.Toolkit({ name: "Toolkit1" });
+            const toolkit2 = new toolkit_1.Toolkit({ name: "Toolkit2" });
+            app.addToolkit(toolkit1);
+            app.addToolkit(toolkit2);
+            expect(app.toolkits.size).toBe(2);
+            expect(app.toolkits.has(toolkit1)).toBe(true);
+            expect(app.toolkits.has(toolkit2)).toBe(true);
+        });
+        it("should not duplicate toolkit when adding same toolkit twice", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const toolkit = new toolkit_1.Toolkit({ name: "TestToolkit" });
+            app.addToolkit(toolkit);
+            app.addToolkit(toolkit);
+            expect(app.toolkits.size).toBe(1);
+        });
+        it("should add toolkit with tools", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            const tool = new MockTool("testTool", "A test tool");
+            const toolkit = new toolkit_1.Toolkit({
+                name: "TestToolkit",
+                tools: [tool],
+            });
+            app.addToolkit(toolkit);
+            expect(app.toolkits.size).toBe(1);
+            const addedToolkit = Array.from(app.toolkits)[0];
+            expect(addedToolkit.tools).toHaveLength(1);
+            expect(addedToolkit.tools[0].name).toBe("testTool");
+        });
+    });
+    describe("serve()", () => {
+        it("should call server.start()", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            app.serve();
+            expect(mockServer.startCalls).toBe(1);
+            expect(mockServer.started).toBe(true);
+        });
+        it("should be callable multiple times", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            app.serve();
+            app.serve();
+            app.serve();
+            expect(mockServer.startCalls).toBe(3);
+        });
+    });
+    describe("integration scenarios", () => {
+        it("should work with complete app setup", () => {
+            const app = new app_1.App("CompleteApp", mockServer);
+            // Create tools
+            const searchTool = new MockTool("search", "Search for items");
+            const createTool = new MockTool("create", "Create new item");
+            // Create toolkits
+            const searchToolkit = new toolkit_1.Toolkit({
+                name: "SearchToolkit",
+                description: "Tools for searching",
+                tools: [searchTool],
+            });
+            const crudToolkit = new toolkit_1.Toolkit({
+                name: "CRUDToolkit",
+                description: "CRUD operations",
+                tools: [createTool],
+            });
+            // Create agents
+            const searchAgent = new agent_1.Agent({
+                name: "SearchAgent",
+                toolkits: [searchToolkit],
+                systemPrompt: "You are a search agent",
+                model: defaultModelFactory,
+            });
+            const crudAgent = new agent_1.Agent({
+                name: "CRUDAgent",
+                toolkits: [crudToolkit],
+                systemPrompt: "You are a CRUD agent",
+                model: defaultModelFactory,
+            });
+            // Add agents to app
+            app.addAgent(searchAgent);
+            app.addAgent(crudAgent);
+            // Add additional toolkit directly
+            const utilToolkit = new toolkit_1.Toolkit({ name: "UtilToolkit" });
+            app.addToolkit(utilToolkit);
+            // Verify state
+            expect(app.name).toBe("CompleteApp");
+            expect(app.agents).toHaveLength(2);
+            expect(app.toolkits.size).toBe(3);
+            expect(mockServer.acceptedApp).toBe(app);
+        });
+        it("should maintain references correctly", () => {
+            const app = new app_1.App("RefApp", mockServer);
+            const toolkit = new toolkit_1.Toolkit({ name: "SharedToolkit" });
+            const agent = new agent_1.Agent({
+                name: "RefAgent",
+                toolkits: [toolkit],
+                systemPrompt: "Test",
+                model: defaultModelFactory,
+            });
+            app.addAgent(agent);
+            app.addToolkit(toolkit);
+            // Agent toolkit and app toolkit should be same reference
+            expect(app.agents[0].toolkits[0]).toBe(toolkit);
+            expect(Array.from(app.toolkits)[0]).toBe(toolkit);
+        });
+        it("should allow iteration over toolkits", () => {
+            const app = new app_1.App("IterApp", mockServer);
+            const toolkit1 = new toolkit_1.Toolkit({ name: "Toolkit1" });
+            const toolkit2 = new toolkit_1.Toolkit({ name: "Toolkit2" });
+            app.addToolkit(toolkit1);
+            app.addToolkit(toolkit2);
+            const toolkitNames = [];
+            app.toolkits.forEach((toolkit) => {
+                toolkitNames.push(toolkit.name);
+            });
+            expect(toolkitNames).toContain("Toolkit1");
+            expect(toolkitNames).toContain("Toolkit2");
+        });
+    });
+    describe("readonly properties", () => {
+        it("should have readonly name property", () => {
+            const app = new app_1.App("ReadonlyApp", mockServer);
+            expect(app.name).toBeDefined();
+            expect(typeof app.name).toBe("string");
+        });
+        it("should have agents array that can be read", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            expect(app.agents).toBeDefined();
+            expect(Array.isArray(app.agents)).toBe(true);
+        });
+        it("should have toolkits Set that can be read", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            expect(app.toolkits).toBeDefined();
+            expect(app.toolkits).toBeInstanceOf(Set);
+        });
+        it("should have server that can be read", () => {
+            const app = new app_1.App("TestApp", mockServer);
+            expect(app.server).toBeDefined();
+            expect(app.server).toBe(mockServer);
+        });
+    });
+    describe("IServer interface compliance", () => {
+        it("should work with any IServer implementation", () => {
+            class CustomServer {
+                constructor() {
+                    this.accepted = false;
+                    this.running = false;
+                }
+                accept(_app) {
+                    this.accepted = true;
+                }
+                async start() {
+                    this.running = true;
+                }
+                async stop() {
+                    this.running = false;
+                }
+            }
+            const customServer = new CustomServer();
+            const app = new app_1.App("CustomApp", customServer);
+            expect(customServer.accepted).toBe(true);
+            app.serve();
+            expect(customServer.running).toBe(true);
+        });
+    });
+});
+describe("Model factory methods", () => {
+    describe("Model.openAI()", () => {
+        it("should create an OpenAI model factory with env secret", () => {
+            const secret = secrets_1.Secret.fromEnv("OPENAI_API_KEY");
+            const factory = model_1.Model.openAI("gpt-4", secret);
+            expect(factory).toBeDefined();
+            expect(typeof factory.create).toBe("function");
+        });
+        it("should create model factories with different identifiers", () => {
+            const secret = secrets_1.Secret.fromEnv("OPENAI_API_KEY");
+            const gpt4 = model_1.Model.openAI("gpt-4", secret);
+            const gpt35 = model_1.Model.openAI("gpt-3.5-turbo", secret);
+            expect(gpt4).toBeDefined();
+            expect(gpt35).toBeDefined();
+        });
+        it("should create model instances from mock factory and invoke with streamer", async () => {
+            const mockFactory = new MockModelFactory();
+            const model = await mockFactory.create({
+                systemPrompt: "You are a helpful assistant.",
+            });
+            const streamer = new MockStreamer();
+            await model.invoke([{ content: "Hello", role: "user" }], streamer);
+            expect(streamer.receivedResponses.length).toBeGreaterThan(0);
+            expect(streamer.receivedModels[0]).toBe(model);
+            expect(model.threadId).toBe("mock-thread-id");
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.test.js","sourceRoot":"","sources":["../../tests/app.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { App } from \"../src/app\";\nimport { Agent } from \"../src/agent\";\nimport { Model } from \"../src/model\";\nimport { Secret } from \"../src/secrets\";\nimport { IModelFactory, IModelStreamer, ModelContent, IModel, ModelResponse } from \"../src/models/types\";\nimport { Toolkit } from \"../src/tools/toolkit\";\nimport { IServer } from \"../src/Server\";\nimport { ITool, Schema, ToolArgBuilder } from \"../src/tools/tool\";\n\n// Mock tool implementation for testing\nclass MockTool implements ITool {\n    public name: string;\n    public description: string;\n    public schema: Schema;\n\n    constructor(name: string, description: string, args: Record<string, ToolArgBuilder> = {}) {\n        this.name = name;\n        this.description = description;\n        this.schema = Schema.objectValue(args);\n    }\n\n    execute(_args: Record<string, unknown>): unknown {\n        return { executed: true };\n    }\n}\n\n// Mock server implementation for testing\nclass MockServer implements IServer {\n    public acceptedApp: unknown | null = null;\n    public started: boolean = false;\n    public stopped: boolean = false;\n    public acceptCalls: number = 0;\n    public startCalls: number = 0;\n    public stopCalls: number = 0;\n\n    accept(app: unknown): void {\n        this.acceptedApp = app;\n        this.acceptCalls++;\n    }\n\n    async start(): Promise<void> {\n        this.started = true;\n        this.startCalls++;\n    }\n\n    async stop(): Promise<void> {\n        this.stopped = true;\n        this.stopCalls++;\n    }\n}\n\n// Mock streamer for testing\nclass MockStreamer implements IModelStreamer {\n    public receivedResponses: ModelResponse[] = [];\n    public receivedModels: IModel[] = [];\n\n    async recieve(model: IModel, content: ModelResponse): Promise<void> {\n        this.receivedModels.push(model);\n        this.receivedResponses.push(content);\n    }\n}\n\n// Mock model for testing without real API calls\nclass MockModel implements IModel {\n    public readonly threadId?: string = \"mock-thread-id\";\n\n    async invoke(prompt: ModelContent[], streamer: IModelStreamer): Promise<void> {\n        await streamer.recieve(this, {\n            eventName: \"response.output_text.done\",\n            data: {\n                typeName: \"output_text\",\n                outputText: {\n                    outputType: \"output_text\",\n                    text: `Mock response to: ${prompt[0]?.content || \"empty\"}`,\n                },\n            },\n        });\n    }\n}\n\n// Mock factory for testing\nclass MockModelFactory implements IModelFactory {\n    async create(_props: { systemPrompt: string }): Promise<IModel> {\n        return new MockModel();\n    }\n}\n\ndescribe(\"App\", () => {\n    let mockServer: MockServer;\n    let defaultModelFactory: IModelFactory;\n\n    beforeEach(() => {\n        mockServer = new MockServer();\n        defaultModelFactory = Model.openAI(\"gpt-4\", Secret.fromEnv(\"OPENAI_API_KEY\"));\n    });\n\n    describe(\"constructor\", () => {\n        it(\"should create an App with name and server\", () => {\n            const app = new App(\"TestApp\", mockServer);\n\n            expect(app.name).toBe(\"TestApp\");\n            expect(app.server).toBe(mockServer);\n            expect(app.agents).toEqual([]);\n            expect(app.toolkits.size).toBe(0);\n        });\n\n        it(\"should call server.accept() during construction\", () => {\n            const app = new App(\"TestApp\", mockServer);\n\n            expect(mockServer.acceptCalls).toBe(1);\n            expect(mockServer.acceptedApp).toBe(app);\n        });\n\n        it(\"should create an App with empty string name\", () => {\n            const app = new App(\"\", mockServer);\n\n            expect(app.name).toBe(\"\");\n        });\n\n        it(\"should initialize agents as empty array\", () => {\n            const app = new App(\"TestApp\", mockServer);\n\n            expect(app.agents).toBeDefined();\n            expect(Array.isArray(app.agents)).toBe(true);\n            expect(app.agents).toHaveLength(0);\n        });\n\n        it(\"should initialize toolkits as empty Set\", () => {\n            const app = new App(\"TestApp\", mockServer);\n\n            expect(app.toolkits).toBeDefined();\n            expect(app.toolkits).toBeInstanceOf(Set);\n            expect(app.toolkits.size).toBe(0);\n        });\n    });\n\n    describe(\"addAgent()\", () => {\n        it(\"should add an agent to the app\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test prompt\",\n                model: defaultModelFactory,\n            });\n\n            app.addAgent(agent);\n\n            expect(app.agents).toHaveLength(1);\n            expect(app.agents[0]).toBe(agent);\n        });\n\n        it(\"should add multiple agents\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const agent1 = new Agent({\n                name: \"Agent1\",\n                toolkits: [],\n                systemPrompt: \"Prompt 1\",\n                model: defaultModelFactory,\n            });\n            const agent2 = new Agent({\n                name: \"Agent2\",\n                toolkits: [],\n                systemPrompt: \"Prompt 2\",\n                model: defaultModelFactory,\n            });\n\n            app.addAgent(agent1);\n            app.addAgent(agent2);\n\n            expect(app.agents).toHaveLength(2);\n            expect(app.agents[0]).toBe(agent1);\n            expect(app.agents[1]).toBe(agent2);\n        });\n\n        it(\"should add agent toolkits to app toolkits\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const toolkit = new Toolkit({ name: \"TestToolkit\" });\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [toolkit],\n                systemPrompt: \"Test prompt\",\n                model: defaultModelFactory,\n            });\n\n            app.addAgent(agent);\n\n            expect(app.toolkits.size).toBe(1);\n            expect(app.toolkits.has(toolkit)).toBe(true);\n        });\n\n        it(\"should add multiple toolkits from agent\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const toolkit1 = new Toolkit({ name: \"Toolkit1\" });\n            const toolkit2 = new Toolkit({ name: \"Toolkit2\" });\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [toolkit1, toolkit2],\n                systemPrompt: \"Test prompt\",\n                model: defaultModelFactory,\n            });\n\n            app.addAgent(agent);\n\n            expect(app.toolkits.size).toBe(2);\n            expect(app.toolkits.has(toolkit1)).toBe(true);\n            expect(app.toolkits.has(toolkit2)).toBe(true);\n        });\n\n        it(\"should not duplicate toolkits when adding same toolkit from multiple agents\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const sharedToolkit = new Toolkit({ name: \"SharedToolkit\" });\n            const agent1 = new Agent({\n                name: \"Agent1\",\n                toolkits: [sharedToolkit],\n                systemPrompt: \"Prompt 1\",\n                model: defaultModelFactory,\n            });\n            const agent2 = new Agent({\n                name: \"Agent2\",\n                toolkits: [sharedToolkit],\n                systemPrompt: \"Prompt 2\",\n                model: defaultModelFactory,\n            });\n\n            app.addAgent(agent1);\n            app.addAgent(agent2);\n\n            expect(app.toolkits.size).toBe(1);\n            expect(app.toolkits.has(sharedToolkit)).toBe(true);\n        });\n\n        it(\"should allow adding the same agent twice\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const agent = new Agent({\n                name: \"TestAgent\",\n                toolkits: [],\n                systemPrompt: \"Test prompt\",\n                model: defaultModelFactory,\n            });\n\n            app.addAgent(agent);\n            app.addAgent(agent);\n\n            expect(app.agents).toHaveLength(2);\n            expect(app.agents[0]).toBe(agent);\n            expect(app.agents[1]).toBe(agent);\n        });\n\n        it(\"should handle agent with no toolkits\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const agent = new Agent({\n                name: \"NoToolkitAgent\",\n                toolkits: [],\n                systemPrompt: \"No toolkits\",\n                model: defaultModelFactory,\n            });\n\n            app.addAgent(agent);\n\n            expect(app.agents).toHaveLength(1);\n            expect(app.toolkits.size).toBe(0);\n        });\n    });\n\n    describe(\"addToolkit()\", () => {\n        it(\"should add a toolkit to the app\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const toolkit = new Toolkit({ name: \"TestToolkit\" });\n\n            app.addToolkit(toolkit);\n\n            expect(app.toolkits.size).toBe(1);\n            expect(app.toolkits.has(toolkit)).toBe(true);\n        });\n\n        it(\"should add multiple toolkits\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const toolkit1 = new Toolkit({ name: \"Toolkit1\" });\n            const toolkit2 = new Toolkit({ name: \"Toolkit2\" });\n\n            app.addToolkit(toolkit1);\n            app.addToolkit(toolkit2);\n\n            expect(app.toolkits.size).toBe(2);\n            expect(app.toolkits.has(toolkit1)).toBe(true);\n            expect(app.toolkits.has(toolkit2)).toBe(true);\n        });\n\n        it(\"should not duplicate toolkit when adding same toolkit twice\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const toolkit = new Toolkit({ name: \"TestToolkit\" });\n\n            app.addToolkit(toolkit);\n            app.addToolkit(toolkit);\n\n            expect(app.toolkits.size).toBe(1);\n        });\n\n        it(\"should add toolkit with tools\", () => {\n            const app = new App(\"TestApp\", mockServer);\n            const tool = new MockTool(\"testTool\", \"A test tool\");\n            const toolkit = new Toolkit({\n                name: \"TestToolkit\",\n                tools: [tool],\n            });\n\n            app.addToolkit(toolkit);\n\n            expect(app.toolkits.size).toBe(1);\n            const addedToolkit = Array.from(app.toolkits)[0];\n            expect(addedToolkit.tools).toHaveLength(1);\n            expect(addedToolkit.tools[0].name).toBe(\"testTool\");\n        });\n    });\n\n    describe(\"serve()\", () => {\n        it(\"should call server.start()\", () => {\n            const app = new App(\"TestApp\", mockServer);\n\n            app.serve();\n\n            expect(mockServer.startCalls).toBe(1);\n            expect(mockServer.started).toBe(true);\n        });\n\n        it(\"should be callable multiple times\", () => {\n            const app = new App(\"TestApp\", mockServer);\n\n            app.serve();\n            app.serve();\n            app.serve();\n\n            expect(mockServer.startCalls).toBe(3);\n        });\n    });\n\n    describe(\"integration scenarios\", () => {\n        it(\"should work with complete app setup\", () => {\n            const app = new App(\"CompleteApp\", mockServer);\n\n            // Create tools\n            const searchTool = new MockTool(\"search\", \"Search for items\");\n            const createTool = new MockTool(\"create\", \"Create new item\");\n\n            // Create toolkits\n            const searchToolkit = new Toolkit({\n                name: \"SearchToolkit\",\n                description: \"Tools for searching\",\n                tools: [searchTool],\n            });\n            const crudToolkit = new Toolkit({\n                name: \"CRUDToolkit\",\n                description: \"CRUD operations\",\n                tools: [createTool],\n            });\n\n            // Create agents\n            const searchAgent = new Agent({\n                name: \"SearchAgent\",\n                toolkits: [searchToolkit],\n                systemPrompt: \"You are a search agent\",\n                model: defaultModelFactory,\n            });\n            const crudAgent = new Agent({\n                name: \"CRUDAgent\",\n                toolkits: [crudToolkit],\n                systemPrompt: \"You are a CRUD agent\",\n                model: defaultModelFactory,\n            });\n\n            // Add agents to app\n            app.addAgent(searchAgent);\n            app.addAgent(crudAgent);\n\n            // Add additional toolkit directly\n            const utilToolkit = new Toolkit({ name: \"UtilToolkit\" });\n            app.addToolkit(utilToolkit);\n\n            // Verify state\n            expect(app.name).toBe(\"CompleteApp\");\n            expect(app.agents).toHaveLength(2);\n            expect(app.toolkits.size).toBe(3);\n            expect(mockServer.acceptedApp).toBe(app);\n        });\n\n        it(\"should maintain references correctly\", () => {\n            const app = new App(\"RefApp\", mockServer);\n            const toolkit = new Toolkit({ name: \"SharedToolkit\" });\n            const agent = new Agent({\n                name: \"RefAgent\",\n                toolkits: [toolkit],\n                systemPrompt: \"Test\",\n                model: defaultModelFactory,\n            });\n\n            app.addAgent(agent);\n            app.addToolkit(toolkit);\n\n            // Agent toolkit and app toolkit should be same reference\n            expect(app.agents[0].toolkits[0]).toBe(toolkit);\n            expect(Array.from(app.toolkits)[0]).toBe(toolkit);\n        });\n\n        it(\"should allow iteration over toolkits\", () => {\n            const app = new App(\"IterApp\", mockServer);\n            const toolkit1 = new Toolkit({ name: \"Toolkit1\" });\n            const toolkit2 = new Toolkit({ name: \"Toolkit2\" });\n\n            app.addToolkit(toolkit1);\n            app.addToolkit(toolkit2);\n\n            const toolkitNames: string[] = [];\n            app.toolkits.forEach((toolkit) => {\n                toolkitNames.push(toolkit.name);\n            });\n\n            expect(toolkitNames).toContain(\"Toolkit1\");\n            expect(toolkitNames).toContain(\"Toolkit2\");\n        });\n    });\n\n    describe(\"readonly properties\", () => {\n        it(\"should have readonly name property\", () => {\n            const app = new App(\"ReadonlyApp\", mockServer);\n\n            expect(app.name).toBeDefined();\n            expect(typeof app.name).toBe(\"string\");\n        });\n\n        it(\"should have agents array that can be read\", () => {\n            const app = new App(\"TestApp\", mockServer);\n\n            expect(app.agents).toBeDefined();\n            expect(Array.isArray(app.agents)).toBe(true);\n        });\n\n        it(\"should have toolkits Set that can be read\", () => {\n            const app = new App(\"TestApp\", mockServer);\n\n            expect(app.toolkits).toBeDefined();\n            expect(app.toolkits).toBeInstanceOf(Set);\n        });\n\n        it(\"should have server that can be read\", () => {\n            const app = new App(\"TestApp\", mockServer);\n\n            expect(app.server).toBeDefined();\n            expect(app.server).toBe(mockServer);\n        });\n    });\n\n    describe(\"IServer interface compliance\", () => {\n        it(\"should work with any IServer implementation\", () => {\n            class CustomServer implements IServer {\n                public accepted = false;\n                public running = false;\n\n                accept(_app: unknown): void {\n                    this.accepted = true;\n                }\n\n                async start(): Promise<void> {\n                    this.running = true;\n                }\n\n                async stop(): Promise<void> {\n                    this.running = false;\n                }\n            }\n\n            const customServer = new CustomServer();\n            const app = new App(\"CustomApp\", customServer);\n\n            expect(customServer.accepted).toBe(true);\n            \n            app.serve();\n            expect(customServer.running).toBe(true);\n        });\n    });\n});\n\ndescribe(\"Model factory methods\", () => {\n    describe(\"Model.openAI()\", () => {\n        it(\"should create an OpenAI model factory with env secret\", () => {\n            const secret = Secret.fromEnv(\"OPENAI_API_KEY\");\n            const factory = Model.openAI(\"gpt-4\", secret);\n\n            expect(factory).toBeDefined();\n            expect(typeof factory.create).toBe(\"function\");\n        });\n\n        it(\"should create model factories with different identifiers\", () => {\n            const secret = Secret.fromEnv(\"OPENAI_API_KEY\");\n            const gpt4 = Model.openAI(\"gpt-4\", secret);\n            const gpt35 = Model.openAI(\"gpt-3.5-turbo\", secret);\n\n            expect(gpt4).toBeDefined();\n            expect(gpt35).toBeDefined();\n        });\n\n        it(\"should create model instances from mock factory and invoke with streamer\", async () => {\n            const mockFactory = new MockModelFactory();\n\n            const model = await mockFactory.create({\n                systemPrompt: \"You are a helpful assistant.\",\n            });\n\n            const streamer = new MockStreamer();\n            await model.invoke([{ content: \"Hello\", role: \"user\" }], streamer);\n\n            expect(streamer.receivedResponses.length).toBeGreaterThan(0);\n            expect(streamer.receivedModels[0]).toBe(model);\n            expect(model.threadId).toBe(\"mock-thread-id\");\n        });\n    });\n});\n"]}

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

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