modelfusion 0.20.0 → 0.21.0

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/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;

package/model-provider/llamacpp/LlamaCppTextEmbeddingModel.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";
@@ -23,8 +23,8 @@ export declare class LlamaCppTextEmbeddingModel extends AbstractModel<LlamaCppTe
     readonly embeddingDimensions: number | undefined;
     private readonly tokenizer;
     tokenize(text: string): Promise<number[]>;
-    callAPI(texts: Array<string>, options?: FunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<LlamaCppTextEmbeddingResponse>;
-    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<{
+    callAPI(texts: Array<string>, options?: ModelFunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<LlamaCppTextEmbeddingResponse>;
+    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<LlamaCppTextEmbeddingModelSettings>): Promise<{
         embedding: number[];
     }>;
     extractEmbeddings(response: LlamaCppTextEmbeddingResponse): number[][];

package/model-provider/llamacpp/LlamaCppTextGenerationModel.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";
@@ -46,9 +46,9 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
     readonly tokenizer: LlamaCppTokenizer;
     callAPI<RESPONSE>(prompt: string, options: {
         responseFormat: LlamaCppTextGenerationResponseFormatType<RESPONSE>;
-    } & FunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<RESPONSE>;
+    } & ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<RESPONSE>;
     countPromptTokens(prompt: string): Promise<number>;
-    generateTextResponse(prompt: string, options?: FunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<{
+    generateTextResponse(prompt: string, options?: ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<{
         model: string;
         prompt: string;
         content: string;
@@ -98,7 +98,7 @@ export declare class LlamaCppTextGenerationModel<CONTEXT_WINDOW_SIZE extends num
         truncated: boolean;
     }>;
     extractText(response: LlamaCppTextGenerationResponse): string;
-    generateDeltaStreamResponse(prompt: string, options?: FunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<AsyncIterable<DeltaEvent<LlamaCppTextGenerationDelta>>>;
+    generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): Promise<AsyncIterable<DeltaEvent<LlamaCppTextGenerationDelta>>>;
     extractTextDelta(fullDelta: LlamaCppTextGenerationDelta): string | undefined;
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, LlamaCppTextGenerationResponse, LlamaCppTextGenerationDelta, LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
     withSettings(additionalSettings: Partial<LlamaCppTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): this;

package/model-provider/openai/OpenAIImageGenerationModel.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 { ResponseHandler } from "../../util/api/postToApi.js";
 import { OpenAIModelSettings } from "./OpenAIModelSettings.js";
@@ -32,10 +32,10 @@ export declare class OpenAIImageGenerationModel extends AbstractModel<OpenAIImag
     private get apiKey();
     callAPI<RESULT>(prompt: string, options: {
         responseFormat: OpenAIImageGenerationResponseFormatType<RESULT>;
-    } & FunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
+    } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
-    generateImageResponse(prompt: string, options?: FunctionOptions<OpenAIImageGenerationSettings>): Promise<{
+    generateImageResponse(prompt: string, options?: ModelFunctionOptions<OpenAIImageGenerationSettings>): Promise<{
         data: {
             b64_json: string;
         }[];

package/model-provider/openai/OpenAITextEmbeddingModel.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";
@@ -50,8 +50,8 @@ export declare class OpenAITextEmbeddingModel extends AbstractModel<OpenAITextEm
     readonly contextWindowSize: number;
     private get apiKey();
     countTokens(input: string): Promise<number>;
-    callAPI(text: string, options?: FunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
-    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<{
+    callAPI(text: string, options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<OpenAITextEmbeddingResponse>;
+    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<OpenAITextEmbeddingModelSettings>): Promise<{
         object: "list";
         model: string;
         data: {

package/model-provider/openai/OpenAITextGenerationModel.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";
@@ -117,10 +117,10 @@ export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextG
     countPromptTokens(input: string): Promise<number>;
     callAPI<RESULT>(prompt: string, options: {
         responseFormat: OpenAITextResponseFormatType<RESULT>;
-    } & FunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
+    } & ModelFunctionOptions<Partial<OpenAIImageGenerationCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
-    generateTextResponse(prompt: string, options?: FunctionOptions<OpenAITextGenerationModelSettings>): Promise<{
+    generateTextResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<{
         object: "text_completion";
         model: string;
         id: string;
@@ -138,7 +138,7 @@ export declare class OpenAITextGenerationModel extends AbstractModel<OpenAITextG
         }[];
     }>;
     extractText(response: OpenAITextGenerationResponse): string;
-    generateDeltaStreamResponse(prompt: string, options?: FunctionOptions<OpenAITextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<OpenAITextGenerationDelta>>>;
+    generateDeltaStreamResponse(prompt: string, options?: ModelFunctionOptions<OpenAITextGenerationModelSettings>): Promise<AsyncIterable<DeltaEvent<OpenAITextGenerationDelta>>>;
     extractTextDelta(fullDelta: OpenAITextGenerationDelta): string | undefined;
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, string>): PromptFormatTextGenerationModel<INPUT_PROMPT, string, OpenAITextGenerationResponse, OpenAITextGenerationDelta, OpenAITextGenerationModelSettings, this>;
     withSettings(additionalSettings: Partial<OpenAITextGenerationModelSettings>): this;

package/model-provider/openai/OpenAITranscriptionModel.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
 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 { TranscriptionModel, TranscriptionModelSettings } from "../../model-function/transcribe-speech/TranscriptionModel.js";
 import { RetryFunction } from "../../util/api/RetryFunction.js";
 import { ThrottleFunction } from "../../util/api/ThrottleFunction.js";
@@ -51,12 +51,12 @@ export declare class OpenAITranscriptionModel extends AbstractModel<OpenAITransc
     constructor(settings: OpenAITranscriptionModelSettings);
     readonly provider: "openai";
     get modelName(): "whisper-1";
-    generateTranscriptionResponse(data: OpenAITranscriptionInput, options?: FunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): PromiseLike<OpenAITranscriptionVerboseJsonResponse>;
+    generateTranscriptionResponse(data: OpenAITranscriptionInput, options?: ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): PromiseLike<OpenAITranscriptionVerboseJsonResponse>;
     extractTranscriptionText(response: OpenAITranscriptionVerboseJsonResponse): string;
     private get apiKey();
     callAPI<RESULT>(data: OpenAITranscriptionInput, options: {
         responseFormat: OpenAITranscriptionResponseFormatType<RESULT>;
-    } & FunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): Promise<RESULT>;
+    } & ModelFunctionOptions<Partial<OpenAITranscriptionModelSettings & OpenAIModelSettings>>): Promise<RESULT>;
     withSettings(additionalSettings: OpenAITranscriptionModelSettings): this;
 }
 declare const openAITranscriptionJsonSchema: z.ZodObject<{

package/model-provider/openai/chat/OpenAIChatModel.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 { GenerateJsonModel } from "../../../model-function/generate-json/GenerateJsonModel.js";
 import { GenerateJsonOrTextModel } from "../../../model-function/generate-json/GenerateJsonOrTextModel.js";
 import { DeltaEvent } from "../../../model-function/generate-text/DeltaEvent.js";
@@ -131,10 +131,10 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
     countPromptTokens(messages: OpenAIChatMessage[]): Promise<number>;
     callAPI<RESULT>(messages: Array<OpenAIChatMessage>, options: {
         responseFormat: OpenAIChatResponseFormatType<RESULT>;
-    } & FunctionOptions<Partial<OpenAIChatCallSettings & OpenAIModelSettings & {
+    } & ModelFunctionOptions<Partial<OpenAIChatCallSettings & OpenAIModelSettings & {
         user?: string;
     }>>): Promise<RESULT>;
-    generateTextResponse(prompt: OpenAIChatMessage[], options?: FunctionOptions<OpenAIChatSettings>): Promise<{
+    generateTextResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<{
         object: "chat.completion";
         model: string;
         id: string;
@@ -159,7 +159,7 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
         }[];
     }>;
     extractText(response: OpenAIChatResponse): string;
-    generateDeltaStreamResponse(prompt: OpenAIChatMessage[], options?: FunctionOptions<OpenAIChatSettings>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
+    generateDeltaStreamResponse(prompt: OpenAIChatMessage[], options?: ModelFunctionOptions<OpenAIChatSettings>): Promise<AsyncIterable<DeltaEvent<OpenAIChatDelta>>>;
     extractTextDelta(fullDelta: OpenAIChatDelta): string | undefined;
     /**
      * JSON generation uses the OpenAI GPT function calling API.
@@ -168,7 +168,7 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
      *
      * @see https://platform.openai.com/docs/guides/gpt/function-calling
      */
-    generateJsonResponse(prompt: OpenAIChatSingleFunctionPrompt<unknown> | OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, options?: FunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
+    generateJsonResponse(prompt: OpenAIChatSingleFunctionPrompt<unknown> | OpenAIChatAutoFunctionPrompt<Array<OpenAIFunctionDescription<unknown>>>, options?: ModelFunctionOptions<OpenAIChatSettings> | undefined): PromiseLike<OpenAIChatResponse>;
     extractJson(response: OpenAIChatResponse): unknown;
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, OpenAIChatMessage[]>): PromptFormatTextGenerationModel<INPUT_PROMPT, OpenAIChatMessage[], OpenAIChatResponse, OpenAIChatDelta, OpenAIChatSettings, this>;
     withSettings(additionalSettings: Partial<OpenAIChatSettings>): this;

package/model-provider/stability/StabilityImageGenerationModel.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";
@@ -31,8 +31,8 @@ export declare class StabilityImageGenerationModel extends AbstractModel<Stabili
     readonly provider: "stability";
     get modelName(): string;
     private get apiKey();
-    callAPI(input: StabilityImageGenerationPrompt, options?: FunctionOptions<StabilityImageGenerationModelSettings>): Promise<StabilityImageGenerationResponse>;
-    generateImageResponse(prompt: StabilityImageGenerationPrompt, options?: FunctionOptions<StabilityImageGenerationModelSettings>): Promise<{
+    callAPI(input: StabilityImageGenerationPrompt, options?: ModelFunctionOptions<StabilityImageGenerationModelSettings>): Promise<StabilityImageGenerationResponse>;
+    generateImageResponse(prompt: StabilityImageGenerationPrompt, options?: ModelFunctionOptions<StabilityImageGenerationModelSettings>): Promise<{
         artifacts: {
             seed: number;
             base64: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build AI applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/prompt/PromptFormatTextGenerationModel.d.ts

@@ -1,4 +1,4 @@
-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 "./PromptFormat.js";
@@ -14,9 +14,9 @@ export declare class PromptFormatTextGenerationModel<PROMPT, MODEL_PROMPT, RESPO
     get tokenizer(): MODEL["tokenizer"];
     get contextWindowSize(): MODEL["contextWindowSize"];
     get countPromptTokens(): MODEL["countPromptTokens"] extends undefined ? undefined : (prompt: PROMPT) => PromiseLike<number>;
-    generateTextResponse(prompt: PROMPT, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    generateTextResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
     extractText(response: RESPONSE): string;
-    get generateDeltaStreamResponse(): MODEL["generateDeltaStreamResponse"] extends undefined ? undefined : (prompt: PROMPT, options: FunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
+    get generateDeltaStreamResponse(): MODEL["generateDeltaStreamResponse"] extends undefined ? undefined : (prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
     get extractTextDelta(): MODEL["extractTextDelta"];
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, RESPONSE, FULL_DELTA, SETTINGS, this>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;

package/run/ConsoleLogger.cjs

@@ -2,10 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleLogger = void 0;
 class ConsoleLogger {
-    onRunFunctionStarted(event) {
-        console.log(JSON.stringify(event, null, 2));
-    }
-    onRunFunctionFinished(event) {
+    onFunctionEvent(event) {
         console.log(JSON.stringify(event, null, 2));
     }
 }

package/run/ConsoleLogger.d.ts

@@ -1,6 +1,5 @@
-import { RunFunctionFinishedEvent, RunFunctionStartedEvent } from "./RunFunctionEvent.js";
-import { RunFunctionObserver } from "./RunFunctionObserver.js";
-export declare class ConsoleLogger implements RunFunctionObserver {
-    onRunFunctionStarted(event: RunFunctionStartedEvent): void;
-    onRunFunctionFinished(event: RunFunctionFinishedEvent): void;
+import { FunctionEvent } from "./FunctionEvent.js";
+import { FunctionObserver } from "./FunctionObserver.js";
+export declare class ConsoleLogger implements FunctionObserver {
+    onFunctionEvent(event: FunctionEvent): void;
 }

package/run/ConsoleLogger.js

@@ -1,8 +1,5 @@
 export class ConsoleLogger {
-    onRunFunctionStarted(event) {
-        console.log(JSON.stringify(event, null, 2));
-    }
-    onRunFunctionFinished(event) {
+    onFunctionEvent(event) {
         console.log(JSON.stringify(event, null, 2));
     }
 }

package/run/DefaultRun.cjs

@@ -55,10 +55,7 @@ class DefaultRun {
         this.costCalculators = costCalculators;
         this.observers = [
             {
-                onRunFunctionStarted: (event) => {
-                    this.events.push(event);
-                },
-                onRunFunctionFinished: (event) => {
+                onFunctionEvent: (event) => {
                     this.events.push(event);
                 },
             },

package/run/DefaultRun.d.ts

@@ -1,22 +1,22 @@
 import { CostCalculator } from "../cost/CostCalculator.js";
 import { SuccessfulModelCall } from "../model-function/SuccessfulModelCall.js";
 import { Run } from "./Run.js";
-import { RunFunctionEvent } from "./RunFunctionEvent.js";
-import { RunFunctionObserver } from "./RunFunctionObserver.js";
+import { FunctionEvent } from "./FunctionEvent.js";
+import { FunctionObserver } from "./FunctionObserver.js";
 export declare class DefaultRun implements Run {
     readonly runId: string;
     readonly sessionId?: string;
     readonly userId?: string;
     readonly abortSignal?: AbortSignal;
     readonly costCalculators: CostCalculator[];
-    readonly events: RunFunctionEvent[];
-    readonly observers?: RunFunctionObserver[];
+    readonly events: FunctionEvent[];
+    readonly observers?: FunctionObserver[];
     constructor({ runId, sessionId, userId, abortSignal, observers, costCalculators, }?: {
         runId?: string;
         sessionId?: string;
         userId?: string;
         abortSignal?: AbortSignal;
-        observers?: RunFunctionObserver[];
+        observers?: FunctionObserver[];
         costCalculators?: CostCalculator[];
     });
     get successfulModelCalls(): Array<SuccessfulModelCall>;

package/run/DefaultRun.js

@@ -52,10 +52,7 @@ export class DefaultRun {
         this.costCalculators = costCalculators;
         this.observers = [
             {
-                onRunFunctionStarted: (event) => {
-                    this.events.push(event);
-                },
-                onRunFunctionFinished: (event) => {
+                onFunctionEvent: (event) => {
                     this.events.push(event);
                 },
             },

package/run/FunctionEvent.d.ts

@@ -0,0 +1,51 @@
+import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/ExecuteToolEvent.js";
+import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
+export type BaseFunctionEvent = {
+    /**
+     * Unique identifier for the function call.
+     */
+    callId: string | undefined;
+    /**
+     * Optional unique identifier for the function.
+     */
+    functionId?: string | undefined;
+    /**
+     * Unique identifier for the run.
+     * Only available if the function is part of a run.
+     */
+    runId?: string | undefined;
+    /**
+     * Unique identifier for the session.
+     * Only available if the function is part of a run with a session.
+     */
+    sessionId?: string | undefined;
+    /**
+     * Unique identifier for the user.
+     * Only available if the function is part of a run with a user.
+     */
+    userId?: string | undefined;
+    /**
+     * Timestamp of the event.
+     */
+    timestamp: Date;
+    /**
+     * Type of the event. Defined in the subclasses.
+     */
+    eventType: "started" | "finished";
+    /**
+     * Type of the function. Defined in the subclasses.
+     */
+    functionType: string;
+};
+export type BaseFunctionStartedEvent = BaseFunctionEvent & {
+    eventType: "started";
+    startTimestamp: Date;
+};
+export type BaseFunctionFinishedEvent = BaseFunctionEvent & {
+    eventType: "finished";
+    status: "success" | "error" | "abort";
+    startTimestamp: Date;
+    finishTimestamp: Date;
+    durationInMs: number;
+};
+export type FunctionEvent = ModelCallStartedEvent | ExecuteToolStartedEvent | ModelCallFinishedEvent | ExecuteToolFinishedEvent;

package/run/{RunFunctionEventSource.js → FunctionEventSource.cjs}

@@ -1,4 +1,7 @@
-export class RunFunctionEventSource {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionEventSource = void 0;
+class FunctionEventSource {
     constructor({ observers, errorHandler, }) {
         Object.defineProperty(this, "observers", {
             enumerable: true,
@@ -15,20 +18,10 @@ export class RunFunctionEventSource {
         this.observers = observers;
         this.errorHandler = errorHandler ?? ((error) => console.error(error));
     }
-    notifyRunFunctionStarted(event) {
+    notify(event) {
         for (const observer of this.observers) {
             try {
-                observer.onRunFunctionStarted?.(event);
-            }
-            catch (error) {
-                this.errorHandler(error);
-            }
-        }
-    }
-    notifyRunFunctionFinished(event) {
-        for (const observer of this.observers) {
-            try {
-                observer.onRunFunctionFinished?.(event);
+                observer.onFunctionEvent(event);
             }
             catch (error) {
                 this.errorHandler(error);
@@ -36,3 +29,4 @@ export class RunFunctionEventSource {
         }
     }
 }
+exports.FunctionEventSource = FunctionEventSource;

package/run/FunctionEventSource.d.ts

@@ -0,0 +1,12 @@
+import { ErrorHandler } from "../util/ErrorHandler.js";
+import { FunctionEvent } from "./FunctionEvent.js";
+import { FunctionObserver } from "./FunctionObserver.js";
+export declare class FunctionEventSource {
+    readonly observers: FunctionObserver[];
+    readonly errorHandler: ErrorHandler;
+    constructor({ observers, errorHandler, }: {
+        observers: FunctionObserver[];
+        errorHandler?: ErrorHandler;
+    });
+    notify(event: FunctionEvent): void;
+}

package/run/{RunFunctionEventSource.cjs → FunctionEventSource.js}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunFunctionEventSource = void 0;
-class RunFunctionEventSource {
+export class FunctionEventSource {
     constructor({ observers, errorHandler, }) {
         Object.defineProperty(this, "observers", {
             enumerable: true,
@@ -18,20 +15,10 @@ class RunFunctionEventSource {
         this.observers = observers;
         this.errorHandler = errorHandler ?? ((error) => console.error(error));
     }
-    notifyRunFunctionStarted(event) {
+    notify(event) {
         for (const observer of this.observers) {
             try {
-                observer.onRunFunctionStarted?.(event);
-            }
-            catch (error) {
-                this.errorHandler(error);
-            }
-        }
-    }
-    notifyRunFunctionFinished(event) {
-        for (const observer of this.observers) {
-            try {
-                observer.onRunFunctionFinished?.(event);
+                observer.onFunctionEvent(event);
             }
             catch (error) {
                 this.errorHandler(error);
@@ -39,4 +26,3 @@ class RunFunctionEventSource {
         }
     }
 }
-exports.RunFunctionEventSource = RunFunctionEventSource;

package/run/FunctionObserver.d.ts

@@ -0,0 +1,7 @@
+import { FunctionEvent } from "./FunctionEvent.js";
+export interface FunctionObserver {
+    /**
+     * Called when a function event occurs.
+     */
+    onFunctionEvent(event: FunctionEvent): void;
+}

package/run/FunctionOptions.d.ts

@@ -0,0 +1,19 @@
+import { Run } from "./Run.js";
+import { FunctionObserver } from "./FunctionObserver.js";
+/**
+ * Additional settings for ModelFusion functions.
+ */
+export type FunctionOptions = {
+    /**
+     * Optional function identifier that is used in events to identify the function.
+     */
+    functionId?: string;
+    /**
+     * Optional observers that are called when the function is invoked.
+     */
+    observers?: Array<FunctionObserver>;
+    /**
+     * Optional run as part of which this function is called.
+     */
+    run?: Run;
+};

package/run/GlobalFunctionObservers.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalFunctionObservers = exports.setGlobalFunctionObservers = void 0;
+let globalFunctionObservers = [];
+function setGlobalFunctionObservers(functionObservers) {
+    globalFunctionObservers = functionObservers;
+}
+exports.setGlobalFunctionObservers = setGlobalFunctionObservers;
+function getGlobalFunctionObservers() {
+    return globalFunctionObservers;
+}
+exports.getGlobalFunctionObservers = getGlobalFunctionObservers;

package/run/GlobalFunctionObservers.d.ts

@@ -0,0 +1,3 @@
+import { FunctionObserver } from "./FunctionObserver.js";
+export declare function setGlobalFunctionObservers(functionObservers: FunctionObserver[]): void;
+export declare function getGlobalFunctionObservers(): FunctionObserver[];

package/run/GlobalFunctionObservers.js

@@ -0,0 +1,7 @@
+let globalFunctionObservers = [];
+export function setGlobalFunctionObservers(functionObservers) {
+    globalFunctionObservers = functionObservers;
+}
+export function getGlobalFunctionObservers() {
+    return globalFunctionObservers;
+}