@shuttl-io/core 0.2.0

package/dist/tests/types.test.js

@@ -0,0 +1,429 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../src/models/types");
+describe("isInputContent()", () => {
+    describe("returns true for valid InputContent", () => {
+        it("should return true for text InputContent", () => {
+            const content = {
+                typeName: "text",
+                text: "Hello world",
+            };
+            expect((0, types_1.isInputContent)(content)).toBe(true);
+        });
+        it("should return true for image InputContent", () => {
+            const content = {
+                typeName: "image",
+                image: "https://example.com/image.png",
+            };
+            expect((0, types_1.isInputContent)(content)).toBe(true);
+        });
+        it("should return true for file InputContent", () => {
+            const content = {
+                typeName: "file",
+                file: "https://example.com/document.pdf",
+            };
+            expect((0, types_1.isInputContent)(content)).toBe(true);
+        });
+        it("should return true for InputContent with minimal required fields", () => {
+            const content = { typeName: "text" };
+            expect((0, types_1.isInputContent)(content)).toBe(true);
+        });
+        it("should return true for InputContent with all optional fields", () => {
+            const content = {
+                typeName: "text",
+                text: "text content",
+                image: "image url",
+                file: "file url",
+            };
+            expect((0, types_1.isInputContent)(content)).toBe(true);
+        });
+    });
+    describe("returns false for invalid inputs", () => {
+        it("should return false for string", () => {
+            expect((0, types_1.isInputContent)("Hello world")).toBe(false);
+        });
+        it("should return false for number", () => {
+            expect((0, types_1.isInputContent)(42)).toBe(false);
+        });
+        it("should return false for boolean", () => {
+            expect((0, types_1.isInputContent)(true)).toBe(false);
+        });
+        it("should return false for null", () => {
+            expect((0, types_1.isInputContent)(null)).toBe(false);
+        });
+        it("should return false for undefined", () => {
+            expect((0, types_1.isInputContent)(undefined)).toBe(false);
+        });
+        it("should return false for array", () => {
+            expect((0, types_1.isInputContent)([])).toBe(false);
+            expect((0, types_1.isInputContent)([{ typeName: "text" }])).toBe(false);
+        });
+        it("should return false for object without typeName", () => {
+            expect((0, types_1.isInputContent)({ text: "Hello" })).toBe(false);
+        });
+        it("should return false for empty object", () => {
+            expect((0, types_1.isInputContent)({})).toBe(false);
+        });
+        it("should return false for function", () => {
+            expect((0, types_1.isInputContent)(() => { })).toBe(false);
+        });
+        it("should return false for Date object", () => {
+            expect((0, types_1.isInputContent)(new Date())).toBe(false);
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle object with typeName property of wrong type", () => {
+            const content = { typeName: 123 };
+            // Still returns true because it just checks for "typeName" in content
+            expect((0, types_1.isInputContent)(content)).toBe(true);
+        });
+        it("should handle deeply nested objects with typeName", () => {
+            const content = {
+                typeName: "text",
+                nested: { also: { typeName: "nested" } },
+            };
+            expect((0, types_1.isInputContent)(content)).toBe(true);
+        });
+    });
+});
+describe("isInputContentArray()", () => {
+    describe("returns true for valid InputContent arrays", () => {
+        it("should return true for array with single text InputContent", () => {
+            const contents = [{ typeName: "text", text: "Hello" }];
+            expect((0, types_1.isInputContentArray)(contents)).toBe(true);
+        });
+        it("should return true for array with multiple InputContents", () => {
+            const contents = [
+                { typeName: "text", text: "Hello" },
+                { typeName: "image", image: "https://example.com/img.png" },
+                { typeName: "file", file: "https://example.com/doc.pdf" },
+            ];
+            expect((0, types_1.isInputContentArray)(contents)).toBe(true);
+        });
+        it("should return true for empty array", () => {
+            expect((0, types_1.isInputContentArray)([])).toBe(true);
+        });
+        it("should return true for array with mixed content types", () => {
+            const contents = [
+                { typeName: "text", text: "Describe this:" },
+                { typeName: "image", image: "https://example.com/photo.jpg" },
+            ];
+            expect((0, types_1.isInputContentArray)(contents)).toBe(true);
+        });
+    });
+    describe("returns false for invalid inputs", () => {
+        it("should return false for string", () => {
+            expect((0, types_1.isInputContentArray)("Hello")).toBe(false);
+        });
+        it("should return false for number", () => {
+            expect((0, types_1.isInputContentArray)(42)).toBe(false);
+        });
+        it("should return false for null", () => {
+            expect((0, types_1.isInputContentArray)(null)).toBe(false);
+        });
+        it("should return false for undefined", () => {
+            expect((0, types_1.isInputContentArray)(undefined)).toBe(false);
+        });
+        it("should return false for object", () => {
+            expect((0, types_1.isInputContentArray)({ typeName: "text" })).toBe(false);
+        });
+        it("should return false for array with non-InputContent elements", () => {
+            expect((0, types_1.isInputContentArray)(["Hello", "World"])).toBe(false);
+        });
+        it("should return false for array with mixed valid and invalid elements", () => {
+            const mixed = [
+                { typeName: "text", text: "Valid" },
+                "Invalid string",
+            ];
+            expect((0, types_1.isInputContentArray)(mixed)).toBe(false);
+        });
+        it("should return false for array of numbers", () => {
+            expect((0, types_1.isInputContentArray)([1, 2, 3])).toBe(false);
+        });
+        it("should return false for array of objects without typeName", () => {
+            expect((0, types_1.isInputContentArray)([{ text: "Hello" }, { image: "url" }])).toBe(false);
+        });
+        it("should return false for array of null", () => {
+            expect((0, types_1.isInputContentArray)([null, null])).toBe(false);
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle large arrays", () => {
+            const largeArray = Array(1000)
+                .fill(null)
+                .map((_, i) => ({
+                typeName: "text",
+                text: `Item ${i}`,
+            }));
+            expect((0, types_1.isInputContentArray)(largeArray)).toBe(true);
+        });
+        it("should return false if one element fails validation", () => {
+            const mostlyValid = [
+                { typeName: "text", text: "Valid 1" },
+                { typeName: "text", text: "Valid 2" },
+                { noTypeName: "invalid" },
+                { typeName: "text", text: "Valid 3" },
+            ];
+            expect((0, types_1.isInputContentArray)(mostlyValid)).toBe(false);
+        });
+    });
+});
+describe("Type definitions", () => {
+    describe("InputContent", () => {
+        it("should accept text type", () => {
+            const content = {
+                typeName: "text",
+                text: "Hello world",
+            };
+            expect(content.typeName).toBe("text");
+            expect(content.text).toBe("Hello world");
+        });
+        it("should accept image type", () => {
+            const content = {
+                typeName: "image",
+                image: "https://example.com/image.png",
+            };
+            expect(content.typeName).toBe("image");
+            expect(content.image).toBe("https://example.com/image.png");
+        });
+        it("should accept file type", () => {
+            const content = {
+                typeName: "file",
+                file: "https://example.com/document.pdf",
+            };
+            expect(content.typeName).toBe("file");
+            expect(content.file).toBe("https://example.com/document.pdf");
+        });
+    });
+    describe("ModelContent", () => {
+        it("should accept user role", () => {
+            const content = {
+                content: "Hello",
+                role: "user",
+            };
+            expect(content.role).toBe("user");
+        });
+        it("should accept assistant role", () => {
+            const content = {
+                content: "Hello",
+                role: "assistant",
+            };
+            expect(content.role).toBe("assistant");
+        });
+        it("should accept system role", () => {
+            const content = {
+                content: "You are helpful",
+                role: "system",
+            };
+            expect(content.role).toBe("system");
+        });
+        it("should accept string content", () => {
+            const content = {
+                content: "String message",
+                role: "user",
+            };
+            expect(content.content).toBe("String message");
+        });
+        it("should accept InputContent content", () => {
+            const content = {
+                content: { typeName: "text", text: "InputContent" },
+                role: "user",
+            };
+            expect(content.content.typeName).toBe("text");
+        });
+        it("should accept InputContent array content", () => {
+            const content = {
+                content: [
+                    { typeName: "text", text: "First" },
+                    { typeName: "image", image: "url" },
+                ],
+                role: "user",
+            };
+            expect(Array.isArray(content.content)).toBe(true);
+            expect(content.content.length).toBe(2);
+        });
+    });
+    describe("ModelToolOutput", () => {
+        it("should have required properties", () => {
+            const output = {
+                outputType: "tool_call",
+                name: "get_weather",
+                arguments: { location: "San Francisco" },
+                callId: "call-123",
+            };
+            expect(output.outputType).toBe("tool_call");
+            expect(output.name).toBe("get_weather");
+            expect(output.arguments).toEqual({ location: "San Francisco" });
+            expect(output.callId).toBe("call-123");
+        });
+    });
+    describe("ModelTextOutput", () => {
+        it("should have required properties", () => {
+            const output = {
+                outputType: "output_text",
+                text: "Hello, world!",
+            };
+            expect(output.outputType).toBe("output_text");
+            expect(output.text).toBe("Hello, world!");
+        });
+    });
+    describe("ModelDeltaOutput", () => {
+        it("should have required properties", () => {
+            const delta = {
+                outputType: "output_text_delta",
+                delta: "Hello",
+                sequenceNumber: 1,
+            };
+            expect(delta.outputType).toBe("output_text_delta");
+            expect(delta.delta).toBe("Hello");
+            expect(delta.sequenceNumber).toBe(1);
+        });
+    });
+    describe("Usage", () => {
+        it("should have all token fields", () => {
+            const usage = {
+                inputTokens: 100,
+                inputTokensDetails: { cachedTokens: 10 },
+                outputTokens: 50,
+                outputTokensDetails: { reasoningTokens: 5 },
+                totalTokens: 150,
+            };
+            expect(usage.inputTokens).toBe(100);
+            expect(usage.inputTokensDetails.cachedTokens).toBe(10);
+            expect(usage.outputTokens).toBe(50);
+            expect(usage.outputTokensDetails.reasoningTokens).toBe(5);
+            expect(usage.totalTokens).toBe(150);
+        });
+    });
+    describe("ModelResponseData", () => {
+        it("should accept tool_call type", () => {
+            const data = {
+                typeName: "tool_call",
+                toolCall: {
+                    outputType: "tool_call",
+                    name: "search",
+                    arguments: { query: "test" },
+                    callId: "call-1",
+                },
+            };
+            expect(data.typeName).toBe("tool_call");
+            expect(data.toolCall?.name).toBe("search");
+        });
+        it("should accept output_text type", () => {
+            const data = {
+                typeName: "output_text",
+                outputText: {
+                    outputType: "output_text",
+                    text: "Response text",
+                },
+            };
+            expect(data.typeName).toBe("output_text");
+            expect(data.outputText?.text).toBe("Response text");
+        });
+        it("should accept output_text_delta type", () => {
+            const data = {
+                typeName: "output_text_delta",
+                outputTextDelta: {
+                    outputType: "output_text_delta",
+                    delta: "chunk",
+                    sequenceNumber: 3,
+                },
+            };
+            expect(data.typeName).toBe("output_text_delta");
+            expect(data.outputTextDelta?.delta).toBe("chunk");
+        });
+        it("should accept response.completed type", () => {
+            const data = {
+                typeName: "response.completed",
+            };
+            expect(data.typeName).toBe("response.completed");
+        });
+        it("should accept response.requested type", () => {
+            const data = {
+                typeName: "response.requested",
+                requested: { model: "gpt-4" },
+            };
+            expect(data.typeName).toBe("response.requested");
+            expect(data.requested.model).toBe("gpt-4");
+        });
+        it("should accept output_text.part.done type", () => {
+            const data = {
+                typeName: "output_text.part.done",
+                outputText: {
+                    outputType: "output_text",
+                    text: "Part done",
+                },
+            };
+            expect(data.typeName).toBe("output_text.part.done");
+        });
+    });
+    describe("ModelResponse", () => {
+        it("should have eventName and data", () => {
+            const response = {
+                eventName: "response.output_text.done",
+                data: {
+                    typeName: "output_text",
+                    outputText: {
+                        outputType: "output_text",
+                        text: "Complete",
+                    },
+                },
+            };
+            expect(response.eventName).toBe("response.output_text.done");
+            expect(response.data).toBeDefined();
+        });
+        it("should accept data as array", () => {
+            const response = {
+                eventName: "response.completed",
+                data: [
+                    {
+                        typeName: "output_text",
+                        outputText: { outputType: "output_text", text: "First" },
+                    },
+                    {
+                        typeName: "output_text",
+                        outputText: { outputType: "output_text", text: "Second" },
+                    },
+                ],
+            };
+            expect(Array.isArray(response.data)).toBe(true);
+            expect(response.data.length).toBe(2);
+        });
+        it("should have optional usage field", () => {
+            const response = {
+                eventName: "response.done",
+                data: { typeName: "response.completed" },
+                usage: {
+                    inputTokens: 100,
+                    inputTokensDetails: { cachedTokens: 0 },
+                    outputTokens: 50,
+                    outputTokensDetails: { reasoningTokens: 0 },
+                    totalTokens: 150,
+                },
+            };
+            expect(response.usage?.totalTokens).toBe(150);
+        });
+    });
+    describe("ToolCallResponse", () => {
+        it("should be a generic record type", () => {
+            const response = {
+                output: '{"result": "success"}',
+                type: "function_call_output",
+                call_id: "call-123",
+            };
+            expect(response.output).toBe('{"result": "success"}');
+            expect(response.type).toBe("function_call_output");
+            expect(response.call_id).toBe("call-123");
+        });
+        it("should accept any keys", () => {
+            const response = {
+                customField: "custom value",
+                numericField: 42,
+                nested: { key: "value" },
+            };
+            expect(response.customField).toBe("custom value");
+            expect(response.numericField).toBe(42);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.test.js","sourceRoot":"","sources":["../../tests/types.test.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    isInputContent,\n    isInputContentArray,\n    InputContent,\n    ModelContent,\n    ModelResponse,\n    ModelResponseData,\n    ModelToolOutput,\n    ModelTextOutput,\n    ModelDeltaOutput,\n    Usage,\n    ToolCallResponse,\n} from \"../src/models/types\";\n\ndescribe(\"isInputContent()\", () => {\n    describe(\"returns true for valid InputContent\", () => {\n        it(\"should return true for text InputContent\", () => {\n            const content: InputContent = {\n                typeName: \"text\",\n                text: \"Hello world\",\n            };\n\n            expect(isInputContent(content)).toBe(true);\n        });\n\n        it(\"should return true for image InputContent\", () => {\n            const content: InputContent = {\n                typeName: \"image\",\n                image: \"https://example.com/image.png\",\n            };\n\n            expect(isInputContent(content)).toBe(true);\n        });\n\n        it(\"should return true for file InputContent\", () => {\n            const content: InputContent = {\n                typeName: \"file\",\n                file: \"https://example.com/document.pdf\",\n            };\n\n            expect(isInputContent(content)).toBe(true);\n        });\n\n        it(\"should return true for InputContent with minimal required fields\", () => {\n            const content = { typeName: \"text\" as const };\n\n            expect(isInputContent(content)).toBe(true);\n        });\n\n        it(\"should return true for InputContent with all optional fields\", () => {\n            const content: InputContent = {\n                typeName: \"text\",\n                text: \"text content\",\n                image: \"image url\",\n                file: \"file url\",\n            };\n\n            expect(isInputContent(content)).toBe(true);\n        });\n    });\n\n    describe(\"returns false for invalid inputs\", () => {\n        it(\"should return false for string\", () => {\n            expect(isInputContent(\"Hello world\")).toBe(false);\n        });\n\n        it(\"should return false for number\", () => {\n            expect(isInputContent(42)).toBe(false);\n        });\n\n        it(\"should return false for boolean\", () => {\n            expect(isInputContent(true)).toBe(false);\n        });\n\n        it(\"should return false for null\", () => {\n            expect(isInputContent(null)).toBe(false);\n        });\n\n        it(\"should return false for undefined\", () => {\n            expect(isInputContent(undefined)).toBe(false);\n        });\n\n        it(\"should return false for array\", () => {\n            expect(isInputContent([])).toBe(false);\n            expect(isInputContent([{ typeName: \"text\" }])).toBe(false);\n        });\n\n        it(\"should return false for object without typeName\", () => {\n            expect(isInputContent({ text: \"Hello\" })).toBe(false);\n        });\n\n        it(\"should return false for empty object\", () => {\n            expect(isInputContent({})).toBe(false);\n        });\n\n        it(\"should return false for function\", () => {\n            expect(isInputContent(() => {})).toBe(false);\n        });\n\n        it(\"should return false for Date object\", () => {\n            expect(isInputContent(new Date())).toBe(false);\n        });\n    });\n\n    describe(\"edge cases\", () => {\n        it(\"should handle object with typeName property of wrong type\", () => {\n            const content = { typeName: 123 };\n            // Still returns true because it just checks for \"typeName\" in content\n            expect(isInputContent(content)).toBe(true);\n        });\n\n        it(\"should handle deeply nested objects with typeName\", () => {\n            const content = {\n                typeName: \"text\",\n                nested: { also: { typeName: \"nested\" } },\n            };\n\n            expect(isInputContent(content)).toBe(true);\n        });\n    });\n});\n\ndescribe(\"isInputContentArray()\", () => {\n    describe(\"returns true for valid InputContent arrays\", () => {\n        it(\"should return true for array with single text InputContent\", () => {\n            const contents: InputContent[] = [{ typeName: \"text\", text: \"Hello\" }];\n\n            expect(isInputContentArray(contents)).toBe(true);\n        });\n\n        it(\"should return true for array with multiple InputContents\", () => {\n            const contents: InputContent[] = [\n                { typeName: \"text\", text: \"Hello\" },\n                { typeName: \"image\", image: \"https://example.com/img.png\" },\n                { typeName: \"file\", file: \"https://example.com/doc.pdf\" },\n            ];\n\n            expect(isInputContentArray(contents)).toBe(true);\n        });\n\n        it(\"should return true for empty array\", () => {\n            expect(isInputContentArray([])).toBe(true);\n        });\n\n        it(\"should return true for array with mixed content types\", () => {\n            const contents: InputContent[] = [\n                { typeName: \"text\", text: \"Describe this:\" },\n                { typeName: \"image\", image: \"https://example.com/photo.jpg\" },\n            ];\n\n            expect(isInputContentArray(contents)).toBe(true);\n        });\n    });\n\n    describe(\"returns false for invalid inputs\", () => {\n        it(\"should return false for string\", () => {\n            expect(isInputContentArray(\"Hello\")).toBe(false);\n        });\n\n        it(\"should return false for number\", () => {\n            expect(isInputContentArray(42)).toBe(false);\n        });\n\n        it(\"should return false for null\", () => {\n            expect(isInputContentArray(null)).toBe(false);\n        });\n\n        it(\"should return false for undefined\", () => {\n            expect(isInputContentArray(undefined)).toBe(false);\n        });\n\n        it(\"should return false for object\", () => {\n            expect(isInputContentArray({ typeName: \"text\" })).toBe(false);\n        });\n\n        it(\"should return false for array with non-InputContent elements\", () => {\n            expect(isInputContentArray([\"Hello\", \"World\"])).toBe(false);\n        });\n\n        it(\"should return false for array with mixed valid and invalid elements\", () => {\n            const mixed = [\n                { typeName: \"text\", text: \"Valid\" },\n                \"Invalid string\",\n            ];\n\n            expect(isInputContentArray(mixed)).toBe(false);\n        });\n\n        it(\"should return false for array of numbers\", () => {\n            expect(isInputContentArray([1, 2, 3])).toBe(false);\n        });\n\n        it(\"should return false for array of objects without typeName\", () => {\n            expect(isInputContentArray([{ text: \"Hello\" }, { image: \"url\" }])).toBe(\n                false\n            );\n        });\n\n        it(\"should return false for array of null\", () => {\n            expect(isInputContentArray([null, null])).toBe(false);\n        });\n    });\n\n    describe(\"edge cases\", () => {\n        it(\"should handle large arrays\", () => {\n            const largeArray: InputContent[] = Array(1000)\n                .fill(null)\n                .map((_, i) => ({\n                    typeName: \"text\" as const,\n                    text: `Item ${i}`,\n                }));\n\n            expect(isInputContentArray(largeArray)).toBe(true);\n        });\n\n        it(\"should return false if one element fails validation\", () => {\n            const mostlyValid = [\n                { typeName: \"text\", text: \"Valid 1\" },\n                { typeName: \"text\", text: \"Valid 2\" },\n                { noTypeName: \"invalid\" },\n                { typeName: \"text\", text: \"Valid 3\" },\n            ];\n\n            expect(isInputContentArray(mostlyValid)).toBe(false);\n        });\n    });\n});\n\ndescribe(\"Type definitions\", () => {\n    describe(\"InputContent\", () => {\n        it(\"should accept text type\", () => {\n            const content: InputContent = {\n                typeName: \"text\",\n                text: \"Hello world\",\n            };\n\n            expect(content.typeName).toBe(\"text\");\n            expect(content.text).toBe(\"Hello world\");\n        });\n\n        it(\"should accept image type\", () => {\n            const content: InputContent = {\n                typeName: \"image\",\n                image: \"https://example.com/image.png\",\n            };\n\n            expect(content.typeName).toBe(\"image\");\n            expect(content.image).toBe(\"https://example.com/image.png\");\n        });\n\n        it(\"should accept file type\", () => {\n            const content: InputContent = {\n                typeName: \"file\",\n                file: \"https://example.com/document.pdf\",\n            };\n\n            expect(content.typeName).toBe(\"file\");\n            expect(content.file).toBe(\"https://example.com/document.pdf\");\n        });\n    });\n\n    describe(\"ModelContent\", () => {\n        it(\"should accept user role\", () => {\n            const content: ModelContent = {\n                content: \"Hello\",\n                role: \"user\",\n            };\n\n            expect(content.role).toBe(\"user\");\n        });\n\n        it(\"should accept assistant role\", () => {\n            const content: ModelContent = {\n                content: \"Hello\",\n                role: \"assistant\",\n            };\n\n            expect(content.role).toBe(\"assistant\");\n        });\n\n        it(\"should accept system role\", () => {\n            const content: ModelContent = {\n                content: \"You are helpful\",\n                role: \"system\",\n            };\n\n            expect(content.role).toBe(\"system\");\n        });\n\n        it(\"should accept string content\", () => {\n            const content: ModelContent = {\n                content: \"String message\",\n                role: \"user\",\n            };\n\n            expect(content.content).toBe(\"String message\");\n        });\n\n        it(\"should accept InputContent content\", () => {\n            const content: ModelContent = {\n                content: { typeName: \"text\", text: \"InputContent\" },\n                role: \"user\",\n            };\n\n            expect((content.content as InputContent).typeName).toBe(\"text\");\n        });\n\n        it(\"should accept InputContent array content\", () => {\n            const content: ModelContent = {\n                content: [\n                    { typeName: \"text\", text: \"First\" },\n                    { typeName: \"image\", image: \"url\" },\n                ],\n                role: \"user\",\n            };\n\n            expect(Array.isArray(content.content)).toBe(true);\n            expect((content.content as InputContent[]).length).toBe(2);\n        });\n    });\n\n    describe(\"ModelToolOutput\", () => {\n        it(\"should have required properties\", () => {\n            const output: ModelToolOutput = {\n                outputType: \"tool_call\",\n                name: \"get_weather\",\n                arguments: { location: \"San Francisco\" },\n                callId: \"call-123\",\n            };\n\n            expect(output.outputType).toBe(\"tool_call\");\n            expect(output.name).toBe(\"get_weather\");\n            expect(output.arguments).toEqual({ location: \"San Francisco\" });\n            expect(output.callId).toBe(\"call-123\");\n        });\n    });\n\n    describe(\"ModelTextOutput\", () => {\n        it(\"should have required properties\", () => {\n            const output: ModelTextOutput = {\n                outputType: \"output_text\",\n                text: \"Hello, world!\",\n            };\n\n            expect(output.outputType).toBe(\"output_text\");\n            expect(output.text).toBe(\"Hello, world!\");\n        });\n    });\n\n    describe(\"ModelDeltaOutput\", () => {\n        it(\"should have required properties\", () => {\n            const delta: ModelDeltaOutput = {\n                outputType: \"output_text_delta\",\n                delta: \"Hello\",\n                sequenceNumber: 1,\n            };\n\n            expect(delta.outputType).toBe(\"output_text_delta\");\n            expect(delta.delta).toBe(\"Hello\");\n            expect(delta.sequenceNumber).toBe(1);\n        });\n    });\n\n    describe(\"Usage\", () => {\n        it(\"should have all token fields\", () => {\n            const usage: Usage = {\n                inputTokens: 100,\n                inputTokensDetails: { cachedTokens: 10 },\n                outputTokens: 50,\n                outputTokensDetails: { reasoningTokens: 5 },\n                totalTokens: 150,\n            };\n\n            expect(usage.inputTokens).toBe(100);\n            expect(usage.inputTokensDetails.cachedTokens).toBe(10);\n            expect(usage.outputTokens).toBe(50);\n            expect(usage.outputTokensDetails.reasoningTokens).toBe(5);\n            expect(usage.totalTokens).toBe(150);\n        });\n    });\n\n    describe(\"ModelResponseData\", () => {\n        it(\"should accept tool_call type\", () => {\n            const data: ModelResponseData = {\n                typeName: \"tool_call\",\n                toolCall: {\n                    outputType: \"tool_call\",\n                    name: \"search\",\n                    arguments: { query: \"test\" },\n                    callId: \"call-1\",\n                },\n            };\n\n            expect(data.typeName).toBe(\"tool_call\");\n            expect(data.toolCall?.name).toBe(\"search\");\n        });\n\n        it(\"should accept output_text type\", () => {\n            const data: ModelResponseData = {\n                typeName: \"output_text\",\n                outputText: {\n                    outputType: \"output_text\",\n                    text: \"Response text\",\n                },\n            };\n\n            expect(data.typeName).toBe(\"output_text\");\n            expect(data.outputText?.text).toBe(\"Response text\");\n        });\n\n        it(\"should accept output_text_delta type\", () => {\n            const data: ModelResponseData = {\n                typeName: \"output_text_delta\",\n                outputTextDelta: {\n                    outputType: \"output_text_delta\",\n                    delta: \"chunk\",\n                    sequenceNumber: 3,\n                },\n            };\n\n            expect(data.typeName).toBe(\"output_text_delta\");\n            expect(data.outputTextDelta?.delta).toBe(\"chunk\");\n        });\n\n        it(\"should accept response.completed type\", () => {\n            const data: ModelResponseData = {\n                typeName: \"response.completed\",\n            };\n\n            expect(data.typeName).toBe(\"response.completed\");\n        });\n\n        it(\"should accept response.requested type\", () => {\n            const data: ModelResponseData = {\n                typeName: \"response.requested\",\n                requested: { model: \"gpt-4\" },\n            };\n\n            expect(data.typeName).toBe(\"response.requested\");\n            expect(data.requested.model).toBe(\"gpt-4\");\n        });\n\n        it(\"should accept output_text.part.done type\", () => {\n            const data: ModelResponseData = {\n                typeName: \"output_text.part.done\",\n                outputText: {\n                    outputType: \"output_text\",\n                    text: \"Part done\",\n                },\n            };\n\n            expect(data.typeName).toBe(\"output_text.part.done\");\n        });\n    });\n\n    describe(\"ModelResponse\", () => {\n        it(\"should have eventName and data\", () => {\n            const response: ModelResponse = {\n                eventName: \"response.output_text.done\",\n                data: {\n                    typeName: \"output_text\",\n                    outputText: {\n                        outputType: \"output_text\",\n                        text: \"Complete\",\n                    },\n                },\n            };\n\n            expect(response.eventName).toBe(\"response.output_text.done\");\n            expect(response.data).toBeDefined();\n        });\n\n        it(\"should accept data as array\", () => {\n            const response: ModelResponse = {\n                eventName: \"response.completed\",\n                data: [\n                    {\n                        typeName: \"output_text\",\n                        outputText: { outputType: \"output_text\", text: \"First\" },\n                    },\n                    {\n                        typeName: \"output_text\",\n                        outputText: { outputType: \"output_text\", text: \"Second\" },\n                    },\n                ],\n            };\n\n            expect(Array.isArray(response.data)).toBe(true);\n            expect((response.data as ModelResponseData[]).length).toBe(2);\n        });\n\n        it(\"should have optional usage field\", () => {\n            const response: ModelResponse = {\n                eventName: \"response.done\",\n                data: { typeName: \"response.completed\" },\n                usage: {\n                    inputTokens: 100,\n                    inputTokensDetails: { cachedTokens: 0 },\n                    outputTokens: 50,\n                    outputTokensDetails: { reasoningTokens: 0 },\n                    totalTokens: 150,\n                },\n            };\n\n            expect(response.usage?.totalTokens).toBe(150);\n        });\n    });\n\n    describe(\"ToolCallResponse\", () => {\n        it(\"should be a generic record type\", () => {\n            const response: ToolCallResponse = {\n                output: '{\"result\": \"success\"}',\n                type: \"function_call_output\",\n                call_id: \"call-123\",\n            };\n\n            expect(response.output).toBe('{\"result\": \"success\"}');\n            expect(response.type).toBe(\"function_call_output\");\n            expect(response.call_id).toBe(\"call-123\");\n        });\n\n        it(\"should accept any keys\", () => {\n            const response: ToolCallResponse = {\n                customField: \"custom value\",\n                numericField: 42,\n                nested: { key: \"value\" },\n            };\n\n            expect(response.customField).toBe(\"custom value\");\n            expect(response.numericField).toBe(42);\n        });\n    });\n});\n\n\n\n\n"]}

package/dist/tools/tool.d.ts

@@ -0,0 +1,33 @@
+export interface ToolArg {
+    readonly name?: string;
+    readonly argType: string;
+    readonly description: string;
+    readonly required: boolean;
+    readonly defaultValue?: unknown;
+    readonly enumValues?: string[];
+}
+export interface ITool {
+    name: string;
+    description: string;
+    schema?: Schema;
+    execute(args: Record<string, unknown>): unknown;
+}
+export declare class ToolArgBuilder {
+    argType: string;
+    description: string;
+    required: boolean;
+    defaultValue?: unknown;
+    enumValues?: string[];
+    constructor(argType: string, description: string, required: boolean, defaultValue?: unknown, enumValues?: string[]);
+    isRequired(): ToolArgBuilder;
+    defaultTo(defaultValue: unknown): ToolArgBuilder;
+}
+export declare class Schema {
+    readonly properties: Record<string, ToolArgBuilder>;
+    private constructor();
+    static objectValue(properties: Record<string, ToolArgBuilder>): Schema;
+    static stringValue(description: string): ToolArgBuilder;
+    static numberValue(description: string): ToolArgBuilder;
+    static booleanValue(description: string): ToolArgBuilder;
+    static enumValue(description: string, enumValues: string[]): ToolArgBuilder;
+}

package/dist/tools/tool.js

@@ -0,0 +1,49 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = exports.ToolArgBuilder = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+class ToolArgBuilder {
+    constructor(argType, description, required, defaultValue, enumValues) {
+        this.argType = argType;
+        this.description = description;
+        this.required = required;
+        this.defaultValue = defaultValue;
+        this.enumValues = enumValues;
+    }
+    isRequired() {
+        this.required = true;
+        return this;
+    }
+    defaultTo(defaultValue) {
+        this.defaultValue = defaultValue;
+        return this;
+    }
+}
+exports.ToolArgBuilder = ToolArgBuilder;
+_a = JSII_RTTI_SYMBOL_1;
+ToolArgBuilder[_a] = { fqn: "@shuttl-io/core.ToolArgBuilder", version: "0.2.0" };
+class Schema {
+    constructor(properties) {
+        this.properties = properties;
+    }
+    static objectValue(properties) {
+        return new Schema(properties);
+    }
+    static stringValue(description) {
+        return new ToolArgBuilder("string", description, false);
+    }
+    static numberValue(description) {
+        return new ToolArgBuilder("number", description, false);
+    }
+    static booleanValue(description) {
+        return new ToolArgBuilder("boolean", description, false);
+    }
+    static enumValue(description, enumValues) {
+        return new ToolArgBuilder("string", description, false, undefined, enumValues);
+    }
+}
+exports.Schema = Schema;
+_b = JSII_RTTI_SYMBOL_1;
+Schema[_b] = { fqn: "@shuttl-io/core.Schema", version: "0.2.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/toolkit.d.ts

@@ -0,0 +1,13 @@
+import { ITool } from "./tool";
+export interface ToolkitProps {
+    readonly name: string;
+    readonly description?: string;
+    readonly tools?: ITool[];
+}
+export declare class Toolkit {
+    readonly name: string;
+    readonly description: string | undefined;
+    readonly tools: ITool[];
+    constructor(props: ToolkitProps);
+    addTool(tool: ITool): void;
+}

package/dist/tools/toolkit.js

@@ -0,0 +1,19 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Toolkit = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+class Toolkit {
+    constructor(props) {
+        this.name = props.name;
+        this.description = props.description;
+        this.tools = props.tools ?? [];
+    }
+    addTool(tool) {
+        this.tools.push(tool);
+    }
+}
+exports.Toolkit = Toolkit;
+_a = JSII_RTTI_SYMBOL_1;
+Toolkit[_a] = { fqn: "@shuttl-io/core.Toolkit", version: "0.2.0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbGtpdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90b29scy90b29sa2l0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBUUEsTUFBYSxPQUFPO0lBS2hCLFlBQW1CLEtBQW1CO1FBQ2xDLElBQUksQ0FBQyxJQUFJLEdBQUcsS0FBSyxDQUFDLElBQUksQ0FBQztRQUN2QixJQUFJLENBQUMsV0FBVyxHQUFHLEtBQUssQ0FBQyxXQUFXLENBQUM7UUFDckMsSUFBSSxDQUFDLEtBQUssR0FBRyxLQUFLLENBQUMsS0FBSyxJQUFJLEVBQUUsQ0FBQztJQUNuQyxDQUFDO0lBRU0sT0FBTyxDQUFDLElBQVc7UUFDdEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDMUIsQ0FBQzs7QUFiTCwwQkFjQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElUb29sIH0gZnJvbSBcIi4vdG9vbFwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIFRvb2xraXRQcm9wcyB7XG4gICAgcmVhZG9ubHkgbmFtZTogc3RyaW5nO1xuICAgIHJlYWRvbmx5IGRlc2NyaXB0aW9uPzogc3RyaW5nO1xuICAgIHJlYWRvbmx5IHRvb2xzPzogSVRvb2xbXTtcbn1cblxuZXhwb3J0IGNsYXNzIFRvb2xraXQge1xuICAgIHB1YmxpYyByZWFkb25seSBuYW1lOiBzdHJpbmc7XG4gICAgcHVibGljIHJlYWRvbmx5IGRlc2NyaXB0aW9uOiBzdHJpbmcgfCB1bmRlZmluZWQ7XG4gICAgcHVibGljIHJlYWRvbmx5IHRvb2xzOiBJVG9vbFtdO1xuXG4gICAgcHVibGljIGNvbnN0cnVjdG9yKHByb3BzOiBUb29sa2l0UHJvcHMpIHtcbiAgICAgICAgdGhpcy5uYW1lID0gcHJvcHMubmFtZTtcbiAgICAgICAgdGhpcy5kZXNjcmlwdGlvbiA9IHByb3BzLmRlc2NyaXB0aW9uO1xuICAgICAgICB0aGlzLnRvb2xzID0gcHJvcHMudG9vbHMgPz8gW107XG4gICAgfVxuXG4gICAgcHVibGljIGFkZFRvb2wodG9vbDogSVRvb2wpOiB2b2lkIHtcbiAgICAgICAgdGhpcy50b29scy5wdXNoKHRvb2wpO1xuICAgIH1cbn0iXX0=