modelfusion 0.18.0 → 0.20.0

package/tool/executeTool.d.ts

@@ -10,15 +10,22 @@ export type ExecuteToolMetadata = {
     startEpochSeconds: number;
     durationInMs: number;
 };
+export declare class ExecuteToolPromise<OUTPUT> extends Promise<OUTPUT> {
+    private fullPromise;
+    private outputPromise;
+    constructor(fullPromise: Promise<{
+        output: OUTPUT;
+        metadata: ExecuteToolMetadata;
+    }>);
+    asFullResponse(): Promise<{
+        output: OUTPUT;
+        metadata: ExecuteToolMetadata;
+    }>;
+    then<TResult1 = OUTPUT, TResult2 = never>(onfulfilled?: ((value: OUTPUT) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<OUTPUT | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<OUTPUT>;
+}
 /**
  * `executeTool` directly executes a tool with the given parameters.
  */
-export declare function executeTool<TOOL extends Tool<any, any, any>>(tool: TOOL, input: z.infer<TOOL["inputSchema"]>, options: FunctionOptions<undefined> & {
-    fullResponse: true;
-}): Promise<{
-    output: Awaited<ReturnType<TOOL["execute"]>>;
-    metadata: ExecuteToolMetadata;
-}>;
-export declare function executeTool<TOOL extends Tool<any, any, any>>(tool: TOOL, input: z.infer<TOOL["inputSchema"]>, options?: FunctionOptions<undefined> & {
-    fullResponse?: false;
-}): Promise<ReturnType<TOOL["execute"]>>;
+export declare function executeTool<TOOL extends Tool<any, any, any>>(tool: TOOL, input: z.infer<TOOL["inputSchema"]>, options?: FunctionOptions<undefined>): ExecuteToolPromise<ReturnType<TOOL["execute"]>>;

package/tool/executeTool.js

@@ -4,8 +4,48 @@ 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 class ExecuteToolPromise extends Promise {
+    constructor(fullPromise) {
+        super((resolve) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            resolve(null); // we override the resolve function
+        });
+        Object.defineProperty(this, "fullPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fullPromise
+        });
+        Object.defineProperty(this, "outputPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.outputPromise = fullPromise.then((result) => result.output);
+    }
+    asFullResponse() {
+        return this.fullPromise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.outputPromise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.outputPromise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.outputPromise.finally(onfinally);
+    }
+}
+/**
+ * `executeTool` directly executes a tool with the given parameters.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function executeTool(tool, input, options) {
+    return new ExecuteToolPromise(doExecuteTool(tool, input, options));
+}
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export async function executeTool(tool, input, options) {
+async function doExecuteTool(tool, input, options) {
     const run = options?.run;
     const eventSource = new RunFunctionEventSource({
         observers: run?.observers ?? [],
@@ -67,10 +107,8 @@ export async function executeTool(tool, input, options) {
         input,
         output,
     });
-    return options?.fullResponse === true
-        ? {
-            output,
-            metadata: finishMetadata,
-        }
-        : output;
+    return {
+        output,
+        metadata: finishMetadata,
+    };
 }

package/tool/useTool.cjs

@@ -14,14 +14,13 @@ const executeTool_js_1 = require("./executeTool.cjs");
  * 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, {
+    const { output: value } = await (0, generateJson_js_1.generateJson)(model, {
         name: tool.name,
         description: tool.description,
         schema: tool.inputSchema,
     }, () => prompt(tool), {
         ...(options ?? {}),
-        fullResponse: true,
-    });
+    }).asFullResponse();
     return {
         tool: tool.name,
         parameters: value,

package/tool/useTool.js

@@ -11,14 +11,13 @@ import { executeTool } from "./executeTool.js";
  * and the result of the tool execution (`result` property, typed).
  */
 export async function useTool(model, tool, prompt, options) {
-    const { value } = await generateJson(model, {
+    const { output: value } = await generateJson(model, {
         name: tool.name,
         description: tool.description,
         schema: tool.inputSchema,
     }, () => prompt(tool), {
         ...(options ?? {}),
-        fullResponse: true,
-    });
+    }).asFullResponse();
     return {
         tool: tool.name,
         parameters: value,