modelfusion 0.19.0 → 0.20.1

package/model-function/generate-text/generateText.cjs

@@ -2,10 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateText = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
-async function generateText(
+/**
+ * Generates a text using a prompt.
+ * The prompt format depends on the model.
+ * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
+ *
+ * @example
+ * const model = new OpenAITextGenerationModel(...);
+ *
+ * const text = await model.generateText(
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+function generateText(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 model, prompt, options) {
-    const result = await (0, executeCall_js_1.executeCall)({
+    return (0, executeCall_js_1.executeCall)({
         model,
         options,
         generateResponse: (options) => model.generateTextResponse(prompt, options),
@@ -46,12 +58,5 @@ model, prompt, options) {
             generatedText: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            text: result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }
 exports.generateText = generateText;

package/model-function/generate-text/generateText.d.ts

@@ -1,5 +1,5 @@
 import { FunctionOptions } from "../FunctionOptions.js";
-import { CallMetadata } from "../executeCall.js";
+import { ModelFunctionPromise } from "../executeCall.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
 /**
  * Generates a text using a prompt.
@@ -13,13 +13,4 @@ import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerati
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-export declare function generateText<PROMPT, RESPONSE, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, prompt: PROMPT, options: FunctionOptions<SETTINGS> & {
-    fullResponse: true;
-}): Promise<{
-    text: string;
-    response: RESPONSE;
-    metadata: CallMetadata<TextGenerationModel<PROMPT, RESPONSE, unknown, SETTINGS>>;
-}>;
-export declare function generateText<PROMPT, RESPONSE, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, prompt: PROMPT, options?: FunctionOptions<SETTINGS> & {
-    fullResponse?: false;
-}): Promise<string>;
+export declare function generateText<PROMPT, RESPONSE, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, prompt: PROMPT, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, string, RESPONSE>;

package/model-function/generate-text/generateText.js

@@ -1,8 +1,20 @@
 import { executeCall } from "../executeCall.js";
-export async function generateText(
+/**
+ * Generates a text using a prompt.
+ * The prompt format depends on the model.
+ * For example, OpenAI text models expect a string prompt, and OpenAI chat models expect an array of chat messages.
+ *
+ * @example
+ * const model = new OpenAITextGenerationModel(...);
+ *
+ * const text = await model.generateText(
+ *   "Write a short story about a robot learning to love:\n\n"
+ * );
+ */
+export function generateText(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 model, prompt, options) {
-    const result = await executeCall({
+    return executeCall({
         model,
         options,
         generateResponse: (options) => model.generateTextResponse(prompt, options),
@@ -43,11 +55,4 @@ model, prompt, options) {
             generatedText: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            text: result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }

package/model-function/generate-text/streamText.cjs

@@ -1,13 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamText = void 0;
+exports.streamText = exports.StreamTextPromise = 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 extractTextDeltas_js_1 = require("./extractTextDeltas.cjs");
-async function streamText(model, prompt, options) {
+class StreamTextPromise 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);
+    }
+}
+exports.StreamTextPromise = StreamTextPromise;
+function streamText(model, prompt, options) {
+    return new StreamTextPromise(doStreamText(model, prompt, options));
+}
+exports.streamText = streamText;
+async function doStreamText(model, prompt, options) {
     if (options?.settings != null) {
         model = model.withSettings(options.settings);
         options = {
@@ -107,11 +145,8 @@ async function streamText(model, prompt, options) {
         });
         throw result.error;
     }
-    return options?.fullResponse === true
-        ? {
-            textStream: result.output,
-            metadata: startMetadata,
-        }
-        : result.output;
+    return {
+        output: result.output,
+        metadata: startMetadata,
+    };
 }
-exports.streamText = streamText;

package/model-function/generate-text/streamText.d.ts

@@ -2,18 +2,22 @@ import { FunctionOptions } from "../FunctionOptions.js";
 import { CallMetadata } from "../executeCall.js";
 import { DeltaEvent } from "./DeltaEvent.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
+export declare class StreamTextPromise<PROMPT, FULL_DELTA, SETTINGS extends TextGenerationModelSettings> extends Promise<AsyncIterable<string>> {
+    private fullPromise;
+    private outputPromise;
+    constructor(fullPromise: Promise<{
+        output: AsyncIterable<string>;
+        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs">;
+    }>);
+    asFullResponse(): Promise<{
+        output: AsyncIterable<string>;
+        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs">;
+    }>;
+    then<TResult1 = AsyncIterable<string>, TResult2 = never>(onfulfilled?: ((value: AsyncIterable<string>) => 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<AsyncIterable<string> | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<AsyncIterable<string>>;
+}
 export declare function streamText<PROMPT, FULL_DELTA, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS> & {
     generateDeltaStreamResponse: (prompt: PROMPT, options: FunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
     extractTextDelta: (fullDelta: FULL_DELTA) => string | undefined;
-}, prompt: PROMPT, options?: FunctionOptions<SETTINGS> & {
-    fullResponse?: false;
-}): Promise<AsyncIterable<string>>;
-export declare function streamText<PROMPT, FULL_DELTA, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS> & {
-    generateDeltaStreamResponse: (prompt: PROMPT, options: FunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
-    extractTextDelta: (fullDelta: FULL_DELTA) => string | undefined;
-}, prompt: PROMPT, options: FunctionOptions<SETTINGS> & {
-    fullResponse: true;
-}): Promise<{
-    textStream: AsyncIterable<string>;
-    metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs">;
-}>;
+}, prompt: PROMPT, options?: FunctionOptions<SETTINGS>): StreamTextPromise<PROMPT, FULL_DELTA, SETTINGS>;

package/model-function/generate-text/streamText.js

@@ -4,7 +4,43 @@ import { startDurationMeasurement } from "../../util/DurationMeasurement.js";
 import { AbortError } from "../../util/api/AbortError.js";
 import { runSafe } from "../../util/runSafe.js";
 import { extractTextDeltas } from "./extractTextDeltas.js";
-export async function streamText(model, prompt, options) {
+export class StreamTextPromise 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);
+    }
+}
+export function streamText(model, prompt, options) {
+    return new StreamTextPromise(doStreamText(model, prompt, options));
+}
+async function doStreamText(model, prompt, options) {
     if (options?.settings != null) {
         model = model.withSettings(options.settings);
         options = {
@@ -104,10 +140,8 @@ export async function streamText(model, prompt, options) {
         });
         throw result.error;
     }
-    return options?.fullResponse === true
-        ? {
-            textStream: result.output,
-            metadata: startMetadata,
-        }
-        : result.output;
+    return {
+        output: result.output,
+        metadata: startMetadata,
+    };
 }

package/model-function/synthesize-speech/synthesizeSpeech.cjs

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.synthesizeSpeech = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
-async function synthesizeSpeech(model, text, options) {
-    const result = await (0, executeCall_js_1.executeCall)({
+/**
+ * Synthesizes speech from text.
+ */
+function synthesizeSpeech(model, text, options) {
+    return (0, executeCall_js_1.executeCall)({
         model,
         options,
         generateResponse: (options) => model.generateSpeechResponse(text, options),
@@ -39,11 +42,5 @@ async function synthesizeSpeech(model, text, options) {
             speech: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            speech: result.output,
-            metadata: result.metadata,
-        }
-        : result.output;
 }
 exports.synthesizeSpeech = synthesizeSpeech;

package/model-function/synthesize-speech/synthesizeSpeech.d.ts

@@ -1,16 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import { FunctionOptions } from "../FunctionOptions.js";
-import { CallMetadata } from "../executeCall.js";
+import { ModelFunctionPromise } from "../executeCall.js";
 import { SpeechSynthesisModel, SpeechSynthesisModelSettings } from "./SpeechSynthesisModel.js";
 /**
  * Synthesizes speech from text.
  */
-export declare function synthesizeSpeech<SETTINGS extends SpeechSynthesisModelSettings>(model: SpeechSynthesisModel<SETTINGS>, text: string, options: FunctionOptions<SETTINGS> & {
-    fullResponse: true;
-}): Promise<{
-    speech: Buffer;
-    metadata: CallMetadata<SpeechSynthesisModel<SETTINGS>>;
-}>;
-export declare function synthesizeSpeech<SETTINGS extends SpeechSynthesisModelSettings>(model: SpeechSynthesisModel<SETTINGS>, text: string, options?: FunctionOptions<SETTINGS> & {
-    fullResponse?: false;
-}): Promise<Buffer>;
+export declare function synthesizeSpeech<SETTINGS extends SpeechSynthesisModelSettings>(model: SpeechSynthesisModel<SETTINGS>, text: string, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<SpeechSynthesisModel<SETTINGS>, Buffer, Buffer>;

package/model-function/synthesize-speech/synthesizeSpeech.js

@@ -1,6 +1,9 @@
 import { executeCall } from "../executeCall.js";
-export async function synthesizeSpeech(model, text, options) {
-    const result = await executeCall({
+/**
+ * Synthesizes speech from text.
+ */
+export function synthesizeSpeech(model, text, options) {
+    return executeCall({
         model,
         options,
         generateResponse: (options) => model.generateSpeechResponse(text, options),
@@ -36,10 +39,4 @@ export async function synthesizeSpeech(model, text, options) {
             speech: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            speech: result.output,
-            metadata: result.metadata,
-        }
-        : result.output;
 }

package/model-function/transcribe-speech/transcribe.cjs

@@ -2,8 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transcribe = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
-async function transcribe(model, data, options) {
-    const result = await (0, executeCall_js_1.executeCall)({
+/**
+ * Transcribe audio data into text.
+ *
+ * @example
+ * const data = await fs.promises.readFile("data/test.mp3");
+ *
+ * const transcription = await transcribe(
+ *   new OpenAITranscriptionModel({ model: "whisper-1" }),
+ *   {
+ *     type: "mp3",
+ *     data,
+ *   }
+ * );
+ */
+function transcribe(model, data, options) {
+    return (0, executeCall_js_1.executeCall)({
         model,
         options,
         generateResponse: (options) => model.generateTranscriptionResponse(data, options),
@@ -39,12 +53,5 @@ async function transcribe(model, data, options) {
             transcription: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            transcription: result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }
 exports.transcribe = transcribe;

package/model-function/transcribe-speech/transcribe.d.ts

@@ -1,5 +1,5 @@
 import { FunctionOptions } from "../FunctionOptions.js";
-import { CallMetadata } from "../executeCall.js";
+import { ModelFunctionPromise } from "../executeCall.js";
 import { TranscriptionModel, TranscriptionModelSettings } from "./TranscriptionModel.js";
 /**
  * Transcribe audio data into text.
@@ -15,13 +15,4 @@ import { TranscriptionModel, TranscriptionModelSettings } from "./TranscriptionM
  *   }
  * );
  */
-export declare function transcribe<DATA, RESPONSE, SETTINGS extends TranscriptionModelSettings>(model: TranscriptionModel<DATA, RESPONSE, SETTINGS>, data: DATA, options: FunctionOptions<SETTINGS> & {
-    fullResponse: true;
-}): Promise<{
-    transcription: string;
-    response: RESPONSE;
-    metadata: CallMetadata<TranscriptionModel<DATA, RESPONSE, SETTINGS>>;
-}>;
-export declare function transcribe<DATA, RESPONSE, SETTINGS extends TranscriptionModelSettings>(model: TranscriptionModel<DATA, RESPONSE, SETTINGS>, data: DATA, options?: FunctionOptions<SETTINGS> & {
-    fullResponse?: false;
-}): Promise<string>;
+export declare function transcribe<DATA, RESPONSE, SETTINGS extends TranscriptionModelSettings>(model: TranscriptionModel<DATA, RESPONSE, SETTINGS>, data: DATA, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<TranscriptionModel<DATA, RESPONSE, SETTINGS>, string, RESPONSE>;

package/model-function/transcribe-speech/transcribe.js

@@ -1,6 +1,20 @@
 import { executeCall } from "../executeCall.js";
-export async function transcribe(model, data, options) {
-    const result = await executeCall({
+/**
+ * Transcribe audio data into text.
+ *
+ * @example
+ * const data = await fs.promises.readFile("data/test.mp3");
+ *
+ * const transcription = await transcribe(
+ *   new OpenAITranscriptionModel({ model: "whisper-1" }),
+ *   {
+ *     type: "mp3",
+ *     data,
+ *   }
+ * );
+ */
+export function transcribe(model, data, options) {
+    return executeCall({
         model,
         options,
         generateResponse: (options) => model.generateTranscriptionResponse(data, options),
@@ -36,11 +50,4 @@ export async function transcribe(model, data, options) {
             transcription: output,
         }),
     });
-    return options?.fullResponse === true
-        ? {
-            transcription: result.output,
-            response: result.response,
-            metadata: result.metadata,
-        }
-        : result.output;
 }

package/model-provider/cohere/CohereTextEmbeddingModel.d.ts

@@ -64,13 +64,13 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
     callAPI(texts: Array<string>, options?: FunctionOptions<CohereTextEmbeddingModelSettings>): Promise<CohereTextEmbeddingResponse>;
     generateEmbeddingResponse(texts: string[], options?: FunctionOptions<CohereTextEmbeddingModelSettings>): Promise<{
         texts: string[];
-        embeddings: number[][];
         id: string;
         meta: {
             api_version: {
                 version: string;
             };
         };
+        embeddings: number[][];
     }>;
     extractEmbeddings(response: CohereTextEmbeddingResponse): number[][];
     withSettings(additionalSettings: Partial<CohereTextEmbeddingModelSettings>): this;
@@ -98,22 +98,22 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
     }>;
 }, "strip", z.ZodTypeAny, {
     texts: string[];
-    embeddings: number[][];
     id: string;
     meta: {
         api_version: {
             version: string;
         };
     };
+    embeddings: number[][];
 }, {
     texts: string[];
-    embeddings: number[][];
     id: string;
     meta: {
         api_version: {
             version: string;
         };
     };
+    embeddings: number[][];
 }>;
 export type CohereTextEmbeddingResponse = z.infer<typeof cohereTextEmbeddingResponseSchema>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build AI applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/run/RunFunctionEvent.d.ts

@@ -1,4 +1,4 @@
-import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "tool/ExecuteToolEvent.js";
+import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/ExecuteToolEvent.js";
 import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
 import { IdMetadata } from "./IdMetadata.js";
 export type RunFunctionEvent = RunFunctionStartedEvent | RunFunctionFinishedEvent;

package/tool/executeTool.cjs

@@ -1,14 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeTool = void 0;
+exports.executeTool = exports.ExecuteToolPromise = 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");
+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);
+    }
+}
+exports.ExecuteToolPromise = ExecuteToolPromise;
+/**
+ * `executeTool` directly executes a tool with the given parameters.
+ */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function executeTool(tool, input, options) {
+function executeTool(tool, input, options) {
+    return new ExecuteToolPromise(doExecuteTool(tool, input, options));
+}
+exports.executeTool = executeTool;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function doExecuteTool(tool, input, options) {
     const run = options?.run;
     const eventSource = new RunFunctionEventSource_js_1.RunFunctionEventSource({
         observers: run?.observers ?? [],
@@ -70,11 +112,8 @@ async function executeTool(tool, input, options) {
         input,
         output,
     });
-    return options?.fullResponse === true
-        ? {
-            output,
-            metadata: finishMetadata,
-        }
-        : output;
+    return {
+        output,
+        metadata: finishMetadata,
+    };
 }
-exports.executeTool = executeTool;

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/index.cjs

@@ -14,6 +14,7 @@ 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("./ExecuteToolEvent.cjs"), exports);
 __exportStar(require("./InvalidToolNameError.cjs"), exports);
 __exportStar(require("./NoSuchToolError.cjs"), exports);
 __exportStar(require("./Tool.cjs"), exports);