modelfusion 0.54.0 → 0.55.0

package/model-provider/ollama/OllamaTextGenerationModel.cjs

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaTextGenerationResponseFormat = exports.OllamaTextGenerationModel = void 0;
+const zod_1 = require("zod");
+const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const PromptFormatTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptFormatTextStreamingModel.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
+const parseJsonStream_js_1 = require("../../util/streaming/parseJsonStream.cjs");
+const OllamaApiConfiguration_js_1 = require("./OllamaApiConfiguration.cjs");
+const OllamaError_js_1 = require("./OllamaError.cjs");
+class OllamaTextGenerationModel extends AbstractModel_js_1.AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ollama"
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get contextWindowSize() {
+        return this.settings.contextWindowSize;
+    }
+    async callAPI(prompt, options) {
+        return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOllamaTextGenerationAPI({
+                ...this.settings,
+                // other
+                abortSignal: options.run?.abortSignal,
+                prompt,
+                responseFormat: options.responseFormat,
+            }),
+        });
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            // "maxCompletionTokens",
+            // "stopSequences",
+            "contextWindowSize",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.OllamaTextGenerationResponseFormat.json,
+        });
+        return {
+            response,
+            text: response.response,
+        };
+    }
+    doStreamText(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.OllamaTextGenerationResponseFormat.deltaIterable,
+        });
+    }
+    withPromptFormat(promptFormat) {
+        return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
+            }),
+            promptFormat,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OllamaTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+exports.OllamaTextGenerationModel = OllamaTextGenerationModel;
+const ollamaTextGenerationResponseSchema = zod_1.z.object({
+    done: zod_1.z.literal(true),
+    model: zod_1.z.string(),
+    response: zod_1.z.string(),
+    total_duration: zod_1.z.number(),
+    load_duration: zod_1.z.number(),
+    prompt_eval_count: zod_1.z.number(),
+    eval_count: zod_1.z.number(),
+    eval_duration: zod_1.z.number(),
+    context: zod_1.z.array(zod_1.z.number()),
+});
+const ollamaTextStreamingResponseSchema = zod_1.z.discriminatedUnion("done", [
+    zod_1.z.object({
+        done: zod_1.z.literal(false),
+        model: zod_1.z.string(),
+        created_at: zod_1.z.string(),
+        response: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        done: zod_1.z.literal(true),
+        model: zod_1.z.string(),
+        created_at: zod_1.z.string(),
+        total_duration: zod_1.z.number(),
+        load_duration: zod_1.z.number(),
+        sample_count: zod_1.z.number().optional(),
+        sample_duration: zod_1.z.number().optional(),
+        prompt_eval_count: zod_1.z.number(),
+        prompt_eval_duration: zod_1.z.number().optional(),
+        eval_count: zod_1.z.number(),
+        eval_duration: zod_1.z.number(),
+        context: zod_1.z.array(zod_1.z.number()),
+    }),
+]);
+async function callOllamaTextGenerationAPI({ api = new OllamaApiConfiguration_js_1.OllamaApiConfiguration(), abortSignal, responseFormat, prompt, model, contextWindowSize, maxCompletionTokens, mirostat, mirostat_eta, mirostat_tau, num_gpu, num_gqa, num_threads, repeat_last_n, repeat_penalty, seed, stopSequences, temperature, tfs_z, top_k, top_p, system, template, context, }) {
+    return (0, postToApi_js_1.postJsonToApi)({
+        url: api.assembleUrl(`/api/generate`),
+        headers: api.headers,
+        body: {
+            stream: responseFormat.stream,
+            model,
+            prompt,
+            options: {
+                mirostat,
+                mirostat_eta,
+                mirostat_tau,
+                num_ctx: contextWindowSize,
+                num_gpu,
+                num_gqa,
+                num_predict: maxCompletionTokens,
+                num_threads,
+                repeat_last_n,
+                repeat_penalty,
+                seed,
+                stop: stopSequences,
+                temperature,
+                tfs_z,
+                top_k,
+                top_p,
+            },
+            system,
+            template,
+            context,
+        },
+        failedResponseHandler: OllamaError_js_1.failedOllamaCallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+async function createOllamaFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue_js_1.AsyncQueue();
+    let accumulatedText = "";
+    // process the stream asynchonously (no 'await' on purpose):
+    (0, parseJsonStream_js_1.parseJsonStream)({
+        stream,
+        schema: ollamaTextStreamingResponseSchema,
+        process(event) {
+            if (event.done === true) {
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content: accumulatedText,
+                        isComplete: true,
+                        delta: "",
+                    },
+                    valueDelta: "",
+                });
+            }
+            else {
+                accumulatedText += event.response;
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content: accumulatedText,
+                        isComplete: false,
+                        delta: event.response,
+                    },
+                    valueDelta: event.response,
+                });
+            }
+        },
+        onDone() {
+            queue.close();
+        },
+    });
+    return queue;
+}
+exports.OllamaTextGenerationResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: (0, postToApi_js_1.createJsonResponseHandler)(ollamaTextGenerationResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true,
+        handler: async ({ response }) => createOllamaFullDeltaIterableQueue(response.body),
+    },
+};

