modelfusion 0.7.0 → 0.8.0

package/tool/index.js

@@ -0,0 +1,6 @@
+export * from "./NoSuchToolError.js";
+export * from "./Tool.js";
+export * from "./ToolExecutionError.js";
+export * from "./executeTool.js";
+export * from "./useTool.js";
+export * from "./useToolOrGenerateText.js";

package/tool/useTool.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTool = void 0;
+const generateJson_js_1 = require("../model-function/generate-json/generateJson.cjs");
+const executeTool_js_1 = require("./executeTool.cjs");
+// In this file, using 'any' is required to allow for flexibility in the inputs. The actual types are
+// retrieved through lookups such as TOOL["name"], such that any does not affect any client.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * `useTool` uses `generateJson` 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) {
+    const { value } = await (0, generateJson_js_1.generateJson)(model, {
+        name: tool.name,
+        description: tool.description,
+        schema: tool.inputSchema,
+    }, () => prompt(tool), {
+        ...(options ?? {}),
+        fullResponse: true,
+    });
+    return {
+        tool: tool.name,
+        parameters: value,
+        result: await (0, executeTool_js_1.executeTool)(tool, value, {
+            run: options?.run,
+        }),
+    };
+}
+exports.useTool = useTool;

package/tool/useTool.d.ts

