modelfusion 0.71.0 → 0.72.0

package/tool/use-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("./UseToolEvent.cjs"), exports);
+__exportStar(require("./useTool.cjs"), exports);

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

@@ -0,0 +1,2 @@
+export * from "./UseToolEvent.js";
+export * from "./useTool.js";

package/tool/use-tool/index.js

@@ -0,0 +1,2 @@
+export * from "./UseToolEvent.js";
+export * from "./useTool.js";

package/tool/use-tool/useTool.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTool = void 0;
+const executeFunctionCall_js_1 = require("../../core/executeFunctionCall.cjs");
+const safeExecuteToolCall_js_1 = require("../execute-tool/safeExecuteToolCall.cjs");
+const generateToolCall_js_1 = require("../generate-tool-call/generateToolCall.cjs");
+/**
+ * `useTool` uses `generateToolCall` to generate parameters for a tool and
+ * then executes the tool with the parameters using `executeTool`.
+ *
+ * @returns The result contains the name of the tool (`tool` property),
+ * the parameters (`parameters` property, typed),
+ * and the result of the tool execution (`result` property, typed).
+ *
+ * @see {@link generateToolCall}
+ * @see {@link executeTool}
+ */
+async function useTool(model, tool, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tool)
+        : prompt;
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool",
+        execute: async (options) => (0, safeExecuteToolCall_js_1.safeExecuteToolCall)(tool, await (0, generateToolCall_js_1.generateToolCall)(model, tool, expandedPrompt, options), options),
+    });
+}
+exports.useTool = useTool;

package/tool/use-tool/useTool.d.ts

@@ -0,0 +1,16 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Tool } from "../Tool.js";
+import { ToolCallResult } from "../ToolCallResult.js";
+import { ToolCallGenerationModel, ToolCallGenerationModelSettings } from "../generate-tool-call/ToolCallGenerationModel.js";
+/**
+ * `useTool` uses `generateToolCall` to generate parameters for a tool and
+ * then executes the tool with the parameters using `executeTool`.
+ *
+ * @returns The result contains the name of the tool (`tool` property),
+ * the parameters (`parameters` property, typed),
+ * and the result of the tool execution (`result` property, typed).
+ *
+ * @see {@link generateToolCall}
+ * @see {@link executeTool}
+ */
+export declare function useTool<PROMPT, TOOL extends Tool<string, any, any>>(model: ToolCallGenerationModel<PROMPT, ToolCallGenerationModelSettings>, tool: TOOL, prompt: PROMPT | ((tool: TOOL) => PROMPT), options?: FunctionOptions): Promise<ToolCallResult<TOOL["name"], TOOL["parameters"], Awaited<ReturnType<TOOL["execute"]>>>>;

package/tool/use-tool/useTool.js

@@ -0,0 +1,26 @@
+import { executeFunctionCall } from "../../core/executeFunctionCall.js";
+import { safeExecuteToolCall } from "../execute-tool/safeExecuteToolCall.js";
+import { generateToolCall } from "../generate-tool-call/generateToolCall.js";
+/**
+ * `useTool` uses `generateToolCall` to generate parameters for a tool and
+ * then executes the tool with the parameters using `executeTool`.
+ *
+ * @returns The result contains the name of the tool (`tool` property),
+ * the parameters (`parameters` property, typed),
+ * and the result of the tool execution (`result` property, typed).
+ *
+ * @see {@link generateToolCall}
+ * @see {@link executeTool}
+ */
+export async function useTool(model, tool, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tool)
+        : prompt;
+    return executeFunctionCall({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool",
+        execute: async (options) => safeExecuteToolCall(tool, await generateToolCall(model, tool, expandedPrompt, options), options),
+    });
+}

package/tool/use-tools-or-generate-text/UseToolsOrGenerateTextEvent.d.ts

