@shuttl-io/core 0.2.0

package/dist/src/models/openAi.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIFactory = exports.OpenAI = exports.OpenAIBadKeyError = exports.OpenAIError = void 0;
+const types_1 = require("./types");
+class OpenAIError extends Error {
+    constructor(message, statusCode, error) {
+        super(message);
+        this.statusCode = statusCode;
+        this.error = error;
+        this.isRetryable = true;
+        this.isRetryable = true;
+    }
+}
+exports.OpenAIError = OpenAIError;
+class OpenAIBadKeyError extends Error {
+    constructor(message, statusCode, error) {
+        super(message);
+        this.statusCode = statusCode;
+        this.error = error;
+        this.isRetryable = false;
+        this.isRetryable = false;
+    }
+}
+exports.OpenAIBadKeyError = OpenAIBadKeyError;
+class OpenAI {
+    constructor(identifier, apiKey, systemPrompt, tools) {
+        this.identifier = identifier;
+        this.apiKey = apiKey;
+        this.systemPrompt = systemPrompt;
+        this.tools = tools;
+        this.messages = [];
+        this.inputs = [];
+        this.isDoneReceiving = true;
+        // this.threadId = crypto.randomUUID();
+        this.threadIDPromise = this.getThreadId();
+        this.messages.push({
+            content: systemPrompt,
+            role: "system",
+        });
+    }
+    async getThreadId() {
+        // Make a request to the OpenAI API to create a new conversation. Use Node primitives to make the request.
+        const response = await fetch("https://api.openai.com/v1/conversations", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                items: [
+                    {
+                        role: "system",
+                        content: this.systemPrompt,
+                    }
+                ]
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.json();
+            throw new OpenAIError("failed to create thread", response.status, error);
+        }
+        const data = await response.json();
+        const threadId = data.id;
+        return threadId;
+    }
+    async invoke(prompt, streamer) {
+        // If the model is not done receiving, wait for it to be done
+        if (!this.isDoneReceiving) {
+            return new Promise((resolve) => {
+                setTimeout(async () => {
+                    await this.invoke(prompt, streamer);
+                    resolve();
+                }, 0);
+            });
+        }
+        this.isDoneReceiving = false;
+        this.inputs.push(...prompt);
+        if (!this.threadId) {
+            this.threadId = await this.threadIDPromise;
+        }
+        // this.inputs.push(...prompt);
+        const stream = true;
+        const tools = this.tools?.map(tool => ({
+            type: "function",
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+                type: "object",
+                properties: Object.entries(tool.schema?.properties ?? {}).reduce((acc, [name, arg]) => {
+                    const property = {
+                        type: arg.argType,
+                        description: arg.description,
+                        default: arg.defaultValue,
+                    };
+                    if (arg.enumValues) {
+                        property.enum = arg.enumValues;
+                    }
+                    acc[name] = property;
+                    return acc;
+                }, {}),
+                required: Object.entries(tool.schema?.properties ?? {}).filter(([_, arg]) => arg.required).map(([name]) => name),
+            }
+        }));
+        const body = {
+            model: this.identifier,
+            conversation: this.threadId,
+            input: this.inputs.map(input => this.createInput(input)),
+            parallel_tool_calls: false,
+            stream,
+            tools: tools ?? [],
+        };
+        streamer.recieve(this, {
+            eventName: "response.requested",
+            data: {
+                typeName: "response.requested",
+                requested: body,
+                threadId: this.threadId,
+            },
+        });
+        try {
+            const response = await fetch(`https://api.openai.com/v1/responses`, {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                if (response.status === 401 && error.error.code === "invalid_api_key") {
+                    throw new OpenAIBadKeyError("bad API key", response.status, error);
+                }
+                throw new OpenAIError("failed to invoke model", response.status, error);
+            }
+            if (stream) {
+                const reader = await response.body?.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (true) {
+                    const result = await reader?.read();
+                    if (!result) {
+                        break;
+                    }
+                    const { done, value } = result;
+                    if (done) {
+                        streamer.recieve(this, {
+                            eventName: "overall.completed",
+                            data: {
+                                typeName: "overall.completed",
+                            },
+                            threadId: this.threadId,
+                        });
+                        break;
+                    }
+                    buffer += decoder.decode(value, { stream: true });
+                    // Process complete messages (delimited by double newlines)
+                    let separatorIndex;
+                    while ((separatorIndex = buffer.indexOf("\n\n")) !== -1) {
+                        const rawMessage = buffer.slice(0, separatorIndex);
+                        buffer = buffer.slice(separatorIndex + 2);
+                        if (!rawMessage.trim()) {
+                            continue;
+                        }
+                        // Raw data is a string in the format of `event: <event_name>\ndata: <event_data>`
+                        const eventMatch = rawMessage.match(/^event: (.+)$/m);
+                        const dataMatch = rawMessage.match(/^data: (.+)$/m);
+                        if (eventMatch && dataMatch) {
+                            const eventName = eventMatch[1];
+                            const eventData = dataMatch[1];
+                            const data = JSON.parse(eventData);
+                            const response = this.createResponse(eventName, data);
+                            streamer.recieve(this, response);
+                        }
+                    }
+                }
+            }
+            else {
+                const data = await response.json();
+                streamer.recieve(this, data);
+                streamer.recieve(this, {
+                    eventName: "overall.completed",
+                    data: {
+                        typeName: "overall.completed",
+                    },
+                    threadId: this.threadId,
+                });
+            }
+        }
+        finally {
+            this.isDoneReceiving = true;
+        }
+    }
+    createInputContent(content) {
+        if (content.typeName === "image") {
+            return {
+                type: "input_image",
+                image_url: content.image,
+            };
+        }
+        if (content.typeName === "file") {
+            // Handle file attachments with base64 content
+            if (content.fileData) {
+                return {
+                    type: "input_file",
+                    filename: content.fileData.name,
+                    file_data: `data:${content.fileData.mimeType || "application/octet-stream"};base64,${content.fileData.content}`,
+                };
+            }
+            // Fallback to URL-based file reference
+            return {
+                type: "input_file",
+                file_url: content.file,
+            };
+        }
+        return {
+            type: "input_text",
+            text: content.text,
+        };
+    }
+    createInput(input) {
+        if ("role" in input) {
+            const realInput = input;
+            // if content is not a string, content should be transformed to a chat GPT input
+            if (typeof realInput.content !== "string") {
+                if ((0, types_1.isInputContentArray)(realInput.content)) {
+                    const content = realInput.content.flatMap(c => this.createInputContent(c));
+                    return { role: realInput.role, content: content };
+                }
+                else if ((0, types_1.isInputContent)(realInput.content)) {
+                    let content = this.createInputContent(realInput.content);
+                    if (Array.isArray(content)) {
+                        return { role: realInput.role, content: content };
+                    }
+                    return { role: realInput.role, content: [content] };
+                }
+            }
+            return { role: realInput.role, content: realInput.content };
+        }
+        return input;
+    }
+    createResponse(eventName, data) {
+        switch (eventName) {
+            case "response.completed":
+                const response = data.response.output.reduce((acc, output) => {
+                    if (output.type === "function_call") {
+                        acc.push({
+                            typeName: "tool_call",
+                            toolCall: output,
+                        });
+                    }
+                    if (output.type === "message") {
+                        output.content.forEach((content) => {
+                            acc.push({
+                                typeName: "output_text",
+                                outputText: {
+                                    outputType: "output_text",
+                                    text: content.text,
+                                },
+                            });
+                        });
+                    }
+                    return acc;
+                }, []);
+                return {
+                    eventName: "response.completed",
+                    modelInstance: this,
+                    data: {
+                        typeName: "response.completed",
+                        ...response,
+                    },
+                    usage: data.response.usage,
+                };
+            case "response.output_text.delta":
+                return {
+                    eventName: "response.output_text_delta",
+                    modelInstance: this,
+                    data: {
+                        typeName: "output_text_delta",
+                        outputTextDelta: {
+                            outputType: "output_text_delta",
+                            delta: data.delta,
+                            sequenceNumber: data.sequence_number,
+                        },
+                    },
+                };
+            case "response.content_part.done":
+                return {
+                    eventName: "response.content_part.done",
+                    modelInstance: this,
+                    data: {
+                        typeName: "output_text",
+                        outputText: {
+                            outputType: "output_text",
+                            text: data.part.text,
+                        },
+                    },
+                };
+            case "response.output_item.done":
+                const output = data.item;
+                if (output.type === "message") {
+                    return {
+                        eventName: "response.output_text.done",
+                        modelInstance: this,
+                        data: {
+                            typeName: "output_text.part.done",
+                            outputText: {
+                                outputType: "output_text",
+                                text: output.content[0].text,
+                            }
+                        },
+                    };
+                }
+                return {
+                    eventName: "response.completed",
+                    modelInstance: this,
+                    data: {
+                        typeName: "tool_call",
+                        toolCall: {
+                            outputType: "tool_call",
+                            name: output.name,
+                            arguments: JSON.parse(output.arguments),
+                            callId: output.call_id,
+                        },
+                    },
+                };
+            default:
+                return data;
+        }
+    }
+}
+exports.OpenAI = OpenAI;
+class OpenAIFactory {
+    constructor(identifier, apiKey) {
+        this.identifier = identifier;
+        this.apiKey = apiKey;
+        this.create = this.create.bind(this);
+    }
+    async create(props) {
+        return new OpenAI(this.identifier, await this.apiKey.resolveSecret(), props.systemPrompt, props.tools);
+    }
+}
+exports.OpenAIFactory = OpenAIFactory;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openAi.js","sourceRoot":"","sources":["../../../src/models/openAi.ts"],"names":[],"mappings":"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","sourcesContent":["import { ISecret } from \"../secrets\";\nimport { \n    IModel, \n    IModelFactory, \n    IModelFactoryProps,\n    ModelContent,\n    IModelStreamer,\n    ModelResponse,\n    ToolCallResponse,\n    ModelResponseData,\n    isInputContentArray,\n    isInputContent,\n    InputContent,\n} from \"./types\";\nimport { ITool } from \"../tools/tool\";\n\nexport class OpenAIError extends Error {\n    public readonly isRetryable: boolean = true;\n    constructor(\n        message: string, \n        public readonly statusCode: number, \n        public readonly error: any,\n    ) {\n        super(message);\n        this.isRetryable = true;\n    }\n}\nexport class OpenAIBadKeyError extends Error {\n    public readonly isRetryable: boolean = false;\n    constructor(message: string, public readonly statusCode: number, public readonly error: any) {\n        super(message);\n        this.isRetryable = false;\n    }\n}\n\nexport class OpenAI implements IModel {\n    private readonly messages: ModelContent[] = [];\n    private threadIDPromise: Promise<string>;\n    public threadId?: string;\n    private inputs: (ModelContent | ToolCallResponse)[] = [];\n    public isDoneReceiving: boolean = true;\n\n    public constructor(\n        public readonly identifier: string,\n        public readonly apiKey: string,\n        public readonly systemPrompt: string,\n        public readonly tools?: ITool[],\n    ){\n\n        // this.threadId = crypto.randomUUID();\n        this.threadIDPromise = this.getThreadId();\n        this.messages.push({\n            content: systemPrompt,\n            role: \"system\",\n        });\n    }\n\n    private async getThreadId(): Promise<string> {\n        // Make a request to the OpenAI API to create a new conversation. Use Node primitives to make the request.\n        const response = await fetch(\"https://api.openai.com/v1/conversations\", {\n            method: \"POST\",\n            headers: {\n                \"Authorization\": `Bearer ${this.apiKey}`,\n                \"Content-Type\": \"application/json\",\n            },\n            body: JSON.stringify({\n                items: [\n                    {\n                        role: \"system\",\n                        content: this.systemPrompt,\n                    }\n                ]\n            }),\n        });\n        if (!response.ok) {\n            const error = await response.json();\n            throw new OpenAIError(\"failed to create thread\", response.status, error);\n        }\n        const data = await response.json() as { id: string, object: string };\n        const threadId = data.id;\n        return threadId;\n    }\n\n    public async invoke(prompt: ModelContent[], streamer: IModelStreamer): Promise<void> {\n        // If the model is not done receiving, wait for it to be done\n        if (!this.isDoneReceiving) {\n            return new Promise((resolve) => {\n                setTimeout(async () => {\n                    await this.invoke(prompt, streamer);\n                    resolve();\n                }, 0);\n            });\n        }\n        this.isDoneReceiving = false;\n        this.inputs.push(...prompt);\n        if (!this.threadId) {\n            this.threadId = await this.threadIDPromise;\n        }\n        // this.inputs.push(...prompt);\n        const stream = true;\n        const tools = this.tools?.map(tool => ({\n            type: \"function\",\n            name: tool.name,\n            description: tool.description,\n            parameters: {\n                type: \"object\",\n                properties: Object.entries(tool.schema?.properties ?? {}).reduce((acc, [name, arg]) => {\n                    const property: Record<string, any> = {\n                        type: arg.argType,\n                        description: arg.description,\n                        default: arg.defaultValue,\n                    };\n                    if (arg.enumValues) {\n                        property.enum = arg.enumValues;\n                    }\n                    acc[name] = property;\n                    return acc;\n                }, {} as Record<string, any>),\n                required: Object.entries(tool.schema?.properties ?? {}).filter(([_, arg]) => arg.required).map(([name]) => name),\n            }\n        }));\n        const body = {\n                model: this.identifier,\n                conversation: this.threadId,\n                input: this.inputs.map(input => this.createInput(input)),\n                parallel_tool_calls: false,\n                stream,\n                tools: tools ?? [],\n        }\n        streamer.recieve(this, {\n            eventName: \"response.requested\",\n            data: {\n                typeName: \"response.requested\",\n                requested: body,\n                threadId: this.threadId,\n            },\n        });\n        try {\n            const response = await fetch(`https://api.openai.com/v1/responses`, {\n                method: \"POST\",\n                headers: {\n                    \"Authorization\": `Bearer ${this.apiKey}`,\n                    \"Content-Type\": \"application/json\",\n                },\n                body: JSON.stringify(body),\n            });\n            if (!response.ok) {\n                const error = await response.json() as any;\n                if (response.status === 401 && error.error.code === \"invalid_api_key\") {\n                    throw new OpenAIBadKeyError(\"bad API key\", response.status, error);\n                }\n                throw new OpenAIError(\"failed to invoke model\", response.status, error);\n            }\n            if (stream) {\n                const reader = await response.body?.getReader();\n                const decoder = new TextDecoder();\n                let buffer = \"\";\n\n                while (true) {\n                    const result = await reader?.read();\n                    if (!result) {\n                        break;\n                    }\n                    const { done, value } = result;\n                    if (done) {\n                        streamer.recieve(this, {\n                            eventName: \"overall.completed\",\n                            data: {\n                                typeName: \"overall.completed\",\n                            },\n                            threadId: this.threadId,\n                        });\n                        break;\n                    }\n                    \n                    buffer += decoder.decode(value, { stream: true });\n                    \n                    // Process complete messages (delimited by double newlines)\n                    let separatorIndex: number;\n                    while ((separatorIndex = buffer.indexOf(\"\\n\\n\")) !== -1) {\n                        const rawMessage = buffer.slice(0, separatorIndex);\n                        buffer = buffer.slice(separatorIndex + 2);\n                        \n                        if (!rawMessage.trim()) {\n                            continue;\n                        }\n                        \n                        // Raw data is a string in the format of `event: <event_name>\\ndata: <event_data>`\n                        const eventMatch = rawMessage.match(/^event: (.+)$/m);\n                        const dataMatch = rawMessage.match(/^data: (.+)$/m);\n                        \n                        if (eventMatch && dataMatch) {\n                            const eventName = eventMatch[1];\n                            const eventData = dataMatch[1];\n                            const data = JSON.parse(eventData) as any;\n                            const response = this.createResponse(eventName, data);\n                            streamer.recieve(this, response);\n                        }\n                    }\n                }\n               \n            } else {\n                const data = await response.json();\n                streamer.recieve(this, data as any);\n                streamer.recieve(this, {\n                    eventName: \"overall.completed\",\n                    data: {\n                        typeName: \"overall.completed\",\n                    },\n                    threadId: this.threadId,\n                });\n            }\n\n        }\n        finally {\n            this.isDoneReceiving = true;\n        }\n        \n    }\n\n    private createInputContent(content: InputContent) {\n        \n        if (content.typeName === \"image\") {\n            return {\n                type: \"input_image\",\n                image_url: content.image,\n            };\n        }\n        if (content.typeName === \"file\") {\n            // Handle file attachments with base64 content\n            if (content.fileData) {\n                return {\n                    type: \"input_file\",\n                    filename: content.fileData.name,\n                    file_data: `data:${content.fileData.mimeType || \"application/octet-stream\"};base64,${content.fileData.content}`,\n                };\n            }\n            // Fallback to URL-based file reference\n            return {\n                type: \"input_file\",\n                file_url: content.file,\n            };\n        }\n        return {\n            type: \"input_text\",\n            text: content.text,\n        };\n    }\n\n    private createInput(input: ModelContent | ToolCallResponse): ModelContent | ToolCallResponse {\n        if (\"role\" in input) {\n            const realInput = input as ModelContent;\n            // if content is not a string, content should be transformed to a chat GPT input\n            if (typeof realInput.content !== \"string\") {\n                if (isInputContentArray(realInput.content)) {\n                    const content = realInput.content.flatMap(c => this.createInputContent(c));\n                    return {role: realInput.role, content: content};\n                } else if (isInputContent(realInput.content)) {\n                    let content = this.createInputContent(realInput.content);\n                    if (Array.isArray(content)) {\n                        return { role: realInput.role, content: content };\n                    }\n                    return { role: realInput.role, content: [content] };\n                }\n            }\n            return { role: realInput.role, content: realInput.content };\n        }\n        return input as ToolCallResponse;\n    }\n\n    private createResponse(eventName: string, data: any): ModelResponse {\n        switch(eventName) {\n            case \"response.completed\":\n                const response = data.response.output.reduce((acc: ModelResponseData[], output: any) => {\n                    if (output.type === \"function_call\") {\n                        acc.push({\n                            typeName: \"tool_call\",\n                            toolCall: output,\n                        });\n                    }\n                    if (output.type === \"message\") {\n                        output.content.forEach((content: any) => {\n                            acc.push({\n                                typeName: \"output_text\",\n                                outputText: {\n                                    outputType: \"output_text\",\n                                    text: content.text,\n                                },\n                            });\n                        });\n                    }\n                    return acc;\n                }, []);\n                return {\n                    eventName: \"response.completed\",\n                    modelInstance: this,\n                    data: {\n                        typeName: \"response.completed\",\n                        ...response,\n                    },\n                    usage: data.response.usage,\n                };\n            case \"response.output_text.delta\":\n                return {\n                    eventName: \"response.output_text_delta\",\n                    modelInstance: this,\n                    data: {\n                        typeName: \"output_text_delta\",\n                        outputTextDelta: {\n                            outputType: \"output_text_delta\",\n                            delta: data.delta,\n                            sequenceNumber: data.sequence_number,\n                        },\n                    },\n                };\n            case \"response.content_part.done\":\n                return {\n                    eventName: \"response.content_part.done\",\n                    modelInstance: this,\n                    data: {\n                        typeName: \"output_text\",\n                        outputText: {\n                            outputType: \"output_text\",\n                            text: data.part.text,\n                        },\n                    },\n                };\n            case \"response.output_item.done\":\n                const output = data.item;\n                if (output.type === \"message\") {\n                    return {\n                        eventName: \"response.output_text.done\",\n                        modelInstance: this,\n                        data: {\n                            typeName: \"output_text.part.done\",\n                            outputText: {\n                                outputType: \"output_text\",\n                                text: output.content[0].text,\n                            }\n                        },\n                    };\n                }\n                return {\n                    eventName: \"response.completed\",\n                    modelInstance: this,\n                    data: {\n                        typeName: \"tool_call\",\n                        toolCall: {\n                            outputType: \"tool_call\",\n                            name: output.name,\n                            arguments: JSON.parse(output.arguments),\n                            callId: output.call_id,\n                        },\n                    },\n                };\n            default:\n                return data;\n        }\n    }\n}\n\nexport class OpenAIFactory implements IModelFactory {\n    constructor(\n        public readonly identifier: string,\n        public readonly apiKey: ISecret,\n    ){\n        this.create = this.create.bind(this);\n    }\n\n    public async create(props: IModelFactoryProps): Promise<IModel> {\n        return new OpenAI(\n            this.identifier,\n            await this.apiKey.resolveSecret(),\n            props.systemPrompt,\n            props.tools,\n        );\n    }\n}"]}

