modelfusion 0.40.1 → 0.41.0

package/model-provider/llamacpp/LlamaCppTextGenerationModel.js

@@ -5,7 +5,7 @@ import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postTo
 import { AsyncQueue } from "../../event-source/AsyncQueue.js";
 import { parseEventSourceStream } from "../../event-source/parseEventSourceStream.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
+import { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { LlamaCppApiConfiguration } from "./LlamaCppApiConfiguration.js";
 import { failedLlamaCppCallResponseHandler } from "./LlamaCppError.js";
 import { LlamaCppTokenizer } from "./LlamaCppTokenizer.js";
@@ -33,25 +33,19 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
         return this.settings.contextWindowSize;
     }
     async callAPI(prompt, options) {
-        const { run, settings, responseFormat } = options;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            ...combinedSettings,
-            // mapping
-            nPredict: combinedSettings.maxCompletionTokens,
-            stop: combinedSettings.stopSequences,
-            // other
-            abortSignal: run?.abortSignal,
-            prompt,
-            responseFormat,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callLlamaCppTextGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callLlamaCppTextGenerationAPI({
+                ...this.settings,
+                // mapping
+                nPredict: this.settings.maxCompletionTokens,
+                stop: this.settings.stopSequences,
+                // other
+                abortSignal: options.run?.abortSignal,
+                prompt,
+                responseFormat: options.responseFormat,
+            }),
         });
     }
     get settingsForEvent() {
@@ -81,16 +75,22 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
         const tokens = await this.tokenizer.tokenize(prompt);
         return tokens.length;
     }
-    generateTextResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateText(prompt, options) {
+        const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: LlamaCppTextGenerationResponseFormat.json,
         });
+        return {
+            response,
+            text: response.content,
+            usage: {
+                promptTokens: response.tokens_evaluated,
+                completionTokens: response.tokens_predicted,
+                totalTokens: response.tokens_evaluated + response.tokens_predicted,
+            },
+        };
     }