@@ -0,0 +1,7 @@
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../../core/FunctionEvent.js";
+export interface UseToolsOrGenerateTextStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "use-tools-or-generate-text";
+}
+export interface UseToolsOrGenerateTextFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "use-tools-or-generate-text";
+}

package/tool/use-tools-or-generate-text/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("./UseToolsOrGenerateTextEvent.cjs"), exports);
+__exportStar(require("./useToolsOrGenerateText.cjs"), exports);

package/tool/use-tools-or-generate-text/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./UseToolsOrGenerateTextEvent.js";
+export * from "./useToolsOrGenerateText.js";

package/tool/use-tools-or-generate-text/index.js

@@ -0,0 +1,2 @@
+export * from "./UseToolsOrGenerateTextEvent.js";
+export * from "./useToolsOrGenerateText.js";

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.cjs

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useToolsOrGenerateText = void 0;
+const executeFunctionCall_js_1 = require("../../core/executeFunctionCall.cjs");
+const ToolCallError_js_1 = require("../ToolCallError.cjs");
+const safeExecuteToolCall_js_1 = require("../execute-tool/safeExecuteToolCall.cjs");
+const generateToolCallsOrText_js_1 = require("../generate-tool-calls-or-text/generateToolCallsOrText.cjs");
+async function useToolsOrGenerateText(model, tools, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tools)
+        : prompt;
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tools-or-generate-text",
+        execute: async (options) => {
+            const modelResponse = await (0, generateToolCallsOrText_js_1.generateToolCallsOrText)(model, tools, expandedPrompt, { ...options, returnType: "structure" });
+            const { toolCalls, text } = modelResponse;
+            // no tool calls:
+            if (toolCalls == null) {
+                return { text, toolResults: null };
+            }
+            // execute tools in parallel:
+            const toolResults = await Promise.all(toolCalls.map(async (toolCall) => {
+                const tool = tools.find((tool) => tool.name === toolCall.name);
+                if (tool == null) {
+                    return {
+                        tool: toolCall.name,
+                        toolCall,
+                        args: toolCall.args,
+                        ok: false,
+                        result: new ToolCallError_js_1.ToolCallError({
+                            message: `No tool with name '${toolCall.name}' found.`,
+                            toolCall,
+                        }),
+                    };
+                }
+                return await (0, safeExecuteToolCall_js_1.safeExecuteToolCall)(tool, toolCall, options);
+            }));
+            return {
+                text,
+                toolResults: toolResults,
+            };
+        },
+    });
+}
+exports.useToolsOrGenerateText = useToolsOrGenerateText;

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.d.ts

@@ -0,0 +1,18 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Tool } from "../Tool.js";
+import { ToolCallResult } from "../ToolCallResult.js";
+import { ToolCallsOrTextGenerationModel, ToolCallsOrTextGenerationModelSettings } from "../generate-tool-calls-or-text/ToolCallsOrTextGenerationModel.js";
+type ToolArray<T extends Tool<any, any, any>[]> = T;
+type ToToolMap<T extends ToolArray<Tool<any, any, any>[]>> = {
+    [K in T[number]["name"]]: Extract<T[number], Tool<K, any, any>>;
+};
+type StringKeys<T> = Extract<keyof T, string>;
+type ToToolCallUnion<T> = {
+    [KEY in StringKeys<T>]: T[KEY] extends Tool<any, infer PARAMETERS, infer OUTPUT> ? ToolCallResult<KEY, PARAMETERS, OUTPUT> : never;
+}[StringKeys<T>];
+type ToOutputValue<TOOLS extends ToolArray<Tool<any, any, any>[]>> = ToToolCallUnion<ToToolMap<TOOLS>>;
+export declare function useToolsOrGenerateText<PROMPT, TOOLS extends Array<Tool<any, any, any>>>(model: ToolCallsOrTextGenerationModel<PROMPT, ToolCallsOrTextGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options?: FunctionOptions): Promise<{
+    text: string | null;
+    toolResults: Array<ToOutputValue<TOOLS>> | null;
+}>;
+export {};

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.js

