supercompat 1.0.0

package/dist/index.js

@@ -0,0 +1,2265 @@
+// src/supercompat.ts
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _async_iterator(iterable) {
+    var method, async, sync, retry = 2;
+    for("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;){
+        if (async && null != (method = iterable[async])) return method.call(iterable);
+        if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+        async = "@@asyncIterator", sync = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+}
+function AsyncFromSyncIterator(s) {
+    function AsyncFromSyncIteratorContinuation(r) {
+        if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+        var done = r.done;
+        return Promise.resolve(r.value).then(function(value) {
+            return {
+                value: value,
+                done: done
+            };
+        });
+    }
+    return AsyncFromSyncIterator = function(s) {
+        this.s = s, this.n = s.next;
+    }, AsyncFromSyncIterator.prototype = {
+        s: null,
+        n: null,
+        next: function() {
+            return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+        },
+        return: function(value) {
+            var ret = this.s.return;
+            return void 0 === ret ? Promise.resolve({
+                value: value,
+                done: !0
+            }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+        },
+        throw: function(value) {
+            var thr = this.s.return;
+            return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+        }
+    }, new AsyncFromSyncIterator(s);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_array(arr) {
+    return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+var _mistral, _mistral1;
+import { assign, partob } from "radash";
+var supercompat = function(param) {
+    var client = param.client, storage = param.storage, runAdapter = param.runAdapter;
+    return assign(client, storage({
+        runAdapter: partob(runAdapter, {
+            client: client
+        })
+    }));
+};
+// src/adapters/client/mistralClientAdapter/index.ts
+var mistralClientAdapter = function(param) {
+    var mistral = param.mistral;
+    return {
+        chat: {
+            completions: {
+                // @ts-ignore-next-line
+                create: function() {
+                    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = arguments[_key];
+                    }
+                    return(// @ts-ignore-next-line
+                    args[0].stream ? (_mistral = mistral).chatStream.apply(_mistral, _to_consumable_array(args)) : (_mistral1 = mistral).chat.apply(_mistral1, _to_consumable_array(args)));
+                }
+            }
+        }
+    };
+};
+// src/adapters/client/perplexityClientAdapter/index.ts
+var agentSideRoles = [
+    "assistant",
+    "system"
+];
+var perplexityClientAdapter = function(param) {
+    var perplexity = param.perplexity;
+    return {
+        chat: {
+            completions: {
+                create: function() {
+                    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = arguments[_key];
+                    }
+                    var _perplexity_chat_completions;
+                    var _args = _to_array(args), firstArg = _args[0], restArgs = _args.slice(1);
+                    var messages3 = [];
+                    firstArg.messages.forEach(function(message, index) {
+                        messages3.push(message);
+                        var nextMessage = firstArg.messages[index + 1];
+                        if (!nextMessage) return;
+                        if (message.role === "user" && nextMessage.role === "user") {
+                            messages3.push({
+                                role: "assistant",
+                                content: ""
+                            });
+                        } else if (agentSideRoles.includes(message.role) && agentSideRoles.includes(nextMessage.role)) {
+                            messages3.push({
+                                role: "user",
+                                content: ""
+                            });
+                        }
+                    });
+                    return (_perplexity_chat_completions = perplexity.chat.completions).create.apply(_perplexity_chat_completions, [
+                        _object_spread_props(_object_spread({}, firstArg), {
+                            messages: messages3
+                        })
+                    ].concat(_to_consumable_array(restArgs)));
+                }
+            }
+        }
+    };
+};
+// src/adapters/run/completionsRunAdapter/index.ts
+import _ from "lodash";
+import { uid, omit, isEmpty } from "radash";
+import dayjs from "dayjs";
+// src/adapters/run/completionsRunAdapter/messages.ts
+import { flat } from "radash";
+// src/adapters/run/completionsRunAdapter/serializeMessage.ts
+var serializeToolCalls = function(param) {
+    var runStep = param.runStep;
+    if (runStep.step_details.type !== "tool_calls") return [];
+    var functionToolCalls = runStep.step_details.tool_calls.filter(function(tc) {
+        return tc.type === "function";
+    });
+    return functionToolCalls.map(function(toolCall) {
+        return {
+            tool_call_id: toolCall.id,
+            role: "tool",
+            name: toolCall.function.name,
+            content: toolCall.function.output
+        };
+    });
+};
+var serializeMessageWithContent = function(param) {
+    var message = param.message;
+    var _message_metadata;
+    return _object_spread({
+        role: message.role,
+        content: serializeContent({
+            content: message.content
+        })
+    }, (message === null || message === void 0 ? void 0 : (_message_metadata = message.metadata) === null || _message_metadata === void 0 ? void 0 : _message_metadata.toolCalls) ? {
+        tool_calls: message.metadata.toolCalls
+    } : {});
+};
+var serializeContent = function(param) {
+    var content = param.content;
+    return content.map(function(content2) {
+        return content2.text.value;
+    }).join("\n");
+};
+var serializeMessage = function(param) {
+    var message = param.message;
+    console.log("serializing msg");
+    console.dir({
+        message: message
+    }, {
+        depth: null
+    });
+    var result = [
+        serializeMessageWithContent({
+            message: message
+        })
+    ];
+    if (!message.run) return result;
+    var toolCallsRunSteps = message.run.runSteps.filter(function(runStep) {
+        return runStep.type === "tool_calls";
+    });
+    toolCallsRunSteps.forEach(function(runStep) {
+        var _result;
+        (_result = result).push.apply(_result, _to_consumable_array(serializeToolCalls({
+            runStep: runStep
+        })));
+    });
+    console.dir({
+        result: result
+    }, {
+        depth: null
+    });
+    return result;
+};
+// src/adapters/run/completionsRunAdapter/messages.ts
+var messages = function() {
+    var _ref = _async_to_generator(function(param) {
+        var run, getMessages2, _, _1;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    run = param.run, getMessages2 = param.getMessages;
+                    _1 = (_ = _to_consumable_array(run.instructions ? [
+                        {
+                            role: "system",
+                            content: run.instructions
+                        }
+                    ] : [])).concat;
+                    return [
+                        4,
+                        getMessages2()
+                    ];
+                case 1:
+                    return [
+                        2,
+                        _1.apply(_, [
+                            _to_consumable_array.apply(void 0, [
+                                flat.apply(void 0, [
+                                    _state.sent().map(function(message) {
+                                        return serializeMessage({
+                                            message: message
+                                        });
+                                    })
+                                ])
+                            ])
+                        ])
+                    ];
+            }
+        });
+    });
+    return function messages(_) {
+        return _ref.apply(this, arguments);
+    };
+}();
+// src/adapters/run/completionsRunAdapter/index.ts
+var updatedToolCall = function(param) {
+    var toolCall = param.toolCall, delta = param.delta;
+    if (!toolCall) return omit(delta, [
+        "index"
+    ]);
+    var result = _.cloneDeep(toolCall);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(delta.function)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+            var _result_function_key;
+            result.function[key] = "".concat((_result_function_key = result.function[key]) !== null && _result_function_key !== void 0 ? _result_function_key : "").concat(value);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+};
+var toolCallsData = function(param) {
+    var prevToolCalls = param.prevToolCalls, delta = param.delta;
+    if (!prevToolCalls) {
+        return delta.tool_calls.map(function(tc) {
+            return _object_spread({
+                id: uid(24),
+                type: "function"
+            }, omit(tc, [
+                "index"
+            ]));
+        });
+    }
+    var newToolCalls = _.cloneDeep(prevToolCalls);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = delta.tool_calls[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var runStepDelta = _step.value;
+            newToolCalls[runStepDelta.index] = updatedToolCall({
+                toolCall: newToolCalls[runStepDelta.index],
+                delta: runStepDelta
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return newToolCalls;
+};
+var completionsRunAdapter = function() {
+    var _ref = _async_to_generator(function(param) {
+        var client, run, onEvent2, getMessages2, opts, _tmp, providerResponse, e, message, toolCallsRunStep, currentContent, currentToolCalls, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, delta, _delta_content, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    client = param.client, run = param.run, onEvent2 = param.onEvent, getMessages2 = param.getMessages;
+                    if (run.status !== "queued") return [
+                        2
+                    ];
+                    onEvent2({
+                        event: "thread.run.in_progress",
+                        data: _object_spread_props(_object_spread({}, run), {
+                            status: "in_progress"
+                        })
+                    });
+                    _tmp = {};
+                    return [
+                        4,
+                        messages({
+                            run: run,
+                            getMessages: getMessages2
+                        })
+                    ];
+                case 1:
+                    opts = _object_spread.apply(void 0, [
+                        (_tmp.messages = _state.sent(), _tmp.model = run.model, _tmp.stream = true, _tmp),
+                        isEmpty(run.tools) ? {} : {
+                            tools: run.tools
+                        }
+                    ]);
+                    console.dir({
+                        opts: opts
+                    }, {
+                        depth: null
+                    });
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        client.chat.completions.create(opts)
+                    ];
+                case 3:
+                    providerResponse = _state.sent();
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    e = _state.sent();
+                    console.error(e);
+                    return [
+                        2,
+                        onEvent2({
+                            event: "thread.run.failed",
+                            data: _object_spread_props(_object_spread({}, run), {
+                                failed_at: dayjs().unix(),
+                                status: "in_progress",
+                                last_error: e.message
+                            })
+                        })
+                    ];
+                case 5:
+                    return [
+                        4,
+                        onEvent2({
+                            event: "thread.message.created",
+                            data: {
+                                id: "THERE_IS_A_BUG_IN_SUPERCOMPAT_IF_YOU_SEE_THIS_ID",
+                                object: "thread.message",
+                                completed_at: null,
+                                run_id: run.id,
+                                created_at: dayjs().unix(),
+                                assistant_id: run.assistant_id,
+                                incomplete_at: null,
+                                incomplete_details: null,
+                                metadata: {},
+                                file_ids: [],
+                                thread_id: run.thread_id,
+                                content: [
+                                    {
+                                        text: {
+                                            value: "",
+                                            annotations: []
+                                        },
+                                        type: "text"
+                                    }
+                                ],
+                                role: "assistant",
+                                status: "in_progress"
+                            }
+                        })
+                    ];
+                case 6:
+                    message = _state.sent();
+                    onEvent2({
+                        event: "thread.run.step.created",
+                        data: {
+                            id: "THERE_IS_A_BUG_IN_SUPERCOMPAT_IF_YOU_SEE_THIS_ID",
+                            object: "thread.run.step",
+                            run_id: run.id,
+                            assistant_id: run.assistant_id,
+                            thread_id: run.thread_id,
+                            type: "message_creation",
+                            status: "completed",
+                            completed_at: dayjs().unix(),
+                            created_at: dayjs().unix(),
+                            expired_at: null,
+                            last_error: null,
+                            metadata: {},
+                            failed_at: null,
+                            cancelled_at: null,
+                            usage: null,
+                            step_details: {
+                                type: "message_creation",
+                                message_creation: {
+                                    message_id: message.id
+                                }
+                            }
+                        }
+                    });
+                    currentContent = "";
+                    console.dir({
+                        providerResponse: providerResponse
+                    }, {
+                        depth: null
+                    });
+                    _iteratorAbruptCompletion = false, _didIteratorError = false;
+                    _state.label = 7;
+                case 7:
+                    _state.trys.push([
+                        7,
+                        15,
+                        16,
+                        21
+                    ]);
+                    _iterator = _async_iterator(providerResponse);
+                    _state.label = 8;
+                case 8:
+                    return [
+                        4,
+                        _iterator.next()
+                    ];
+                case 9:
+                    if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
+                        3,
+                        14
+                    ];
+                    _value = _step.value;
+                    chunk = _value;
+                    delta = chunk.choices[0].delta;
+                    if (delta.content) {
+                        ;
+                        currentContent = "".concat(currentContent).concat((_delta_content = delta.content) !== null && _delta_content !== void 0 ? _delta_content : "");
+                    }
+                    if (!delta.tool_calls) return [
+                        3,
+                        12
+                    ];
+                    if (!!toolCallsRunStep) return [
+                        3,
+                        11
+                    ];
+                    return [
+                        4,
+                        onEvent2({
+                            event: "thread.run.step.created",
+                            data: {
+                                id: "THERE_IS_A_BUG_IN_SUPERCOMPAT_IF_YOU_SEE_THIS_ID",
+                                object: "thread.run.step",
+                                run_id: run.id,
+                                assistant_id: run.assistant_id,
+                                thread_id: run.thread_id,
+                                type: "tool_calls",
+                                status: "in_progress",
+                                completed_at: null,
+                                created_at: dayjs().unix(),
+                                expired_at: null,
+                                last_error: null,
+                                metadata: {},
+                                failed_at: null,
+                                cancelled_at: null,
+                                usage: null,
+                                step_details: {
+                                    type: "tool_calls",
+                                    tool_calls: []
+                                }
+                            }
+                        })
+                    ];
+                case 10:
+                    toolCallsRunStep = _state.sent();
+                    _state.label = 11;
+                case 11:
+                    onEvent2({
+                        event: "thread.run.step.delta",
+                        data: {
+                            object: "thread.run.step.delta",
+                            run_id: run.id,
+                            id: toolCallsRunStep.id,
+                            delta: {
+                                step_details: {
+                                    type: "tool_calls",
+                                    tool_calls: delta.tool_calls.map(function(tc) {
+                                        return _object_spread({
+                                            id: uid(24),
+                                            type: "function"
+                                        }, tc);
+                                    })
+                                }
+                            }
+                        }
+                    });
+                    currentToolCalls = toolCallsData({
+                        prevToolCalls: currentToolCalls,
+                        delta: delta
+                    });
+                    _state.label = 12;
+                case 12:
+                    if (delta.content) {
+                        onEvent2({
+                            event: "thread.message.delta",
+                            data: {
+                                id: message.id,
+                                delta: {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            index: 0,
+                                            text: {
+                                                value: delta.content
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        });
+                    }
+                    _state.label = 13;
+                case 13:
+                    _iteratorAbruptCompletion = false;
+                    return [
+                        3,
+                        8
+                    ];
+                case 14:
+                    return [
+                        3,
+                        21
+                    ];
+                case 15:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        21
+                    ];
+                case 16:
+                    _state.trys.push([
+                        16,
+                        ,
+                        19,
+                        20
+                    ]);
+                    if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
+                        3,
+                        18
+                    ];
+                    return [
+                        4,
+                        _iterator.return()
+                    ];
+                case 17:
+                    _state.sent();
+                    _state.label = 18;
+                case 18:
+                    return [
+                        3,
+                        20
+                    ];
+                case 19:
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                    return [
+                        7
+                    ];
+                case 20:
+                    return [
+                        7
+                    ];
+                case 21:
+                    return [
+                        4,
+                        onEvent2({
+                            event: "thread.message.completed",
+                            data: _object_spread_props(_object_spread({}, message), {
+                                status: "completed",
+                                content: [
+                                    {
+                                        text: {
+                                            value: currentContent,
+                                            annotations: []
+                                        },
+                                        type: "text"
+                                    }
+                                ],
+                                tool_calls: currentToolCalls
+                            })
+                        })
+                    ];
+                case 22:
+                    message = _state.sent();
+                    if (isEmpty(message.toolCalls)) {
+                        return [
+                            2,
+                            onEvent2({
+                                event: "thread.run.completed",
+                                data: _object_spread_props(_object_spread({}, run), {
+                                    status: "completed",
+                                    completed_at: dayjs().unix()
+                                })
+                            })
+                        ];
+                    }
+                    return [
+                        2,
+                        onEvent2({
+                            event: "thread.run.requires_action",
+                            data: _object_spread_props(_object_spread({}, run), {
+                                status: "requires_action",
+                                required_action: {
+                                    type: "submit_tool_outputs",
+                                    submit_tool_outputs: {
+                                        tool_calls: message.toolCalls
+                                    }
+                                }
+                            })
+                        })
+                    ];
+            }
+        });
+    });
+    return function completionsRunAdapter(_) {
+        return _ref.apply(this, arguments);
+    };
+}();
+// src/adapters/storage/prismaStorageAdapter/beta/threads/create.ts
+import dayjs3 from "dayjs";
+// src/adapters/storage/prismaStorageAdapter/beta/threads/serializeThread.ts
+import dayjs2 from "dayjs";
+var serializeThread = function(param) {
+    var thread = param.thread;
+    return {
+        id: thread.id,
+        object: "thread",
+        created_at: dayjs2(thread.createdAt).unix(),
+        metadata: thread.metadata
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/create.ts
+var create = function(param) {
+    var prisma = param.prisma;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var _len, args, _key, _args_, _args__body, messages3, metadata, initialCreatedAt, thread;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    for(_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = _arguments[_key];
+                    }
+                    _args_ = args[0], _args__body = _args_.// @ts-ignore-next-line
+                    body, messages3 = _args__body.messages, metadata = _args__body.metadata;
+                    initialCreatedAt = dayjs3().subtract(messages3.length, "seconds").format();
+                    return [
+                        4,
+                        prisma.thread.create({
+                            data: {
+                                assistantId: metadata.superinterfaceAssistantId,
+                                metadata: metadata,
+                                messages: {
+                                    create: messages3.map(function(message, index) {
+                                        return {
+                                            role: message.role,
+                                            content: [
+                                                {
+                                                    type: "text",
+                                                    text: {
+                                                        annotations: [],
+                                                        value: message.content
+                                                    }
+                                                }
+                                            ],
+                                            fileIds: message.file_ids,
+                                            metadata: message.metadata,
+                                            createdAt: dayjs3(initialCreatedAt).add(index, "seconds").toDate()
+                                        };
+                                    })
+                                }
+                            }
+                        })
+                    ];
+                case 1:
+                    thread = _state.sent();
+                    return [
+                        2,
+                        serializeThread({
+                            thread: thread
+                        })
+                    ];
+            }
+        });
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/messages/list.ts
+import { assign as assign3, last } from "radash";
+// src/adapters/storage/prismaStorageAdapter/beta/threads/messages/serializeMessage.ts
+import dayjs4 from "dayjs";
+import { assign as assign2 } from "radash";
+var serializeMessage2 = function(param) {
+    var message = param.message;
+    var _message_metadata;
+    return {
+        id: message.id,
+        object: "thread.message",
+        created_at: dayjs4(message.createdAt).unix(),
+        thread_id: message.threadId,
+        completed_at: message.completedAt ? dayjs4(message.completedAt).unix() : null,
+        incomplete_at: message.incompleteAt ? dayjs4(message.incompleteAt).unix() : null,
+        incomplete_details: message.incompleteDetails,
+        role: message.role.toLowerCase(),
+        content: message.content,
+        assistant_id: message.assistantId,
+        run_id: message.runId,
+        file_ids: message.fileIds,
+        status: message.status.toLowerCase(),
+        metadata: assign2((_message_metadata = message.metadata) !== null && _message_metadata !== void 0 ? _message_metadata : {}, {
+            toolCalls: message.toolCalls
+        })
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/messages/list.ts
+var list = function(param) {
+    var prisma = param.prisma;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var _len, args, _key, _last, threadId, _args_, _assign3, // @ts-ignore-next-line
+        limit, // @ts-ignore-next-line
+        order, messages3, _last_id;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    for(_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = _arguments[_key];
+                    }
+                    threadId = args[0];
+                    _assign3 = assign3({
+                        // @ts-ignore-next-line
+                        limit: 20,
+                        order: "desc"
+                    }, (_args_ = args[1]) !== null && _args_ !== void 0 ? _args_ : {}), limit = _assign3.limit, order = _assign3.order;
+                    return [
+                        4,
+                        prisma.message.findMany({
+                            where: {
+                                threadId: threadId
+                            },
+                            take: limit,
+                            orderBy: {
+                                createdAt: order
+                            }
+                        })
+                    ];
+                case 1:
+                    messages3 = _state.sent();
+                    return [
+                        2,
+                        {
+                            data: messages3.map(function(message) {
+                                return serializeMessage2({
+                                    message: message
+                                });
+                            }),
+                            hasNextPage: function() {
+                                return false;
+                            },
+                            body: {
+                                last_id: (_last_id = (_last = last(messages3)) === null || _last === void 0 ? void 0 : _last.id) !== null && _last_id !== void 0 ? _last_id : null
+                            }
+                        }
+                    ];
+            }
+        });
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/messages/create.ts
+var messageContentBlocks = function(param) {
+    var content = param.content;
+    return [
+        {
+            type: "text",
+            text: {
+                value: content !== null && content !== void 0 ? content : "",
+                annotations: []
+            }
+        }
+    ];
+};
+var create2 = function(param) {
+    var prisma = param.prisma;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var _len, args, _key, threadId, content, message;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    for(_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = _arguments[_key];
+                    }
+                    threadId = args[0];
+                    content = args[1].content;
+                    return [
+                        4,
+                        prisma.message.create({
+                            data: {
+                                threadId: threadId,
+                                content: messageContentBlocks({
+                                    content: content
+                                }),
+                                role: "USER"
+                            }
+                        })
+                    ];
+                case 1:
+                    message = _state.sent();
+                    return [
+                        2,
+                        serializeMessage2({
+                            message: message
+                        })
+                    ];
+            }
+        });
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/messages/index.ts
+var messages2 = function(param) {
+    var prisma = param.prisma;
+    return {
+        list: list({
+            prisma: prisma
+        }),
+        create: create2({
+            prisma: prisma
+        })
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/list.ts
+import { assign as assign4, last as last2 } from "radash";
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/serializeRun.ts
+import dayjs5 from "dayjs";
+var serializeRun = function(param) {
+    var run = param.run;
+    return {
+        id: run.id,
+        object: "thread.run",
+        created_at: dayjs5(run.createdAt).unix(),
+        thread_id: run.threadId,
+        assistant_id: run.assistantId,
+        status: run.status.toLowerCase(),
+        required_action: run.requiredAction,
+        last_error: run.lastError,
+        expires_at: dayjs5(run.expiresAt).unix(),
+        started_at: run.startedAt ? dayjs5(run.startedAt).unix() : null,
+        cancelled_at: run.cancelledAt ? dayjs5(run.cancelledAt).unix() : null,
+        failed_at: run.failedAt ? dayjs5(run.failedAt).unix() : null,
+        completed_at: run.completedAt ? dayjs5(run.completedAt).unix() : null,
+        model: run.model,
+        instructions: run.instructions,
+        // @ts-ignore-next-line
+        tools: run.tools,
+        file_ids: run.fileIds,
+        metadata: run.metadata,
+        usage: run.usage
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/list.ts
+var list2 = function(param) {
+    var prisma = param.prisma;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var _len, args, _key, _last2, threadId, _args_, _assign4, // @ts-ignore-next-line
+        limit, // @ts-ignore-next-line
+        order, runs2, _last2_id;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    for(_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = _arguments[_key];
+                    }
+                    threadId = args[0];
+                    _assign4 = assign4({
+                        // @ts-ignore-next-line
+                        limit: 20,
+                        order: "desc"
+                    }, (_args_ = args[1]) !== null && _args_ !== void 0 ? _args_ : {}), limit = _assign4.limit, order = _assign4.order;
+                    return [
+                        4,
+                        prisma.run.findMany({
+                            where: {
+                                threadId: threadId
+                            },
+                            take: limit,
+                            orderBy: {
+                                createdAt: order
+                            }
+                        })
+                    ];
+                case 1:
+                    runs2 = _state.sent();
+                    return [
+                        2,
+                        {
+                            data: runs2.map(function(run) {
+                                return serializeRun({
+                                    run: run
+                                });
+                            }),
+                            hasNextPage: function() {
+                                return false;
+                            },
+                            body: {
+                                last_id: (_last2_id = (_last2 = last2(runs2)) === null || _last2 === void 0 ? void 0 : _last2.id) !== null && _last2_id !== void 0 ? _last2_id : null
+                            }
+                        }
+                    ];
+            }
+        });
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/create.ts
+import dayjs6 from "dayjs";
+import { assign as assign5 } from "radash";
+var create3 = function(param) {
+    var prisma = param.prisma;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var _len, args, _key, threadId, assistant_id, assistant, _assign5, model, instructions, // additional_instructions,
+        tools, metadata, run;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    for(_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = _arguments[_key];
+                    }
+                    threadId = args[0];
+                    assistant_id = args[1].assistant_id;
+                    return [
+                        4,
+                        prisma.assistant.findUnique({
+                            where: {
+                                id: assistant_id
+                            }
+                        })
+                    ];
+                case 1:
+                    assistant = _state.sent();
+                    if (!assistant) {
+                        throw new Error("Assistant not found");
+                    }
+                    _assign5 = assign5({
+                        model: assistant.modelSlug,
+                        instructions: "",
+                        additional_instructions: null
+                    }, args[1]), model = _assign5.model, instructions = _assign5.instructions, tools = _assign5.tools, metadata = _assign5.metadata;
+                    return [
+                        4,
+                        prisma.run.create({
+                            data: {
+                                status: "QUEUED",
+                                expiresAt: dayjs6().add(1, "hour").unix(),
+                                // @ts-ignore-next-line
+                                model: model,
+                                // @ts-ignore-next-line
+                                instructions: instructions,
+                                // @ts-ignore-next-line
+                                tools: tools,
+                                // @ts-ignore-next-line
+                                metadata: metadata,
+                                thread: {
+                                    connect: {
+                                        id: threadId
+                                    }
+                                },
+                                assistant: {
+                                    connect: {
+                                        id: assistant_id
+                                    }
+                                }
+                            }
+                        })
+                    ];
+                case 2:
+                    run = _state.sent();
+                    return [
+                        2,
+                        serializeRun({
+                            run: run
+                        })
+                    ];
+            }
+        });
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/createAndStream.ts
+import { assign as assign6 } from "radash";
+import dayjs8 from "dayjs";
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/threadRunInProgress.ts
+var threadRunInProgress = function(param) {
+    var prisma = param.prisma, event = param.event, controller = param.controller;
+    controller.enqueue(event);
+    return prisma.run.update({
+        where: {
+            id: event.data.id
+        },
+        data: {
+            status: "IN_PROGRESS" /* IN_PROGRESS */ 
+        }
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/threadRunFailed.ts
+var threadRunFailed = function(param) {
+    var prisma = param.prisma, event = param.event, controller = param.controller;
+    controller.enqueue(event);
+    return prisma.run.update({
+        where: {
+            id: event.data.id
+        },
+        data: {
+            status: "FAILED" /* FAILED */ ,
+            failedAt: event.data.failed_at,
+            lastError: event.data.last_error
+        }
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/threadRunCompleted.ts
+var threadRunCompleted = function(param) {
+    var prisma = param.prisma, event = param.event, controller = param.controller;
+    controller.enqueue(event);
+    return prisma.run.update({
+        where: {
+            id: event.data.id
+        },
+        data: {
+            status: "COMPLETED" /* COMPLETED */ ,
+            requiredAction: void 0
+        }
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/threadRunRequiresAction.ts
+var threadRunRequiresAction = function(param) {
+    var prisma = param.prisma, event = param.event, controller = param.controller;
+    controller.enqueue(event);
+    return prisma.run.update({
+        where: {
+            id: event.data.id
+        },
+        data: {
+            status: RunStatus.REQUIRES_ACTION,
+            requiredAction: event.data.required_action
+        }
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/steps/serializeRunStep.ts
+import dayjs7 from "dayjs";
+var serializeRunStep = function(param) {
+    var runStep = param.runStep;
+    return {
+        id: runStep.id,
+        object: "thread.run.step",
+        created_at: dayjs7(runStep.createdAt).unix(),
+        assistant_id: runStep.assistantId,
+        thread_id: runStep.threadId,
+        run_id: runStep.runId,
+        type: runStep.type.toLowerCase(),
+        status: runStep.status.toLowerCase(),
+        // @ts-ignore-next-line
+        step_details: runStep.stepDetails,
+        last_error: runStep.lastError,
+        expired_at: runStep.expiredAt ? dayjs7(runStep.expiredAt).unix() : null,
+        cancelled_at: runStep.cancelledAt ? dayjs7(runStep.cancelledAt).unix() : null,
+        failed_at: runStep.failedAt ? dayjs7(runStep.failedAt).unix() : null,
+        completed_at: runStep.completedAt ? dayjs7(runStep.completedAt).unix() : null,
+        metadata: runStep.metadata,
+        usage: runStep.usage
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/threadRunStepCreated.ts
+var type = function(event) {
+    if (event.data.type === "message_creation") return "MESSAGE_CREATION" /* MESSAGE_CREATION */ ;
+    if (event.data.type === "tool_calls") return "TOOL_CALLS" /* TOOL_CALLS */ ;
+    throw new Error("Unknown type: ".concat(event.data.type));
+};
+var status = function(event) {
+    if (event.data.status === "in_progress") return "IN_PROGRESS" /* IN_PROGRESS */ ;
+    if (event.data.status === "cancelled") return "CANCELLED" /* CANCELLED */ ;
+    if (event.data.status === "completed") return "COMPLETED" /* COMPLETED */ ;
+    if (event.data.status === "failed") return "FAILED" /* FAILED */ ;
+    if (event.data.status === "expired") return "EXPIRED" /* EXPIRED */ ;
+    throw new Error("Unknown status: ".concat(event.data.status));
+};
+var threadRunStepCreated = function() {
+    var _ref = _async_to_generator(function(param) {
+        var prisma, event, controller, runStep, serializedRunStep;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    prisma = param.prisma, event = param.event, controller = param.controller;
+                    return [
+                        4,
+                        prisma.runStep.create({
+                            data: {
+                                runId: event.data.run_id,
+                                assistantId: event.data.assistant_id,
+                                threadId: event.data.thread_id,
+                                type: type(event),
+                                status: status(event),
+                                stepDetails: event.data.step_details,
+                                completedAt: event.data.completed_at
+                            }
+                        })
+                    ];
+                case 1:
+                    runStep = _state.sent();
+                    serializedRunStep = serializeRunStep({
+                        runStep: runStep
+                    });
+                    controller.enqueue(_object_spread_props(_object_spread({}, event), {
+                        data: serializedRunStep
+                    }));
+                    return [
+                        2,
+                        serializedRunStep
+                    ];
+            }
+        });
+    });
+    return function threadRunStepCreated(_) {
+        return _ref.apply(this, arguments);
+    };
+}();
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/threadRunStepDelta.ts
+var threadRunStepDelta = function(param) {
+    var event = param.event, controller = param.controller;
+    return controller.enqueue(event);
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/threadMessageCreated.ts
+var status2 = function(event) {
+    if (event.data.status === "completed") return "COMPLETED" /* COMPLETED */ ;
+    if (event.data.status === "in_progress") return "IN_PROGRESS" /* IN_PROGRESS */ ;
+    if (event.data.status === "incomplete") return "INCOMPLETE" /* INCOMPLETE */ ;
+    throw new Error("Unknown status: ".concat(event.data.status));
+};
+var threadMessageCreated = function() {
+    var _ref = _async_to_generator(function(param) {
+        var prisma, event, controller, message, serializedMessage;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    prisma = param.prisma, event = param.event, controller = param.controller;
+                    return [
+                        4,
+                        prisma.message.create({
+                            data: {
+                                threadId: event.data.thread_id,
+                                content: event.data.content,
+                                role: event.data.role === "assistant" ? "ASSISTANT" : "USER",
+                                assistantId: event.data.assistant_id,
+                                runId: event.data.run_id,
+                                status: status2(event)
+                            }
+                        })
+                    ];
+                case 1:
+                    message = _state.sent();
+                    serializedMessage = serializeMessage2({
+                        message: message
+                    });
+                    controller.enqueue(_object_spread_props(_object_spread({}, event), {
+                        data: serializedMessage
+                    }));
+                    return [
+                        2,
+                        serializedMessage
+                    ];
+            }
+        });
+    });
+    return function threadMessageCreated(_) {
+        return _ref.apply(this, arguments);
+    };
+}();
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/threadMessageDelta.ts
+var threadMessageDelta = function(param) {
+    var event = param.event, controller = param.controller;
+    return controller.enqueue(event);
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/threadMessageCompleted.ts
+var threadMessageCompleted = function() {
+    var _ref = _async_to_generator(function(param) {
+        var prisma, event, controller, latestRunStep;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    prisma = param.prisma, event = param.event, controller = param.controller;
+                    controller.enqueue(event);
+                    if (!event.data.tool_calls) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        prisma.runStep.findFirst({
+                            where: {
+                                threadId: event.data.thread_id,
+                                type: "TOOL_CALLS" /* TOOL_CALLS */ 
+                            },
+                            orderBy: {
+                                createdAt: "desc"
+                            }
+                        })
+                    ];
+                case 1:
+                    latestRunStep = _state.sent();
+                    if (!latestRunStep) {
+                        throw new Error("No run step found");
+                    }
+                    return [
+                        4,
+                        prisma.runStep.update({
+                            where: {
+                                id: latestRunStep.id
+                            },
+                            data: {
+                                stepDetails: {
+                                    type: "tool_calls",
+                                    tool_calls: event.data.tool_calls
+                                }
+                            }
+                        })
+                    ];
+                case 2:
+                    _state.sent();
+                    _state.label = 3;
+                case 3:
+                    return [
+                        2,
+                        prisma.message.update({
+                            where: {
+                                id: event.data.id
+                            },
+                            data: _object_spread({
+                                status: "COMPLETED" /* COMPLETED */ 
+                            }, event.data.content ? {
+                                content: event.data.content
+                            } : {}, event.data.tool_calls ? {
+                                toolCalls: event.data.tool_calls
+                            } : {})
+                        })
+                    ];
+            }
+        });
+    });
+    return function threadMessageCompleted(_) {
+        return _ref.apply(this, arguments);
+    };
+}();
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/handlers/index.ts
+var handlers = {
+    "thread.run.in_progress": threadRunInProgress,
+    "thread.run.failed": threadRunFailed,
+    "thread.run.completed": threadRunCompleted,
+    "thread.run.requires_action": threadRunRequiresAction,
+    "thread.run.step.created": threadRunStepCreated,
+    "thread.run.step.delta": threadRunStepDelta,
+    "thread.message.created": threadMessageCreated,
+    "thread.message.delta": threadMessageDelta,
+    "thread.message.completed": threadMessageCompleted
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/onEvent/index.ts
+var onEvent = function(param) {
+    var prisma = param.prisma, controller = param.controller;
+    return function(event) {
+        var handler = handlers[event.event];
+        if (!handler) {
+            console.log("No handler for event", event);
+            return;
+        }
+        return handler({
+            prisma: prisma,
+            controller: controller,
+            event: event
+        });
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/getMessages.ts
+var getMessages = function(param) {
+    var prisma = param.prisma, run = param.run;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var messages3;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        prisma.message.findMany({
+                            where: {
+                                threadId: run.threadId
+                            },
+                            include: {
+                                run: {
+                                    include: {
+                                        runSteps: true
+                                    }
+                                }
+                            },
+                            take: -10,
+                            orderBy: {
+                                createdAt: "asc"
+                            }
+                        })
+                    ];
+                case 1:
+                    messages3 = _state.sent();
+                    return [
+                        2,
+                        messages3.map(function(message) {
+                            return _object_spread_props(_object_spread({}, serializeMessage2({
+                                message: message
+                            })), {
+                                run: message.run ? _object_spread_props(_object_spread({}, serializeRun({
+                                    run: message.run
+                                })), {
+                                    runSteps: message.run.runSteps.map(function(runStep) {
+                                        return serializeRunStep({
+                                            runStep: runStep
+                                        });
+                                    })
+                                }) : null
+                            });
+                        })
+                    ];
+            }
+        });
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/createAndStream.ts
+var createAndStream = function(param) {
+    var prisma = param.prisma, runAdapter = param.runAdapter;
+    return function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return new ReadableStream({
+            start: function start(controller) {
+                return _async_to_generator(function() {
+                    var threadId, assistant_id, assistant, _assign6, model, instructions, // additional_instructions,
+                    tools, metadata, run, data;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                threadId = args[0];
+                                assistant_id = args[1].assistant_id;
+                                return [
+                                    4,
+                                    prisma.assistant.findUnique({
+                                        where: {
+                                            id: assistant_id
+                                        }
+                                    })
+                                ];
+                            case 1:
+                                assistant = _state.sent();
+                                if (!assistant) {
+                                    throw new Error("Assistant not found");
+                                }
+                                _assign6 = assign6({
+                                    model: assistant.modelSlug,
+                                    instructions: "",
+                                    additional_instructions: null
+                                }, args[1]), model = _assign6.model, instructions = _assign6.instructions, tools = _assign6.tools, metadata = _assign6.metadata;
+                                return [
+                                    4,
+                                    prisma.run.create({
+                                        data: {
+                                            status: "QUEUED",
+                                            expiresAt: dayjs8().add(1, "hour").unix(),
+                                            // @ts-ignore-next-line
+                                            model: model,
+                                            // @ts-ignore-next-line
+                                            instructions: instructions,
+                                            // @ts-ignore-next-line
+                                            tools: tools,
+                                            // @ts-ignore-next-line
+                                            metadata: metadata,
+                                            thread: {
+                                                connect: {
+                                                    id: threadId
+                                                }
+                                            },
+                                            assistant: {
+                                                connect: {
+                                                    id: assistant_id
+                                                }
+                                            }
+                                        }
+                                    })
+                                ];
+                            case 2:
+                                run = _state.sent();
+                                data = serializeRun({
+                                    run: run
+                                });
+                                controller.enqueue({
+                                    event: "thread.run.created",
+                                    data: data
+                                });
+                                console.log("createAndStream", {
+                                    getMessages: getMessages
+                                });
+                                return [
+                                    4,
+                                    runAdapter({
+                                        run: data,
+                                        onEvent: onEvent({
+                                            controller: controller,
+                                            prisma: prisma
+                                        }),
+                                        getMessages: getMessages({
+                                            prisma: prisma,
+                                            run: run
+                                        })
+                                    })
+                                ];
+                            case 3:
+                                _state.sent();
+                                console.log("Stream ended inside cloud storage");
+                                controller.close();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        });
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/submitToolOutputs.ts
+import dayjs9 from "dayjs";
+var submitToolOutputs = function(param) {
+    var prisma = param.prisma, runAdapter = param.runAdapter;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var _len, args, _key, _args, threadId, runId, body, tool_outputs, run, data;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    for(_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = _arguments[_key];
+                    }
+                    _args = _sliced_to_array(args, 3), threadId = _args[0], runId = _args[1], body = _args[2];
+                    tool_outputs = body.tool_outputs;
+                    return [
+                        4,
+                        prisma.$transaction(function() {
+                            var _ref = _async_to_generator(function(prisma2) {
+                                var runSteps, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                prisma2.runStep.findMany({
+                                                    where: {
+                                                        threadId: threadId,
+                                                        runId: runId,
+                                                        type: "TOOL_CALLS",
+                                                        status: "IN_PROGRESS"
+                                                    }
+                                                })
+                                            ];
+                                        case 1:
+                                            runSteps = _state.sent();
+                                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                            _state.label = 2;
+                                        case 2:
+                                            _state.trys.push([
+                                                2,
+                                                7,
+                                                8,
+                                                9
+                                            ]);
+                                            _loop = function() {
+                                                var runStep;
+                                                return _ts_generator(this, function(_state) {
+                                                    switch(_state.label){
+                                                        case 0:
+                                                            runStep = _step.value;
+                                                            return [
+                                                                4,
+                                                                prisma2.runStep.update({
+                                                                    where: {
+                                                                        id: runStep.id
+                                                                    },
+                                                                    data: {
+                                                                        status: "COMPLETED",
+                                                                        completedAt: dayjs9().unix(),
+                                                                        stepDetails: {
+                                                                            type: "tool_calls",
+                                                                            tool_calls: runStep.stepDetails.tool_calls.map(function(toolCall) {
+                                                                                var toolOutput = tool_outputs.find(function(output) {
+                                                                                    return output.tool_call_id === toolCall.id;
+                                                                                }) || tool_outputs[0];
+                                                                                if (!toolOutput) {
+                                                                                    console.dir({
+                                                                                        toolOutput: toolOutput,
+                                                                                        runStep: runStep,
+                                                                                        tool_outputs: tool_outputs,
+                                                                                        runSteps: runSteps
+                                                                                    }, {
+                                                                                        depth: null
+                                                                                    });
+                                                                                    throw new Error("Tool output not found");
+                                                                                }
+                                                                                return {
+                                                                                    id: toolCall.id,
+                                                                                    type: toolCall.type,
+                                                                                    function: _object_spread_props(_object_spread({}, toolCall.function), {
+                                                                                        output: toolOutput.output
+                                                                                    })
+                                                                                };
+                                                                            })
+                                                                        }
+                                                                    }
+                                                                })
+                                                            ];
+                                                        case 1:
+                                                            _state.sent();
+                                                            return [
+                                                                2
+                                                            ];
+                                                    }
+                                                });
+                                            };
+                                            _iterator = runSteps[Symbol.iterator]();
+                                            _state.label = 3;
+                                        case 3:
+                                            if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                                3,
+                                                6
+                                            ];
+                                            return [
+                                                5,
+                                                _ts_values(_loop())
+                                            ];
+                                        case 4:
+                                            _state.sent();
+                                            _state.label = 5;
+                                        case 5:
+                                            _iteratorNormalCompletion = true;
+                                            return [
+                                                3,
+                                                3
+                                            ];
+                                        case 6:
+                                            return [
+                                                3,
+                                                9
+                                            ];
+                                        case 7:
+                                            err = _state.sent();
+                                            _didIteratorError = true;
+                                            _iteratorError = err;
+                                            return [
+                                                3,
+                                                9
+                                            ];
+                                        case 8:
+                                            try {
+                                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                    _iterator.return();
+                                                }
+                                            } finally{
+                                                if (_didIteratorError) {
+                                                    throw _iteratorError;
+                                                }
+                                            }
+                                            return [
+                                                7
+                                            ];
+                                        case 9:
+                                            return [
+                                                2,
+                                                prisma2.run.update({
+                                                    where: {
+                                                        id: runId
+                                                    },
+                                                    data: {
+                                                        status: "QUEUED"
+                                                    }
+                                                })
+                                            ];
+                                    }
+                                });
+                            });
+                            return function(prisma2) {
+                                return _ref.apply(this, arguments);
+                            };
+                        }())
+                    ];
+                case 1:
+                    run = _state.sent();
+                    data = serializeRun({
+                        run: run
+                    });
+                    return [
+                        4,
+                        new Promise(function(resolve) {
+                            return new ReadableStream({
+                                start: function start(controller) {
+                                    return _async_to_generator(function() {
+                                        return _ts_generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    return [
+                                                        4,
+                                                        runAdapter({
+                                                            run: data,
+                                                            onEvent: onEvent({
+                                                                controller: controller,
+                                                                prisma: prisma
+                                                            }),
+                                                            // @ts-ignore-next-line
+                                                            getMessages: getMessages({
+                                                                prisma: prisma,
+                                                                run: run
+                                                            })
+                                                        })
+                                                    ];
+                                                case 1:
+                                                    _state.sent();
+                                                    controller.close();
+                                                    resolve(void 0);
+                                                    return [
+                                                        2
+                                                    ];
+                                            }
+                                        });
+                                    })();
+                                }
+                            });
+                        })
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        2,
+                        data
+                    ];
+            }
+        });
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/submitToolOutputsStream.ts
+import dayjs10 from "dayjs";
+var submitToolOutputsStream = function(param) {
+    var prisma = param.prisma, runAdapter = param.runAdapter;
+    return function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return new ReadableStream({
+            start: function start(controller) {
+                return _async_to_generator(function() {
+                    var _args, threadId, runId, body, tool_outputs, run;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                _args = _sliced_to_array(args, 3), threadId = _args[0], runId = _args[1], body = _args[2];
+                                tool_outputs = body.tool_outputs;
+                                return [
+                                    4,
+                                    prisma.$transaction(function() {
+                                        var _ref = _async_to_generator(function(prisma2) {
+                                            var runSteps, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _loop, _iterator, _step, err;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        return [
+                                                            4,
+                                                            prisma2.runStep.findMany({
+                                                                where: {
+                                                                    threadId: threadId,
+                                                                    runId: runId,
+                                                                    type: "TOOL_CALLS",
+                                                                    status: "IN_PROGRESS"
+                                                                },
+                                                                orderBy: {
+                                                                    createdAt: "asc"
+                                                                }
+                                                            })
+                                                        ];
+                                                    case 1:
+                                                        runSteps = _state.sent();
+                                                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                                        _state.label = 2;
+                                                    case 2:
+                                                        _state.trys.push([
+                                                            2,
+                                                            7,
+                                                            8,
+                                                            9
+                                                        ]);
+                                                        _loop = function() {
+                                                            var runStep, completedRunStep;
+                                                            return _ts_generator(this, function(_state) {
+                                                                switch(_state.label){
+                                                                    case 0:
+                                                                        runStep = _step.value;
+                                                                        return [
+                                                                            4,
+                                                                            prisma2.runStep.update({
+                                                                                where: {
+                                                                                    id: runStep.id
+                                                                                },
+                                                                                data: {
+                                                                                    status: "COMPLETED",
+                                                                                    completedAt: dayjs10().unix(),
+                                                                                    stepDetails: {
+                                                                                        type: "tool_calls",
+                                                                                        tool_calls: runStep.stepDetails.tool_calls.map(function(toolCall) {
+                                                                                            var toolOutput = tool_outputs.find(function(output) {
+                                                                                                return output.tool_call_id === toolCall.id;
+                                                                                            }) || tool_outputs[0];
+                                                                                            if (!toolOutput) {
+                                                                                                console.dir({
+                                                                                                    toolOutput: toolOutput,
+                                                                                                    runStep: runStep,
+                                                                                                    tool_outputs: tool_outputs,
+                                                                                                    runSteps: runSteps
+                                                                                                }, {
+                                                                                                    depth: null
+                                                                                                });
+                                                                                                throw new Error("Tool output not found");
+                                                                                            }
+                                                                                            return {
+                                                                                                id: toolCall.id,
+                                                                                                type: toolCall.type,
+                                                                                                function: _object_spread_props(_object_spread({}, toolCall.function), {
+                                                                                                    output: toolOutput.output
+                                                                                                })
+                                                                                            };
+                                                                                        })
+                                                                                    }
+                                                                                }
+                                                                            })
+                                                                        ];
+                                                                    case 1:
+                                                                        completedRunStep = _state.sent();
+                                                                        controller.enqueue({
+                                                                            event: "thread.run.step.completed",
+                                                                            data: serializeRunStep({
+                                                                                runStep: completedRunStep
+                                                                            })
+                                                                        });
+                                                                        return [
+                                                                            2
+                                                                        ];
+                                                                }
+                                                            });
+                                                        };
+                                                        _iterator = runSteps[Symbol.iterator]();
+                                                        _state.label = 3;
+                                                    case 3:
+                                                        if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                                            3,
+                                                            6
+                                                        ];
+                                                        return [
+                                                            5,
+                                                            _ts_values(_loop())
+                                                        ];
+                                                    case 4:
+                                                        _state.sent();
+                                                        _state.label = 5;
+                                                    case 5:
+                                                        _iteratorNormalCompletion = true;
+                                                        return [
+                                                            3,
+                                                            3
+                                                        ];
+                                                    case 6:
+                                                        return [
+                                                            3,
+                                                            9
+                                                        ];
+                                                    case 7:
+                                                        err = _state.sent();
+                                                        _didIteratorError = true;
+                                                        _iteratorError = err;
+                                                        return [
+                                                            3,
+                                                            9
+                                                        ];
+                                                    case 8:
+                                                        try {
+                                                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                                _iterator.return();
+                                                            }
+                                                        } finally{
+                                                            if (_didIteratorError) {
+                                                                throw _iteratorError;
+                                                            }
+                                                        }
+                                                        return [
+                                                            7
+                                                        ];
+                                                    case 9:
+                                                        return [
+                                                            2,
+                                                            prisma2.run.update({
+                                                                where: {
+                                                                    id: runId
+                                                                },
+                                                                data: {
+                                                                    status: "QUEUED"
+                                                                }
+                                                            })
+                                                        ];
+                                                }
+                                            });
+                                        });
+                                        return function(prisma2) {
+                                            return _ref.apply(this, arguments);
+                                        };
+                                    }())
+                                ];
+                            case 1:
+                                run = _state.sent();
+                                return [
+                                    4,
+                                    runAdapter({
+                                        run: serializeRun({
+                                            run: run
+                                        }),
+                                        onEvent: onEvent({
+                                            controller: controller,
+                                            prisma: prisma
+                                        }),
+                                        // @ts-ignore-next-line
+                                        getMessages: getMessages({
+                                            prisma: prisma,
+                                            run: run
+                                        })
+                                    })
+                                ];
+                            case 2:
+                                _state.sent();
+                                console.log("Stream ended inside cloud storage");
+                                controller.close();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        });
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/steps/list.ts
+import { assign as assign7, last as last3 } from "radash";
+var list3 = function(param) {
+    var prisma = param.prisma;
+    return /*#__PURE__*/ _async_to_generator(function() {
+        var _len, args, _key, _last3, threadId, runId, _args_, _assign7, // @ts-ignore-next-line
+        limit, // @ts-ignore-next-line
+        order, runSteps, _last3_id;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    for(_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                        args[_key] = _arguments[_key];
+                    }
+                    threadId = args[0];
+                    runId = args[1];
+                    _assign7 = assign7({
+                        // @ts-ignore-next-line
+                        limit: 20,
+                        order: "desc"
+                    }, (_args_ = args[2]) !== null && _args_ !== void 0 ? _args_ : {}), limit = _assign7.limit, order = _assign7.order;
+                    return [
+                        4,
+                        prisma.runStep.findMany({
+                            where: {
+                                threadId: threadId,
+                                runId: runId
+                            },
+                            take: limit,
+                            orderBy: {
+                                createdAt: order
+                            }
+                        })
+                    ];
+                case 1:
+                    runSteps = _state.sent();
+                    return [
+                        2,
+                        {
+                            data: runSteps.map(function(runStep) {
+                                return serializeRunStep({
+                                    runStep: runStep
+                                });
+                            }),
+                            hasNextPage: function() {
+                                return false;
+                            },
+                            body: {
+                                last_id: (_last3_id = (_last3 = last3(runSteps)) === null || _last3 === void 0 ? void 0 : _last3.id) !== null && _last3_id !== void 0 ? _last3_id : null
+                            }
+                        }
+                    ];
+            }
+        });
+    });
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/steps/index.ts
+var steps = function(param) {
+    var prisma = param.prisma;
+    return {
+        list: list3({
+            prisma: prisma
+        })
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/runs/index.ts
+var runs = function(param) {
+    var prisma = param.prisma, runAdapter = param.runAdapter;
+    return {
+        list: list2({
+            prisma: prisma
+        }),
+        create: create3({
+            prisma: prisma
+        }),
+        createAndStream: createAndStream({
+            prisma: prisma,
+            runAdapter: runAdapter
+        }),
+        submitToolOutputs: submitToolOutputs({
+            prisma: prisma,
+            runAdapter: runAdapter
+        }),
+        submitToolOutputsStream: submitToolOutputsStream({
+            prisma: prisma,
+            runAdapter: runAdapter
+        }),
+        steps: steps({
+            prisma: prisma
+        })
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/threads/index.ts
+var threads = function(param) {
+    var prisma = param.prisma, runAdapter = param.runAdapter;
+    return {
+        create: create({
+            prisma: prisma
+        }),
+        messages: messages2({
+            prisma: prisma
+        }),
+        runs: runs({
+            prisma: prisma,
+            runAdapter: runAdapter
+        })
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/beta/index.ts
+var beta = function(param) {
+    var prisma = param.prisma, runAdapter = param.runAdapter;
+    return {
+        threads: threads({
+            prisma: prisma,
+            runAdapter: runAdapter
+        })
+    };
+};
+// src/adapters/storage/prismaStorageAdapter/index.ts
+var prismaStorageAdapter = function(param) {
+    var prisma = param.prisma;
+    return function(param) {
+        var runAdapter = param.runAdapter;
+        return {
+            beta: beta({
+                prisma: prisma,
+                runAdapter: runAdapter
+            })
+        };
+    };
+};
+export { completionsRunAdapter, mistralClientAdapter, perplexityClientAdapter, prismaStorageAdapter, supercompat };
+//# sourceMappingURL=index.js.map