@shuttl-io/core 0.2.0

package/dist/tests/model.test.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const model_1 = require("../src/model");
+const secrets_1 = require("../src/secrets");
+// 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 the streaming interface 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("Model", () => {
+    describe("openAI factory", () => {
+        it("should create an OpenAI model factory with identifier and apiKey", () => {
+            const secret = secrets_1.Secret.fromEnv("OPENAI_API_KEY");
+            const factory = model_1.Model.openAI("gpt-4", secret);
+            expect(factory).toBeDefined();
+        });
+        it("should create 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 return an IModelFactory implementation", () => {
+            const secret = secrets_1.Secret.fromEnv("OPENAI_API_KEY");
+            const factory = model_1.Model.openAI("gpt-4", secret);
+            // IModelFactory should have a create method
+            expect(typeof factory.create).toBe("function");
+        });
+        it("should create multiple independent factory instances", () => {
+            const key1 = secrets_1.Secret.fromEnv("KEY_1");
+            const key2 = secrets_1.Secret.fromEnv("KEY_2");
+            const factory1 = model_1.Model.openAI("model-1", key1);
+            const factory2 = model_1.Model.openAI("model-2", key2);
+            expect(factory1).not.toBe(factory2);
+        });
+    });
+    describe("IModelFactory interface", () => {
+        it("should have a create method that accepts IModelFactoryProps", async () => {
+            const factory = new MockModelFactory();
+            const model = await factory.create({
+                systemPrompt: "You are a helpful assistant.",
+            });
+            expect(model).toBeDefined();
+        });
+        it("should create IModel instances with invoke method", async () => {
+            const factory = new MockModelFactory();
+            const model = await factory.create({
+                systemPrompt: "You are a helpful assistant.",
+            });
+            expect(typeof model.invoke).toBe("function");
+        });
+        it("should create IModel instances with threadId property", async () => {
+            const factory = new MockModelFactory();
+            const model = await factory.create({
+                systemPrompt: "You are a helpful assistant.",
+            });
+            expect(model.threadId).toBeDefined();
+        });
+        it("should create multiple independent model instances", async () => {
+            const factory = new MockModelFactory();
+            const model1 = await factory.create({
+                systemPrompt: "You are assistant 1.",
+            });
+            const model2 = await factory.create({
+                systemPrompt: "You are assistant 2.",
+            });
+            expect(model1).not.toBe(model2);
+        });
+    });
+    describe("IModel interface with streaming", () => {
+        it("should invoke with streamer and return void", async () => {
+            const model = new MockModel();
+            const streamer = new MockStreamer();
+            const prompt = [
+                { content: "Test message", role: "user" },
+            ];
+            const result = await model.invoke(prompt, streamer);
+            expect(result).toBeUndefined();
+        });
+        it("should send ModelResponse to streamer via recieve method", async () => {
+            const model = new MockModel();
+            const streamer = new MockStreamer();
+            const prompt = [
+                { content: "Hello", role: "user" },
+            ];
+            await model.invoke(prompt, streamer);
+            expect(streamer.receivedResponses.length).toBeGreaterThan(0);
+        });
+        it("should send response with event and data", async () => {
+            const model = new MockModel();
+            const streamer = new MockStreamer();
+            const prompt = [
+                { content: "Hello", role: "user" },
+            ];
+            await model.invoke(prompt, streamer);
+            expect(streamer.receivedResponses[0].eventName).toBeDefined();
+            expect(streamer.receivedResponses[0].data).toBeDefined();
+        });
+        it("should pass model reference to streamer recieve method", async () => {
+            const model = new MockModel();
+            const streamer = new MockStreamer();
+            const prompt = [
+                { content: "Hello", role: "user" },
+            ];
+            await model.invoke(prompt, streamer);
+            expect(streamer.receivedModels[0]).toBe(model);
+        });
+        it("should have threadId property on model", async () => {
+            const model = new MockModel();
+            expect(model.threadId).toBe("mock-thread-id");
+        });
+    });
+    describe("IModelStreamer interface", () => {
+        it("should implement recieve method with model and ModelResponse parameters", () => {
+            const streamer = new MockStreamer();
+            expect(typeof streamer.recieve).toBe("function");
+        });
+        it("should accumulate received responses", async () => {
+            const streamer = new MockStreamer();
+            const mockModel = new MockModel();
+            await streamer.recieve(mockModel, {
+                eventName: "response.output_text.done",
+                data: { typeName: "output_text", outputText: { outputType: "output_text", text: "First" } },
+            });
+            await streamer.recieve(mockModel, {
+                eventName: "response.output_text.done",
+                data: { typeName: "output_text", outputText: { outputType: "output_text", text: "Second" } },
+            });
+            expect(streamer.receivedResponses).toHaveLength(2);
+        });
+        it("should track which model sent each response", async () => {
+            const streamer = new MockStreamer();
+            const model1 = new MockModel();
+            const model2 = new MockModel();
+            await streamer.recieve(model1, {
+                eventName: "response.output_text.done",
+                data: { typeName: "output_text", outputText: { outputType: "output_text", text: "From model 1" } },
+            });
+            await streamer.recieve(model2, {
+                eventName: "response.output_text.done",
+                data: { typeName: "output_text", outputText: { outputType: "output_text", text: "From model 2" } },
+            });
+            expect(streamer.receivedModels[0]).toBe(model1);
+            expect(streamer.receivedModels[1]).toBe(model2);
+        });
+    });
+    describe("ModelResponse types", () => {
+        it("should support output_text type", async () => {
+            const response = {
+                eventName: "response.output_text.done",
+                data: {
+                    typeName: "output_text",
+                    outputText: {
+                        outputType: "output_text",
+                        text: "Hello world",
+                    },
+                },
+            };
+            expect(Array.isArray(response.data)).toBe(false);
+            const data = response.data;
+            expect(data.typeName).toBe("output_text");
+            expect(data.outputText?.text).toBe("Hello world");
+        });
+        it("should support tool_call type", async () => {
+            const response = {
+                eventName: "response.function_call_arguments.done",
+                data: {
+                    typeName: "tool_call",
+                    toolCall: {
+                        outputType: "tool_call",
+                        name: "get_weather",
+                        arguments: { location: "San Francisco" },
+                        callId: "123",
+                    },
+                },
+            };
+            expect(Array.isArray(response.data)).toBe(false);
+            const data = response.data;
+            expect(data.typeName).toBe("tool_call");
+            expect(data.toolCall?.name).toBe("get_weather");
+        });
+        it("should support output_text_delta type", async () => {
+            const response = {
+                eventName: "response.output_text.delta",
+                data: {
+                    typeName: "output_text_delta",
+                    outputTextDelta: {
+                        outputType: "output_text_delta",
+                        delta: "Hello",
+                        sequenceNumber: 1,
+                    },
+                },
+            };
+            expect(Array.isArray(response.data)).toBe(false);
+            const data = response.data;
+            expect(data.typeName).toBe("output_text_delta");
+            expect(data.outputTextDelta?.delta).toBe("Hello");
+        });
+        it("should support data as an array", async () => {
+            const response = {
+                eventName: "response.completed",
+                data: [
+                    {
+                        typeName: "output_text",
+                        outputText: {
+                            outputType: "output_text",
+                            text: "First message",
+                        },
+                    },
+                    {
+                        typeName: "output_text",
+                        outputText: {
+                            outputType: "output_text",
+                            text: "Second message",
+                        },
+                    },
+                ],
+            };
+            expect(Array.isArray(response.data)).toBe(true);
+            const dataArray = response.data;
+            expect(dataArray).toHaveLength(2);
+            expect(dataArray[0].typeName).toBe("output_text");
+            expect(dataArray[0].outputText?.text).toBe("First message");
+            expect(dataArray[1].outputText?.text).toBe("Second message");
+        });
+        it("should support optional usage field", async () => {
+            const response = {
+                eventName: "response.done",
+                data: {
+                    typeName: "output_text",
+                    outputText: { outputType: "output_text", text: "Done" },
+                },
+                usage: {
+                    inputTokens: 10,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokens: 20,
+                    outputTokensDetails: { reasoningTokens: 5 },
+                    totalTokens: 30,
+                },
+            };
+            expect(response.usage?.totalTokens).toBe(30);
+        });
+    });
+    describe("ModelContent type", () => {
+        it("should accept user role", () => {
+            const content = {
+                content: "User message",
+                role: "user",
+            };
+            expect(content.role).toBe("user");
+            expect(content.content).toBe("User message");
+        });
+        it("should accept assistant role", () => {
+            const content = {
+                content: "Assistant response",
+                role: "assistant",
+            };
+            expect(content.role).toBe("assistant");
+            expect(content.content).toBe("Assistant response");
+        });
+        it("should accept system role", () => {
+            const content = {
+                content: "System instructions",
+                role: "system",
+            };
+            expect(content.role).toBe("system");
+            expect(content.content).toBe("System instructions");
+        });
+    });
+    describe("different secret types with openAI", () => {
+        it("should work with env secrets", () => {
+            const secret = secrets_1.Secret.fromEnv("MY_API_KEY");
+            const factory = model_1.Model.openAI("gpt-4", secret);
+            expect(factory).toBeDefined();
+            expect(typeof factory.create).toBe("function");
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.test.js","sourceRoot":"","sources":["../../tests/model.test.ts"],"names":[],"mappings":"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","sourcesContent":["import { Model } from \"../src/model\";\nimport { Secret } from \"../src/secrets\";\nimport { ModelContent, IModelStreamer, IModel, IModelFactory, ModelResponse, ModelResponseData } from \"../src/models/types\";\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 the streaming interface 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(\"Model\", () => {\n    describe(\"openAI factory\", () => {\n        it(\"should create an OpenAI model factory with identifier and apiKey\", () => {\n            const secret = Secret.fromEnv(\"OPENAI_API_KEY\");\n            const factory = Model.openAI(\"gpt-4\", secret);\n\n            expect(factory).toBeDefined();\n        });\n\n        it(\"should create 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 return an IModelFactory implementation\", () => {\n            const secret = Secret.fromEnv(\"OPENAI_API_KEY\");\n            const factory = Model.openAI(\"gpt-4\", secret);\n\n            // IModelFactory should have a create method\n            expect(typeof factory.create).toBe(\"function\");\n        });\n\n        it(\"should create multiple independent factory instances\", () => {\n            const key1 = Secret.fromEnv(\"KEY_1\");\n            const key2 = Secret.fromEnv(\"KEY_2\");\n            const factory1 = Model.openAI(\"model-1\", key1);\n            const factory2 = Model.openAI(\"model-2\", key2);\n\n            expect(factory1).not.toBe(factory2);\n        });\n    });\n\n    describe(\"IModelFactory interface\", () => {\n        it(\"should have a create method that accepts IModelFactoryProps\", async () => {\n            const factory = new MockModelFactory();\n\n            const model = await factory.create({\n                systemPrompt: \"You are a helpful assistant.\",\n            });\n\n            expect(model).toBeDefined();\n        });\n\n        it(\"should create IModel instances with invoke method\", async () => {\n            const factory = new MockModelFactory();\n\n            const model = await factory.create({\n                systemPrompt: \"You are a helpful assistant.\",\n            });\n\n            expect(typeof model.invoke).toBe(\"function\");\n        });\n\n        it(\"should create IModel instances with threadId property\", async () => {\n            const factory = new MockModelFactory();\n\n            const model = await factory.create({\n                systemPrompt: \"You are a helpful assistant.\",\n            });\n\n            expect(model.threadId).toBeDefined();\n        });\n\n        it(\"should create multiple independent model instances\", async () => {\n            const factory = new MockModelFactory();\n\n            const model1 = await factory.create({\n                systemPrompt: \"You are assistant 1.\",\n            });\n\n            const model2 = await factory.create({\n                systemPrompt: \"You are assistant 2.\",\n            });\n\n            expect(model1).not.toBe(model2);\n        });\n    });\n\n    describe(\"IModel interface with streaming\", () => {\n        it(\"should invoke with streamer and return void\", async () => {\n            const model = new MockModel();\n            const streamer = new MockStreamer();\n            const prompt: ModelContent[] = [\n                { content: \"Test message\", role: \"user\" },\n            ];\n\n            const result = await model.invoke(prompt, streamer);\n\n            expect(result).toBeUndefined();\n        });\n\n        it(\"should send ModelResponse to streamer via recieve method\", async () => {\n            const model = new MockModel();\n            const streamer = new MockStreamer();\n            const prompt: ModelContent[] = [\n                { content: \"Hello\", role: \"user\" },\n            ];\n\n            await model.invoke(prompt, streamer);\n\n            expect(streamer.receivedResponses.length).toBeGreaterThan(0);\n        });\n\n        it(\"should send response with event and data\", async () => {\n            const model = new MockModel();\n            const streamer = new MockStreamer();\n            const prompt: ModelContent[] = [\n                { content: \"Hello\", role: \"user\" },\n            ];\n\n            await model.invoke(prompt, streamer);\n\n            expect(streamer.receivedResponses[0].eventName).toBeDefined();\n            expect(streamer.receivedResponses[0].data).toBeDefined();\n        });\n\n        it(\"should pass model reference to streamer recieve method\", async () => {\n            const model = new MockModel();\n            const streamer = new MockStreamer();\n            const prompt: ModelContent[] = [\n                { content: \"Hello\", role: \"user\" },\n            ];\n\n            await model.invoke(prompt, streamer);\n\n            expect(streamer.receivedModels[0]).toBe(model);\n        });\n\n        it(\"should have threadId property on model\", async () => {\n            const model = new MockModel();\n\n            expect(model.threadId).toBe(\"mock-thread-id\");\n        });\n    });\n\n    describe(\"IModelStreamer interface\", () => {\n        it(\"should implement recieve method with model and ModelResponse parameters\", () => {\n            const streamer = new MockStreamer();\n\n            expect(typeof streamer.recieve).toBe(\"function\");\n        });\n\n        it(\"should accumulate received responses\", async () => {\n            const streamer = new MockStreamer();\n            const mockModel = new MockModel();\n\n            await streamer.recieve(mockModel, {\n                eventName: \"response.output_text.done\",\n                data: { typeName: \"output_text\", outputText: { outputType: \"output_text\", text: \"First\" } },\n            });\n            await streamer.recieve(mockModel, {\n                eventName: \"response.output_text.done\",\n                data: { typeName: \"output_text\", outputText: { outputType: \"output_text\", text: \"Second\" } },\n            });\n\n            expect(streamer.receivedResponses).toHaveLength(2);\n        });\n\n        it(\"should track which model sent each response\", async () => {\n            const streamer = new MockStreamer();\n            const model1 = new MockModel();\n            const model2 = new MockModel();\n\n            await streamer.recieve(model1, {\n                eventName: \"response.output_text.done\",\n                data: { typeName: \"output_text\", outputText: { outputType: \"output_text\", text: \"From model 1\" } },\n            });\n            await streamer.recieve(model2, {\n                eventName: \"response.output_text.done\",\n                data: { typeName: \"output_text\", outputText: { outputType: \"output_text\", text: \"From model 2\" } },\n            });\n\n            expect(streamer.receivedModels[0]).toBe(model1);\n            expect(streamer.receivedModels[1]).toBe(model2);\n        });\n    });\n\n    describe(\"ModelResponse types\", () => {\n        it(\"should support output_text type\", 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            expect(Array.isArray(response.data)).toBe(false);\n            const data = response.data as ModelResponseData;\n            expect(data.typeName).toBe(\"output_text\");\n            expect(data.outputText?.text).toBe(\"Hello world\");\n        });\n\n        it(\"should support tool_call type\", async () => {\n            const response: ModelResponse = {\n                eventName: \"response.function_call_arguments.done\",\n                data: {\n                    typeName: \"tool_call\",\n                    toolCall: {\n                        outputType: \"tool_call\",\n                        name: \"get_weather\",\n                        arguments: { location: \"San Francisco\" },\n                        callId: \"123\",\n                    },\n                },\n            };\n\n            expect(Array.isArray(response.data)).toBe(false);\n            const data = response.data as ModelResponseData;\n            expect(data.typeName).toBe(\"tool_call\");\n            expect(data.toolCall?.name).toBe(\"get_weather\");\n        });\n\n        it(\"should support output_text_delta type\", 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            expect(Array.isArray(response.data)).toBe(false);\n            const data = response.data as ModelResponseData;\n            expect(data.typeName).toBe(\"output_text_delta\");\n            expect(data.outputTextDelta?.delta).toBe(\"Hello\");\n        });\n\n        it(\"should support data as an 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 message\",\n                        },\n                    },\n                    {\n                        typeName: \"output_text\",\n                        outputText: {\n                            outputType: \"output_text\",\n                            text: \"Second message\",\n                        },\n                    },\n                ],\n            };\n\n            expect(Array.isArray(response.data)).toBe(true);\n            const dataArray = response.data as ModelResponseData[];\n            expect(dataArray).toHaveLength(2);\n            expect(dataArray[0].typeName).toBe(\"output_text\");\n            expect(dataArray[0].outputText?.text).toBe(\"First message\");\n            expect(dataArray[1].outputText?.text).toBe(\"Second message\");\n        });\n\n        it(\"should support optional usage field\", async () => {\n            const response: ModelResponse = {\n                eventName: \"response.done\",\n                data: {\n                    typeName: \"output_text\",\n                    outputText: { outputType: \"output_text\", text: \"Done\" },\n                },\n                usage: {\n                    inputTokens: 10,\n                    inputTokensDetails: { cachedTokens: 0 },\n                    outputTokens: 20,\n                    outputTokensDetails: { reasoningTokens: 5 },\n                    totalTokens: 30,\n                },\n            };\n\n            expect(response.usage?.totalTokens).toBe(30);\n        });\n    });\n\n    describe(\"ModelContent type\", () => {\n        it(\"should accept user role\", () => {\n            const content: ModelContent = {\n                content: \"User message\",\n                role: \"user\",\n            };\n\n            expect(content.role).toBe(\"user\");\n            expect(content.content).toBe(\"User message\");\n        });\n\n        it(\"should accept assistant role\", () => {\n            const content: ModelContent = {\n                content: \"Assistant response\",\n                role: \"assistant\",\n            };\n\n            expect(content.role).toBe(\"assistant\");\n            expect(content.content).toBe(\"Assistant response\");\n        });\n\n        it(\"should accept system role\", () => {\n            const content: ModelContent = {\n                content: \"System instructions\",\n                role: \"system\",\n            };\n\n            expect(content.role).toBe(\"system\");\n            expect(content.content).toBe(\"System instructions\");\n        });\n    });\n\n    describe(\"different secret types with openAI\", () => {\n        it(\"should work with env secrets\", () => {\n            const secret = Secret.fromEnv(\"MY_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});\n"]}

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

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