package/dist/src/models/types.d.ts

@@ -0,0 +1,101 @@
+import { ITool } from "../tools/tool";
+/**
+ * Represents a file attachment sent with a chat message
+ */
+export interface FileAttachment {
+    /** The file name */
+    readonly name: string;
+    /** The file path (optional, may not be relevant in all contexts) */
+    readonly path?: string;
+    /** Base64 encoded file content */
+    readonly content: string;
+    /** MIME type of the file */
+    readonly mimeType?: string;
+}
+export declare const isFileAttachment: (obj: any) => obj is FileAttachment;
+export declare const isFileAttachmentArray: (arr: any) => arr is FileAttachment[];
+export interface InputContent {
+    readonly typeName: "text" | "image" | "file";
+    readonly text?: string;
+    readonly image?: string;
+    readonly file?: string;
+    /** For file type, can include base64 content */
+    readonly fileData?: FileAttachment;
+}
+export declare const isInputContent: (content: any) => content is InputContent;
+export declare const isInputContentArray: (content: any) => content is InputContent[];
+export interface ModelContent {
+    readonly content: string | InputContent | InputContent[];
+    readonly role: "user" | "assistant" | "system";
+}
+/**
+ * @internal
+ */
+export interface GenericArguments {
+    [key: string]: any;
+}
+export interface ModelToolOutput {
+    readonly outputType: "tool_call";
+    readonly name: string;
+    readonly arguments: Record<string, unknown>;
+    readonly callId: string;
+}
+export interface ModelTextOutput {
+    readonly outputType: "output_text";
+    readonly text: string;
+}
+export interface InputTokensDetails {
+    readonly cachedTokens: number;
+}
+export interface OutputTokensDetails {
+    readonly reasoningTokens: number;
+}
+export interface ModelDeltaOutput {
+    readonly outputType: "output_text_delta";
+    readonly delta: string;
+    readonly sequenceNumber: number;
+}
+export interface Usage {
+    readonly inputTokens: number;
+    readonly inputTokensDetails: InputTokensDetails;
+    readonly outputTokens: number;
+    readonly outputTokensDetails: OutputTokensDetails;
+    readonly totalTokens: number;
+}
+export interface ModelResponseData {
+    readonly typeName: "response.requested" | "tool_call" | "output_text" | "output_text_delta" | "response.completed" | "output_text.part.done" | "overall.completed";
+    readonly toolCall?: ModelToolOutput;
+    readonly outputText?: ModelTextOutput;
+    readonly outputTextDelta?: ModelDeltaOutput;
+    readonly requested?: any;
+    readonly threadId?: string;
+}
+export interface ModelResponse {
+    readonly eventName: string;
+    readonly data: ModelResponseData[] | ModelResponseData;
+    readonly usage?: Usage;
+    readonly modelInstance?: IModel;
+    readonly threadId?: string;
+}
+export type ToolCallResponse = Record<string, unknown>;
+export interface IModelStreamer {
+    recieve(model: IModel, content: ModelResponse): Promise<void>;
+}
+export interface IModel {
+    readonly threadId?: string;
+    invoke(prompt: (ModelContent | ToolCallResponse)[], streamer: IModelStreamer): Promise<void>;
+}
+export interface IModelFactoryProps {
+    readonly systemPrompt: string;
+    readonly tools?: ITool[];
+}
+export interface IModelFactory {
+    create(props: IModelFactoryProps): Promise<IModel>;
+}
+export interface ModelResponseStreamValue {
+    readonly value: ModelResponse | undefined;
+    readonly done: boolean;
+}
+export interface IModelResponseStream {
+    next(): Promise<ModelResponseStreamValue>;
+}

