modelfusion 0.97.0 → 0.99.0

package/model-provider/openai/chat/AbstractOpenAIChatModel.d.ts

@@ -32,20 +32,48 @@ export interface AbstractOpenAIChatCallSettings {
             name: string;
         };
     };
-    stop?: string | string[];
-    maxTokens?: number;
+    /**
+     * `temperature`: Controls the randomness and creativity in the model's responses.
+     * A lower temperature (close to 0) results in more predictable, conservative text, while a higher temperature (close to 1) produces more varied and creative output.
+     * Adjust this to balance between consistency and creativity in the model's replies.
+     * Example: temperature: 0.5
+     */
     temperature?: number;
+    /**
+     *  This parameter sets a threshold for token selection based on probability.
+     * The model will only consider the most likely tokens that cumulatively exceed this threshold while generating a response.
+     * It's a way to control the randomness of the output, balancing between diverse responses and sticking to more likely words.
+     * This means a topP of .1 will be far less random than one at .9
+     * Example: topP: 0.2
+     */
     topP?: number;
+    /**
+     * Used to set the initial state for the random number generator in the model.
+     * Providing a specific seed value ensures consistent outputs for the same inputs across different runs - useful for testing and reproducibility.
+     * A `null` value (or not setting it) results in varied, non-repeatable outputs each time.
+     * Example: seed: 89 (or) seed: null
+     */
     seed?: number | null;
+    /**
+     * Discourages the model from repeating the same information or context already mentioned in the conversation or prompt.
+     * Increasing this value encourages the model to introduce new topics or ideas, rather than reiterating what has been said.
+     * This is useful for maintaining a diverse and engaging conversation or for brainstorming sessions where varied ideas are needed.
+     * Example: presencePenalty: 1.0 // Strongly discourages repeating the same content.
+     */
+    presencePenalty?: number;
+    /**
+     * This parameter reduces the likelihood of the model repeatedly using the same words or phrases in its responses.
+     * A higher frequency penalty promotes a wider variety of language and expressions in the output.
+     * This is particularly useful in creative writing or content generation tasks where diversity in language is desirable.
+     * Example: frequencyPenalty: 0.5 // Moderately discourages repetitive language.
+     */
+    frequencyPenalty?: number;
     responseFormat?: {
         type?: "text" | "json_object";
     };
-    n?: number;
-    presencePenalty?: number;
-    frequencyPenalty?: number;
     logitBias?: Record<number, number>;
 }
-export interface AbstractOpenAIChatSettings extends TextGenerationModelSettings, Omit<AbstractOpenAIChatCallSettings, "stop" | "maxTokens"> {
+export interface AbstractOpenAIChatSettings extends TextGenerationModelSettings, AbstractOpenAIChatCallSettings {
     isUserIdForwardingEnabled?: boolean;
 }
 export type OpenAIChatPrompt = OpenAIChatMessage[];
@@ -64,7 +92,7 @@ export declare abstract class AbstractOpenAIChatModel<SETTINGS extends AbstractO
         tools?: AbstractOpenAIChatCallSettings["tools"];
         toolChoice?: AbstractOpenAIChatCallSettings["toolChoice"];
     }): Promise<RESULT>;
