modelfusion 0.21.0 → 0.23.0

package/README.md

@@ -376,6 +376,7 @@ const { chunks } = await retrieveTextChunks(
 - [Text Chunks](https://modelfusion.dev/guide/text-chunk/)
   - [Split Text](https://modelfusion.dev/guide/text-chunk/split)
 - [Utilities](https://modelfusion.dev/guide/util/)
+  - [Function Logging](https://modelfusion.dev/guide/util/logging)
   - [Function observers](https://modelfusion.dev/guide/util/observer)
   - [Retry strategies](https://modelfusion.dev/guide/util/retry)
   - [Throttling strategies](https://modelfusion.dev/guide/util/throttle)

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../../run/FunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 export type SummarizationFunction = (input: {
     text: 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}/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,

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,

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

@@ -1,6 +1,6 @@
 import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/ExecuteToolEvent.js";
 import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
-export type BaseFunctionEvent = {
+export interface BaseFunctionEvent {
     /**
      * Unique identifier for the function call.
      */
@@ -36,16 +36,40 @@ export type BaseFunctionEvent = {
      * Type of the function. Defined in the subclasses.
      */
     functionType: string;
-};
-export type BaseFunctionStartedEvent = BaseFunctionEvent & {
+}
+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 type BaseFunctionFinishedEvent = BaseFunctionEvent & {
+export interface BaseFunctionFinishedEvent extends BaseFunctionEvent {
     eventType: "finished";
-    status: "success" | "error" | "abort";
+    /**
+     * 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/core/FunctionOptions.d.ts

@@ -0,0 +1,33 @@
+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 logging to use for the function. Logs are sent to the console.
+     * Overrides the global function logging setting.
+     */
+    logging?: FunctionLogging;
+    /**
+     * 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;
+};
+/**
+ * The logging to use for the function. Logs are sent to the console.
+ *
+ * - `off` or undefined: No logging.
+ * - `basic-text`: Log the timestamp and the type of event as a single line of text.
+ * - `detailed-object`: Log everything except the original response as an object to the console.
+ * - `detailed-json`: Log everything except the original response as a JSON string to the console.
+ */
+export type FunctionLogging = undefined | "off" | "basic-text" | "detailed-object" | "detailed-json";

package/core/GlobalFunctionLogging.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalFunctionLogging = exports.setGlobalFunctionLogging = void 0;
+let globalFunctionLogging = undefined;
+function setGlobalFunctionLogging(logLevel) {
+    globalFunctionLogging = logLevel;
+}
+exports.setGlobalFunctionLogging = setGlobalFunctionLogging;
+function getGlobalFunctionLogging() {
+    return globalFunctionLogging;
+}
+exports.getGlobalFunctionLogging = getGlobalFunctionLogging;

package/core/GlobalFunctionLogging.d.ts

@@ -0,0 +1,3 @@
+import { FunctionLogging } from "./FunctionOptions.js";
+export declare function setGlobalFunctionLogging(logLevel: FunctionLogging): void;
+export declare function getGlobalFunctionLogging(): FunctionLogging;

package/core/GlobalFunctionLogging.js

@@ -0,0 +1,7 @@
+let globalFunctionLogging = undefined;
+export function setGlobalFunctionLogging(logLevel) {
+    globalFunctionLogging = logLevel;
+}
+export function getGlobalFunctionLogging() {
+    return globalFunctionLogging;
+}

package/core/getFunctionCallLogger.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionCallLogger = void 0;
+function getFunctionCallLogger(logging) {
+    switch (logging) {
+        case "basic-text":
+            return [basicTextObserver];
+        case "detailed-object":
+            return [detailedObjectObserver];
+        case "detailed-json":
+            return [detailedJsonObserver];
+        case "off":
+        default:
+            return [];
+    }
+}
+exports.getFunctionCallLogger = getFunctionCallLogger;
+const basicTextObserver = {
+    onFunctionEvent(event) {
+        // log based on event type:
+        switch (event.eventType) {
+            case "started": {
+                console.log(`[${event.timestamp.toISOString()}] ${event.callId} - ${event.functionType} ${event.eventType}`);
+                break;
+            }
+            case "finished": {
+                console.log(`[${event.timestamp.toISOString()}] ${event.callId} - ${event.functionType} ${event.eventType} in ${event.durationInMs}ms`);
+                break;
+            }
+        }
+    },
+};
+const detailedObjectObserver = {
+    onFunctionEvent(event) {
+        // Remove the "response" property from the result (if any):
+        if (event.eventType === "finished" &&
+            event.result != null &&
+            "response" in event.result &&
+            event.result?.response != null) {
+            event = {
+                ...event,
+                result: Object.fromEntries(Object.entries(event.result).filter(([k]) => k !== "response")
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ),
+            };
+        }
+        // filter all undefined properties from event for cleaner console output:
+        event = Object.fromEntries(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Object.entries(event).filter(([_, v]) => v !== undefined));
+        console.log(event);
+    },
+};
+const detailedJsonObserver = {
+    onFunctionEvent(event) {
+        // Remove the "response" property from the result (if any):
+        if (event.eventType === "finished" &&
+            event.result != null &&
+            "response" in event.result &&
+            event.result?.response != null) {
+            event = {
+                ...event,
+                result: Object.fromEntries(Object.entries(event.result).filter(([k]) => k !== "response")
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ),
+            };
+        }
+        // filter all undefined properties from event for cleaner console output:
+        event = Object.fromEntries(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Object.entries(event).filter(([_, v]) => v !== undefined));
+        console.log(JSON.stringify(event));
+    },
+};

package/core/getFunctionCallLogger.d.ts

@@ -0,0 +1,3 @@
+import { FunctionOptions } from "./FunctionOptions.js";
+import { FunctionObserver } from "./FunctionObserver.js";
+export declare function getFunctionCallLogger(logging: FunctionOptions["logging"]): Array<FunctionObserver>;

package/core/getFunctionCallLogger.js

@@ -0,0 +1,70 @@
+export function getFunctionCallLogger(logging) {
+    switch (logging) {
+        case "basic-text":
+            return [basicTextObserver];
+        case "detailed-object":
+            return [detailedObjectObserver];
+        case "detailed-json":
+            return [detailedJsonObserver];
+        case "off":
+        default:
+            return [];
+    }
+}
+const basicTextObserver = {
+    onFunctionEvent(event) {
+        // log based on event type:
+        switch (event.eventType) {
+            case "started": {
+                console.log(`[${event.timestamp.toISOString()}] ${event.callId} - ${event.functionType} ${event.eventType}`);
+                break;
+            }
+            case "finished": {
+                console.log(`[${event.timestamp.toISOString()}] ${event.callId} - ${event.functionType} ${event.eventType} in ${event.durationInMs}ms`);
+                break;
+            }
+        }
+    },
+};
+const detailedObjectObserver = {
+    onFunctionEvent(event) {
+        // Remove the "response" property from the result (if any):
+        if (event.eventType === "finished" &&
+            event.result != null &&
+            "response" in event.result &&
+            event.result?.response != null) {
+            event = {
+                ...event,
+                result: Object.fromEntries(Object.entries(event.result).filter(([k]) => k !== "response")
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ),
+            };
+        }
+        // filter all undefined properties from event for cleaner console output:
+        event = Object.fromEntries(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Object.entries(event).filter(([_, v]) => v !== undefined));
+        console.log(event);
+    },
+};
+const detailedJsonObserver = {
+    onFunctionEvent(event) {
+        // Remove the "response" property from the result (if any):
+        if (event.eventType === "finished" &&
+            event.result != null &&
+            "response" in event.result &&
+            event.result?.response != null) {
+            event = {
+                ...event,
+                result: Object.fromEntries(Object.entries(event.result).filter(([k]) => k !== "response")
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ),
+            };
+        }
+        // filter all undefined properties from event for cleaner console output:
+        event = Object.fromEntries(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        Object.entries(event).filter(([_, v]) => v !== undefined));
+        console.log(JSON.stringify(event));
+    },
+};

package/{run → core}/index.cjs

@@ -14,12 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ConsoleLogger.cjs"), exports);
 __exportStar(require("./DefaultRun.cjs"), exports);
 __exportStar(require("./FunctionEvent.cjs"), exports);
 __exportStar(require("./FunctionEventSource.cjs"), exports);
 __exportStar(require("./FunctionObserver.cjs"), exports);
 __exportStar(require("./FunctionOptions.cjs"), exports);
+__exportStar(require("./GlobalFunctionLogging.cjs"), exports);
 __exportStar(require("./GlobalFunctionObservers.cjs"), exports);
 __exportStar(require("./Run.cjs"), exports);
 __exportStar(require("./Vector.cjs"), exports);

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

@@ -1,9 +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 "./GlobalFunctionLogging.js";
 export * from "./GlobalFunctionObservers.js";
 export * from "./Run.js";
 export * from "./Vector.js";

package/{run → core}/index.js

@@ -1,9 +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 "./GlobalFunctionLogging.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/AbstractModel.d.ts

@@ -7,6 +7,7 @@ export declare abstract class AbstractModel<SETTINGS extends ModelSettings> impl
     abstract readonly provider: string;
     abstract readonly modelName: string | null;
     get modelInformation(): ModelInformation;
+    abstract get settingsForEvent(): Partial<SETTINGS>;
     readonly settings: SETTINGS;
     abstract withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

package/model-function/Model.d.ts

@@ -1,14 +1,19 @@
 import { ModelInformation } from "./ModelInformation.js";
-import { FunctionObserver } from "../run/FunctionObserver.js";
+import { FunctionObserver } from "../core/FunctionObserver.js";
 export interface ModelSettings {
     /**
      * Observers that are called when the model is used in run functions.
      */
     observers?: Array<FunctionObserver>;
 }
-export interface Model<SETTINGS> {
+export interface Model<SETTINGS extends ModelSettings> {
     modelInformation: ModelInformation;
     readonly settings: SETTINGS;
+    /**
+     * Returns settings that should be recorded in observability events.
+     * Security-related settings (e.g. API keys) should not be included here.
+     */
+    get settingsForEvent(): Partial<SETTINGS>;
     /**
      * The `withSettings` method creates a new model with the same configuration as the original model, but with the specified settings changed.
      *

package/model-function/ModelCallEvent.d.ts

@@ -1,4 +1,4 @@
-import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../run/FunctionEvent.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,45 @@ 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 BaseModelCallStartedEvent = BaseFunctionStartedEvent & {
+export interface BaseModelCallStartedEvent extends BaseFunctionStartedEvent {
     model: ModelInformation;
+    /**
+     * The main input to the model call. The type depends on the call type or model.
+     */
+    input: unknown;
+    /**
+     * The model settings used for the call. The type depends on the model.
+     */
+    settings: unknown;
+}
+export type BaseModelCallFinishedEventResult = {
+    status: "success";
+    response: unknown;
+    output: unknown;
+    /**
+     * Optional usage information for the model call. The type depends on the call type.
+     */
+    usage?: unknown;
+} | {
+    status: "error";
+    error: unknown;
+} | {
+    status: "abort";
 };
-export type ModelCallStartedEvent = ImageGenerationStartedEvent | JsonGenerationStartedEvent | SpeechSynthesisStartedEvent | TextEmbeddingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
-export type BaseModelCallFinishedEvent = BaseFunctionFinishedEvent & {
+export interface BaseModelCallFinishedEvent extends BaseFunctionFinishedEvent {
     model: ModelInformation;
-};
+    /**
+     * The main input to the model call. The type depends on the call type or model.
+     */
+    input: unknown;
+    /**
+     * The model settings used for the call. The type depends on the model.
+     */
+    settings: unknown;
+    /**
+     * The result of the model call. Can be "success", "error", or "abort". Additional information is provided depending on the status.
+     */
+    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

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

package/model-function/SuccessfulModelCall.cjs

@@ -3,11 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractSuccessfulModelCalls = void 0;
 function extractSuccessfulModelCalls(runFunctionEvents) {
     return runFunctionEvents
-        .filter((event) => "status" in event && event.status === "success")
+        .filter((event) => "result" in event &&
+        "status" in event.result &&
+        event.result.status === "success")
         .map((event) => ({
         model: event.model,
         settings: event.settings,
-        response: event.response,
+        response: event.result.response,
         type: event.functionType,
     }));
 }

package/model-function/SuccessfulModelCall.d.ts

@@ -1,4 +1,4 @@
-import { FunctionEvent } from "../run/FunctionEvent.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";

package/model-function/SuccessfulModelCall.js

@@ -1,10 +1,12 @@
 export function extractSuccessfulModelCalls(runFunctionEvents) {
     return runFunctionEvents
-        .filter((event) => "status" in event && event.status === "success")
+        .filter((event) => "result" in event &&
+        "status" in event.result &&
+        event.result.status === "success")
         .map((event) => ({
         model: event.model,
         settings: event.settings,
-        response: event.response,
+        response: event.result.response,
         type: event.functionType,
     }));
 }

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

@@ -1,21 +1,21 @@
-import { Vector } from "../../run/Vector.js";
+import { Vector } from "../../core/Vector.js";
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export type TextEmbeddingStartedEvent = BaseModelCallStartedEvent & {
+export interface TextEmbeddingStartedEvent extends BaseModelCallStartedEvent {
     functionType: "text-embedding";
-    settings: unknown;
-    texts: Array<string>;
-};
-export type TextEmbeddingFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "text-embedding";
-    settings: unknown;
-    texts: Array<string>;
-} & ({
+    input: string | Array<string>;
+}
+export type TextEmbeddingFinishedEventResult = {
     status: "success";
     response: unknown;
-    generatedEmbeddings: Array<Vector>;
+    output: Vector | Array<Vector>;
 } | {
     status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface TextEmbeddingFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "text-embedding";
+    input: string | Array<string>;
+    result: TextEmbeddingFinishedEventResult;
+}

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

@@ -1,4 +1,4 @@
-import { Vector } from "../../run/Vector.js";
+import { Vector } from "../../core/Vector.js";
 import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface TextEmbeddingModelSettings extends ModelSettings {