@@ -0,0 +1,44 @@
+import { executeFunctionCall } from "../../core/executeFunctionCall.js";
+import { ToolCallError } from "../ToolCallError.js";
+import { safeExecuteToolCall } from "../execute-tool/safeExecuteToolCall.js";
+import { generateToolCallsOrText } from "../generate-tool-calls-or-text/generateToolCallsOrText.js";
+export async function useToolsOrGenerateText(model, tools, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tools)
+        : prompt;
+    return executeFunctionCall({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tools-or-generate-text",
+        execute: async (options) => {
+            const modelResponse = await generateToolCallsOrText(model, tools, expandedPrompt, { ...options, returnType: "structure" });
+            const { toolCalls, text } = modelResponse;
+            // no tool calls:
+            if (toolCalls == null) {
+                return { text, toolResults: null };
+            }
+            // execute tools in parallel:
+            const toolResults = await Promise.all(toolCalls.map(async (toolCall) => {
+                const tool = tools.find((tool) => tool.name === toolCall.name);
+                if (tool == null) {
+                    return {
+                        tool: toolCall.name,
+                        toolCall,
+                        args: toolCall.args,
+                        ok: false,
+                        result: new ToolCallError({
+                            message: `No tool with name '${toolCall.name}' found.`,
+                            toolCall,
+                        }),
+                    };
+                }
+                return await safeExecuteToolCall(tool, toolCall, options);
+            }));
+            return {
+                text,
+                toolResults: toolResults,
+            };
+        },
+    });
+}

