modelfusion 0.103.0 → 0.105.0

package/model-provider/ollama/OllamaCompletionModel.test.js

@@ -1,23 +1,23 @@
 import { fail } from "assert";
-import { HttpResponse, http } from "msw";
-import { setupServer } from "msw/node";
+import { z } from "zod";
 import { ApiCallError } from "../../core/api/ApiCallError.js";
 import { retryNever } from "../../core/api/retryNever.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
+import { jsonStructurePrompt } from "../../model-function/generate-structure/jsonStructurePrompt.js";
+import { streamStructure } from "../../model-function/generate-structure/streamStructure.js";
 import { generateText } from "../../model-function/generate-text/generateText.js";
+import * as TextPrompt from "../../model-function/generate-text/prompt-template/TextPromptTemplate.js";
+import { streamText } from "../../model-function/generate-text/streamText.js";
+import { JsonTestServer } from "../../test/JsonTestServer.js";
+import { StreamingTestServer } from "../../test/StreamingTestServer.js";
+import { arrayFromAsync } from "../../test/arrayFromAsync.js";
 import { OllamaApiConfiguration } from "./OllamaApiConfiguration.js";
 import { OllamaCompletionModel } from "./OllamaCompletionModel.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-let responseBodyJson = {};
-const server = setupServer(http.post("http://127.0.0.1:11434/api/generate", () => HttpResponse.json(responseBodyJson)));
-beforeAll(() => server.listen());
-beforeEach(() => {
-    responseBodyJson = {};
-});
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
 describe("generateText", () => {
+    const server = new JsonTestServer("http://127.0.0.1:11434/api/generate");
+    server.setupTestEnvironment();
     it("should return the generated text", async () => {
-        responseBodyJson = {
+        server.responseBodyJson = {
             model: "test-model",
             created_at: "2023-08-04T19:22:45.499127Z",
             response: "test response",
@@ -38,7 +38,7 @@ describe("generateText", () => {
         expect(result).toEqual("test response");
     });
     it("should throw retryable ApiCallError when Ollama is overloaded", async () => {
-        responseBodyJson = {
+        server.responseBodyJson = {
             model: "",
             created_at: "0001-01-01T00:00:00Z",
             response: "",
@@ -59,3 +59,68 @@ describe("generateText", () => {
         }
     });
 });
+describe("streamText", () => {
+    const server = new StreamingTestServer("http://127.0.0.1:11434/api/generate");
+    server.setupTestEnvironment();
+    it("should return a text stream", async () => {
+        server.responseChunks = [
+            `{"model":"mistral:text","created_at":"2023-12-24T16:11:17.715003Z","response":"Hello","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-24T16:11:17.715003Z","response":", ","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-24T16:11:17.715003Z","response":"world!","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-24T16:11:19.697067Z","response":"",` +
+                `"done":true,"context":[123,456,789],"total_duration":2165354041,"load_duration":1293958,` +
+                `"prompt_eval_count":5,"prompt_eval_duration":193273000,"eval_count":136,"eval_duration":1966852000}\n`,
+        ];
+        const stream = await streamText(new OllamaCompletionModel({ model: "mistral:text" }).withTextPrompt(), "hello");
+        // note: space moved to last chunk bc of trimming
+        expect(await arrayFromAsync(stream)).toStrictEqual([
+            "Hello",
+            ",",
+            " world!",
+        ]);
+    });
+});
+describe("streamStructure", () => {
+    const server = new StreamingTestServer("http://127.0.0.1:11434/api/generate");
+    server.setupTestEnvironment();
+    it("should return a text stream", async () => {
+        server.responseChunks = [
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.253175Z","response":"{","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.273505Z","response":"\\n","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.293192Z","response":"   ","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.312446Z","response":" \\"","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.332021Z","response":"name","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.351128Z","response":"\\":","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.372082Z","response":" \\"","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.391903Z","response":"M","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.411056Z","response":"ike","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.430789Z","response":"\\"","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.450216Z","response":"\\n","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.47009Z","response":"}","done":false}\n`,
+            `{"model":"mistral:text","created_at":"2023-12-25T11:48:02.48885Z","response":"","done":true,` +
+                `"total_duration":521893000,"load_duration":957666,"prompt_eval_count":74,"prompt_eval_duration":302508000,` +
+                `"eval_count":12,"eval_duration":215282000}\n`,
+        ];
+        const stream = await streamStructure(new OllamaCompletionModel({
+            model: "mistral:text",
+            format: "json",
+            raw: true,
+        })
+            .withTextPromptTemplate(TextPrompt.instruction())
+            .asStructureGenerationModel(jsonStructurePrompt((instruction, schema) => ({
+            system: "JSON schema: \n" +
+                JSON.stringify(schema.getJsonSchema()) +
+                "\n\n" +
+                "Respond only using JSON that matches the above schema.",
+            instruction,
+        }))), zodSchema(z.object({ name: z.string() })), "generate a name");
+        // note: space moved to last chunk bc of trimming
+        expect(await arrayFromAsync(stream)).toStrictEqual([
+            { isComplete: false, value: {} },
+            { isComplete: false, value: { name: "" } },
+            { isComplete: false, value: { name: "M" } },
+            { isComplete: false, value: { name: "Mike" } },
+            { isComplete: true, value: { name: "Mike" } },
+        ]);
+    });
+});

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

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIChatResponseFormat = exports.AbstractOpenAIChatModel = void 0;
 const zod_1 = require("zod");
-const callWithRetryAndThrottle_js_1 = require("../../../core/api/callWithRetryAndThrottle.cjs");
-const postToApi_js_1 = require("../../../core/api/postToApi.cjs");
-const parseJSON_js_1 = require("../../../core/schema/parseJSON.cjs");
-const AbstractModel_js_1 = require("../../../model-function/AbstractModel.cjs");
-const parsePartialJson_js_1 = require("../../../model-function/generate-structure/parsePartialJson.cjs");
-const OpenAIApiConfiguration_js_1 = require("../OpenAIApiConfiguration.cjs");
-const OpenAIError_js_1 = require("../OpenAIError.cjs");
-const OpenAIChatStreamIterable_js_1 = require("./OpenAIChatStreamIterable.cjs");
+const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
+const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const createEventSourceResponseHandler_js_1 = require("../../util/streaming/createEventSourceResponseHandler.cjs");
+const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
+const OpenAIError_js_1 = require("./OpenAIError.cjs");
 /**
  * Abstract text generation model that calls an API that is compatible with the OpenAI chat API.
  *
@@ -105,9 +105,21 @@ class AbstractOpenAIChatModel extends AbstractModel_js_1.AbstractModel {
     doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
-            responseFormat: exports.OpenAIChatResponseFormat.textDeltaIterable,
+            responseFormat: exports.OpenAIChatResponseFormat.deltaIterable,
         });
     }
+    extractTextDelta(delta) {
+        const chunk = delta;
+        if (chunk.object !== "chat.completion.chunk") {
+            return undefined;
+        }
+        const chatChunk = chunk;
+        const firstChoice = chatChunk.choices[0];
+        if (firstChoice.index > 0) {
+            return undefined;
+        }
+        return firstChoice.delta.content ?? undefined;
+    }
     async doGenerateToolCall(tool, prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
@@ -220,6 +232,54 @@ const openAIChatResponseSchema = zod_1.z.object({
         total_tokens: zod_1.z.number(),
     }),
 });
+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 openaiChatChunkSchema = (0, 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'",
+        }),
+    }),
+]));
 exports.OpenAIChatResponseFormat = {
     /**
      * Returns the response as a JSON object.
@@ -231,12 +291,8 @@ exports.OpenAIChatResponseFormat = {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    textDeltaIterable: {
-        stream: true,
-        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => delta[0]?.delta?.content ?? ""),
-    },
-    structureDeltaIterable: {
+    deltaIterable: {
         stream: true,
-        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => (0, parsePartialJson_js_1.parsePartialJson)(delta[0]?.function_call?.arguments)),
+        handler: (0, createEventSourceResponseHandler_js_1.createEventSourceResponseHandler)(openaiChatChunkSchema),
     },
 };

package/model-provider/openai/{chat/AbstractOpenAIChatModel.d.ts → AbstractOpenAIChatModel.d.ts}

@@ -1,12 +1,11 @@
 import { z } from "zod";
-import { FunctionOptions } from "../../../core/FunctionOptions.js";
-import { ApiConfiguration } from "../../../core/api/ApiConfiguration.js";
-import { ResponseHandler } from "../../../core/api/postToApi.js";
-import { AbstractModel } from "../../../model-function/AbstractModel.js";
-import { Delta } from "../../../model-function/Delta.js";
-import { TextGenerationModelSettings } from "../../../model-function/generate-text/TextGenerationModel.js";
-import { TextGenerationFinishReason } from "../../../model-function/generate-text/TextGenerationResult.js";
-import { ToolDefinition } from "../../../tool/ToolDefinition.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
+import { ResponseHandler } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { TextGenerationFinishReason } from "../../model-function/generate-text/TextGenerationResult.js";
+import { ToolDefinition } from "../../tool/ToolDefinition.js";
 import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
 export interface AbstractOpenAIChatCallSettings {
     api?: ApiConfiguration;
@@ -138,7 +137,36 @@ export declare abstract class AbstractOpenAIChatModel<SETTINGS extends AbstractO
         };
     }>;
     private translateFinishReason;
-    doStreamText(prompt: OpenAIChatPrompt, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
+    doStreamText(prompt: OpenAIChatPrompt, options?: FunctionOptions): Promise<AsyncIterable<import("../../index.js").Delta<{
+        object: "chat.completion.chunk";
+        model: string;
+        id: string;
+        created: number;
+        choices: {
+            delta: {
+                role?: "user" | "assistant" | undefined;
+                content?: string | null | undefined;
+                function_call?: {
+                    name?: string | undefined;
+                    arguments?: string | undefined;
+                } | undefined;
+                tool_calls?: {
+                    function: {
+                        name: string;
+                        arguments: string;
+                    };
+                    type: "function";
+                    id: string;
+                }[] | undefined;
+            };
+            index: number;
+            finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+        }[];
+        system_fingerprint?: string | null | undefined;
+    } | {
+        object: string;
+    }>>>;
+    extractTextDelta(delta: unknown): string | undefined;
     doGenerateToolCall(tool: ToolDefinition<string, unknown>, prompt: OpenAIChatPrompt, options?: FunctionOptions): Promise<{
         response: {
             object: "chat.completion";
@@ -437,6 +465,210 @@ declare const openAIChatResponseSchema: z.ZodObject<{
     system_fingerprint?: string | null | undefined;
 }>;
 export type OpenAIChatResponse = z.infer<typeof openAIChatResponseSchema>;
+declare const chatCompletionChunkSchema: z.ZodObject<{
+    object: z.ZodLiteral<"chat.completion.chunk">;
+    id: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        delta: z.ZodObject<{
+            role: z.ZodOptional<z.ZodEnum<["assistant", "user"]>>;
+            content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            function_call: z.ZodOptional<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                arguments: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            }, {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            }>>;
+            tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    arguments: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    arguments: string;
+                }, {
+                    name: string;
+                    arguments: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        }, {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        }>;
+        finish_reason: z.ZodOptional<z.ZodNullable<z.ZodEnum<["stop", "length", "tool_calls", "content_filter", "function_call"]>>>;
+        index: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }, {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }>, "many">;
+    created: z.ZodNumber;
+    model: z.ZodString;
+    system_fingerprint: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    object: "chat.completion.chunk";
+    model: string;
+    id: string;
+    created: number;
+    choices: {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }[];
+    system_fingerprint?: string | null | undefined;
+}, {
+    object: "chat.completion.chunk";
+    model: string;
+    id: string;
+    created: number;
+    choices: {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }[];
+    system_fingerprint?: string | null | undefined;
+}>;
+export type OpenAIChatCompletionChunk = z.infer<typeof chatCompletionChunkSchema>;
+declare const openaiChatChunkSchema: import("../../core/schema/ZodSchema.js").ZodSchema<{
+    object: "chat.completion.chunk";
+    model: string;
+    id: string;
+    created: number;
+    choices: {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }[];
+    system_fingerprint?: string | null | undefined;
+} | {
+    object: string;
+}>;
+export type OpenAIChatChunk = (typeof openaiChatChunkSchema)["_type"];
 export type OpenAIChatResponseFormatType<T> = {
     stream: boolean;
     handler: ResponseHandler<T>;
@@ -446,7 +678,7 @@ export declare const OpenAIChatResponseFormat: {
      * Returns the response as a JSON object.
      */
     json: {
-        stream: false;
+        stream: boolean;
         handler: ResponseHandler<{
             object: "chat.completion";
             usage: {
@@ -484,17 +716,39 @@ export declare const OpenAIChatResponseFormat: {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    textDeltaIterable: {
-        stream: true;
+    deltaIterable: {
+        stream: boolean;
         handler: ({ response }: {
             response: Response;
-        }) => Promise<AsyncIterable<Delta<string>>>;
-    };
-    structureDeltaIterable: {
-        stream: true;
-        handler: ({ response }: {
-            response: Response;
-        }) => Promise<AsyncIterable<Delta<unknown>>>;
+        }) => Promise<AsyncIterable<import("../../index.js").Delta<{
+            object: "chat.completion.chunk";
+            model: string;
+            id: string;
+            created: number;
+            choices: {
+                delta: {
+                    role?: "user" | "assistant" | undefined;
+                    content?: string | null | undefined;
+                    function_call?: {
+                        name?: string | undefined;
+                        arguments?: string | undefined;
+                    } | undefined;
+                    tool_calls?: {
+                        function: {
+                            name: string;
+                            arguments: string;
+                        };
+                        type: "function";
+                        id: string;
+                    }[] | undefined;
+                };
+                index: number;
+                finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+            }[];
+            system_fingerprint?: string | null | undefined;
+        } | {
+            object: string;
+        }>>>;
     };
 };
 export {};

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

@@ -1,12 +1,12 @@
 import { z } from "zod";
-import { callWithRetryAndThrottle } from "../../../core/api/callWithRetryAndThrottle.js";
-import { createJsonResponseHandler, postJsonToApi, } from "../../../core/api/postToApi.js";
-import { parseJSON } from "../../../core/schema/parseJSON.js";
-import { AbstractModel } from "../../../model-function/AbstractModel.js";
-import { parsePartialJson } from "../../../model-function/generate-structure/parsePartialJson.js";
-import { OpenAIApiConfiguration } from "../OpenAIApiConfiguration.js";
-import { failedOpenAICallResponseHandler } from "../OpenAIError.js";
-import { createOpenAIChatDeltaIterableQueue } from "./OpenAIChatStreamIterable.js";
+import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
+import { parseJSON } from "../../core/schema/parseJSON.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { createEventSourceResponseHandler } from "../../util/streaming/createEventSourceResponseHandler.js";
+import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
+import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 /**
  * Abstract text generation model that calls an API that is compatible with the OpenAI chat API.
  *
@@ -102,9 +102,21 @@ export class AbstractOpenAIChatModel extends AbstractModel {
     doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
-            responseFormat: OpenAIChatResponseFormat.textDeltaIterable,
+            responseFormat: OpenAIChatResponseFormat.deltaIterable,
         });
     }
+    extractTextDelta(delta) {
+        const chunk = delta;
+        if (chunk.object !== "chat.completion.chunk") {
+            return undefined;
+        }
+        const chatChunk = chunk;
+        const firstChoice = chatChunk.choices[0];
+        if (firstChoice.index > 0) {
+            return undefined;
+        }
+        return firstChoice.delta.content ?? undefined;
+    }
     async doGenerateToolCall(tool, prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
@@ -216,6 +228,54 @@ const openAIChatResponseSchema = z.object({
         total_tokens: z.number(),
     }),
 });
+const chatCompletionChunkSchema = z.object({
+    object: z.literal("chat.completion.chunk"),
+    id: z.string(),
+    choices: z.array(z.object({
+        delta: z.object({
+            role: z.enum(["assistant", "user"]).optional(),
+            content: z.string().nullable().optional(),
+            function_call: z
+                .object({
+                name: z.string().optional(),
+                arguments: z.string().optional(),
+            })
+                .optional(),
+            tool_calls: z
+                .array(z.object({
+                id: z.string(),
+                type: z.literal("function"),
+                function: z.object({
+                    name: z.string(),
+                    arguments: z.string(),
+                }),
+            }))
+                .optional(),
+        }),
+        finish_reason: z
+            .enum([
+            "stop",
+            "length",
+            "tool_calls",
+            "content_filter",
+            "function_call",
+        ])
+            .nullable()
+            .optional(),
+        index: z.number(),
+    })),
+    created: z.number(),
+    model: z.string(),
+    system_fingerprint: z.string().optional().nullable(),
+});
+const openaiChatChunkSchema = zodSchema(z.union([
+    chatCompletionChunkSchema,
+    z.object({
+        object: z.string().refine((obj) => obj !== "chat.completion.chunk", {
+            message: "Object must be 'chat.completion.chunk'",
+        }),
+    }),
+]));
 export const OpenAIChatResponseFormat = {
     /**
      * Returns the response as a JSON object.
@@ -227,12 +287,8 @@ export const OpenAIChatResponseFormat = {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    textDeltaIterable: {
-        stream: true,
-        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => delta[0]?.delta?.content ?? ""),
-    },
-    structureDeltaIterable: {
+    deltaIterable: {
         stream: true,
-        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => parsePartialJson(delta[0]?.function_call?.arguments)),
+        handler: createEventSourceResponseHandler(openaiChatChunkSchema),
     },
 };