modelfusion 0.40.0 → 0.41.0

package/model-provider/cohere/CohereTextEmbeddingModel.d.ts

@@ -1,7 +1,7 @@
 import z from "zod";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { EmbeddingModel, EmbeddingModelSettings } from "../../model-function/embed/EmbeddingModel.js";
 import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
 export declare const COHERE_TEXT_EMBEDDING_MODELS: {
@@ -38,7 +38,7 @@ export interface CohereTextEmbeddingModelSettings extends EmbeddingModelSettings
  *   ]
  * );
  */
-export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEmbeddingModelSettings> implements EmbeddingModel<string, CohereTextEmbeddingResponse, CohereTextEmbeddingModelSettings>, FullTokenizer {
+export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEmbeddingModelSettings> implements EmbeddingModel<string, CohereTextEmbeddingModelSettings>, FullTokenizer {
     constructor(settings: CohereTextEmbeddingModelSettings);
     readonly provider: "cohere";
     get modelName(): "embed-english-light-v2.0" | "embed-english-v2.0" | "embed-multilingual-v2.0";
@@ -52,19 +52,21 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
         tokenTexts: string[];
     }>;
     detokenize(tokens: number[]): Promise<string>;
-    callAPI(texts: Array<string>, options?: ModelFunctionOptions<CohereTextEmbeddingModelSettings>): Promise<CohereTextEmbeddingResponse>;
+    callAPI(texts: Array<string>, options?: FunctionOptions): Promise<CohereTextEmbeddingResponse>;
     get settingsForEvent(): Partial<CohereTextEmbeddingModelSettings>;
-    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<CohereTextEmbeddingModelSettings>): Promise<{
-        id: string;
-        meta: {
-            api_version: {
-                version: string;
+    doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
+        response: {
+            id: string;
+            meta: {
+                api_version: {
+                    version: string;
+                };
             };
+            texts: string[];
+            embeddings: number[][];
         };
-        texts: string[];
         embeddings: number[][];
     }>;
-    extractEmbeddings(response: CohereTextEmbeddingResponse): number[][];
     withSettings(additionalSettings: Partial<CohereTextEmbeddingModelSettings>): this;
 }
 declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{

package/model-provider/cohere/CohereTextEmbeddingModel.js

@@ -91,18 +91,14 @@ export class CohereTextEmbeddingModel extends AbstractModel {
         if (texts.length > this.maxValuesPerCall) {
             throw new Error(`The Cohere embedding API only supports ${this.maxValuesPerCall} texts per API call.`);
         }
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            texts,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callCohereEmbeddingAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callCohereEmbeddingAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                texts,
+            }),
         });
     }
     get settingsForEvent() {
@@ -110,11 +106,12 @@ export class CohereTextEmbeddingModel extends AbstractModel {
             truncate: this.settings.truncate,
         };
     }
-    generateEmbeddingResponse(texts, options) {
-        return this.callAPI(texts, options);
-    }
-    extractEmbeddings(response) {
-        return response.embeddings;
+    async doEmbedValues(texts, options) {
+        const response = await this.callAPI(texts, options);
+        return {
+            response,
+            embeddings: response.embeddings,
+        };
     }
     withSettings(additionalSettings) {
         return new CohereTextEmbeddingModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/cohere/CohereTextGenerationModel.cjs

@@ -11,7 +11,7 @@ const postToApi_js_1 = require("../../core/api/postToApi.cjs");
 const AsyncQueue_js_1 = require("../../event-source/AsyncQueue.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 CohereApiConfiguration_js_1 = require("./CohereApiConfiguration.cjs");
 const CohereError_js_1 = require("./CohereError.cjs");
 const CohereTokenizer_js_1 = require("./CohereTokenizer.cjs");
@@ -81,27 +81,21 @@ class CohereTextGenerationModel 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 callSettings = {
-            ...combinedSettings,
-            // use endSequences instead of stopSequences
-            // to exclude stop tokens from the generated text
-            endSequences: combinedSettings.stopSequences,
-            maxTokens: combinedSettings.maxCompletionTokens,
-            // mapped name because of conflict with stopSequences:
-            stopSequences: combinedSettings.cohereStopSequences,
-            abortSignal: run?.abortSignal,
-            prompt,
-            responseFormat,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callCohereTextGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callCohereTextGenerationAPI({
+                ...this.settings,
+                // use endSequences instead of stopSequences
+                // to exclude stop tokens from the generated text
+                endSequences: this.settings.stopSequences,
+                maxTokens: this.settings.maxCompletionTokens,
+                // mapped name because of conflict with stopSequences:
+                stopSequences: this.settings.cohereStopSequences,
+                abortSignal: options.run?.abortSignal,
+                responseFormat: options.responseFormat,
+                prompt,
+            }),
         });
     }
     get settingsForEvent() {
@@ -121,16 +115,17 @@ class CohereTextGenerationModel 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.CohereTextGenerationResponseFormat.json,
         });