package/model-provider/ollama/OllamaTextGenerationModel.d.ts

@@ -0,0 +1,134 @@
+import { z } from "zod";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
+import { ResponseHandler } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { Delta } from "../../model-function/Delta.js";
+import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
+import { TextGenerationModelSettings, TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
+import { TextGenerationPromptFormat } from "../../model-function/generate-text/TextGenerationPromptFormat.js";
+export interface OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE extends number | undefined> extends TextGenerationModelSettings {
+    api?: ApiConfiguration;
+    model: string;
+    temperature?: number;
+    /**
+     * Specify the context window size of the model that you have loaded in your
+     * Ollama server.
+     */
+    contextWindowSize?: CONTEXT_WINDOW_SIZE;
+    mirostat?: number;
+    mirostat_eta?: number;
+    mirostat_tau?: number;
+    num_gqa?: number;
+    num_gpu?: number;
+    num_threads?: number;
+    repeat_last_n?: number;
+    repeat_penalty?: number;
+    seed?: number;
+    tfs_z?: number;
+    top_k?: number;
+    top_p?: number;
+    system?: string;
+    template?: string;
+    context?: number[];
+}
+export declare class OllamaTextGenerationModel<CONTEXT_WINDOW_SIZE extends number | undefined> extends AbstractModel<OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> implements TextStreamingModel<string, OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> {
+    constructor(settings: OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>);
+    readonly provider = "ollama";
+    get modelName(): string;
+    readonly tokenizer: undefined;
+    readonly countPromptTokens: undefined;
+    get contextWindowSize(): CONTEXT_WINDOW_SIZE;
+    callAPI<RESPONSE>(prompt: string, options: {
+        responseFormat: OllamaTextGenerationResponseFormatType<RESPONSE>;
+    } & FunctionOptions): Promise<RESPONSE>;
+    get settingsForEvent(): Partial<OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>;
+    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
+            response: string;
+            model: string;
+            done: true;
+            context: number[];
+            total_duration: number;
+            load_duration: number;
+            prompt_eval_count: number;
+            eval_count: number;
+            eval_duration: number;
+        };
+        text: string;
+    }>;
+    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: TextGenerationPromptFormat<INPUT_PROMPT, string>): PromptFormatTextStreamingModel<INPUT_PROMPT, string, OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
+    withSettings(additionalSettings: Partial<OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): this;
+}
+declare const ollamaTextGenerationResponseSchema: z.ZodObject<{
+    done: z.ZodLiteral<true>;
+    model: z.ZodString;
+    response: z.ZodString;
+    total_duration: z.ZodNumber;
+    load_duration: z.ZodNumber;
+    prompt_eval_count: z.ZodNumber;
+    eval_count: z.ZodNumber;
+    eval_duration: z.ZodNumber;
+    context: z.ZodArray<z.ZodNumber, "many">;
+}, "strip", z.ZodTypeAny, {
+    response: string;
+    model: string;
+    done: true;
+    context: number[];
+    total_duration: number;
+    load_duration: number;
+    prompt_eval_count: number;
+    eval_count: number;
+    eval_duration: number;
+}, {
+    response: string;
+    model: string;
+    done: true;
+    context: number[];
+    total_duration: number;
+    load_duration: number;
+    prompt_eval_count: number;
+    eval_count: number;
+    eval_duration: number;
+}>;
+export type OllamaTextGenerationResponse = z.infer<typeof ollamaTextGenerationResponseSchema>;
+export type OllamaTextGenerationDelta = {
+    content: string;
+    isComplete: boolean;
+    delta: string;
+};
+export type OllamaTextGenerationResponseFormatType<T> = {
+    stream: boolean;
+    handler: ResponseHandler<T>;
+};
+export declare const OllamaTextGenerationResponseFormat: {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false;
+        handler: ResponseHandler<{
+            response: string;
+            model: string;
+            done: true;
+            context: number[];
+            total_duration: number;
+            load_duration: number;
+            prompt_eval_count: number;
+            eval_count: number;
+            eval_duration: number;
+        }>;
+    };
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true;
+        handler: ({ response }: {
+            response: Response;
+        }) => Promise<AsyncIterable<Delta<string>>>;
+    };
+};
+export {};

