modelfusion 0.97.0 → 0.98.0

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

@@ -74,6 +74,7 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
     get settingsForEvent(): Partial<CohereTextEmbeddingModelSettings>;
     doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
         response: {
+            embeddings: number[][];
             id: string;
             meta: {
                 api_version: {
@@ -81,7 +82,6 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
                 };
             };
             texts: string[];
-            embeddings: number[][];
         };
         embeddings: number[][];
     }>;
@@ -109,6 +109,7 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     }>;
 }, "strip", z.ZodTypeAny, {
+    embeddings: number[][];
     id: string;
     meta: {
         api_version: {
@@ -116,8 +117,8 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     };
     texts: string[];
-    embeddings: number[][];
 }, {
+    embeddings: number[][];
     id: string;
     meta: {
         api_version: {
@@ -125,7 +126,6 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     };
     texts: string[];
-    embeddings: number[][];
 }>;
 export type CohereTextEmbeddingResponse = z.infer<typeof cohereTextEmbeddingResponseSchema>;
 export {};

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

@@ -219,7 +219,7 @@ exports.OpenAIChatResponseFormat = {
      */
     textDeltaIterable: {
         stream: true,
-        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => delta[0]?.delta.content ?? ""),
+        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => delta[0]?.delta?.content ?? ""),
     },
     structureDeltaIterable: {
         stream: true,

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

@@ -32,16 +32,65 @@ export interface AbstractOpenAIChatCallSettings {
             name: string;
         };
     };
+    /**
+     * An array of strings or a single string that the model will recognize as end-of-text indicators.
+     * The model stops generating more content when it encounters any of these strings.
+     * This is particularly useful in scripted or formatted text generation, where a specific end point is required.
+     * Example: stop: ['\n', 'END']
+     */
     stop?: string | string[];
+    /**
+     * Specifies the maximum number of tokens (words, punctuation, parts of words) that the model can generate in a single response.
+     * It helps to control the length of the output, this can help prevent wasted time and tokens when tweaker topP or temperature.
+     * Example: maxTokens: 1000
+     */
     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;
     responseFormat?: {
         type?: "text" | "json_object";
     };
+    /**
+     * Specifies the number of responses or completions the model should generate for a given prompt.
+     * This is useful when you need multiple different outputs or ideas for a single prompt.
+     * The model will generate 'n' distinct responses, each based on the same initial prompt.
+     * In a streaming model this will result in both responses streamed back in real time.
+     * Example: n: 3 // The model will produce 3 different responses.
+     */
     n?: number;
+    /**
+     * 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;
     logitBias?: Record<number, number>;
 }

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

@@ -215,7 +215,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.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",
+            n: 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",
+            n: 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "The TypeScript library for building multi-modal AI applications.",
-  "version": "0.97.0",
+  "version": "0.98.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;

package/tool/generate-tool-call/generateToolCall.d.ts

@@ -4,12 +4,12 @@ import { ToolCall } from "../ToolCall.js";
 import { ToolDefinition } from "../ToolDefinition.js";
 import { ToolCallGenerationModel, ToolCallGenerationModelSettings } from "./ToolCallGenerationModel.js";
 export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(model: ToolCallGenerationModel<PROMPT, SETTINGS>, tool: ToolDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolDefinition<NAME, PARAMETERS>) => PROMPT), options?: FunctionOptions & {
-    returnType?: "structure";
+    fullResponse?: false;
 }): Promise<ToolCall<NAME, PARAMETERS>>;
 export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(model: ToolCallGenerationModel<PROMPT, SETTINGS>, tool: ToolDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolDefinition<NAME, PARAMETERS>) => PROMPT), options: FunctionOptions & {
-    returnType: "full";
+    fullResponse: true;
 }): Promise<{
-    value: ToolCall<NAME, PARAMETERS>;
+    toolCall: ToolCall<NAME, PARAMETERS>;
     response: unknown;
     metadata: ModelCallMetadata;
 }>;

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

@@ -51,5 +51,11 @@ export 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;
 }

package/tool/generate-tool-calls-or-text/TextGenerationToolCallsOrGenerateTextModel.cjs

@@ -30,12 +30,12 @@ class TextGenerationToolCallsOrGenerateTextModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCallsOrText(tools, prompt, options) {
-        const { response, value, metadata } = await (0, generateText_js_1.generateText)(this.model, this.template.createPrompt(prompt, tools), {
+        const { response, text: generatedText, metadata, } = await (0, generateText_js_1.generateText)(this.model, this.template.createPrompt(prompt, tools), {
             ...options,
-            returnType: "full",
+            fullResponse: true,
         });
         try {
-            const { text, toolCalls } = this.template.extractToolCallsAndText(value);
+            const { text, toolCalls } = this.template.extractToolCallsAndText(generatedText);
             return {
                 response,
                 text,
@@ -45,7 +45,7 @@ class TextGenerationToolCallsOrGenerateTextModel {
         }
         catch (error) {
             throw new ToolCallsOrTextParseError_js_1.ToolCallsOrTextParseError({
-                valueText: value,
+                valueText: generatedText,
                 cause: error,
             });
         }

package/tool/generate-tool-calls-or-text/TextGenerationToolCallsOrGenerateTextModel.js

@@ -27,12 +27,12 @@ export class TextGenerationToolCallsOrGenerateTextModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCallsOrText(tools, prompt, options) {
-        const { response, value, metadata } = await generateText(this.model, this.template.createPrompt(prompt, tools), {
+        const { response, text: generatedText, metadata, } = await generateText(this.model, this.template.createPrompt(prompt, tools), {
             ...options,
-            returnType: "full",
+            fullResponse: true,
         });
         try {
-            const { text, toolCalls } = this.template.extractToolCallsAndText(value);
+            const { text, toolCalls } = this.template.extractToolCallsAndText(generatedText);
             return {
                 response,
                 text,
@@ -42,7 +42,7 @@ export class TextGenerationToolCallsOrGenerateTextModel {
         }
         catch (error) {
             throw new ToolCallsOrTextParseError({
-                valueText: value,
+                valueText: generatedText,
                 cause: error,
             });
         }

package/tool/generate-tool-calls-or-text/generateToolCallsOrText.cjs

@@ -58,6 +58,6 @@ async function generateToolCallsOrText(model, tools, prompt, options) {
             };
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse ? fullResponse : fullResponse.value;
 }
 exports.generateToolCallsOrText = generateToolCallsOrText;

package/tool/generate-tool-calls-or-text/generateToolCallsOrText.d.ts

@@ -15,13 +15,13 @@ type ToToolCallUnion<T> = {
 }[keyof T];
 type ToOutputValue<TOOL_CALLS extends ToolCallDefinitionArray<ToolDefinition<any, any>[]>> = ToToolCallUnion<ToToolCallDefinitionMap<TOOL_CALLS>>;
 export declare function generateToolCallsOrText<TOOLS extends Array<ToolDefinition<any, any>>, PROMPT>(model: ToolCallsOrTextGenerationModel<PROMPT, ToolCallsOrTextGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options?: FunctionOptions & {
-    returnType?: "structure";
+    fullResponse?: false;
 }): Promise<{
     text: string | null;
     toolCalls: Array<ToOutputValue<TOOLS>> | null;
 }>;
 export declare function generateToolCallsOrText<TOOLS extends ToolDefinition<any, any>[], PROMPT>(model: ToolCallsOrTextGenerationModel<PROMPT, ToolCallsOrTextGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options: FunctionOptions & {
-    returnType?: "full";
+    fullResponse?: boolean;
 }): Promise<{
     value: {
         text: string | null;

package/tool/generate-tool-calls-or-text/generateToolCallsOrText.js

@@ -55,5 +55,5 @@ export async function generateToolCallsOrText(model, tools, prompt, options) {
             };
         },
     });
-    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+    return options?.fullResponse ? fullResponse : fullResponse.value;
 }

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.cjs

@@ -15,7 +15,7 @@ async function useToolsOrGenerateText(model, tools, prompt, options) {
         input: expandedPrompt,
         functionType: "use-tools-or-generate-text",
         execute: async (options) => {
-            const modelResponse = await (0, generateToolCallsOrText_js_1.generateToolCallsOrText)(model, tools, expandedPrompt, { ...options, returnType: "structure" });
+            const modelResponse = await (0, generateToolCallsOrText_js_1.generateToolCallsOrText)(model, tools, expandedPrompt, { ...options, fullResponse: false });
             const { toolCalls, text } = modelResponse;
             // no tool calls:
             if (toolCalls == null) {

package/tool/use-tools-or-generate-text/useToolsOrGenerateText.js

@@ -12,7 +12,7 @@ export async function useToolsOrGenerateText(model, tools, prompt, options) {
         input: expandedPrompt,
         functionType: "use-tools-or-generate-text",
         execute: async (options) => {
-            const modelResponse = await generateToolCallsOrText(model, tools, expandedPrompt, { ...options, returnType: "structure" });
+            const modelResponse = await generateToolCallsOrText(model, tools, expandedPrompt, { ...options, fullResponse: false });
             const { toolCalls, text } = modelResponse;
             // no tool calls:
             if (toolCalls == null) {