modelfusion 0.69.0 → 0.71.0

package/model-function/generate-text/prompt-format/trimChatPrompt.cjs

@@ -15,39 +15,34 @@ const validateChatPrompt_js_1 = require("./validateChatPrompt.cjs");
 async function trimChatPrompt({ prompt, model, tokenLimit = model.contextWindowSize -
     (model.settings.maxCompletionTokens ?? model.contextWindowSize / 4), }) {
     (0, validateChatPrompt_js_1.validateChatPrompt)(prompt);
-    const startsWithSystemMessage = "system" in prompt[0];
-    const systemMessage = startsWithSystemMessage ? [prompt[0]] : [];
-    let messages = [];
-    // add the last message (final user message) to the prompt
-    messages.push(prompt[prompt.length - 1]);
+    let minimalPrompt = {
+        system: prompt.system,
+        messages: [prompt.messages[prompt.messages.length - 1]], // last user message
+    };
     // check if the minimal prompt is already too long
-    const promptTokenCount = await model.countPromptTokens([
-        ...systemMessage,
-        ...messages,
-    ]);
+    const promptTokenCount = await model.countPromptTokens(minimalPrompt);
     // the minimal chat prompt is already over the token limit and cannot be trimmed further:
     if (promptTokenCount > tokenLimit) {
-        return [...systemMessage, prompt[prompt.length - 1]];
+        return minimalPrompt;
     }
     // inner messages
-    const innerMessages = prompt.slice(startsWithSystemMessage ? 1 : 0, -1);
+    const innerMessages = prompt.messages.slice(0, -1);
     // taking always a pair of user-message and ai-message from the end, moving backwards
     for (let i = innerMessages.length - 1; i >= 0; i -= 2) {
-        const aiMessage = innerMessages[i];
+        const assistantMessage = innerMessages[i];
         const userMessage = innerMessages[i - 1];
-        // create a temporary array and check if it fits within the token limit
-        const tokenCount = await model.countPromptTokens([
-            ...systemMessage,
-            userMessage,
-            aiMessage,
-            ...messages,
-        ]);
+        // create a temporary prompt and check if it fits within the token limit
+        const attemptedPrompt = {
+            system: prompt.system,
+            messages: [userMessage, assistantMessage, ...minimalPrompt.messages],
+        };
+        const tokenCount = await model.countPromptTokens(attemptedPrompt);
         if (tokenCount > tokenLimit) {
             break;
         }
-        // if it fits, add the messages to the messages array
-        messages = [userMessage, aiMessage, ...messages];
+        // if it fits, its the new minimal prompt
+        minimalPrompt = attemptedPrompt;
     }
-    return [...systemMessage, ...messages];
+    return minimalPrompt;
 }
 exports.trimChatPrompt = trimChatPrompt;

package/model-function/generate-text/prompt-format/trimChatPrompt.js

@@ -12,38 +12,33 @@ import { validateChatPrompt } from "./validateChatPrompt.js";
 export async function trimChatPrompt({ prompt, model, tokenLimit = model.contextWindowSize -
     (model.settings.maxCompletionTokens ?? model.contextWindowSize / 4), }) {
     validateChatPrompt(prompt);
-    const startsWithSystemMessage = "system" in prompt[0];
-    const systemMessage = startsWithSystemMessage ? [prompt[0]] : [];
-    let messages = [];
-    // add the last message (final user message) to the prompt
-    messages.push(prompt[prompt.length - 1]);
+    let minimalPrompt = {
+        system: prompt.system,
+        messages: [prompt.messages[prompt.messages.length - 1]], // last user message
+    };
     // check if the minimal prompt is already too long
-    const promptTokenCount = await model.countPromptTokens([
-        ...systemMessage,
-        ...messages,
-    ]);
+    const promptTokenCount = await model.countPromptTokens(minimalPrompt);
     // the minimal chat prompt is already over the token limit and cannot be trimmed further:
     if (promptTokenCount > tokenLimit) {
-        return [...systemMessage, prompt[prompt.length - 1]];
+        return minimalPrompt;
     }
     // inner messages
-    const innerMessages = prompt.slice(startsWithSystemMessage ? 1 : 0, -1);
+    const innerMessages = prompt.messages.slice(0, -1);
     // taking always a pair of user-message and ai-message from the end, moving backwards
     for (let i = innerMessages.length - 1; i >= 0; i -= 2) {
-        const aiMessage = innerMessages[i];
+        const assistantMessage = innerMessages[i];
         const userMessage = innerMessages[i - 1];
-        // create a temporary array and check if it fits within the token limit
-        const tokenCount = await model.countPromptTokens([
-            ...systemMessage,
-            userMessage,
-            aiMessage,
-            ...messages,
-        ]);
+        // create a temporary prompt and check if it fits within the token limit
+        const attemptedPrompt = {
+            system: prompt.system,
+            messages: [userMessage, assistantMessage, ...minimalPrompt.messages],
+        };
+        const tokenCount = await model.countPromptTokens(attemptedPrompt);
         if (tokenCount > tokenLimit) {
             break;
         }
-        // if it fits, add the messages to the messages array
-        messages = [userMessage, aiMessage, ...messages];
+        // if it fits, its the new minimal prompt
+        minimalPrompt = attemptedPrompt;
     }
-    return [...systemMessage, ...messages];
+    return minimalPrompt;
 }

