modelfusion 0.20.0 → 0.21.0

package/run/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/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/run/index.d.ts

@@ -1,9 +1,9 @@
 export * from "./ConsoleLogger.js";
 export * from "./DefaultRun.js";
-export * from "./IdMetadata.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 "./RunFunction.js";
-export * from "./RunFunctionEvent.js";
-export * from "./RunFunctionObserver.js";
-export * from "./RunFunctionEventSource.js";
 export * from "./Vector.js";

package/run/index.js

@@ -1,9 +1,9 @@
 export * from "./ConsoleLogger.js";
 export * from "./DefaultRun.js";
-export * from "./IdMetadata.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 "./RunFunction.js";
-export * from "./RunFunctionEvent.js";
-export * from "./RunFunctionObserver.js";
-export * from "./RunFunctionEventSource.js";
 export * from "./Vector.js";

package/text-chunk/SimilarTextChunksFromVectorIndexRetriever.cjs

@@ -33,6 +33,7 @@ class SimilarTextChunksFromVectorIndexRetriever {
         if (options?.settings != null) {
             return this.withSettings(options.settings).retrieveTextChunks(query, {
                 functionId: options.functionId,
+                observers: options.observers,
                 run: options.run,
             });
         }

package/text-chunk/SimilarTextChunksFromVectorIndexRetriever.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../model-function/embed-text/TextEmbeddingModel.js";
 import { TextChunk } from "./TextChunk.js";
 import { TextChunkRetriever, TextChunkRetrieverSettings } from "./retrieve-text-chunks/TextChunkRetriever.js";
@@ -15,6 +15,6 @@ export declare class SimilarTextChunksFromVectorIndexRetriever<CHUNK extends Tex
         vectorIndex: VectorIndex<CHUNK, INDEX>;
         embeddingModel: TextEmbeddingModel<unknown, SETTINGS>;
     } & SimilarTextChunksFromVectorIndexRetrieverSettings);
-    retrieveTextChunks(query: string, options?: FunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
+    retrieveTextChunks(query: string, options?: ModelFunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
     withSettings(additionalSettings: Partial<SimilarTextChunksFromVectorIndexRetrieverSettings>): this;
 }

package/text-chunk/SimilarTextChunksFromVectorIndexRetriever.js

@@ -30,6 +30,7 @@ export class SimilarTextChunksFromVectorIndexRetriever {
         if (options?.settings != null) {
             return this.withSettings(options.settings).retrieveTextChunks(query, {
                 functionId: options.functionId,
+                observers: options.observers,
                 run: options.run,
             });
         }

package/text-chunk/retrieve-text-chunks/TextChunkRetriever.d.ts

@@ -1,8 +1,8 @@
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TextChunk } from "../TextChunk.js";
 export interface TextChunkRetrieverSettings {
 }
 export interface TextChunkRetriever<CHUNK extends TextChunk, QUERY, SETTINGS extends TextChunkRetrieverSettings> {
-    retrieveTextChunks(query: QUERY, options?: FunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
+    retrieveTextChunks(query: QUERY, options?: ModelFunctionOptions<TextChunkRetrieverSettings>): Promise<CHUNK[]>;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

package/text-chunk/retrieve-text-chunks/retrieveTextChunks.d.ts

@@ -1,6 +1,6 @@
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../../model-function/ModelFunctionOptions.js";
 import { TextChunk } from "../TextChunk.js";
 import { TextChunkRetriever, TextChunkRetrieverSettings } from "./TextChunkRetriever.js";
-export declare function retrieveTextChunks<CHUNK extends TextChunk, QUERY, SETTINGS extends TextChunkRetrieverSettings>(retriever: TextChunkRetriever<CHUNK, QUERY, SETTINGS>, query: QUERY, options?: FunctionOptions<SETTINGS>): Promise<{
+export declare function retrieveTextChunks<CHUNK extends TextChunk, QUERY, SETTINGS extends TextChunkRetrieverSettings>(retriever: TextChunkRetriever<CHUNK, QUERY, SETTINGS>, query: QUERY, options?: ModelFunctionOptions<SETTINGS>): Promise<{
     chunks: CHUNK[];
 }>;

package/text-chunk/split/SplitFunction.d.ts

@@ -1,4 +1,4 @@
-import { RunFunction } from "../../run/RunFunction.js";
-export type SplitFunction = RunFunction<{
+import { FunctionOptions } from "../../run/FunctionOptions.js";
+export type SplitFunction = (input: {
     text: string;
-}, Array<string>>;
+}, options?: FunctionOptions) => PromiseLike<Array<string>>;

package/text-chunk/upsertTextChunks.d.ts

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { ModelFunctionOptions } from "../model-function/ModelFunctionOptions.js";
 import { TextEmbeddingModel, TextEmbeddingModelSettings } from "../model-function/embed-text/TextEmbeddingModel.js";
 import { TextChunk } from "./TextChunk.js";
 import { VectorIndex } from "../vector-index/VectorIndex.js";
@@ -8,4 +8,4 @@ export declare function upsertTextChunks<CHUNK extends TextChunk, SETTINGS exten
     generateId?: () => string;
     chunks: CHUNK[];
     ids?: Array<string | undefined>;
-}, options?: FunctionOptions<SETTINGS>): Promise<void>;
+}, options?: ModelFunctionOptions<SETTINGS>): Promise<void>;

