modelfusion 0.40.1 → 0.41.0

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

@@ -1,13 +1,12 @@
 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 { DeltaEvent } from "../../model-function/DeltaEvent.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
-import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { Delta } from "../../model-function/Delta.js";
+import { TextGenerationModelSettings, TextStreamingModel } from "../../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "../../prompt/PromptFormat.js";
-import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
-import { OpenAIImageGenerationCallSettings } from "./OpenAIImageGenerationModel.js";
+import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
 /**
  * @see https://platform.openai.com/docs/models/
@@ -135,7 +134,7 @@ export interface OpenAITextGenerationModelSettings extends TextGenerationModelSe
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextGenerationModelSettings> implements TextGenerationModel<string, OpenAITextGenerationResponse, OpenAITextGenerationDelta, OpenAITextGenerationModelSettings> {
+export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextGenerationModelSettings> implements TextStreamingModel<string, OpenAITextGenerationModelSettings> {
     constructor(settings: OpenAITextGenerationModelSettings);
     readonly provider: "openai";
     get modelName(): OpenAITextGenerationModelType;
@@ -144,36 +143,35 @@ export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextG
     countPromptTokens(input: string): Promise<number>;
     callAPI<RESULT>(prompt: string, options: {
         responseFormat: OpenAITextResponseFormatType<RESULT>;
-    } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & {
-        user?: string;
-    }>>): Promise<RESULT>;
+    } & FunctionOptions): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAITextGenerationModelSettings>;
-    generateTextResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<{
-        object: "text_completion";
-        model: string;
+    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
+            object: "text_completion";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            id: string;
+            created: number;
+            choices: {
+                text: string;
+                finish_reason: string;
+                index: number;
+                logprobs?: any;
+            }[];
+        };
+        text: string;
         usage: {
-            prompt_tokens: number;
-            completion_tokens: number;
-            total_tokens: number;
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
         };
-        id: string;
-        created: number;
-        choices: {
-            text: string;
-            finish_reason: string;
-            index: number;
-            logprobs?: any;
-        }[];
     }>;
-    extractText(response: OpenAITextGenerationResponse): string;
-    generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<OpenAITextGenerationDelta>>>;
-    extractTextDelta(fullDelta: OpenAITextGenerationDelta): string | undefined;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, OpenAITextGenerationResponse, OpenAITextGenerationDelta, OpenAITextGenerationModelSettings, this>;
-    extractUsage(response: OpenAITextGenerationResponse): {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
+    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextStreamingModel<INPUT_PROMPT, string, OpenAITextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<OpenAITextGenerationModelSettings>): this;
 }
 declare const openAITextGenerationResponseSchema: z.ZodObject<{
@@ -280,7 +278,7 @@ export declare const OpenAITextResponseFormat: {
         stream: true;
         handler: ({ response }: {
             response: Response;
-        }) => Promise<AsyncIterable<DeltaEvent<OpenAITextGenerationDelta>>>;
+        }) => Promise<AsyncIterable<Delta<string>>>;
     };
 };
 export type OpenAITextGenerationDelta = Array<{

package/model-provider/openai/OpenAITextGenerationModel.js

@@ -6,7 +6,7 @@ import { AsyncQueue } from "../../event-source/AsyncQueue.js";
 import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
-import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
+import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
@@ -172,18 +172,14 @@ export class OpenAITextGenerationModel extends AbstractModel {
         return countTokens(this.tokenizer, input);
     }
     async callAPI(prompt, options) {
-        const { run, settings, responseFormat } = options;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
+        const { run, responseFormat } = options;
         const callSettings = {
             user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
             // Copied settings:
-            ...combinedSettings,
+            ...this.settings,
             // map to OpenAI API names:
-            stop: combinedSettings.stopSequences,
-            maxTokens: combinedSettings.maxCompletionTokens,
+            stop: this.settings.stopSequences,
+            maxTokens: this.settings.maxCompletionTokens,
             // other settings:
             abortSignal: run?.abortSignal,
             prompt,
@@ -212,26 +208,29 @@ export class OpenAITextGenerationModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateTextResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: OpenAITextResponseFormat.json,
         });
+        return {
+            response,
+            text: response.choices[0].text,
+            usage: {
+                promptTokens: response.usage.prompt_tokens,
+                completionTokens: response.usage.completion_tokens,
+                totalTokens: response.usage.total_tokens,
+            },
+        };
     }
-    extractText(response) {
-        return response.choices[0].text;
-    }
-    generateDeltaStreamResponse(prompt, options) {
+    doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
             responseFormat: OpenAITextResponseFormat.deltaIterable,
         });
     }
-    extractTextDelta(fullDelta) {
-        return fullDelta[0].delta;
-    }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel({
             model: this.withSettings({
                 stopSequences: [
                     ...(this.settings.stopSequences ?? []),
@@ -241,13 +240,6 @@ export class OpenAITextGenerationModel extends AbstractModel {
             promptFormat,
         });
     }
-    extractUsage(response) {
-        return {
-            promptTokens: response.usage.prompt_tokens,
-            completionTokens: response.usage.completion_tokens,
-            totalTokens: response.usage.total_tokens,
-        };
-    }
     withSettings(additionalSettings) {
         return new OpenAITextGenerationModel(Object.assign({}, this.settings, additionalSettings));
     }
@@ -375,6 +367,7 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                 queue.push({
                     type: "delta",
                     fullDelta: streamDeltaDeepCopy,
+                    valueDelta: streamDeltaDeepCopy[0].delta,
                 });
             }
         }

package/model-provider/openai/OpenAITranscriptionModel.cjs

@@ -5,9 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAITranscriptionResponseFormat = exports.OpenAITranscriptionModel = exports.calculateOpenAITranscriptionCostInMillicents = exports.OPENAI_TRANSCRIPTION_MODELS = void 0;
 const zod_1 = __importDefault(require("zod"));
-const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("./OpenAIError.cjs");
 /**
@@ -56,40 +56,31 @@ class OpenAITranscriptionModel extends AbstractModel_js_1.AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    generateTranscriptionResponse(data, options) {
-        return this.callAPI(data, {
+    async doTranscribe(data, options) {
+        const response = await this.callAPI(data, {
             responseFormat: exports.OpenAITranscriptionResponseFormat.verboseJson,
             functionId: options?.functionId,
-            settings: options?.settings,
             run: options?.run,
         });
-    }
-    extractTranscriptionText(response) {
-        return response.text;
+        return {
+            response,
+            transcription: response.text,
+        };
     }
     async callAPI(data, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const responseFormat = options?.responseFormat;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            file: {
-                name: `audio.${data.type}`,
-                data: data.data,
-            },
-            responseFormat,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAITranscriptionAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOpenAITranscriptionAPI({
+                ...this.settings,
+                // other settings:
+                abortSignal: options?.run?.abortSignal,
+                file: {
+                    name: `audio.${data.type}`,
+                    data: data.data,
+                },
+                responseFormat: options?.responseFormat,
+            }),
         });
     }
     get settingsForEvent() {

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

@@ -1,10 +1,10 @@
 /// <reference types="node" />
 import z from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { TranscriptionModel, TranscriptionModelSettings } from "../../model-function/transcribe-speech/TranscriptionModel.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { TranscriptionModel, TranscriptionModelSettings } from "../../model-function/transcribe-speech/TranscriptionModel.js";
 /**
  * @see https://openai.com/pricing
  */
