modelfusion 0.40.0 → 0.41.0

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

@@ -4,11 +4,11 @@ import { callWithRetryAndThrottle } from "../../../core/api/callWithRetryAndThro
 import { createJsonResponseHandler, postJsonToApi, } from "../../../core/api/postToApi.js";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
 import { parsePartialJson } from "../../../model-function/generate-structure/parsePartialJson.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";
-import { createOpenAIChatFullDeltaIterableQueue, } from "./OpenAIChatStreamIterable.js";
+import { createOpenAIChatDeltaIterableQueue } from "./OpenAIChatStreamIterable.js";
 import { countOpenAIChatPromptTokens } from "./countOpenAIChatMessageTokens.js";
 /*
  * Available OpenAI chat models, their token limits, and pricing.
@@ -174,27 +174,25 @@ export class OpenAIChatModel extends 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 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() {
@@ -212,24 +210,23 @@ export class OpenAIChatModel 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: 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: OpenAIChatResponseFormat.deltaIterable,
+            responseFormat: 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.
@@ -237,69 +234,54 @@ export class OpenAIChatModel extends 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: 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 SecureJSON.parse(response.choices[0].message.function_call.arguments);
-    }
-    generateStructureStreamResponse(structureDefinition, prompt, options) {
-        return this.callAPI(prompt, {
-            responseFormat: 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: SecureJSON.parse(response.choices[0].message.function_call.arguments),
+            usage: this.extractUsage(response),
+        };
     }
-    extractPartialStructure(fullDelta) {
-        return parsePartialJson(fullDelta[0]?.function_call?.arguments);
-    }
-    generateStructureOrTextResponse(structureDefinitions, prompt, options) {
+    async doStreamStructure(structureDefinition, prompt, options) {
         return this.callAPI(prompt, {
-            responseFormat: OpenAIChatResponseFormat.json,
-            functionId: options?.functionId,
-            settings: {
-                ...options,
-                functionCall: "auto",
-                functions: structureDefinitions.map((structureDefinition) => ({
+            ...options,
+            responseFormat: 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: 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,
@@ -310,6 +292,11 @@ export class OpenAIChatModel extends AbstractModel {
                 value: SecureJSON.parse(functionCall.arguments),
                 text: content,
             };
+        return {
+            response,
+            structureAndText,
+            usage: this.extractUsage(response),
+        };
     }
     extractUsage(response) {
         return {
@@ -319,8 +306,13 @@ export class OpenAIChatModel extends AbstractModel {
         };
     }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel({
-            model: this.withSettings({ stopSequences: promptFormat.stopSequences }),
+        return new PromptFormatTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
+            }),
             promptFormat,
         });
     }
@@ -394,8 +386,12 @@ export const OpenAIChatResponseFormat = {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    deltaIterable: {
+    textDeltaIterable: {
+        stream: true,
+        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => delta[0]?.delta.content ?? ""),
+    },
+    structureDeltaIterable: {
         stream: true,
-        handler: async ({ response }) => createOpenAIChatFullDeltaIterableQueue(response.body),
+        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => parsePartialJson(delta[0]?.function_call?.arguments)),
     },
 };

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOpenAIChatFullDeltaIterableQueue = void 0;
+exports.createOpenAIChatDeltaIterableQueue = void 0;
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
 const AsyncQueue_js_1 = require("../../../event-source/AsyncQueue.cjs");
@@ -28,7 +28,7 @@ const chatResponseStreamEventSchema = zod_1.z.object({
     model: zod_1.z.string(),
     object: zod_1.z.string(),
 });
-async function createOpenAIChatFullDeltaIterableQueue(stream) {
+async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaValue) {
     const queue = new AsyncQueue_js_1.AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
@@ -96,6 +96,7 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
                 queue.push({
                     type: "delta",
                     fullDelta: streamDeltaDeepCopy,
+                    valueDelta: extractDeltaValue(streamDeltaDeepCopy),
                 });
             }
         }
@@ -112,4 +113,4 @@ async function createOpenAIChatFullDeltaIterableQueue(stream) {
     });
     return queue;
 }
-exports.createOpenAIChatFullDeltaIterableQueue = createOpenAIChatFullDeltaIterableQueue;
+exports.createOpenAIChatDeltaIterableQueue = createOpenAIChatDeltaIterableQueue;

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

@@ -1,4 +1,4 @@
-import { DeltaEvent } from "../../../model-function/DeltaEvent.js";
+import { Delta } from "../../../model-function/Delta.js";
 export type OpenAIChatDelta = Array<{
     role: "assistant" | "user" | undefined;
     content: string;
@@ -16,4 +16,4 @@ export type OpenAIChatDelta = Array<{
         };
     };
 }>;
-export declare function createOpenAIChatFullDeltaIterableQueue(stream: ReadableStream<Uint8Array>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
+export declare function createOpenAIChatDeltaIterableQueue<VALUE>(stream: ReadableStream<Uint8Array>, extractDeltaValue: (delta: OpenAIChatDelta) => VALUE): Promise<AsyncIterable<Delta<VALUE>>>;

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

@@ -22,7 +22,7 @@ const chatResponseStreamEventSchema = z.object({
     model: z.string(),
     object: z.string(),
 });
-export async function createOpenAIChatFullDeltaIterableQueue(stream) {
+export async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaValue) {
     const queue = new AsyncQueue();
     const streamDelta = [];
     // process the stream asynchonously (no 'await' on purpose):
@@ -90,6 +90,7 @@ export async function createOpenAIChatFullDeltaIterableQueue(stream) {
                 queue.push({
                     type: "delta",
                     fullDelta: streamDeltaDeepCopy,
+                    valueDelta: extractDeltaValue(streamDeltaDeepCopy),
                 });
             }
         }

package/model-provider/stability/StabilityImageGenerationModel.cjs

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StabilityImageGenerationModel = void 0;
 const zod_1 = 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 StabilityError_js_1 = require("./StabilityError.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const StabilityApiConfiguration_js_1 = require("./StabilityApiConfiguration.cjs");
+const StabilityError_js_1 = require("./StabilityError.cjs");
 /**
  * Create an image generation model that calls the Stability AI image generation API.
  *
@@ -43,21 +43,15 @@ class StabilityImageGenerationModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.model;
     }
     async callAPI(input, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            // copied settings:
-            ...this.settings,
-            ...settings,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            engineId: this.settings.model,
-            textPrompts: input,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callStabilityImageGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callStabilityImageGenerationAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                engineId: this.settings.model,
+                textPrompts: input,
+            }),
         });
     }
     get settingsForEvent() {
@@ -75,11 +69,12 @@ class StabilityImageGenerationModel extends AbstractModel_js_1.AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateImageResponse(prompt, options) {
-        return this.callAPI(prompt, options);
-    }
-    extractBase64Image(response) {
-        return response.artifacts[0].base64;
+    async doGenerateImage(prompt, options) {
+        const response = await this.callAPI(prompt, options);
+        return {
+            response,
+            base64Image: response.artifacts[0].base64,
+        };
     }
     withSettings(additionalSettings) {
         return new StabilityImageGenerationModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/stability/StabilityImageGenerationModel.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 { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
 /**
  * Create an image generation model that calls the Stability AI image generation API.
@@ -25,20 +25,22 @@ import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-
  *   ]
  * );
  */
