modelfusion 0.104.0 → 0.105.0

package/model-provider/openai/{chat/countOpenAIChatMessageTokens.cjs → countOpenAIChatMessageTokens.cjs}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.countOpenAIChatPromptTokens = exports.countOpenAIChatMessageTokens = exports.OPENAI_CHAT_MESSAGE_BASE_TOKEN_COUNT = exports.OPENAI_CHAT_PROMPT_BASE_TOKEN_COUNT = void 0;
-const countTokens_js_1 = require("../../../model-function/tokenize-text/countTokens.cjs");
-const TikTokenTokenizer_js_1 = require("../TikTokenTokenizer.cjs");
+const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
+const TikTokenTokenizer_js_1 = require("./TikTokenTokenizer.cjs");
 const OpenAIChatModel_js_1 = require("./OpenAIChatModel.cjs");
 /**
  * Prompt tokens that are included automatically for every full

package/model-provider/openai/{chat/countOpenAIChatMessageTokens.js → countOpenAIChatMessageTokens.js}

@@ -1,5 +1,5 @@
-import { countTokens } from "../../../model-function/tokenize-text/countTokens.js";
-import { TikTokenTokenizer } from "../TikTokenTokenizer.js";
+import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
+import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
 import { getOpenAIChatModelInformation, } from "./OpenAIChatModel.js";
 /**
  * Prompt tokens that are included automatically for every full

package/model-provider/openai/index.cjs

@@ -26,9 +26,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenAIChatPrompt = exports.openai = void 0;
+exports.openai = exports.OpenAIChatPrompt = void 0;
+__exportStar(require("./AbstractOpenAIChatModel.cjs"), exports);
 __exportStar(require("./AzureOpenAIApiConfiguration.cjs"), exports);
 __exportStar(require("./OpenAIApiConfiguration.cjs"), exports);
+__exportStar(require("./OpenAIChatMessage.cjs"), exports);
+__exportStar(require("./OpenAIChatModel.cjs"), exports);
+exports.OpenAIChatPrompt = __importStar(require("./OpenAIChatPromptTemplate.cjs"));
 __exportStar(require("./OpenAICompletionModel.cjs"), exports);
 __exportStar(require("./OpenAICostCalculator.cjs"), exports);
 exports.openai = __importStar(require("./OpenAIFacade.cjs"));
@@ -37,8 +41,4 @@ __exportStar(require("./OpenAISpeechModel.cjs"), exports);
 __exportStar(require("./OpenAITextEmbeddingModel.cjs"), exports);
 __exportStar(require("./OpenAITranscriptionModel.cjs"), exports);
 __exportStar(require("./TikTokenTokenizer.cjs"), exports);
-__exportStar(require("./chat/AbstractOpenAIChatModel.cjs"), exports);
-__exportStar(require("./chat/OpenAIChatMessage.cjs"), exports);
-__exportStar(require("./chat/OpenAIChatModel.cjs"), exports);
-exports.OpenAIChatPrompt = __importStar(require("./chat/OpenAIChatPromptTemplate.cjs"));
-__exportStar(require("./chat/countOpenAIChatMessageTokens.cjs"), exports);
+__exportStar(require("./countOpenAIChatMessageTokens.cjs"), exports);

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

@@ -1,5 +1,9 @@
+export * from "./AbstractOpenAIChatModel.js";
 export * from "./AzureOpenAIApiConfiguration.js";
 export * from "./OpenAIApiConfiguration.js";
+export * from "./OpenAIChatMessage.js";
+export * from "./OpenAIChatModel.js";
+export * as OpenAIChatPrompt from "./OpenAIChatPromptTemplate.js";
 export * from "./OpenAICompletionModel.js";
 export * from "./OpenAICostCalculator.js";
 export { OpenAIErrorData } from "./OpenAIError.js";
@@ -9,9 +13,4 @@ export * from "./OpenAISpeechModel.js";
 export * from "./OpenAITextEmbeddingModel.js";
 export * from "./OpenAITranscriptionModel.js";
 export * from "./TikTokenTokenizer.js";
-export * from "./chat/AbstractOpenAIChatModel.js";
-export * from "./chat/OpenAIChatMessage.js";
-export * from "./chat/OpenAIChatModel.js";
-export * as OpenAIChatPrompt from "./chat/OpenAIChatPromptTemplate.js";
-export { OpenAIChatDelta } from "./chat/OpenAIChatStreamIterable.js";
-export * from "./chat/countOpenAIChatMessageTokens.js";
+export * from "./countOpenAIChatMessageTokens.js";

package/model-provider/openai/index.js

@@ -1,5 +1,9 @@
+export * from "./AbstractOpenAIChatModel.js";
 export * from "./AzureOpenAIApiConfiguration.js";
 export * from "./OpenAIApiConfiguration.js";
+export * from "./OpenAIChatMessage.js";
+export * from "./OpenAIChatModel.js";
+export * as OpenAIChatPrompt from "./OpenAIChatPromptTemplate.js";
 export * from "./OpenAICompletionModel.js";
 export * from "./OpenAICostCalculator.js";
 export * as openai from "./OpenAIFacade.js";
@@ -8,8 +12,4 @@ export * from "./OpenAISpeechModel.js";
 export * from "./OpenAITextEmbeddingModel.js";
 export * from "./OpenAITranscriptionModel.js";
 export * from "./TikTokenTokenizer.js";
-export * from "./chat/AbstractOpenAIChatModel.js";
-export * from "./chat/OpenAIChatMessage.js";
-export * from "./chat/OpenAIChatModel.js";
-export * as OpenAIChatPrompt from "./chat/OpenAIChatPromptTemplate.js";
-export * from "./chat/countOpenAIChatMessageTokens.js";
+export * from "./countOpenAIChatMessageTokens.js";

package/model-provider/openai-compatible/OpenAICompatibleChatModel.cjs

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAICompatibleChatModel = void 0;
 const StructureFromTextStreamingModel_js_1 = require("../../model-function/generate-structure/StructureFromTextStreamingModel.cjs");
-const PromptTemplateTextStreamingModel_js_1 = require("../../model-function/generate-text/PromptTemplateTextStreamingModel.cjs");
+const PromptTemplateFullTextModel_js_1 = require("../../model-function/generate-text/PromptTemplateFullTextModel.cjs");
 const TextGenerationModel_js_1 = require("../../model-function/generate-text/TextGenerationModel.cjs");
-const AbstractOpenAIChatModel_js_1 = require("../openai/chat/AbstractOpenAIChatModel.cjs");
-const OpenAIChatPromptTemplate_js_1 = require("../openai/chat/OpenAIChatPromptTemplate.cjs");
+const AbstractOpenAIChatModel_js_1 = require("../openai/AbstractOpenAIChatModel.cjs");
+const OpenAIChatPromptTemplate_js_1 = require("../openai/OpenAIChatPromptTemplate.cjs");
 /**
  * Create a text generation model that calls an API that is compatible with OpenAI's chat API.
  *
@@ -82,7 +82,7 @@ class OpenAICompatibleChatModel extends AbstractOpenAIChatModel_js_1.AbstractOpe
         return this.withPromptTemplate((0, OpenAIChatPromptTemplate_js_1.chat)());
     }
     withPromptTemplate(promptTemplate) {
-        return new PromptTemplateTextStreamingModel_js_1.PromptTemplateTextStreamingModel({
+        return new PromptTemplateFullTextModel_js_1.PromptTemplateFullTextModel({
             model: this.withSettings({
                 stopSequences: [
                     ...(this.settings.stopSequences ?? []),

package/model-provider/openai-compatible/OpenAICompatibleChatModel.d.ts

@@ -1,11 +1,11 @@
 import { StructureFromTextPromptTemplate } from "../../model-function/generate-structure/StructureFromTextPromptTemplate.js";
 import { StructureFromTextStreamingModel } from "../../model-function/generate-structure/StructureFromTextStreamingModel.js";
-import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
+import { PromptTemplateFullTextModel } from "../../model-function/generate-text/PromptTemplateFullTextModel.js";
 import { TextGenerationModelSettings, TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
 import { TextGenerationPromptTemplate } from "../../model-function/generate-text/TextGenerationPromptTemplate.js";
 import { ToolCallGenerationModel } from "../../tool/generate-tool-call/ToolCallGenerationModel.js";
 import { ToolCallsOrTextGenerationModel } from "../../tool/generate-tool-calls-or-text/ToolCallsOrTextGenerationModel.js";
-import { AbstractOpenAIChatCallSettings, AbstractOpenAIChatModel, OpenAIChatPrompt } from "../openai/chat/AbstractOpenAIChatModel.js";
+import { AbstractOpenAIChatCallSettings, AbstractOpenAIChatModel, OpenAIChatPrompt } from "../openai/AbstractOpenAIChatModel.js";
 export type OpenAICompatibleProviderName = `openaicompatible` | `openaicompatible-${string}`;
 export interface OpenAICompatibleChatSettings extends TextGenerationModelSettings, Omit<AbstractOpenAIChatCallSettings, "stop" | "maxTokens"> {
     provider?: OpenAICompatibleProviderName;
@@ -31,15 +31,15 @@ export declare class OpenAICompatibleChatModel extends AbstractOpenAIChatModel<O
     /**
      * Returns this model with a text prompt template.
      */
