modelfusion 0.70.0 → 0.72.0

package/tool/ToolCallArgumentsValidationError.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCallArgumentsValidationError = void 0;
+const getErrorMessage_js_1 = require("../util/getErrorMessage.cjs");
+/**
+ * Thrown when the arguments of a tool call are invalid.
+ *
+ * This typically means they don't match the parameters schema that is expected the tool.
+ */
+class ToolCallArgumentsValidationError extends Error {
+    constructor({ toolName, args, cause, }) {
+        super(`Argument validation failed for tool '${toolName}'.\n` +
+            `Arguments: ${JSON.stringify(args)}.\n` +
+            `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "args", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolCallArgumentsValidationError";
+        this.toolName = toolName;
+        this.cause = cause;
+        this.args = args;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            toolName: this.toolName,
+            args: this.args,
+        };
+    }
+}
+exports.ToolCallArgumentsValidationError = ToolCallArgumentsValidationError;

package/tool/ToolCallArgumentsValidationError.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Thrown when the arguments of a tool call are invalid.
+ *
+ * This typically means they don't match the parameters schema that is expected the tool.
+ */
+export declare class ToolCallArgumentsValidationError extends Error {
+    readonly toolName: string;
+    readonly cause: unknown;
+    readonly args: unknown;
+    constructor({ toolName, args, cause, }: {
+        toolName: string;
+        args: unknown;
+        cause: unknown;
+    });
+    toJSON(): {
+        name: string;
+        message: string;
+        cause: unknown;
+        stack: string | undefined;
+        toolName: string;
+        args: unknown;
+    };
+}

package/tool/ToolCallArgumentsValidationError.js

@@ -0,0 +1,45 @@
+import { getErrorMessage } from "../util/getErrorMessage.js";
+/**
+ * Thrown when the arguments of a tool call are invalid.
+ *
+ * This typically means they don't match the parameters schema that is expected the tool.
+ */
+export class ToolCallArgumentsValidationError extends Error {
+    constructor({ toolName, args, cause, }) {
+        super(`Argument validation failed for tool '${toolName}'.\n` +
+            `Arguments: ${JSON.stringify(args)}.\n` +
+            `Error message: ${getErrorMessage(cause)}`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "args", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolCallArgumentsValidationError";
+        this.toolName = toolName;
+        this.cause = cause;
+        this.args = args;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            toolName: this.toolName,
+            args: this.args,
+        };
+    }
+}

package/tool/ToolCallError.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCallError = void 0;
+const getErrorMessage_js_1 = require("../util/getErrorMessage.cjs");
+class ToolCallError extends Error {
+    constructor({ cause, toolCall, message = (0, getErrorMessage_js_1.getErrorMessage)(cause), }) {
+        super(`Tool call for tool '${toolCall.name}' failed: ${message}`);
+        Object.defineProperty(this, "toolCall", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolCallError";
+        this.toolCall = toolCall;
+        this.cause = cause;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            cause: this.cause,
+            message: this.message,
+            stack: this.stack,
+            toolCall: this.toolCall,
+        };
+    }
+}
+exports.ToolCallError = ToolCallError;

package/tool/ToolCallError.d.ts

@@ -0,0 +1,17 @@
+import { ToolCall } from "./ToolCall.js";
+export declare class ToolCallError extends Error {
+    readonly toolCall: ToolCall<string, unknown>;
+    readonly cause: unknown | undefined;
+    constructor({ cause, toolCall, message, }: {
+        toolCall: ToolCall<string, unknown>;
+        cause?: unknown;
+        message?: string;
+    });
+    toJSON(): {
+        name: string;
+        cause: unknown;
+        message: string;
+        stack: string | undefined;
+        toolCall: ToolCall<string, unknown>;
+    };
+}

package/tool/ToolCallError.js

@@ -0,0 +1,30 @@
+import { getErrorMessage } from "../util/getErrorMessage.js";
+export class ToolCallError extends Error {
+    constructor({ cause, toolCall, message = getErrorMessage(cause), }) {
+        super(`Tool call for tool '${toolCall.name}' failed: ${message}`);
+        Object.defineProperty(this, "toolCall", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolCallError";
+        this.toolCall = toolCall;
+        this.cause = cause;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            cause: this.cause,
+            message: this.message,
+            stack: this.stack,
+            toolCall: this.toolCall,
+        };
+    }
+}

package/{model-function/generate-tool-call → tool}/ToolCallGenerationError.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolCallsGenerationError = void 0;
-const getErrorMessage_js_1 = require("../../util/getErrorMessage.cjs");
-class ToolCallsGenerationError extends Error {
+exports.ToolCallGenerationError = void 0;
+const getErrorMessage_js_1 = require("../util/getErrorMessage.cjs");
+class ToolCallGenerationError extends Error {
     constructor({ toolName, cause }) {
         super(`Tool call generation failed for tool '${toolName}'. ` +
             `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
@@ -32,4 +32,4 @@ class ToolCallsGenerationError extends Error {
         };
     }
 }
-exports.ToolCallsGenerationError = ToolCallsGenerationError;
+exports.ToolCallGenerationError = ToolCallGenerationError;

package/{model-function/generate-tool-call → tool}/ToolCallGenerationError.d.ts

@@ -1,4 +1,4 @@
-export declare class ToolCallsGenerationError extends Error {
+export declare class ToolCallGenerationError extends Error {
     readonly toolName: string;
     readonly cause: unknown;
     constructor({ toolName, cause }: {

package/{model-function/generate-tool-call → tool}/ToolCallGenerationError.js

@@ -1,5 +1,5 @@
-import { getErrorMessage } from "../../util/getErrorMessage.js";
-export class ToolCallsGenerationError extends Error {
+import { getErrorMessage } from "../util/getErrorMessage.js";
+export class ToolCallGenerationError extends Error {
     constructor({ toolName, cause }) {
         super(`Tool call generation failed for tool '${toolName}'. ` +
             `Error message: ${getErrorMessage(cause)}`);

package/{model-function/generate-tool-call/ToolCallParametersValidationError.cjs → tool/ToolCallParseError.cjs}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolCallParametersValidationError = void 0;
-const getErrorMessage_js_1 = require("../../util/getErrorMessage.cjs");
-class ToolCallParametersValidationError extends Error {
-    constructor({ toolName, parameters, cause, }) {
-        super(`Parameter validation failed for tool '${toolName}'. ` +
-            `Value: ${JSON.stringify(parameters)}.\n` +
+exports.ToolCallParseError = void 0;
+const getErrorMessage_js_1 = require("../util/getErrorMessage.cjs");
+class ToolCallParseError extends Error {
+    constructor({ toolName, valueText, cause, }) {
+        super(`Tool call parsing failed for '${toolName}'. ` +
+            `Value: ${valueText}.\n` +
             `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
         Object.defineProperty(this, "toolName", {
             enumerable: true,
@@ -13,32 +13,32 @@ class ToolCallParametersValidationError extends Error {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "cause", {
+        Object.defineProperty(this, "valueText", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "parameters", {
+        Object.defineProperty(this, "cause", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.name = "ToolCallParametersValidationError";
+        this.name = "ToolCallParseError";
         this.toolName = toolName;
         this.cause = cause;
-        this.parameters = parameters;
+        this.valueText = valueText;
     }
     toJSON() {
         return {
             name: this.name,
-            message: this.message,
             cause: this.cause,
+            message: this.message,
             stack: this.stack,
             toolName: this.toolName,
-            parameter: this.parameters,
+            valueText: this.valueText,
         };
     }
 }
-exports.ToolCallParametersValidationError = ToolCallParametersValidationError;
+exports.ToolCallParseError = ToolCallParseError;

package/tool/ToolCallParseError.d.ts

@@ -0,0 +1,18 @@
+export declare class ToolCallParseError extends Error {
+    readonly toolName: string;
+    readonly valueText: string;
+    readonly cause: unknown;
+    constructor({ toolName, valueText, cause, }: {
+        toolName: string;
+        valueText: string;
+        cause: unknown;
+    });
+    toJSON(): {
+        name: string;
+        cause: unknown;
+        message: string;
+        stack: string | undefined;
+        toolName: string;
+        valueText: string;
+    };
+}

package/tool/ToolCallParseError.js

@@ -0,0 +1,40 @@
+import { getErrorMessage } from "../util/getErrorMessage.js";
+export class ToolCallParseError extends Error {
+    constructor({ toolName, valueText, cause, }) {
+        super(`Tool call parsing failed for '${toolName}'. ` +
+            `Value: ${valueText}.\n` +
+            `Error message: ${getErrorMessage(cause)}`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "valueText", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolCallParseError";
+        this.toolName = toolName;
+        this.cause = cause;
+        this.valueText = valueText;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            cause: this.cause,
+            message: this.message,
+            stack: this.stack,
+            toolName: this.toolName,
+            valueText: this.valueText,
+        };
+    }
+}

package/tool/ToolCallResult.d.ts

@@ -0,0 +1,13 @@
+import { ToolCall } from "./ToolCall.js";
+import { ToolCallError } from "./ToolCallError.js";
+export type ToolCallResult<NAME extends string, PARAMETERS, RETURN_TYPE> = {
+    tool: NAME;
+    toolCall: ToolCall<NAME, PARAMETERS>;
+    args: PARAMETERS;
+} & ({
+    ok: true;
+    result: RETURN_TYPE;
+} | {
+    ok: false;
+    result: ToolCallError;
+});

package/tool/ToolDefinition.d.ts

@@ -0,0 +1,7 @@
+import { JsonSchemaProducer } from "../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../core/schema/Schema.js";
+export interface ToolDefinition<NAME extends string, PARAMETERS> {
+    name: NAME;
+    description?: string;
+    parameters: Schema<PARAMETERS> & JsonSchemaProducer;
+}

package/tool/ToolExecutionError.cjs

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolExecutionError = void 0;
+const getErrorMessage_js_1 = require("../util/getErrorMessage.cjs");
 class ToolExecutionError extends Error {
-    constructor({ message = "unknown error", toolName, input, cause, }) {
-        super(`Error executing tool ${toolName}: ${message}`);
+    constructor({ toolName, input, cause, message = (0, getErrorMessage_js_1.getErrorMessage)(cause), }) {
+        super(`Error executing tool '${toolName}': ${message}`);
         Object.defineProperty(this, "toolName", {
             enumerable: true,
             configurable: true,
@@ -30,11 +31,11 @@ class ToolExecutionError extends Error {
     toJSON() {
         return {
             name: this.name,
-            toolName: this.toolName,
-            input: this.input,
             cause: this.cause,
             message: this.message,
             stack: this.stack,
+            toolName: this.toolName,
+            input: this.input,
         };
     }
 }

package/tool/ToolExecutionError.d.ts

@@ -2,18 +2,18 @@ export declare class ToolExecutionError extends Error {
     readonly toolName: string;
     readonly input: unknown;
     readonly cause: unknown;
-    constructor({ message, toolName, input, cause, }: {
+    constructor({ toolName, input, cause, message, }: {
         toolName: string;
         input: unknown;
-        message: string | undefined;
         cause: unknown | undefined;
+        message?: string;
     });
     toJSON(): {
         name: string;
-        toolName: string;
-        input: unknown;
         cause: unknown;
         message: string;
         stack: string | undefined;
+        toolName: string;
+        input: unknown;
     };
 }

package/tool/ToolExecutionError.js

@@ -1,6 +1,7 @@
+import { getErrorMessage } from "../util/getErrorMessage.js";
 export class ToolExecutionError extends Error {
-    constructor({ message = "unknown error", toolName, input, cause, }) {
-        super(`Error executing tool ${toolName}: ${message}`);
+    constructor({ toolName, input, cause, message = getErrorMessage(cause), }) {
+        super(`Error executing tool '${toolName}': ${message}`);
         Object.defineProperty(this, "toolName", {
             enumerable: true,
             configurable: true,
@@ -27,11 +28,11 @@ export class ToolExecutionError extends Error {
     toJSON() {
         return {
             name: this.name,
-            toolName: this.toolName,
-            input: this.input,
             cause: this.cause,
             message: this.message,
             stack: this.stack,
+            toolName: this.toolName,
+            input: this.input,
         };
     }
 }

package/tool/WebSearchTool.cjs

@@ -4,7 +4,7 @@ exports.WebSearchTool = void 0;
 const zod_1 = require("zod");
 const ZodSchema_js_1 = require("../core/schema/ZodSchema.cjs");
 const Tool_js_1 = require("./Tool.cjs");
-const OUTPUT_SCHEMA = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
+const RETURN_TYPE_SCHEMA = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
     results: zod_1.z.array(zod_1.z.object({
         title: zod_1.z.string(),
         link: zod_1.z.string().url(),
@@ -12,7 +12,7 @@ const OUTPUT_SCHEMA = new ZodSchema_js_1.ZodSchema(zod_1.z.object({
     })),
 }));
 // expose the schemas to library consumers:
-const createInputSchema = (description) => 
+const createParameters = (description) => 
 // same structure, but with description:
 new ZodSchema_js_1.ZodSchema(zod_1.z.object({
     query: zod_1.z.string().describe(description),
@@ -47,8 +47,8 @@ class WebSearchTool extends Tool_js_1.Tool {
         super({
             name,
             description,
-            inputSchema: createInputSchema(queryDescription),
-            outputSchema: OUTPUT_SCHEMA,
+            parameters: createParameters(queryDescription),
+            returnType: RETURN_TYPE_SCHEMA,
             execute,
         });
     }

package/tool/WebSearchTool.d.ts

@@ -1,7 +1,7 @@
 import { FunctionOptions } from "../core/FunctionOptions.js";
 import { ZodSchema } from "../core/schema/ZodSchema.js";
 import { Tool } from "./Tool.js";
-declare const OUTPUT_SCHEMA: ZodSchema<{
+declare const RETURN_TYPE_SCHEMA: ZodSchema<{
     results: {
         link: string;
         title: string;
@@ -44,7 +44,7 @@ export type WebSearchToolOutput = {
  * ```
  */
 export declare class WebSearchTool<NAME extends string> extends Tool<NAME, WebSearchToolInput, WebSearchToolOutput> {
-    readonly outputSchema: typeof OUTPUT_SCHEMA;
+    readonly returnType: typeof RETURN_TYPE_SCHEMA;
     constructor({ name, description, queryDescription, execute, }: {
         name: NAME;
         description: string;

package/tool/WebSearchTool.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { ZodSchema } from "../core/schema/ZodSchema.js";
 import { Tool } from "./Tool.js";
-const OUTPUT_SCHEMA = new ZodSchema(z.object({
+const RETURN_TYPE_SCHEMA = new ZodSchema(z.object({
     results: z.array(z.object({
         title: z.string(),
         link: z.string().url(),
@@ -9,7 +9,7 @@ const OUTPUT_SCHEMA = new ZodSchema(z.object({
     })),
 }));
 // expose the schemas to library consumers:
-const createInputSchema = (description) => 
+const createParameters = (description) => 
 // same structure, but with description:
 new ZodSchema(z.object({
     query: z.string().describe(description),
@@ -44,8 +44,8 @@ export class WebSearchTool extends Tool {
         super({
             name,
             description,
-            inputSchema: createInputSchema(queryDescription),
-            outputSchema: OUTPUT_SCHEMA,
+            parameters: createParameters(queryDescription),
+            returnType: RETURN_TYPE_SCHEMA,
             execute,
         });
     }

package/tool/{ExecuteToolEvent.d.ts → execute-tool/ExecuteToolEvent.d.ts}

@@ -1,4 +1,4 @@
-import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../../core/FunctionEvent.js";
 export interface ExecuteToolStartedEvent extends BaseFunctionStartedEvent {
     functionType: "execute-tool";
     toolName: string;

package/tool/{executeTool.cjs → execute-tool/executeTool.cjs}

@@ -2,23 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeTool = void 0;
 const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
-const GlobalFunctionLogging_js_1 = require("../core/GlobalFunctionLogging.cjs");
-const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cjs");
-const AbortError_js_1 = require("../core/api/AbortError.cjs");
-const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
-const getRun_js_1 = require("../core/getRun.cjs");
-const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
-const runSafe_js_1 = require("../util/runSafe.cjs");
-const ToolExecutionError_js_1 = require("./ToolExecutionError.cjs");
+const FunctionEventSource_js_1 = require("../../core/FunctionEventSource.cjs");
+const GlobalFunctionLogging_js_1 = require("../../core/GlobalFunctionLogging.cjs");
+const GlobalFunctionObservers_js_1 = require("../../core/GlobalFunctionObservers.cjs");
+const AbortError_js_1 = require("../../core/api/AbortError.cjs");
+const getFunctionCallLogger_js_1 = require("../../core/getFunctionCallLogger.cjs");
+const getRun_js_1 = require("../../core/getRun.cjs");
+const DurationMeasurement_js_1 = require("../../util/DurationMeasurement.cjs");
+const runSafe_js_1 = require("../../util/runSafe.cjs");
+const ToolExecutionError_js_1 = require("../ToolExecutionError.cjs");
 async function executeTool(// eslint-disable-line @typescript-eslint/no-explicit-any
-tool, input, options) {
-    const fullResponse = await doExecuteTool(tool, input, options);
+tool, args, options) {
+    const fullResponse = await doExecuteTool(tool, args, options);
     return options?.returnType === "full" ? fullResponse : fullResponse.output;
 }
 exports.executeTool = executeTool;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function doExecuteTool(tool, input, options) {
+async function doExecuteTool(tool, args, options) {
     const run = await (0, getRun_js_1.getRun)(options?.run);
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
         observers: [
@@ -39,7 +39,7 @@ async function doExecuteTool(tool, input, options) {
         userId: run?.userId,
         functionId: options?.functionId,
         toolName: tool.name,
-        input,
+        input: args,
     };
     eventSource.notify({
         ...metadata,
@@ -47,7 +47,7 @@ async function doExecuteTool(tool, input, options) {
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     });
-    const result = await (0, runSafe_js_1.runSafe)(() => tool.execute(input, {
+    const result = await (0, runSafe_js_1.runSafe)(() => tool.execute(args, {
         functionId: options?.functionId,
         logging: options?.logging,
         observers: options?.observers,
@@ -81,7 +81,7 @@ async function doExecuteTool(tool, input, options) {
         });
         throw new ToolExecutionError_js_1.ToolExecutionError({
             toolName: tool.name,
-            input,
+            input: args,
             cause: result.error,
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             message: result.error?.message,

package/tool/{executeTool.d.ts → execute-tool/executeTool.d.ts}

@@ -1,5 +1,5 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
-import { Tool } from "./Tool.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Tool } from "../Tool.js";
 export type ExecuteToolMetadata = {
     callId: string;
     runId?: string;
@@ -11,16 +11,16 @@ export type ExecuteToolMetadata = {
     durationInMs: number;
 };
 /**
- * `executeTool` directly executes a tool with the given parameters.
+ * `executeTool` executes a tool with the given parameters.
  */
 export declare function executeTool<TOOL extends Tool<any, any, any>>(// eslint-disable-line @typescript-eslint/no-explicit-any
-tool: TOOL, input: TOOL["inputSchema"]["_type"], options?: FunctionOptions & {
+tool: TOOL, args: TOOL["parameters"]["_type"], options?: FunctionOptions & {
     returnType?: "output";
 }): Promise<ReturnType<TOOL["execute"]>>;
 export declare function executeTool<TOOL extends Tool<any, any, any>>(// eslint-disable-line @typescript-eslint/no-explicit-any
-tool: TOOL, input: TOOL["inputSchema"]["_type"], options: FunctionOptions & {
+tool: TOOL, args: TOOL["parameters"]["_type"], options: FunctionOptions & {
     returnType: "full";
 }): Promise<{
-    output: ReturnType<TOOL["execute"]>;
+    output: Awaited<ReturnType<TOOL["execute"]>>;
     metadata: ExecuteToolMetadata;
 }>;