modelfusion 0.33.1 → 0.34.0

package/{model-function/generate-text → event-source}/AsyncQueue.cjs

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncQueue = void 0;
-/**
- * @internal
- */
 class AsyncQueue {
     constructor() {
         Object.defineProperty(this, "queue", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
         Object.defineProperty(this, "resolvers", {
             enumerable: true,
@@ -22,11 +19,8 @@ class AsyncQueue {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: false
         });
-        this.queue = [];
-        this.resolvers = [];
-        this.closed = false;
     }
     push(value) {
         if (this.closed) {
@@ -43,6 +37,7 @@ class AsyncQueue {
     close() {
         while (this.resolvers.length) {
             const resolve = this.resolvers.shift();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             resolve?.({ value: undefined, done: true });
         }
         this.closed = true;
@@ -51,13 +46,19 @@ class AsyncQueue {
         return {
             next: () => {
                 if (this.queue.length > 0) {
-                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                    return Promise.resolve({
+                        value: this.queue.shift(),
+                        done: false,
+                    });
                 }
                 else if (this.closed) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     return Promise.resolve({ value: undefined, done: true });
                 }
                 else {
-                    return new Promise((resolve) => this.resolvers.push(resolve));
+                    return new Promise((resolve) => {
+                        this.resolvers.push(resolve);
+                    });
                 }
             },
         };

package/event-source/AsyncQueue.d.ts

@@ -0,0 +1,8 @@
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    private closed;
+    push(value: T): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/{model-function/generate-text → event-source}/AsyncQueue.js

@@ -1,13 +1,10 @@
-/**
- * @internal
- */
 export class AsyncQueue {
     constructor() {
         Object.defineProperty(this, "queue", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
         Object.defineProperty(this, "resolvers", {
             enumerable: true,
@@ -19,11 +16,8 @@ export class AsyncQueue {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: false
         });
-        this.queue = [];
-        this.resolvers = [];
-        this.closed = false;
     }
     push(value) {
         if (this.closed) {
@@ -40,6 +34,7 @@ export class AsyncQueue {
     close() {
         while (this.resolvers.length) {
             const resolve = this.resolvers.shift();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             resolve?.({ value: undefined, done: true });
         }
         this.closed = true;
@@ -48,13 +43,19 @@ export class AsyncQueue {
         return {
             next: () => {
                 if (this.queue.length > 0) {
-                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                    return Promise.resolve({
+                        value: this.queue.shift(),
+                        done: false,
+                    });
                 }
                 else if (this.closed) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     return Promise.resolve({ value: undefined, done: true });
                 }
                 else {
-                    return new Promise((resolve) => this.resolvers.push(resolve));
+                    return new Promise((resolve) => {
+                        this.resolvers.push(resolve);
+                    });
                 }
             },
         };

package/event-source/EventSourceParserStream.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourceParserStream = void 0;
+const eventsource_parser_1 = require("eventsource-parser");
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
+ *
+ * @example
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ */
+// Copied from https://github.com/rexxars/eventsource-parser/blob/main/src/stream.ts to avoid issues with the commonjs build.
+class EventSourceParserStream extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = (0, eventsource_parser_1.createParser)((event) => {
+                    if (event.type === "event") {
+                        controller.enqueue(event);
+                    }
+                });
+            },
+            transform(chunk) {
+                parser.feed(chunk);
+            },
+        });
+    }
+}
+exports.EventSourceParserStream = EventSourceParserStream;

package/event-source/EventSourceParserStream.d.ts

@@ -0,0 +1,15 @@
+import { ParsedEvent } from "eventsource-parser";
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
+ *
+ * @example
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ */
+export declare class EventSourceParserStream extends TransformStream<string, ParsedEvent> {
+    constructor();
+}

package/event-source/EventSourceParserStream.js

@@ -0,0 +1,30 @@
+import { createParser, } from "eventsource-parser";
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
+ *
+ * @example
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ */
+// Copied from https://github.com/rexxars/eventsource-parser/blob/main/src/stream.ts to avoid issues with the commonjs build.
+export class EventSourceParserStream extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = createParser((event) => {
+                    if (event.type === "event") {
+                        controller.enqueue(event);
+                    }
+                });
+            },
+            transform(chunk) {
+                parser.feed(chunk);
+            },
+        });
+    }
+}

package/event-source/convertReadableStreamToAsyncIterable.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertReadableStreamToAsyncIterable = void 0;
+async function* convertReadableStreamToAsyncIterable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return; // This will close the generator
+            }
+            yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+exports.convertReadableStreamToAsyncIterable = convertReadableStreamToAsyncIterable;

package/event-source/convertReadableStreamToAsyncIterable.d.ts

@@ -0,0 +1 @@
+export declare function convertReadableStreamToAsyncIterable<T>(stream: ReadableStream<T>): AsyncIterable<T>;

package/event-source/convertReadableStreamToAsyncIterable.js

@@ -0,0 +1,15 @@
+export async function* convertReadableStreamToAsyncIterable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return; // This will close the generator
+            }
+            yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/event-source/createEventSourceStream.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventSourceStream = void 0;
+const textEncoder = new TextEncoder();
+function createEventSourceStream(events) {
+    return new ReadableStream({
+        async start(controller) {
+            for await (const event of events) {
+                controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+            }
+            controller.close();
+        },
+    });
+}
+exports.createEventSourceStream = createEventSourceStream;

package/event-source/createEventSourceStream.d.ts

@@ -0,0 +1 @@
+export declare function createEventSourceStream(events: AsyncIterable<unknown>): ReadableStream<any>;

package/event-source/createEventSourceStream.js

@@ -0,0 +1,11 @@
+const textEncoder = new TextEncoder();
+export function createEventSourceStream(events) {
+    return new ReadableStream({
+        async start(controller) {
+            for await (const event of events) {
+                controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+            }
+            controller.close();
+        },
+    });
+}

package/event-source/index.cjs

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

package/event-source/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./AsyncQueue.js";
+export * from "./createEventSourceStream.js";
+export * from "./readEventSourceStream.js";

package/event-source/index.js

@@ -0,0 +1,3 @@
+export * from "./AsyncQueue.js";
+export * from "./createEventSourceStream.js";
+export * from "./readEventSourceStream.js";

package/event-source/parseEventSourceStream.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEventSourceStream = void 0;
+const convertReadableStreamToAsyncIterable_js_1 = require("./convertReadableStreamToAsyncIterable.cjs");
+const EventSourceParserStream_js_1 = require("./EventSourceParserStream.cjs");
+async function parseEventSourceStream({ stream, }) {
+    const eventStream = stream
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new EventSourceParserStream_js_1.EventSourceParserStream());
+    return (0, convertReadableStreamToAsyncIterable_js_1.convertReadableStreamToAsyncIterable)(eventStream);
+}
+exports.parseEventSourceStream = parseEventSourceStream;

package/event-source/parseEventSourceStream.d.ts

@@ -0,0 +1,4 @@
+import { ParsedEvent } from "eventsource-parser";
+export declare function parseEventSourceStream({ stream, }: {
+    stream: ReadableStream<Uint8Array>;
+}): Promise<AsyncIterable<ParsedEvent>>;

package/event-source/parseEventSourceStream.js

@@ -0,0 +1,8 @@
+import { convertReadableStreamToAsyncIterable } from "./convertReadableStreamToAsyncIterable.js";
+import { EventSourceParserStream } from "./EventSourceParserStream.js";
+export async function parseEventSourceStream({ stream, }) {
+    const eventStream = stream
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new EventSourceParserStream());
+    return convertReadableStreamToAsyncIterable(eventStream);
+}

