modelfusion 0.71.0 → 0.72.0

package/tool/useTool.cjs

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useTool = void 0;
-const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
-const generateStructure_js_1 = require("../model-function/generate-structure/generateStructure.cjs");
-const executeTool_js_1 = require("./executeTool.cjs");
-/**
- * `useTool` uses `generateStructure` to generate parameters for a tool and then executes the tool with the parameters.
- *
- * @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).
- */
-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) => {
-            const { value } = await (0, generateStructure_js_1.generateStructure)(model, {
-                name: tool.name,
-                description: tool.description,
-                schema: tool.inputSchema,
-            }, expandedPrompt, {
-                ...options,
-                returnType: "full",
-            });
-            return {
-                tool: tool.name,
-                parameters: value,
-                result: await (0, executeTool_js_1.executeTool)(tool, value, options),
-            };
-        },
-    });
-}
-exports.useTool = useTool;

package/tool/useTool.d.ts

@@ -1,15 +0,0 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
-import { StructureGenerationModel, StructureGenerationModelSettings } from "../model-function/generate-structure/StructureGenerationModel.js";
-import { Tool } from "./Tool.js";
-/**
- * `useTool` uses `generateStructure` to generate parameters for a tool and then executes the tool with the parameters.
- *
- * @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).
- */
-export declare function useTool<PROMPT, TOOL extends Tool<any, any, any>>(model: StructureGenerationModel<PROMPT, StructureGenerationModelSettings>, tool: TOOL, prompt: PROMPT | ((tool: TOOL) => PROMPT), options?: FunctionOptions): Promise<{
-    tool: TOOL["name"];
-    parameters: TOOL["inputSchema"];
-    result: Awaited<ReturnType<TOOL["execute"]>>;
-}>;

package/tool/useTool.js

@@ -1,36 +0,0 @@
-import { executeFunctionCall } from "../core/executeFunctionCall.js";
-import { generateStructure } from "../model-function/generate-structure/generateStructure.js";
-import { executeTool } from "./executeTool.js";
-/**
- * `useTool` uses `generateStructure` to generate parameters for a tool and then executes the tool with the parameters.
- *
- * @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).
- */
-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) => {
-            const { value } = await generateStructure(model, {
-                name: tool.name,
-                description: tool.description,
-                schema: tool.inputSchema,
-            }, expandedPrompt, {
-                ...options,
-                returnType: "full",
-            });
-            return {
-                tool: tool.name,
-                parameters: value,
-                result: await executeTool(tool, value, options),
-            };
-        },
-    });
-}

package/tool/useToolOrGenerateText.cjs

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useToolOrGenerateText = void 0;
-const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
-const generateStructureOrText_js_1 = require("../model-function/generate-structure/generateStructureOrText.cjs");
-const NoSuchToolError_js_1 = require("./NoSuchToolError.cjs");
-const executeTool_js_1 = require("./executeTool.cjs");
-async function useToolOrGenerateText(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-tool-or-generate-text",
-        execute: async (options) => {
-            const modelResponse = await (0, generateStructureOrText_js_1.generateStructureOrText)(model, tools.map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                schema: tool.inputSchema,
-            })), expandedPrompt, {
-                ...options,
-                returnType: "structure",
-            });
-            const { structure, text } = modelResponse;
-            if (structure == null) {
-                return {
-                    tool: null,
-                    parameters: null,
-                    result: null,
-                    text,
-                };
-            }
-            const tool = tools.find((tool) => tool.name === structure);
-            if (tool == null) {
-                throw new NoSuchToolError_js_1.NoSuchToolError(structure.toString());
-            }
-            const toolParameters = modelResponse.value;
-            const result = await (0, executeTool_js_1.executeTool)(tool, toolParameters, options);
-            return {
-                tool: structure,
-                result,
-                parameters: toolParameters,
-                text: text, // string | null is the expected value here
-            };
-        },
-    });
-}
-exports.useToolOrGenerateText = useToolOrGenerateText;

package/tool/useToolOrGenerateText.d.ts

@@ -1,23 +0,0 @@
-import { FunctionOptions } from "../core/FunctionOptions.js";
-import { StructureOrTextGenerationModel, StructureOrTextGenerationModelSettings } from "../model-function/generate-structure/StructureOrTextGenerationModel.js";
-import { Tool } from "./Tool.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 ToToolUnion<T> = {
-    [KEY in keyof T]: T[KEY] extends Tool<any, infer INPUT, infer OUTPUT> ? {
-        tool: KEY;
-        parameters: INPUT;
-        result: OUTPUT;
-        text: string | null;
-    } : never;
-}[keyof T];
-type ToOutputValue<TOOLS extends ToolArray<Tool<any, any, any>[]>> = ToToolUnion<ToToolMap<TOOLS>>;
-export declare function useToolOrGenerateText<PROMPT, SETTINGS extends StructureOrTextGenerationModelSettings, TOOLS extends Array<Tool<any, any, any>>>(model: StructureOrTextGenerationModel<PROMPT, SETTINGS>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options?: FunctionOptions): Promise<{
-    tool: null;
-    parameters: null;
-    result: null;
-    text: string;
-} | ToOutputValue<TOOLS>>;
-export {};

package/tool/useToolOrGenerateText.js

@@ -1,46 +0,0 @@
-import { executeFunctionCall } from "../core/executeFunctionCall.js";
-import { generateStructureOrText } from "../model-function/generate-structure/generateStructureOrText.js";
-import { NoSuchToolError } from "./NoSuchToolError.js";
-import { executeTool } from "./executeTool.js";
-export async function useToolOrGenerateText(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-tool-or-generate-text",
-        execute: async (options) => {
-            const modelResponse = await generateStructureOrText(model, tools.map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                schema: tool.inputSchema,
-            })), expandedPrompt, {
-                ...options,
-                returnType: "structure",
-            });
-            const { structure, text } = modelResponse;
-            if (structure == null) {
-                return {
-                    tool: null,
-                    parameters: null,
-                    result: null,
-                    text,
-                };
-            }
-            const tool = tools.find((tool) => tool.name === structure);
-            if (tool == null) {
-                throw new NoSuchToolError(structure.toString());
-            }
-            const toolParameters = modelResponse.value;
-            const result = await executeTool(tool, toolParameters, options);
-            return {
-                tool: structure,
-                result,
-                parameters: toolParameters,
-                text: text, // string | null is the expected value here
-            };
-        },
-    });
-}