package/model-function/generate-text/prompt-format/validateChatPrompt.cjs

@@ -1,36 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateChatPrompt = exports.ChatPromptValidationError = void 0;
-class ChatPromptValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ChatPromptValidationError";
-    }
-}
-exports.ChatPromptValidationError = ChatPromptValidationError;
+exports.validateChatPrompt = void 0;
+const ChatPromptValidationError_js_1 = require("./ChatPromptValidationError.cjs");
 /**
  * Checks if a chat prompt is valid. Throws a `ChatPromptValidationError` if it's not.
  */
 function validateChatPrompt(chatPrompt) {
-    if (chatPrompt.length < 1) {
-        throw new ChatPromptValidationError("ChatPrompt should have at least one message.");
-    }
-    const initialType = "system" in chatPrompt[0] ? "system" : "user";
-    if (initialType === "system" && chatPrompt.length === 1) {
-        throw new ChatPromptValidationError("A system message should be followed by a user message.");
+    const messages = chatPrompt.messages;
+    if (messages.length < 1) {
+        throw new ChatPromptValidationError_js_1.ChatPromptValidationError("ChatPrompt should have at least one message.");
     }
-    let expectedType = initialType === "system" ? "user" : "ai";
-    for (let i = 1; i < chatPrompt.length; i++) {
-        const messageType = "user" in chatPrompt[i] ? "user" : "ai";
-        if (messageType !== expectedType) {
-            throw new ChatPromptValidationError(`Message at index ${i} should be a ${expectedType} message, but it's a ${messageType} message.`);
+    for (let i = 0; i < messages.length; i++) {
+        const expectedRole = i % 2 === 0 ? "user" : "assistant";
+        const role = messages[i].role;
+        if (role !== expectedRole) {
+            throw new ChatPromptValidationError_js_1.ChatPromptValidationError(`Message at index ${i} should have role '${expectedRole}', but has role '${role}'.`);
         }
-        // Flip the expected type for the next iteration.
-        expectedType = expectedType === "user" ? "ai" : "user";
     }
-    // If the last message is not a user message, throw an error.
-    if (expectedType !== "ai") {
-        throw new ChatPromptValidationError("The last message should be a user message.");
+    if (messages.length % 2 === 0) {
+        throw new ChatPromptValidationError_js_1.ChatPromptValidationError("The last message must be a user message.");
     }
 }
 exports.validateChatPrompt = validateChatPrompt;

package/model-function/generate-text/prompt-format/validateChatPrompt.d.ts

@@ -1,7 +1,4 @@
 import { ChatPrompt } from "./ChatPrompt.js";
-export declare class ChatPromptValidationError extends Error {
-    constructor(message: string);
-}
 /**
  * Checks if a chat prompt is valid. Throws a `ChatPromptValidationError` if it's not.
  */

package/model-function/generate-text/prompt-format/validateChatPrompt.js

@@ -1,31 +1,20 @@
-export class ChatPromptValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ChatPromptValidationError";
-    }
-}
+import { ChatPromptValidationError } from "./ChatPromptValidationError.js";
 /**
  * Checks if a chat prompt is valid. Throws a `ChatPromptValidationError` if it's not.
  */
 export function validateChatPrompt(chatPrompt) {
-    if (chatPrompt.length < 1) {
+    const messages = chatPrompt.messages;
+    if (messages.length < 1) {
         throw new ChatPromptValidationError("ChatPrompt should have at least one message.");
     }
-    const initialType = "system" in chatPrompt[0] ? "system" : "user";
-    if (initialType === "system" && chatPrompt.length === 1) {
-        throw new ChatPromptValidationError("A system message should be followed by a user message.");
-    }
-    let expectedType = initialType === "system" ? "user" : "ai";
-    for (let i = 1; i < chatPrompt.length; i++) {
-        const messageType = "user" in chatPrompt[i] ? "user" : "ai";
-        if (messageType !== expectedType) {
-            throw new ChatPromptValidationError(`Message at index ${i} should be a ${expectedType} message, but it's a ${messageType} message.`);
+    for (let i = 0; i < messages.length; i++) {
+        const expectedRole = i % 2 === 0 ? "user" : "assistant";
+        const role = messages[i].role;
+        if (role !== expectedRole) {
+            throw new ChatPromptValidationError(`Message at index ${i} should have role '${expectedRole}', but has role '${role}'.`);
         }
-        // Flip the expected type for the next iteration.
-        expectedType = expectedType === "user" ? "ai" : "user";
     }
-    // If the last message is not a user message, throw an error.
-    if (expectedType !== "ai") {
-        throw new ChatPromptValidationError("The last message should be a user message.");
+    if (messages.length % 2 === 0) {
+        throw new ChatPromptValidationError("The last message must be a user message.");
     }
 }

package/model-function/generate-tool-call/NoSuchToolDefinitionError.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoSuchToolDefinitionError = void 0;
+class NoSuchToolDefinitionError extends Error {
+    constructor({ toolName, parameters, }) {
+        super(`Tool definition '${toolName}' not found. ` +
+            `Parameters: ${JSON.stringify(parameters)}.`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "parameters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "NoSuchToolDefinitionError";
+        this.toolName = toolName;
+        this.parameters = parameters;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            toolName: this.toolName,
+            parameter: this.parameters,
+        };
+    }
+}
+exports.NoSuchToolDefinitionError = NoSuchToolDefinitionError;

package/model-function/generate-tool-call/NoSuchToolDefinitionError.d.ts

@@ -0,0 +1,17 @@
+export declare class NoSuchToolDefinitionError extends Error {
+    readonly toolName: string;
+    readonly cause: unknown;
+    readonly parameters: unknown;
+    constructor({ toolName, parameters, }: {
+        toolName: string;
+        parameters: unknown;
+    });
+    toJSON(): {
+        name: string;
+        message: string;
+        cause: unknown;
+        stack: string | undefined;
+        toolName: string;
+        parameter: unknown;
+    };
+}

package/model-function/generate-tool-call/NoSuchToolDefinitionError.js

@@ -0,0 +1,37 @@
+export class NoSuchToolDefinitionError extends Error {
+    constructor({ toolName, parameters, }) {
+        super(`Tool definition '${toolName}' not found. ` +
+            `Parameters: ${JSON.stringify(parameters)}.`);
+        Object.defineProperty(this, "toolName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "parameters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "NoSuchToolDefinitionError";
+        this.toolName = toolName;
+        this.parameters = parameters;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            toolName: this.toolName,
+            parameter: this.parameters,
+        };
+    }
+}

package/model-function/generate-tool-call/ToolCall.d.ts

@@ -0,0 +1,5 @@
+export interface ToolCall<NAME extends string, PARAMETERS> {
+    id: string;
+    name: NAME;
+    parameters: PARAMETERS;
+}

package/model-function/generate-tool-call/ToolCallGenerationModel.d.ts

@@ -1,12 +1,12 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
-import { ToolCallDefinition } from "./ToolCallDefinition.js";
+import { ToolDefinition } from "./ToolDefinition.js";
 export interface ToolCallGenerationModelSettings extends ModelSettings {
 }
 export interface ToolCallGenerationModel<PROMPT, SETTINGS extends ToolCallGenerationModelSettings = ToolCallGenerationModelSettings> extends Model<SETTINGS> {
-    doGenerateToolCall(tool: ToolCallDefinition<string, unknown>, prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+    doGenerateToolCall(tool: ToolDefinition<string, unknown>, prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
         response: unknown;
-        value: {
+        toolCall: {
             id: string;
             parameters: unknown;
         } | null;

package/model-function/generate-tool-call/ToolCallParametersValidationError.cjs

@@ -5,7 +5,7 @@ const getErrorMessage_js_1 = require("../../util/getErrorMessage.cjs");
 class ToolCallParametersValidationError extends Error {
     constructor({ toolName, parameters, cause, }) {
         super(`Parameter validation failed for tool '${toolName}'. ` +
-            `Value: ${JSON.stringify(parameters)}.\n` +
+            `Parameters: ${JSON.stringify(parameters)}.\n` +
             `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
         Object.defineProperty(this, "toolName", {
             enumerable: true,

package/model-function/generate-tool-call/ToolCallParametersValidationError.js

@@ -2,7 +2,7 @@ import { getErrorMessage } from "../../util/getErrorMessage.js";
 export class ToolCallParametersValidationError extends Error {
     constructor({ toolName, parameters, cause, }) {
         super(`Parameter validation failed for tool '${toolName}'. ` +
-            `Value: ${JSON.stringify(parameters)}.\n` +
+            `Parameters: ${JSON.stringify(parameters)}.\n` +
             `Error message: ${getErrorMessage(cause)}`);
         Object.defineProperty(this, "toolName", {
             enumerable: true,

package/model-function/generate-tool-call/ToolCallsOrTextGenerationEvent.cjs

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

package/model-function/generate-tool-call/ToolCallsOrTextGenerationEvent.d.ts

@@ -0,0 +1,23 @@
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+export interface ToolCallsOrTextGenerationStartedEvent extends BaseModelCallStartedEvent {
+    functionType: "generate-tool-calls-or-text";
+}
+export type ToolCallsOrTextGenerationFinishedEventResult = {
+    status: "success";
+    response: unknown;
+    value: unknown;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+} | {
+    status: "error";
+    error: unknown;
+} | {
+    status: "abort";
+};
+export type ToolCallsOrTextGenerationFinishedEvent = BaseModelCallFinishedEvent & {
+    functionType: "generate-tool-calls-or-text";
+    result: ToolCallsOrTextGenerationFinishedEventResult;
+};

package/model-function/generate-tool-call/ToolCallsOrTextGenerationEvent.js

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

package/model-function/generate-tool-call/ToolCallsOrTextGenerationModel.cjs

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

package/model-function/generate-tool-call/ToolCallsOrTextGenerationModel.d.ts

@@ -0,0 +1,21 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+import { ToolDefinition } from "./ToolDefinition.js";
+export interface ToolCallsOrTextGenerationModelSettings extends ModelSettings {
+}
+export interface ToolCallsOrTextGenerationModel<PROMPT, SETTINGS extends ToolCallsOrTextGenerationModelSettings> extends Model<SETTINGS> {
+    doGenerateToolCallsOrText(tools: Array<ToolDefinition<string, unknown>>, prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+        response: unknown;
+        text: string | null;
+        toolCalls: Array<{
+            id: string;
+            name: string;
+            parameters: unknown;
+        }> | null;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+}

package/model-function/generate-tool-call/ToolCallsOrTextGenerationModel.js

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

package/model-function/generate-tool-call/ToolDefinition.cjs

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

package/model-function/generate-tool-call/{ToolCallDefinition.d.ts → ToolDefinition.d.ts}

@@ -1,6 +1,6 @@
 import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
 import { Schema } from "../../core/schema/Schema.js";
-export interface ToolCallDefinition<NAME extends string, PARAMETERS> {
+export interface ToolDefinition<NAME extends string, PARAMETERS> {
     name: NAME;
     description?: string;
     parameters: Schema<PARAMETERS> & JsonSchemaProducer;

package/model-function/generate-tool-call/ToolDefinition.js

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

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

@@ -17,7 +17,7 @@ async function generateToolCall(model, tool, prompt, options) {
         generateResponse: async (options) => {
             try {
                 const result = await model.doGenerateToolCall(tool, expandedPrompt, options);
-                const toolCall = result.value;
+                const toolCall = result.toolCall;
                 if (toolCall === null) {
                     throw new ToolCallGenerationError_js_1.ToolCallsGenerationError({
                         toolName: tool.name,
@@ -36,6 +36,7 @@ async function generateToolCall(model, tool, prompt, options) {
                     response: result.response,
                     extractedValue: {
                         id: toolCall.id,
+                        name: tool.name,
                         parameters: parseResult.data,
                     },
                     usage: result.usage,

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

@@ -1,20 +1,15 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ModelCallMetadata } from "../ModelCallMetadata.js";
-import { ToolCallDefinition } from "./ToolCallDefinition.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: ToolCallDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolCallDefinition<NAME, PARAMETERS>) => PROMPT), options?: FunctionOptions & {
+import { ToolCall } from "./ToolCall.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";
-}): Promise<{
-    id: string;
-    parameters: PARAMETERS;
-}>;
-export declare function generateToolCall<PARAMETERS, PROMPT, NAME extends string, SETTINGS extends ToolCallGenerationModelSettings>(model: ToolCallGenerationModel<PROMPT, SETTINGS>, tool: ToolCallDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolCallDefinition<NAME, PARAMETERS>) => PROMPT), options: FunctionOptions & {
+}): 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";
 }): Promise<{
-    value: {
-        id: string;
-        parameters: PARAMETERS;
-    };
+    value: ToolCall<NAME, PARAMETERS>;
     response: unknown;
     metadata: ModelCallMetadata;
 }>;

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

@@ -14,7 +14,7 @@ export async function generateToolCall(model, tool, prompt, options) {
         generateResponse: async (options) => {
             try {
                 const result = await model.doGenerateToolCall(tool, expandedPrompt, options);
-                const toolCall = result.value;
+                const toolCall = result.toolCall;
                 if (toolCall === null) {
                     throw new ToolCallsGenerationError({
                         toolName: tool.name,
@@ -33,6 +33,7 @@ export async function generateToolCall(model, tool, prompt, options) {
                     response: result.response,
                     extractedValue: {
                         id: toolCall.id,
+                        name: tool.name,
                         parameters: parseResult.data,
                     },
                     usage: result.usage,

package/model-function/generate-tool-call/generateToolCallsOrText.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateToolCallsOrText = void 0;
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
+const NoSuchToolDefinitionError_js_1 = require("./NoSuchToolDefinitionError.cjs");
+const ToolCallParametersValidationError_js_1 = require("./ToolCallParametersValidationError.cjs");
+async function generateToolCallsOrText(model, tools, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tools)
+        : prompt;
+    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+        functionType: "generate-tool-calls-or-text",
+        input: expandedPrompt,
+        model,
+        options,
+        generateResponse: async (options) => {
+            const result = await model.doGenerateToolCallsOrText(tools, expandedPrompt, options);
+            const { text, toolCalls: rawToolCalls } = result;
+            // no tool calls:
+            if (rawToolCalls == null) {
+                return {
+                    response: result.response,
+                    extractedValue: { text, toolCalls: null },
+                    usage: result.usage,
+                };
+            }
+            // map tool calls:
+            const toolCalls = rawToolCalls.map((rawToolCall) => {
+                const tool = tools.find((tool) => tool.name === rawToolCall.name);
+                if (tool == undefined) {
+                    throw new NoSuchToolDefinitionError_js_1.NoSuchToolDefinitionError({
+                        toolName: rawToolCall.name,
+                        parameters: rawToolCall.parameters,
+                    });
+                }
+                const parseResult = tool.parameters.validate(rawToolCall.parameters);
+                if (!parseResult.success) {
+                    throw new ToolCallParametersValidationError_js_1.ToolCallParametersValidationError({
+                        toolName: tool.name,
+                        parameters: rawToolCall.parameters,
+                        cause: parseResult.error,
+                    });
+                }
+                return {
+                    id: rawToolCall.id,
+                    name: tool.name,
+                    parameters: parseResult.data,
+                };
+            });
+            return {
+                response: result.response,
+                extractedValue: {
+                    text,
+                    toolCalls: toolCalls,
+                },
+                usage: result.usage,
+            };
+        },
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+}
+exports.generateToolCallsOrText = generateToolCallsOrText;

package/model-function/generate-tool-call/generateToolCallsOrText.d.ts

@@ -0,0 +1,33 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ModelCallMetadata } from "../ModelCallMetadata.js";
+import { ToolCallsOrTextGenerationModel, ToolCallsOrTextGenerationModelSettings } from "./ToolCallsOrTextGenerationModel.js";
+import { ToolDefinition } from "./ToolDefinition.js";
+type ToolCallDefinitionArray<T extends ToolDefinition<any, any>[]> = T;
+type ToToolCallDefinitionMap<T extends ToolCallDefinitionArray<ToolDefinition<any, any>[]>> = {
+    [K in T[number]["name"]]: Extract<T[number], ToolDefinition<K, any>>;
+};
+type ToToolCallUnion<T> = {
+    [KEY in keyof T]: T[KEY] extends ToolDefinition<any, infer PARAMETERS> ? {
+        id: string;
+        name: KEY;
+        parameters: PARAMETERS;
+    } : never;
+}[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 | ((structureDefinitions: TOOLS) => PROMPT), options?: FunctionOptions & {
+    returnType?: "structure";
+}): 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 | ((structureDefinitions: TOOLS) => PROMPT), options: FunctionOptions & {
+    returnType?: "full";
+}): Promise<{
+    value: {
+        text: string | null;
+        toolCalls: Array<ToOutputValue<TOOLS>>;
+    };
+    response: unknown;
+    metadata: ModelCallMetadata;
+}>;
+export {};