modelfusion 0.6.0 → 0.8.0

package/run/index.d.ts

@@ -3,4 +3,7 @@ export * from "./DefaultRun.js";
 export * from "./IdMetadata.js";
 export * from "./Run.js";
 export * from "./RunFunction.js";
+export * from "./RunFunctionEvent.js";
+export * from "./RunFunctionObserver.js";
+export * from "./RunFunctionEventSource.js";
 export * from "./Vector.js";

package/run/index.js

@@ -3,4 +3,7 @@ export * from "./DefaultRun.js";
 export * from "./IdMetadata.js";
 export * from "./Run.js";
 export * from "./RunFunction.js";
+export * from "./RunFunctionEvent.js";
+export * from "./RunFunctionObserver.js";
+export * from "./RunFunctionEventSource.js";
 export * from "./Vector.js";

package/text-chunk/SimilarTextChunksFromVectorIndexRetriever.cjs

@@ -36,7 +36,7 @@ class SimilarTextChunksFromVectorIndexRetriever {
                 run: options.run,
             });
         }
-        const { embedding } = await (0, embedText_js_1.embedText)(this.embeddingModel, query, {
+        const embedding = await (0, embedText_js_1.embedText)(this.embeddingModel, query, {
             functionId: options?.functionId,
             run: options?.run,
         });

package/text-chunk/SimilarTextChunksFromVectorIndexRetriever.js

@@ -33,7 +33,7 @@ export class SimilarTextChunksFromVectorIndexRetriever {
                 run: options.run,
             });
         }
-        const { embedding } = await embedText(this.embeddingModel, query, {
+        const embedding = await embedText(this.embeddingModel, query, {
             functionId: options?.functionId,
             run: options?.run,
         });

package/text-chunk/upsertTextChunks.cjs

@@ -5,7 +5,7 @@ const nanoid_1 = require("nanoid");
 const embedText_js_1 = require("../model-function/embed-text/embedText.cjs");
 async function upsertTextChunks({ vectorIndex, embeddingModel, generateId = nanoid_1.nanoid, chunks, ids, }, options) {
     // many embedding models support bulk embedding, so we first embed all texts:
-    const { embeddings } = await (0, embedText_js_1.embedTexts)(embeddingModel, chunks.map((chunk) => chunk.text), options);
+    const embeddings = await (0, embedText_js_1.embedTexts)(embeddingModel, chunks.map((chunk) => chunk.text), options);
     await vectorIndex.upsertMany(chunks.map((chunk, i) => ({
         id: ids?.[i] ?? generateId(),
         vector: embeddings[i],

package/text-chunk/upsertTextChunks.js

@@ -2,7 +2,7 @@ import { nanoid as createId } from "nanoid";
 import { embedTexts } from "../model-function/embed-text/embedText.js";
 export async function upsertTextChunks({ vectorIndex, embeddingModel, generateId = createId, chunks, ids, }, options) {
     // many embedding models support bulk embedding, so we first embed all texts:
-    const { embeddings } = await embedTexts(embeddingModel, chunks.map((chunk) => chunk.text), options);
+    const embeddings = await embedTexts(embeddingModel, chunks.map((chunk) => chunk.text), options);
     await vectorIndex.upsertMany(chunks.map((chunk, i) => ({
         id: ids?.[i] ?? generateId(),
         vector: embeddings[i],

package/tool/ExecuteToolEvent.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/tool/ExecuteToolEvent.d.ts

@@ -0,0 +1,22 @@
+import { RunFunctionFinishedEventMetadata, RunFunctionStartedEventMetadata } from "../run/RunFunctionEvent.js";
+import { Tool } from "./Tool.js";
+export type ExecuteToolStartedEvent = {
+    type: "execute-tool-started";
+    metadata: RunFunctionStartedEventMetadata;
+    tool: Tool<string, unknown, unknown>;
+    input: unknown;
+};
+export type ExecuteToolFinishedEvent = {
+    type: "execute-tool-finished";
+    metadata: RunFunctionFinishedEventMetadata;
+    tool: Tool<string, unknown, unknown>;
+    input: unknown;
+} & ({
+    status: "success";
+    output: unknown;
+} | {
+    status: "failure";
+    error: unknown;
+} | {
+    status: "abort";
+});

package/tool/ExecuteToolEvent.js

@@ -0,0 +1 @@
+export {};

package/{composed-function/use-tool → tool}/Tool.cjs

@@ -21,6 +21,12 @@ class Tool {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "outputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "execute", {
             enumerable: true,
             configurable: true,
@@ -30,6 +36,7 @@ class Tool {
         this.name = options.name;
         this.description = options.description;
         this.inputSchema = options.inputSchema;
+        this.outputSchema = options.outputSchema;
         this.execute = options.execute;
     }
     get inputSchemaDefinition() {

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

@@ -1,14 +1,17 @@
 import { z } from "zod";
-import { SchemaDefinition } from "../../model-function/generate-json/SchemaDefinition.js";
+import { SchemaDefinition } from "../model-function/generate-json/SchemaDefinition.js";
+import { RunFunction } from "../run/RunFunction.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>;
+    readonly outputSchema?: z.ZodSchema<OUTPUT>;
+    readonly execute: RunFunction<INPUT, OUTPUT>;
     constructor(options: {
         name: NAME;
         description: string;
         inputSchema: z.ZodSchema<INPUT>;
+        outputSchema?: z.ZodSchema<OUTPUT>;
         execute(input: INPUT): Promise<OUTPUT>;
     });
     get inputSchemaDefinition(): SchemaDefinition<NAME, INPUT>;

package/{composed-function/use-tool → tool}/Tool.js

@@ -18,6 +18,12 @@ export class Tool {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "outputSchema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "execute", {
             enumerable: true,
             configurable: true,
@@ -27,6 +33,7 @@ export class Tool {
         this.name = options.name;
         this.description = options.description;
         this.inputSchema = options.inputSchema;
+        this.outputSchema = options.outputSchema;
         this.execute = options.execute;
     }
     get inputSchemaDefinition() {

package/tool/ToolExecutionError.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutionError = void 0;
+class ToolExecutionError extends Error {
+    constructor({ message = "unknown error", toolName, input, cause, }) {
+        super(`Error executing tool ${toolName}: ${message}`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolExecutionError";
+        this.toolName = toolName;
+        this.input = input;
+        this.cause = cause;
+    }
+}
+exports.ToolExecutionError = ToolExecutionError;

package/tool/ToolExecutionError.d.ts

@@ -0,0 +1,11 @@
+export declare class ToolExecutionError extends Error {
+    readonly toolName: string;
+    readonly input: unknown;
+    readonly cause: unknown;
+    constructor({ message, toolName, input, cause, }: {
+        toolName: string;
+        input: unknown;
+        message: string | undefined;
+        cause: unknown | undefined;
+    });
+}

package/tool/ToolExecutionError.js

@@ -0,0 +1,27 @@
+export class ToolExecutionError extends Error {
+    constructor({ message = "unknown error", toolName, input, cause, }) {
+        super(`Error executing tool ${toolName}: ${message}`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ToolExecutionError";
+        this.toolName = toolName;
+        this.input = input;
+        this.cause = cause;
+    }
+}

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,20 @@
+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;
+};
+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,22 @@
+"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("./executeTool.cjs"), exports);
+__exportStar(require("./useTool.cjs"), exports);
+__exportStar(require("./useToolOrGenerateText.cjs"), exports);

package/tool/index.d.ts

@@ -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/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
+    };
+}