package/event-source/readEventSourceStream.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEventSourceStream = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("./parseEventSourceStream.cjs");
+function readEventSourceStream({ stream, schema, errorHandler, }) {
+    const queue = new AsyncQueue_js_1.AsyncQueue();
+    // run async (no await on purpose):
+    (0, parseEventSourceStream_js_1.parseEventSourceStream)({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                queue.push(schema.parse(secure_json_parse_1.default.parse(event.data)));
+            }
+        }
+        catch (error) {
+            errorHandler?.(error);
+        }
+        finally {
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        errorHandler?.(error);
+        queue.close();
+    });
+    return queue;
+}
+exports.readEventSourceStream = readEventSourceStream;

package/event-source/readEventSourceStream.d.ts

@@ -0,0 +1,6 @@
+import { ErrorHandler } from "../util/ErrorHandler.js";
+export declare function readEventSourceStream<T>({ stream, schema, errorHandler, }: {
+    stream: ReadableStream<Uint8Array>;
+    schema: Zod.Schema<T>;
+    errorHandler?: ErrorHandler;
+}): AsyncIterable<T>;

package/event-source/readEventSourceStream.js

@@ -0,0 +1,26 @@
+import SecureJSON from "secure-json-parse";
+import { AsyncQueue } from "./AsyncQueue.js";
+import { parseEventSourceStream } from "./parseEventSourceStream.js";
+export function readEventSourceStream({ stream, schema, errorHandler, }) {
+    const queue = new AsyncQueue();
+    // run async (no await on purpose):
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                queue.push(schema.parse(SecureJSON.parse(event.data)));
+            }
+        }
+        catch (error) {
+            errorHandler?.(error);
+        }
+        finally {
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        errorHandler?.(error);
+        queue.close();
+    });
+    return queue;
+}

