modelfusion 0.21.0 → 0.23.0

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

@@ -16,6 +16,8 @@ const executeCall_js_1 = require("../executeCall.cjs");
  */
 function embedTexts(model, texts, options) {
     return (0, executeCall_js_1.executeCall)({
+        functionType: "text-embedding",
+        input: texts,
         model,
         options,
         generateResponse: (options) => {
@@ -34,33 +36,6 @@ function embedTexts(model, texts, options) {
             }
             return embeddings;
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: output,
-        }),
     });
 }
 exports.embedTexts = embedTexts;
@@ -74,43 +49,13 @@ exports.embedTexts = embedTexts;
  * );
  */
 function embedText(model, text, options) {
-    const texts = [text];
     return (0, executeCall_js_1.executeCall)({
+        functionType: "text-embedding",
+        input: text,
         model,
         options,
-        generateResponse: (options) => {
-            return model.generateEmbeddingResponse(texts, options);
-        },
-        extractOutputValue: (result) => {
-            return model.extractEmbeddings(result)[0];
-        },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: [output],
-        }),
+        generateResponse: (options) => model.generateEmbeddingResponse([text], options),
+        extractOutputValue: (result) => model.extractEmbeddings(result)[0],
     });
 }
 exports.embedText = embedText;

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

@@ -1,4 +1,4 @@
-import { Vector } from "../../run/Vector.js";
+import { Vector } from "../../core/Vector.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?: ModelFunctionOptions<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<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?: ModelFunctionOptions<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<Vector, RESPONSE>;

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

@@ -13,6 +13,8 @@ import { executeCall } from "../executeCall.js";
  */
 export function embedTexts(model, texts, options) {
     return executeCall({
+        functionType: "text-embedding",
+        input: texts,
         model,
         options,
         generateResponse: (options) => {
@@ -31,33 +33,6 @@ export function embedTexts(model, texts, options) {
             }
             return embeddings;
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: output,
-        }),
     });
 }
 /**
@@ -70,42 +45,12 @@ export function embedTexts(model, texts, options) {
  * );
  */
 export function embedText(model, text, options) {
-    const texts = [text];
     return executeCall({
+        functionType: "text-embedding",
+        input: text,
         model,
         options,
-        generateResponse: (options) => {
-            return model.generateEmbeddingResponse(texts, options);
-        },
-        extractOutputValue: (result) => {
-            return model.extractEmbeddings(result)[0];
-        },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-embedding",
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: [output],
-        }),
+        generateResponse: (options) => model.generateEmbeddingResponse([text], options),
+        extractOutputValue: (result) => model.extractEmbeddings(result)[0],
     });
 }

package/model-function/executeCall.cjs

@@ -1,25 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelFunctionPromise = exports.executeCall = void 0;
+exports.executeCall = exports.ModelFunctionPromise = void 0;
 const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("../run/FunctionEventSource.cjs");
-const GlobalFunctionObservers_js_1 = require("../run/GlobalFunctionObservers.cjs");
+const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
+const GlobalFunctionLogging_js_1 = require("../core/GlobalFunctionLogging.cjs");
+const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cjs");
+const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.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");
-function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
-    return new ModelFunctionPromise(doExecuteCall({
-        model,
-        options,
-        getStartEvent,
-        getAbortEvent,
-        getFailureEvent,
-        getSuccessEvent,
-        generateResponse,
-        extractOutputValue,
-    }));
-}
-exports.executeCall = executeCall;
 class ModelFunctionPromise extends Promise {
     constructor(fullPromise) {
         super((resolve) => {
@@ -54,11 +43,24 @@ class ModelFunctionPromise extends Promise {
     }
 }
 exports.ModelFunctionPromise = ModelFunctionPromise;
-async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+function executeCall({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }) {
+    return new ModelFunctionPromise(doExecuteCall({
+        model,
+        options,
+        input,
+        functionType,
+        generateResponse,
+        extractOutputValue,
+        extractUsage,
+    }));
+}
+exports.executeCall = executeCall;
+async function doExecuteCall({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }) {
     if (options?.settings != null) {
         model = model.withSettings(options.settings);
         options = {
             functionId: options.functionId,
+            logging: options.logging,
             observers: options.observers,
             run: options.run,
         };
@@ -67,6 +69,7 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
     const settings = model.settings;
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
         observers: [
+            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, GlobalFunctionLogging_js_1.getGlobalFunctionLogging)()),
             ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
             ...(settings.observers ?? []),
             ...(run?.observers ?? []),
@@ -76,50 +79,67 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
     });
     const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
     const startMetadata = {
+        functionType,
         callId: `call-${(0, nanoid_1.nanoid)()}`,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
+        settings: model.settingsForEvent,
+        input,
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notify(getStartEvent({
-        ...startMetadata,
+    eventSource.notify({
         eventType: "started",
-    }, settings));
+        ...startMetadata,
+    });
     const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
         functionId: options?.functionId,
         settings,
         run,
     }));
     const finishMetadata = {
-        ...startMetadata,
         eventType: "finished",
+        ...startMetadata,
         finishTimestamp: new Date(),
         durationInMs: durationMeasurement.durationInMs,
     };
     if (!result.ok) {
         if (result.isAborted) {
-            eventSource.notify(getAbortEvent({
+            eventSource.notify({
                 ...finishMetadata,
-                status: "abort",
-            }, settings));
+                eventType: "finished",
+                result: {
+                    status: "abort",
+                },
+            });
             throw new AbortError_js_1.AbortError();
         }
-        eventSource.notify(getFailureEvent({
+        eventSource.notify({
             ...finishMetadata,
-            status: "error",
-        }, settings, result.error));
+            eventType: "finished",
+            result: {
+                status: "error",
+                error: result.error,
+            },
+        });
         throw result.error;
     }
     const response = result.output;
     const output = extractOutputValue(response);
