modelfusion 0.7.0 → 0.9.0

package/run/DefaultRun.cjs

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultRun = void 0;
 const nanoid_1 = require("nanoid");
-const SuccessfulModelCall_js_1 = require("../model-function/SuccessfulModelCall.cjs");
 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 = [], } = {}) {
         Object.defineProperty(this, "runId", {
@@ -36,7 +36,7 @@ class DefaultRun {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modelCallEvents", {
+        Object.defineProperty(this, "events", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -55,18 +55,18 @@ class DefaultRun {
         this.costCalculators = costCalculators;
         this.observers = [
             {
-                onModelCallStarted: (event) => {
-                    this.modelCallEvents.push(event);
+                onRunFunctionStarted: (event) => {
+                    this.events.push(event);
                 },
-                onModelCallFinished: (event) => {
-                    this.modelCallEvents.push(event);
+                onRunFunctionFinished: (event) => {
+                    this.events.push(event);
                 },
             },
             ...(observers ?? []),
         ];
     }
     get successfulModelCalls() {
-        return (0, SuccessfulModelCall_js_1.extractSuccessfulModelCalls)(this.modelCallEvents);
+        return (0, SuccessfulModelCall_js_1.extractSuccessfulModelCalls)(this.events);
     }
     calculateCost() {
         return (0, calculateCost_js_1.calculateCost)({

package/run/DefaultRun.d.ts

@@ -1,22 +1,22 @@
+import { CostCalculator } from "../cost/CostCalculator.js";
 import { SuccessfulModelCall } from "../model-function/SuccessfulModelCall.js";
-import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
-import { ModelCallObserver } from "../model-function/ModelCallObserver.js";
 import { Run } from "./Run.js";
-import { CostCalculator } from "../cost/CostCalculator.js";
+import { RunFunctionEvent } from "./RunFunctionEvent.js";
+import { RunFunctionObserver } from "./RunFunctionObserver.js";
 export declare class DefaultRun implements Run {
     readonly runId: string;
     readonly sessionId?: string;
     readonly userId?: string;
     readonly abortSignal?: AbortSignal;
     readonly costCalculators: CostCalculator[];
-    readonly modelCallEvents: (ModelCallFinishedEvent | ModelCallStartedEvent)[];
-    readonly observers?: ModelCallObserver[];
+    readonly events: RunFunctionEvent[];
+    readonly observers?: RunFunctionObserver[];
     constructor({ runId, sessionId, userId, abortSignal, observers, costCalculators, }?: {
         runId?: string;
         sessionId?: string;
         userId?: string;
         abortSignal?: AbortSignal;
-        observers?: ModelCallObserver[];
+        observers?: RunFunctionObserver[];
         costCalculators?: CostCalculator[];
     });
     get successfulModelCalls(): Array<SuccessfulModelCall>;

package/run/DefaultRun.js

@@ -1,6 +1,6 @@
 import { nanoid as createId } from "nanoid";
-import { extractSuccessfulModelCalls, } from "../model-function/SuccessfulModelCall.js";
 import { calculateCost } from "../cost/calculateCost.js";
+import { extractSuccessfulModelCalls, } from "../model-function/SuccessfulModelCall.js";
 export class DefaultRun {
     constructor({ runId = createId(), sessionId, userId, abortSignal, observers, costCalculators = [], } = {}) {
         Object.defineProperty(this, "runId", {
@@ -33,7 +33,7 @@ export class DefaultRun {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "modelCallEvents", {
+        Object.defineProperty(this, "events", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -52,18 +52,18 @@ export class DefaultRun {
         this.costCalculators = costCalculators;
         this.observers = [
             {
-                onModelCallStarted: (event) => {
-                    this.modelCallEvents.push(event);
+                onRunFunctionStarted: (event) => {
+                    this.events.push(event);
                 },
-                onModelCallFinished: (event) => {
-                    this.modelCallEvents.push(event);
+                onRunFunctionFinished: (event) => {
+                    this.events.push(event);
                 },
             },
             ...(observers ?? []),
         ];
     }
     get successfulModelCalls() {
-        return extractSuccessfulModelCalls(this.modelCallEvents);
+        return extractSuccessfulModelCalls(this.events);
     }
     calculateCost() {
         return calculateCost({

package/run/Run.d.ts

@@ -1,5 +1,5 @@
 import { ErrorHandler } from "../util/ErrorHandler.js";
-import { ModelCallObserver } from "../model-function/ModelCallObserver.js";
+import { RunFunctionObserver } from "./RunFunctionObserver.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?: ModelCallObserver[];
+    observers?: RunFunctionObserver[];
     errorHandler?: ErrorHandler;
 }

package/run/RunFunction.d.ts

@@ -1,4 +1,3 @@
-import { SafeResult } from "../util/SafeResult.js";
 import { Run } from "./Run.js";
 /**
  * Standardized function signature for functions that are part of a run.
@@ -8,6 +7,3 @@ import { Run } from "./Run.js";
 export type RunFunction<INPUT, OUTPUT> = (input: INPUT, options?: {
     run?: Run;
 }) => PromiseLike<OUTPUT>;
-export type SafeRunFunction<INPUT, OUTPUT> = (input: INPUT, options?: {
-    run?: Run;
-}) => PromiseLike<SafeResult<OUTPUT>>;

package/run/RunFunctionEvent.d.ts

@@ -0,0 +1,12 @@
+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/{model-function/ModelCallEventSource.cjs → run/RunFunctionEventSource.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelCallEventSource = void 0;
-class ModelCallEventSource {
+exports.RunFunctionEventSource = void 0;
+class RunFunctionEventSource {
     constructor({ observers, errorHandler, }) {
         Object.defineProperty(this, "observers", {
             enumerable: true,
@@ -18,20 +18,20 @@ class ModelCallEventSource {
         this.observers = observers;
         this.errorHandler = errorHandler ?? ((error) => console.error(error));
     }
-    notifyModelCallStarted(event) {
+    notifyRunFunctionStarted(event) {
         for (const observer of this.observers) {
             try {
-                observer.onModelCallStarted?.(event);
+                observer.onRunFunctionStarted?.(event);
             }
             catch (error) {
                 this.errorHandler(error);
             }
         }
     }
-    notifyModelCallFinished(event) {
+    notifyRunFunctionFinished(event) {
         for (const observer of this.observers) {
             try {
-                observer.onModelCallFinished?.(event);
+                observer.onRunFunctionFinished?.(event);
             }
             catch (error) {
                 this.errorHandler(error);
@@ -39,4 +39,4 @@ class ModelCallEventSource {
         }
     }
 }
-exports.ModelCallEventSource = ModelCallEventSource;
+exports.RunFunctionEventSource = RunFunctionEventSource;

package/run/RunFunctionEventSource.d.ts

@@ -0,0 +1,13 @@
+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/{model-function/ModelCallEventSource.js → run/RunFunctionEventSource.js}

@@ -1,4 +1,4 @@
-export class ModelCallEventSource {
+export class RunFunctionEventSource {
     constructor({ observers, errorHandler, }) {
         Object.defineProperty(this, "observers", {
             enumerable: true,
@@ -15,20 +15,20 @@ export class ModelCallEventSource {
         this.observers = observers;
         this.errorHandler = errorHandler ?? ((error) => console.error(error));
     }
-    notifyModelCallStarted(event) {
+    notifyRunFunctionStarted(event) {
         for (const observer of this.observers) {
             try {
-                observer.onModelCallStarted?.(event);
+                observer.onRunFunctionStarted?.(event);
             }
             catch (error) {
                 this.errorHandler(error);
             }
         }
     }
-    notifyModelCallFinished(event) {
+    notifyRunFunctionFinished(event) {
         for (const observer of this.observers) {
             try {
-                observer.onModelCallFinished?.(event);
+                observer.onRunFunctionFinished?.(event);
             }
             catch (error) {
                 this.errorHandler(error);

package/run/RunFunctionObserver.cjs

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

package/run/RunFunctionObserver.d.ts

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

package/run/RunFunctionObserver.js

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

package/run/index.cjs

@@ -19,4 +19,7 @@ __exportStar(require("./DefaultRun.cjs"), exports);
 __exportStar(require("./IdMetadata.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

@@ -3,4 +3,7 @@ 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

@@ -3,4 +3,7 @@ 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/tool/ExecuteToolEvent.cjs

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

package/tool/ExecuteToolEvent.d.ts

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

package/tool/ExecuteToolEvent.js

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

package/{composed-function/use-tool → tool}/Tool.cjs

@@ -1,26 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tool = void 0;
+/**
+ * A tool is a function with a name, description and defined inputs that can be used
+ * by agents and chatbots.
+ */
 class Tool {
     constructor(options) {
+        /**
+         * The name of the tool. Should be understandable for language models and unique among the tools that they know.
+         */
         Object.defineProperty(this, "name", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * A description of what the tool does. Will be used by the language model to decide whether to use the tool.
+         */
         Object.defineProperty(this, "description", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * The schema of the input that the tool expects. The language model will use this to generate the input.
+         * Use descriptions to make the input understandable for the language model.
+         */
         Object.defineProperty(this, "inputSchema", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * An optional schema of the output that the tool produces. This will be used to validate the output.
+         */
+        Object.defineProperty(this, "outputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The actual execution function of the tool.
+         */
         Object.defineProperty(this, "execute", {
             enumerable: true,
             configurable: true,
@@ -30,8 +56,13 @@ class Tool {
         this.name = options.name;
         this.description = options.description;
         this.inputSchema = options.inputSchema;
+        this.outputSchema = options.outputSchema;
         this.execute = options.execute;
     }
+    /**
+     * Provdes a schema definition with the name, description and schema of the input.
+     * This is used by `useTool`.
+     */
     get inputSchemaDefinition() {
         return {
             name: this.name,

package/tool/Tool.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { SchemaDefinition } from "../model-function/generate-json/SchemaDefinition.js";
+import { RunFunction } from "../run/RunFunction.js";
+/**
+ * A tool is a function with a name, description and defined inputs that can be used
+ * by agents and chatbots.
+ */
+export declare class Tool<NAME extends string, INPUT, OUTPUT> {
+    /**
+     * The name of the tool. Should be understandable for language models and unique among the tools that they know.
+     */
+    readonly name: NAME;
+    /**
+     * A description of what the tool does. Will be used by the language model to decide whether to use the tool.
+     */
+    readonly description: string;
+    /**
+     * The schema of the input that the tool expects. The language model will use this to generate the input.
+     * Use descriptions to make the input understandable for the language model.
+     */
+    readonly inputSchema: z.ZodSchema<INPUT>;
+    /**
+     * An optional schema of the output that the tool produces. This will be used to validate the output.
+     */
+    readonly outputSchema?: z.ZodSchema<OUTPUT>;
+    /**
+     * The actual execution function of the tool.
+     */
+    readonly execute: RunFunction<INPUT, OUTPUT>;
+    constructor(options: {
+        name: NAME;
+        description: string;
+        inputSchema: z.ZodSchema<INPUT>;
+        outputSchema?: z.ZodSchema<OUTPUT>;
+        execute(input: INPUT): Promise<OUTPUT>;
+    });
+    /**
+     * Provdes a schema definition with the name, description and schema of the input.
+     * This is used by `useTool`.
+     */
+    get inputSchemaDefinition(): SchemaDefinition<NAME, INPUT>;
+}

package/tool/Tool.js

@@ -0,0 +1,70 @@
+/**
+ * A tool is a function with a name, description and defined inputs that can be used
+ * by agents and chatbots.
+ */
+export class Tool {
+    constructor(options) {
+        /**
+         * The name of the tool. Should be understandable for language models and unique among the tools that they know.
+         */
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * A description of what the tool does. Will be used by the language model to decide whether to use the tool.
+         */
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The schema of the input that the tool expects. The language model will use this to generate the input.
+         * Use descriptions to make the input understandable for the language model.
+         */
+        Object.defineProperty(this, "inputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * An optional schema of the output that the tool produces. This will be used to validate the output.
+         */
+        Object.defineProperty(this, "outputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * The actual execution function of the tool.
+         */
+        Object.defineProperty(this, "execute", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = options.name;
+        this.description = options.description;
+        this.inputSchema = options.inputSchema;
+        this.outputSchema = options.outputSchema;
+        this.execute = options.execute;
+    }
+    /**
+     * Provdes a schema definition with the name, description and schema of the input.
+     * This is used by `useTool`.
+     */
+    get inputSchemaDefinition() {
+        return {
+            name: this.name,
+            description: this.description,
+            schema: this.inputSchema,
+        };
+    }
+}

package/tool/ToolExecutionError.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutionError = void 0;
+class ToolExecutionError extends Error {
+    constructor({ message = "unknown error", toolName, input, cause, }) {
+        super(`Error executing tool ${toolName}: ${message}`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolExecutionError";
+        this.toolName = toolName;
+        this.input = input;
+        this.cause = cause;
+    }
+}
+exports.ToolExecutionError = ToolExecutionError;

package/tool/ToolExecutionError.d.ts

@@ -0,0 +1,11 @@
+export declare class ToolExecutionError extends Error {
+    readonly toolName: string;
+    readonly input: unknown;
+    readonly cause: unknown;
+    constructor({ message, toolName, input, cause, }: {
+        toolName: string;
+        input: unknown;
+        message: string | undefined;
+        cause: unknown | undefined;
+    });
+}

package/tool/ToolExecutionError.js

@@ -0,0 +1,27 @@
+export class ToolExecutionError extends Error {
+    constructor({ message = "unknown error", toolName, input, cause, }) {
+        super(`Error executing tool ${toolName}: ${message}`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolExecutionError";
+        this.toolName = toolName;
+        this.input = input;
+        this.cause = cause;
+    }
+}

package/tool/WebSearchTool.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSearchTool = void 0;
+const zod_1 = require("zod");
+const Tool_js_1 = require("./Tool.cjs");
+const INPUT_SCHEMA = zod_1.z.object({
+    query: zod_1.z.string(),
+});
+const OUTPUT_SCHEMA = zod_1.z.object({
+    results: zod_1.z.array(zod_1.z.object({
+        title: zod_1.z.string(),
+        link: zod_1.z.string().url(),
+        snippet: zod_1.z.string(),
+    })),
+});
+/**
+ * @see https://serpapi.com/search-api
+ */
+class WebSearchTool extends Tool_js_1.Tool {
+    constructor(options) {
+        super({
+            name: options.name,
+            description: options.description,
+            inputSchema: INPUT_SCHEMA,
+            outputSchema: OUTPUT_SCHEMA,
+            execute: options.execute,
+        });
+    }
+}
+exports.WebSearchTool = WebSearchTool;
+// expose the schemas to library consumers:
+Object.defineProperty(WebSearchTool, "INPUT_SCHEMA", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: INPUT_SCHEMA
+});
+Object.defineProperty(WebSearchTool, "OUTPUT_SCHEMA", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: OUTPUT_SCHEMA
+});