@shuttl-io/core 0.2.0

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export * from "./http";

package/dist/server/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VydmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx5Q0FBdUIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9odHRwXCI7XG5cblxuXG5cblxuXG5cblxuXG5cblxuXG5cbiJdfQ==

package/dist/src/Server.d.ts

@@ -0,0 +1,5 @@
+export interface IServer {
+    accept(app: unknown): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/src/Server.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2VydmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL1NlcnZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiXG5leHBvcnQgaW50ZXJmYWNlIElTZXJ2ZXIge1xuICAgIGFjY2VwdChhcHA6IHVua25vd24pOiB2b2lkO1xuICAgIHN0YXJ0KCk6IFByb21pc2U8dm9pZD47XG4gICAgc3RvcCgpOiBQcm9taXNlPHZvaWQ+O1xufVxuXG4iXX0=

package/dist/src/Triggers.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVHJpZ2dlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvVHJpZ2dlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIiJdfQ==

package/dist/src/agent.d.ts

@@ -0,0 +1,49 @@
+import { IModelFactory, ModelContent, ModelResponse, ToolCallResponse, FileAttachment } from "./models/types";
+import { Toolkit } from "./tools/toolkit";
+import { ITrigger } from "./trigger/ITrigger";
+import { IOutcome } from "./outcomes/IOutcomes";
+import { IModelStreamer } from "./models/types";
+import { IModel } from "./models/types";
+import { ITool } from "./tools/tool";
+export interface AgentProps {
+    readonly name: string;
+    readonly toolkits: Toolkit[];
+    readonly systemPrompt: string;
+    readonly model: IModelFactory;
+    readonly triggers?: ITrigger[];
+    readonly outcomes?: IOutcome[];
+    readonly tools?: ITool[];
+}
+export interface IAgentStreamerWriter {
+    write(value: string): void;
+    writeObject?(value: any): void;
+}
+export declare class AgentStreamer implements IModelStreamer {
+    private readonly agent;
+    private readonly controlID;
+    private resultPromise;
+    private jobs;
+    private calls;
+    private readonly writer;
+    constructor(agent: Agent, controlID: string, writer?: IAgentStreamerWriter);
+    private write;
+    recieve(model: IModel, content: ModelResponse): Promise<void>;
+    private invokeWithExpenantialBackoff;
+    private processData;
+}
+export declare class Agent {
+    readonly name: string;
+    readonly toolkits: Toolkit[];
+    readonly tools: ITool[];
+    readonly systemPrompt: string;
+    readonly model: IModelFactory;
+    readonly triggers: ITrigger[];
+    readonly outcomes: IOutcome[];
+    private modelInstances;
+    private readonly toolRecords;
+    constructor(props: AgentProps);
+    invoke(prompt: string | (ModelContent | ToolCallResponse)[], threadId?: string, streamer?: IModelStreamer, attachments?: FileAttachment[]): Promise<IModel>;
+    getTool(name: string): ITool;
+    getToolCallResult(callID: string, result: unknown): Record<string, unknown>;
+    respondWithToolCall(modelInstance: IModel, callID: string, result: unknown, streamer: IModelStreamer): Promise<void>;
+}

package/dist/src/agent.js

@@ -0,0 +1,251 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = exports.AgentStreamer = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const process_1 = require("process");
+const ApiTrigger_1 = require("./trigger/ApiTrigger");
+const StreamingOutcome_1 = require("./outcomes/StreamingOutcome");
+class AgentStreamer {
+    constructor(agent, controlID, writer) {
+        this.agent = agent;
+        this.controlID = controlID;
+        this.resultPromise = [];
+        this.jobs = 0;
+        this.calls = {};
+        if (writer) {
+            this.writer = writer;
+        }
+        else {
+            this.writer = process_1.stdout;
+        }
+    }
+    write(type, data, success) {
+        let body = {
+            result: data,
+        };
+        if (!success) {
+            body = {
+                errorObj: {
+                    code: "ERROR",
+                    message: "An error occurred",
+                },
+            };
+        }
+        if (this.writer.writeObject) {
+            this.writer.writeObject({
+                id: this.controlID,
+                type: type,
+                success,
+                ...body,
+            });
+        }
+        else {
+            const json = JSON.stringify({
+                id: this.controlID,
+                type: type,
+                success,
+                ...body,
+            });
+            this.writer.write(json + "\n");
+        }
+    }
+    async recieve(model, content) {
+        this.jobs++;
+        try {
+            if (content.data === undefined) {
+                return;
+            }
+            if (content.eventName === "response.completed") {
+                this.jobs--;
+                setImmediate(async () => {
+                    if (this.resultPromise.length > 0) {
+                        const results = await Promise.all(this.resultPromise);
+                        const toolCalls = results.map(result => this.agent.getToolCallResult(result.callId, result.result));
+                        this.write("tool_calls_completed", toolCalls, true);
+                        this.resultPromise = [];
+                        this.calls = {};
+                        await this.invokeWithExpenantialBackoff(model, toolCalls, this, 0);
+                    }
+                });
+            }
+            if (Array.isArray(content.data)) {
+                for (const data of content.data) {
+                    this.processData(data);
+                }
+            }
+            else {
+                this.processData(content.data);
+            }
+        }
+        finally {
+            this.jobs--;
+        }
+    }
+    invokeWithExpenantialBackoff(model, toolCalls, streamer, attempts = 0) {
+        return new Promise((resolve, reject) => {
+            setTimeout(async () => {
+                try {
+                    await model.invoke(toolCalls, streamer);
+                    resolve();
+                }
+                catch (e) {
+                    if (e.isRetryable === true && attempts < 3) {
+                        await this.invokeWithExpenantialBackoff(model, toolCalls, streamer, attempts + 1);
+                        resolve();
+                    }
+                    reject(e);
+                }
+            }, 500 * Math.pow(2, attempts));
+        });
+    }
+    processData(data) {
+        switch (data.typeName) {
+            case "tool_call":
+                this.write("tool_call", data, true);
+                if (data.toolCall) {
+                    const tool = this.agent.getTool(data.toolCall.name);
+                    const toolCallExecutor = async () => {
+                        const result = await tool.execute(data.toolCall.arguments);
+                        return {
+                            callId: data.toolCall.callId,
+                            result: result,
+                        };
+                    };
+                    this.resultPromise.push(toolCallExecutor());
+                    this.calls[data.toolCall.callId] = toolCallExecutor();
+                }
+                break;
+            case "output_text": {
+                this.write("output_text", data, true);
+                break;
+            }
+            case "output_text.part.done": {
+                this.write("output_text.part.done", data, true);
+                break;
+            }
+            case "output_text_delta": {
+                this.write("output_text_delta", data, true);
+                break;
+            }
+            case "response.requested": {
+                this.write("response.requested", data, true);
+                break;
+            }
+            case "overall.completed": {
+                this.write("overall.completed", {
+                    ...data,
+                    controlID: this.controlID,
+                }, true);
+                break;
+            }
+            case "response.completed": {
+                this.write("response.completed", data, true);
+                break;
+            }
+        }
+    }
+}
+exports.AgentStreamer = AgentStreamer;
+_a = JSII_RTTI_SYMBOL_1;
+AgentStreamer[_a] = { fqn: "@shuttl-io/core.AgentStreamer", version: "0.1.7-0" };
+class Agent {
+    constructor(props) {
+        this.modelInstances = {};
+        this.toolRecords = {};
+        this.name = props.name;
+        this.toolkits = props.toolkits;
+        this.systemPrompt = props.systemPrompt;
+        this.model = props.model;
+        this.triggers = props.triggers || [new ApiTrigger_1.ApiTrigger()];
+        this.outcomes = props.outcomes || [new StreamingOutcome_1.StreamingOutcome()];
+        this.tools = props.tools || [];
+        this.tools = this.tools.concat(this.toolkits.flatMap(toolkit => toolkit.tools));
+        this.tools.forEach(tool => {
+            this.toolRecords[tool.name] = tool;
+        });
+    }
+    async invoke(prompt, threadId, streamer, attachments) {
+        if (!streamer) {
+            streamer = new AgentStreamer(this, "NOTSET");
+        }
+        // Build separate input items for text and file attachments
+        const buildInputs = (textPrompt) => {
+            const inputs = [];
+            // Add the text message as a separate input
+            if (textPrompt) {
+                inputs.push({
+                    role: "user",
+                    content: textPrompt,
+                });
+            }
+            // Add each file attachment as a separate input
+            if (attachments && attachments.length > 0) {
+                for (const attachment of attachments) {
+                    const fileContent = {
+                        typeName: "file",
+                        file: attachment.name,
+                        fileData: attachment,
+                    };
+                    inputs.push({
+                        role: "user",
+                        content: fileContent,
+                    });
+                }
+            }
+            return inputs;
+        };
+        if (!threadId) {
+            const model = await this.model.create({
+                systemPrompt: this.systemPrompt,
+                tools: this.tools,
+            });
+            if (typeof prompt === "string") {
+                const inputs = buildInputs(prompt);
+                await model.invoke(inputs, streamer);
+            }
+            else {
+                await model.invoke(prompt, streamer);
+            }
+            // We have to wait for the first invoke bc that is where the threadId is set
+            this.modelInstances[model.threadId] = model;
+            return model;
+        }
+        else {
+            if (!this.modelInstances[threadId]) {
+                throw new Error(`Model instance with threadId ${threadId} not found`);
+            }
+            const model = this.modelInstances[threadId];
+            if (typeof prompt === "string") {
+                const inputs = buildInputs(prompt);
+                await model.invoke(inputs, streamer);
+            }
+            else {
+                await model.invoke(prompt, streamer);
+            }
+            return model;
+        }
+    }
+    getTool(name) {
+        const tool = this.toolRecords[name];
+        if (!tool) {
+            throw new Error(`Tool ${name} not found`);
+        }
+        return tool;
+    }
+    getToolCallResult(callID, result) {
+        const toolResult = JSON.stringify(result);
+        return {
+            output: toolResult,
+            type: "function_call_output",
+            call_id: callID,
+        };
+    }
+    async respondWithToolCall(modelInstance, callID, result, streamer) {
+        await modelInstance.invoke([this.getToolCallResult(callID, result)], streamer);
+    }
+}
+exports.Agent = Agent;
+_b = JSII_RTTI_SYMBOL_1;
+Agent[_b] = { fqn: "@shuttl-io/core.Agent", version: "0.1.7-0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agent.js","sourceRoot":"","sources":["../../src/agent.ts"],"names":[],"mappings":";;;;;AAOA,qCAAiC;AACjC,qDAAkD;AAClD,kEAA+D;AAiB/D,MAAa,aAAa;IAMtB,YACqB,KAAY,EACZ,SAAiB,EAClC,MAA6B;QAFZ,UAAK,GAAL,KAAK,CAAO;QACZ,cAAS,GAAT,SAAS,CAAQ;QAP9B,kBAAa,GAAmD,EAAE,CAAC;QACnE,SAAI,GAAW,CAAC,CAAC;QACjB,UAAK,GAAiE,EAAE,CAAC;QAQ7E,IAAI,MAAM,EAAE,CAAC;YACT,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACzB,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,MAAM,GAAG,gBAAM,CAAC;QACzB,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,IAAY,EAAE,IAAS,EAAE,OAAgB;QACnD,IAAI,IAAI,GAAO;YACX,MAAM,EAAE,IAAI;SACf,CAAA;QACD,IAAI,CAAC,OAAO,EAAE,CAAC;YACX,IAAI,GAAG;gBACH,QAAQ,EAAE;oBACN,IAAI,EAAE,OAAO;oBACb,OAAO,EAAE,mBAAmB;iBAC/B;aACJ,CAAC;QACN,CAAC;QACD,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC;gBACpB,EAAE,EAAE,IAAI,CAAC,SAAS;gBAClB,IAAI,EAAE,IAAI;gBACV,OAAO;gBACP,GAAG,IAAI;aACV,CAAC,CAAC;QACP,CAAC;aAAM,CAAC;YACJ,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC;gBACxB,EAAE,EAAE,IAAI,CAAC,SAAS;gBAClB,IAAI,EAAE,IAAI;gBACV,OAAO;gBACP,GAAG,IAAI;aACV,CAAC,CAAC;YACH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,CAAC;QACnC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,KAAa,EAAE,OAAsB;QACtD,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC;YACD,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC7B,OAAO;YACX,CAAC;YACD,IAAI,OAAO,CAAC,SAAS,KAAK,oBAAoB,EAAE,CAAC;gBAC7C,IAAI,CAAC,IAAI,EAAE,CAAC;gBACZ,YAAY,CAAC,KAAK,IAAI,EAAE;oBACpB,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;wBAChC,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;wBACtD,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;wBACpG,IAAI,CAAC,KAAK,CAAC,sBAAsB,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;wBACpD,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;wBACxB,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;wBAChB,MAAM,IAAI,CAAC,4BAA4B,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;oBACvE,CAAC;gBACL,CAAC,CAAC,CAAC;YACP,CAAC;YAED,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC9B,KAAK,MAAM,IAAI,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;oBAC9B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;gBAC3B,CAAC;YACL,CAAC;iBAAM,CAAC;gBACJ,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACnC,CAAC;QAEL,CAAC;gBACO,CAAC;YACL,IAAI,CAAC,IAAI,EAAE,CAAC;QAChB,CAAC;IACL,CAAC;IAEO,4BAA4B,CAAC,KAAa,EAAE,SAA8C,EAAE,QAAwB,EAAE,WAAmB,CAAC;QAC9I,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACnC,UAAU,CAAC,KAAK,IAAI,EAAE;gBAClB,IAAI,CAAC;oBACD,MAAM,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;oBACxC,OAAO,EAAE,CAAC;gBACd,CAAC;gBAAC,OAAO,CAAM,EAAE,CAAC;oBACd,IAAI,CAAC,CAAC,WAAW,KAAK,IAAI,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;wBACzC,MAAM,IAAI,CAAC,4BAA4B,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC;wBAClF,OAAO,EAAE,CAAC;oBACd,CAAC;oBACD,MAAM,CAAC,CAAC,CAAC,CAAC;gBACd,CAAC;YACL,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,WAAW,CAAC,IAAuB;QACnC,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;YACpB,KAAK,WAAW;gBACZ,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBACpC,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAChB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;oBACpD,MAAM,gBAAgB,GAAG,KAAK,IAAI,EAAE;wBAChC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAS,CAAC,SAAS,CAAC,CAAC;wBAC5D,OAAO;4BACH,MAAM,EAAE,IAAI,CAAC,QAAS,CAAC,MAAM;4BAC7B,MAAM,EAAE,MAAM;yBACjB,CAAC;oBACN,CAAC,CAAA;oBACD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC;oBAC5C,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAS,CAAC,MAAM,CAAC,GAAG,gBAAgB,EAAE,CAAC;gBAC3D,CAAC;gBACD,MAAM;YACV,KAAK,aAAa,CAAC,CAAC,CAAC;gBACjB,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBACtC,MAAM;YACV,CAAC;YACD,KAAK,uBAAuB,CAAC,CAAC,CAAC;gBAC3B,IAAI,CAAC,KAAK,CAAC,uBAAuB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBAChD,MAAM;YACV,CAAC;YACD,KAAK,mBAAmB,CAAC,CAAC,CAAC;gBACvB,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBAC5C,MAAM;YACV,CAAC;YACD,KAAK,oBAAoB,CAAC,CAAC,CAAC;gBACxB,IAAI,CAAC,KAAK,CAAC,oBAAoB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBAC7C,MAAM;YACV,CAAC;YACD,KAAK,mBAAmB,CAAC,CAAC,CAAC;gBACvB,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE;oBAC5B,GAAG,IAAI;oBACP,SAAS,EAAE,IAAI,CAAC,SAAS;iBAC5B,EAAE,IAAI,CAAC,CAAC;gBACT,MAAM;YACV,CAAC;YACD,KAAK,oBAAoB,CAAC,CAAC,CAAC;gBACxB,IAAI,CAAC,KAAK,CAAC,oBAAoB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBAC7C,MAAM;YACV,CAAC;QACL,CAAC;IACL,CAAC;;AAhJT,sCAiJK;;;AAEL,MAAa,KAAK;IAWd,YAAmB,KAAiB;QAH5B,mBAAc,GAA2B,EAAE,CAAC;QACnC,gBAAW,GAA0B,EAAE,CAAC;QAGrD,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QAC/B,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;QACvC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,CAAC,IAAI,uBAAU,EAAE,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,IAAI,CAAC,IAAI,mCAAgB,EAAE,CAAC,CAAC;QAC3D,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC;QAC/B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAChD,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,CAC3B,CAAC,CAAC;QACH,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACtB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QACvC,CAAC,CAAC,CAAC;IACP,CAAC;IAEM,KAAK,CAAC,MAAM,CACf,MAAoD,EACpD,QAAiB,EACjB,QAAyB,EACzB,WAA8B;QAE9B,IAAI,CAAC,QAAQ,EAAE,CAAC;YACZ,QAAQ,GAAG,IAAI,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACjD,CAAC;QAED,2DAA2D;QAC3D,MAAM,WAAW,GAAG,CAAC,UAAkB,EAAkB,EAAE;YACvD,MAAM,MAAM,GAAmB,EAAE,CAAC;YAElC,2CAA2C;YAC3C,IAAI,UAAU,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC;oBACR,IAAI,EAAE,MAAM;oBACZ,OAAO,EAAE,UAAU;iBACtB,CAAC,CAAC;YACP,CAAC;YAED,+CAA+C;YAC/C,IAAI,WAAW,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACxC,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;oBACnC,MAAM,WAAW,GAAiB;wBAC9B,QAAQ,EAAE,MAAM;wBAChB,IAAI,EAAE,UAAU,CAAC,IAAI;wBACrB,QAAQ,EAAE,UAAU;qBACvB,CAAC;oBACF,MAAM,CAAC,IAAI,CAAC;wBACR,IAAI,EAAE,MAAM;wBACZ,OAAO,EAAE,WAAW;qBACvB,CAAC,CAAC;gBACP,CAAC;YACL,CAAC;YAED,OAAO,MAAM,CAAC;QAClB,CAAC,CAAC;QAEF,IAAI,CAAC,QAAQ,EAAE,CAAC;YACZ,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;gBAClC,YAAY,EAAE,IAAI,CAAC,YAAY;gBAC/B,KAAK,EAAE,IAAI,CAAC,KAAK;aACpB,CAAC,CAAC;YAEH,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;gBAC7B,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;gBACnC,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACzC,CAAC;iBAAM,CAAC;gBACJ,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACzC,CAAC;YAED,4EAA4E;YAC5E,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,QAAS,CAAC,GAAG,KAAK,CAAC;YAC7C,OAAO,KAAK,CAAC;QACjB,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACjC,MAAM,IAAI,KAAK,CAAC,gCAAgC,QAAQ,YAAY,CAAC,CAAC;YAC1E,CAAC;YACD,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;YAC5C,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;gBAC7B,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;gBACnC,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACzC,CAAC;iBAAM,CAAC;gBACJ,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACzC,CAAC;YACD,OAAO,KAAK,CAAC;QACjB,CAAC;IACL,CAAC;IAEM,OAAO,CAAC,IAAY;QACvB,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,IAAI,EAAE,CAAC;YACR,MAAM,IAAI,KAAK,CAAC,QAAQ,IAAI,YAAY,CAAC,CAAC;QAC9C,CAAC;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEO,iBAAiB,CACrB,MAAc,EACd,MAAe;QAEf,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAC1C,OAAO;YACH,MAAM,EAAE,UAAU;YAClB,IAAI,EAAE,sBAAsB;YAC5B,OAAO,EAAE,MAAM;SAClB,CAAC;IACN,CAAC;IAEM,KAAK,CAAC,mBAAmB,CAC5B,aAAqB,EACrB,MAAc,EACd,MAAe,EACf,QAAwB;QACxB,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;IACnF,CAAC;;AA5HL,sBA6HC","sourcesContent":["import { IModelFactory, ModelContent, ModelResponse, ToolCallResponse, FileAttachment, InputContent } from \"./models/types\";\nimport { Toolkit } from \"./tools/toolkit\";\nimport { ITrigger } from \"./trigger/ITrigger\";\nimport { IOutcome } from \"./outcomes/IOutcomes\";\nimport { IModelStreamer, ModelResponseData } from \"./models/types\";\nimport { IModel } from \"./models/types\";\nimport { ITool } from \"./tools/tool\";\nimport { stdout } from \"process\";\nimport { ApiTrigger } from \"./trigger/ApiTrigger\";\nimport { StreamingOutcome } from \"./outcomes/StreamingOutcome\";\n\nexport interface AgentProps {\n    readonly name: string;\n    readonly toolkits: Toolkit[];\n    readonly systemPrompt: string;\n    readonly model: IModelFactory;\n    readonly triggers?: ITrigger[];\n    readonly outcomes?: IOutcome[];\n    readonly tools?: ITool[];\n}\n\nexport interface IAgentStreamerWriter {\n    write(value: string): void;\n    writeObject?(value: any): void;\n}\n\nexport class AgentStreamer implements IModelStreamer {\n    private resultPromise: Promise<{ callId: string, result: unknown }>[] = [];\n    private jobs: number = 0;\n    private calls: Record<string, Promise<{ callId: string, result: unknown }>> = {};\n    private readonly writer: IAgentStreamerWriter\n\n    public constructor(\n        private readonly agent: Agent,\n        private readonly controlID: string,\n        writer?: IAgentStreamerWriter\n    ) {\n        if (writer) {\n            this.writer = writer;\n        } else {\n            this.writer = stdout;\n        }\n    }\n\n    private write(type: string, data: any, success: boolean): void {\n        let body:any = {\n            result: data,\n        }\n        if (!success) {\n            body = {\n                errorObj: {\n                    code: \"ERROR\",\n                    message: \"An error occurred\",\n                },\n            };\n        }\n        if (this.writer.writeObject) {\n            this.writer.writeObject({\n                id: this.controlID,\n                type: type,\n                success,\n                ...body,\n            });\n        } else {\n            const json = JSON.stringify({\n                id: this.controlID,\n                type: type,\n                success,\n                ...body,\n            });\n            this.writer.write(json + \"\\n\");\n        }\n    }\n\n    public async recieve(model: IModel, content: ModelResponse): Promise<void> {\n        this.jobs++;\n        try {\n            if (content.data === undefined) {\n                return;\n            }\n            if (content.eventName === \"response.completed\") {\n                this.jobs--;\n                setImmediate(async () => {\n                    if (this.resultPromise.length > 0) {\n                        const results = await Promise.all(this.resultPromise);\n                        const toolCalls = results.map(result => this.agent.getToolCallResult(result.callId, result.result));\n                        this.write(\"tool_calls_completed\", toolCalls, true);\n                        this.resultPromise = [];\n                        this.calls = {};\n                        await this.invokeWithExpenantialBackoff(model, toolCalls, this, 0);\n                    }\n                });\n            }\n\n            if (Array.isArray(content.data)) {\n                for (const data of content.data) {\n                    this.processData(data);\n                }\n            } else {\n                this.processData(content.data);\n            }\n\n        }\n        finally {\n            this.jobs--;\n        }\n    }\n\n    private invokeWithExpenantialBackoff(model: IModel, toolCalls: (ModelContent | ToolCallResponse)[], streamer: IModelStreamer, attempts: number = 0): Promise<void> {\n        return new Promise((resolve, reject) => {\n            setTimeout(async () => {\n                try {\n                    await model.invoke(toolCalls, streamer);\n                    resolve();\n                } catch (e: any) {\n                    if (e.isRetryable === true && attempts < 3) {\n                        await this.invokeWithExpenantialBackoff(model, toolCalls, streamer, attempts + 1);\n                        resolve();\n                    }\n                    reject(e);\n                }\n            }, 500 * Math.pow(2, attempts));\n        });\n    }\n\n    private processData(data: ModelResponseData): void {\n            switch (data.typeName) {\n                case \"tool_call\":\n                    this.write(\"tool_call\", data, true);\n                    if (data.toolCall) {\n                        const tool = this.agent.getTool(data.toolCall.name);\n                        const toolCallExecutor = async () => {\n                            const result = await tool.execute(data.toolCall!.arguments);\n                            return {\n                                callId: data.toolCall!.callId,\n                                result: result,\n                            };\n                        }\n                        this.resultPromise.push(toolCallExecutor());\n                        this.calls[data.toolCall!.callId] = toolCallExecutor();\n                    }\n                    break;\n                case \"output_text\": {\n                    this.write(\"output_text\", data, true);\n                    break;\n                }\n                case \"output_text.part.done\": {\n                    this.write(\"output_text.part.done\", data, true);\n                    break;\n                }\n                case \"output_text_delta\": {\n                    this.write(\"output_text_delta\", data, true);\n                    break;\n                }\n                case \"response.requested\": {\n                    this.write(\"response.requested\", data, true);\n                    break;\n                }\n                case \"overall.completed\": {\n                    this.write(\"overall.completed\", {\n                        ...data,\n                        controlID: this.controlID,\n                    }, true);\n                    break;\n                }\n                case \"response.completed\": {\n                    this.write(\"response.completed\", data, true);\n                    break;\n                }\n            }\n        }\n    }\n\nexport class Agent {\n    public readonly name: string;\n    public readonly toolkits: Toolkit[];\n    public readonly tools: ITool[];\n    public readonly systemPrompt: string;\n    public readonly model: IModelFactory;\n    public readonly triggers: ITrigger[];\n    public readonly outcomes: IOutcome[];\n    private modelInstances: Record<string, IModel> = {};\n    private readonly toolRecords: Record<string, ITool> = {};\n\n    public constructor(props: AgentProps) {\n        this.name = props.name;\n        this.toolkits = props.toolkits;\n        this.systemPrompt = props.systemPrompt;\n        this.model = props.model;\n        this.triggers = props.triggers || [new ApiTrigger()];\n        this.outcomes = props.outcomes || [new StreamingOutcome()];\n        this.tools = props.tools || [];\n        this.tools = this.tools.concat(this.toolkits.flatMap(\n            toolkit => toolkit.tools\n        ));\n        this.tools.forEach(tool => {\n            this.toolRecords[tool.name] = tool;\n        });\n    }\n\n    public async invoke(\n        prompt: string | (ModelContent | ToolCallResponse)[], \n        threadId?: string, \n        streamer?: IModelStreamer,\n        attachments?: FileAttachment[]\n    ): Promise<IModel> {\n        if (!streamer) {\n            streamer = new AgentStreamer(this, \"NOTSET\");\n        }\n\n        // Build separate input items for text and file attachments\n        const buildInputs = (textPrompt: string): ModelContent[] => {\n            const inputs: ModelContent[] = [];\n            \n            // Add the text message as a separate input\n            if (textPrompt) {\n                inputs.push({\n                    role: \"user\",\n                    content: textPrompt,\n                });\n            }\n            \n            // Add each file attachment as a separate input\n            if (attachments && attachments.length > 0) {\n                for (const attachment of attachments) {\n                    const fileContent: InputContent = {\n                        typeName: \"file\",\n                        file: attachment.name,\n                        fileData: attachment,\n                    };\n                    inputs.push({\n                        role: \"user\",\n                        content: fileContent,\n                    });\n                }\n            }\n            \n            return inputs;\n        };\n\n        if (!threadId) {\n            const model = await this.model.create({ \n                systemPrompt: this.systemPrompt,\n                tools: this.tools,\n            });\n            \n            if (typeof prompt === \"string\") {\n                const inputs = buildInputs(prompt);\n                await model.invoke(inputs, streamer);\n            } else {\n                await model.invoke(prompt, streamer);\n            }\n            \n            // We have to wait for the first invoke bc that is where the threadId is set\n            this.modelInstances[model.threadId!] = model;\n            return model;\n        } else {\n            if (!this.modelInstances[threadId]) {\n                throw new Error(`Model instance with threadId ${threadId} not found`);\n            }\n            const model = this.modelInstances[threadId];\n            if (typeof prompt === \"string\") {\n                const inputs = buildInputs(prompt);\n                await model.invoke(inputs, streamer);\n            } else {\n                await model.invoke(prompt, streamer);\n            }\n            return model;\n        }\n    }\n\n    public getTool(name: string): ITool {\n        const tool = this.toolRecords[name];\n        if (!tool) {\n            throw new Error(`Tool ${name} not found`);\n        }\n        return tool;\n    }\n\n    public  getToolCallResult(\n        callID: string, \n        result: unknown,\n    ): Record<string, unknown>  {\n        const toolResult = JSON.stringify(result);\n        return {\n            output: toolResult,\n            type: \"function_call_output\",\n            call_id: callID,\n        };\n    }\n\n    public async respondWithToolCall(\n        modelInstance: IModel, \n        callID: string, \n        result: unknown,\n        streamer: IModelStreamer): Promise<void> {\n        await modelInstance.invoke([this.getToolCallResult(callID, result)], streamer);\n    }\n}"]}

package/dist/src/app.d.ts

@@ -0,0 +1,17 @@
+import { Agent } from "./agent";
+import { Toolkit } from "./tools/toolkit";
+import { IServer } from "./Server";
+export declare class App {
+    readonly name: string;
+    readonly agents: Agent[];
+    /**
+     * @jsii ignore
+     */
+    readonly toolkits: Set<Toolkit>;
+    readonly server: IServer;
+    constructor(name: string, server: IServer);
+    addAgent(agent: Agent): void;
+    addToolkit(toolkit: Toolkit): void;
+    serve(): void;
+    private monkeyPatchConsoleLog;
+}

package/dist/src/app.js

@@ -0,0 +1,46 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const process_1 = require("process");
+class App {
+    constructor(name, server) {
+        this.name = name;
+        this.server = server;
+        this.agents = [];
+        this.toolkits = new Set();
+        this.server.accept(this);
+    }
+    addAgent(agent) {
+        this.agents.push(agent);
+        agent.toolkits.forEach(toolkit => {
+            this.toolkits.add(toolkit);
+        });
+    }
+    addToolkit(toolkit) {
+        this.toolkits.add(toolkit);
+    }
+    serve() {
+        let originalConsoleLog;
+        if (process.env._SHUTTL_CONTROL === "true") {
+            originalConsoleLog = console.log.bind(console);
+            this.monkeyPatchConsoleLog();
+            this.server.start();
+            console.log = originalConsoleLog;
+        }
+        else {
+            this.server.start();
+        }
+    }
+    //Monkey patch console.log to log to stderr
+    monkeyPatchConsoleLog() {
+        console.log = (...args) => {
+            process_1.stderr.write(args.join(" ") + "\n");
+        };
+    }
+}
+exports.App = App;
+_a = JSII_RTTI_SYMBOL_1;
+App[_a] = { fqn: "@shuttl-io/core.App", version: "0.1.7-0" };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./agent";
+export * from "./model";
+export * from "./secrets";
+export * from "./models/types";
+export * from "./tools/toolkit";
+export * from "./tools/tool";
+export * from "./Server";
+export * from "./app";
+export * from "./server";
+export * from "./trigger";
+export * from "./outcomes";
+export * from "./models/types";

package/dist/src/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./agent"), exports);
+__exportStar(require("./model"), exports);
+__exportStar(require("./secrets"), exports);
+__exportStar(require("./models/types"), exports);
+__exportStar(require("./tools/toolkit"), exports);
+__exportStar(require("./tools/tool"), exports);
+__exportStar(require("./Server"), exports);
+__exportStar(require("./app"), exports);
+__exportStar(require("./server"), exports);
+__exportStar(require("./trigger"), exports);
+__exportStar(require("./outcomes"), exports);
+__exportStar(require("./models/types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBDQUF3QjtBQUN4QiwwQ0FBd0I7QUFDeEIsNENBQTBCO0FBQzFCLGlEQUErQjtBQUMvQixrREFBZ0M7QUFDaEMsK0NBQTZCO0FBQzdCLDJDQUF5QjtBQUN6Qix3Q0FBc0I7QUFDdEIsMkNBQXlCO0FBQ3pCLDRDQUEwQjtBQUMxQiw2Q0FBMkI7QUFDM0IsaURBQStCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYWdlbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL21vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZWNyZXRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tb2RlbHMvdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Rvb2xzL3Rvb2xraXRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3Rvb2xzL3Rvb2xcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1NlcnZlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vYXBwXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZXJ2ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RyaWdnZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL291dGNvbWVzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9tb2RlbHMvdHlwZXNcIjsiXX0=

package/dist/src/model.d.ts

@@ -0,0 +1,6 @@
+import { ISecret } from "./secrets";
+import type { IModelFactory } from "./models/types";
+export declare class Model {
+    protected constructor();
+    static openAI(identifier: string, apiKey: ISecret): IModelFactory;
+}

package/dist/src/model.js

@@ -0,0 +1,16 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const openAi_1 = require("./models/openAi");
+class Model {
+    constructor() { }
+    static openAI(identifier, apiKey) {
+        return new openAi_1.OpenAIFactory(identifier, apiKey);
+    }
+}
+exports.Model = Model;
+_a = JSII_RTTI_SYMBOL_1;
+Model[_a] = { fqn: "@shuttl-io/core.Model", version: "0.1.7-0" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFDQSw0Q0FBaUQ7QUFHakQsTUFBYSxLQUFLO0lBQ2QsZ0JBQXdCLENBQUM7SUFFbEIsTUFBTSxDQUFDLE1BQU0sQ0FBQyxVQUFrQixFQUFFLE1BQWU7UUFDcEQsT0FBTyxJQUFJLHNCQUFhLENBQUMsVUFBVSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ2pELENBQUM7O0FBTEwsc0JBTUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJU2VjcmV0IH0gZnJvbSBcIi4vc2VjcmV0c1wiO1xuaW1wb3J0IHsgIE9wZW5BSUZhY3RvcnkgfSBmcm9tIFwiLi9tb2RlbHMvb3BlbkFpXCI7XG5pbXBvcnQgdHlwZSB7IElNb2RlbEZhY3RvcnkgfSBmcm9tIFwiLi9tb2RlbHMvdHlwZXNcIjtcblxuZXhwb3J0IGNsYXNzIE1vZGVsIHtcbiAgICBwcm90ZWN0ZWQgY29uc3RydWN0b3IoKXt9XG5cbiAgICBwdWJsaWMgc3RhdGljIG9wZW5BSShpZGVudGlmaWVyOiBzdHJpbmcsIGFwaUtleTogSVNlY3JldCk6IElNb2RlbEZhY3Rvcnkge1xuICAgICAgICByZXR1cm4gbmV3IE9wZW5BSUZhY3RvcnkoaWRlbnRpZmllciwgYXBpS2V5KTtcbiAgICB9XG59Il19

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

@@ -0,0 +1,38 @@
+import { ISecret } from "../secrets";
+import { IModel, IModelFactory, IModelFactoryProps, ModelContent, IModelStreamer } from "./types";
+import { ITool } from "../tools/tool";
+export declare class OpenAIError extends Error {
+    readonly statusCode: number;
+    readonly error: any;
+    readonly isRetryable: boolean;
+    constructor(message: string, statusCode: number, error: any);
+}
+export declare class OpenAIBadKeyError extends Error {
+    readonly statusCode: number;
+    readonly error: any;
+    readonly isRetryable: boolean;
+    constructor(message: string, statusCode: number, error: any);
+}
+export declare class OpenAI implements IModel {
+    readonly identifier: string;
+    readonly apiKey: string;
+    readonly systemPrompt: string;
+    readonly tools?: ITool[] | undefined;
+    private readonly messages;
+    private threadIDPromise;
+    threadId?: string;
+    private inputs;
+    isDoneReceiving: boolean;
+    constructor(identifier: string, apiKey: string, systemPrompt: string, tools?: ITool[] | undefined);
+    private getThreadId;
+    invoke(prompt: ModelContent[], streamer: IModelStreamer): Promise<void>;
+    private createInputContent;
+    private createInput;
+    private createResponse;
+}
+export declare class OpenAIFactory implements IModelFactory {
+    readonly identifier: string;
+    readonly apiKey: ISecret;
+    constructor(identifier: string, apiKey: ISecret);
+    create(props: IModelFactoryProps): Promise<IModel>;
+}