package/util/getErrorMessage.cjs

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getErrorMessage = void 0;
 function getErrorMessage(error) {
+    if (error == null) {
+        return "unknown error";
+    }
     if (typeof error === "string") {
         return error;
     }

package/util/getErrorMessage.d.ts

@@ -1 +1 @@
-export declare function getErrorMessage(error: unknown): string;
+export declare function getErrorMessage(error: unknown | undefined): string;

package/util/getErrorMessage.js

@@ -1,4 +1,7 @@
 export function getErrorMessage(error) {
+    if (error == null) {
+        return "unknown error";
+    }
     if (typeof error === "string") {
         return error;
     }

package/model-function/generate-structure/NoSuchStructureError.cjs

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoSuchStructureError = void 0;
-class NoSuchStructureError extends Error {
-    constructor(structureName) {
-        super(`No such structure: ${structureName}`);
-        Object.defineProperty(this, "structureName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "NoSuchStructureError";
-        this.structureName = structureName;
-    }
-}
-exports.NoSuchStructureError = NoSuchStructureError;

package/model-function/generate-structure/NoSuchStructureError.d.ts

@@ -1,4 +0,0 @@
-export declare class NoSuchStructureError extends Error {
-    readonly structureName: string;
-    constructor(structureName: string);
-}

package/model-function/generate-structure/NoSuchStructureError.js

@@ -1,13 +0,0 @@
-export class NoSuchStructureError extends Error {
-    constructor(structureName) {
-        super(`No such structure: ${structureName}`);
-        Object.defineProperty(this, "structureName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "NoSuchStructureError";
-        this.structureName = structureName;
-    }
-}

package/model-function/generate-structure/StructureOrTextGenerationModel.d.ts

@@ -1,26 +0,0 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { StructureDefinition } from "../../core/schema/StructureDefinition.js";
-import { Model, ModelSettings } from "../Model.js";
-export interface StructureOrTextGenerationModelSettings extends ModelSettings {
-}
-export interface StructureOrTextGenerationModel<PROMPT, SETTINGS extends StructureOrTextGenerationModelSettings> extends Model<SETTINGS> {
-    doGenerateStructureOrText(structureDefinitions: Array<StructureDefinition<string, unknown>>, prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
-        response: unknown;
-        structureAndText: {
-            structure: null;
-            value: null;
-            valueText: null;
-            text: string;
-        } | {
-            structure: string;
-            value: unknown;
-            valueText: string;
-            text: string | null;
-        };
-        usage?: {
-            promptTokens: number;
-            completionTokens: number;
-            totalTokens: number;
-        };
-    }>;
-}

package/model-function/generate-structure/generateStructureOrText.cjs

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateStructureOrText = void 0;
-const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
-const NoSuchStructureError_js_1 = require("./NoSuchStructureError.cjs");
-const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
-async function generateStructureOrText(model, structureDefinitions, prompt, options) {
-    // Note: PROMPT must not be a function.
-    const expandedPrompt = typeof prompt === "function"
-        ? prompt(structureDefinitions)
-        : prompt;
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "generate-structure-or-text",
-        input: expandedPrompt,
-        model,
-        options,
-        generateResponse: async (options) => {
-            const result = await model.doGenerateStructureOrText(structureDefinitions, expandedPrompt, options);
-            const { structure, value, text } = result.structureAndText;
-            // text generation:
-            if (structure == null) {
-                return {
-                    response: result.response,
-                    extractedValue: { structure, value, text },
-                    usage: result.usage,
-                };
-            }
-            const definition = structureDefinitions.find((d) => d.name === structure);
-            if (definition == undefined) {
-                throw new NoSuchStructureError_js_1.NoSuchStructureError(structure);
-            }
-            const parseResult = definition.schema.validate(value);
-            if (!parseResult.success) {
-                throw new StructureValidationError_js_1.StructureValidationError({
-                    structureName: structure,
-                    value,
-                    valueText: result.structureAndText.valueText,
-                    cause: parseResult.error,
-                });
-            }
-            return {
-                response: result.response,
-                extractedValue: {
-                    structure: structure,
-                    value: parseResult.data,
-                    text: text, // text is string | null, which is part of the response for schema values
-                },
-                usage: result.usage,
-            };
-        },
-    });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
-}
-exports.generateStructureOrText = generateStructureOrText;

package/model-function/generate-structure/generateStructureOrText.d.ts

@@ -1,97 +0,0 @@
-import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { StructureDefinition } from "../../core/schema/StructureDefinition.js";
-import { ModelCallMetadata } from "../ModelCallMetadata.js";
-import { StructureOrTextGenerationModel, StructureOrTextGenerationModelSettings } from "./StructureOrTextGenerationModel.js";
-type StructureDefinitionArray<T extends StructureDefinition<any, any>[]> = T;
-type ToStructureDefinitionMap<T extends StructureDefinitionArray<StructureDefinition<any, any>[]>> = {
-    [K in T[number]["name"]]: Extract<T[number], StructureDefinition<K, any>>;
-};
-type ToStructureUnion<T> = {
-    [KEY in keyof T]: T[KEY] extends StructureDefinition<any, infer STRUCTURE> ? {
-        structure: KEY;
-        value: STRUCTURE;
-        text: string | null;
-    } : never;
-}[keyof T];
-type ToOutputValue<STRUCTURES extends StructureDefinitionArray<StructureDefinition<any, any>[]>> = ToStructureUnion<ToStructureDefinitionMap<STRUCTURES>>;
-/**
- * Generates a typed object or plain text based on the given prompt and structure definitions.
- * The structure definition is used as part of the final prompt.
- *
- * This function interacts with a specified model to either return a structured object conforming to one of the provided
- * structure definitions or a plain text response if the model decides not to return a structured object.
- *
- * For the OpenAI chat model, this generates and parses a function call with automatic function selection.
- *
- * @see https://modelfusion.dev/guide/function/generate-structure-or-text
- *
- * @example
- * const { structure, value, text } = await generateStructureOrText(
- *   new OpenAIChatModel(...),
- *   [
- *     new ZodStructureDefinition({
- *       name: "getCurrentWeather" as const, // mark 'as const' for type inference
- *       description: "Get the current weather in a given location",
- *       schema: z.object({
- *         location: z
- *           .string()
- *           .describe("The city and state, e.g. San Francisco, CA"),
- *         unit: z.enum(["celsius", "fahrenheit"]).optional(),
- *       }),
- *     }),
- *     new ZodStructureDefinition({
- *       name: "getContactInformation" as const,
- *       description: "Get the contact information for a given person",
- *       schema: z.object({
- *         name: z.string().describe("The name of the person"),
- *       }),
- *     }),
- *   ],
- *   [OpenAIChatMessage.user(query)]
- * );
- *
- * switch (structure) {
- *   case "getCurrentWeather": {
- *     const { location, unit } = value;
- *     console.log("getCurrentWeather", location, unit);
- *     break;
- *   }
- *
- *   case "getContactInformation": {
- *     const { name } = value;
- *     console.log("getContactInformation", name);
- *     break;
- *   }
- *
- *   case null: {
- *     console.log("No function call. Generated text: ", text);
- *   }
- * }
- *
- * @param {StructureOrTextGenerationModel<PROMPT, SETTINGS>} model - The model responsible for generating structured data or text.
- * @param {STRUCTURES} structureDefinitions - An array of StructureDefinition instances defining the possible structures of the expected response.
- * @param {PROMPT | ((structureDefinitions: STRUCTURES) => PROMPT)} prompt - The prompt used to generate the structure or text.
- * You can also pass a function that takes the array of structure definitions as an argument and returns the prompt.
- * @param {FunctionOptions} [options] - Additional options to control the function's execution behavior.
- *
- * @returns {Promise<{ structure: null; value: null; text: string } | ToOutputValue<STRUCTURES>>} - Returns a promise that resolves to an object containing either a structured response conforming to one of the provided definitions or a plain text response.
- */
-export declare function generateStructureOrText<STRUCTURES extends StructureDefinition<any, any>[], PROMPT>(model: StructureOrTextGenerationModel<PROMPT, StructureOrTextGenerationModelSettings>, structureDefinitions: STRUCTURES, prompt: PROMPT | ((structureDefinitions: STRUCTURES) => PROMPT), options?: FunctionOptions & {
-    returnType?: "structure";
-}): Promise<{
-    structure: null;
-    value: null;
-    text: string;
-} | ToOutputValue<STRUCTURES>>;
-export declare function generateStructureOrText<STRUCTURES extends StructureDefinition<any, any>[], PROMPT>(model: StructureOrTextGenerationModel<PROMPT, StructureOrTextGenerationModelSettings>, structureDefinitions: STRUCTURES, prompt: PROMPT | ((structureDefinitions: STRUCTURES) => PROMPT), options: FunctionOptions & {
-    returnType?: "full";
-}): Promise<{
-    value: {
-        structure: null;
-        value: null;
-        text: string;
-    } | ToOutputValue<STRUCTURES>;
-    response: unknown;
-    metadata: ModelCallMetadata;
-}>;
-export {};

package/model-function/generate-structure/generateStructureOrText.js

@@ -1,50 +0,0 @@
-import { executeStandardCall } from "../executeStandardCall.js";
-import { NoSuchStructureError } from "./NoSuchStructureError.js";
-import { StructureValidationError } from "./StructureValidationError.js";
-export async function generateStructureOrText(model, structureDefinitions, prompt, options) {
-    // Note: PROMPT must not be a function.
-    const expandedPrompt = typeof prompt === "function"
-        ? prompt(structureDefinitions)
-        : prompt;
-    const fullResponse = await executeStandardCall({
-        functionType: "generate-structure-or-text",
-        input: expandedPrompt,
-        model,
-        options,
-        generateResponse: async (options) => {
-            const result = await model.doGenerateStructureOrText(structureDefinitions, expandedPrompt, options);
-            const { structure, value, text } = result.structureAndText;
-            // text generation:
-            if (structure == null) {
-                return {
-                    response: result.response,
-                    extractedValue: { structure, value, text },
-                    usage: result.usage,
-                };
-            }
-            const definition = structureDefinitions.find((d) => d.name === structure);
-            if (definition == undefined) {
-                throw new NoSuchStructureError(structure);
-            }
-            const parseResult = definition.schema.validate(value);
-            if (!parseResult.success) {
-                throw new StructureValidationError({
-                    structureName: structure,
-                    value,
-                    valueText: result.structureAndText.valueText,
-                    cause: parseResult.error,
-                });
-            }
-            return {
-                response: result.response,
-                extractedValue: {
-                    structure: structure,
-                    value: parseResult.data,
-                    text: text, // text is string | null, which is part of the response for schema values
-                },
-                usage: result.usage,
-            };
-        },
-    });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
-}

package/model-function/generate-tool-call/ToolCall.d.ts

@@ -1,5 +0,0 @@
-export interface ToolCall<NAME extends string, PARAMETERS> {
-    id: string;
-    name: NAME;
-    parameters: PARAMETERS;
-}

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

@@ -1,10 +0,0 @@
-export * from "./ToolCall.js";
-export * from "./ToolCallGenerationError.js";
-export * from "./ToolCallGenerationEvent.js";
-export * from "./ToolCallGenerationModel.js";
-export * from "./ToolCallParametersValidationError.js";
-export * from "./ToolCallsOrTextGenerationEvent.js";
-export * from "./ToolCallsOrTextGenerationModel.js";
-export * from "./ToolDefinition.js";
-export * from "./generateToolCall.js";
-export * from "./generateToolCallsOrText.js";

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

@@ -1,10 +0,0 @@
-export * from "./ToolCall.js";
-export * from "./ToolCallGenerationError.js";
-export * from "./ToolCallGenerationEvent.js";
-export * from "./ToolCallGenerationModel.js";
-export * from "./ToolCallParametersValidationError.js";
-export * from "./ToolCallsOrTextGenerationEvent.js";
-export * from "./ToolCallsOrTextGenerationModel.js";
-export * from "./ToolDefinition.js";
-export * from "./generateToolCall.js";
-export * from "./generateToolCallsOrText.js";

package/tool/NoSuchToolError.cjs

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoSuchToolError = void 0;
-class NoSuchToolError extends Error {
-    constructor(toolName) {
-        super(`No such tool: ${toolName}`);
-        Object.defineProperty(this, "toolName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "NoSuchToolError";
-        this.toolName = toolName;
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            toolName: this.toolName,
-            message: this.message,
-            stack: this.stack,
-        };
-    }
-}
-exports.NoSuchToolError = NoSuchToolError;

package/tool/NoSuchToolError.d.ts

@@ -1,10 +0,0 @@
-export declare class NoSuchToolError extends Error {
-    readonly toolName: string;
-    constructor(toolName: string);
-    toJSON(): {
-        name: string;
-        toolName: string;
-        message: string;
-        stack: string | undefined;
-    };
-}

package/tool/NoSuchToolError.js

@@ -1,21 +0,0 @@
-export class NoSuchToolError extends Error {
-    constructor(toolName) {
-        super(`No such tool: ${toolName}`);
-        Object.defineProperty(this, "toolName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "NoSuchToolError";
-        this.toolName = toolName;
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            toolName: this.toolName,
-            message: this.message,
-            stack: this.stack,
-        };
-    }
-}

package/tool/UseToolOrGenerateTextEvent.d.ts

@@ -1,7 +0,0 @@
-import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
-export interface UseToolOrGenerateTextStartedEvent extends BaseFunctionStartedEvent {
-    functionType: "use-tool-or-generate-text";
-}
-export interface UseToolOrGenerateTextFinishedEvent extends BaseFunctionFinishedEvent {
-    functionType: "use-tool-or-generate-text";
-}