package/index.cjs

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./composed-function/index.cjs"), exports);
 __exportStar(require("./core/index.cjs"), exports);
 __exportStar(require("./cost/index.cjs"), exports);
+__exportStar(require("./event-source/index.cjs"), exports);
 __exportStar(require("./model-function/index.cjs"), exports);
 __exportStar(require("./model-provider/index.cjs"), exports);
 __exportStar(require("./observability/index.cjs"), exports);

package/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./composed-function/index.js";
 export * from "./core/index.js";
 export * from "./cost/index.js";
+export * from "./event-source/index.js";
 export * from "./model-function/index.js";
 export * from "./model-provider/index.js";
 export * from "./observability/index.js";

package/index.js

@@ -1,6 +1,7 @@
 export * from "./composed-function/index.js";
 export * from "./core/index.js";
 export * from "./cost/index.js";
+export * from "./event-source/index.js";
 export * from "./model-function/index.js";
 export * from "./model-provider/index.js";
 export * from "./observability/index.js";

package/model-function/index.cjs

@@ -37,7 +37,6 @@ __exportStar(require("./generate-structure/StructureValidationError.cjs"), expor
 __exportStar(require("./generate-structure/generateStructure.cjs"), exports);
 __exportStar(require("./generate-structure/generateStructureOrText.cjs"), exports);
 __exportStar(require("./generate-text/DeltaEvent.cjs"), exports);
-__exportStar(require("./generate-text/TextDeltaEventSource.cjs"), exports);
 __exportStar(require("./generate-text/TextGenerationEvent.cjs"), exports);
 __exportStar(require("./generate-text/TextGenerationModel.cjs"), exports);
 __exportStar(require("./generate-text/TextStreamingEvent.cjs"), exports);

package/model-function/index.d.ts

@@ -21,7 +21,6 @@ export * from "./generate-structure/StructureValidationError.js";
 export * from "./generate-structure/generateStructure.js";
 export * from "./generate-structure/generateStructureOrText.js";
 export * from "./generate-text/DeltaEvent.js";
-export * from "./generate-text/TextDeltaEventSource.js";
 export * from "./generate-text/TextGenerationEvent.js";
 export * from "./generate-text/TextGenerationModel.js";
 export * from "./generate-text/TextStreamingEvent.js";

package/model-function/index.js

@@ -21,7 +21,6 @@ export * from "./generate-structure/StructureValidationError.js";
 export * from "./generate-structure/generateStructure.js";
 export * from "./generate-structure/generateStructureOrText.js";
 export * from "./generate-text/DeltaEvent.js";
-export * from "./generate-text/TextDeltaEventSource.js";
 export * from "./generate-text/TextGenerationEvent.js";
 export * from "./generate-text/TextGenerationModel.js";
 export * from "./generate-text/TextStreamingEvent.js";

package/model-provider/cohere/CohereTextGenerationModel.cjs

@@ -7,7 +7,7 @@ exports.CohereTextGenerationResponseFormat = exports.CohereTextGenerationModel =
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
-const AsyncQueue_js_1 = require("../../model-function/generate-text/AsyncQueue.cjs");
+const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
 const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
 const PromptFormatTextGenerationModel_js_1 = require("../../prompt/PromptFormatTextGenerationModel.cjs");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");

package/model-provider/cohere/CohereTextGenerationModel.js

@@ -1,7 +1,7 @@
 import SecureJSON from "secure-json-parse";
 import { z } from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { AsyncQueue } from "../../model-function/generate-text/AsyncQueue.js";
+import { AsyncQueue } from "../../event-source/AsyncQueue.js";
 import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
 import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";

package/model-provider/llamacpp/LlamaCppTextGenerationModel.cjs

@@ -7,8 +7,8 @@ exports.LlamaCppTextGenerationResponseFormat = exports.LlamaCppTextGenerationMod
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = __importDefault(require("zod"));
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
-const AsyncQueue_js_1 = require("../../model-function/generate-text/AsyncQueue.cjs");
-const parseEventSourceReadableStream_js_1 = require("../../model-function/generate-text/parseEventSourceReadableStream.cjs");
+const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const PromptFormatTextGenerationModel_js_1 = require("../../prompt/PromptFormatTextGenerationModel.cjs");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
@@ -215,14 +215,11 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue_js_1.AsyncQueue();
     let content = "";
     // process the stream asynchonously (no 'await' on purpose):
-    (0, parseEventSourceReadableStream_js_1.parseEventSourceReadableStream)({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            try {
+    (0, parseEventSourceStream_js_1.parseEventSourceStream)({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
                 const json = secure_json_parse_1.default.parse(data);
                 const parseResult = llamaCppTextStreamingResponseSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -233,26 +230,29 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                content += event.content;
+                const eventData = parseResult.data;
+                content += eventData.content;
                 queue.push({
                     type: "delta",
                     fullDelta: {
                         content,
-                        isComplete: event.stop,
-                        delta: event.content,
+                        isComplete: eventData.stop,
+                        delta: eventData.content,
                     },
                 });
-                if (event.stop) {
+                if (eventData.stop) {
                     queue.close();
                 }
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
     });
     return queue;
 }

package/model-provider/llamacpp/LlamaCppTextGenerationModel.js

@@ -1,8 +1,8 @@
 import SecureJSON from "secure-json-parse";
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { AsyncQueue } from "../../model-function/generate-text/AsyncQueue.js";
-import { parseEventSourceReadableStream } from "../../model-function/generate-text/parseEventSourceReadableStream.js";
+import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
@@ -208,14 +208,11 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue();
     let content = "";
     // process the stream asynchonously (no 'await' on purpose):
-    parseEventSourceReadableStream({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            try {
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
                 const json = SecureJSON.parse(data);
                 const parseResult = llamaCppTextStreamingResponseSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -226,26 +223,29 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                content += event.content;
+                const eventData = parseResult.data;
+                content += eventData.content;
                 queue.push({
                     type: "delta",
                     fullDelta: {
                         content,
-                        isComplete: event.stop,
-                        delta: event.content,
+                        isComplete: eventData.stop,
+                        delta: eventData.content,
                     },
                 });
-                if (event.stop) {
+                if (eventData.stop) {
                     queue.close();
                 }
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
     });
     return queue;
 }

package/model-provider/openai/OpenAITextGenerationModel.cjs

@@ -7,8 +7,8 @@ exports.OpenAITextResponseFormat = exports.OpenAITextGenerationModel = exports.c
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = __importDefault(require("zod"));
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
-const AsyncQueue_js_1 = require("../../model-function/generate-text/AsyncQueue.cjs");
-const parseEventSourceReadableStream_js_1 = require("../../model-function/generate-text/parseEventSourceReadableStream.cjs");
+const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
 const PromptFormatTextGenerationModel_js_1 = require("../../prompt/PromptFormatTextGenerationModel.cjs");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
@@ -335,18 +335,15 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue_js_1.AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
-    (0, parseEventSourceReadableStream_js_1.parseEventSourceReadableStream)({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            if (data === "[DONE]") {
-                queue.close();
-                return;
-            }
-            try {
+    (0, parseEventSourceStream_js_1.parseEventSourceStream)({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
+                if (data === "[DONE]") {
+                    queue.close();
+                    return;
+                }
                 const json = secure_json_parse_1.default.parse(data);
                 const parseResult = textResponseStreamEventSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -357,9 +354,9 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                for (let i = 0; i < event.choices.length; i++) {
-                    const eventChoice = event.choices[i];
+                const eventData = parseResult.data;
+                for (let i = 0; i < eventData.choices.length; i++) {
+                    const eventChoice = eventData.choices[i];
                     const delta = eventChoice.text;
                     if (streamDelta[i] == null) {
                         streamDelta[i] = {
@@ -383,12 +380,17 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                     fullDelta: streamDeltaDeepCopy,
                 });
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
     });
     return queue;
 }

package/model-provider/openai/OpenAITextGenerationModel.js

@@ -1,8 +1,8 @@
 import SecureJSON from "secure-json-parse";
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { AsyncQueue } from "../../model-function/generate-text/AsyncQueue.js";
-import { parseEventSourceReadableStream } from "../../model-function/generate-text/parseEventSourceReadableStream.js";
+import { AsyncQueue } from "../../event-source/AsyncQueue.js";
+import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
 import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
@@ -325,18 +325,15 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
-    parseEventSourceReadableStream({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            if (data === "[DONE]") {
-                queue.close();
-                return;
-            }
-            try {
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
+                if (data === "[DONE]") {
+                    queue.close();
+                    return;
+                }
                 const json = SecureJSON.parse(data);
                 const parseResult = textResponseStreamEventSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -347,9 +344,9 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                for (let i = 0; i < event.choices.length; i++) {
-                    const eventChoice = event.choices[i];
+                const eventData = parseResult.data;
+                for (let i = 0; i < eventData.choices.length; i++) {
+                    const eventChoice = eventData.choices[i];
                     const delta = eventChoice.text;
                     if (streamDelta[i] == null) {
                         streamDelta[i] = {
@@ -373,12 +370,17 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                     fullDelta: streamDeltaDeepCopy,
                 });
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
     });
     return queue;
 }

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

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOpenAIChatFullDeltaIterableQueue = void 0;
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
-const AsyncQueue_js_1 = require("../../../model-function/generate-text/AsyncQueue.cjs");
-const parseEventSourceReadableStream_js_1 = require("../../../model-function/generate-text/parseEventSourceReadableStream.cjs");
+const AsyncQueue_js_1 = require("../../../event-source/AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("../../../event-source/parseEventSourceStream.cjs");
 const chatResponseStreamEventSchema = zod_1.z.object({
     choices: zod_1.z.array(zod_1.z.object({
         delta: zod_1.z.object({
@@ -32,18 +32,15 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue_js_1.AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
-    (0, parseEventSourceReadableStream_js_1.parseEventSourceReadableStream)({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            if (data === "[DONE]") {
-                queue.close();
-                return;
-            }
-            try {
+    (0, parseEventSourceStream_js_1.parseEventSourceStream)({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
+                if (data === "[DONE]") {
+                    queue.close();
+                    return;
+                }
                 const json = secure_json_parse_1.default.parse(data);
                 const parseResult = chatResponseStreamEventSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -54,9 +51,9 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                for (let i = 0; i < event.choices.length; i++) {
-                    const eventChoice = event.choices[i];
+                const eventData = parseResult.data;
+                for (let i = 0; i < eventData.choices.length; i++) {
+                    const eventChoice = eventData.choices[i];
                     const delta = eventChoice.delta;
                     if (streamDelta[i] == null) {
                         streamDelta[i] = {
@@ -85,7 +82,8 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
                             choice.function_call.name += delta.function_call.name;
                         }
                         if (delta.function_call.arguments != undefined) {
-                            choice.function_call.arguments += delta.function_call.arguments;
+                            choice.function_call.arguments +=
+                                delta.function_call.arguments;
                         }
                     }
                     if (delta.role != undefined) {
@@ -100,12 +98,17 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
                     fullDelta: streamDeltaDeepCopy,
                 });
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
     });
     return queue;
 }

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

@@ -1,7 +1,7 @@
 import SecureJSON from "secure-json-parse";
 import { z } from "zod";
-import { AsyncQueue } from "../../../model-function/generate-text/AsyncQueue.js";
-import { parseEventSourceReadableStream } from "../../../model-function/generate-text/parseEventSourceReadableStream.js";
+import { AsyncQueue } from "../../../event-source/AsyncQueue.js";
+import { parseEventSourceStream } from "../../../event-source/parseEventSourceStream.js";
 const chatResponseStreamEventSchema = z.object({
     choices: z.array(z.object({
         delta: z.object({
@@ -26,18 +26,15 @@ export async function createOpenAIChatFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
-    parseEventSourceReadableStream({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            const data = event.data;
-            if (data === "[DONE]") {
-                queue.close();
-                return;
-            }
-            try {
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
+                if (data === "[DONE]") {
+                    queue.close();
+                    return;
+                }
                 const json = SecureJSON.parse(data);
                 const parseResult = chatResponseStreamEventSchema.safeParse(json);
                 if (!parseResult.success) {
@@ -48,9 +45,9 @@ export async function createOpenAIChatFullDeltaIterableQueue(stream) {
                     queue.close();
                     return;
                 }
-                const event = parseResult.data;
-                for (let i = 0; i < event.choices.length; i++) {
-                    const eventChoice = event.choices[i];
+                const eventData = parseResult.data;
+                for (let i = 0; i < eventData.choices.length; i++) {
+                    const eventChoice = eventData.choices[i];
                     const delta = eventChoice.delta;
                     if (streamDelta[i] == null) {
                         streamDelta[i] = {
@@ -79,7 +76,8 @@ export async function createOpenAIChatFullDeltaIterableQueue(stream) {
                             choice.function_call.name += delta.function_call.name;
                         }
                         if (delta.function_call.arguments != undefined) {
-                            choice.function_call.arguments += delta.function_call.arguments;
+                            choice.function_call.arguments +=
+                                delta.function_call.arguments;
                         }
                     }
                     if (delta.role != undefined) {
@@ -94,12 +92,17 @@ export async function createOpenAIChatFullDeltaIterableQueue(stream) {
                     fullDelta: streamDeltaDeepCopy,
                 });
             }
-            catch (error) {
-                queue.push({ type: "error", error });
-                queue.close();
-                return;
-            }
-        },
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
     });
     return queue;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.33.1",
+  "version": "0.34.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -51,7 +51,7 @@
     "dist": "npm run clean && npm run lint && npm run build && npm run dist:copy-files"
   },
   "dependencies": {
-    "eventsource-parser": "1.0.0",
+    "eventsource-parser": "1.1.1",
     "js-tiktoken": "1.0.7",
     "nanoid": "3.3.6",
     "secure-json-parse": "2.7.0",

package/model-function/generate-text/AsyncQueue.d.ts

@@ -1,17 +0,0 @@
-/**
- * @internal
- */
-export declare class AsyncQueue<T> implements AsyncIterable<T | undefined> {
-    queue: T[];
-    resolvers: Array<(options: {
-        value: T | undefined;
-        done: boolean;
-    }) => void>;
-    closed: boolean;
-    constructor();
-    push(value: T): void;
-    close(): void;
-    [Symbol.asyncIterator](): {
-        next: () => Promise<IteratorResult<T | undefined, T | undefined>>;
-    };
-}

package/model-function/generate-text/TextDeltaEventSource.cjs

@@ -1,54 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTextDeltaEventSource = exports.createTextDeltaEventSource = void 0;
-const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
-const zod_1 = require("zod");
-const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
-const parseEventSourceReadableStream_js_1 = require("./parseEventSourceReadableStream.cjs");
-const textEncoder = new TextEncoder();
-const textDeltaEventDataSchema = zod_1.z.object({
-    textDelta: zod_1.z.string().optional(),
-    isFinished: zod_1.z.boolean(),
-});
-function enqueueData(controller, data) {
-    controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(data)}\n\n`));
-}
-function createTextDeltaEventSource(textDeltas) {
-    return new ReadableStream({
-        async start(controller) {
-            for await (const textDelta of textDeltas) {
-                enqueueData(controller, { textDelta, isFinished: false });
-            }
-            enqueueData(controller, { isFinished: true });
-        },
-    });
-}
-exports.createTextDeltaEventSource = createTextDeltaEventSource;
-function parseTextDeltaEventSource(stream, options) {
-    const queue = new AsyncQueue_js_1.AsyncQueue();
-    // run async (no await on purpose):
-    (0, parseEventSourceReadableStream_js_1.parseEventSourceReadableStream)({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            try {
-                const data = textDeltaEventDataSchema.parse(secure_json_parse_1.default.parse(event.data));
-                queue.push(data.textDelta);
-                if (data.isFinished) {
-                    queue.close();
-                }
-            }
-            catch (error) {
-                options?.errorHandler(error);
-                queue.close();
-            }
-        },
-    });
-    return queue;
-}
-exports.parseTextDeltaEventSource = parseTextDeltaEventSource;

package/model-function/generate-text/TextDeltaEventSource.d.ts

@@ -1,5 +0,0 @@
-import { ErrorHandler } from "../../util/ErrorHandler.js";
-export declare function createTextDeltaEventSource(textDeltas: AsyncIterable<string>): ReadableStream<any>;
-export declare function parseTextDeltaEventSource(stream: ReadableStream<Uint8Array>, options?: {
-    errorHandler: ErrorHandler;
-}): AsyncIterable<string | undefined>;

package/model-function/generate-text/TextDeltaEventSource.js

@@ -1,46 +0,0 @@
-import SecureJSON from "secure-json-parse";
-import { z } from "zod";
-import { AsyncQueue } from "./AsyncQueue.js";
-import { parseEventSourceReadableStream } from "./parseEventSourceReadableStream.js";
-const textEncoder = new TextEncoder();
-const textDeltaEventDataSchema = z.object({
-    textDelta: z.string().optional(),
-    isFinished: z.boolean(),
-});
-function enqueueData(controller, data) {
-    controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(data)}\n\n`));
-}
-export function createTextDeltaEventSource(textDeltas) {
-    return new ReadableStream({
-        async start(controller) {
-            for await (const textDelta of textDeltas) {
-                enqueueData(controller, { textDelta, isFinished: false });
-            }
-            enqueueData(controller, { isFinished: true });
-        },
-    });
-}
-export function parseTextDeltaEventSource(stream, options) {
-    const queue = new AsyncQueue();
-    // run async (no await on purpose):
-    parseEventSourceReadableStream({
-        stream,
-        callback: (event) => {
-            if (event.type !== "event") {
-                return;
-            }
-            try {
-                const data = textDeltaEventDataSchema.parse(SecureJSON.parse(event.data));
-                queue.push(data.textDelta);
-                if (data.isFinished) {
-                    queue.close();
-                }
-            }
-            catch (error) {
-                options?.errorHandler(error);
-                queue.close();
-            }
-        },
-    });
-    return queue;
-}

package/model-function/generate-text/parseEventSourceReadableStream.cjs

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEventSourceReadableStream = void 0;
-const eventsource_parser_1 = require("eventsource-parser");
-async function* convertReadableStreamToAsyncIterable(reader) {
-    while (true) {
-        const result = await reader.read();
-        if (result.done) {
-            break;
-        }
-        yield result.value;
-    }
-}
-/**
- * @internal
- */
-async function parseEventSourceReadableStream({ stream, callback, }) {
-    try {
-        const parser = (0, eventsource_parser_1.createParser)(callback);
-        const decoder = new TextDecoder();
-        const iterable = convertReadableStreamToAsyncIterable(stream.getReader());
-        for await (const value of iterable) {
-            parser.feed(decoder.decode(value));
-        }
-    }
-    catch (error) {
-        console.error(error); // TODO introduce error handler param
-    }
-}
-exports.parseEventSourceReadableStream = parseEventSourceReadableStream;

package/model-function/generate-text/parseEventSourceReadableStream.d.ts

@@ -1,8 +0,0 @@
-import { EventSourceParseCallback } from "eventsource-parser";
-/**
- * @internal
- */
-export declare function parseEventSourceReadableStream({ stream, callback, }: {
-    stream: ReadableStream<Uint8Array>;
-    callback: EventSourceParseCallback;
-}): Promise<void>;

package/model-function/generate-text/parseEventSourceReadableStream.js

@@ -1,26 +0,0 @@
-import { createParser } from "eventsource-parser";
-async function* convertReadableStreamToAsyncIterable(reader) {
-    while (true) {
-        const result = await reader.read();
-        if (result.done) {
-            break;
-        }
-        yield result.value;
-    }
-}
-/**
- * @internal
- */
-export async function parseEventSourceReadableStream({ stream, callback, }) {
-    try {
-        const parser = createParser(callback);
-        const decoder = new TextDecoder();
-        const iterable = convertReadableStreamToAsyncIterable(stream.getReader());
-        for await (const value of iterable) {
-            parser.feed(decoder.decode(value));
-        }
-    }
-    catch (error) {
-        console.error(error); // TODO introduce error handler param
-    }
-}