modelfusion 0.20.1 → 0.21.0

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

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamText = exports.StreamTextPromise = void 0;
 const nanoid_1 = require("nanoid");
-const RunFunctionEventSource_js_1 = require("../../run/RunFunctionEventSource.cjs");
+const FunctionEventSource_js_1 = require("../../run/FunctionEventSource.cjs");
+const GlobalFunctionObservers_js_1 = require("../../run/GlobalFunctionObservers.cjs");
 const DurationMeasurement_js_1 = require("../../util/DurationMeasurement.cjs");
 const AbortError_js_1 = require("../../util/api/AbortError.cjs");
 const runSafe_js_1 = require("../../util/runSafe.cjs");
@@ -50,13 +51,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_js_1.RunFunctionEventSource({
-        observers: [...(settings.observers ?? []), ...(run?.observers ?? [])],
+    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
+        observers: [
+            ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
+            ...(settings.observers ?? []),
+            ...(run?.observers ?? []),
+            ...(options?.observers ?? []),
+        ],
         errorHandler: run?.errorHandler,
     });
     const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
@@ -67,11 +74,13 @@ async function doStreamText(model, prompt, options) {
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notifyRunFunctionStarted({
-        type: "text-streaming-started",
-        metadata: startMetadata,
+    eventSource.notify({
+        ...startMetadata,
+        functionType: "text-streaming",
+        eventType: "started",
         settings,
         prompt,
     });
@@ -85,12 +94,14 @@ 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",
+            eventSource.notify({
+                ...finishMetadata,
+                functionType: "text-streaming",
                 status: "success",
-                metadata: finishMetadata,
                 settings,
                 prompt,
                 response: lastFullDelta,
@@ -100,20 +111,22 @@ async function doStreamText(model, prompt, options) {
         onError: (error) => {
             const finishMetadata = {
                 ...startMetadata,
+                eventType: "finished",
+                finishTimestamp: new Date(),
                 durationInMs: durationMeasurement.durationInMs,
             };
-            eventSource.notifyRunFunctionFinished(error instanceof AbortError_js_1.AbortError
+            eventSource.notify(error instanceof AbortError_js_1.AbortError
                 ? {
-                    type: "text-streaming-finished",
+                    ...finishMetadata,
+                    functionType: "text-streaming",
                     status: "abort",
-                    metadata: finishMetadata,
                     settings,
                     prompt,
                 }
                 : {
-                    type: "text-streaming-finished",
-                    status: "failure",
-                    metadata: finishMetadata,
+                    ...finishMetadata,
+                    functionType: "text-streaming",
+                    status: "error",
                     settings,
                     prompt,
                     error,
@@ -123,22 +136,24 @@ async function doStreamText(model, prompt, options) {
     if (!result.ok) {
         const finishMetadata = {
             ...startMetadata,
+            eventType: "finished",
+            finishTimestamp: new Date(),
             durationInMs: durationMeasurement.durationInMs,
         };
         if (result.isAborted) {
-            eventSource.notifyRunFunctionFinished({
-                type: "text-streaming-finished",
+            eventSource.notify({
+                ...finishMetadata,
+                functionType: "text-streaming",
                 status: "abort",
-                metadata: finishMetadata,
                 settings,
                 prompt,
             });
             throw new AbortError_js_1.AbortError();
         }
-        eventSource.notifyRunFunctionFinished({
-            type: "text-streaming-finished",
-            status: "failure",
-            metadata: finishMetadata,
+        eventSource.notify({
+            ...finishMetadata,
+            functionType: "text-streaming",
+            status: "error",
             settings,
             prompt,
             error: result.error,

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { CallMetadata } from "../executeCall.js";
 import { DeltaEvent } from "./DeltaEvent.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
@@ -7,17 +7,17 @@ export declare class StreamTextPromise<PROMPT, FULL_DELTA, SETTINGS extends Text
     private outputPromise;
     constructor(fullPromise: Promise<{
         output: AsyncIterable<string>;
-        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs">;
+        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs" | "finishTimestamp">;
     }>);
     asFullResponse(): Promise<{
         output: AsyncIterable<string>;
-        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs">;
+        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs" | "finishTimestamp">;
     }>;
     then<TResult1 = AsyncIterable<string>, TResult2 = never>(onfulfilled?: ((value: AsyncIterable<string>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
     catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<AsyncIterable<string> | TResult>;
     finally(onfinally?: (() => void) | undefined | null): Promise<AsyncIterable<string>>;
 }
 export declare function streamText<PROMPT, FULL_DELTA, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS> & {
-    generateDeltaStreamResponse: (prompt: PROMPT, options: FunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
+    generateDeltaStreamResponse: (prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
     extractTextDelta: (fullDelta: FULL_DELTA) => string | undefined;
-}, prompt: PROMPT, options?: FunctionOptions<SETTINGS>): StreamTextPromise<PROMPT, FULL_DELTA, SETTINGS>;
+}, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): StreamTextPromise<PROMPT, FULL_DELTA, SETTINGS>;

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 "../../run/FunctionEventSource.js";
+import { getGlobalFunctionObservers } from "../../run/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,11 +69,13 @@ async function doStreamText(model, prompt, options) {
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notifyRunFunctionStarted({
-        type: "text-streaming-started",
-        metadata: startMetadata,
+    eventSource.notify({
+        ...startMetadata,
+        functionType: "text-streaming",
+        eventType: "started",
         settings,
         prompt,
     });
@@ -80,12 +89,14 @@ 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",
+            eventSource.notify({
+                ...finishMetadata,
+                functionType: "text-streaming",
                 status: "success",
-                metadata: finishMetadata,
                 settings,
                 prompt,
                 response: lastFullDelta,
@@ -95,20 +106,22 @@ async function doStreamText(model, prompt, options) {
         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",
+                    ...finishMetadata,
+                    functionType: "text-streaming",
                     status: "abort",
-                    metadata: finishMetadata,
                     settings,
                     prompt,
                 }
                 : {
-                    type: "text-streaming-finished",
-                    status: "failure",
-                    metadata: finishMetadata,
+                    ...finishMetadata,
+                    functionType: "text-streaming",
+                    status: "error",
                     settings,
                     prompt,
                     error,
@@ -118,22 +131,24 @@ async function doStreamText(model, prompt, options) {
     if (!result.ok) {
         const finishMetadata = {
             ...startMetadata,
+            eventType: "finished",
+            finishTimestamp: new Date(),
             durationInMs: durationMeasurement.durationInMs,
         };
         if (result.isAborted) {
-            eventSource.notifyRunFunctionFinished({
-                type: "text-streaming-finished",
+            eventSource.notify({
+                ...finishMetadata,
+                functionType: "text-streaming",
                 status: "abort",
-                metadata: finishMetadata,
                 settings,
                 prompt,
             });
             throw new AbortError();
         }
-        eventSource.notifyRunFunctionFinished({
-            type: "text-streaming-finished",
-            status: "failure",
-            metadata: finishMetadata,
+        eventSource.notify({
+            ...finishMetadata,
+            functionType: "text-streaming",
+            status: "error",
             settings,
             prompt,
             error: 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,21 +1,19 @@
 /// <reference types="node" resolution-mode="require"/>
-import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
-export type SpeechSynthesisStartedEvent = {
-    type: "speech-synthesis-started";
-    metadata: ModelCallStartedEventMetadata;
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export type SpeechSynthesisStartedEvent = BaseModelCallStartedEvent & {
+    functionType: "speech-synthesis";
     settings: unknown;
     text: string;
 };
-export type SpeechSynthesisFinishedEvent = {
-    type: "speech-synthesis-finished";
-    metadata: ModelCallFinishedEventMetadata;
+export type SpeechSynthesisFinishedEvent = BaseModelCallFinishedEvent & {
+    functionType: "speech-synthesis";
     settings: unknown;
     text: string;
 } & ({
     status: "success";
     response: Buffer;
 } | {
-    status: "failure";
+    status: "error";
     error: unknown;
 } | {
     status: "abort";

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

@@ -12,30 +12,28 @@ function synthesizeSpeech(model, text, options) {
         generateResponse: (options) => model.generateSpeechResponse(text, options),
         extractOutputValue: (buffer) => buffer,
         getStartEvent: (metadata, settings) => ({
-            type: "speech-synthesis-started",
-            metadata,
+            ...metadata,
+            functionType: "speech-synthesis",
             settings,
             text,
         }),
         getAbortEvent: (metadata, settings) => ({
-            type: "speech-synthesis-finished",
+            ...metadata,
+            functionType: "speech-synthesis",
             status: "abort",
             settings,
-            metadata,
             text,
         }),
         getFailureEvent: (metadata, settings, error) => ({
-            type: "speech-synthesis-finished",
-            status: "failure",
-            metadata,
+            ...metadata,
+            functionType: "speech-synthesis",
             settings,
             text,
             error,
         }),
         getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "speech-synthesis-finished",
-            status: "success",
-            metadata,
+            ...metadata,
+            functionType: "speech-synthesis",
             settings,
             text,
             response,

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

@@ -9,30 +9,28 @@ export function synthesizeSpeech(model, text, options) {
         generateResponse: (options) => model.generateSpeechResponse(text, options),
         extractOutputValue: (buffer) => buffer,
         getStartEvent: (metadata, settings) => ({
-            type: "speech-synthesis-started",
-            metadata,
+            ...metadata,
+            functionType: "speech-synthesis",
             settings,
             text,
         }),
         getAbortEvent: (metadata, settings) => ({
-            type: "speech-synthesis-finished",
+            ...metadata,
+            functionType: "speech-synthesis",
             status: "abort",
             settings,
-            metadata,
             text,
         }),
         getFailureEvent: (metadata, settings, error) => ({
-            type: "speech-synthesis-finished",
-            status: "failure",
-            metadata,
+            ...metadata,
+            functionType: "speech-synthesis",
             settings,
             text,
             error,
         }),
         getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "speech-synthesis-finished",
-            status: "success",
-            metadata,
+            ...metadata,
+            functionType: "speech-synthesis",
             settings,
             text,
             response,

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

@@ -1,13 +1,11 @@
-import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
-export type TranscriptionStartedEvent = {
-    type: "transcription-started";
-    metadata: ModelCallStartedEventMetadata;
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export type TranscriptionStartedEvent = BaseModelCallStartedEvent & {
+    functionType: "transcription";
     settings: unknown;
     data: unknown;
 };
-export type TranscriptionFinishedEvent = {
-    type: "transcription-finished";
-    metadata: ModelCallFinishedEventMetadata;
+export type TranscriptionFinishedEvent = BaseModelCallFinishedEvent & {
+    functionType: "transcription";
     settings: unknown;
     data: unknown;
 } & ({
@@ -15,7 +13,7 @@ export type TranscriptionFinishedEvent = {
     response: unknown;
     transcription: string;
 } | {
-    status: "failure";
+    status: "error";
     error: unknown;
 } | {
     status: "abort";

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

@@ -23,30 +23,27 @@ function transcribe(model, data, options) {
         generateResponse: (options) => model.generateTranscriptionResponse(data, options),
         extractOutputValue: model.extractTranscriptionText,
         getStartEvent: (metadata, settings) => ({
-            type: "transcription-started",
-            metadata,
+            ...metadata,
+            functionType: "transcription",
             settings,
             data,
         }),
         getAbortEvent: (metadata, settings) => ({
-            type: "transcription-finished",
-            status: "abort",
+            ...metadata,
+            functionType: "transcription",
             settings,
-            metadata,
             data,
         }),
         getFailureEvent: (metadata, settings, error) => ({
-            type: "transcription-finished",
-            status: "failure",
-            metadata,
+            ...metadata,
+            functionType: "transcription",
             settings,
             data,
             error,
         }),
         getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "transcription-finished",
-            status: "success",
-            metadata,
+            ...metadata,
+            functionType: "transcription",
             settings,
             data,
             response,

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

@@ -20,30 +20,27 @@ export function transcribe(model, data, options) {
         generateResponse: (options) => model.generateTranscriptionResponse(data, options),
         extractOutputValue: model.extractTranscriptionText,
         getStartEvent: (metadata, settings) => ({
-            type: "transcription-started",
-            metadata,
+            ...metadata,
+            functionType: "transcription",
             settings,
             data,
         }),
         getAbortEvent: (metadata, settings) => ({
-            type: "transcription-finished",
-            status: "abort",
+            ...metadata,
+            functionType: "transcription",
             settings,
-            metadata,
             data,
         }),
         getFailureEvent: (metadata, settings, error) => ({
-            type: "transcription-finished",
-            status: "failure",
-            metadata,
+            ...metadata,
+            functionType: "transcription",
             settings,
             data,
             error,
         }),
         getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "transcription-finished",
-            status: "success",
-            metadata,
+            ...metadata,
+            functionType: "transcription",
             settings,
             data,
             response,

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,8 +61,8 @@ 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<{
+    callAPI(texts: Array<string>, options?: ModelFunctionOptions<CohereTextEmbeddingModelSettings>): Promise<CohereTextEmbeddingResponse>;
+    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<CohereTextEmbeddingModelSettings>): Promise<{
         texts: string[];
         id: string;
         meta: {