modelfusion 0.20.1 → 0.21.0

package/README.md

@@ -372,18 +372,16 @@ const { chunks } = await retrieveTextChunks(
   - [Transcribe Speech](https://modelfusion.dev/guide/function/transcribe-speech)
   - [Synthesize Speech](https://modelfusion.dev/guide/function/synthesize-speech)
   - [Generate images](https://modelfusion.dev/guide/function/generate-image)
-- Summarize text
 - [Tools](https://modelfusion.dev/guide/tools)
 - [Text Chunks](https://modelfusion.dev/guide/text-chunk/)
   - [Split Text](https://modelfusion.dev/guide/text-chunk/split)
-- [Run abstraction](https://modelfusion.dev/guide/run/)
-  - [Abort signals](https://modelfusion.dev/guide/run/abort)
-  - [Cost calculation](https://modelfusion.dev/guide/run/cost-calculation)
-  - Call recording
-- Utilities
+- [Utilities](https://modelfusion.dev/guide/util/)
+  - [Function observers](https://modelfusion.dev/guide/util/observer)
   - [Retry strategies](https://modelfusion.dev/guide/util/retry)
   - [Throttling strategies](https://modelfusion.dev/guide/util/throttle)
-  - Error handling
+  - [Run abstraction](https://modelfusion.dev/guide/util/run)
+  - [Abort signals](https://modelfusion.dev/guide/util/abort)
+  - [Cost calculation](https://modelfusion.dev/guide/util/cost-calculation)
 
 ## Integrations
 

package/composed-function/summarize/SummarizationFunction.d.ts

@@ -1,4 +1,4 @@
-import { RunFunction } from "../../run/RunFunction.js";
-export type SummarizationFunction = RunFunction<{
+import { FunctionOptions } from "../../run/FunctionOptions.js";
+export type SummarizationFunction = (input: {
     text: string;
-}, string>;
+}, options?: FunctionOptions) => PromiseLike<string>;

package/model-function/Model.d.ts

@@ -1,7 +1,10 @@
 import { ModelInformation } from "./ModelInformation.js";
-import { RunFunctionObserver } from "../run/RunFunctionObserver.js";
+import { FunctionObserver } from "../run/FunctionObserver.js";
 export interface ModelSettings {
-    observers?: Array<RunFunctionObserver>;
+    /**
+     * Observers that are called when the model is used in run functions.
+     */
+    observers?: Array<FunctionObserver>;
 }
 export interface Model<SETTINGS> {
     modelInformation: ModelInformation;

package/model-function/ModelCallEvent.d.ts

@@ -1,4 +1,4 @@
-import { RunFunctionFinishedEventMetadata, RunFunctionStartedEventMetadata } from "../run/RunFunctionEvent.js";
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../run/FunctionEvent.js";
 import { ModelInformation } from "./ModelInformation.js";
 import { TextEmbeddingFinishedEvent, TextEmbeddingStartedEvent } from "./embed-text/TextEmbeddingEvent.js";
 import { ImageGenerationFinishedEvent, ImageGenerationStartedEvent } from "./generate-image/ImageGenerationEvent.js";
@@ -7,11 +7,11 @@ import { TextGenerationFinishedEvent, TextGenerationStartedEvent } from "./gener
 import { TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextStreamingEvent.js";
 import { SpeechSynthesisFinishedEvent, SpeechSynthesisStartedEvent } from "./synthesize-speech/SpeechSynthesisEvent.js";
 import { TranscriptionFinishedEvent, TranscriptionStartedEvent } from "./transcribe-speech/TranscriptionEvent.js";
-export type ModelCallStartedEventMetadata = RunFunctionStartedEventMetadata & {
+export type BaseModelCallStartedEvent = BaseFunctionStartedEvent & {
     model: ModelInformation;
 };
 export type ModelCallStartedEvent = ImageGenerationStartedEvent | JsonGenerationStartedEvent | SpeechSynthesisStartedEvent | TextEmbeddingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
-export type ModelCallFinishedEventMetadata = RunFunctionFinishedEventMetadata & {
+export type BaseModelCallFinishedEvent = BaseFunctionFinishedEvent & {
     model: ModelInformation;
 };
 export type ModelCallFinishedEvent = ImageGenerationFinishedEvent | JsonGenerationFinishedEvent | SpeechSynthesisFinishedEvent | TextEmbeddingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;

package/model-function/ModelFunctionOptions.d.ts

@@ -0,0 +1,4 @@
+import { FunctionOptions } from "../run/FunctionOptions.js";
+export interface ModelFunctionOptions<SETTINGS> extends FunctionOptions {
+    settings?: Partial<SETTINGS>;
+}

package/model-function/SuccessfulModelCall.cjs

@@ -3,24 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractSuccessfulModelCalls = void 0;
 function extractSuccessfulModelCalls(runFunctionEvents) {
     return runFunctionEvents
-        .filter((event) => Object.keys(eventTypeToCostType).includes(event.type) &&
-        "status" in event &&
-        event.status === "success")
+        .filter((event) => "status" in event && event.status === "success")
         .map((event) => ({
-        model: event.metadata.model,
+        model: event.model,
         settings: event.settings,
         response: event.response,
-        type: eventTypeToCostType[event.type],
+        type: event.functionType,
     }));
 }
 exports.extractSuccessfulModelCalls = extractSuccessfulModelCalls;
-const eventTypeToCostType = {
-    "image-generation-finished": "image-generation",
-    "json-generation-finished": "json-generation",
-    "json-or-text-generation-finished": "json-or-text-generation",
-    "speech-synthesis-finished": "speech-synthesis",
-    "text-embedding-finished": "text-embedding",
-    "text-generation-finished": "text-generation",
-    "text-streaming-finished": "text-streaming",
-    "transcription-finished": "transcription",
-};

package/model-function/SuccessfulModelCall.d.ts

@@ -1,4 +1,4 @@
-import { RunFunctionEvent } from "../run/RunFunctionEvent.js";
+import { FunctionEvent } from "../run/FunctionEvent.js";
 import { ModelInformation } from "./ModelInformation.js";
 export type SuccessfulModelCall = {
     type: "image-generation" | "json-generation" | "json-or-text-generation" | "speech-synthesis" | "text-embedding" | "text-generation" | "text-streaming" | "transcription";
@@ -6,4 +6,4 @@ export type SuccessfulModelCall = {
     settings: unknown;
     response: unknown;
 };
-export declare function extractSuccessfulModelCalls(runFunctionEvents: RunFunctionEvent[]): SuccessfulModelCall[];
+export declare function extractSuccessfulModelCalls(runFunctionEvents: FunctionEvent[]): SuccessfulModelCall[];

package/model-function/SuccessfulModelCall.js

@@ -1,22 +1,10 @@
 export function extractSuccessfulModelCalls(runFunctionEvents) {
     return runFunctionEvents
-        .filter((event) => Object.keys(eventTypeToCostType).includes(event.type) &&
-        "status" in event &&
-        event.status === "success")
+        .filter((event) => "status" in event && event.status === "success")
         .map((event) => ({
-        model: event.metadata.model,
+        model: event.model,
         settings: event.settings,
         response: event.response,
-        type: eventTypeToCostType[event.type],
+        type: event.functionType,
     }));
 }
-const eventTypeToCostType = {
-    "image-generation-finished": "image-generation",
-    "json-generation-finished": "json-generation",
-    "json-or-text-generation-finished": "json-or-text-generation",
-    "speech-synthesis-finished": "speech-synthesis",
-    "text-embedding-finished": "text-embedding",
-    "text-generation-finished": "text-generation",
-    "text-streaming-finished": "text-streaming",
-    "transcription-finished": "transcription",
-};

package/model-function/embed-text/TextEmbeddingEvent.d.ts

@@ -1,14 +1,12 @@
 import { Vector } from "../../run/Vector.js";
-import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
-export type TextEmbeddingStartedEvent = {
-    type: "text-embedding-started";
-    metadata: ModelCallStartedEventMetadata;
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export type TextEmbeddingStartedEvent = BaseModelCallStartedEvent & {
+    functionType: "text-embedding";
     settings: unknown;
     texts: Array<string>;
 };
-export type TextEmbeddingFinishedEvent = {
-    type: "text-embedding-finished";
-    metadata: ModelCallFinishedEventMetadata;
+export type TextEmbeddingFinishedEvent = BaseModelCallFinishedEvent & {
+    functionType: "text-embedding";
     settings: unknown;
     texts: Array<string>;
 } & ({
@@ -16,7 +14,7 @@ export type TextEmbeddingFinishedEvent = {
     response: unknown;
     generatedEmbeddings: Array<Vector>;
 } | {
-    status: "failure";
+    status: "error";
     error: unknown;
 } | {
     status: "abort";

package/model-function/embed-text/TextEmbeddingModel.d.ts

@@ -1,5 +1,5 @@
 import { Vector } from "../../run/Vector.js";
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface TextEmbeddingModelSettings extends ModelSettings {
 }
@@ -13,6 +13,6 @@ export interface TextEmbeddingModel<RESPONSE, SETTINGS extends TextEmbeddingMode
      */
     readonly embeddingDimensions: number | undefined;
     readonly maxTextsPerCall: number;
-    generateEmbeddingResponse(texts: string[], options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    generateEmbeddingResponse(texts: string[], options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
     extractEmbeddings(response: RESPONSE): Vector[];
 }

package/model-function/embed-text/embedText.cjs

@@ -35,30 +35,27 @@ function embedTexts(model, texts, options) {
             return embeddings;
         },
         getStartEvent: (metadata, settings) => ({
-            type: "text-embedding-started",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
         }),
         getAbortEvent: (metadata, settings) => ({
-            type: "text-embedding-finished",
-            status: "abort",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
         }),
         getFailureEvent: (metadata, settings, error) => ({
-            type: "text-embedding-finished",
-            status: "failure",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             error,
             texts,
         }),
         getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-embedding-finished",
-            status: "success",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
             response,
@@ -88,30 +85,27 @@ function embedText(model, text, options) {
             return model.extractEmbeddings(result)[0];
         },
         getStartEvent: (metadata, settings) => ({
-            type: "text-embedding-started",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
         }),
         getAbortEvent: (metadata, settings) => ({
-            type: "text-embedding-finished",
-            status: "abort",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
         }),
         getFailureEvent: (metadata, settings, error) => ({
-            type: "text-embedding-finished",
-            status: "failure",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             error,
             texts,
         }),
         getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-embedding-finished",
-            status: "success",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
             response,

package/model-function/embed-text/embedText.d.ts

@@ -1,5 +1,5 @@
 import { Vector } from "../../run/Vector.js";
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "./TextEmbeddingModel.js";
 /**
@@ -14,7 +14,7 @@ import { TextEmbeddingModel, TextEmbeddingModelSettings } from "./TextEmbeddingM
  *   ]
  * );
  */
-export declare function embedTexts<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, texts: string[], options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<TextEmbeddingModel<RESPONSE, SETTINGS>, Vector[], RESPONSE[]>;
+export declare function embedTexts<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, texts: string[], options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<TextEmbeddingModel<RESPONSE, SETTINGS>, Vector[], RESPONSE[]>;
 /**
  * Generate an embedding for a single text.
  *
@@ -24,4 +24,4 @@ export declare function embedTexts<RESPONSE, SETTINGS extends TextEmbeddingModel
  *   "At first, Nox didn't know what to do with the pup."
  * );
  */
-export declare function embedText<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, text: string, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<TextEmbeddingModel<RESPONSE, SETTINGS>, Vector, RESPONSE>;
+export declare function embedText<RESPONSE, SETTINGS extends TextEmbeddingModelSettings>(model: TextEmbeddingModel<RESPONSE, SETTINGS>, text: string, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<TextEmbeddingModel<RESPONSE, SETTINGS>, Vector, RESPONSE>;

package/model-function/embed-text/embedText.js

@@ -32,30 +32,27 @@ export function embedTexts(model, texts, options) {
             return embeddings;
         },
         getStartEvent: (metadata, settings) => ({
-            type: "text-embedding-started",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
         }),
         getAbortEvent: (metadata, settings) => ({
-            type: "text-embedding-finished",
-            status: "abort",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
         }),
         getFailureEvent: (metadata, settings, error) => ({
-            type: "text-embedding-finished",
-            status: "failure",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             error,
             texts,
         }),
         getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-embedding-finished",
-            status: "success",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
             response,
@@ -84,30 +81,27 @@ export function embedText(model, text, options) {
             return model.extractEmbeddings(result)[0];
         },
         getStartEvent: (metadata, settings) => ({
-            type: "text-embedding-started",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
         }),
         getAbortEvent: (metadata, settings) => ({
-            type: "text-embedding-finished",
-            status: "abort",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
         }),
         getFailureEvent: (metadata, settings, error) => ({
-            type: "text-embedding-finished",
-            status: "failure",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             error,
             texts,
         }),
         getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-embedding-finished",
-            status: "success",
-            metadata,
+            ...metadata,
+            functionType: "text-embedding",
             settings,
             texts,
             response,

package/model-function/executeCall.cjs

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelFunctionPromise = exports.executeCall = 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");
@@ -58,13 +59,19 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
         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)();
@@ -75,9 +82,13 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notifyRunFunctionStarted(getStartEvent(startMetadata, settings));
+    eventSource.notify(getStartEvent({
+        ...startMetadata,
+        eventType: "started",
+    }, settings));
     const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
         functionId: options?.functionId,
         settings,
@@ -85,19 +96,30 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
     }));
     const finishMetadata = {
         ...startMetadata,
+        eventType: "finished",
+        finishTimestamp: new Date(),
         durationInMs: durationMeasurement.durationInMs,
     };
     if (!result.ok) {
         if (result.isAborted) {
-            eventSource.notifyRunFunctionFinished(getAbortEvent(finishMetadata, settings));
+            eventSource.notify(getAbortEvent({
+                ...finishMetadata,
+                status: "abort",
+            }, settings));
             throw new AbortError_js_1.AbortError();
         }
-        eventSource.notifyRunFunctionFinished(getFailureEvent(finishMetadata, settings, result.error));
+        eventSource.notify(getFailureEvent({
+            ...finishMetadata,
+            status: "error",
+        }, settings, result.error));
         throw result.error;
     }
     const response = result.output;
     const output = extractOutputValue(response);
-    eventSource.notifyRunFunctionFinished(getSuccessEvent(finishMetadata, settings, response, output));
+    eventSource.notify(getSuccessEvent({
+        ...finishMetadata,
+        status: "success",
+    }, settings, response, output));
     return {
         output,
         response,

package/model-function/executeCall.d.ts

@@ -1,6 +1,6 @@
-import { FunctionOptions } from "./FunctionOptions.js";
 import { Model, ModelSettings } from "./Model.js";
-import { ModelCallFinishedEvent, ModelCallFinishedEventMetadata, ModelCallStartedEvent, ModelCallStartedEventMetadata } from "./ModelCallEvent.js";
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent, ModelCallFinishedEvent, ModelCallStartedEvent } from "./ModelCallEvent.js";
+import { ModelFunctionOptions } from "./ModelFunctionOptions.js";
 export type CallMetadata<MODEL extends Model<unknown>> = {
     callId: string;
     runId?: string;
@@ -8,17 +8,24 @@ export type CallMetadata<MODEL extends Model<unknown>> = {
     userId?: string;
     functionId?: string;
     model: MODEL["modelInformation"];
-    startEpochSeconds: number;
+    startTimestamp: Date;
+    finishTimestamp: Date;
     durationInMs: number;
 };
 export declare function executeCall<SETTINGS extends ModelSettings, MODEL extends Model<SETTINGS>, OUTPUT, RESPONSE>({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }: {
     model: MODEL;
-    options?: FunctionOptions<SETTINGS>;
-    getStartEvent: (metadata: ModelCallStartedEventMetadata, settings: SETTINGS) => ModelCallStartedEvent;
-    getAbortEvent: (metadata: ModelCallFinishedEventMetadata, settings: SETTINGS) => ModelCallFinishedEvent;
-    getFailureEvent: (metadata: ModelCallFinishedEventMetadata, settings: SETTINGS, error: unknown) => ModelCallFinishedEvent;
-    getSuccessEvent: (metadata: ModelCallFinishedEventMetadata, settings: SETTINGS, response: RESPONSE, output: OUTPUT) => ModelCallFinishedEvent;
-    generateResponse: (options: FunctionOptions<SETTINGS>) => PromiseLike<RESPONSE>;
+    options?: ModelFunctionOptions<SETTINGS>;
+    getStartEvent: (metadata: Omit<BaseModelCallStartedEvent, "functionType">, settings: SETTINGS) => ModelCallStartedEvent;
+    getAbortEvent: (metadata: Omit<BaseModelCallFinishedEvent & {
+        status: "abort";
+    }, "functionType">, settings: SETTINGS) => ModelCallFinishedEvent;
+    getFailureEvent: (metadata: Omit<BaseModelCallFinishedEvent & {
+        status: "error";
+    }, "functionType">, settings: SETTINGS, error: unknown) => ModelCallFinishedEvent;
+    getSuccessEvent: (metadata: Omit<BaseModelCallFinishedEvent & {
+        status: "success";
+    }, "functionType">, settings: SETTINGS, response: RESPONSE, output: OUTPUT) => ModelCallFinishedEvent;
+    generateResponse: (options: ModelFunctionOptions<SETTINGS>) => PromiseLike<RESPONSE>;
     extractOutputValue: (response: RESPONSE) => OUTPUT;
 }): ModelFunctionPromise<MODEL, OUTPUT, RESPONSE>;
 export declare class ModelFunctionPromise<MODEL extends Model<any>, OUTPUT, RESPONSE> extends Promise<OUTPUT> {

package/model-function/executeCall.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";
@@ -53,13 +54,19 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
         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();
@@ -70,9 +77,13 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notifyRunFunctionStarted(getStartEvent(startMetadata, settings));
+    eventSource.notify(getStartEvent({
+        ...startMetadata,
+        eventType: "started",
+    }, settings));
     const result = await runSafe(() => generateResponse({
         functionId: options?.functionId,
         settings,
@@ -80,19 +91,30 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
     }));
     const finishMetadata = {
         ...startMetadata,
+        eventType: "finished",
+        finishTimestamp: new Date(),
         durationInMs: durationMeasurement.durationInMs,
     };
     if (!result.ok) {
         if (result.isAborted) {
-            eventSource.notifyRunFunctionFinished(getAbortEvent(finishMetadata, settings));
+            eventSource.notify(getAbortEvent({
+                ...finishMetadata,
+                status: "abort",
+            }, settings));
             throw new AbortError();
         }
-        eventSource.notifyRunFunctionFinished(getFailureEvent(finishMetadata, settings, result.error));
+        eventSource.notify(getFailureEvent({
+            ...finishMetadata,
+            status: "error",
+        }, settings, result.error));
         throw result.error;
     }
     const response = result.output;
     const output = extractOutputValue(response);
-    eventSource.notifyRunFunctionFinished(getSuccessEvent(finishMetadata, settings, response, output));
+    eventSource.notify(getSuccessEvent({
+        ...finishMetadata,
+        status: "success",
+    }, settings, response, output));
     return {
         output,
         response,

package/model-function/generate-image/ImageGenerationEvent.d.ts

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

package/model-function/generate-image/ImageGenerationModel.d.ts

@@ -1,8 +1,8 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface ImageGenerationModelSettings extends ModelSettings {
 }
 export interface ImageGenerationModel<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings> extends Model<SETTINGS> {
-    generateImageResponse(prompt: PROMPT, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    generateImageResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
     extractBase64Image(response: RESPONSE): string;
 }