modelfusion 0.40.1 → 0.41.0

package/model-function/generate-text/generateText.cjs

@@ -14,22 +14,21 @@ const executeCall_js_1 = require("../executeCall.cjs");
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-function generateText(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-model, prompt, options) {
+function generateText(model, prompt, options) {
     return (0, executeCall_js_1.executeCall)({
         functionType: "text-generation",
         input: prompt,
         model,
         options,
-        generateResponse: (options) => model.generateTextResponse(prompt, options),
-        extractOutputValue: (result) => {
+        generateResponse: async (options) => {
+            const result = await model.doGenerateText(prompt, options);
             const shouldTrimWhitespace = model.settings.trimWhitespace ?? true;
-            return shouldTrimWhitespace
-                ? model.extractText(result).trim()
-                : model.extractText(result);
+            return {
+                response: result.response,
+                extractedValue: shouldTrimWhitespace ? result.text.trim() : result.text,
+                usage: result.usage,
+            };
         },
-        extractUsage: (result) => model.extractUsage?.(result),
     });
 }
 exports.generateText = generateText;

package/model-function/generate-text/generateText.d.ts

@@ -1,4 +1,4 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
 /**
@@ -13,4 +13,4 @@ import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerati
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-export declare function generateText<PROMPT, RESPONSE, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<string, RESPONSE>;
+export declare function generateText<PROMPT>(model: TextGenerationModel<PROMPT, TextGenerationModelSettings>, prompt: PROMPT, options?: FunctionOptions): ModelFunctionPromise<string>;

package/model-function/generate-text/generateText.js

@@ -11,21 +11,20 @@ import { executeCall } from "../executeCall.js";
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-export function generateText(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-model, prompt, options) {
+export function generateText(model, prompt, options) {
     return executeCall({
         functionType: "text-generation",
         input: prompt,
         model,
         options,
-        generateResponse: (options) => model.generateTextResponse(prompt, options),
-        extractOutputValue: (result) => {
+        generateResponse: async (options) => {
+            const result = await model.doGenerateText(prompt, options);
             const shouldTrimWhitespace = model.settings.trimWhitespace ?? true;
-            return shouldTrimWhitespace
-                ? model.extractText(result).trim()
-                : model.extractText(result);
+            return {
+                response: result.response,
+                extractedValue: shouldTrimWhitespace ? result.text.trim() : result.text,
+                usage: result.usage,
+            };
         },
-        extractUsage: (result) => model.extractUsage?.(result),
     });
 }

package/model-function/generate-text/streamText.cjs

@@ -15,21 +15,12 @@ function streamText(model, prompt, options) {
 }
 exports.streamText = streamText;
 async function doStreamText(model, prompt, options) {
-    if (options?.settings != null) {
-        model = model.withSettings(options.settings);
-        options = {
-            functionId: options.functionId,
-            observers: options.observers,
-            run: options.run,
-        };
-    }
     const run = options?.run;
-    const settings = model.settings;
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
         observers: [
             ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, GlobalFunctionLogging_js_1.getGlobalFunctionLogging)()),
             ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
-            ...(settings.observers ?? []),
+            ...(model.settings.observers ?? []),
             ...(run?.functionObserver != null ? [run.functionObserver] : []),
             ...(options?.observers ?? []),
         ],
@@ -54,11 +45,7 @@ async function doStreamText(model, prompt, options) {
         ...startMetadata,
     });
     const result = await (0, runSafe_js_1.runSafe)(async () => {
-        const deltaIterable = await model.generateDeltaStreamResponse(prompt, {
-            functionId: options?.functionId,
-            settings,
-            run,
-        });
+        const deltaIterable = await model.doStreamText(prompt, options);
         return (async function* () {
             let accumulatedText = "";
             let lastFullDelta;
@@ -89,10 +76,10 @@ async function doStreamText(model, prompt, options) {
                 }
                 if (event?.type === "delta") {
                     lastFullDelta = event.fullDelta;
-                    const delta = model.extractTextDelta(lastFullDelta);
-                    if (delta != null && delta.length > 0) {
-                        accumulatedText += delta;
-                        yield delta;
+                    const textDelta = event.valueDelta;
+                    if (textDelta != null && textDelta.length > 0) {
+                        accumulatedText += textDelta;
+                        yield textDelta;
                     }
                 }
             }
@@ -107,7 +94,7 @@ async function doStreamText(model, prompt, options) {
                 result: {
                     status: "success",
                     response: lastFullDelta,
-                    output: accumulatedText,
+                    value: accumulatedText,
                 },
             });
         })();
@@ -138,7 +125,7 @@ async function doStreamText(model, prompt, options) {
         throw result.error;
     }
     return {
-        output: result.output,
+        output: result.value,
         metadata: startMetadata,
     };
 }

package/model-function/generate-text/streamText.d.ts

@@ -1,8 +1,4 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
-import { DeltaEvent } from "../DeltaEvent.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
-import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
-export declare function streamText<PROMPT, FULL_DELTA, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS> & {
-    generateDeltaStreamResponse: (prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
-    extractTextDelta: (fullDelta: FULL_DELTA) => string | undefined;
-}, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): AsyncIterableResultPromise<string>;
+import { TextStreamingModel } from "./TextGenerationModel.js";
+export declare function streamText<PROMPT>(model: TextStreamingModel<PROMPT>, prompt: PROMPT, options?: FunctionOptions): AsyncIterableResultPromise<string>;

package/model-function/generate-text/streamText.js

@@ -11,21 +11,12 @@ export function streamText(model, prompt, options) {
     return new AsyncIterableResultPromise(doStreamText(model, prompt, options));
 }
 async function doStreamText(model, prompt, options) {
-    if (options?.settings != null) {
-        model = model.withSettings(options.settings);
-        options = {
-            functionId: options.functionId,
-            observers: options.observers,
-            run: options.run,
-        };
-    }
     const run = options?.run;
-    const settings = model.settings;
     const eventSource = new FunctionEventSource({
         observers: [
             ...getFunctionCallLogger(options?.logging ?? getGlobalFunctionLogging()),
             ...getGlobalFunctionObservers(),
-            ...(settings.observers ?? []),
+            ...(model.settings.observers ?? []),
             ...(run?.functionObserver != null ? [run.functionObserver] : []),
             ...(options?.observers ?? []),
         ],
@@ -50,11 +41,7 @@ async function doStreamText(model, prompt, options) {
         ...startMetadata,
     });
     const result = await runSafe(async () => {
-        const deltaIterable = await model.generateDeltaStreamResponse(prompt, {
-            functionId: options?.functionId,
-            settings,
-            run,
-        });
+        const deltaIterable = await model.doStreamText(prompt, options);
         return (async function* () {
             let accumulatedText = "";
             let lastFullDelta;
@@ -85,10 +72,10 @@ async function doStreamText(model, prompt, options) {
                 }
                 if (event?.type === "delta") {
                     lastFullDelta = event.fullDelta;
-                    const delta = model.extractTextDelta(lastFullDelta);
-                    if (delta != null && delta.length > 0) {
-                        accumulatedText += delta;
-                        yield delta;
+                    const textDelta = event.valueDelta;
+                    if (textDelta != null && textDelta.length > 0) {
+                        accumulatedText += textDelta;
+                        yield textDelta;
                     }
                 }
             }
@@ -103,7 +90,7 @@ async function doStreamText(model, prompt, options) {
                 result: {
                     status: "success",
                     response: lastFullDelta,
-                    output: accumulatedText,
+                    value: accumulatedText,
                 },
             });
         })();
@@ -134,7 +121,7 @@ async function doStreamText(model, prompt, options) {
         throw result.error;
     }
     return {
-        output: result.output,
+        output: result.value,
         metadata: startMetadata,
     };
 }

package/model-function/index.cjs

@@ -14,10 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./DeltaEvent.cjs"), exports);
+__exportStar(require("./Delta.cjs"), exports);
 __exportStar(require("./Model.cjs"), exports);
 __exportStar(require("./ModelCallEvent.cjs"), exports);
-__exportStar(require("./ModelFunctionOptions.cjs"), exports);
+__exportStar(require("./ModelCallMetadata.cjs"), exports);
 __exportStar(require("./ModelInformation.cjs"), exports);
 __exportStar(require("./SuccessfulModelCall.cjs"), exports);
 __exportStar(require("./describe-image/ImageDescriptionEvent.cjs"), exports);

package/model-function/index.d.ts

@@ -1,7 +1,7 @@
-export * from "./DeltaEvent.js";
+export * from "./Delta.js";
 export * from "./Model.js";
 export * from "./ModelCallEvent.js";
-export * from "./ModelFunctionOptions.js";
+export * from "./ModelCallMetadata.js";
 export * from "./ModelInformation.js";
 export * from "./SuccessfulModelCall.js";
 export * from "./describe-image/ImageDescriptionEvent.js";

package/model-function/index.js

@@ -1,7 +1,7 @@
-export * from "./DeltaEvent.js";
+export * from "./Delta.js";
 export * from "./Model.js";
 export * from "./ModelCallEvent.js";
-export * from "./ModelFunctionOptions.js";
+export * from "./ModelCallMetadata.js";
 export * from "./ModelInformation.js";
 export * from "./SuccessfulModelCall.js";
 export * from "./describe-image/ImageDescriptionEvent.js";

package/model-function/synthesize-speech/SpeechSynthesisEvent.d.ts

@@ -7,7 +7,7 @@ export interface SpeechSynthesisStartedEvent extends BaseModelCallStartedEvent {
 export type SpeechSynthesisFinishedEventResult = {
     status: "success";
     response: unknown;
-    output: Buffer;
+    value: Buffer;
 } | {
     status: "error";
     error: unknown;

package/model-function/synthesize-speech/SpeechSynthesisModel.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="node" />
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface SpeechSynthesisModelSettings extends ModelSettings {
 }
-export interface SpeechSynthesisModel<SETTINGS extends SpeechSynthesisModelSettings> extends Model<SETTINGS> {
+export interface SpeechSynthesisModel<SETTINGS extends SpeechSynthesisModelSettings = SpeechSynthesisModelSettings> extends Model<SETTINGS> {
     /**
      * Generates an mp3 audio buffer that contains the speech for the given text.
      */
-    generateSpeechResponse: (text: string, options?: ModelFunctionOptions<SETTINGS>) => PromiseLike<Buffer>;
+    generateSpeechResponse: (text: string, options?: FunctionOptions) => PromiseLike<Buffer>;
 }

package/model-function/synthesize-speech/synthesizeSpeech.cjs

@@ -11,8 +11,13 @@ function synthesizeSpeech(model, text, options) {
         input: text,
         model,
         options,
-        generateResponse: (options) => model.generateSpeechResponse(text, options),
-        extractOutputValue: (buffer) => buffer,
+        generateResponse: async (options) => {
+            const response = await model.generateSpeechResponse(text, options);
+            return {
+                response,
+                extractedValue: response,
+            };
+        },
     });
 }
 exports.synthesizeSpeech = synthesizeSpeech;