-    extractText(response) {
-        return response.content;
-    }
-    generateDeltaStreamResponse(prompt, options) {
+    doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
             responseFormat: LlamaCppTextGenerationResponseFormat.deltaIterable,
@@ -100,7 +100,7 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
         return fullDelta.delta;
     }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel({
             model: this.withSettings({
                 stopSequences: [
                     ...(this.settings.stopSequences ?? []),
@@ -110,13 +110,6 @@ export class LlamaCppTextGenerationModel extends AbstractModel {
             promptFormat,
         });
     }
-    extractUsage(response) {
-        return {
-            promptTokens: response.tokens_evaluated,
-            completionTokens: response.tokens_predicted,
-            totalTokens: response.tokens_evaluated + response.tokens_predicted,
-        };
-    }
     withSettings(additionalSettings) {
         return new LlamaCppTextGenerationModel(Object.assign({}, this.settings, additionalSettings));
     }
@@ -235,6 +228,7 @@ async function createLlamaCppFullDeltaIterableQueue(stream) {
                         isComplete: eventData.stop,
                         delta: eventData.content,
                     },
+                    valueDelta: eventData.content,
                 });
                 if (eventData.stop) {
                     queue.close();

package/model-provider/lmnt/LmntSpeechSynthesisModel.cjs

@@ -25,19 +25,14 @@ class LmntSpeechSynthesisModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.voice;
     }
     async callAPI(text, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            // copied settings:
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            text,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callLmntTextToSpeechAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callLmntTextToSpeechAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                text,
+            }),
         });
     }
     get settingsForEvent() {

package/model-provider/lmnt/LmntSpeechSynthesisModel.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { SpeechSynthesisModel, SpeechSynthesisModelSettings } from "../../model-function/synthesize-speech/SpeechSynthesisModel.js";
 export interface LmntSpeechSynthesisModelSettings extends SpeechSynthesisModelSettings {
     api?: ApiConfiguration;
@@ -21,6 +21,6 @@ export declare class LmntSpeechSynthesisModel extends AbstractModel<LmntSpeechSy
     get modelName(): string;
     private callAPI;
     get settingsForEvent(): Partial<LmntSpeechSynthesisModelSettings>;
-    generateSpeechResponse(text: string, options?: ModelFunctionOptions<LmntSpeechSynthesisModelSettings> | undefined): Promise<Buffer>;
+    generateSpeechResponse(text: string, options?: FunctionOptions): Promise<Buffer>;
     withSettings(additionalSettings: Partial<LmntSpeechSynthesisModelSettings>): this;
 }

package/model-provider/lmnt/LmntSpeechSynthesisModel.js

@@ -22,19 +22,14 @@ export class LmntSpeechSynthesisModel extends AbstractModel {
         return this.settings.voice;
     }
     async callAPI(text, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            // copied settings:
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            text,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callLmntTextToSpeechAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callLmntTextToSpeechAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                text,
+            }),
         });
     }
     get settingsForEvent() {

package/model-provider/openai/OpenAIImageGenerationModel.cjs

@@ -46,17 +46,10 @@ class OpenAIImageGenerationModel extends AbstractModel_js_1.AbstractModel {
     }
     async callAPI(prompt, options) {
         const run = options?.run;
-        const settings = options?.settings;
         const responseFormat = options?.responseFormat;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
         const callSettings = {
+            ...this.settings,
             user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
             abortSignal: run?.abortSignal,
             responseFormat,
             prompt,
@@ -74,16 +67,15 @@ class OpenAIImageGenerationModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateImageResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateImage(prompt, options) {
+        const response = await this.callAPI(prompt, {
             responseFormat: exports.OpenAIImageGenerationResponseFormat.base64Json,
-            functionId: options?.functionId,
-            settings: options?.settings,
-            run: options?.run,
+            ...options,
         });
-    }
-    extractBase64Image(response) {
-        return response.data[0].b64_json;
+        return {
+            response,
+            base64Image: response.data[0].b64_json,
+        };
     }
     withSettings(additionalSettings) {
         return new OpenAIImageGenerationModel(Object.assign({}, this.settings, additionalSettings));

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

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
 import { ResponseHandler } from "../../core/api/postToApi.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 export interface OpenAIImageGenerationCallSettings {
     n?: number;
     size?: "256x256" | "512x512" | "1024x1024";
@@ -26,23 +26,23 @@ export interface OpenAIImageGenerationSettings extends ImageGenerationModelSetti
  *   "the wicked witch of the west in the style of early 19th century painting"
  * );
  */
-export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImageGenerationSettings> implements ImageGenerationModel<string, OpenAIImageGenerationBase64JsonResponse, OpenAIImageGenerationSettings> {
+export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImageGenerationSettings> implements ImageGenerationModel<string, OpenAIImageGenerationSettings> {
     constructor(settings: OpenAIImageGenerationSettings);
     readonly provider: "openai";
     readonly modelName: null;
     callAPI<RESULT>(prompt: string, options: {
         responseFormat: OpenAIImageGenerationResponseFormatType<RESULT>;
-    } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & {
-        user?: string;
-    }>>): Promise<RESULT>;
+    } & FunctionOptions): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAIImageGenerationSettings>;
-    generateImageResponse(prompt: string, options?: ModelFunctionOptions<OpenAIImageGenerationSettings>): Promise<{
-        data: {
-            b64_json: string;
-        }[];
-        created: number;
+    doGenerateImage(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
+            data: {
+                b64_json: string;
+            }[];
+            created: number;
+        };
+        base64Image: string;
     }>;
-    extractBase64Image(response: OpenAIImageGenerationBase64JsonResponse): string;
     withSettings(additionalSettings: Partial<OpenAIImageGenerationSettings>): this;
 }
 export type OpenAIImageGenerationResponseFormatType<T> = {

package/model-provider/openai/OpenAIImageGenerationModel.js

@@ -42,17 +42,10 @@ export class OpenAIImageGenerationModel extends AbstractModel {
     }
     async callAPI(prompt, options) {
         const run = options?.run;
-        const settings = options?.settings;
         const responseFormat = options?.responseFormat;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
         const callSettings = {
+            ...this.settings,
             user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
             abortSignal: run?.abortSignal,
             responseFormat,
             prompt,
@@ -70,16 +63,15 @@ export class OpenAIImageGenerationModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateImageResponse(prompt, options) {
-        return this.callAPI(prompt, {
+    async doGenerateImage(prompt, options) {
+        const response = await this.callAPI(prompt, {
             responseFormat: OpenAIImageGenerationResponseFormat.base64Json,
-            functionId: options?.functionId,
-            settings: options?.settings,
-            run: options?.run,
+            ...options,
         });
-    }
-    extractBase64Image(response) {
-        return response.data[0].b64_json;
+        return {
+            response,
+            base64Image: response.data[0].b64_json,
+        };
     }
     withSettings(additionalSettings) {
         return new OpenAIImageGenerationModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/openai/OpenAITextEmbeddingModel.cjs

@@ -5,10 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAITextEmbeddingModel = exports.calculateOpenAIEmbeddingCostInMillicents = exports.isOpenAIEmbeddingModel = exports.OPENAI_TEXT_EMBEDDING_MODELS = void 0;
 const zod_1 = __importDefault(require("zod"));
-const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
-const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.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 countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.cjs");
 const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
 const OpenAIError_js_1 = require("./OpenAIError.cjs");
 const TikTokenTokenizer_js_1 = require("./TikTokenTokenizer.cjs");
@@ -91,37 +91,31 @@ class OpenAITextEmbeddingModel extends AbstractModel_js_1.AbstractModel {
         return (0, countTokens_js_1.countTokens)(this.tokenizer, input);
     }
     async callAPI(texts, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            input: texts,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAITextEmbeddingAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOpenAITextEmbeddingAPI({
+                ...this.settings,
+                user: this.settings.isUserIdForwardingEnabled
+                    ? options?.run?.userId
+                    : undefined,
+                abortSignal: options?.run?.abortSignal,
+                input: texts,
+            }),
         });
     }
     get settingsForEvent() {
         return {};
     }
-    generateEmbeddingResponse(texts, options) {
+    async doEmbedValues(texts, options) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The OpenAI embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
-        return this.callAPI(texts, options);
-    }
-    extractEmbeddings(response) {
-        return response.data.map((data) => data.embedding);
+        const response = await this.callAPI(texts, options);
+        return {
+            response,
+            embeddings: response.data.map((data) => data.embedding),
+        };
     }
     withSettings(additionalSettings) {
         return new OpenAITextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));

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

@@ -1,7 +1,7 @@
 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 { AbstractModel } from "../../model-function/AbstractModel.js";
 import { EmbeddingModel, EmbeddingModelSettings } from "../../model-function/embed/EmbeddingModel.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
 export declare const OPENAI_TEXT_EMBEDDING_MODELS: {
@@ -36,7 +36,7 @@ export interface OpenAITextEmbeddingModelSettings extends EmbeddingModelSettings
  *   ]
  * );
  */
-export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEmbeddingModelSettings> implements EmbeddingModel<string, OpenAITextEmbeddingResponse, OpenAITextEmbeddingModelSettings> {
+export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEmbeddingModelSettings> implements EmbeddingModel<string, OpenAITextEmbeddingModelSettings> {
     constructor(settings: OpenAITextEmbeddingModelSettings);
     readonly provider: "openai";
     get modelName(): "text-embedding-ada-002";
@@ -45,22 +45,24 @@ export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEm
     readonly tokenizer: TikTokenTokenizer;
     readonly contextWindowSize: number;
     countTokens(input: string): Promise<number>;
-    callAPI(texts: Array<string>, options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
+    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<OpenAITextEmbeddingResponse>;
     get settingsForEvent(): Partial<OpenAITextEmbeddingModelSettings>;
-    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<{
-        object: "list";
-        model: string;
-        usage: {
-            prompt_tokens: number;
-            total_tokens: number;
+    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+        response: {
+            object: "list";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                total_tokens: number;
+            };
+            data: {
+                object: "embedding";
+                embedding: number[];
+                index: number;
+            }[];
         };
-        data: {
-            object: "embedding";
-            embedding: number[];
-            index: number;
-        }[];
+        embeddings: number[][];
     }>;
-    extractEmbeddings(response: OpenAITextEmbeddingResponse): number[][];
     withSettings(additionalSettings: OpenAITextEmbeddingModelSettings): this;
 }
 declare const openAITextEmbeddingResponseSchema: z.ZodObject<{

package/model-provider/openai/OpenAITextEmbeddingModel.js

@@ -1,8 +1,8 @@
 import z from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { countTokens } from "../../model-function/tokenize-text/countTokens.js";
 import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
 import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 import { TikTokenTokenizer } from "./TikTokenTokenizer.js";
@@ -83,37 +83,31 @@ export class OpenAITextEmbeddingModel extends AbstractModel {
         return countTokens(this.tokenizer, input);
     }
     async callAPI(texts, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            user: this.settings.isUserIdForwardingEnabled ? run?.userId : undefined,
-            // Copied settings:
-            ...combinedSettings,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            input: texts,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callOpenAITextEmbeddingAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callOpenAITextEmbeddingAPI({
+                ...this.settings,
+                user: this.settings.isUserIdForwardingEnabled
+                    ? options?.run?.userId
+                    : undefined,
+                abortSignal: options?.run?.abortSignal,
+                input: texts,
+            }),
         });
     }
     get settingsForEvent() {
         return {};
     }
-    generateEmbeddingResponse(texts, options) {
+    async doEmbedValues(texts, options) {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The OpenAI embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
-        return this.callAPI(texts, options);
-    }
-    extractEmbeddings(response) {
-        return response.data.map((data) => data.embedding);
+        const response = await this.callAPI(texts, options);
+        return {
+            response,
+            embeddings: response.data.map((data) => data.embedding),
+        };
     }
     withSettings(additionalSettings) {
         return new OpenAITextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/openai/OpenAITextGenerationModel.cjs

@@ -12,7 +12,7 @@ const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.cjs");
 const parseEventSourceStream_js_1 = require("../../event-source/parseEventSourceStream.cjs");
 const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const countTokens_js_1 = require("../../model-function/tokenize-text/countTokens.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");
@@ -181,18 +181,14 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return (0, countTokens_js_1.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,
@@ -221,26 +217,29 @@ class OpenAITextGenerationModel 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.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: exports.OpenAITextResponseFormat.deltaIterable,
         });
     }
-    extractTextDelta(fullDelta) {
-        return fullDelta[0].delta;
-    }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
             model: this.withSettings({
                 stopSequences: [
                     ...(this.settings.stopSequences ?? []),
@@ -250,13 +249,6 @@ class OpenAITextGenerationModel extends AbstractModel_js_1.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));
     }
@@ -385,6 +377,7 @@ async function createOpenAITextFullDeltaIterableQueue(stream) {
                 queue.push({
                     type: "delta",
                     fullDelta: streamDeltaDeepCopy,
+                    valueDelta: streamDeltaDeepCopy[0].delta,
                 });
             }
         }