-    doGenerateText(prompt: OpenAIChatPrompt, options?: FunctionOptions): Promise<{
+    doGenerateTexts(prompt: OpenAIChatPrompt, options?: FunctionOptions): Promise<{
         response: {
             object: "chat.completion";
             usage: {
@@ -98,7 +126,7 @@ export declare abstract class AbstractOpenAIChatModel<SETTINGS extends AbstractO
             }[];
             system_fingerprint?: string | null | undefined;
         };
-        text: string;
+        texts: string[];
         usage: {
             promptTokens: number;
             completionTokens: number;

package/model-provider/openai/chat/AbstractOpenAIChatModel.js

@@ -17,38 +17,67 @@ export class AbstractOpenAIChatModel extends AbstractModel {
         super({ settings });
     }
     async callAPI(messages, options) {
+        const api = this.settings.api ?? new OpenAIApiConfiguration();
+        const responseFormat = options.responseFormat;
+        const abortSignal = options.run?.abortSignal;
+        const user = this.settings.isUserIdForwardingEnabled
+            ? options.run?.userId
+            : undefined;
+        const openAIResponseFormat = this.settings.responseFormat;
+        // function & tool calling:
+        const functions = options.functions ?? this.settings.functions;
+        const functionCall = options.functionCall ?? this.settings.functionCall;
+        const tools = options.tools ?? this.settings.tools;
+        const toolChoice = options.toolChoice ?? this.settings.toolChoice;
+        let { stopSequences } = this.settings;
         return callWithRetryAndThrottle({
             retry: this.settings.api?.retry,
             throttle: this.settings.api?.throttle,
-            call: async () => callOpenAIChatCompletionAPI({
-                ...this.settings,
-                // function & tool calling:
-                functions: options.functions ?? this.settings.functions,
-                functionCall: options.functionCall ?? this.settings.functionCall,
-                tools: options.tools ?? this.settings.tools,
-                toolChoice: options.toolChoice ?? this.settings.toolChoice,
-                // map to OpenAI API names:
-                stop: this.settings.stopSequences,
-                maxTokens: this.settings.maxCompletionTokens,
-                openAIResponseFormat: this.settings.responseFormat,
-                // other settings:
-                user: this.settings.isUserIdForwardingEnabled
-                    ? options.run?.userId
-                    : undefined,
-                abortSignal: options.run?.abortSignal,
-                responseFormat: options.responseFormat,
-                messages,
-            }),
+            call: async () => {
+                // empty arrays are not allowed for stopSequences:
+                if (stopSequences != null &&
+                    Array.isArray(stopSequences) &&
+                    stopSequences.length === 0) {
+                    stopSequences = undefined;
+                }
+                return postJsonToApi({
+                    url: api.assembleUrl("/chat/completions"),
+                    headers: api.headers,
+                    body: {
+                        stream: responseFormat.stream,
+                        model: this.settings.model,
+                        messages,
+                        functions,
+                        function_call: functionCall,
+                        tools,
+                        tool_choice: toolChoice,
+                        temperature: this.settings.temperature,
+                        top_p: this.settings.topP,
+                        n: this.settings.numberOfGenerations,
+                        stop: this.settings.stopSequences,
+                        max_tokens: this.settings.maxGenerationTokens,
+                        presence_penalty: this.settings.presencePenalty,
+                        frequency_penalty: this.settings.frequencyPenalty,
+                        logit_bias: this.settings.logitBias,
+                        seed: this.settings.seed,
+                        response_format: openAIResponseFormat,
+                        user,
+                    },
+                    failedResponseHandler: failedOpenAICallResponseHandler,
+                    successfulResponseHandler: responseFormat.handler,
+                    abortSignal,
+                });
+            },
         });
     }
-    async doGenerateText(prompt, options) {
+    async doGenerateTexts(prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
             responseFormat: OpenAIChatResponseFormat.json,
         });
         return {
             response,
-            text: response.choices[0].message.content,
+            texts: response.choices.map((choice) => choice.message.content ?? ""),
             usage: this.extractUsage(response),
         };
     }
@@ -169,39 +198,6 @@ const openAIChatResponseSchema = z.object({
         total_tokens: z.number(),
     }),
 });