@@ -42,15 +42,35 @@ export type OpenAITranscriptionInput = {
  *   }
  * );
  */
-export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITranscriptionModelSettings> implements TranscriptionModel<OpenAITranscriptionInput, OpenAITranscriptionVerboseJsonResponse, OpenAITranscriptionModelSettings> {
+export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITranscriptionModelSettings> implements TranscriptionModel<OpenAITranscriptionInput, OpenAITranscriptionModelSettings> {
     constructor(settings: OpenAITranscriptionModelSettings);
     readonly provider: "openai";
     get modelName(): "whisper-1";
-    generateTranscriptionResponse(data: OpenAITranscriptionInput, options?: ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings>>): PromiseLike<OpenAITranscriptionVerboseJsonResponse>;
-    extractTranscriptionText(response: OpenAITranscriptionVerboseJsonResponse): string;
+    doTranscribe(data: OpenAITranscriptionInput, options?: FunctionOptions): Promise<{
+        response: {
+            text: string;
+            segments: {
+                text: string;
+                temperature: number;
+                id: number;
+                tokens: number[];
+                seek: number;
+                start: number;
+                end: number;
+                avg_logprob: number;
+                compression_ratio: number;
+                no_speech_prob: number;
+                transient?: boolean | undefined;
+            }[];
+            task: "transcribe";
+            language: string;
+            duration: number;
+        };
+        transcription: string;
+    }>;
     callAPI<RESULT>(data: OpenAITranscriptionInput, options: {
         responseFormat: OpenAITranscriptionResponseFormatType<RESULT>;
-    } & ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings>>): Promise<RESULT>;
+    } & FunctionOptions): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAITranscriptionModelSettings>;
     withSettings(additionalSettings: OpenAITranscriptionModelSettings): this;
 }