package/model-provider/ollama/OllamaTextGenerationModel.js

@@ -0,0 +1,212 @@
+import { z } from "zod";
+import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
+import { parseJsonStream } from "../../util/streaming/parseJsonStream.js";
+import { OllamaApiConfiguration } from "./OllamaApiConfiguration.js";
+import { failedOllamaCallResponseHandler } from "./OllamaError.js";
+export class OllamaTextGenerationModel extends AbstractModel {
+    constructor(settings) {
+        super({ settings });
+        Object.defineProperty(this, "provider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "ollama"
+        });
+        Object.defineProperty(this, "tokenizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+        Object.defineProperty(this, "countPromptTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    get modelName() {
+        return this.settings.model;
+    }
+    get contextWindowSize() {
+        return this.settings.contextWindowSize;
+    }
+    async callAPI(prompt, options) {
+        return callWithRetryAndThrottle({
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOllamaTextGenerationAPI({
+                ...this.settings,
+                // other
+                abortSignal: options.run?.abortSignal,
+                prompt,
+                responseFormat: options.responseFormat,
+            }),
+        });
+    }
+    get settingsForEvent() {
+        const eventSettingProperties = [
+            // "maxCompletionTokens",
+            // "stopSequences",
+            "contextWindowSize",
+        ];
+        return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
+    }
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: OllamaTextGenerationResponseFormat.json,
+        });
+        return {
+            response,
+            text: response.response,
+        };
+    }
+    doStreamText(prompt, options) {
+        return this.callAPI(prompt, {
+            ...options,
+            responseFormat: OllamaTextGenerationResponseFormat.deltaIterable,
+        });
+    }
+    withPromptFormat(promptFormat) {
+        return new PromptFormatTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
+            }),
+            promptFormat,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new OllamaTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
+    }
+}
+const ollamaTextGenerationResponseSchema = z.object({
+    done: z.literal(true),
+    model: z.string(),
+    response: z.string(),
+    total_duration: z.number(),
+    load_duration: z.number(),
+    prompt_eval_count: z.number(),
+    eval_count: z.number(),
+    eval_duration: z.number(),
+    context: z.array(z.number()),
+});
+const ollamaTextStreamingResponseSchema = z.discriminatedUnion("done", [
+    z.object({
+        done: z.literal(false),
+        model: z.string(),
+        created_at: z.string(),
+        response: z.string(),
+    }),
+    z.object({
+        done: z.literal(true),
+        model: z.string(),
+        created_at: z.string(),
+        total_duration: z.number(),
+        load_duration: z.number(),
+        sample_count: z.number().optional(),
+        sample_duration: z.number().optional(),
+        prompt_eval_count: z.number(),
+        prompt_eval_duration: z.number().optional(),
+        eval_count: z.number(),
+        eval_duration: z.number(),
+        context: z.array(z.number()),
+    }),
+]);
+async function callOllamaTextGenerationAPI({ api = new OllamaApiConfiguration(), abortSignal, responseFormat, prompt, model, contextWindowSize, maxCompletionTokens, mirostat, mirostat_eta, mirostat_tau, num_gpu, num_gqa, num_threads, repeat_last_n, repeat_penalty, seed, stopSequences, temperature, tfs_z, top_k, top_p, system, template, context, }) {
+    return postJsonToApi({
+        url: api.assembleUrl(`/api/generate`),
+        headers: api.headers,
+        body: {
+            stream: responseFormat.stream,
+            model,
+            prompt,
+            options: {
+                mirostat,
+                mirostat_eta,
+                mirostat_tau,
+                num_ctx: contextWindowSize,
+                num_gpu,
+                num_gqa,
+                num_predict: maxCompletionTokens,
+                num_threads,
+                repeat_last_n,
+                repeat_penalty,
+                seed,
+                stop: stopSequences,
+                temperature,
+                tfs_z,
+                top_k,
+                top_p,
+            },
+            system,
+            template,
+            context,
+        },
+        failedResponseHandler: failedOllamaCallResponseHandler,
+        successfulResponseHandler: responseFormat.handler,
+        abortSignal,
+    });
+}
+async function createOllamaFullDeltaIterableQueue(stream) {
+    const queue = new AsyncQueue();
+    let accumulatedText = "";
+    // process the stream asynchonously (no 'await' on purpose):
+    parseJsonStream({
+        stream,
+        schema: ollamaTextStreamingResponseSchema,
+        process(event) {
+            if (event.done === true) {
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content: accumulatedText,
+                        isComplete: true,
+                        delta: "",
+                    },
+                    valueDelta: "",
+                });
+            }
+            else {
+                accumulatedText += event.response;
+                queue.push({
+                    type: "delta",
+                    fullDelta: {
+                        content: accumulatedText,
+                        isComplete: false,
+                        delta: event.response,
+                    },
+                    valueDelta: event.response,
+                });
+            }
+        },
+        onDone() {
+            queue.close();
+        },
+    });
+    return queue;
+}
+export const OllamaTextGenerationResponseFormat = {
+    /**
+     * Returns the response as a JSON object.
+     */
+    json: {
+        stream: false,
+        handler: createJsonResponseHandler(ollamaTextGenerationResponseSchema),
+    },
+    /**
+     * Returns an async iterable over the full deltas (all choices, including full current state at time of event)
+     * of the response stream.
+     */
+    deltaIterable: {
+        stream: true,
+        handler: async ({ response }) => createOllamaFullDeltaIterableQueue(response.body),
+    },
+};

