modelfusion 0.20.1 → 0.22.0

package/tool/executeTool.d.ts

@@ -1,13 +1,14 @@
-import { FunctionOptions } from "../model-function/FunctionOptions.js";
-import { Tool } from "./Tool.js";
 import { z } from "zod";
+import { FunctionOptions } from "../core/FunctionOptions.js";
+import { Tool } from "./Tool.js";
 export type ExecuteToolMetadata = {
     callId: string;
     runId?: string;
     sessionId?: string;
     userId?: string;
     functionId?: string;
-    startEpochSeconds: number;
+    startTimestamp: Date;
+    finishTimestamp: Date;
     durationInMs: number;
 };
 export declare class ExecuteToolPromise<OUTPUT> extends Promise<OUTPUT> {
@@ -28,4 +29,4 @@ export declare class ExecuteToolPromise<OUTPUT> extends Promise<OUTPUT> {
 /**
  * `executeTool` directly executes a tool with the given parameters.
  */
-export declare function executeTool<TOOL extends Tool<any, any, any>>(tool: TOOL, input: z.infer<TOOL["inputSchema"]>, options?: FunctionOptions<undefined>): ExecuteToolPromise<ReturnType<TOOL["execute"]>>;
+export declare function executeTool<TOOL extends Tool<any, any, any>>(tool: TOOL, input: z.infer<TOOL["inputSchema"]>, options?: FunctionOptions): ExecuteToolPromise<ReturnType<TOOL["execute"]>>;

package/tool/executeTool.js

@@ -1,5 +1,6 @@
 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";
@@ -47,48 +48,56 @@ export function executeTool(tool, input, options) {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function doExecuteTool(tool, input, options) {
     const run = options?.run;
-    const eventSource = new RunFunctionEventSource({
-        observers: run?.observers ?? [],
+    const eventSource = new FunctionEventSource({
+        observers: [
+            ...getGlobalFunctionObservers(),
+            ...(run?.observers ?? []),
+            ...(options?.observers ?? []),
+        ],
         errorHandler: run?.errorHandler,
     });
     const durationMeasurement = startDurationMeasurement();
-    const startMetadata = {
+    const metadata = {
+        functionType: "execute-tool",
         callId: `call-${createId()}`,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
         functionId: options?.functionId,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
-    };
-    eventSource.notifyRunFunctionStarted({
-        type: "execute-tool-started",
-        metadata: startMetadata,
-        tool: tool,
+        toolName: tool.name,
         input,
+    };
+    eventSource.notify({
+        ...metadata,
+        eventType: "started",
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
     });
     const result = await runSafe(() => tool.execute(input, options));
     const finishMetadata = {
-        ...startMetadata,
+        ...metadata,
+        eventType: "finished",
+        timestamp: new Date(),
+        startTimestamp: durationMeasurement.startDate,
+        finishTimestamp: new Date(),
         durationInMs: durationMeasurement.durationInMs,
     };
     if (!result.ok) {
         if (result.isAborted) {
-            eventSource.notifyRunFunctionFinished({
-                type: "execute-tool-finished",
-                status: "abort",
-                metadata: finishMetadata,
-                tool: tool,
-                input,
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "abort",
+                },
             });
             throw new AbortError();
         }
-        eventSource.notifyRunFunctionFinished({
-            type: "execute-tool-finished",
-            status: "failure",
-            metadata: finishMetadata,
-            tool: tool,
-            input,
-            error: result.error,
+        eventSource.notify({
+            ...finishMetadata,
+            result: {
+                status: "error",
+                error: result.error,
+            },
         });
         throw new ToolExecutionError({
             toolName: tool.name,
@@ -99,13 +108,12 @@ async function doExecuteTool(tool, input, options) {
         });
     }
     const output = result.output;
-    eventSource.notifyRunFunctionFinished({
-        type: "execute-tool-finished",
-        status: "success",
-        metadata: finishMetadata,
-        tool: tool,
-        input,
-        output,
+    eventSource.notify({
+        ...finishMetadata,
+        result: {
+            status: "success",
+            output,
+        },
     });
     return {
         output,

package/tool/useTool.cjs

@@ -18,15 +18,11 @@ async function useTool(model, tool, prompt, options) {
         name: tool.name,
         description: tool.description,
         schema: tool.inputSchema,
-    }, () => prompt(tool), {
-        ...(options ?? {}),
-    }).asFullResponse();
+    }, () => prompt(tool), options).asFullResponse();
     return {
         tool: tool.name,
         parameters: value,
-        result: await (0, executeTool_js_1.executeTool)(tool, value, {
-            run: options?.run,
-        }),
+        result: await (0, executeTool_js_1.executeTool)(tool, value, options),
     };
 }
 exports.useTool = useTool;

package/tool/useTool.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
 import { GenerateJsonModel, GenerateJsonModelSettings } from "../model-function/generate-json/GenerateJsonModel.js";
 import { Tool } from "./Tool.js";
 /**
@@ -8,7 +8,7 @@ import { Tool } from "./Tool.js";
  * the parameters (`parameters` property, typed),
  * and the result of the tool execution (`result` property, typed).
  */
-export declare function useTool<PROMPT, RESPONSE, SETTINGS extends GenerateJsonModelSettings, TOOL extends Tool<any, any, any>>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, tool: TOOL, prompt: (tool: TOOL) => PROMPT, options?: FunctionOptions<SETTINGS>): Promise<{
+export declare function useTool<PROMPT, RESPONSE, SETTINGS extends GenerateJsonModelSettings, TOOL extends Tool<any, any, any>>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, tool: TOOL, prompt: (tool: TOOL) => PROMPT, options?: ModelFunctionOptions<SETTINGS>): Promise<{
     tool: TOOL["name"];
     parameters: TOOL["inputSchema"];
     result: Awaited<ReturnType<TOOL["execute"]>>;

package/tool/useTool.js

@@ -15,14 +15,10 @@ export async function useTool(model, tool, prompt, options) {
         name: tool.name,
         description: tool.description,
         schema: tool.inputSchema,
-    }, () => prompt(tool), {
-        ...(options ?? {}),
-    }).asFullResponse();
+    }, () => prompt(tool), options).asFullResponse();
     return {
         tool: tool.name,
         parameters: value,
-        result: await executeTool(tool, value, {
-            run: options?.run,
-        }),
+        result: await executeTool(tool, value, options),
     };
 }

package/tool/useToolOrGenerateText.cjs

@@ -25,9 +25,7 @@ async function useToolOrGenerateText(model, tools, prompt, options) {
         throw new NoSuchToolError_js_1.NoSuchToolError(schema.toString());
     }
     const toolParameters = modelResponse.value;
-    const result = await (0, executeTool_js_1.executeTool)(tool, toolParameters, {
-        run: options?.run,
-    });
+    const result = await (0, executeTool_js_1.executeTool)(tool, toolParameters, options);
     return {
         tool: schema,
         result,

package/tool/useToolOrGenerateText.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
 import { GenerateJsonOrTextModel, GenerateJsonOrTextModelSettings, GenerateJsonOrTextPrompt } from "../model-function/generate-json/GenerateJsonOrTextModel.js";
 import { Tool } from "./Tool.js";
 type ToolArray<T extends Tool<any, any, any>[]> = T;
@@ -14,7 +14,7 @@ type ToToolUnion<T> = {
     } : never;
 }[keyof T];
 type ToOutputValue<TOOLS extends ToolArray<Tool<any, any, any>[]>> = ToToolUnion<ToToolMap<TOOLS>>;
-export declare function useToolOrGenerateText<PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings, TOOLS extends Array<Tool<any, any, any>>>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, tools: TOOLS, prompt: (tools: TOOLS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): Promise<{
+export declare function useToolOrGenerateText<PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings, TOOLS extends Array<Tool<any, any, any>>>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, tools: TOOLS, prompt: (tools: TOOLS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): Promise<{
     tool: null;
     parameters: null;
     result: null;

package/tool/useToolOrGenerateText.js

@@ -22,9 +22,7 @@ export async function useToolOrGenerateText(model, tools, prompt, options) {
         throw new NoSuchToolError(schema.toString());
     }
     const toolParameters = modelResponse.value;
-    const result = await executeTool(tool, toolParameters, {
-        run: options?.run,
-    });
+    const result = await executeTool(tool, toolParameters, options);
     return {
         tool: schema,
         result,

package/util/DurationMeasurement.cjs

@@ -20,6 +20,9 @@ class PerformanceNowDurationMeasurement {
     get startEpochSeconds() {
         return Math.floor((globalThis.performance.timeOrigin + this.startTime) / 1000);
     }
+    get startDate() {
+        return new Date(this.startEpochSeconds * 1000);
+    }
     get durationInMs() {
         return Math.ceil(globalThis.performance.now() - this.startTime);
     }
@@ -36,6 +39,9 @@ class DateDurationMeasurement {
     get startEpochSeconds() {
         return Math.floor(this.startTime / 1000);
     }
+    get startDate() {
+        return new Date(this.startTime);
+    }
     get durationInMs() {
         return Date.now() - this.startTime;
     }

package/util/DurationMeasurement.d.ts

@@ -1,5 +1,6 @@
 export declare function startDurationMeasurement(): DurationMeasurement;
 export interface DurationMeasurement {
     startEpochSeconds: number;
+    startDate: Date;
     durationInMs: number;
 }

package/util/DurationMeasurement.js

@@ -16,6 +16,9 @@ class PerformanceNowDurationMeasurement {
     get startEpochSeconds() {
         return Math.floor((globalThis.performance.timeOrigin + this.startTime) / 1000);
     }
+    get startDate() {
+        return new Date(this.startEpochSeconds * 1000);
+    }
     get durationInMs() {
         return Math.ceil(globalThis.performance.now() - this.startTime);
     }
@@ -32,6 +35,9 @@ class DateDurationMeasurement {
     get startEpochSeconds() {
         return Math.floor(this.startTime / 1000);
     }
+    get startDate() {
+        return new Date(this.startTime);
+    }
     get durationInMs() {
         return Date.now() - this.startTime;
     }

package/util/api/postToApi.cjs

@@ -105,6 +105,14 @@ const postToApi = async ({ url, headers = {}, body, successfulResponseHandler, f
                 throw error;
             }
         }
+        // unwrap original error when fetch failed (for easier debugging):
+        if (error instanceof TypeError && error.message === "fetch failed") {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (error.cause != null) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                throw error.cause;
+            }
+        }
         throw error;
     }
 };

package/util/api/postToApi.js

@@ -98,6 +98,14 @@ export const postToApi = async ({ url, headers = {}, body, successfulResponseHan
                 throw error;
             }
         }
+        // unwrap original error when fetch failed (for easier debugging):
+        if (error instanceof TypeError && error.message === "fetch failed") {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (error.cause != null) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                throw error.cause;
+            }
+        }
         throw error;
     }
 };

package/vector-index/VectorIndex.d.ts

@@ -1,4 +1,4 @@
-import { Vector } from "../run/Vector.js";
+import { Vector } from "../core/Vector.js";
 export interface VectorIndex<DATA, INDEX> {
     upsertMany(data: Array<{
         id: string;

package/vector-index/memory/MemoryVectorIndex.d.ts

@@ -1,5 +1,5 @@
 import z from "zod";
-import { Vector } from "../../run/Vector.js";
+import { Vector } from "../../core/Vector.js";
 import { VectorIndex } from "../VectorIndex.js";
 /**
  * A very simple vector index that stores all entries in memory. Useful when you only have

package/vector-index/pinecone/PineconeVectorIndex.d.ts

@@ -1,6 +1,6 @@
 import { VectorOperationsApi } from "@pinecone-database/pinecone/dist/pinecone-generated-ts-fetch/index.js";
 import { z } from "zod";
-import { Vector } from "../../run/Vector.js";
+import { Vector } from "../../core/Vector.js";
 import { VectorIndex } from "../VectorIndex.js";
 export declare class PineconeVectorIndex<DATA extends object | undefined> implements VectorIndex<DATA, PineconeVectorIndex<DATA>> {
     readonly index: VectorOperationsApi;

package/model-function/FunctionOptions.d.ts

@@ -1,6 +0,0 @@
-import { Run } from "../run/Run.js";
-export interface FunctionOptions<SETTINGS> {
-    functionId?: string;
-    settings?: Partial<SETTINGS>;
-    run?: Run;
-}

package/run/ConsoleLogger.d.ts

@@ -1,6 +0,0 @@
-import { RunFunctionFinishedEvent, RunFunctionStartedEvent } from "./RunFunctionEvent.js";
-import { RunFunctionObserver } from "./RunFunctionObserver.js";
-export declare class ConsoleLogger implements RunFunctionObserver {
-    onRunFunctionStarted(event: RunFunctionStartedEvent): void;
-    onRunFunctionFinished(event: RunFunctionFinishedEvent): void;
-}

package/run/ConsoleLogger.js

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

package/run/IdMetadata.d.ts

@@ -1,7 +0,0 @@
-export type IdMetadata = {
-    callId?: string | undefined;
-    functionId?: string | undefined;
-    runId?: string | undefined;
-    sessionId?: string | undefined;
-    userId?: string | undefined;
-};

package/run/RunFunction.d.ts

@@ -1,9 +0,0 @@
-import { Run } from "./Run.js";
-/**
- * Standardized function signature for functions that are part of a run.
- *
- * This enables wrapping and chaining of run functions.
- */
-export type RunFunction<INPUT, OUTPUT> = (input: INPUT, options?: {
-    run?: Run;
-}) => PromiseLike<OUTPUT>;

package/run/RunFunctionEvent.d.ts

@@ -1,12 +0,0 @@
-import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/ExecuteToolEvent.js";
-import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
-import { IdMetadata } from "./IdMetadata.js";
-export type RunFunctionEvent = RunFunctionStartedEvent | RunFunctionFinishedEvent;
-export type RunFunctionStartedEventMetadata = IdMetadata & {
-    startEpochSeconds: number;
-};
-export type RunFunctionStartedEvent = ModelCallStartedEvent | ExecuteToolStartedEvent;
-export type RunFunctionFinishedEventMetadata = RunFunctionStartedEventMetadata & {
-    durationInMs: number;
-};
-export type RunFunctionFinishedEvent = ModelCallFinishedEvent | ExecuteToolFinishedEvent;

package/run/RunFunctionEventSource.d.ts

@@ -1,13 +0,0 @@
-import { ErrorHandler } from "../util/ErrorHandler.js";
-import { RunFunctionFinishedEvent, RunFunctionStartedEvent } from "./RunFunctionEvent.js";
-import { RunFunctionObserver } from "./RunFunctionObserver.js";
-export declare class RunFunctionEventSource {
-    readonly observers: RunFunctionObserver[];
-    readonly errorHandler: ErrorHandler;
-    constructor({ observers, errorHandler, }: {
-        observers: RunFunctionObserver[];
-        errorHandler?: ErrorHandler;
-    });
-    notifyRunFunctionStarted(event: RunFunctionStartedEvent): void;
-    notifyRunFunctionFinished(event: RunFunctionFinishedEvent): void;
-}

package/run/RunFunctionObserver.cjs

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/run/RunFunctionObserver.d.ts

@@ -1,5 +0,0 @@
-import { RunFunctionFinishedEvent, RunFunctionStartedEvent } from "./RunFunctionEvent.js";
-export type RunFunctionObserver = {
-    onRunFunctionStarted?: (event: RunFunctionStartedEvent) => void;
-    onRunFunctionFinished?: (event: RunFunctionFinishedEvent) => void;
-};

package/run/RunFunctionObserver.js

@@ -1 +0,0 @@
-export {};

package/run/index.d.ts

@@ -1,9 +0,0 @@
-export * from "./ConsoleLogger.js";
-export * from "./DefaultRun.js";
-export * from "./IdMetadata.js";
-export * from "./Run.js";
-export * from "./RunFunction.js";
-export * from "./RunFunctionEvent.js";
-export * from "./RunFunctionObserver.js";
-export * from "./RunFunctionEventSource.js";
-export * from "./Vector.js";

package/run/index.js

@@ -1,9 +0,0 @@
-export * from "./ConsoleLogger.js";
-export * from "./DefaultRun.js";
-export * from "./IdMetadata.js";
-export * from "./Run.js";
-export * from "./RunFunction.js";
-export * from "./RunFunctionEvent.js";
-export * from "./RunFunctionObserver.js";
-export * from "./RunFunctionEventSource.js";
-export * from "./Vector.js";