modelfusion 0.20.1 → 0.22.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 "../../core/FunctionOptions.js";
+export type SummarizationFunction = (input: {
     text: string;
-}, string>;
+}, options?: FunctionOptions) => PromiseLike<string>;

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

@@ -1,4 +1,4 @@
-import { Run } from "../../run/Run.js";
+import { Run } from "../../core/Run.js";
 import { SplitFunction } from "../../text-chunk/split/SplitFunction.js";
 import { SummarizationFunction } from "./SummarizationFunction.js";
 export declare function summarizeRecursively({ summarize, split, join, text, }: {

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

@@ -1,6 +1,6 @@
 import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
 import { FullTokenizer } from "../../model-function/tokenize-text/Tokenizer.js";
-import { Run } from "../../run/Run.js";
+import { Run } from "../../core/Run.js";
 /**
  * Recursively summarizes a text using a text generation model, e.g. for summarization or text extraction.
  * It automatically splits the text into optimal chunks that are small enough to be processed by the model,

package/{run → core}/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/core/ConsoleLogger.d.ts

@@ -0,0 +1,5 @@
+import { FunctionEvent } from "./FunctionEvent.js";
+import { FunctionObserver } from "./FunctionObserver.js";
+export declare class ConsoleLogger implements FunctionObserver {
+    onFunctionEvent(event: FunctionEvent): void;
+}

package/core/ConsoleLogger.js

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

package/{run → core}/DefaultRun.cjs

@@ -5,7 +5,7 @@ const nanoid_1 = require("nanoid");
 const calculateCost_js_1 = require("../cost/calculateCost.cjs");
 const SuccessfulModelCall_js_1 = require("../model-function/SuccessfulModelCall.cjs");
 class DefaultRun {
-    constructor({ runId = (0, nanoid_1.nanoid)(), sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
+    constructor({ runId = `run-${(0, nanoid_1.nanoid)()}`, sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
         Object.defineProperty(this, "runId", {
             enumerable: true,
             configurable: true,
@@ -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 → core}/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 → core}/DefaultRun.js

@@ -2,7 +2,7 @@ import { nanoid as createId } from "nanoid";
 import { calculateCost } from "../cost/calculateCost.js";
 import { extractSuccessfulModelCalls, } from "../model-function/SuccessfulModelCall.js";
 export class DefaultRun {
-    constructor({ runId = createId(), sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
+    constructor({ runId = `run-${createId()}`, sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
         Object.defineProperty(this, "runId", {
             enumerable: true,
             configurable: true,
@@ -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/core/FunctionEvent.d.ts

@@ -0,0 +1,75 @@
+import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/ExecuteToolEvent.js";
+import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
+export interface 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 interface BaseFunctionStartedEvent extends BaseFunctionEvent {
+    eventType: "started";
+    /**
+     * Timestamp when the function call started.
+     */
+    startTimestamp: Date;
+}
+export type BaseFunctionFinishedEventResult = {
+    status: "success";
+    output: unknown;
+} | {
+    status: "error";
+    error: unknown;
+} | {
+    status: "abort";
+};
+export interface BaseFunctionFinishedEvent extends BaseFunctionEvent {
+    eventType: "finished";
+    /**
+     * Timestamp when the function call started.
+     */
+    startTimestamp: Date;
+    /**
+     * Timestamp when the function call finished.
+     */
+    finishTimestamp: Date;
+    /**
+     * Duration of the function call in milliseconds.
+     */
+    durationInMs: number;
+    /**
+     * Result of the function call.
+     */
+    result: BaseFunctionFinishedEventResult;
+}
+export type FunctionEvent = ModelCallStartedEvent | ExecuteToolStartedEvent | ModelCallFinishedEvent | ExecuteToolFinishedEvent;

package/{run/RunFunctionEventSource.js → core/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/core/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 → core/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/core/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/core/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/core/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/core/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/core/GlobalFunctionObservers.js

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

package/{run → core}/Run.d.ts

@@ -1,5 +1,5 @@
 import { ErrorHandler } from "../util/ErrorHandler.js";
-import { RunFunctionObserver } from "./RunFunctionObserver.js";
+import { FunctionObserver } from "./FunctionObserver.js";
 export interface Run {
     /**
      * Unique identifier for a specific run. Primarily utilized for efficient referencing
@@ -22,6 +22,6 @@ export interface Run {
      * to the run.
      */
     abortSignal?: AbortSignal;
-    observers?: RunFunctionObserver[];
+    observers?: FunctionObserver[];
     errorHandler?: ErrorHandler;
 }

package/{run → core}/index.cjs

@@ -16,10 +16,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ConsoleLogger.cjs"), exports);
 __exportStar(require("./DefaultRun.cjs"), exports);
-__exportStar(require("./IdMetadata.cjs"), exports);
+__exportStar(require("./FunctionEvent.cjs"), exports);
+__exportStar(require("./FunctionEventSource.cjs"), exports);
+__exportStar(require("./FunctionObserver.cjs"), exports);
+__exportStar(require("./FunctionOptions.cjs"), exports);
+__exportStar(require("./GlobalFunctionObservers.cjs"), exports);
 __exportStar(require("./Run.cjs"), exports);
-__exportStar(require("./RunFunction.cjs"), exports);
-__exportStar(require("./RunFunctionEvent.cjs"), exports);
-__exportStar(require("./RunFunctionObserver.cjs"), exports);
-__exportStar(require("./RunFunctionEventSource.cjs"), exports);
 __exportStar(require("./Vector.cjs"), exports);

package/core/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./ConsoleLogger.js";
+export * from "./DefaultRun.js";
+export * from "./FunctionEvent.js";
+export * from "./FunctionEventSource.js";
+export * from "./FunctionObserver.js";
+export * from "./FunctionOptions.js";
+export * from "./GlobalFunctionObservers.js";
+export * from "./Run.js";
+export * from "./Vector.js";

package/core/index.js

@@ -0,0 +1,9 @@
+export * from "./ConsoleLogger.js";
+export * from "./DefaultRun.js";
+export * from "./FunctionEvent.js";
+export * from "./FunctionEventSource.js";
+export * from "./FunctionObserver.js";
+export * from "./FunctionOptions.js";
+export * from "./GlobalFunctionObservers.js";
+export * from "./Run.js";
+export * from "./Vector.js";

package/index.cjs

@@ -15,11 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./composed-function/index.cjs"), exports);
+__exportStar(require("./core/index.cjs"), exports);
 __exportStar(require("./cost/index.cjs"), exports);
 __exportStar(require("./model-function/index.cjs"), exports);
 __exportStar(require("./model-provider/index.cjs"), exports);
 __exportStar(require("./prompt/index.cjs"), exports);
-__exportStar(require("./run/index.cjs"), exports);
 __exportStar(require("./text-chunk/index.cjs"), exports);
 __exportStar(require("./tool/index.cjs"), exports);
 __exportStar(require("./util/index.cjs"), exports);

package/index.d.ts

@@ -1,9 +1,9 @@
 export * from "./composed-function/index.js";
+export * from "./core/index.js";
 export * from "./cost/index.js";
 export * from "./model-function/index.js";
 export * from "./model-provider/index.js";
 export * from "./prompt/index.js";
-export * from "./run/index.js";
 export * from "./text-chunk/index.js";
 export * from "./tool/index.js";
 export * from "./util/index.js";

package/index.js

@@ -1,9 +1,9 @@
 export * from "./composed-function/index.js";
+export * from "./core/index.js";
 export * from "./cost/index.js";
 export * from "./model-function/index.js";
 export * from "./model-provider/index.js";
 export * from "./prompt/index.js";
-export * from "./run/index.js";
 export * from "./text-chunk/index.js";
 export * from "./tool/index.js";
 export * from "./util/index.js";

package/model-function/Model.d.ts

@@ -1,7 +1,10 @@
 import { ModelInformation } from "./ModelInformation.js";
-import { RunFunctionObserver } from "../run/RunFunctionObserver.js";
+import { FunctionObserver } from "../core/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 "../core/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,26 @@ 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 interface BaseModelCallStartedEvent extends BaseFunctionStartedEvent {
     model: ModelInformation;
+    settings: unknown;
+    input: unknown;
+}
+export type BaseModelCallFinishedEventResult = {
+    status: "success";
+    response: unknown;
+    output: unknown;
+} | {
+    status: "error";
+    error: unknown;
+} | {
+    status: "abort";
 };
-export type ModelCallStartedEvent = ImageGenerationStartedEvent | JsonGenerationStartedEvent | SpeechSynthesisStartedEvent | TextEmbeddingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
-export type ModelCallFinishedEventMetadata = RunFunctionFinishedEventMetadata & {
+export interface BaseModelCallFinishedEvent extends BaseFunctionFinishedEvent {
     model: ModelInformation;
-};
+    settings: unknown;
+    input: unknown;
+    result: BaseModelCallFinishedEventResult;
+}
+export type ModelCallStartedEvent = ImageGenerationStartedEvent | JsonGenerationStartedEvent | SpeechSynthesisStartedEvent | TextEmbeddingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
 export type ModelCallFinishedEvent = ImageGenerationFinishedEvent | JsonGenerationFinishedEvent | SpeechSynthesisFinishedEvent | TextEmbeddingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;

package/model-function/ModelFunctionOptions.d.ts

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

package/model-function/SuccessfulModelCall.cjs

@@ -3,24 +3,14 @@ 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) => "result" in event &&
+        "status" in event.result &&
+        event.result.status === "success")
         .map((event) => ({
-        model: event.metadata.model,
+        model: event.model,
         settings: event.settings,
-        response: event.response,
-        type: eventTypeToCostType[event.type],
+        response: event.result.response,
+        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 "../core/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,12 @@
 export function extractSuccessfulModelCalls(runFunctionEvents) {
     return runFunctionEvents
-        .filter((event) => Object.keys(eventTypeToCostType).includes(event.type) &&
-        "status" in event &&
-        event.status === "success")
+        .filter((event) => "result" in event &&
+        "status" in event.result &&
+        event.result.status === "success")
         .map((event) => ({
-        model: event.metadata.model,
+        model: event.model,
         settings: event.settings,
-        response: event.response,
-        type: eventTypeToCostType[event.type],
+        response: event.result.response,
+        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,23 +1,21 @@
-import { Vector } from "../../run/Vector.js";
-import { ModelCallFinishedEventMetadata, ModelCallStartedEventMetadata } from "../ModelCallEvent.js";
-export type TextEmbeddingStartedEvent = {
-    type: "text-embedding-started";
-    metadata: ModelCallStartedEventMetadata;
-    settings: unknown;
-    texts: Array<string>;
-};
-export type TextEmbeddingFinishedEvent = {
-    type: "text-embedding-finished";
-    metadata: ModelCallFinishedEventMetadata;
-    settings: unknown;
-    texts: Array<string>;
-} & ({
+import { Vector } from "../../core/Vector.js";
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export interface TextEmbeddingStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "text-embedding";
+    input: string | Array<string>;
+}
+export type TextEmbeddingFinishedEventResult = {
     status: "success";
     response: unknown;
-    generatedEmbeddings: Array<Vector>;
+    output: Vector | Array<Vector>;
 } | {
-    status: "failure";
+    status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface TextEmbeddingFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "text-embedding";
+    input: string | Array<string>;
+    result: TextEmbeddingFinishedEventResult;
+}