-    eventSource.notify(getSuccessEvent({
+    const usage = extractUsage?.(response);
+    eventSource.notify({
         ...finishMetadata,
-        status: "success",
-    }, settings, response, output));
+        eventType: "finished",
+        result: {
+            status: "success",
+            usage,
+            response,
+            output,
+        },
+    });
     return {
         output,
         response,

package/model-function/executeCall.d.ts

@@ -1,47 +1,41 @@
 import { Model, ModelSettings } from "./Model.js";
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent, ModelCallFinishedEvent, ModelCallStartedEvent } from "./ModelCallEvent.js";
+import { ModelCallStartedEvent } from "./ModelCallEvent.js";
 import { ModelFunctionOptions } from "./ModelFunctionOptions.js";
-export type CallMetadata<MODEL extends Model<unknown>> = {
+import { ModelInformation } from "./ModelInformation.js";
+export type ModelCallMetadata = {
     callId: string;
     runId?: string;
     sessionId?: string;
     userId?: string;
     functionId?: string;
-    model: MODEL["modelInformation"];
     startTimestamp: Date;
     finishTimestamp: Date;
     durationInMs: number;
+    model: ModelInformation;
 };
-export declare function executeCall<SETTINGS extends ModelSettings, MODEL extends Model<SETTINGS>, OUTPUT, RESPONSE>({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }: {
-    model: MODEL;
-    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> {
+export declare class ModelFunctionPromise<OUTPUT, RESPONSE> extends Promise<OUTPUT> {
     private fullPromise;
     private outputPromise;
     constructor(fullPromise: Promise<{
         output: OUTPUT;
         response: RESPONSE;
-        metadata: CallMetadata<MODEL>;
+        metadata: ModelCallMetadata;
     }>);
     asFullResponse(): Promise<{
         output: OUTPUT;
         response: RESPONSE;
-        metadata: CallMetadata<MODEL>;
+        metadata: ModelCallMetadata;
     }>;
     then<TResult1 = OUTPUT, TResult2 = never>(onfulfilled?: ((value: OUTPUT) => 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<OUTPUT | TResult>;
     finally(onfinally?: (() => void) | undefined | null): Promise<OUTPUT>;
 }
+export declare function executeCall<SETTINGS extends ModelSettings, MODEL extends Model<SETTINGS>, OUTPUT, RESPONSE>({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }: {
+    model: MODEL;
+    options?: ModelFunctionOptions<SETTINGS>;
+    input: unknown;
+    functionType: ModelCallStartedEvent["functionType"];
+    generateResponse: (options: ModelFunctionOptions<SETTINGS>) => PromiseLike<RESPONSE>;
+    extractOutputValue: (response: RESPONSE) => OUTPUT;
+    extractUsage?: (response: RESPONSE) => unknown;
+}): ModelFunctionPromise<OUTPUT, RESPONSE>;

package/model-function/executeCall.js

@@ -1,21 +1,11 @@
 import { nanoid as createId } from "nanoid";
-import { FunctionEventSource } from "../run/FunctionEventSource.js";
-import { getGlobalFunctionObservers } from "../run/GlobalFunctionObservers.js";
+import { FunctionEventSource } from "../core/FunctionEventSource.js";
+import { getGlobalFunctionLogging } from "../core/GlobalFunctionLogging.js";
+import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
+import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { AbortError } from "../util/api/AbortError.js";
 import { runSafe } from "../util/runSafe.js";
-export function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
-    return new ModelFunctionPromise(doExecuteCall({
-        model,
-        options,
-        getStartEvent,
-        getAbortEvent,
-        getFailureEvent,
-        getSuccessEvent,
-        generateResponse,
-        extractOutputValue,
-    }));
-}
 export class ModelFunctionPromise extends Promise {
     constructor(fullPromise) {
         super((resolve) => {
@@ -49,11 +39,23 @@ export class ModelFunctionPromise extends Promise {
         return this.outputPromise.finally(onfinally);
     }
 }
-async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+export function executeCall({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }) {
+    return new ModelFunctionPromise(doExecuteCall({
+        model,
+        options,
+        input,
+        functionType,
+        generateResponse,
+        extractOutputValue,
+        extractUsage,
+    }));
+}
+async function doExecuteCall({ model, options, input, functionType, generateResponse, extractOutputValue, extractUsage, }) {
     if (options?.settings != null) {
         model = model.withSettings(options.settings);
         options = {
             functionId: options.functionId,
+            logging: options.logging,
             observers: options.observers,
             run: options.run,
         };
@@ -62,6 +64,7 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
     const settings = model.settings;
     const eventSource = new FunctionEventSource({
         observers: [
+            ...getFunctionCallLogger(options?.logging ?? getGlobalFunctionLogging()),
             ...getGlobalFunctionObservers(),
             ...(settings.observers ?? []),
             ...(run?.observers ?? []),
@@ -71,50 +74,67 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
     });
     const durationMeasurement = startDurationMeasurement();
     const startMetadata = {
+        functionType,
         callId: `call-${createId()}`,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
+        settings: model.settingsForEvent,
+        input,
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notify(getStartEvent({
-        ...startMetadata,
+    eventSource.notify({
         eventType: "started",
-    }, settings));
+        ...startMetadata,
+    });
     const result = await runSafe(() => generateResponse({
         functionId: options?.functionId,
         settings,
         run,
     }));
     const finishMetadata = {
-        ...startMetadata,
         eventType: "finished",
+        ...startMetadata,
         finishTimestamp: new Date(),
         durationInMs: durationMeasurement.durationInMs,
     };
     if (!result.ok) {
         if (result.isAborted) {
-            eventSource.notify(getAbortEvent({
+            eventSource.notify({
                 ...finishMetadata,
-                status: "abort",
-            }, settings));
+                eventType: "finished",
+                result: {
+                    status: "abort",
+                },
+            });
             throw new AbortError();
         }
-        eventSource.notify(getFailureEvent({
+        eventSource.notify({
             ...finishMetadata,
-            status: "error",
-        }, settings, result.error));
+            eventType: "finished",
+            result: {
+                status: "error",
+                error: result.error,
+            },
+        });
         throw result.error;
     }
     const response = result.output;
     const output = extractOutputValue(response);
-    eventSource.notify(getSuccessEvent({
+    const usage = extractUsage?.(response);
+    eventSource.notify({
         ...finishMetadata,
-        status: "success",
-    }, settings, response, output));
+        eventType: "finished",
+        result: {
+            status: "success",
+            usage,
+            response,
+            output,
+        },
+    });
     return {
         output,
         response,

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

@@ -1,20 +1,18 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export type ImageGenerationStartedEvent = BaseModelCallStartedEvent & {
+export interface ImageGenerationStartedEvent extends BaseModelCallStartedEvent {
     functionType: "image-generation";
-    settings: unknown;
-    prompt: unknown;
-};
-export type ImageGenerationFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "image-generation";
-    settings: unknown;
-    prompt: unknown;
-} & ({
+}
+export type ImageGenerationFinishedEventResult = {
     status: "success";
     response: unknown;
-    generatedImage: string;
+    output: string;
 } | {
     status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface ImageGenerationFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "image-generation";
+    result: ImageGenerationFinishedEventResult;
+}

package/model-function/generate-image/generateImage.cjs

@@ -19,37 +19,12 @@ const executeCall_js_1 = require("../executeCall.cjs");
  */
 function generateImage(model, prompt, options) {
     return (0, executeCall_js_1.executeCall)({
+        functionType: "image-generation",
+        input: prompt,
         model,
         options,
         generateResponse: (options) => model.generateImageResponse(prompt, options),
         extractOutputValue: model.extractBase64Image,
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-            response,
-            generatedImage: output,
-        }),
     });
 }
 exports.generateImage = generateImage;

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

@@ -16,4 +16,4 @@ import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGener
  *   ]
  * );
  */
-export declare function generateImage<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings>(model: ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, string, RESPONSE>;
+export declare function generateImage<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings>(model: ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<string, RESPONSE>;

package/model-function/generate-image/generateImage.js

@@ -16,36 +16,11 @@ import { executeCall } from "../executeCall.js";
  */
 export function generateImage(model, prompt, options) {
     return executeCall({
+        functionType: "image-generation",
+        input: prompt,
         model,
         options,
         generateResponse: (options) => model.generateImageResponse(prompt, options),
         extractOutputValue: model.extractBase64Image,
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-            response,
-            generatedImage: output,
-        }),
     });
 }