package/dist/src/models/types.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInputContentArray = exports.isInputContent = exports.isFileAttachmentArray = exports.isFileAttachment = void 0;
+const isFileAttachment = (obj) => {
+    return typeof obj === "object"
+        && obj !== null
+        && typeof obj.name === "string"
+        && typeof obj.content === "string";
+};
+exports.isFileAttachment = isFileAttachment;
+const isFileAttachmentArray = (arr) => {
+    return Array.isArray(arr) && arr.every(exports.isFileAttachment);
+};
+exports.isFileAttachmentArray = isFileAttachmentArray;
+const isInputContent = (content) => {
+    return typeof (content) !== "string"
+        && !Array.isArray(content)
+        && content !== null
+        && typeof content === "object"
+        && "typeName" in content;
+};
+exports.isInputContent = isInputContent;
+const isInputContentArray = (content) => {
+    return Array.isArray(content) && content.every(exports.isInputContent);
+};
+exports.isInputContentArray = isInputContentArray;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/outcomes/CombinationOutcome.d.ts

@@ -0,0 +1,9 @@
+import { IOutcome } from "./IOutcomes";
+import { IModelResponseStream } from "../models/types";
+export declare class Outcomes implements IOutcome {
+    private outcomes;
+    constructor(outcomes: IOutcome[]);
+    static combine(...outcomes: IOutcome[]): Outcomes;
+    send(messageStream: IModelResponseStream): Promise<void>;
+    bindToRequest(request: any): Promise<void>;
+}