package/model-provider/ollama/index.cjs

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaError = void 0;
+__exportStar(require("./OllamaApiConfiguration.cjs"), exports);
+var OllamaError_js_1 = require("./OllamaError.cjs");
+Object.defineProperty(exports, "OllamaError", { enumerable: true, get: function () { return OllamaError_js_1.OllamaError; } });
+__exportStar(require("./OllamaTextGenerationModel.cjs"), exports);

package/model-provider/ollama/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./OllamaApiConfiguration.js";
+export { OllamaError, OllamaErrorData } from "./OllamaError.js";
+export * from "./OllamaTextGenerationModel.js";

package/model-provider/ollama/index.js

@@ -0,0 +1,3 @@
+export * from "./OllamaApiConfiguration.js";
+export { OllamaError } from "./OllamaError.js";
+export * from "./OllamaTextGenerationModel.js";

package/model-provider/openai/OpenAICompletionModel.cjs

@@ -4,13 +4,13 @@ exports.OpenAITextResponseFormat = exports.OpenAICompletionModel = exports.calcu
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
-const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
-const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const PromptFormatTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptFormatTextStreamingModel.cjs");
 const TextPromptFormat_js_1 = require("../../model-function/generate-text/TextPromptFormat.cjs");
 const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
+const AsyncQueue_js_1 = require("../../util/AsyncQueue.cjs");
 const parseJSON_js_1 = require("../../util/parseJSON.cjs");
