modelfusion 0.7.0 → 0.9.0

package/tool/WebSearchTool.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { Tool } from "./Tool.js";
+declare const INPUT_SCHEMA: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+declare const OUTPUT_SCHEMA: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        link: z.ZodString;
+        snippet: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        link: string;
+        title: string;
+        snippet: string;
+    }, {
+        link: string;
+        title: string;
+        snippet: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    results: {
+        link: string;
+        title: string;
+        snippet: string;
+    }[];
+}, {
+    results: {
+        link: string;
+        title: string;
+        snippet: string;
+    }[];
+}>;
+/**
+ * @see https://serpapi.com/search-api
+ */
+export declare class WebSearchTool<NAME extends string> extends Tool<NAME, z.infer<typeof INPUT_SCHEMA>, z.infer<typeof OUTPUT_SCHEMA>> {
+    static readonly INPUT_SCHEMA: z.ZodObject<{
+        query: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        query: string;
+    }, {
+        query: string;
+    }>;
+    static readonly OUTPUT_SCHEMA: z.ZodObject<{
+        results: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            link: z.ZodString;
+            snippet: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            link: string;
+            title: string;
+            snippet: string;
+        }, {
+            link: string;
+            title: string;
+            snippet: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        results: {
+            link: string;
+            title: string;
+            snippet: string;
+        }[];
+    }, {
+        results: {
+            link: string;
+            title: string;
+            snippet: string;
+        }[];
+    }>;
+    constructor(options: {
+        name: NAME;
+        description: string;
+        execute(input: z.infer<typeof INPUT_SCHEMA>): Promise<z.infer<typeof OUTPUT_SCHEMA>>;
+    });
+}
+export {};

package/tool/WebSearchTool.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { Tool } from "./Tool.js";
+const INPUT_SCHEMA = z.object({
+    query: z.string(),
+});
+const OUTPUT_SCHEMA = z.object({
+    results: z.array(z.object({
+        title: z.string(),
+        link: z.string().url(),
+        snippet: z.string(),
+    })),
+});
+/**
+ * @see https://serpapi.com/search-api
+ */
+export class WebSearchTool extends Tool {
+    constructor(options) {
+        super({
+            name: options.name,
+            description: options.description,
+            inputSchema: INPUT_SCHEMA,
+            outputSchema: OUTPUT_SCHEMA,
+            execute: options.execute,
+        });
+    }
+}
+// expose the schemas to library consumers:
+Object.defineProperty(WebSearchTool, "INPUT_SCHEMA", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: INPUT_SCHEMA
+});
+Object.defineProperty(WebSearchTool, "OUTPUT_SCHEMA", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: OUTPUT_SCHEMA
+});