package/model-provider/openai/OpenAITranscriptionModel.js

@@ -1,7 +1,7 @@
 import z from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, createTextResponseHandler, postToApi, } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 /**
@@ -49,40 +49,31 @@ export class OpenAITranscriptionModel extends AbstractModel {
     get modelName() {
         return this.settings.model;
     }
-    generateTranscriptionResponse(data, options) {
-        return this.callAPI(data, {
+    async doTranscribe(data, options) {
+        const response = await this.callAPI(data, {
             responseFormat: OpenAITranscriptionResponseFormat.verboseJson,
             functionId: options?.functionId,
-            settings: options?.settings,
             run: options?.run,
         });
-    }
-    extractTranscriptionText(response) {
-        return response.text;
+        return {
+            response,
+            transcription: response.text,
+        };
     }
     async callAPI(data, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const responseFormat = options?.responseFormat;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            file: {
-                name: `audio.${data.type}`,
-                data: data.data,
-            },
-            responseFormat,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAITranscriptionAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOpenAITranscriptionAPI({
+                ...this.settings,
+                // other settings:
+                abortSignal: options?.run?.abortSignal,
+                file: {
+                    name: `audio.${data.type}`,
+                    data: data.data,
+                },
+                responseFormat: options?.responseFormat,
+            }),
         });
     }
     get settingsForEvent() {

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

@@ -10,7 +10,7 @@ const callWithRetryAndThrottle_js_1 = require("../../../core/api/callWithRetryAn
 const postToApi_js_1 = require("../../../core/api/postToApi.cjs");
 const AbstractModel_js_1 = require("../../../model-function/AbstractModel.cjs");
 const parsePartialJson_js_1 = require("../../../model-function/generate-structure/parsePartialJson.cjs");
-const PromptFormatTextGenerationModel_js_1 = require("../../../prompt/PromptFormatTextGenerationModel.cjs");
+const PromptFormatTextStreamingModel_js_1 = require("../../../prompt/PromptFormatTextStreamingModel.cjs");
 const OpenAIApiConfiguration_js_1 = require("../OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("../OpenAIError.cjs");
 const TikTokenTokenizer_js_1 = require("../TikTokenTokenizer.cjs");
@@ -183,27 +183,25 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
         });
     }
     async callAPI(messages, options) {
-        const { run, settings, responseFormat } = options;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...combinedSettings,
-            // map to OpenAI API names:
-            stop: combinedSettings.stopSequences,
-            maxTokens: combinedSettings.maxCompletionTokens,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            messages,
-            responseFormat,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAIChatCompletionAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOpenAIChatCompletionAPI({
+                ...this.settings,
+                // function calling:
+                functions: options.functions ?? this.settings.functions,
+                functionCall: options.functionCall ?? this.settings.functionCall,
+                // map to OpenAI API names:
+                stop: this.settings.stopSequences,
+                maxTokens: this.settings.maxCompletionTokens,
+                // other settings:
+                user: this.settings.isUserIdForwardingEnabled
+                    ? options.run?.userId
+                    : undefined,
+                abortSignal: options.run?.abortSignal,
+                responseFormat: options.responseFormat,
+                messages,
+            }),
         });
     }
     get settingsForEvent() {
@@ -221,24 +219,23 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateTextResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: exports.OpenAIChatResponseFormat.json,
         });
+        return {
+            response,
+            text: response.choices[0].message.content,
+            usage: this.extractUsage(response),
+        };
     }
-    extractText(response) {
-        return response.choices[0].message.content;
-    }
-    generateDeltaStreamResponse(prompt, options) {
+    doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
-            responseFormat: exports.OpenAIChatResponseFormat.deltaIterable,
+            responseFormat: exports.OpenAIChatResponseFormat.textDeltaIterable,
         });
     }
-    extractTextDelta(fullDelta) {
-        return fullDelta[0]?.delta.content ?? undefined;
-    }
     /**
      * JSON generation uses the OpenAI GPT function calling API.
      * It provides a single function specification and instructs the model to provide parameters for calling the function.
@@ -246,69 +243,54 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
      *
      * @see https://platform.openai.com/docs/guides/gpt/function-calling
      */