@@ -0,0 +1,15 @@
+import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { GenerateJsonModel, GenerateJsonModelSettings, GenerateJsonPrompt } from "../model-function/generate-json/GenerateJsonModel.js";
+import { Tool } from "./Tool.js";
+/**
+ * `useTool` uses `generateJson` 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, RESPONSE, SETTINGS extends GenerateJsonModelSettings, TOOL extends Tool<any, any, any>>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, tool: TOOL, prompt: (tool: TOOL) => PROMPT & GenerateJsonPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): Promise<{
+    tool: TOOL["name"];
+    parameters: TOOL["inputSchema"];
+    result: Awaited<ReturnType<TOOL["execute"]>>;
+}>;

package/tool/useTool.js

@@ -0,0 +1,29 @@
+import { generateJson } from "../model-function/generate-json/generateJson.js";
+import { executeTool } from "./executeTool.js";
+// In this file, using 'any' is required to allow for flexibility in the inputs. The actual types are
+// retrieved through lookups such as TOOL["name"], such that any does not affect any client.
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * `useTool` uses `generateJson` 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) {
+    const { value } = await generateJson(model, {
+        name: tool.name,
+        description: tool.description,
+        schema: tool.inputSchema,
+    }, () => prompt(tool), {
+        ...(options ?? {}),
+        fullResponse: true,
+    });
+    return {
+        tool: tool.name,
+        parameters: value,
+        result: await executeTool(tool, value, {
+            run: options?.run,
+        }),
+    };
+}

package/tool/useToolOrGenerateText.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useToolOrGenerateText = void 0;
+const generateJsonOrText_js_1 = require("../model-function/generate-json/generateJsonOrText.cjs");
+const NoSuchToolError_js_1 = require("./NoSuchToolError.cjs");
+const executeTool_js_1 = require("./executeTool.cjs");
+async function useToolOrGenerateText(model, tools, prompt, options) {
+    const expandedPrompt = prompt(tools);
+    const modelResponse = await (0, generateJsonOrText_js_1.generateJsonOrText)(model, tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        schema: tool.inputSchema,
+    })), () => expandedPrompt, options);
+    const { schema, text } = modelResponse;
+    if (schema == null) {
+        return {
+            tool: null,
+            parameters: null,
+            result: null,
+            text,
+        };
+    }
+    const tool = tools.find((tool) => tool.name === schema);
+    if (tool == null) {
+        throw new NoSuchToolError_js_1.NoSuchToolError(schema.toString());
+    }
+    const toolParameters = modelResponse.value;
+    const result = await (0, executeTool_js_1.executeTool)(tool, toolParameters, {
+        run: options?.run,
+    });
+    return {
+        tool: schema,
+        result,
+        parameters: toolParameters,
+        text: text, // string | null is the expected value here
+    };
+}
+exports.useToolOrGenerateText = useToolOrGenerateText;

package/{composed-function/use-tool/useTool.d.ts → tool/useToolOrGenerateText.d.ts}

@@ -1,19 +1,6 @@
-import { FunctionOptions } from "../../model-function/FunctionOptions.js";
-import { GenerateJsonModel, GenerateJsonModelSettings, GenerateJsonPrompt } from "../../model-function/generate-json/GenerateJsonModel.js";
-import { GenerateJsonOrTextModel, GenerateJsonOrTextModelSettings, GenerateJsonOrTextPrompt } from "../../model-function/generate-json/GenerateJsonOrTextModel.js";
+import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { GenerateJsonOrTextModel, GenerateJsonOrTextModelSettings, GenerateJsonOrTextPrompt } from "../model-function/generate-json/GenerateJsonOrTextModel.js";
 import { Tool } from "./Tool.js";
-/**
- * `useTool` uses `generateJson` 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, RESPONSE, SETTINGS extends GenerateJsonModelSettings, TOOL extends Tool<any, any, any>>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, tool: TOOL, prompt: (tool: TOOL) => PROMPT & GenerateJsonPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): Promise<{
-    tool: TOOL["name"];
-    parameters: TOOL["inputSchema"];
-    result: Awaited<ReturnType<TOOL["execute"]>>;
-}>;
 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>>;

package/tool/useToolOrGenerateText.js

@@ -0,0 +1,34 @@
+import { generateJsonOrText } from "../model-function/generate-json/generateJsonOrText.js";
+import { NoSuchToolError } from "./NoSuchToolError.js";
+import { executeTool } from "./executeTool.js";
+export async function useToolOrGenerateText(model, tools, prompt, options) {
+    const expandedPrompt = prompt(tools);
+    const modelResponse = await generateJsonOrText(model, tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        schema: tool.inputSchema,
+    })), () => expandedPrompt, options);
+    const { schema, text } = modelResponse;
+    if (schema == null) {
+        return {
+            tool: null,
+            parameters: null,
+            result: null,
+            text,
+        };
+    }
+    const tool = tools.find((tool) => tool.name === schema);
+    if (tool == null) {
+        throw new NoSuchToolError(schema.toString());
+    }
+    const toolParameters = modelResponse.value;
+    const result = await executeTool(tool, toolParameters, {
+        run: options?.run,
+    });
+    return {
+        tool: schema,
+        result,
+        parameters: toolParameters,
+        text: text, // string | null is the expected value here
+    };
+}

package/composed-function/use-tool/useTool.cjs

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useToolOrGenerateText = exports.useTool = void 0;
-const generateJson_js_1 = require("../../model-function/generate-json/generateJson.cjs");
-const generateJsonOrText_js_1 = require("../../model-function/generate-json/generateJsonOrText.cjs");
-const NoSuchToolError_js_1 = require("./NoSuchToolError.cjs");
-// In this file, using 'any' is required to allow for flexibility in the inputs. The actual types are
-// retrieved through lookups such as TOOL["name"], such that any does not affect any client.
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * `useTool` uses `generateJson` 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) {
-    const { value } = await (0, generateJson_js_1.generateJson)(model, {
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    }, () => prompt(tool), {
-        ...(options ?? {}),
-        fullResponse: true,
-    });
-    return {
-        tool: tool.name,
-        parameters: value,
-        result: await tool.execute(value),
-    };
-}
-exports.useTool = useTool;
-async function useToolOrGenerateText(model, tools, prompt, options) {
-    const expandedPrompt = prompt(tools);
-    const modelResponse = await (0, generateJsonOrText_js_1.generateJsonOrText)(model, tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    })), () => expandedPrompt, options);
-    const { schema, text } = modelResponse;
-    if (schema == null) {
-        return {
-            tool: null,
-            parameters: null,
-            result: null,
-            text,
-        };
-    }
-    const tool = tools.find((tool) => tool.name === schema);
-    if (tool == null) {
-        throw new NoSuchToolError_js_1.NoSuchToolError(schema.toString());
-    }
-    const toolParameters = modelResponse.value;
-    const result = await tool.execute(toolParameters);
-    return {
-        tool: schema,
-        result,
-        parameters: toolParameters,
-        text: text, // string | null is the expected value here
-    };
-}
-exports.useToolOrGenerateText = useToolOrGenerateText;

package/composed-function/use-tool/useTool.js

@@ -1,57 +0,0 @@
-import { generateJson } from "../../model-function/generate-json/generateJson.js";
-import { generateJsonOrText } from "../../model-function/generate-json/generateJsonOrText.js";
-import { NoSuchToolError } from "./NoSuchToolError.js";
-// In this file, using 'any' is required to allow for flexibility in the inputs. The actual types are
-// retrieved through lookups such as TOOL["name"], such that any does not affect any client.
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * `useTool` uses `generateJson` 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) {
-    const { value } = await generateJson(model, {
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    }, () => prompt(tool), {
-        ...(options ?? {}),
-        fullResponse: true,
-    });
-    return {
-        tool: tool.name,
-        parameters: value,
-        result: await tool.execute(value),
-    };
-}
-export async function useToolOrGenerateText(model, tools, prompt, options) {
-    const expandedPrompt = prompt(tools);
-    const modelResponse = await generateJsonOrText(model, tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    })), () => expandedPrompt, options);
-    const { schema, text } = modelResponse;
-    if (schema == null) {
-        return {
-            tool: null,
-            parameters: null,
-            result: null,
-            text,
-        };
-    }
-    const tool = tools.find((tool) => tool.name === schema);
-    if (tool == null) {
-        throw new NoSuchToolError(schema.toString());
-    }
-    const toolParameters = modelResponse.value;
-    const result = await tool.execute(toolParameters);
-    return {
-        tool: schema,
-        result,
-        parameters: toolParameters,
-        text: text, // string | null is the expected value here
-    };
-}

package/model-function/ModelCallEventSource.d.ts

@@ -1,13 +0,0 @@
-import { ErrorHandler } from "../util/ErrorHandler.js";
-import { ModelCallFinishedEvent, ModelCallStartedEvent } from "./ModelCallEvent.js";
-import { ModelCallObserver } from "./ModelCallObserver.js";
-export declare class ModelCallEventSource {
-    readonly observers: ModelCallObserver[];
-    readonly errorHandler: ErrorHandler;
-    constructor({ observers, errorHandler, }: {
-        observers: ModelCallObserver[];
-        errorHandler?: ErrorHandler;
-    });
-    notifyModelCallStarted(event: ModelCallStartedEvent): void;
-    notifyModelCallFinished(event: ModelCallFinishedEvent): void;
-}

package/model-function/ModelCallObserver.d.ts

@@ -1,5 +0,0 @@
-import { ModelCallFinishedEvent, ModelCallStartedEvent } from "./ModelCallEvent.js";
-export type ModelCallObserver = {
-    onModelCallStarted?: (event: ModelCallStartedEvent) => void;
-    onModelCallFinished?: (event: ModelCallFinishedEvent) => void;
-};