-export declare class StabilityImageGenerationModel extends AbstractModel<StabilityImageGenerationModelSettings> implements ImageGenerationModel<StabilityImageGenerationPrompt, StabilityImageGenerationResponse, StabilityImageGenerationModelSettings> {
+export declare class StabilityImageGenerationModel extends AbstractModel<StabilityImageGenerationModelSettings> implements ImageGenerationModel<StabilityImageGenerationPrompt, StabilityImageGenerationModelSettings> {
     constructor(settings: StabilityImageGenerationModelSettings);
     readonly provider: "stability";
     get modelName(): StabilityImageGenerationModelType;
-    callAPI(input: StabilityImageGenerationPrompt, options?: ModelFunctionOptions<StabilityImageGenerationModelSettings>): Promise<StabilityImageGenerationResponse>;
+    callAPI(input: StabilityImageGenerationPrompt, options?: FunctionOptions): Promise<StabilityImageGenerationResponse>;
     get settingsForEvent(): Partial<StabilityImageGenerationModelSettings>;
-    generateImageResponse(prompt: StabilityImageGenerationPrompt, options?: ModelFunctionOptions<StabilityImageGenerationModelSettings>): Promise<{
-        artifacts: {
-            seed: number;
-            base64: string;
-            finishReason: "SUCCESS" | "ERROR" | "CONTENT_FILTERED";
-        }[];
+    doGenerateImage(prompt: StabilityImageGenerationPrompt, options?: FunctionOptions): Promise<{
+        response: {
+            artifacts: {
+                seed: number;
+                base64: string;
+                finishReason: "SUCCESS" | "ERROR" | "CONTENT_FILTERED";
+            }[];
+        };
+        base64Image: string;
     }>;
-    extractBase64Image(response: StabilityImageGenerationResponse): string;
     withSettings(additionalSettings: StabilityImageGenerationModelSettings): this;
 }
 declare const stabilityImageGenerationModels: readonly ["stable-diffusion-v1-5", "stable-diffusion-512-v2-1", "stable-diffusion-xl-1024-v0-9", "stable-diffusion-xl-1024-v1-0"];

package/model-provider/stability/StabilityImageGenerationModel.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
-import { failedStabilityCallResponseHandler } from "./StabilityError.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { StabilityApiConfiguration } from "./StabilityApiConfiguration.js";
+import { failedStabilityCallResponseHandler } from "./StabilityError.js";
 /**
  * Create an image generation model that calls the Stability AI image generation API.
  *
@@ -40,21 +40,15 @@ export class StabilityImageGenerationModel extends AbstractModel {
         return this.settings.model;
     }
     async callAPI(input, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            // copied settings:
-            ...this.settings,
-            ...settings,
-            // other settings:
-            abortSignal: run?.abortSignal,
-            engineId: this.settings.model,
-            textPrompts: input,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callStabilityImageGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callStabilityImageGenerationAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                engineId: this.settings.model,
+                textPrompts: input,
+            }),
         });
     }
     get settingsForEvent() {
@@ -72,11 +66,12 @@ export class StabilityImageGenerationModel extends AbstractModel {
         ];
         return Object.fromEntries(Object.entries(this.settings).filter(([key]) => eventSettingProperties.includes(key)));
     }
-    generateImageResponse(prompt, options) {
-        return this.callAPI(prompt, options);
-    }
-    extractBase64Image(response) {
-        return response.artifacts[0].base64;
+    async doGenerateImage(prompt, options) {
+        const response = await this.callAPI(prompt, options);
+        return {
+            response,
+            base64Image: response.artifacts[0].base64,
+        };
     }
     withSettings(additionalSettings) {
         return new StabilityImageGenerationModel(Object.assign({}, this.settings, additionalSettings));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/prompt/PromptFormatTextGenerationModel.cjs

@@ -37,30 +37,17 @@ class PromptFormatTextGenerationModel {
         }
         return ((prompt) => originalCountPromptTokens(this.promptFormat.format(prompt)));
     }
-    generateTextResponse(prompt, options) {
+    doGenerateText(prompt, options) {
         const mappedPrompt = this.promptFormat.format(prompt);
-        return this.model.generateTextResponse(mappedPrompt, options);
-    }
-    extractText(response) {
-        return this.model.extractText(response);
-    }
-    get generateDeltaStreamResponse() {
-        const originalGenerateDeltaStreamResponse = this.model.generateDeltaStreamResponse?.bind(this.model);
-        if (originalGenerateDeltaStreamResponse === undefined) {
-            return undefined;
-        }
-        return ((prompt, options) => {
-            const mappedPrompt = this.promptFormat.format(prompt);
-            return originalGenerateDeltaStreamResponse(mappedPrompt, options);
-        });
-    }
-    get extractTextDelta() {
-        return this.model.extractTextDelta;
+        return this.model.doGenerateText(mappedPrompt, options);
     }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextGenerationModel({
             model: this.withSettings({
-                stopSequences: promptFormat.stopSequences,
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
             }),
             promptFormat,
         });

package/prompt/PromptFormatTextGenerationModel.d.ts

@@ -1,10 +1,9 @@
-import { DeltaEvent } from "../model-function/DeltaEvent.js";
-import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
+import { FunctionOptions } from "../core/FunctionOptions.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "./PromptFormat.js";
-export declare class PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, RESPONSE, FULL_DELTA, SETTINGS extends TextGenerationModelSettings, MODEL extends TextGenerationModel<MODEL_PROMPT, RESPONSE, FULL_DELTA, SETTINGS>> implements TextGenerationModel<PROMPT, RESPONSE, FULL_DELTA, SETTINGS> {
-    private readonly model;
-    private readonly promptFormat;
+export declare class PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, SETTINGS extends TextGenerationModelSettings, MODEL extends TextGenerationModel<MODEL_PROMPT, SETTINGS>> implements TextGenerationModel<PROMPT, SETTINGS> {
+    readonly model: MODEL;
+    readonly promptFormat: PromptFormat<PROMPT, MODEL_PROMPT>;
     constructor({ model, promptFormat, }: {
         model: MODEL;
         promptFormat: PromptFormat<PROMPT, MODEL_PROMPT>;
@@ -14,11 +13,16 @@ export declare class PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, RESPO
     get tokenizer(): MODEL["tokenizer"];
     get contextWindowSize(): MODEL["contextWindowSize"];
     get countPromptTokens(): MODEL["countPromptTokens"] extends undefined ? undefined : (prompt: PROMPT) => PromiseLike<number>;
-    generateTextResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
-    extractText(response: RESPONSE): string;
-    get generateDeltaStreamResponse(): MODEL["generateDeltaStreamResponse"] extends undefined ? undefined : (prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
-    get extractTextDelta(): MODEL["extractTextDelta"];
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, RESPONSE, FULL_DELTA, SETTINGS, this>;
+    doGenerateText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+        response: unknown;
+        text: string;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        } | undefined;
+    }>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
     get settingsForEvent(): Partial<SETTINGS>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

package/prompt/PromptFormatTextGenerationModel.js

@@ -34,30 +34,17 @@ export class PromptFormatTextGenerationModel {
         }
         return ((prompt) => originalCountPromptTokens(this.promptFormat.format(prompt)));
     }
-    generateTextResponse(prompt, options) {
+    doGenerateText(prompt, options) {
         const mappedPrompt = this.promptFormat.format(prompt);
-        return this.model.generateTextResponse(mappedPrompt, options);
-    }
-    extractText(response) {
-        return this.model.extractText(response);
-    }
-    get generateDeltaStreamResponse() {
-        const originalGenerateDeltaStreamResponse = this.model.generateDeltaStreamResponse?.bind(this.model);
-        if (originalGenerateDeltaStreamResponse === undefined) {
-            return undefined;
-        }
-        return ((prompt, options) => {
-            const mappedPrompt = this.promptFormat.format(prompt);
-            return originalGenerateDeltaStreamResponse(mappedPrompt, options);
-        });
-    }
-    get extractTextDelta() {
-        return this.model.extractTextDelta;
+        return this.model.doGenerateText(mappedPrompt, options);
     }
     withPromptFormat(promptFormat) {
         return new PromptFormatTextGenerationModel({
             model: this.withSettings({
-                stopSequences: promptFormat.stopSequences,
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
             }),
             promptFormat,
         });

package/prompt/PromptFormatTextStreamingModel.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromptFormatTextStreamingModel = void 0;
+const PromptFormatTextGenerationModel_js_1 = require("./PromptFormatTextGenerationModel.cjs");
+class PromptFormatTextStreamingModel extends PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel {
+    constructor(options) {
+        super(options);
+    }
+    doStreamText(prompt, options) {
+        const mappedPrompt = this.promptFormat.format(prompt);
+        return this.model.doStreamText(mappedPrompt, options);
+    }
+    withPromptFormat(promptFormat) {
+        return new PromptFormatTextStreamingModel({
+            model: this.withSettings({
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
+            }),
+            promptFormat,
+        });
+    }
+    withSettings(additionalSettings) {
+        return new PromptFormatTextStreamingModel({
+            model: this.model.withSettings(additionalSettings),
+            promptFormat: this.promptFormat,
+        });
+    }
+}
+exports.PromptFormatTextStreamingModel = PromptFormatTextStreamingModel;

package/prompt/PromptFormatTextStreamingModel.d.ts

@@ -0,0 +1,13 @@
+import { FunctionOptions } from "../core/FunctionOptions.js";
+import { TextGenerationModelSettings, TextStreamingModel } from "../model-function/generate-text/TextGenerationModel.js";
+import { PromptFormat } from "./PromptFormat.js";
+import { PromptFormatTextGenerationModel } from "./PromptFormatTextGenerationModel.js";
+export declare class PromptFormatTextStreamingModel<PROMPT, MODEL_PROMPT, SETTINGS extends TextGenerationModelSettings, MODEL extends TextStreamingModel<MODEL_PROMPT, SETTINGS>> extends PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, SETTINGS, MODEL> implements TextStreamingModel<PROMPT, SETTINGS> {
+    constructor(options: {
+        model: MODEL;
+        promptFormat: PromptFormat<PROMPT, MODEL_PROMPT>;
+    });
+    doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<import("../index.js").Delta<string>>>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextStreamingModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
+    withSettings(additionalSettings: Partial<SETTINGS>): this;
+}