package/dist/src/outcomes/CombinationOutcome.js

@@ -0,0 +1,41 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Outcomes = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+class Outcomes {
+    constructor(outcomes) {
+        this.outcomes = outcomes;
+    }
+    static combine(...outcomes) {
+        return new Outcomes(outcomes);
+    }
+    async send(messageStream) {
+        let shouldContinue = true;
+        while (shouldContinue) {
+            const value = await messageStream.next();
+            if (value.done) {
+                shouldContinue = false;
+            }
+            const createNext = {
+                next: async () => {
+                    return value;
+                },
+            };
+            const allOutcomeResults = [];
+            for (const outcome of this.outcomes) {
+                const result = outcome.send(createNext);
+                allOutcomeResults.push(result);
+            }
+            await Promise.all(allOutcomeResults);
+        }
+        return Promise.resolve();
+    }
+    async bindToRequest(request) {
+        await Promise.all(this.outcomes.map(outcome => outcome.bindToRequest(request)));
+    }
+}
+exports.Outcomes = Outcomes;
+_a = JSII_RTTI_SYMBOL_1;
+Outcomes[_a] = { fqn: "@shuttl-io/core.Outcomes", version: "0.1.7-0" };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/outcomes/IOutcomes.d.ts

@@ -0,0 +1,9 @@
+import { IModelResponseStream } from "../models/types";
+export interface IOutcome {
+    send(messageStream: IModelResponseStream): Promise<void>;
+    bindToRequest(request: any): Promise<void>;
+}
+export declare class SlackOutcome implements IOutcome {
+    send(messageStream: IModelResponseStream): Promise<void>;
+    bindToRequest(request: any): Promise<void>;
+}