+const parseEventSourceStream_js_1 = require("../../util/streaming/parseEventSourceStream.cjs");
 const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("./OpenAIError.cjs");
 const TikTokenTokenizer_js_1 = require("./TikTokenTokenizer.cjs");

package/model-provider/openai/OpenAICompletionModel.js

@@ -1,13 +1,13 @@
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { AsyncQueue } from "../../util/AsyncQueue.js";
-import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { PromptFormatTextStreamingModel } from "../../model-function/generate-text/PromptFormatTextStreamingModel.js";
 import { mapChatPromptToTextFormat, mapInstructionPromptToTextFormat, } from "../../model-function/generate-text/TextPromptFormat.js";
 import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
+import { AsyncQueue } from "../../util/AsyncQueue.js";
 import { parseJsonWithZod } from "../../util/parseJSON.js";
+import { parseEventSourceStream } from "../../util/streaming/parseEventSourceStream.js";
 import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";

package/model-provider/openai/chat/OpenAIChatStreamIterable.cjs

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAIChatDeltaIterableQueue = void 0;
 const zod_1 = require("zod");
 const AsyncQueue_js_1 = require("../../../util/AsyncQueue.cjs");
-const parseEventSourceStream_js_1 = require("../../../event-source/parseEventSourceStream.cjs");
+const parseEventSourceStream_js_1 = require("../../../util/streaming/parseEventSourceStream.cjs");
 const parseJSON_js_1 = require("../../../util/parseJSON.cjs");
 const chatResponseStreamEventSchema = zod_1.z.object({
     choices: zod_1.z.array(zod_1.z.object({

package/model-provider/openai/chat/OpenAIChatStreamIterable.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AsyncQueue } from "../../../util/AsyncQueue.js";
-import { parseEventSourceStream } from "../../../event-source/parseEventSourceStream.js";
+import { parseEventSourceStream } from "../../../util/streaming/parseEventSourceStream.js";
 import { safeParseJsonWithZod } from "../../../util/parseJSON.js";
 const chatResponseStreamEventSchema = z.object({
     choices: z.array(z.object({

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.54.0",
+  "version": "0.55.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/util/index.cjs

@@ -20,3 +20,4 @@ __exportStar(require("./cosineSimilarity.cjs"), exports);
 __exportStar(require("./delay.cjs"), exports);
 __exportStar(require("./getAudioFileExtension.cjs"), exports);
 __exportStar(require("./parseJSON.cjs"), exports);
+__exportStar(require("./streaming/index.cjs"), exports);

package/util/index.d.ts

@@ -4,3 +4,4 @@ export * from "./cosineSimilarity.js";
 export * from "./delay.js";
 export * from "./getAudioFileExtension.js";
 export * from "./parseJSON.js";
+export * from "./streaming/index.js";

package/util/index.js

@@ -4,3 +4,4 @@ export * from "./cosineSimilarity.js";
 export * from "./delay.js";
 export * from "./getAudioFileExtension.js";
 export * from "./parseJSON.js";
+export * from "./streaming/index.js";