package/model-function/synthesize-speech/synthesizeSpeech.d.ts

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { SpeechSynthesisModel, SpeechSynthesisModelSettings } from "./SpeechSynthesisModel.js";
 /**
  * Synthesizes speech from text.
  */
-export declare function synthesizeSpeech<SETTINGS extends SpeechSynthesisModelSettings>(model: SpeechSynthesisModel<SETTINGS>, text: string, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<Buffer, Buffer>;
+export declare function synthesizeSpeech(model: SpeechSynthesisModel<SpeechSynthesisModelSettings>, text: string, options?: FunctionOptions): ModelFunctionPromise<Buffer>;

package/model-function/synthesize-speech/synthesizeSpeech.js

@@ -8,7 +8,12 @@ export function synthesizeSpeech(model, text, options) {
         input: text,
         model,
         options,
-        generateResponse: (options) => model.generateSpeechResponse(text, options),
-        extractOutputValue: (buffer) => buffer,
+        generateResponse: async (options) => {
+            const response = await model.generateSpeechResponse(text, options);
+            return {
+                response,
+                extractedValue: response,
+            };
+        },
     });
 }

package/model-function/transcribe-speech/TranscriptionEvent.d.ts

@@ -5,7 +5,7 @@ export interface TranscriptionStartedEvent extends BaseModelCallStartedEvent {
 export type TranscriptionFinishedEventResult = {
     status: "success";
     response: unknown;
-    output: string;
+    value: string;
 } | {
     status: "error";
     error: unknown;

package/model-function/transcribe-speech/TranscriptionModel.d.ts

@@ -1,8 +1,10 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface TranscriptionModelSettings extends ModelSettings {
 }
-export interface TranscriptionModel<DATA, RESPONSE, SETTINGS extends TranscriptionModelSettings> extends Model<SETTINGS> {
-    generateTranscriptionResponse: (data: DATA, options?: ModelFunctionOptions<SETTINGS>) => PromiseLike<RESPONSE>;
-    extractTranscriptionText: (response: RESPONSE) => string;
+export interface TranscriptionModel<DATA, SETTINGS extends TranscriptionModelSettings = TranscriptionModelSettings> extends Model<SETTINGS> {
+    doTranscribe: (data: DATA, options?: FunctionOptions) => PromiseLike<{
+        response: unknown;
+        transcription: string;
+    }>;
 }

package/model-function/transcribe-speech/transcribe.cjs

@@ -22,8 +22,13 @@ function transcribe(model, data, options) {
         input: data,
         model,
         options,
-        generateResponse: (options) => model.generateTranscriptionResponse(data, options),
-        extractOutputValue: model.extractTranscriptionText,
+        generateResponse: async (options) => {
+            const result = await model.doTranscribe(data, options);
+            return {
+                response: result.response,
+                extractedValue: result.transcription,
+            };
+        },
     });
 }
 exports.transcribe = transcribe;

package/model-function/transcribe-speech/transcribe.d.ts

@@ -1,4 +1,4 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { TranscriptionModel, TranscriptionModelSettings } from "./TranscriptionModel.js";
 /**
@@ -15,4 +15,4 @@ import { TranscriptionModel, TranscriptionModelSettings } from "./TranscriptionM
  *   }
  * );
  */
-export declare function transcribe<DATA, RESPONSE, SETTINGS extends TranscriptionModelSettings>(model: TranscriptionModel<DATA, RESPONSE, SETTINGS>, data: DATA, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<string, RESPONSE>;
+export declare function transcribe<DATA>(model: TranscriptionModel<DATA, TranscriptionModelSettings>, data: DATA, options?: FunctionOptions): ModelFunctionPromise<string>;

package/model-function/transcribe-speech/transcribe.js

@@ -19,7 +19,12 @@ export function transcribe(model, data, options) {
         input: data,
         model,
         options,
-        generateResponse: (options) => model.generateTranscriptionResponse(data, options),
-        extractOutputValue: model.extractTranscriptionText,
+        generateResponse: async (options) => {
+            const result = await model.doTranscribe(data, options);
+            return {
+                response: result.response,
+                extractedValue: result.transcription,
+            };
+        },
     });
 }

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.cjs

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Automatic1111ImageGenerationModel = 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 AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
 const Automatic1111ApiConfiguration_js_1 = require("./Automatic1111ApiConfiguration.cjs");
 const Automatic1111Error_js_1 = require("./Automatic1111Error.cjs");
 /**
@@ -26,19 +26,14 @@ class Automatic1111ImageGenerationModel extends AbstractModel_js_1.AbstractModel
         return this.settings.model;
     }
     async callAPI(input, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            engineId: this.settings.model,
-            prompt: input.prompt,
-        };
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callAutomatic1111ImageGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callAutomatic1111ImageGenerationAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                prompt: input.prompt,
+            }),
         });
     }
     get settingsForEvent() {
@@ -49,11 +44,12 @@ class Automatic1111ImageGenerationModel extends AbstractModel_js_1.AbstractModel
             steps: this.settings.steps,
         };
     }
-    generateImageResponse(prompt, options) {
-        return this.callAPI(prompt, options);
-    }
-    extractBase64Image(response) {
-        return response.images[0];
+    async doGenerateImage(prompt, options) {
+        const response = await this.callAPI(prompt, options);
+        return {
+            response,
+            base64Image: response.images[0],
+        };
     }
     withSettings(additionalSettings) {
         return new Automatic1111ImageGenerationModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.d.ts

@@ -1,25 +1,27 @@
 import { z } from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
-import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.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 AUTOMATIC1111 Stable Diffusion Web UI API.
  *
  * @see https://github.com/AUTOMATIC1111/stable-diffusion-webui
  */