package/tool/ExecuteToolEvent.d.ts

@@ -1,21 +1,19 @@
-import { RunFunctionFinishedEventMetadata, RunFunctionStartedEventMetadata } from "../run/RunFunctionEvent.js";
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../run/FunctionEvent.js";
 import { Tool } from "./Tool.js";
-export type ExecuteToolStartedEvent = {
-    type: "execute-tool-started";
-    metadata: RunFunctionStartedEventMetadata;
+export type ExecuteToolStartedEvent = BaseFunctionStartedEvent & {
+    functionType: "execute-tool";
     tool: Tool<string, unknown, unknown>;
     input: unknown;
 };
-export type ExecuteToolFinishedEvent = {
-    type: "execute-tool-finished";
-    metadata: RunFunctionFinishedEventMetadata;
+export type ExecuteToolFinishedEvent = BaseFunctionFinishedEvent & {
+    functionType: "execute-tool";
     tool: Tool<string, unknown, unknown>;
     input: unknown;
 } & ({
     status: "success";
     output: unknown;
 } | {
-    status: "failure";
+    status: "error";
     error: unknown;
 } | {
     status: "abort";

package/tool/Tool.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { SchemaDefinition } from "../model-function/generate-json/SchemaDefinition.js";
-import { RunFunction } from "../run/RunFunction.js";
+import { FunctionOptions } from "../run/FunctionOptions.js";
 /**
  * A tool is a function with a name, description and defined inputs that can be used
  * by agents and chatbots.
@@ -28,13 +28,13 @@ export declare class Tool<NAME extends string, INPUT, OUTPUT> {
     /**
      * The actual execution function of the tool.
      */
-    readonly execute: RunFunction<INPUT, OUTPUT>;
+    readonly execute: (input: INPUT, options?: FunctionOptions) => PromiseLike<OUTPUT>;
     constructor({ name, description, inputSchema, outputSchema, execute, }: {
         name: NAME;
         description: string;
         inputSchema: z.ZodSchema<INPUT>;
         outputSchema?: z.ZodSchema<OUTPUT>;
-        execute(input: INPUT): Promise<OUTPUT>;
+        execute(input: INPUT, options?: FunctionOptions): PromiseLike<OUTPUT>;
     });
     /**
      * Provdes a schema definition with the name, description and schema of the input.

package/tool/WebSearchTool.d.ts

@@ -1,3 +1,4 @@
+import { FunctionOptions } from "../run/FunctionOptions.js";
 import { Tool } from "./Tool.js";
 export type WebSearchToolInput = {
     query: string;
@@ -14,6 +15,6 @@ export declare class WebSearchTool<NAME extends string> extends Tool<NAME, WebSe
         name: NAME;
         description: string;
         queryDescription?: string;
-        execute(input: WebSearchToolInput): Promise<WebSearchToolOutput>;
+        execute(input: WebSearchToolInput, options?: FunctionOptions): PromiseLike<WebSearchToolOutput>;
     });
 }

package/tool/executeTool.cjs

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeTool = exports.ExecuteToolPromise = void 0;
 const nanoid_1 = require("nanoid");
-const RunFunctionEventSource_js_1 = require("../run/RunFunctionEventSource.cjs");
+const FunctionEventSource_js_1 = require("../run/FunctionEventSource.cjs");
+const GlobalFunctionObservers_js_1 = require("../run/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");
@@ -52,47 +53,51 @@ exports.executeTool = executeTool;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function doExecuteTool(tool, input, options) {
     const run = options?.run;
-    const eventSource = new RunFunctionEventSource_js_1.RunFunctionEventSource({
-        observers: run?.observers ?? [],
+    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
+        observers: [
+            ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
+            ...(run?.observers ?? []),
+            ...(options?.observers ?? []),
+        ],
         errorHandler: run?.errorHandler,
     });
     const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
-    const startMetadata = {
+    const metadata = {
+        functionType: "execute-tool",
         callId: `call-${(0, nanoid_1.nanoid)()}`,
         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,
         input,
+    };
+    eventSource.notify({
+        ...metadata,
+        eventType: "started",
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
     });
     const result = await (0, runSafe_js_1.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",
+            eventSource.notify({
+                ...finishMetadata,
                 status: "abort",
-                metadata: finishMetadata,
-                tool: tool,
-                input,
             });
             throw new AbortError_js_1.AbortError();
         }
-        eventSource.notifyRunFunctionFinished({
-            type: "execute-tool-finished",
-            status: "failure",
-            metadata: finishMetadata,
-            tool: tool,
-            input,
+        eventSource.notify({
+            ...finishMetadata,
+            status: "error",
             error: result.error,
         });
         throw new ToolExecutionError_js_1.ToolExecutionError({
@@ -104,12 +109,9 @@ async function doExecuteTool(tool, input, options) {
         });
     }
     const output = result.output;
-    eventSource.notifyRunFunctionFinished({
-        type: "execute-tool-finished",
+    eventSource.notify({
+        ...finishMetadata,
         status: "success",
-        metadata: finishMetadata,
-        tool: tool,
-        input,
         output,
     });
     return {

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 "../run/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 "../run/FunctionEventSource.js";
+import { getGlobalFunctionObservers } from "../run/GlobalFunctionObservers.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { AbortError } from "../util/api/AbortError.js";
 import { runSafe } from "../util/runSafe.js";
@@ -47,47 +48,51 @@ 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,
         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",
+            eventSource.notify({
+                ...finishMetadata,
                 status: "abort",
-                metadata: finishMetadata,
-                tool: tool,
-                input,
             });
             throw new AbortError();
         }
-        eventSource.notifyRunFunctionFinished({
-            type: "execute-tool-finished",
-            status: "failure",
-            metadata: finishMetadata,
-            tool: tool,
-            input,
+        eventSource.notify({
+            ...finishMetadata,
+            status: "error",
             error: result.error,
         });
         throw new ToolExecutionError({
@@ -99,12 +104,9 @@ async function doExecuteTool(tool, input, options) {
         });
     }
     const output = result.output;
-    eventSource.notifyRunFunctionFinished({
-        type: "execute-tool-finished",
+    eventSource.notify({
+        ...finishMetadata,
         status: "success",
-        metadata: finishMetadata,
-        tool: tool,
-        input,
         output,
     });
     return {

package/tool/index.cjs

@@ -14,6 +14,7 @@ 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("./ExecuteToolEvent.cjs"), exports);
 __exportStar(require("./InvalidToolNameError.cjs"), exports);
 __exportStar(require("./NoSuchToolError.cjs"), exports);
 __exportStar(require("./Tool.cjs"), exports);

package/tool/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./ExecuteToolEvent.js";
 export * from "./InvalidToolNameError.js";
 export * from "./NoSuchToolError.js";
 export * from "./Tool.js";

package/tool/index.js

@@ -1,3 +1,4 @@
+export * from "./ExecuteToolEvent.js";
 export * from "./InvalidToolNameError.js";
 export * from "./NoSuchToolError.js";
 export * from "./Tool.js";

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