package/dist/src/outcomes/IOutcomes.js

@@ -0,0 +1,19 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackOutcome = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+class SlackOutcome {
+    send(messageStream) {
+        console.log("Sending message to Slack:", messageStream);
+        return Promise.resolve();
+    }
+    bindToRequest(request) {
+        console.log("Binding request to Slack:", request);
+        return Promise.resolve();
+    }
+}
+exports.SlackOutcome = SlackOutcome;
+_a = JSII_RTTI_SYMBOL_1;
+SlackOutcome[_a] = { fqn: "@shuttl-io/core.SlackOutcome", version: "0.1.7-0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSU91dGNvbWVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL291dGNvbWVzL0lPdXRjb21lcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQU9BLE1BQWEsWUFBWTtJQUNkLElBQUksQ0FBQyxhQUFtQztRQUMzQyxPQUFPLENBQUMsR0FBRyxDQUFDLDJCQUEyQixFQUFFLGFBQWEsQ0FBQyxDQUFDO1FBQ3hELE9BQU8sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzdCLENBQUM7SUFFTSxhQUFhLENBQUMsT0FBWTtRQUM3QixPQUFPLENBQUMsR0FBRyxDQUFDLDJCQUEyQixFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQ2xELE9BQU8sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzdCLENBQUM7O0FBVEwsb0NBVUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJTW9kZWxSZXNwb25zZVN0cmVhbSB9IGZyb20gXCIuLi9tb2RlbHMvdHlwZXNcIjtcblxuZXhwb3J0IGludGVyZmFjZSBJT3V0Y29tZSB7XG4gICBzZW5kKG1lc3NhZ2VTdHJlYW06IElNb2RlbFJlc3BvbnNlU3RyZWFtKSA6IFByb21pc2U8dm9pZD47XG4gICBiaW5kVG9SZXF1ZXN0KHJlcXVlc3Q6IGFueSkgOiBQcm9taXNlPHZvaWQ+O1xufVxuXG5leHBvcnQgY2xhc3MgU2xhY2tPdXRjb21lIGltcGxlbWVudHMgSU91dGNvbWUge1xuICAgIHB1YmxpYyBzZW5kKG1lc3NhZ2VTdHJlYW06IElNb2RlbFJlc3BvbnNlU3RyZWFtKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgICAgIGNvbnNvbGUubG9nKFwiU2VuZGluZyBtZXNzYWdlIHRvIFNsYWNrOlwiLCBtZXNzYWdlU3RyZWFtKTtcbiAgICAgICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZSgpO1xuICAgIH1cblxuICAgIHB1YmxpYyBiaW5kVG9SZXF1ZXN0KHJlcXVlc3Q6IGFueSk6IFByb21pc2U8dm9pZD4ge1xuICAgICAgICBjb25zb2xlLmxvZyhcIkJpbmRpbmcgcmVxdWVzdCB0byBTbGFjazpcIiwgcmVxdWVzdCk7XG4gICAgICAgIHJldHVybiBQcm9taXNlLnJlc29sdmUoKTtcbiAgICB9XG59Il19

package/dist/src/outcomes/StreamingOutcome.d.ts

@@ -0,0 +1,6 @@
+import { IOutcome } from "./IOutcomes";
+import { IModelResponseStream } from "../models/types";
+export declare class StreamingOutcome implements IOutcome {
+    send(messageStream: IModelResponseStream): Promise<void>;
+    bindToRequest(request: any): Promise<void>;
+}