-async function callOpenAIChatCompletionAPI({ api = new OpenAIApiConfiguration(), abortSignal, responseFormat, model, messages, functions, functionCall, tools, toolChoice, temperature, topP, n, stop, maxTokens, presencePenalty, frequencyPenalty, logitBias, user, openAIResponseFormat, seed, }) {
-    // empty arrays are not allowed for stop:
-    if (stop != null && Array.isArray(stop) && stop.length === 0) {
-        stop = undefined;
-    }
-    return postJsonToApi({
-        url: api.assembleUrl("/chat/completions"),
-        headers: api.headers,
-        body: {
-            stream: responseFormat.stream,
-            model,
-            messages,
-            functions,
-            function_call: functionCall,
-            tools,
-            tool_choice: toolChoice,
-            temperature,
-            top_p: topP,
-            n,
-            stop,
-            max_tokens: maxTokens,
-            presence_penalty: presencePenalty,
-            frequency_penalty: frequencyPenalty,
-            logit_bias: logitBias,
-            seed,
-            response_format: openAIResponseFormat,
-            user,
-        },
-        failedResponseHandler: failedOpenAICallResponseHandler,
-        successfulResponseHandler: responseFormat.handler,
-        abortSignal,
-    });
-}
 export const OpenAIChatResponseFormat = {
     /**
      * Returns the response as a JSON object.
@@ -215,7 +211,7 @@ export const OpenAIChatResponseFormat = {
      */
     textDeltaIterable: {
         stream: true,
-        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => delta[0]?.delta.content ?? ""),
+        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => delta[0]?.delta?.content ?? ""),
     },
     structureDeltaIterable: {
         stream: true,

package/model-provider/openai/chat/OpenAIChatModel.cjs

@@ -144,7 +144,7 @@ exports.calculateOpenAIChatCostInMillicents = calculateOpenAIChatCostInMillicent
  * const model = new OpenAIChatModel({
  *   model: "gpt-3.5-turbo",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText([
@@ -196,13 +196,13 @@ class OpenAIChatModel extends AbstractOpenAIChatModel_js_1.AbstractOpenAIChatMod
     }
     get settingsForEvent() {
         const eventSettingProperties = [
+            "maxGenerationTokens",
             "stopSequences",
-            "maxCompletionTokens",
+            "numberOfGenerations",
             "functions",
             "functionCall",
             "temperature",
             "topP",
-            "n",
             "presencePenalty",
             "frequencyPenalty",
             "logitBias",

package/model-provider/openai/chat/OpenAIChatModel.d.ts

@@ -117,7 +117,7 @@ export interface OpenAIChatSettings extends TextGenerationModelSettings, Omit<Op
  * const model = new OpenAIChatModel({
  *   model: "gpt-3.5-turbo",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText([

package/model-provider/openai/chat/OpenAIChatModel.js

@@ -138,7 +138,7 @@ export const calculateOpenAIChatCostInMillicents = ({ model, response, }) => {
  * const model = new OpenAIChatModel({
  *   model: "gpt-3.5-turbo",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText([
@@ -190,13 +190,13 @@ export class OpenAIChatModel extends AbstractOpenAIChatModel {
     }
     get settingsForEvent() {
         const eventSettingProperties = [
+            "maxGenerationTokens",
             "stopSequences",
-            "maxCompletionTokens",
+            "numberOfGenerations",
             "functions",
             "functionCall",
             "temperature",
             "topP",
-            "n",
             "presencePenalty",
             "frequencyPenalty",
             "logitBias",

package/model-provider/openai/chat/OpenAIChatModel.test.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const msw_1 = require("msw");
+const node_1 = require("msw/node");
+const streamText_js_1 = require("../../../model-function/generate-text/streamText.cjs");
+const OpenAIChatModel_js_1 = require("./OpenAIChatModel.cjs");
+const OpenAIApiConfiguration_js_1 = require("../OpenAIApiConfiguration.cjs");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let responseChunks = [];
+const server = (0, node_1.setupServer)(msw_1.http.post("https://api.openai.com/v1/chat/completions", () => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                for (const chunk of responseChunks) {
+                    controller.enqueue(encoder.encode(chunk));
+                }
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+    return new msw_1.HttpResponse(stream, {
+        status: 200,
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}));
+beforeAll(() => server.listen());
+beforeEach(() => {
+    responseChunks = [];
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+describe("streamText", () => {
+    it("should return only values from the first choice when using streamText", async () => {
+        responseChunks = [
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"A"},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"content":"B"},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{},"finish_reason":"stop"}]}\n\n`,
+            "data: [DONE]\n\n",
+        ];
+        const stream = await (0, streamText_js_1.streamText)(new OpenAIChatModel_js_1.OpenAIChatModel({
+            api: new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration({ apiKey: "test" }),
+            model: "gpt-3.5-turbo",
+            numberOfGenerations: 2,
+        }).withTextPrompt(), "test prompt");
+        const chunks = [];
+        for await (const part of stream) {
+            chunks.push(part);
+        }
+        expect(chunks).toStrictEqual(["A"]);
+    });
+});

package/model-provider/openai/chat/OpenAIChatModel.test.d.ts

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

package/model-provider/openai/chat/OpenAIChatModel.test.js

@@ -0,0 +1,59 @@
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+import { streamText } from "../../../model-function/generate-text/streamText.js";
+import { OpenAIChatModel } from "./OpenAIChatModel.js";
+import { OpenAIApiConfiguration } from "../OpenAIApiConfiguration.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let responseChunks = [];
+const server = setupServer(http.post("https://api.openai.com/v1/chat/completions", () => {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                for (const chunk of responseChunks) {
+                    controller.enqueue(encoder.encode(chunk));
+                }
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+    return new HttpResponse(stream, {
+        status: 200,
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}));
+beforeAll(() => server.listen());
+beforeEach(() => {
+    responseChunks = [];
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+describe("streamText", () => {
+    it("should return only values from the first choice when using streamText", async () => {
+        responseChunks = [
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"A"},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"role":"assistant","content":""},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{"content":"B"},"finish_reason":null}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\n`,
+            `data: {"id":"chatcmpl-123","object":"chat.completion.chunk","created":1702657020,"model":"gpt-3.5-turbo-0613","system_fingerprint":null,"choices":[{"index":1,"delta":{},"finish_reason":"stop"}]}\n\n`,
+            "data: [DONE]\n\n",
+        ];
+        const stream = await streamText(new OpenAIChatModel({
+            api: new OpenAIApiConfiguration({ apiKey: "test" }),
+            model: "gpt-3.5-turbo",
+            numberOfGenerations: 2,
+        }).withTextPrompt(), "test prompt");
+        const chunks = [];
+        for await (const part of stream) {
+            chunks.push(part);
+        }
+        expect(chunks).toStrictEqual(["A"]);
+    });
+});

package/model-provider/openai/chat/OpenAIChatStreamIterable.cjs

@@ -87,18 +87,23 @@ async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaValue) {
                     continue;
                 }
                 const completionChunk = eventData;
+                // reset delta for all existing streamDeltas
+                for (const delta of streamDelta) {
+                    delta.delta = undefined;
+                }
                 for (let i = 0; i < completionChunk.choices.length; i++) {
                     const eventChoice = completionChunk.choices[i];
+                    const index = eventChoice.index;
                     const delta = eventChoice.delta;
-                    if (streamDelta[i] == null) {
-                        streamDelta[i] = {
+                    if (streamDelta[index] == null) {
+                        streamDelta[index] = {
                             role: undefined,
                             content: "",
                             isComplete: false,
                             delta,
                         };
                     }
-                    const choice = streamDelta[i];
+                    const choice = streamDelta[index];
                     choice.delta = delta;
                     if (eventChoice.finish_reason != null) {
                         choice.isComplete = true;

package/model-provider/openai/chat/OpenAIChatStreamIterable.d.ts

@@ -14,6 +14,6 @@ export type OpenAIChatDelta = Array<{
             name?: string;
             arguments?: string;
         };
-    };
+    } | undefined;
 }>;
 export declare function createOpenAIChatDeltaIterableQueue<VALUE>(stream: ReadableStream<Uint8Array>, extractDeltaValue: (delta: OpenAIChatDelta) => VALUE): Promise<AsyncIterable<Delta<VALUE>>>;

package/model-provider/openai/chat/OpenAIChatStreamIterable.js

@@ -84,18 +84,23 @@ export async function createOpenAIChatDeltaIterableQueue(stream, extractDeltaVal
                     continue;
                 }
                 const completionChunk = eventData;
+                // reset delta for all existing streamDeltas
+                for (const delta of streamDelta) {
+                    delta.delta = undefined;
+                }
                 for (let i = 0; i < completionChunk.choices.length; i++) {
                     const eventChoice = completionChunk.choices[i];
+                    const index = eventChoice.index;
                     const delta = eventChoice.delta;
-                    if (streamDelta[i] == null) {
-                        streamDelta[i] = {
+                    if (streamDelta[index] == null) {
+                        streamDelta[index] = {
                             role: undefined,
                             content: "",
                             isComplete: false,
                             delta,
                         };
                     }
-                    const choice = streamDelta[i];
+                    const choice = streamDelta[index];
                     choice.delta = delta;
                     if (eventChoice.finish_reason != null) {
                         choice.isComplete = true;

package/model-provider/openai-compatible/OpenAICompatibleChatModel.cjs

@@ -44,12 +44,12 @@ class OpenAICompatibleChatModel extends AbstractOpenAIChatModel_js_1.AbstractOpe
     get settingsForEvent() {
         const eventSettingProperties = [
             "stopSequences",
-            "maxCompletionTokens",
+            "maxGenerationTokens",
+            "numberOfGenerations",
             "functions",
             "functionCall",
             "temperature",
             "topP",
-            "n",
             "presencePenalty",
             "frequencyPenalty",
             "logitBias",

package/model-provider/openai-compatible/OpenAICompatibleChatModel.js

@@ -41,12 +41,12 @@ export class OpenAICompatibleChatModel extends AbstractOpenAIChatModel {
     get settingsForEvent() {
         const eventSettingProperties = [
             "stopSequences",
-            "maxCompletionTokens",
+            "maxGenerationTokens",
+            "numberOfGenerations",
             "functions",
             "functionCall",
             "temperature",
             "topP",
-            "n",
             "presencePenalty",
             "frequencyPenalty",
             "logitBias",

package/model-provider/openai-compatible/OpenAICompatibleFacade.cjs

@@ -14,7 +14,7 @@ const OpenAICompatibleChatModel_js_1 = require("./OpenAICompatibleChatModel.cjs"
  * const model = openaicompatible.ChatTextGenerator({
  *   model: "provider-specific-model-name",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText([

package/model-provider/openai-compatible/OpenAICompatibleFacade.d.ts

@@ -11,7 +11,7 @@ import { OpenAICompatibleChatModel, OpenAICompatibleChatSettings } from "./OpenA
  * const model = openaicompatible.ChatTextGenerator({
  *   model: "provider-specific-model-name",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText([

package/model-provider/openai-compatible/OpenAICompatibleFacade.js

@@ -11,7 +11,7 @@ import { OpenAICompatibleChatModel, } from "./OpenAICompatibleChatModel.js";
  * const model = openaicompatible.ChatTextGenerator({
  *   model: "provider-specific-model-name",
  *   temperature: 0.7,
- *   maxCompletionTokens: 500,
+ *   maxGenerationTokens: 500,
  * });
  *
  * const text = await generateText([

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "The TypeScript library for building multi-modal AI applications.",
-  "version": "0.97.0",
+  "version": "0.99.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/tool/execute-tool/executeTool.cjs

@@ -13,7 +13,7 @@ const ToolExecutionError_js_1 = require("../ToolExecutionError.cjs");
 async function executeTool(// eslint-disable-line @typescript-eslint/no-explicit-any
 tool, args, options) {
     const fullResponse = await doExecuteTool(tool, args, options);
-    return options?.returnType === "full" ? fullResponse : fullResponse.output;
+    return options?.fullResponse ? fullResponse : fullResponse.output;
 }
 exports.executeTool = executeTool;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/tool/execute-tool/executeTool.d.ts

@@ -15,11 +15,11 @@ export type ExecuteToolMetadata = {
  */
 export declare function executeTool<TOOL extends Tool<any, any, any>>(// eslint-disable-line @typescript-eslint/no-explicit-any
 tool: TOOL, args: TOOL["parameters"]["_type"], options?: FunctionOptions & {
-    returnType?: "output";
+    fullResponse?: false;
 }): Promise<ReturnType<TOOL["execute"]>>;
 export declare function executeTool<TOOL extends Tool<any, any, any>>(// eslint-disable-line @typescript-eslint/no-explicit-any
 tool: TOOL, args: TOOL["parameters"]["_type"], options: FunctionOptions & {
-    returnType: "full";
+    fullResponse: true;
 }): Promise<{
     output: Awaited<ReturnType<TOOL["execute"]>>;
     metadata: ExecuteToolMetadata;

package/tool/execute-tool/executeTool.js

@@ -10,7 +10,7 @@ import { ToolExecutionError } from "../ToolExecutionError.js";
 export async function executeTool(// eslint-disable-line @typescript-eslint/no-explicit-any
 tool, args, options) {
     const fullResponse = await doExecuteTool(tool, args, options);
-    return options?.returnType === "full" ? fullResponse : fullResponse.output;
+    return options?.fullResponse ? fullResponse : fullResponse.output;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function doExecuteTool(tool, args, options) {

package/tool/generate-tool-call/TextGenerationToolCallModel.cjs

@@ -30,21 +30,21 @@ class TextGenerationToolCallModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCall(tool, prompt, options) {
-        const { response, value, metadata } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, tool), {
+        const { response, text, metadata } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, tool), {
             ...options,
-            returnType: "full",
+            fullResponse: true,
         });
         try {
             return {
                 response,
-                toolCall: this.format.extractToolCall(value),
+                toolCall: this.format.extractToolCall(text),
                 usage: metadata?.usage,
             };
         }
         catch (error) {
             throw new ToolCallParseError_js_1.ToolCallParseError({
                 toolName: tool.name,
-                valueText: value,
+                valueText: text,
                 cause: error,
             });
         }

package/tool/generate-tool-call/TextGenerationToolCallModel.js

@@ -27,21 +27,21 @@ export class TextGenerationToolCallModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCall(tool, prompt, options) {
-        const { response, value, metadata } = await generateText(this.model, this.format.createPrompt(prompt, tool), {
+        const { response, text, metadata } = await generateText(this.model, this.format.createPrompt(prompt, tool), {
             ...options,
-            returnType: "full",
+            fullResponse: true,
         });
         try {
             return {
                 response,
-                toolCall: this.format.extractToolCall(value),
+                toolCall: this.format.extractToolCall(text),
                 usage: metadata?.usage,
             };
         }
         catch (error) {
             throw new ToolCallParseError({
                 toolName: tool.name,
-                valueText: value,
+                valueText: text,
                 cause: error,
             });
         }

package/tool/generate-tool-call/generateToolCall.cjs

@@ -54,6 +54,12 @@ async function generateToolCall(model, tool, prompt, options) {
             }
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse
+        ? {
+            toolCall: fullResponse.value,
+            response: fullResponse.response,
+            metadata: fullResponse.metadata,
+        }
+        : fullResponse.value;
 }
 exports.generateToolCall = generateToolCall;