package/tool/executeTool.cjs

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTool = void 0;
+const nanoid_1 = require("nanoid");
+const RunFunctionEventSource_js_1 = require("../run/RunFunctionEventSource.cjs");
+const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
+const AbortError_js_1 = require("../util/api/AbortError.cjs");
+const runSafe_js_1 = require("../util/runSafe.cjs");
+const ToolExecutionError_js_1 = require("./ToolExecutionError.cjs");
+async function executeTool(tool, input, options) {
+    const run = options?.run;
+    const eventSource = new RunFunctionEventSource_js_1.RunFunctionEventSource({
+        observers: run?.observers ?? [],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
+    const startMetadata = {
+        callId: `call-${(0, nanoid_1.nanoid)()}`,
+        runId: run?.runId,
+        sessionId: run?.sessionId,
+        userId: run?.userId,
+        functionId: options?.functionId,
+        startEpochSeconds: durationMeasurement.startEpochSeconds,
+    };
+    eventSource.notifyRunFunctionStarted({
+        type: "execute-tool-started",
+        metadata: startMetadata,
+        tool: tool,
+        input,
+    });
+    const result = await (0, runSafe_js_1.runSafe)(() => tool.execute(input, options));
+    const finishMetadata = {
+        ...startMetadata,
+        durationInMs: durationMeasurement.durationInMs,
+    };
+    if (!result.ok) {
+        if (result.isAborted) {
+            eventSource.notifyRunFunctionFinished({
+                type: "execute-tool-finished",
+                status: "abort",
+                metadata: finishMetadata,
+                tool: tool,
+                input,
+            });
+            throw new AbortError_js_1.AbortError();
+        }
+        eventSource.notifyRunFunctionFinished({
+            type: "execute-tool-finished",
+            status: "failure",
+            metadata: finishMetadata,
+            tool: tool,
+            input,
+            error: result.error,
+        });
+        throw new ToolExecutionError_js_1.ToolExecutionError({
+            toolName: tool.name,
+            input,
+            cause: result.error,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            message: result.error?.message,
+        });
+    }
+    const output = result.output;
+    eventSource.notifyRunFunctionFinished({
+        type: "execute-tool-finished",
+        status: "success",
+        metadata: finishMetadata,
+        tool: tool,
+        input,
+        output,
+    });
+    return options?.fullResponse === true
+        ? {
+            output,
+            metadata: finishMetadata,
+        }
+        : output;
+}
+exports.executeTool = executeTool;

package/tool/executeTool.d.ts

@@ -0,0 +1,23 @@
+import { FunctionOptions } from "../model-function/FunctionOptions.js";
+import { Tool } from "./Tool.js";
+export type ExecuteToolMetadata = {
+    callId: string;
+    runId?: string;
+    sessionId?: string;
+    userId?: string;
+    functionId?: string;
+    startEpochSeconds: number;
+    durationInMs: number;
+};
+/**
+ * `executeTool` directly executes a tool with the given parameters.
+ */
+export declare function executeTool<INPUT, OUTPUT>(tool: Tool<string, INPUT, OUTPUT>, input: INPUT, options: FunctionOptions<undefined> & {
+    fullResponse: true;
+}): Promise<{
+    output: OUTPUT;
+    metadata: ExecuteToolMetadata;
+}>;
+export declare function executeTool<INPUT, OUTPUT>(tool: Tool<string, INPUT, OUTPUT>, input: INPUT, options?: FunctionOptions<undefined> & {
+    fullResponse?: false;
+}): Promise<OUTPUT>;

package/tool/executeTool.js

@@ -0,0 +1,75 @@
+import { nanoid as createId } from "nanoid";
+import { RunFunctionEventSource } from "../run/RunFunctionEventSource.js";
+import { startDurationMeasurement } from "../util/DurationMeasurement.js";
+import { AbortError } from "../util/api/AbortError.js";
+import { runSafe } from "../util/runSafe.js";
+import { ToolExecutionError } from "./ToolExecutionError.js";
+export async function executeTool(tool, input, options) {
+    const run = options?.run;
+    const eventSource = new RunFunctionEventSource({
+        observers: run?.observers ?? [],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = startDurationMeasurement();
+    const startMetadata = {
+        callId: `call-${createId()}`,
+        runId: run?.runId,
+        sessionId: run?.sessionId,
+        userId: run?.userId,
+        functionId: options?.functionId,
+        startEpochSeconds: durationMeasurement.startEpochSeconds,
+    };
+    eventSource.notifyRunFunctionStarted({
+        type: "execute-tool-started",
+        metadata: startMetadata,
+        tool: tool,
+        input,
+    });
+    const result = await runSafe(() => tool.execute(input, options));
+    const finishMetadata = {
+        ...startMetadata,
+        durationInMs: durationMeasurement.durationInMs,
+    };
+    if (!result.ok) {
+        if (result.isAborted) {
+            eventSource.notifyRunFunctionFinished({
+                type: "execute-tool-finished",
+                status: "abort",
+                metadata: finishMetadata,
+                tool: tool,
+                input,
+            });
+            throw new AbortError();
+        }
+        eventSource.notifyRunFunctionFinished({
+            type: "execute-tool-finished",
+            status: "failure",
+            metadata: finishMetadata,
+            tool: tool,
+            input,
+            error: result.error,
+        });
+        throw new ToolExecutionError({
+            toolName: tool.name,
+            input,
+            cause: result.error,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            message: result.error?.message,
+        });
+    }
+    const output = result.output;
+    eventSource.notifyRunFunctionFinished({
+        type: "execute-tool-finished",
+        status: "success",
+        metadata: finishMetadata,
+        tool: tool,
+        input,
+        output,
+    });
+    return options?.fullResponse === true
+        ? {
+            output,
+            metadata: finishMetadata,
+        }
+        : output;
+}

package/tool/index.cjs

@@ -0,0 +1,23 @@
+"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("./NoSuchToolError.cjs"), exports);
+__exportStar(require("./Tool.cjs"), exports);
+__exportStar(require("./ToolExecutionError.cjs"), exports);
+__exportStar(require("./WebSearchTool.cjs"), exports);
+__exportStar(require("./executeTool.cjs"), exports);
+__exportStar(require("./useTool.cjs"), exports);
+__exportStar(require("./useToolOrGenerateText.cjs"), exports);

package/tool/index.d.ts

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

package/tool/index.js

@@ -0,0 +1,7 @@
+export * from "./NoSuchToolError.js";
+export * from "./Tool.js";
+export * from "./ToolExecutionError.js";
+export * from "./WebSearchTool.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/Tool.d.ts

@@ -1,15 +0,0 @@
-import { z } from "zod";
-import { SchemaDefinition } from "../../model-function/generate-json/SchemaDefinition.js";
-export declare class Tool<NAME extends string, INPUT, OUTPUT> {
-    readonly name: NAME;
-    readonly description: string;
-    readonly inputSchema: z.ZodSchema<INPUT>;
-    readonly execute: (input: INPUT) => PromiseLike<OUTPUT>;
-    constructor(options: {
-        name: NAME;
-        description: string;
-        inputSchema: z.ZodSchema<INPUT>;
-        execute(input: INPUT): Promise<OUTPUT>;
-    });
-    get inputSchemaDefinition(): SchemaDefinition<NAME, INPUT>;
-}

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

@@ -1,39 +0,0 @@
-export class Tool {
-    constructor(options) {
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "description", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "inputSchema", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "execute", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = options.name;
-        this.description = options.description;
-        this.inputSchema = options.inputSchema;
-        this.execute = options.execute;
-    }
-    get inputSchemaDefinition() {
-        return {
-            name: this.name,
-            description: this.description,
-            schema: this.inputSchema,
-        };
-    }
-}

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;