modelfusion 0.20.1 → 0.22.0

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

@@ -1,5 +1,5 @@
-import { Vector } from "../../run/Vector.js";
-import { FunctionOptions } from "../FunctionOptions.js";
+import { Vector } from "../../core/Vector.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

@@ -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,36 +36,6 @@ function embedTexts(model, texts, options) {
             }
             return embeddings;
         },
-        getStartEvent: (metadata, settings) => ({
-            type: "text-embedding-started",
-            metadata,
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "text-embedding-finished",
-            status: "abort",
-            metadata,
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "text-embedding-finished",
-            status: "failure",
-            metadata,
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-embedding-finished",
-            status: "success",
-            metadata,
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: output,
-        }),
     });
 }
 exports.embedTexts = embedTexts;
@@ -77,46 +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) => ({
-            type: "text-embedding-started",
-            metadata,
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "text-embedding-finished",
-            status: "abort",
-            metadata,
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "text-embedding-finished",
-            status: "failure",
-            metadata,
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-embedding-finished",
-            status: "success",
-            metadata,
-            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,5 +1,5 @@
-import { Vector } from "../../run/Vector.js";
-import { FunctionOptions } from "../FunctionOptions.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?: 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

@@ -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,36 +33,6 @@ export function embedTexts(model, texts, options) {
             }
             return embeddings;
         },
-        getStartEvent: (metadata, settings) => ({
-            type: "text-embedding-started",
-            metadata,
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "text-embedding-finished",
-            status: "abort",
-            metadata,
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "text-embedding-finished",
-            status: "failure",
-            metadata,
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-embedding-finished",
-            status: "success",
-            metadata,
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: output,
-        }),
     });
 }
 /**
@@ -73,45 +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) => ({
-            type: "text-embedding-started",
-            metadata,
-            settings,
-            texts,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "text-embedding-finished",
-            status: "abort",
-            metadata,
-            settings,
-            texts,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "text-embedding-finished",
-            status: "failure",
-            metadata,
-            settings,
-            error,
-            texts,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-embedding-finished",
-            status: "success",
-            metadata,
-            settings,
-            texts,
-            response,
-            generatedEmbeddings: [output],
-        }),
+        generateResponse: (options) => model.generateEmbeddingResponse([text], options),
+        extractOutputValue: (result) => model.extractEmbeddings(result)[0],
     });
 }

package/model-function/executeCall.cjs

@@ -2,18 +2,17 @@
 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("../core/FunctionEventSource.cjs");
+const GlobalFunctionObservers_js_1 = require("../core/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");
-function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+function executeCall({ model, options, input, functionType, generateResponse, extractOutputValue, }) {
     return new ModelFunctionPromise(doExecuteCall({
         model,
         options,
-        getStartEvent,
-        getAbortEvent,
-        getFailureEvent,
-        getSuccessEvent,
+        input,
+        functionType,
         generateResponse,
         extractOutputValue,
     }));
@@ -53,18 +52,24 @@ class ModelFunctionPromise extends Promise {
     }
 }
 exports.ModelFunctionPromise = ModelFunctionPromise;
-async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+async function doExecuteCall({ model, options, input, functionType, generateResponse, extractOutputValue, }) {
     if (options?.settings != null) {
         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 +80,16 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
+        functionType,
+        input,
+        settings,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notifyRunFunctionStarted(getStartEvent(startMetadata, settings));
+    eventSource.notify({
+        ...startMetadata,
+        eventType: "started",
+    });
     const result = await (0, runSafe_js_1.runSafe)(() => generateResponse({
         functionId: options?.functionId,
         settings,
@@ -85,19 +97,42 @@ 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({
+                ...finishMetadata,
+                eventType: "finished",
+                result: {
+                    status: "abort",
+                },
+            });
             throw new AbortError_js_1.AbortError();
         }
-        eventSource.notifyRunFunctionFinished(getFailureEvent(finishMetadata, settings, result.error));
+        eventSource.notify({
+            ...finishMetadata,
+            eventType: "finished",
+            result: {
+                status: "error",
+                error: result.error,
+            },
+        });
         throw result.error;
     }
     const response = result.output;
     const output = extractOutputValue(response);
-    eventSource.notifyRunFunctionFinished(getSuccessEvent(finishMetadata, settings, response, output));
+    eventSource.notify({
+        ...finishMetadata,
+        eventType: "finished",
+        result: {
+            status: "success",
+            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 { ModelCallStartedEvent } from "./ModelCallEvent.js";
+import { ModelFunctionOptions } from "./ModelFunctionOptions.js";
 export type CallMetadata<MODEL extends Model<unknown>> = {
     callId: string;
     runId?: string;
@@ -8,17 +8,16 @@ 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, }: {
+export declare function executeCall<SETTINGS extends ModelSettings, MODEL extends Model<SETTINGS>, OUTPUT, RESPONSE>({ model, options, input, functionType, 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>;
+    input: unknown;
+    functionType: ModelCallStartedEvent["functionType"];
+    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,16 +1,15 @@
 import { nanoid as createId } from "nanoid";
-import { RunFunctionEventSource } from "../run/RunFunctionEventSource.js";
+import { FunctionEventSource } from "../core/FunctionEventSource.js";
+import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { AbortError } from "../util/api/AbortError.js";
 import { runSafe } from "../util/runSafe.js";
-export function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+export function executeCall({ model, options, input, functionType, generateResponse, extractOutputValue, }) {
     return new ModelFunctionPromise(doExecuteCall({
         model,
         options,
-        getStartEvent,
-        getAbortEvent,
-        getFailureEvent,
-        getSuccessEvent,
+        input,
+        functionType,
         generateResponse,
         extractOutputValue,
     }));
@@ -48,18 +47,24 @@ export class ModelFunctionPromise extends Promise {
         return this.outputPromise.finally(onfinally);
     }
 }
-async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+async function doExecuteCall({ model, options, input, functionType, generateResponse, extractOutputValue, }) {
     if (options?.settings != null) {
         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 +75,16 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
+        functionType,
+        input,
+        settings,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notifyRunFunctionStarted(getStartEvent(startMetadata, settings));
+    eventSource.notify({
+        ...startMetadata,
+        eventType: "started",
+    });
     const result = await runSafe(() => generateResponse({
         functionId: options?.functionId,
         settings,
@@ -80,19 +92,42 @@ 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({
+                ...finishMetadata,
+                eventType: "finished",
+                result: {
+                    status: "abort",
+                },
+            });
             throw new AbortError();
         }
-        eventSource.notifyRunFunctionFinished(getFailureEvent(finishMetadata, settings, result.error));
+        eventSource.notify({
+            ...finishMetadata,
+            eventType: "finished",
+            result: {
+                status: "error",
+                error: result.error,
+            },
+        });
         throw result.error;
     }
     const response = result.output;
     const output = extractOutputValue(response);
-    eventSource.notifyRunFunctionFinished(getSuccessEvent(finishMetadata, settings, response, output));
+    eventSource.notify({
+        ...finishMetadata,
+        eventType: "finished",
+        result: {
+            status: "success",
+            response,
+            output,
+        },
+    });
     return {
         output,
         response,

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

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

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

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

@@ -19,40 +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) => ({
-            type: "image-generation-started",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "image-generation-finished",
-            status: "abort",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "image-generation-finished",
-            status: "failure",
-            metadata,
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "image-generation-finished",
-            status: "success",
-            metadata,
-            settings,
-            prompt,
-            response,
-            generatedImage: output,
-        }),
     });
 }
 exports.generateImage = generateImage;

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGenerationModel.js";
 /**
@@ -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?: FunctionOptions<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<ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, string, RESPONSE>;

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

@@ -16,39 +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) => ({
-            type: "image-generation-started",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "image-generation-finished",
-            status: "abort",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "image-generation-finished",
-            status: "failure",
-            metadata,
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "image-generation-finished",
-            status: "success",
-            metadata,
-            settings,
-            prompt,
-            response,
-            generatedImage: output,
-        }),
     });
 }

package/model-function/generate-json/GenerateJsonModel.d.ts

@@ -1,8 +1,8 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface GenerateJsonModelSettings extends ModelSettings {
 }
 export interface GenerateJsonModel<PROMPT, RESPONSE, SETTINGS extends GenerateJsonModelSettings> extends Model<SETTINGS> {
-    generateJsonResponse(prompt: PROMPT, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    generateJsonResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
     extractJson(response: RESPONSE): unknown;
 }

package/model-function/generate-json/GenerateJsonOrTextModel.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface GenerateJsonOrTextModelSettings extends ModelSettings {
 }
@@ -14,5 +14,5 @@ export interface GenerateJsonOrTextPrompt<RESPONSE> {
     };
 }
 export interface GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings> extends Model<SETTINGS> {
-    generateJsonResponse(prompt: PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    generateJsonResponse(prompt: PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
 }