modelfusion 0.20.1 → 0.22.0

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

@@ -1,5 +1,6 @@
 import { nanoid as createId } from "nanoid";
-import { RunFunctionEventSource } from "../../run/RunFunctionEventSource.js";
+import { FunctionEventSource } from "../../core/FunctionEventSource.js";
+import { getGlobalFunctionObservers } from "../../core/GlobalFunctionObservers.js";
 import { startDurationMeasurement } from "../../util/DurationMeasurement.js";
 import { AbortError } from "../../util/api/AbortError.js";
 import { runSafe } from "../../util/runSafe.js";
@@ -45,13 +46,19 @@ async function doStreamText(model, prompt, options) {
         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 RunFunctionEventSource({
-        observers: [...(settings.observers ?? []), ...(run?.observers ?? [])],
+    const eventSource = new FunctionEventSource({
+        observers: [
+            ...getGlobalFunctionObservers(),
+            ...(settings.observers ?? []),
+            ...(run?.observers ?? []),
+            ...(options?.observers ?? []),
+        ],
         errorHandler: run?.errorHandler,
     });
     const durationMeasurement = startDurationMeasurement();
@@ -62,13 +69,15 @@ async function doStreamText(model, prompt, options) {
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
-    };
-    eventSource.notifyRunFunctionStarted({
-        type: "text-streaming-started",
-        metadata: startMetadata,
+        functionType: "text-streaming",
+        input: prompt,
         settings,
-        prompt,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
+    };
+    eventSource.notify({
+        ...startMetadata,
+        eventType: "started",
     });
     const result = await runSafe(async () => extractTextDeltas({
         deltaIterable: await model.generateDeltaStreamResponse(prompt, {
@@ -80,63 +89,64 @@ async function doStreamText(model, prompt, options) {
         onDone: (fullText, lastFullDelta) => {
             const finishMetadata = {
                 ...startMetadata,
+                eventType: "finished",
+                finishTimestamp: new Date(),
                 durationInMs: durationMeasurement.durationInMs,
             };
-            eventSource.notifyRunFunctionFinished({
-                type: "text-streaming-finished",
-                status: "success",
-                metadata: finishMetadata,
-                settings,
-                prompt,
-                response: lastFullDelta,
-                generatedText: fullText,
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "success",
+                    response: lastFullDelta,
+                    output: fullText,
+                },
             });
         },
         onError: (error) => {
             const finishMetadata = {
                 ...startMetadata,
+                eventType: "finished",
+                finishTimestamp: new Date(),
                 durationInMs: durationMeasurement.durationInMs,
             };
-            eventSource.notifyRunFunctionFinished(error instanceof AbortError
+            eventSource.notify(error instanceof AbortError
                 ? {
-                    type: "text-streaming-finished",
-                    status: "abort",
-                    metadata: finishMetadata,
-                    settings,
-                    prompt,
+                    ...finishMetadata,
+                    result: {
+                        status: "abort",
+                    },
                 }
                 : {
-                    type: "text-streaming-finished",
-                    status: "failure",
-                    metadata: finishMetadata,
-                    settings,
-                    prompt,
-                    error,
+                    ...finishMetadata,
+                    result: {
+                        status: "error",
+                        error,
+                    },
                 });
         },
     }));
     if (!result.ok) {
         const finishMetadata = {
             ...startMetadata,
+            eventType: "finished",
+            finishTimestamp: new Date(),
             durationInMs: durationMeasurement.durationInMs,
         };
         if (result.isAborted) {
-            eventSource.notifyRunFunctionFinished({
-                type: "text-streaming-finished",
-                status: "abort",
-                metadata: finishMetadata,
-                settings,
-                prompt,
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "abort",
+                },
             });
             throw new AbortError();
         }
-        eventSource.notifyRunFunctionFinished({
-            type: "text-streaming-finished",
-            status: "failure",
-            metadata: finishMetadata,
-            settings,
-            prompt,
-            error: result.error,
+        eventSource.notify({
+            ...finishMetadata,
+            result: {
+                status: "error",
+                error: result.error,
+            },
         });
         throw result.error;
     }

package/model-function/index.cjs

@@ -14,9 +14,9 @@ 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("./FunctionOptions.cjs"), exports);
 __exportStar(require("./Model.cjs"), exports);
 __exportStar(require("./ModelCallEvent.cjs"), exports);
+__exportStar(require("./ModelFunctionOptions.cjs"), exports);
 __exportStar(require("./ModelInformation.cjs"), exports);
 __exportStar(require("./SuccessfulModelCall.cjs"), exports);
 __exportStar(require("./embed-text/TextEmbeddingEvent.cjs"), exports);

package/model-function/index.d.ts

@@ -1,6 +1,6 @@
-export * from "./FunctionOptions.js";
 export * from "./Model.js";
 export * from "./ModelCallEvent.js";
+export * from "./ModelFunctionOptions.js";
 export * from "./ModelInformation.js";
 export * from "./SuccessfulModelCall.js";
 export * from "./embed-text/TextEmbeddingEvent.js";

package/model-function/index.js

@@ -1,6 +1,6 @@
-export * from "./FunctionOptions.js";
 export * from "./Model.js";
 export * from "./ModelCallEvent.js";
+export * from "./ModelFunctionOptions.js";
 export * from "./ModelInformation.js";
 export * from "./SuccessfulModelCall.js";
 export * from "./embed-text/TextEmbeddingEvent.js";

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

@@ -1,22 +1,21 @@
 /// <reference types="node" resolution-mode="require"/>
-import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
-export type SpeechSynthesisStartedEvent = {
-    type: "speech-synthesis-started";
-    metadata: ModelCallStartedEventMetadata;
-    settings: unknown;
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export interface SpeechSynthesisStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "speech-synthesis";
     text: string;
-};
-export type SpeechSynthesisFinishedEvent = {
-    type: "speech-synthesis-finished";
-    metadata: ModelCallFinishedEventMetadata;
-    settings: unknown;
-    text: string;
-} & ({
+}
+export type SpeechSynthesisFinishedEventResult = {
     status: "success";
-    response: Buffer;
+    response: unknown;
+    output: Buffer;
 } | {
-    status: "failure";
+    status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface SpeechSynthesisFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "speech-synthesis";
+    text: string;
+    result: SpeechSynthesisFinishedEventResult;
+}

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

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

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

@@ -7,40 +7,12 @@ const executeCall_js_1 = require("../executeCall.cjs");
  */
 function synthesizeSpeech(model, text, options) {
     return (0, executeCall_js_1.executeCall)({
+        functionType: "speech-synthesis",
+        input: text,
         model,
         options,
         generateResponse: (options) => model.generateSpeechResponse(text, options),
         extractOutputValue: (buffer) => buffer,
-        getStartEvent: (metadata, settings) => ({
-            type: "speech-synthesis-started",
-            metadata,
-            settings,
-            text,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "speech-synthesis-finished",
-            status: "abort",
-            settings,
-            metadata,
-            text,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "speech-synthesis-finished",
-            status: "failure",
-            metadata,
-            settings,
-            text,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "speech-synthesis-finished",
-            status: "success",
-            metadata,
-            settings,
-            text,
-            response,
-            speech: output,
-        }),
     });
 }
 exports.synthesizeSpeech = synthesizeSpeech;

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

@@ -1,8 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.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?: FunctionOptions<SETTINGS>): ModelFunctionPromise<SpeechSynthesisModel<SETTINGS>, Buffer, Buffer>;
+export declare function synthesizeSpeech<SETTINGS extends SpeechSynthesisModelSettings>(model: SpeechSynthesisModel<SETTINGS>, text: string, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<SpeechSynthesisModel<SETTINGS>, Buffer, Buffer>;

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

@@ -4,39 +4,11 @@ import { executeCall } from "../executeCall.js";
  */
 export function synthesizeSpeech(model, text, options) {
     return executeCall({
+        functionType: "speech-synthesis",
+        input: text,
         model,
         options,
         generateResponse: (options) => model.generateSpeechResponse(text, options),
         extractOutputValue: (buffer) => buffer,
-        getStartEvent: (metadata, settings) => ({
-            type: "speech-synthesis-started",
-            metadata,
-            settings,
-            text,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "speech-synthesis-finished",
-            status: "abort",
-            settings,
-            metadata,
-            text,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "speech-synthesis-finished",
-            status: "failure",
-            metadata,
-            settings,
-            text,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "speech-synthesis-finished",
-            status: "success",
-            metadata,
-            settings,
-            text,
-            response,
-            speech: output,
-        }),
     });
 }

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

@@ -1,22 +1,18 @@
-import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
-export type TranscriptionStartedEvent = {
-    type: "transcription-started";
-    metadata: ModelCallStartedEventMetadata;
-    settings: unknown;
-    data: unknown;
-};
-export type TranscriptionFinishedEvent = {
-    type: "transcription-finished";
-    metadata: ModelCallFinishedEventMetadata;
-    settings: unknown;
-    data: unknown;
-} & ({
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export interface TranscriptionStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "transcription";
+}
+export type TranscriptionFinishedEventResult = {
     status: "success";
     response: unknown;
-    transcription: string;
+    output: string;
 } | {
-    status: "failure";
+    status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface TranscriptionFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "transcription";
+    result: TranscriptionFinishedEventResult;
+}

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

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

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

@@ -18,40 +18,12 @@ const executeCall_js_1 = require("../executeCall.cjs");
  */
 function transcribe(model, data, options) {
     return (0, executeCall_js_1.executeCall)({
+        functionType: "transcription",
+        input: data,
         model,
         options,
         generateResponse: (options) => model.generateTranscriptionResponse(data, options),
         extractOutputValue: model.extractTranscriptionText,
-        getStartEvent: (metadata, settings) => ({
-            type: "transcription-started",
-            metadata,
-            settings,
-            data,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "transcription-finished",
-            status: "abort",
-            settings,
-            metadata,
-            data,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "transcription-finished",
-            status: "failure",
-            metadata,
-            settings,
-            data,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "transcription-finished",
-            status: "success",
-            metadata,
-            settings,
-            data,
-            response,
-            transcription: output,
-        }),
     });
 }
 exports.transcribe = transcribe;

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.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?: FunctionOptions<SETTINGS>): ModelFunctionPromise<TranscriptionModel<DATA, RESPONSE, SETTINGS>, string, RESPONSE>;
+export declare function transcribe<DATA, RESPONSE, SETTINGS extends TranscriptionModelSettings>(model: TranscriptionModel<DATA, RESPONSE, SETTINGS>, data: DATA, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<TranscriptionModel<DATA, RESPONSE, SETTINGS>, string, RESPONSE>;

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

@@ -15,39 +15,11 @@ import { executeCall } from "../executeCall.js";
  */
 export function transcribe(model, data, options) {
     return executeCall({
+        functionType: "transcription",
+        input: data,
         model,
         options,
         generateResponse: (options) => model.generateTranscriptionResponse(data, options),
         extractOutputValue: model.extractTranscriptionText,
-        getStartEvent: (metadata, settings) => ({
-            type: "transcription-started",
-            metadata,
-            settings,
-            data,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "transcription-finished",
-            status: "abort",
-            settings,
-            metadata,
-            data,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "transcription-finished",
-            status: "failure",
-            metadata,
-            settings,
-            data,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "transcription-finished",
-            status: "success",
-            metadata,
-            settings,
-            data,
-            response,
-            transcription: output,
-        }),
     });
 }

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "../../model-function/generate-image/ImageGenerationModel.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
@@ -13,8 +13,8 @@ export declare class Automatic1111ImageGenerationModel extends AbstractModel<Aut
     constructor(settings: Automatic1111ImageGenerationModelSettings);
     readonly provider: "Automatic1111";
     get modelName(): string;
-    callAPI(input: A111ImageGenerationPrompt, options?: FunctionOptions<Automatic1111ImageGenerationModelSettings>): Promise<Automatic1111ImageGenerationResponse>;
-    generateImageResponse(prompt: A111ImageGenerationPrompt, options?: FunctionOptions<Automatic1111ImageGenerationModelSettings>): Promise<{
+    callAPI(input: A111ImageGenerationPrompt, options?: ModelFunctionOptions<Automatic1111ImageGenerationModelSettings>): Promise<Automatic1111ImageGenerationResponse>;
+    generateImageResponse(prompt: A111ImageGenerationPrompt, options?: ModelFunctionOptions<Automatic1111ImageGenerationModelSettings>): Promise<{
         images: string[];
         parameters: {};
         info: string;

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

@@ -1,6 +1,6 @@
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../../model-function/embed-text/TextEmbeddingModel.js";
 import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
@@ -61,15 +61,15 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
     }>;
     detokenize(tokens: number[]): Promise<string>;
     private get apiKey();
-    callAPI(texts: Array<string>, options?: FunctionOptions<CohereTextEmbeddingModelSettings>): Promise<CohereTextEmbeddingResponse>;
-    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<CohereTextEmbeddingModelSettings>): Promise<{
-        texts: string[];
+    callAPI(texts: Array<string>, options?: ModelFunctionOptions<CohereTextEmbeddingModelSettings>): Promise<CohereTextEmbeddingResponse>;
+    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<CohereTextEmbeddingModelSettings>): Promise<{
         id: string;
         meta: {
             api_version: {
                 version: string;
             };
         };
+        texts: string[];
         embeddings: number[][];
     }>;
     extractEmbeddings(response: CohereTextEmbeddingResponse): number[][];
@@ -97,22 +97,22 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     }>;
 }, "strip", z.ZodTypeAny, {
-    texts: string[];
     id: string;
     meta: {
         api_version: {
             version: string;
         };
     };
+    texts: string[];
     embeddings: number[][];
 }, {
-    texts: string[];
     id: string;
     meta: {
         api_version: {
             version: string;
         };
     };
+    texts: string[];
     embeddings: number[][];
 }>;
 export type CohereTextEmbeddingResponse = z.infer<typeof cohereTextEmbeddingResponseSchema>;

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { DeltaEvent } from "../../model-function/generate-text/DeltaEvent.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
 import { PromptFormat } from "../../prompt/PromptFormat.js";
@@ -72,8 +72,8 @@ export declare class CohereTextGenerationModel extends AbstractModel<CohereTextG
     countPromptTokens(input: string): Promise<number>;
     callAPI<RESPONSE>(prompt: string, options: {
         responseFormat: CohereTextGenerationResponseFormatType<RESPONSE>;
-    } & FunctionOptions<CohereTextGenerationModelSettings>): Promise<RESPONSE>;
-    generateTextResponse(prompt: string, options?: FunctionOptions<CohereTextGenerationModelSettings>): Promise<{
+    } & ModelFunctionOptions<CohereTextGenerationModelSettings>): Promise<RESPONSE>;
+    generateTextResponse(prompt: string, options?: ModelFunctionOptions<CohereTextGenerationModelSettings>): Promise<{
         prompt: string;
         id: string;
         generations: {
@@ -88,7 +88,7 @@ export declare class CohereTextGenerationModel extends AbstractModel<CohereTextG
         } | undefined;
     }>;
     extractText(response: CohereTextGenerationResponse): string;
-    generateDeltaStreamResponse(prompt: string, options?: FunctionOptions<CohereTextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<CohereTextGenerationDelta>>>;
+    generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<CohereTextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<CohereTextGenerationDelta>>>;
     extractTextDelta(fullDelta: CohereTextGenerationDelta): string | undefined;
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, CohereTextGenerationResponse, CohereTextGenerationDelta, CohereTextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<CohereTextGenerationModelSettings>): this;

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

@@ -1,6 +1,6 @@
 import z from "zod";
 import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
-import { Run } from "../../run/Run.js";
+import { Run } from "../../core/Run.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
 import { CohereTextGenerationModelType } from "./CohereTextGenerationModel.js";

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

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { SpeechSynthesisModel, SpeechSynthesisModelSettings } from "../../model-function/synthesize-speech/SpeechSynthesisModel.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
@@ -24,6 +24,6 @@ export declare class ElevenLabsSpeechSynthesisModel extends AbstractModel<Eleven
     readonly modelName: null;
     private get apiKey();
     private callAPI;
-    generateSpeechResponse(text: string, options?: FunctionOptions<ElevenLabsSpeechSynthesisModelSettings> | undefined): Promise<Buffer>;
+    generateSpeechResponse(text: string, options?: ModelFunctionOptions<ElevenLabsSpeechSynthesisModelSettings> | undefined): Promise<Buffer>;
     withSettings(additionalSettings: Partial<ElevenLabsSpeechSynthesisModelSettings>): this;
 }

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

@@ -1,6 +1,6 @@
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../../model-function/embed-text/TextEmbeddingModel.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
@@ -46,9 +46,9 @@ export declare class HuggingFaceTextEmbeddingModel extends AbstractModel<Hugging
     readonly embeddingDimensions: number | undefined;
     readonly tokenizer: undefined;
     private get apiKey();
-    callAPI(texts: Array<string>, options?: FunctionOptions<HuggingFaceTextEmbeddingModelSettings>): Promise<HuggingFaceTextEmbeddingResponse>;
+    callAPI(texts: Array<string>, options?: ModelFunctionOptions<HuggingFaceTextEmbeddingModelSettings>): Promise<HuggingFaceTextEmbeddingResponse>;
     readonly countPromptTokens: undefined;
-    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<HuggingFaceTextEmbeddingModelSettings>): Promise<number[][]>;
+    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<HuggingFaceTextEmbeddingModelSettings>): Promise<number[][]>;
     extractEmbeddings(response: HuggingFaceTextEmbeddingResponse): number[][];
     withSettings(additionalSettings: Partial<HuggingFaceTextEmbeddingModelSettings>): this;
 }

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

@@ -1,6 +1,6 @@
 import z from "zod";
 import { AbstractModel } from "../../model-function/AbstractModel.js";
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
@@ -49,9 +49,9 @@ export declare class HuggingFaceTextGenerationModel extends AbstractModel<Huggin
     readonly contextWindowSize: undefined;
     readonly tokenizer: undefined;
     private get apiKey();
-    callAPI(prompt: string, options?: FunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<HuggingFaceTextGenerationResponse>;
+    callAPI(prompt: string, options?: ModelFunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<HuggingFaceTextGenerationResponse>;
     readonly countPromptTokens: undefined;
-    generateTextResponse(prompt: string, options?: FunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<{
+    generateTextResponse(prompt: string, options?: ModelFunctionOptions<HuggingFaceTextGenerationModelSettings>): Promise<{
         generated_text: string;
     }[]>;
     extractText(response: HuggingFaceTextGenerationResponse): string;