+        return {
+            response,
+            text: response.generations[0].text,
+        };
     }
-    extractText(response) {
-        return response.generations[0].text;
-    }
-    generateDeltaStreamResponse(prompt, options) {
+    doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
             responseFormat: exports.CohereTextGenerationResponseFormat.deltaIterable,
@@ -140,9 +135,12 @@ class CohereTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return fullDelta.delta;
     }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel_js_1.PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel_js_1.PromptFormatTextStreamingModel({
             model: this.withSettings({
-                stopSequences: promptFormat.stopSequences,
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
             }),
             promptFormat,
         });
@@ -218,6 +216,7 @@ async function createCohereTextGenerationFullDeltaIterableQueue(stream) {
                     isComplete: true,
                     delta: "",
                 },
+                valueDelta: "",
             });
         }
         else {
@@ -229,6 +228,7 @@ async function createCohereTextGenerationFullDeltaIterableQueue(stream) {
                     isComplete: false,
                     delta: event.text,
                 },
+                valueDelta: event.text,
             });
         }
     }

package/model-provider/cohere/CohereTextGenerationModel.d.ts

@@ -1,12 +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 { PromptFormatTextStreamingModel } from "../../prompt/PromptFormatTextStreamingModel.js";
 import { CohereTokenizer } from "./CohereTokenizer.js";
 export declare const COHERE_TEXT_GENERATION_MODELS: {
     command: {
@@ -54,7 +54,7 @@ export interface CohereTextGenerationModelSettings extends TextGenerationModelSe
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-export declare class CohereTextGenerationModel extends AbstractModel<CohereTextGenerationModelSettings> implements TextGenerationModel<string, CohereTextGenerationResponse, CohereTextGenerationDelta, CohereTextGenerationModelSettings> {
+export declare class CohereTextGenerationModel extends AbstractModel<CohereTextGenerationModelSettings> implements TextStreamingModel<string, CohereTextGenerationModelSettings> {
     constructor(settings: CohereTextGenerationModelSettings);
     readonly provider: "cohere";
     get modelName(): "command" | "command-nightly" | "command-light" | "command-light-nightly";
@@ -63,26 +63,28 @@ export declare class CohereTextGenerationModel extends AbstractModel<CohereTextG
     countPromptTokens(input: string): Promise<number>;
     callAPI<RESPONSE>(prompt: string, options: {
         responseFormat: CohereTextGenerationResponseFormatType<RESPONSE>;
-    } & ModelFunctionOptions<CohereTextGenerationModelSettings>): Promise<RESPONSE>;
+    } & FunctionOptions): Promise<RESPONSE>;
     get settingsForEvent(): Partial<CohereTextGenerationModelSettings>;
-    generateTextResponse(prompt: string, options?: ModelFunctionOptions<CohereTextGenerationModelSettings>): Promise<{
-        prompt: string;
-        id: string;
-        generations: {
-            text: string;
+    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+        response: {
+            prompt: string;
             id: string;
-            finish_reason?: string | undefined;
-        }[];
-        meta?: {
-            api_version: {
-                version: string;
-            };
-        } | undefined;
+            generations: {
+                text: string;
+                id: string;
+                finish_reason?: string | undefined;
+            }[];
+            meta?: {
+                api_version: {
+                    version: string;
+                };
+            } | undefined;
+        };
+        text: string;
     }>;
-    extractText(response: CohereTextGenerationResponse): string;
-    generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<CohereTextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<CohereTextGenerationDelta>>>;
+    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
     extractTextDelta(fullDelta: CohereTextGenerationDelta): string | undefined;
-    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, CohereTextGenerationResponse, CohereTextGenerationDelta, CohereTextGenerationModelSettings, this>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextStreamingModel<INPUT_PROMPT, string, CohereTextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<CohereTextGenerationModelSettings>): this;
 }
 declare const cohereTextGenerationResponseSchema: z.ZodObject<{
@@ -184,7 +186,7 @@ export declare const CohereTextGenerationResponseFormat: {
         stream: true;
         handler: ({ response }: {
             response: Response;
-        }) => Promise<AsyncIterable<DeltaEvent<CohereTextGenerationDelta>>>;
+        }) => Promise<AsyncIterable<Delta<string>>>;
     };
 };
 export {};

package/model-provider/cohere/CohereTextGenerationModel.js

