modelfusion 0.103.0 → 0.105.0

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;
+}

package/model-function/generate-text/prompt-template/Content.cjs

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/model-function/generate-text/prompt-template/Content.d.ts

@@ -1,20 +0,0 @@
-export type MultiModalInput = Array<Content>;
-export type Content = TextContent | ImageContent;
-export interface TextContent {
-    type: "text";
-    /**
-     * The text content.
-     */
-    text: string;
-}
-export interface ImageContent {
-    type: "image";
-    /**
-     * Base-64 encoded image.
-     */
-    base64Image: string;
-    /**
-     * Optional mime type of the image.
-     */
-    mimeType?: string;
-}

package/model-provider/openai/chat/OpenAIChatModel.test.cjs

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const msw_1 = require("msw");
-const node_1 = require("msw/node");
-const streamText_js_1 = require("../../../model-function/generate-text/streamText.cjs");
-const OpenAIChatModel_js_1 = require("./OpenAIChatModel.cjs");
-const OpenAIApiConfiguration_js_1 = require("../OpenAIApiConfiguration.cjs");
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let responseChunks = [];
-const server = (0, node_1.setupServer)(msw_1.http.post("https://api.openai.com/v1/chat/completions", () => {
-    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",
-        },
-    });
-}));
-beforeAll(() => server.listen());
-beforeEach(() => {
-    responseChunks = [];
-});
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
-describe("streamText", () => {
-    it("should return only values from the first choice when using streamText", async () => {
-        responseChunks = [
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"A"},"finish_reason":null}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"content":"B"},"finish_reason":null}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{},"finish_reason":"stop"}]}\n\n`,
-            "data: [DONE]\n\n",
-        ];
-        const stream = await (0, streamText_js_1.streamText)(new OpenAIChatModel_js_1.OpenAIChatModel({
-            api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test" }),
-            model: "gpt-3.5-turbo",
-            numberOfGenerations: 2,
-        }).withTextPrompt(), "test prompt");
-        const chunks = [];
-        for await (const part of stream) {
-            chunks.push(part);
-        }
-        expect(chunks).toStrictEqual(["A"]);
-    });
-});

package/model-provider/openai/chat/OpenAIChatModel.test.js

@@ -1,59 +0,0 @@
-import { HttpResponse, http } from "msw";
-import { setupServer } from "msw/node";
-import { streamText } from "../../../model-function/generate-text/streamText.js";
-import { OpenAIChatModel } from "./OpenAIChatModel.js";
-import { OpenAIApiConfiguration } from "../OpenAIApiConfiguration.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let responseChunks = [];
-const server = setupServer(http.post("https://api.openai.com/v1/chat/completions", () => {
-    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",
-        },
-    });
-}));
-beforeAll(() => server.listen());
-beforeEach(() => {
-    responseChunks = [];
-});
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
-describe("streamText", () => {
-    it("should return only values from the first choice when using streamText", async () => {
-        responseChunks = [
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"A"},"finish_reason":null}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"content":"B"},"finish_reason":null}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\n`,
-            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{},"finish_reason":"stop"}]}\n\n`,
-            "data: [DONE]\n\n",
-        ];
-        const stream = await streamText(new OpenAIChatModel({
-            api: new OpenAIApiConfiguration({ apiKey: "test" }),
-            model: "gpt-3.5-turbo",
-            numberOfGenerations: 2,
-        }).withTextPrompt(), "test prompt");
-        const chunks = [];
-        for await (const part of stream) {
-            chunks.push(part);
-        }
-        expect(chunks).toStrictEqual(["A"]);
-    });
-});

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

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.chat = exports.instruction = exports.text = exports.identity = void 0;
-const ChatPrompt_js_1 = require("../../../model-function/generate-text/prompt-template/ChatPrompt.cjs");
-const OpenAIChatMessage_js_1 = require("./OpenAIChatMessage.cjs");
-/**
- * OpenAIMessage[] identity chat format.
- */
-function identity() {
-    return { format: (prompt) => prompt, stopSequences: [] };
-}
-exports.identity = identity;
-/**
- * Formats a text prompt as an OpenAI chat prompt.
- */
-function text() {
-    return {
-        format: (prompt) => [OpenAIChatMessage_js_1.OpenAIChatMessage.user(prompt)],
-        stopSequences: [],
-    };
-}
-exports.text = text;
-/**
- * Formats an instruction prompt as an OpenAI chat prompt.
- */
-function instruction() {
-    return {
-        format(prompt) {
-            const messages = [];
-            if (prompt.system != null) {
-                messages.push(OpenAIChatMessage_js_1.OpenAIChatMessage.system(prompt.system));
-            }
-            messages.push(OpenAIChatMessage_js_1.OpenAIChatMessage.user(prompt.instruction));
-            return messages;
-        },
-        stopSequences: [],
-    };
-}
-exports.instruction = instruction;
-/**
- * Formats a chat prompt as an OpenAI chat prompt.
- */
-function chat() {
-    return {
-        format(prompt) {
-            (0, ChatPrompt_js_1.validateChatPrompt)(prompt);
-            const messages = [];
-            if (prompt.system != null) {
-                messages.push(OpenAIChatMessage_js_1.OpenAIChatMessage.system(prompt.system));
-            }
-            for (const { role, content } of prompt.messages) {
-                switch (role) {
-                    case "user": {
-                        messages.push(OpenAIChatMessage_js_1.OpenAIChatMessage.user(content));
-                        break;
-                    }
-                    case "assistant": {
-                        messages.push(OpenAIChatMessage_js_1.OpenAIChatMessage.assistant(content));
-                        break;
-                    }
-                    default: {
-                        const _exhaustiveCheck = role;
-                        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-                    }
-                }
-            }
-            return messages;
-        },
-        stopSequences: [],
-    };
-}
-exports.chat = chat;

package/model-provider/openai/chat/OpenAIChatPromptTemplate.d.ts

@@ -1,20 +0,0 @@
-import { TextGenerationPromptTemplate } from "../../../model-function/generate-text/TextGenerationPromptTemplate.js";
-import { MultiModalChatPrompt, TextChatPrompt } from "../../../model-function/generate-text/prompt-template/ChatPrompt.js";
-import { MultiModalInstructionPrompt, TextInstructionPrompt } from "../../../model-function/generate-text/prompt-template/InstructionPrompt.js";
-import { OpenAIChatPrompt } from "./AbstractOpenAIChatModel.js";
-/**
- * OpenAIMessage[] identity chat format.
- */
-export declare function identity(): TextGenerationPromptTemplate<OpenAIChatPrompt, OpenAIChatPrompt>;
-/**
- * Formats a text prompt as an OpenAI chat prompt.
- */
-export declare function text(): TextGenerationPromptTemplate<string, OpenAIChatPrompt>;
-/**
- * Formats an instruction prompt as an OpenAI chat prompt.
- */
-export declare function instruction(): TextGenerationPromptTemplate<MultiModalInstructionPrompt | TextInstructionPrompt, OpenAIChatPrompt>;
-/**
- * Formats a chat prompt as an OpenAI chat prompt.
- */
-export declare function chat(): TextGenerationPromptTemplate<MultiModalChatPrompt | TextChatPrompt, OpenAIChatPrompt>;

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

@@ -1,65 +0,0 @@
-import { validateChatPrompt, } from "../../../model-function/generate-text/prompt-template/ChatPrompt.js";
-import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
-/**
- * OpenAIMessage[] identity chat format.
- */
-export function identity() {
-    return { format: (prompt) => prompt, stopSequences: [] };
-}
-/**
- * Formats a text prompt as an OpenAI chat prompt.
- */
-export function text() {
-    return {
-        format: (prompt) => [OpenAIChatMessage.user(prompt)],
-        stopSequences: [],
-    };
-}
-/**
- * Formats an instruction prompt as an OpenAI chat prompt.
- */
-export function instruction() {
-    return {
-        format(prompt) {
-            const messages = [];
-            if (prompt.system != null) {
-                messages.push(OpenAIChatMessage.system(prompt.system));
-            }
-            messages.push(OpenAIChatMessage.user(prompt.instruction));
-            return messages;
-        },
-        stopSequences: [],
-    };
-}
-/**
- * Formats a chat prompt as an OpenAI chat prompt.
- */
-export function chat() {
-    return {
-        format(prompt) {
-            validateChatPrompt(prompt);
-            const messages = [];
-            if (prompt.system != null) {
-                messages.push(OpenAIChatMessage.system(prompt.system));
-            }
-            for (const { role, content } of prompt.messages) {
-                switch (role) {
-                    case "user": {
-                        messages.push(OpenAIChatMessage.user(content));
-                        break;
-                    }
-                    case "assistant": {
-                        messages.push(OpenAIChatMessage.assistant(content));
-                        break;
-                    }
-                    default: {
-                        const _exhaustiveCheck = role;
-                        throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
-                    }
-                }
-            }
-            return messages;
-        },
-        stopSequences: [],
-    };
-}

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

@@ -1,156 +0,0 @@
-"use strict";
-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("../../../util/streaming/parseEventSourceStream.cjs");
-const parseJSON_js_1 = require("../../../core/schema/parseJSON.cjs");
-const ZodSchema_js_1 = require("../../../core/schema/ZodSchema.cjs");
-const chatCompletionChunkSchema = zod_1.z.object({
-    object: zod_1.z.literal("chat.completion.chunk"),
-    id: zod_1.z.string(),
-    choices: zod_1.z.array(zod_1.z.object({
-        delta: zod_1.z.object({
-            role: zod_1.z.enum(["assistant", "user"]).optional(),
-            content: zod_1.z.string().nullable().optional(),
-            function_call: zod_1.z
-                .object({
-                name: zod_1.z.string().optional(),
-                arguments: zod_1.z.string().optional(),
-            })
-                .optional(),
-            tool_calls: zod_1.z
-                .array(zod_1.z.object({
-                id: zod_1.z.string(),
-                type: zod_1.z.literal("function"),
-                function: zod_1.z.object({
-                    name: zod_1.z.string(),
-                    arguments: zod_1.z.string(),
-                }),
-            }))
-                .optional(),
-        }),
-        finish_reason: zod_1.z
-            .enum([
-            "stop",
-            "length",
-            "tool_calls",
-            "content_filter",
-            "function_call",
-        ])
-            .nullable()
-            .optional(),
-        index: zod_1.z.number(),
-    })),
-    created: zod_1.z.number(),
-    model: zod_1.z.string(),
-    system_fingerprint: zod_1.z.string().optional().nullable(),
-});
-const chatResponseStreamEventSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.union([
-    chatCompletionChunkSchema,
-    zod_1.z.object({
-        object: zod_1.z.string().refine((obj) => obj !== "chat.completion.chunk", {
-            message: "Object must be 'chat.completion.chunk'",
-        }),
-    }),
-]));
-async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaValue) {
-    const queue = new AsyncQueue_js_1.AsyncQueue();
-    const streamDelta = [];
-    // 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: chatResponseStreamEventSchema,
-                });
-                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 eventData = parseResult.data;
-                // ignore objects that are not "chat.completion.chunk" events.
-                // Such additional objects are e.g. sent by Azure OpenAI.
-                if (eventData.object !== "chat.completion.chunk") {
-                    continue;
-                }
-                const completionChunk = eventData;
-                // reset delta for all existing streamDeltas
-                for (const delta of streamDelta) {
-                    delta.delta = undefined;
-                }
-                for (let i = 0; i < completionChunk.choices.length; i++) {
-                    const eventChoice = completionChunk.choices[i];
-                    const index = eventChoice.index;
-                    const delta = eventChoice.delta;
-                    if (streamDelta[index] == null) {
-                        streamDelta[index] = {
-                            role: undefined,
-                            content: "",
-                            isComplete: false,
-                            delta,
-                        };
-                    }
-                    const choice = streamDelta[index];
-                    choice.delta = delta;
-                    if (eventChoice.finish_reason != null) {
-                        choice.isComplete = true;
-                    }
-                    if (delta.content != undefined) {
-                        choice.content += delta.content;
-                    }
-                    if (delta.function_call != undefined) {
-                        if (choice.function_call == undefined) {
-                            choice.function_call = {
-                                name: "",
-                                arguments: "",
-                            };
-                        }
-                        if (delta.function_call.name != undefined) {
-                            choice.function_call.name += delta.function_call.name;
-                        }
-                        if (delta.function_call.arguments != undefined) {
-                            choice.function_call.arguments +=
-                                delta.function_call.arguments;
-                        }
-                    }
-                    if (delta.role != undefined) {
-                        choice.role = delta.role;
-                    }
-                }
-                // Since we're mutating the choices array in an async scenario,
-                // we need to make a deep copy:
-                const streamDeltaDeepCopy = JSON.parse(JSON.stringify(streamDelta));
-                queue.push({
-                    type: "delta",
-                    fullDelta: streamDeltaDeepCopy,
-                    valueDelta: extractDeltaValue(streamDeltaDeepCopy),
-                });
-            }
-        }
-        catch (error) {
-            queue.push({ type: "error", error });
-            queue.close();
-            return;
-        }
-    })
-        .catch((error) => {
-        queue.push({ type: "error", error });
-        queue.close();
-        return;
-    });
-    return queue;
-}
-exports.createOpenAIChatDeltaIterableQueue = createOpenAIChatDeltaIterableQueue;

package/model-provider/openai/chat/OpenAIChatStreamIterable.d.ts

@@ -1,19 +0,0 @@
-import { Delta } from "../../../model-function/Delta.js";
-export type OpenAIChatDelta = Array<{
-    role: "assistant" | "user" | undefined;
-    content: string;
-    function_call?: {
-        name: string;
-        arguments: string;
-    };
-    isComplete: boolean;
-    delta: {
-        role?: "assistant" | "user";
-        content?: string | null;
-        function_call?: {
-            name?: string;
-            arguments?: string;
-        };
-    } | undefined;
-}>;
-export declare function createOpenAIChatDeltaIterableQueue<VALUE>(stream: ReadableStream<Uint8Array>, extractDeltaValue: (delta: OpenAIChatDelta) => VALUE): Promise<AsyncIterable<Delta<VALUE>>>;