-    withTextPrompt(): PromptTemplateTextStreamingModel<string, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
+    withTextPrompt(): PromptTemplateFullTextModel<string, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
     /**
      * Returns this model with an instruction prompt template.
      */
-    withInstructionPrompt(): PromptTemplateTextStreamingModel<import("../../index.js").InstructionPrompt, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
+    withInstructionPrompt(): PromptTemplateFullTextModel<import("../../index.js").InstructionPrompt, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
     /**
      * Returns this model with a chat prompt template.
      */
-    withChatPrompt(): PromptTemplateTextStreamingModel<import("../../index.js").ChatPrompt, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
-    withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, OpenAIChatPrompt>): PromptTemplateTextStreamingModel<INPUT_PROMPT, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
+    withChatPrompt(): PromptTemplateFullTextModel<import("../../index.js").ChatPrompt, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
+    withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, OpenAIChatPrompt>): PromptTemplateFullTextModel<INPUT_PROMPT, OpenAIChatPrompt, OpenAICompatibleChatSettings, this>;
     withSettings(additionalSettings: Partial<OpenAICompatibleChatSettings>): this;
 }

package/model-provider/openai-compatible/OpenAICompatibleChatModel.js

@@ -1,8 +1,8 @@
 import { StructureFromTextStreamingModel } from "../../model-function/generate-structure/StructureFromTextStreamingModel.js";