@@ -5,7 +5,7 @@ import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postTo
 import { AsyncQueue } from "../../event-source/AsyncQueue.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 { CohereApiConfiguration } from "./CohereApiConfiguration.js";
 import { failedCohereCallResponseHandler } from "./CohereError.js";
 import { CohereTokenizer } from "./CohereTokenizer.js";
@@ -75,27 +75,21 @@ export class CohereTextGenerationModel extends AbstractModel {
         return countTokens(this.tokenizer, input);
     }
     async callAPI(prompt, options) {
-        const { run, settings, responseFormat } = options;
-        const combinedSettings = {
-            ...this.settings,
-            settings,
-        };
-        const callSettings = {
-            ...combinedSettings,
-            // use endSequences instead of stopSequences
-            // to exclude stop tokens from the generated text
-            endSequences: combinedSettings.stopSequences,
-            maxTokens: combinedSettings.maxCompletionTokens,
-            // mapped name because of conflict with stopSequences:
-            stopSequences: combinedSettings.cohereStopSequences,
-            abortSignal: run?.abortSignal,
-            prompt,
-            responseFormat,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callCohereTextGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callCohereTextGenerationAPI({
+                ...this.settings,
+                // use endSequences instead of stopSequences
+                // to exclude stop tokens from the generated text
+                endSequences: this.settings.stopSequences,
+                maxTokens: this.settings.maxCompletionTokens,
+                // mapped name because of conflict with stopSequences:
+                stopSequences: this.settings.cohereStopSequences,
+                abortSignal: options.run?.abortSignal,
+                responseFormat: options.responseFormat,
+                prompt,
+            }),
         });
     }
     get settingsForEvent() {
@@ -115,16 +109,17 @@ export class CohereTextGenerationModel 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: CohereTextGenerationResponseFormat.json,
         });
+        return {
+            response,
+            text: response.generations[0].text,
+        };
     }
-    extractText(response) {
-        return response.generations[0].text;
-    }
-    generateDeltaStreamResponse(prompt, options) {
+    doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
             responseFormat: CohereTextGenerationResponseFormat.deltaIterable,
@@ -134,9 +129,12 @@ export class CohereTextGenerationModel extends AbstractModel {
         return fullDelta.delta;
     }
     withPromptFormat(promptFormat) {
-        return new PromptFormatTextGenerationModel({
+        return new PromptFormatTextStreamingModel({
             model: this.withSettings({
-                stopSequences: promptFormat.stopSequences,
+                stopSequences: [
+                    ...(this.settings.stopSequences ?? []),
+                    ...promptFormat.stopSequences,
+                ],
             }),
             promptFormat,
         });
@@ -211,6 +209,7 @@ async function createCohereTextGenerationFullDeltaIterableQueue(stream) {
                     isComplete: true,
                     delta: "",
                 },
+                valueDelta: "",
             });
         }
         else {
@@ -222,6 +221,7 @@ async function createCohereTextGenerationFullDeltaIterableQueue(stream) {
                     isComplete: false,
                     delta: event.text,
                 },
+                valueDelta: event.text,
             });
         }
     }

package/model-provider/elevenlabs/ElevenLabsSpeechSynthesisModel.cjs

@@ -25,24 +25,17 @@ class ElevenLabsSpeechSynthesisModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.voice;
     }
     async callAPI(text, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            api: combinedSettings.api,
-            abortSignal: run?.abortSignal,
-            text,
-            voiceId: combinedSettings.voice,
-            modelId: combinedSettings.model,
-            voiceSettings: combinedSettings.voiceSettings,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: combinedSettings.api?.retry,
-            throttle: combinedSettings.api?.throttle,
-            call: async () => callElevenLabsTextToSpeechAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callElevenLabsTextToSpeechAPI({
+                api: this.settings.api,
+                abortSignal: options?.run?.abortSignal,
+                text,
+                voiceId: this.settings.voice,
+                modelId: this.settings.model,
+                voiceSettings: this.settings.voiceSettings,
+            }),
         });
     }
     get settingsForEvent() {

package/model-provider/elevenlabs/ElevenLabsSpeechSynthesisModel.d.ts

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

package/model-provider/elevenlabs/ElevenLabsSpeechSynthesisModel.js

@@ -22,24 +22,17 @@ export class ElevenLabsSpeechSynthesisModel extends AbstractModel {
         return this.settings.voice;
     }
     async callAPI(text, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const combinedSettings = {
-            ...this.settings,
-            ...settings,
-        };
-        const callSettings = {
-            api: combinedSettings.api,
-            abortSignal: run?.abortSignal,
-            text,
-            voiceId: combinedSettings.voice,
-            modelId: combinedSettings.model,
-            voiceSettings: combinedSettings.voiceSettings,
-        };
         return callWithRetryAndThrottle({
-            retry: combinedSettings.api?.retry,
-            throttle: combinedSettings.api?.throttle,
-            call: async () => callElevenLabsTextToSpeechAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callElevenLabsTextToSpeechAPI({
+                api: this.settings.api,
+                abortSignal: options?.run?.abortSignal,
+                text,
+                voiceId: this.settings.voice,
+                modelId: this.settings.model,
+                voiceSettings: this.settings.voiceSettings,
+            }),
         });
     }
     get settingsForEvent() {

package/model-provider/huggingface/HuggingFaceImageDescriptionModel.cjs

@@ -35,28 +35,25 @@ class HuggingFaceImageDescriptionModel extends AbstractModel_js_1.AbstractModel
         return this.settings.model;
     }
     async callAPI(data, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            data,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callHuggingFaceImageDescriptionAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callHuggingFaceImageDescriptionAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                data,
+            }),
         });
     }
     get settingsForEvent() {
         return {};
     }
