modelfusion 0.71.0 → 0.73.0

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

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

@@ -1,20 +1,20 @@
 import { nanoid as createId } from "nanoid";
-import { FunctionEventSource } from "../core/FunctionEventSource.js";
-import { getGlobalFunctionLogging } from "../core/GlobalFunctionLogging.js";
-import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
-import { AbortError } from "../core/api/AbortError.js";
-import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
-import { getRun } from "../core/getRun.js";
-import { startDurationMeasurement } from "../util/DurationMeasurement.js";
-import { runSafe } from "../util/runSafe.js";
-import { ToolExecutionError } from "./ToolExecutionError.js";
+import { FunctionEventSource } from "../../core/FunctionEventSource.js";
+import { getGlobalFunctionLogging } from "../../core/GlobalFunctionLogging.js";
+import { getGlobalFunctionObservers } from "../../core/GlobalFunctionObservers.js";
+import { AbortError } from "../../core/api/AbortError.js";
+import { getFunctionCallLogger } from "../../core/getFunctionCallLogger.js";
+import { getRun } from "../../core/getRun.js";
+import { startDurationMeasurement } from "../../util/DurationMeasurement.js";
+import { runSafe } from "../../util/runSafe.js";
+import { ToolExecutionError } from "../ToolExecutionError.js";
 export 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;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function doExecuteTool(tool, input, options) {
+async function doExecuteTool(tool, args, options) {
     const run = await getRun(options?.run);
     const eventSource = new FunctionEventSource({
         observers: [
@@ -35,7 +35,7 @@ async function doExecuteTool(tool, input, options) {
         userId: run?.userId,
         functionId: options?.functionId,
         toolName: tool.name,
-        input,
+        input: args,
     };
     eventSource.notify({
         ...metadata,
@@ -43,7 +43,7 @@ async function doExecuteTool(tool, input, options) {
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     });
-    const result = await runSafe(() => tool.execute(input, {
+    const result = await runSafe(() => tool.execute(args, {
         functionId: options?.functionId,
         logging: options?.logging,
         observers: options?.observers,
@@ -77,7 +77,7 @@ async function doExecuteTool(tool, input, options) {
         });
         throw new 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/execute-tool/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./executeTool.cjs"), exports);

package/tool/execute-tool/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ExecuteToolEvent.js";
+export * from "./executeTool.js";

package/tool/execute-tool/index.js

@@ -0,0 +1,2 @@
+export * from "./ExecuteToolEvent.js";
+export * from "./executeTool.js";

package/tool/execute-tool/safeExecuteToolCall.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeExecuteToolCall = void 0;
+const ToolCallError_js_1 = require("../ToolCallError.cjs");
+const ToolExecutionError_js_1 = require("../ToolExecutionError.cjs");
+const executeTool_js_1 = require("./executeTool.cjs");
+async function safeExecuteToolCall(tool, toolCall, options) {
+    try {
+        return {
+            tool: toolCall.name,
+            toolCall,
+            args: toolCall.args,
+            ok: true,
+            result: await (0, executeTool_js_1.executeTool)(tool, toolCall.args, options),
+        };
+    }
+    catch (error) {
+        // If the error is an AbortError, rethrow it.
+        if (error instanceof Error && error.name === "AbortError") {
+            throw error;
+        }
+        return {
+            tool: toolCall.name,
+            toolCall,
+            args: toolCall.args,
+            ok: false,
+            result: new ToolCallError_js_1.ToolCallError({
+                toolCall,
+                cause: error instanceof ToolExecutionError_js_1.ToolExecutionError ? error.cause : error,
+            }),
+        };
+    }
+}
+exports.safeExecuteToolCall = safeExecuteToolCall;

package/tool/execute-tool/safeExecuteToolCall.d.ts

@@ -0,0 +1,5 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Tool } from "../Tool.js";
+import { ToolCall } from "../ToolCall.js";
+import { ToolCallResult } from "../ToolCallResult.js";
+export declare function safeExecuteToolCall<TOOL extends Tool<string, unknown, any>>(tool: TOOL, toolCall: ToolCall<TOOL["name"], TOOL["parameters"]>, options?: FunctionOptions): Promise<ToolCallResult<TOOL["name"], TOOL["parameters"], Awaited<ReturnType<TOOL["execute"]>>>>;

package/tool/execute-tool/safeExecuteToolCall.js

@@ -0,0 +1,30 @@
+import { ToolCallError } from "../ToolCallError.js";
+import { ToolExecutionError } from "../ToolExecutionError.js";
+import { executeTool } from "./executeTool.js";
+export async function safeExecuteToolCall(tool, toolCall, options) {
+    try {
+        return {
+            tool: toolCall.name,
+            toolCall,
+            args: toolCall.args,
+            ok: true,
+            result: await executeTool(tool, toolCall.args, options),
+        };
+    }
+    catch (error) {
+        // If the error is an AbortError, rethrow it.
+        if (error instanceof Error && error.name === "AbortError") {
+            throw error;
+        }
+        return {
+            tool: toolCall.name,
+            toolCall,
+            args: toolCall.args,
+            ok: false,
+            result: new ToolCallError({
+                toolCall,
+                cause: error instanceof ToolExecutionError ? error.cause : error,
+            }),
+        };
+    }
+}

package/tool/generate-tool-call/TextGenerationToolCallModel.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextGenerationToolCallModel = void 0;
+const generateText_js_1 = require("../../model-function/generate-text/generateText.cjs");
+const ToolCallParseError_js_1 = require("../ToolCallParseError.cjs");
+class TextGenerationToolCallModel {
+    constructor({ model, format, }) {
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "format", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = model;
+        this.format = format;
+    }
+    get modelInformation() {
+        return this.model.modelInformation;
+    }
+    get settings() {
+        return this.model.settings;
+    }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
+    async doGenerateToolCall(tool, prompt, options) {
+        const { response, value, metadata } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, tool), {
+            ...options,
+            returnType: "full",
+        });
+        try {
+            return {
+                response,
+                toolCall: this.format.extractToolCall(value),
+                usage: metadata?.usage,
+            };
+        }
+        catch (error) {
+            throw new ToolCallParseError_js_1.ToolCallParseError({
+                toolName: tool.name,
+                valueText: value,
+                cause: error,
+            });
+        }
+    }
+    withSettings(additionalSettings) {
+        return new TextGenerationToolCallModel({
+            model: this.model.withSettings(additionalSettings),
+            format: this.format,
+        });
+    }
+}
+exports.TextGenerationToolCallModel = TextGenerationToolCallModel;

package/tool/generate-tool-call/TextGenerationToolCallModel.d.ts

@@ -0,0 +1,35 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { ToolDefinition } from "../ToolDefinition.js";
+import { ToolCallGenerationModel } from "./ToolCallGenerationModel.js";
+export interface ToolCallTextPromptFormat<PROMPT> {
+    createPrompt: (prompt: PROMPT, tool: ToolDefinition<string, unknown>) => string;
+    extractToolCall: (response: string) => {
+        id: string;
+        args: unknown;
+    } | null;
+}
+export declare class TextGenerationToolCallModel<PROMPT, MODEL extends TextGenerationModel<string, TextGenerationModelSettings>> implements ToolCallGenerationModel<PROMPT, MODEL["settings"]> {
+    private readonly model;
+    private readonly format;
+    constructor({ model, format, }: {
+        model: MODEL;
+        format: ToolCallTextPromptFormat<PROMPT>;
+    });
+    get modelInformation(): import("../../index.js").ModelInformation;
+    get settings(): TextGenerationModelSettings;
+    get settingsForEvent(): Partial<MODEL["settings"]>;
+    doGenerateToolCall(tool: ToolDefinition<string, unknown>, prompt: PROMPT, options?: FunctionOptions): Promise<{
+        response: unknown;
+        toolCall: {
+            id: string;
+            args: unknown;
+        } | null;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        } | undefined;
+    }>;
+    withSettings(additionalSettings: Partial<MODEL["settings"]>): this;
+}

package/tool/generate-tool-call/TextGenerationToolCallModel.js

@@ -0,0 +1,55 @@
+import { generateText } from "../../model-function/generate-text/generateText.js";
+import { ToolCallParseError } from "../ToolCallParseError.js";
+export class TextGenerationToolCallModel {
+    constructor({ model, format, }) {
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "format", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = model;
+        this.format = format;
+    }
+    get modelInformation() {
+        return this.model.modelInformation;
+    }
+    get settings() {
+        return this.model.settings;
+    }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
+    async doGenerateToolCall(tool, prompt, options) {
+        const { response, value, metadata } = await generateText(this.model, this.format.createPrompt(prompt, tool), {
+            ...options,
+            returnType: "full",
+        });
+        try {
+            return {
+                response,
+                toolCall: this.format.extractToolCall(value),
+                usage: metadata?.usage,
+            };
+        }
+        catch (error) {
+            throw new ToolCallParseError({
+                toolName: tool.name,
+                valueText: value,
+                cause: error,
+            });
+        }
+    }
+    withSettings(additionalSettings) {
+        return new TextGenerationToolCallModel({
+            model: this.model.withSettings(additionalSettings),
+            format: this.format,
+        });
+    }
+}

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

@@ -1,4 +1,4 @@
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../../model-function/ModelCallEvent.js";
 export interface ToolCallGenerationStartedEvent extends BaseModelCallStartedEvent {
     functionType: "generate-tool-call";
 }

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

@@ -1,6 +1,6 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { Model, ModelSettings } from "../Model.js";
-import { ToolDefinition } from "./ToolDefinition.js";
+import { Model, ModelSettings } from "../../model-function/Model.js";
+import { ToolDefinition } from "../ToolDefinition.js";
 export interface ToolCallGenerationModelSettings extends ModelSettings {
 }
 export interface ToolCallGenerationModel<PROMPT, SETTINGS extends ToolCallGenerationModelSettings = ToolCallGenerationModelSettings> extends Model<SETTINGS> {
@@ -8,7 +8,7 @@ export interface ToolCallGenerationModel<PROMPT, SETTINGS extends ToolCallGenera
         response: unknown;
         toolCall: {
             id: string;
-            parameters: unknown;
+            args: unknown;
         } | null;
         usage?: {
             promptTokens: number;

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateToolCall = void 0;
-const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-const ToolCallParametersValidationError_js_1 = require("./ToolCallParametersValidationError.cjs");
-const ToolCallGenerationError_js_1 = require("./ToolCallGenerationError.cjs");
+const executeStandardCall_js_1 = require("../../model-function/executeStandardCall.cjs");
+const ToolCallArgumentsValidationError_js_1 = require("../ToolCallArgumentsValidationError.cjs");
+const ToolCallGenerationError_js_1 = require("../ToolCallGenerationError.cjs");
 async function generateToolCall(model, tool, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
@@ -19,16 +19,16 @@ async function generateToolCall(model, tool, prompt, options) {
                 const result = await model.doGenerateToolCall(tool, expandedPrompt, options);
                 const toolCall = result.toolCall;
                 if (toolCall === null) {
-                    throw new ToolCallGenerationError_js_1.ToolCallsGenerationError({
+                    throw new ToolCallGenerationError_js_1.ToolCallGenerationError({
                         toolName: tool.name,
                         cause: "No tool call generated.",
                     });
                 }
-                const parseResult = tool.parameters.validate(toolCall.parameters);
+                const parseResult = tool.parameters.validate(toolCall.args);
                 if (!parseResult.success) {
-                    throw new ToolCallParametersValidationError_js_1.ToolCallParametersValidationError({
+                    throw new ToolCallArgumentsValidationError_js_1.ToolCallArgumentsValidationError({
                         toolName: tool.name,
-                        parameters: toolCall.parameters,
+                        args: toolCall.args,
                         cause: parseResult.error,
                     });
                 }
@@ -37,17 +37,17 @@ async function generateToolCall(model, tool, prompt, options) {
                     extractedValue: {
                         id: toolCall.id,
                         name: tool.name,
-                        parameters: parseResult.data,
+                        args: parseResult.data,
                     },
                     usage: result.usage,
                 };
             }
             catch (error) {
-                if (error instanceof ToolCallParametersValidationError_js_1.ToolCallParametersValidationError ||
-                    error instanceof ToolCallGenerationError_js_1.ToolCallsGenerationError) {
+                if (error instanceof ToolCallArgumentsValidationError_js_1.ToolCallArgumentsValidationError ||
+                    error instanceof ToolCallGenerationError_js_1.ToolCallGenerationError) {
                     throw error;
                 }
-                throw new ToolCallGenerationError_js_1.ToolCallsGenerationError({
+                throw new ToolCallGenerationError_js_1.ToolCallGenerationError({
                     toolName: tool.name,
                     cause: error,
                 });

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

@@ -1,8 +1,8 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { ModelCallMetadata } from "../ModelCallMetadata.js";
-import { ToolDefinition } from "./ToolDefinition.js";
+import { ModelCallMetadata } from "../../model-function/ModelCallMetadata.js";
+import { ToolCall } from "../ToolCall.js";
+import { ToolDefinition } from "../ToolDefinition.js";
 import { ToolCallGenerationModel, ToolCallGenerationModelSettings } from "./ToolCallGenerationModel.js";
-import { ToolCall } from "./ToolCall.js";
 export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(model: ToolCallGenerationModel<PROMPT, SETTINGS>, tool: ToolDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolDefinition<NAME, PARAMETERS>) => PROMPT), options?: FunctionOptions & {
     returnType?: "structure";
 }): Promise<ToolCall<NAME, PARAMETERS>>;

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

@@ -1,6 +1,6 @@
-import { executeStandardCall } from "../executeStandardCall.js";
-import { ToolCallParametersValidationError } from "./ToolCallParametersValidationError.js";
-import { ToolCallsGenerationError } from "./ToolCallGenerationError.js";
+import { executeStandardCall } from "../../model-function/executeStandardCall.js";
+import { ToolCallArgumentsValidationError } from "../ToolCallArgumentsValidationError.js";
+import { ToolCallGenerationError } from "../ToolCallGenerationError.js";
 export async function generateToolCall(model, tool, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
@@ -16,16 +16,16 @@ export async function generateToolCall(model, tool, prompt, options) {
                 const result = await model.doGenerateToolCall(tool, expandedPrompt, options);
                 const toolCall = result.toolCall;
                 if (toolCall === null) {
-                    throw new ToolCallsGenerationError({
+                    throw new ToolCallGenerationError({
                         toolName: tool.name,
                         cause: "No tool call generated.",
                     });
                 }
-                const parseResult = tool.parameters.validate(toolCall.parameters);
+                const parseResult = tool.parameters.validate(toolCall.args);
                 if (!parseResult.success) {
-                    throw new ToolCallParametersValidationError({
+                    throw new ToolCallArgumentsValidationError({
                         toolName: tool.name,
-                        parameters: toolCall.parameters,
+                        args: toolCall.args,
                         cause: parseResult.error,
                     });
                 }
@@ -34,17 +34,17 @@ export async function generateToolCall(model, tool, prompt, options) {
                     extractedValue: {
                         id: toolCall.id,
                         name: tool.name,
-                        parameters: parseResult.data,
+                        args: parseResult.data,
                     },
                     usage: result.usage,
                 };
             }
             catch (error) {
-                if (error instanceof ToolCallParametersValidationError ||
-                    error instanceof ToolCallsGenerationError) {
+                if (error instanceof ToolCallArgumentsValidationError ||
+                    error instanceof ToolCallGenerationError) {
                     throw error;
                 }
-                throw new ToolCallsGenerationError({
+                throw new ToolCallGenerationError({
                     toolName: tool.name,
                     cause: error,
                 });

package/tool/generate-tool-call/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./TextGenerationToolCallModel.cjs"), exports);
+__exportStar(require("./ToolCallGenerationEvent.cjs"), exports);
+__exportStar(require("./ToolCallGenerationModel.cjs"), exports);
+__exportStar(require("./generateToolCall.cjs"), exports);

package/tool/generate-tool-call/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./TextGenerationToolCallModel.js";
+export * from "./ToolCallGenerationEvent.js";
+export * from "./ToolCallGenerationModel.js";
+export * from "./generateToolCall.js";

package/tool/generate-tool-call/index.js

@@ -0,0 +1,4 @@
+export * from "./TextGenerationToolCallModel.js";
+export * from "./ToolCallGenerationEvent.js";
+export * from "./ToolCallGenerationModel.js";
+export * from "./generateToolCall.js";

package/{model-function/generate-tool-call → tool/generate-tool-calls-or-text}/ToolCallsOrTextGenerationEvent.d.ts

@@ -1,4 +1,4 @@
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../../model-function/ModelCallEvent.js";
 export interface ToolCallsOrTextGenerationStartedEvent extends BaseModelCallStartedEvent {
     functionType: "generate-tool-calls-or-text";
 }