-import { PromptTemplateTextStreamingModel } from "../../model-function/generate-text/PromptTemplateTextStreamingModel.js";
+import { PromptTemplateFullTextModel } from "../../model-function/generate-text/PromptTemplateFullTextModel.js";
 import { textGenerationModelProperties, } from "../../model-function/generate-text/TextGenerationModel.js";
-import { AbstractOpenAIChatModel, } from "../openai/chat/AbstractOpenAIChatModel.js";
-import { chat, instruction, text, } from "../openai/chat/OpenAIChatPromptTemplate.js";
+import { AbstractOpenAIChatModel, } from "../openai/AbstractOpenAIChatModel.js";
+import { chat, instruction, text } from "../openai/OpenAIChatPromptTemplate.js";
 /**
  * Create a text generation model that calls an API that is compatible with OpenAI's chat API.
  *
@@ -79,7 +79,7 @@ export class OpenAICompatibleChatModel extends AbstractOpenAIChatModel {
         return this.withPromptTemplate(chat());
     }
     withPromptTemplate(promptTemplate) {
-        return new PromptTemplateTextStreamingModel({
+        return new PromptTemplateFullTextModel({
             model: this.withSettings({
                 stopSequences: [
                     ...(this.settings.stopSequences ?? []),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "The TypeScript library for building multi-modal AI applications.",
-  "version": "0.104.0",
+  "version": "0.105.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -61,15 +61,15 @@
   },
   "scripts": {
     "lint": "eslint --ext .ts src",
-    "clean": "rimraf build dist .turbo",
+    "clean": "rimraf build dist .turbo node_modules",
     "build": "pnpm build:esm && pnpm build:cjs && pnpm build:copy-files",
     "build:esm": "tsc --outDir dist/",
     "build:cjs": "tsc --outDir build/cjs/ -p tsconfig.cjs.json && node bin/prepare-cjs.js",
     "build:copy-files": "copyfiles --flat package.json ../../README.md ../../LICENSE ../../CHANGELOG.md dist",
     "test": "vitest --config vitest.config.js --run src",
-    "test:watch": "vitest watch--config vitest.config.js",
-    "test:coverage": "vitest run --coverage",
-    "test:coverage:ui": "vitest run --coverage --ui",
+    "test:watch": "vitest watch --config vitest.config.js",
+    "test:coverage": "vitest run --config vitest.config.js --coverage",
+    "test:coverage:ui": "vitest --config vitest.config.js --coverage --ui",
     "dist": "pnpm clean && pnpm lint && pnpm test && pnpm build"
   },
   "dependencies": {

package/test/JsonTestServer.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonTestServer = void 0;
+const msw_1 = require("msw");
+const node_1 = require("msw/node");
+class JsonTestServer {
+    constructor(url) {
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "responseBodyJson", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        const responseBodyJson = () => this.responseBodyJson;
+        this.server = (0, node_1.setupServer)(msw_1.http.post(url, () => msw_1.HttpResponse.json(responseBodyJson())));
+    }
+    setupTestEnvironment() {
+        beforeAll(() => this.server.listen());
+        beforeEach(() => {
+            this.responseBodyJson = {};
+        });
+        afterEach(() => this.server.resetHandlers());
+        afterAll(() => this.server.close());
+    }
+}
+exports.JsonTestServer = JsonTestServer;

package/test/JsonTestServer.d.ts

@@ -0,0 +1,7 @@
+import { SetupServer } from "msw/node";
+export declare class JsonTestServer {
+    readonly server: SetupServer;
+    responseBodyJson: any;
+    constructor(url: string);
+    setupTestEnvironment(): void;
+}

package/test/JsonTestServer.js

@@ -0,0 +1,29 @@
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+export class JsonTestServer {
+    constructor(url) {
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "responseBodyJson", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        const responseBodyJson = () => this.responseBodyJson;
+        this.server = setupServer(http.post(url, () => HttpResponse.json(responseBodyJson())));
+    }
+    setupTestEnvironment() {
+        beforeAll(() => this.server.listen());
+        beforeEach(() => {
+            this.responseBodyJson = {};
+        });
+        afterEach(() => this.server.resetHandlers());
+        afterAll(() => this.server.close());
+    }
+}

package/test/StreamingTestServer.cjs

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamingTestServer = void 0;
+const msw_1 = require("msw");
+const node_1 = require("msw/node");
+class StreamingTestServer {
+    constructor(url) {
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "responseChunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        const responseChunks = () => this.responseChunks;
+        this.server = (0, node_1.setupServer)(msw_1.http.post(url, () => {
+            const encoder = new TextEncoder();
+            const stream = new ReadableStream({
+                async start(controller) {
+                    try {
+                        for (const chunk of responseChunks()) {
+                            controller.enqueue(encoder.encode(chunk));
+                        }
+                    }
+                    finally {
+                        controller.close();
+                    }
+                },
+            });
+            return new msw_1.HttpResponse(stream, {
+                status: 200,
+                headers: {
+                    "Content-Type": "text/event-stream",
+                    "Cache-Control": "no-cache",
+                    Connection: "keep-alive",
+                },
+            });
+        }));
+    }
+    setupTestEnvironment() {
+        beforeAll(() => this.server.listen());
+        beforeEach(() => {
+            this.responseChunks = [];
+        });
+        afterEach(() => this.server.resetHandlers());
+        afterAll(() => this.server.close());
+    }
+}
+exports.StreamingTestServer = StreamingTestServer;

package/test/StreamingTestServer.d.ts

@@ -0,0 +1,7 @@
+import { SetupServer } from "msw/node";
+export declare class StreamingTestServer {
+    readonly server: SetupServer;
+    responseChunks: any[];
+    constructor(url: string);
+    setupTestEnvironment(): void;
+}

package/test/StreamingTestServer.js

@@ -0,0 +1,51 @@
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+export class StreamingTestServer {
+    constructor(url) {
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "responseChunks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        const responseChunks = () => this.responseChunks;
+        this.server = setupServer(http.post(url, () => {
+            const encoder = new TextEncoder();
+            const stream = new ReadableStream({
+                async start(controller) {
+                    try {
+                        for (const chunk of responseChunks()) {
+                            controller.enqueue(encoder.encode(chunk));
+                        }
+                    }
+                    finally {
+                        controller.close();
+                    }
+                },
+            });
+            return new HttpResponse(stream, {
+                status: 200,
+                headers: {
+                    "Content-Type": "text/event-stream",
+                    "Cache-Control": "no-cache",
+                    Connection: "keep-alive",
+                },
+            });
+        }));
+    }
+    setupTestEnvironment() {
+        beforeAll(() => this.server.listen());
+        beforeEach(() => {
+            this.responseChunks = [];
+        });
+        afterEach(() => this.server.resetHandlers());
+        afterAll(() => this.server.close());
+    }
+}

package/test/arrayFromAsync.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayFromAsync = void 0;
+// TODO once Array.fromAsync is in Node.js,
+// use Array.fromAsync instead of this function
+async function arrayFromAsync(iterable) {
+    const result = [];
+    for await (const item of iterable) {
+        result.push(item);
+    }
+    return result;
+}
+exports.arrayFromAsync = arrayFromAsync;

package/test/arrayFromAsync.d.ts

@@ -0,0 +1 @@
+export declare function arrayFromAsync<T>(iterable: AsyncIterable<T>): Promise<T[]>;

package/test/arrayFromAsync.js

@@ -0,0 +1,9 @@
+// TODO once Array.fromAsync is in Node.js,
+// use Array.fromAsync instead of this function
+export async function arrayFromAsync(iterable) {
+    const result = [];
+    for await (const item of iterable) {
+        result.push(item);
+    }
+    return result;
+}

package/util/streaming/createEventSourceResponseHandler.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventSourceResponseHandler = void 0;
+const parseEventSourceStreamAsAsyncIterable_js_1 = require("./parseEventSourceStreamAsAsyncIterable.cjs");
+const createEventSourceResponseHandler = (schema) => ({ response }) => (0, parseEventSourceStreamAsAsyncIterable_js_1.parseEventSourceStreamAsAsyncIterable)({
+    stream: response.body,
+    schema,
+});
+exports.createEventSourceResponseHandler = createEventSourceResponseHandler;

package/util/streaming/createEventSourceResponseHandler.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "../../core/schema/Schema.js";
+export declare const createEventSourceResponseHandler: <T>(schema: Schema<T>) => ({ response }: {
+    response: Response;
+}) => Promise<AsyncIterable<import("../../index.js").Delta<T>>>;

package/util/streaming/createEventSourceResponseHandler.js

@@ -0,0 +1,5 @@
+import { parseEventSourceStreamAsAsyncIterable } from "./parseEventSourceStreamAsAsyncIterable.js";
+export const createEventSourceResponseHandler = (schema) => ({ response }) => parseEventSourceStreamAsAsyncIterable({
+    stream: response.body,
+    schema,
+});

package/util/streaming/createJsonStreamResponseHandler.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonStreamResponseHandler = void 0;
+const parseJsonStreamAsAsyncIterable_js_1 = require("./parseJsonStreamAsAsyncIterable.cjs");
+const createJsonStreamResponseHandler = (schema) => ({ response }) => (0, parseJsonStreamAsAsyncIterable_js_1.parseJsonStreamAsAsyncIterable)({
+    stream: response.body,
+    schema,
+});
+exports.createJsonStreamResponseHandler = createJsonStreamResponseHandler;

package/util/streaming/createJsonStreamResponseHandler.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "../../core/schema/Schema.js";
+export declare const createJsonStreamResponseHandler: <T>(schema: Schema<T>) => ({ response }: {
+    response: Response;
+}) => Promise<AsyncIterable<import("../../index.js").Delta<T>>>;

package/util/streaming/createJsonStreamResponseHandler.js

@@ -0,0 +1,5 @@
+import { parseJsonStreamAsAsyncIterable } from "./parseJsonStreamAsAsyncIterable.js";
+export const createJsonStreamResponseHandler = (schema) => ({ response }) => parseJsonStreamAsAsyncIterable({
+    stream: response.body,
+    schema,
+});

package/util/streaming/parseEventSourceStreamAsAsyncIterable.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEventSourceStreamAsAsyncIterable = void 0;
+const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
+const AsyncQueue_js_1 = require("../AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("./parseEventSourceStream.cjs");
+async function parseEventSourceStreamAsAsyncIterable({ stream, schema, }) {
+    const queue = new AsyncQueue_js_1.AsyncQueue();
+    // process the stream asynchonously (no 'await' on purpose):
+    (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 parseResult = (0, parseJSON_js_1.safeParseJSON)({
+                    text: data,
+                    schema,
+                });
+                if (!parseResult.success) {
+                    queue.push({
+                        type: "error",
+                        error: parseResult.error,
+                    });
+                    // Note: the queue is not closed on purpose. Some providers might add additional
+                    // chunks that are not parsable, and ModelFusion should be resilient to that.
+                    continue;
+                }
+                const completionChunk = parseResult.data;
+                queue.push({
+                    type: "delta",
+                    deltaValue: completionChunk,
+                });
+            }
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
+    });
+    return queue;
+}
+exports.parseEventSourceStreamAsAsyncIterable = parseEventSourceStreamAsAsyncIterable;

package/util/streaming/parseEventSourceStreamAsAsyncIterable.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from "../../core/schema/Schema.js";
+import { Delta } from "../../model-function/Delta.js";
+export declare function parseEventSourceStreamAsAsyncIterable<T>({ stream, schema, }: {
+    stream: ReadableStream<Uint8Array>;
+    schema: Schema<T>;
+}): Promise<AsyncIterable<Delta<T>>>;

package/util/streaming/parseEventSourceStreamAsAsyncIterable.js

@@ -0,0 +1,48 @@
+import { safeParseJSON } from "../../core/schema/parseJSON.js";
+import { AsyncQueue } from "../AsyncQueue.js";
+import { parseEventSourceStream } from "./parseEventSourceStream.js";
+export async function parseEventSourceStreamAsAsyncIterable({ stream, schema, }) {
+    const queue = new AsyncQueue();
+    // process the stream asynchonously (no 'await' on purpose):
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                const data = event.data;
+                if (data === "[DONE]") {
+                    queue.close();
+                    return;
+                }
+                const parseResult = safeParseJSON({
+                    text: data,
+                    schema,
+                });
+                if (!parseResult.success) {
+                    queue.push({
+                        type: "error",
+                        error: parseResult.error,
+                    });
+                    // Note: the queue is not closed on purpose. Some providers might add additional
+                    // chunks that are not parsable, and ModelFusion should be resilient to that.
+                    continue;
+                }
+                const completionChunk = parseResult.data;
+                queue.push({
+                    type: "delta",
+                    deltaValue: completionChunk,
+                });
+            }
+        }
+        catch (error) {
+            queue.push({ type: "error", error });
+            queue.close();
+            return;
+        }
+    })
+        .catch((error) => {
+        queue.push({ type: "error", error });
+        queue.close();
+        return;
+    });
+    return queue;
+}

package/util/streaming/parseJsonStreamAsAsyncIterable.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonStreamAsAsyncIterable = void 0;
+const AsyncQueue_js_1 = require("../AsyncQueue.cjs");
+const parseJsonStream_js_1 = require("./parseJsonStream.cjs");
+async function parseJsonStreamAsAsyncIterable({ stream, schema, }) {
+    const queue = new AsyncQueue_js_1.AsyncQueue();
+    // process the stream asynchonously (no 'await' on purpose):
+    (0, parseJsonStream_js_1.parseJsonStream)({
+        stream,
+        schema,
+        process(event) {
+            queue.push({ type: "delta", deltaValue: event });
+        },
+        onDone() {
+            queue.close();
+        },
+    });
+    return queue;
+}
+exports.parseJsonStreamAsAsyncIterable = parseJsonStreamAsAsyncIterable;

package/util/streaming/parseJsonStreamAsAsyncIterable.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from "../../core/schema/Schema.js";
+import { Delta } from "../../model-function/Delta.js";
+export declare function parseJsonStreamAsAsyncIterable<T>({ stream, schema, }: {
+    stream: ReadableStream<Uint8Array>;
+    schema: Schema<T>;
+}): Promise<AsyncIterable<Delta<T>>>;

package/util/streaming/parseJsonStreamAsAsyncIterable.js

@@ -0,0 +1,17 @@
+import { AsyncQueue } from "../AsyncQueue.js";
+import { parseJsonStream } from "./parseJsonStream.js";
+export async function parseJsonStreamAsAsyncIterable({ stream, schema, }) {
+    const queue = new AsyncQueue();
+    // process the stream asynchonously (no 'await' on purpose):
+    parseJsonStream({
+        stream,
+        schema,
+        process(event) {
+            queue.push({ type: "delta", deltaValue: event });
+        },
+        onDone() {
+            queue.close();
+        },
+    });
+    return queue;
+}