-    generateImageDescriptionResponse(data, options) {
-        return this.callAPI(data, options);
-    }
-    extractImageDescription(response) {
-        return response[0].generated_text;
+    async doDescribeImage(data, options) {
+        const response = await this.callAPI(data, options);
+        return {
+            response,
+            description: response[0].generated_text,
+        };
     }
     withSettings(additionalSettings) {
         return new HuggingFaceImageDescriptionModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/huggingface/HuggingFaceImageDescriptionModel.d.ts

@@ -2,7 +2,7 @@
 import z from "zod";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ImageDescriptionModel, ImageDescriptionModelSettings } from "../../model-function/describe-image/ImageDescriptionModel.js";
 export interface HuggingFaceImageDescriptionModelSettings extends ImageDescriptionModelSettings {
     api?: ApiConfiguration;
@@ -13,17 +13,19 @@ export interface HuggingFaceImageDescriptionModelSettings extends ImageDescripti
  *
  * @see https://huggingface.co/tasks/image-to-text
  */
-export declare class HuggingFaceImageDescriptionModel extends AbstractModel<HuggingFaceImageDescriptionModelSettings> implements ImageDescriptionModel<Buffer, HuggingFaceImageDescriptionResponse, HuggingFaceImageDescriptionModelSettings> {
+export declare class HuggingFaceImageDescriptionModel extends AbstractModel<HuggingFaceImageDescriptionModelSettings> implements ImageDescriptionModel<Buffer, HuggingFaceImageDescriptionModelSettings> {
     constructor(settings: HuggingFaceImageDescriptionModelSettings);
     readonly provider = "huggingface";
     get modelName(): string;
-    callAPI(data: Buffer, options?: ModelFunctionOptions<HuggingFaceImageDescriptionModelSettings>): Promise<HuggingFaceImageDescriptionResponse>;
+    callAPI(data: Buffer, options?: FunctionOptions): Promise<HuggingFaceImageDescriptionResponse>;
     get settingsForEvent(): Partial<HuggingFaceImageDescriptionModelSettings>;
     readonly countPromptTokens: undefined;
-    generateImageDescriptionResponse(data: Buffer, options?: ModelFunctionOptions<HuggingFaceImageDescriptionModelSettings>): Promise<{
-        generated_text: string;
-    }[]>;
-    extractImageDescription(response: HuggingFaceImageDescriptionResponse): string;
+    doDescribeImage(data: Buffer, options?: FunctionOptions): Promise<{
+        response: {
+            generated_text: string;
+        }[];
+        description: string;
+    }>;
     withSettings(additionalSettings: Partial<HuggingFaceImageDescriptionModelSettings>): this;
 }
 declare const huggingFaceImageDescriptionResponseSchema: z.ZodArray<z.ZodObject<{

package/model-provider/huggingface/HuggingFaceImageDescriptionModel.js

@@ -29,28 +29,25 @@ export class HuggingFaceImageDescriptionModel extends AbstractModel {
         return this.settings.model;
     }
     async callAPI(data, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            data,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callHuggingFaceImageDescriptionAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callHuggingFaceImageDescriptionAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                data,
+            }),
         });
     }
     get settingsForEvent() {
         return {};
     }
-    generateImageDescriptionResponse(data, options) {
-        return this.callAPI(data, options);
-    }
-    extractImageDescription(response) {
-        return response[0].generated_text;
+    async doDescribeImage(data, options) {
+        const response = await this.callAPI(data, options);
+        return {
+            response,
+            description: response[0].generated_text,
+        };
     }
     withSettings(additionalSettings) {
         return new HuggingFaceImageDescriptionModel(Object.assign({}, this.settings, additionalSettings));