modelfusion 0.40.1 → 0.41.0

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

@@ -1,18 +1,17 @@
 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 { StructureDefinition } from "../../../core/structure/StructureDefinition.js";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
-import { DeltaEvent } from "../../../model-function/DeltaEvent.js";
-import { ModelFunctionOptions } from "../../../model-function/ModelFunctionOptions.js";
+import { Delta } from "../../../model-function/Delta.js";
 import { StructureGenerationModel } from "../../../model-function/generate-structure/StructureGenerationModel.js";
 import { StructureOrTextGenerationModel } from "../../../model-function/generate-structure/StructureOrTextGenerationModel.js";
-import { TextGenerationModel, TextGenerationModelSettings } from "../../../model-function/generate-text/TextGenerationModel.js";
+import { TextGenerationModelSettings, TextStreamingModel } from "../../../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "../../../prompt/PromptFormat.js";
-import { PromptFormatTextGenerationModel } from "../../../prompt/PromptFormatTextGenerationModel.js";
+import { PromptFormatTextStreamingModel } from "../../../prompt/PromptFormatTextStreamingModel.js";
 import { TikTokenTokenizer } from "../TikTokenTokenizer.js";
 import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
-import { OpenAIChatDelta } from "./OpenAIChatStreamIterable.js";
 export declare const OPENAI_CHAT_MODELS: {
     "gpt-4": {
         contextWindowSize: number;
@@ -132,7 +131,7 @@ export interface OpenAIChatSettings extends TextGenerationModelSettings, Omit<Op
  *   ),
  * ]);
  */
-export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, StructureGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings>, StructureOrTextGenerationModel<OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatSettings> {
+export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextStreamingModel<OpenAIChatMessage[], OpenAIChatSettings>, StructureGenerationModel<OpenAIChatMessage[], OpenAIChatSettings>, StructureOrTextGenerationModel<OpenAIChatMessage[], OpenAIChatSettings> {
     constructor(settings: OpenAIChatSettings);
     readonly provider: "openai";
     get modelName(): OpenAIChatModelType;
@@ -145,37 +144,50 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
     countPromptTokens(messages: OpenAIChatMessage[]): Promise<number>;
     callAPI<RESULT>(messages: Array<OpenAIChatMessage>, options: {
         responseFormat: OpenAIChatResponseFormatType<RESULT>;
-    } & ModelFunctionOptions<Partial<OpenAIChatCallSettings & {
-        user?: string;
-    }>>): Promise<RESULT>;
+    } & FunctionOptions & {
+        functions?: Array<{
+            name: string;
+            description?: string;
+            parameters: unknown;
+        }>;
+        functionCall?: "none" | "auto" | {
+            name: string;
+        };
+    }): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAIChatSettings>;
-    generateTextResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<{
-        object: "chat.completion";
-        model: string;
+    doGenerateText(prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
+        response: {
+            object: "chat.completion";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            id: string;
+            created: number;
+            choices: {
+                message: {
+                    content: string | null;
+                    role: "assistant";
+                    function_call?: {
+                        name: string;
+                        arguments: string;
+                    } | undefined;
+                };
+                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: {
-            message: {
-                content: string | null;
-                role: "assistant";
-                function_call?: {
-                    name: string;
-                    arguments: string;
-                } | undefined;
-            };
-            finish_reason: string;
-            index: number;
-            logprobs?: any;
-        }[];
     }>;
-    extractText(response: OpenAIChatResponse): string;
-    generateDeltaStreamResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
-    extractTextDelta(fullDelta: OpenAIChatDelta): string | undefined;
+    doStreamText(prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
     /**
      * 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.
@@ -183,26 +195,85 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
      *
      * @see https://platform.openai.com/docs/guides/gpt/function-calling
      */
-    generateStructureResponse(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
-    extractStructure(response: OpenAIChatResponse): unknown;
-    generateStructureStreamResponse(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
-    extractPartialStructure(fullDelta: OpenAIChatDelta): unknown | undefined;
-    generateStructureOrTextResponse(structureDefinitions: Array<StructureDefinition<string, unknown>>, prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
-    extractStructureAndText(response: OpenAIChatResponse): {
-        structure: null;
-        value: null;
-        text: string;
-    } | {
-        structure: string;
-        value: any;
-        text: string | null;
-    };
+    doGenerateStructure(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
+        response: {
+            object: "chat.completion";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            id: string;
+            created: number;
+            choices: {
+                message: {
+                    content: string | null;
+                    role: "assistant";
+                    function_call?: {
+                        name: string;
+                        arguments: string;
+                    } | undefined;
+                };
+                finish_reason: string;
+                index: number;
+                logprobs?: any;
+            }[];
+        };
+        structure: any;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+    doStreamStructure(structureDefinition: StructureDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<AsyncIterable<Delta<unknown>>>;
+    doGenerateStructureOrText(structureDefinitions: Array<StructureDefinition<string, unknown>>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
+        response: {
+            object: "chat.completion";
+            model: string;
+            usage: {
+                prompt_tokens: number;
+                completion_tokens: number;
+                total_tokens: number;
+            };
+            id: string;
+            created: number;
+            choices: {
+                message: {
+                    content: string | null;
+                    role: "assistant";
+                    function_call?: {
+                        name: string;
+                        arguments: string;
+                    } | undefined;
+                };
+                finish_reason: string;
+                index: number;
+                logprobs?: any;
+            }[];
+        };
+        structureAndText: {
+            structure: null;
+            value: null;
+            text: string;
+        } | {
+            structure: string;
+            value: any;
+            text: string | null;
+        };
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
     extractUsage(response: OpenAIChatResponse): {
         promptTokens: number;
         completionTokens: number;
         totalTokens: number;
     };
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, OpenAIChatMessage[]>): PromptFormatTextGenerationModel<INPUT_PROMPT, OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings, this>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, OpenAIChatMessage[]>): PromptFormatTextStreamingModel<INPUT_PROMPT, OpenAIChatMessage[], OpenAIChatSettings, this>;
     withSettings(additionalSettings: Partial<OpenAIChatSettings>): this;
 }
 declare const openAIChatResponseSchema: z.ZodObject<{
@@ -366,11 +437,17 @@ export declare const OpenAIChatResponseFormat: {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    deltaIterable: {
+    textDeltaIterable: {
+        stream: true;
+        handler: ({ response }: {
+            response: Response;
+        }) => Promise<AsyncIterable<Delta<string>>>;
+    };
+    structureDeltaIterable: {
         stream: true;
         handler: ({ response }: {
             response: Response;
-        }) => Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
+        }) => Promise<AsyncIterable<Delta<unknown>>>;
     };
 };
 export {};

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,7 +306,7 @@ export class OpenAIChatModel extends AbstractModel {
         };
     }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel({
             model: this.withSettings({
                 stopSequences: [
                     ...(this.settings.stopSequences ?? []),
@@ -399,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"];