-export declare class Automatic1111ImageGenerationModel extends AbstractModel<Automatic1111ImageGenerationModelSettings> implements ImageGenerationModel<A111ImageGenerationPrompt, Automatic1111ImageGenerationResponse, Automatic1111ImageGenerationModelSettings> {
+export declare class Automatic1111ImageGenerationModel extends AbstractModel<Automatic1111ImageGenerationModelSettings> implements ImageGenerationModel<A111ImageGenerationPrompt, Automatic1111ImageGenerationModelSettings> {
     constructor(settings: Automatic1111ImageGenerationModelSettings);
     readonly provider: "Automatic1111";
     get modelName(): string;
-    callAPI(input: A111ImageGenerationPrompt, options?: ModelFunctionOptions<Automatic1111ImageGenerationModelSettings>): Promise<Automatic1111ImageGenerationResponse>;
+    callAPI(input: A111ImageGenerationPrompt, options?: FunctionOptions): Promise<Automatic1111ImageGenerationResponse>;
     get settingsForEvent(): Partial<Automatic1111ImageGenerationModelSettings>;
-    generateImageResponse(prompt: A111ImageGenerationPrompt, options?: ModelFunctionOptions<Automatic1111ImageGenerationModelSettings>): Promise<{
-        images: string[];
-        parameters: {};
-        info: string;
+    doGenerateImage(prompt: A111ImageGenerationPrompt, options?: FunctionOptions): Promise<{
+        response: {
+            images: string[];
+            parameters: {};
+            info: string;
+        };
+        base64Image: string;
     }>;
-    extractBase64Image(response: Automatic1111ImageGenerationResponse): string;
     withSettings(additionalSettings: Automatic1111ImageGenerationModelSettings): this;
 }
 export interface Automatic1111ImageGenerationModelSettings extends ImageGenerationModelSettings {

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
 import { Automatic1111ApiConfiguration } from "./Automatic1111ApiConfiguration.js";
 import { failedAutomatic1111CallResponseHandler } from "./Automatic1111Error.js";
 /**
@@ -23,19 +23,14 @@ export class Automatic1111ImageGenerationModel extends AbstractModel {
         return this.settings.model;
     }
     async callAPI(input, options) {
-        const run = options?.run;
-        const settings = options?.settings;
-        const callSettings = {
-            ...this.settings,
-            ...settings,
-            abortSignal: run?.abortSignal,
-            engineId: this.settings.model,
-            prompt: input.prompt,
-        };
         return callWithRetryAndThrottle({
-            retry: callSettings.api?.retry,
-            throttle: callSettings.api?.throttle,
-            call: async () => callAutomatic1111ImageGenerationAPI(callSettings),
+            retry: this.settings.api?.retry,
+            throttle: this.settings.api?.throttle,
+            call: async () => callAutomatic1111ImageGenerationAPI({
+                ...this.settings,
+                abortSignal: options?.run?.abortSignal,
+                prompt: input.prompt,
+            }),
         });
     }
     get settingsForEvent() {
@@ -46,11 +41,12 @@ export class Automatic1111ImageGenerationModel extends AbstractModel {
             steps: this.settings.steps,
         };
     }
-    generateImageResponse(prompt, options) {
-        return this.callAPI(prompt, options);
-    }
-    extractBase64Image(response) {
-        return response.images[0];
+    async doGenerateImage(prompt, options) {
+        const response = await this.callAPI(prompt, options);
+        return {
+            response,
+            base64Image: response.images[0],
+        };
     }
     withSettings(additionalSettings) {
         return new Automatic1111ImageGenerationModel(Object.assign({}, this.settings, additionalSettings));

package/model-provider/cohere/CohereTextEmbeddingModel.cjs

@@ -97,18 +97,14 @@ class CohereTextEmbeddingModel extends AbstractModel_js_1.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 (0, callWithRetryAndThrottle_js_1.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() {
@@ -116,11 +112,12 @@ class CohereTextEmbeddingModel extends AbstractModel_js_1.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));