-    generateStructureResponse(structureDefinition, prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateStructure(structureDefinition, prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
             responseFormat: exports.OpenAIChatResponseFormat.json,
-            functionId: options?.functionId,
-            settings: {
-                ...options,
-                functionCall: { name: structureDefinition.name },
-                functions: [
-                    {
-                        name: structureDefinition.name,
-                        description: structureDefinition.description,
-                        parameters: structureDefinition.schema.getJsonSchema(),
-                    },
-                ],
-            },
-            run: options?.run,
-        });
-    }
-    extractStructure(response) {
-        return secure_json_parse_1.default.parse(response.choices[0].message.function_call.arguments);
-    }
-    generateStructureStreamResponse(structureDefinition, prompt, options) {
-        return this.callAPI(prompt, {
-            responseFormat: exports.OpenAIChatResponseFormat.deltaIterable,
-            functionId: options?.functionId,
-            settings: {
-                ...options,
-                functionCall: { name: structureDefinition.name },
-                functions: [
-                    {
-                        name: structureDefinition.name,
-                        description: structureDefinition.description,
-                        parameters: structureDefinition.schema.getJsonSchema(),
-                    },
-                ],
-            },
-            run: options?.run,
+            functionCall: { name: structureDefinition.name },
+            functions: [
+                {
+                    name: structureDefinition.name,
+                    description: structureDefinition.description,
+                    parameters: structureDefinition.schema.getJsonSchema(),
+                },
+            ],
         });
+        return {
+            response,
+            structure: secure_json_parse_1.default.parse(response.choices[0].message.function_call.arguments),
+            usage: this.extractUsage(response),
+        };
     }
-    extractPartialStructure(fullDelta) {
-        return (0, parsePartialJson_js_1.parsePartialJson)(fullDelta[0]?.function_call?.arguments);
-    }
-    generateStructureOrTextResponse(structureDefinitions, prompt, options) {
+    async doStreamStructure(structureDefinition, prompt, options) {
         return this.callAPI(prompt, {
-            responseFormat: exports.OpenAIChatResponseFormat.json,
-            functionId: options?.functionId,
-            settings: {
-                ...options,
-                functionCall: "auto",
-                functions: structureDefinitions.map((structureDefinition) => ({
+            ...options,
+            responseFormat: exports.OpenAIChatResponseFormat.structureDeltaIterable,
+            functionCall: { name: structureDefinition.name },
+            functions: [
+                {
                     name: structureDefinition.name,
                     description: structureDefinition.description,
                     parameters: structureDefinition.schema.getJsonSchema(),
-                })),
-            },
-            run: options?.run,
+                },
+            ],
         });
     }
-    extractStructureAndText(response) {
+    async doGenerateStructureOrText(structureDefinitions, prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.OpenAIChatResponseFormat.json,
+            functionCall: "auto",
+            functions: structureDefinitions.map((structureDefinition) => ({
+                name: structureDefinition.name,
+                description: structureDefinition.description,
+                parameters: structureDefinition.schema.getJsonSchema(),
+            })),
+        });
         const message = response.choices[0].message;
         const content = message.content;
         const functionCall = message.function_call;
-        return functionCall == null
+        const structureAndText = functionCall == null
             ? {
                 structure: null,
                 value: null,
@@ -319,6 +301,11 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
                 value: secure_json_parse_1.default.parse(functionCall.arguments),
                 text: content,
             };
+        return {
+            response,
+            structureAndText,
+            usage: this.extractUsage(response),
+        };
     }
     extractUsage(response) {
         return {
@@ -328,7 +315,7 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
         };
     }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
             model: this.withSettings({
                 stopSequences: [
                     ...(this.settings.stopSequences ?? []),
@@ -409,8 +396,12 @@ exports.OpenAIChatResponseFormat = {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    deltaIterable: {
+    textDeltaIterable: {
+        stream: true,
+        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => delta[0]?.delta.content ?? ""),
+    },
+    structureDeltaIterable: {
         stream: true,
-        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatFullDeltaIterableQueue)(response.body),
+        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => (0, parsePartialJson_js_1.parsePartialJson)(delta[0]?.function_call?.arguments)),
     },
 };