modelfusion 0.71.0 → 0.72.0

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

package/{model-function/generate-tool-call → tool/generate-tool-calls-or-text}/ToolCallsOrTextGenerationModel.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 ToolCallsOrTextGenerationModelSettings extends ModelSettings {
 }
 export interface ToolCallsOrTextGenerationModel<PROMPT, SETTINGS extends ToolCallsOrTextGenerationModelSettings> extends Model<SETTINGS> {
@@ -10,7 +10,7 @@ export interface ToolCallsOrTextGenerationModel<PROMPT, SETTINGS extends ToolCal
         toolCalls: Array<{
             id: string;
             name: string;
-            parameters: unknown;
+            args: unknown;
         }> | null;
         usage?: {
             promptTokens: number;

package/{model-function/generate-tool-call → tool/generate-tool-calls-or-text}/generateToolCallsOrText.cjs

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateToolCallsOrText = void 0;
-const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-const NoSuchToolDefinitionError_js_1 = require("./NoSuchToolDefinitionError.cjs");
-const ToolCallParametersValidationError_js_1 = require("./ToolCallParametersValidationError.cjs");
+const executeStandardCall_js_1 = require("../../model-function/executeStandardCall.cjs");
+const NoSuchToolDefinitionError_js_1 = require("../NoSuchToolDefinitionError.cjs");
+const ToolCallArgumentsValidationError_js_1 = require("../ToolCallArgumentsValidationError.cjs");
 async function generateToolCallsOrText(model, tools, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
@@ -31,21 +31,21 @@ async function generateToolCallsOrText(model, tools, prompt, options) {
                 if (tool == undefined) {
                     throw new NoSuchToolDefinitionError_js_1.NoSuchToolDefinitionError({
                         toolName: rawToolCall.name,
-                        parameters: rawToolCall.parameters,
+                        parameters: rawToolCall.args,
                     });
                 }
-                const parseResult = tool.parameters.validate(rawToolCall.parameters);
+                const parseResult = tool.parameters.validate(rawToolCall.args);
                 if (!parseResult.success) {
-                    throw new ToolCallParametersValidationError_js_1.ToolCallParametersValidationError({
+                    throw new ToolCallArgumentsValidationError_js_1.ToolCallArgumentsValidationError({
                         toolName: tool.name,
-                        parameters: rawToolCall.parameters,
+                        args: rawToolCall.args,
                         cause: parseResult.error,
                     });
                 }
                 return {
                     id: rawToolCall.id,
                     name: tool.name,
-                    parameters: parseResult.data,
+                    args: parseResult.data,
                 };
             });
             return {

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

@@ -1,7 +1,7 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { ModelCallMetadata } from "../ModelCallMetadata.js";
+import { ModelCallMetadata } from "../../model-function/ModelCallMetadata.js";
+import { ToolDefinition } from "../ToolDefinition.js";
 import { ToolCallsOrTextGenerationModel, ToolCallsOrTextGenerationModelSettings } from "./ToolCallsOrTextGenerationModel.js";
-import { ToolDefinition } from "./ToolDefinition.js";
 type ToolCallDefinitionArray<T extends ToolDefinition<any, any>[]> = T;
 type ToToolCallDefinitionMap<T extends ToolCallDefinitionArray<ToolDefinition<any, any>[]>> = {
     [K in T[number]["name"]]: Extract<T[number], ToolDefinition<K, any>>;
@@ -10,7 +10,7 @@ type ToToolCallUnion<T> = {
     [KEY in keyof T]: T[KEY] extends ToolDefinition<any, infer PARAMETERS> ? {
         id: string;
         name: KEY;
-        parameters: PARAMETERS;
+        args: PARAMETERS;
     } : never;
 }[keyof T];
 type ToOutputValue<TOOL_CALLS extends ToolCallDefinitionArray<ToolDefinition<any, any>[]>> = ToToolCallUnion<ToToolCallDefinitionMap<TOOL_CALLS>>;

package/{model-function/generate-tool-call → tool/generate-tool-calls-or-text}/generateToolCallsOrText.js

@@ -1,6 +1,6 @@
-import { executeStandardCall } from "../executeStandardCall.js";
-import { NoSuchToolDefinitionError } from "./NoSuchToolDefinitionError.js";
-import { ToolCallParametersValidationError } from "./ToolCallParametersValidationError.js";
+import { executeStandardCall } from "../../model-function/executeStandardCall.js";
+import { NoSuchToolDefinitionError } from "../NoSuchToolDefinitionError.js";
+import { ToolCallArgumentsValidationError } from "../ToolCallArgumentsValidationError.js";
 export async function generateToolCallsOrText(model, tools, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
@@ -28,21 +28,21 @@ export async function generateToolCallsOrText(model, tools, prompt, options) {
                 if (tool == undefined) {
                     throw new NoSuchToolDefinitionError({
                         toolName: rawToolCall.name,
-                        parameters: rawToolCall.parameters,
+                        parameters: rawToolCall.args,
                     });
                 }
-                const parseResult = tool.parameters.validate(rawToolCall.parameters);
+                const parseResult = tool.parameters.validate(rawToolCall.args);
                 if (!parseResult.success) {
-                    throw new ToolCallParametersValidationError({
+                    throw new ToolCallArgumentsValidationError({
                         toolName: tool.name,
-                        parameters: rawToolCall.parameters,
+                        args: rawToolCall.args,
                         cause: parseResult.error,
                     });
                 }
                 return {
                     id: rawToolCall.id,
                     name: tool.name,
-                    parameters: parseResult.data,
+                    args: parseResult.data,
                 };
             });
             return {

package/{model-function/generate-tool-call → tool/generate-tool-calls-or-text}/index.cjs

@@ -14,13 +14,6 @@ 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("./ToolCall.cjs"), exports);
-__exportStar(require("./ToolCallGenerationError.cjs"), exports);
-__exportStar(require("./ToolCallGenerationEvent.cjs"), exports);
-__exportStar(require("./ToolCallGenerationModel.cjs"), exports);
-__exportStar(require("./ToolCallParametersValidationError.cjs"), exports);
 __exportStar(require("./ToolCallsOrTextGenerationEvent.cjs"), exports);
 __exportStar(require("./ToolCallsOrTextGenerationModel.cjs"), exports);
-__exportStar(require("./ToolDefinition.cjs"), exports);
-__exportStar(require("./generateToolCall.cjs"), exports);
 __exportStar(require("./generateToolCallsOrText.cjs"), exports);

package/tool/generate-tool-calls-or-text/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ToolCallsOrTextGenerationEvent.js";
+export * from "./ToolCallsOrTextGenerationModel.js";
+export * from "./generateToolCallsOrText.js";

package/tool/generate-tool-calls-or-text/index.js

@@ -0,0 +1,3 @@
+export * from "./ToolCallsOrTextGenerationEvent.js";
+export * from "./ToolCallsOrTextGenerationModel.js";
+export * from "./generateToolCallsOrText.js";

package/tool/index.cjs

@@ -14,14 +14,19 @@ 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("./NoSuchToolDefinitionError.cjs"), exports);
 __exportStar(require("./Tool.cjs"), exports);
+__exportStar(require("./ToolCall.cjs"), exports);
+__exportStar(require("./ToolCallArgumentsValidationError.cjs"), exports);
+__exportStar(require("./ToolCallError.cjs"), exports);
+__exportStar(require("./ToolCallGenerationError.cjs"), exports);
+__exportStar(require("./ToolCallResult.cjs"), exports);
+__exportStar(require("./ToolDefinition.cjs"), exports);
 __exportStar(require("./ToolExecutionError.cjs"), exports);
-__exportStar(require("./UseToolEvent.cjs"), exports);
-__exportStar(require("./UseToolOrGenerateTextEvent.cjs"), exports);
 __exportStar(require("./WebSearchTool.cjs"), exports);
-__exportStar(require("./executeTool.cjs"), exports);
-__exportStar(require("./useTool.cjs"), exports);
-__exportStar(require("./useToolOrGenerateText.cjs"), exports);
+__exportStar(require("./execute-tool/index.cjs"), exports);
+__exportStar(require("./generate-tool-call/index.cjs"), exports);
+__exportStar(require("./generate-tool-calls-or-text/index.cjs"), exports);
+__exportStar(require("./use-tool/index.cjs"), exports);
+__exportStar(require("./use-tools-or-generate-text/index.cjs"), exports);

package/tool/index.d.ts

@@ -1,11 +1,16 @@
-export * from "./ExecuteToolEvent.js";
 export * from "./InvalidToolNameError.js";
-export * from "./NoSuchToolError.js";
+export * from "./NoSuchToolDefinitionError.js";
 export * from "./Tool.js";
+export * from "./ToolCall.js";
+export * from "./ToolCallArgumentsValidationError.js";
+export * from "./ToolCallError.js";
+export * from "./ToolCallGenerationError.js";
+export * from "./ToolCallResult.js";
+export * from "./ToolDefinition.js";
 export * from "./ToolExecutionError.js";
-export * from "./UseToolEvent.js";
-export * from "./UseToolOrGenerateTextEvent.js";
 export * from "./WebSearchTool.js";
-export * from "./executeTool.js";
-export * from "./useTool.js";
-export * from "./useToolOrGenerateText.js";
+export * from "./execute-tool/index.js";
+export * from "./generate-tool-call/index.js";
+export * from "./generate-tool-calls-or-text/index.js";
+export * from "./use-tool/index.js";
+export * from "./use-tools-or-generate-text/index.js";

package/tool/index.js

@@ -1,11 +1,16 @@
-export * from "./ExecuteToolEvent.js";
 export * from "./InvalidToolNameError.js";
-export * from "./NoSuchToolError.js";
+export * from "./NoSuchToolDefinitionError.js";
 export * from "./Tool.js";
+export * from "./ToolCall.js";
+export * from "./ToolCallArgumentsValidationError.js";
+export * from "./ToolCallError.js";
+export * from "./ToolCallGenerationError.js";
+export * from "./ToolCallResult.js";
+export * from "./ToolDefinition.js";
 export * from "./ToolExecutionError.js";
-export * from "./UseToolEvent.js";
-export * from "./UseToolOrGenerateTextEvent.js";
 export * from "./WebSearchTool.js";
-export * from "./executeTool.js";
-export * from "./useTool.js";
-export * from "./useToolOrGenerateText.js";
+export * from "./execute-tool/index.js";
+export * from "./generate-tool-call/index.js";
+export * from "./generate-tool-calls-or-text/index.js";
+export * from "./use-tool/index.js";
+export * from "./use-tools-or-generate-text/index.js";

package/tool/{UseToolEvent.d.ts → use-tool/UseToolEvent.d.ts}

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