modelfusion 0.68.1 → 0.70.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/ToolCallDefinition.cjs

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

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

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

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

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

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCallsGenerationError = void 0;
+const getErrorMessage_js_1 = require("../../util/getErrorMessage.cjs");
+class ToolCallsGenerationError extends Error {
+    constructor({ toolName, cause }) {
+        super(`Tool call generation failed for tool '${toolName}'. ` +
+            `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
+        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
+        });
+        this.name = "ToolCallsGenerationError";
+        this.toolName = toolName;
+        this.cause = cause;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            toolName: this.toolName,
+        };
+    }
+}
+exports.ToolCallsGenerationError = ToolCallsGenerationError;

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

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

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

@@ -0,0 +1,31 @@
+import { getErrorMessage } from "../../util/getErrorMessage.js";
+export class ToolCallsGenerationError extends Error {
+    constructor({ toolName, cause }) {
+        super(`Tool call generation failed for tool '${toolName}'. ` +
+            `Error message: ${getErrorMessage(cause)}`);
+        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
+        });
+        this.name = "ToolCallsGenerationError";
+        this.toolName = toolName;
+        this.cause = cause;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            toolName: this.toolName,
+        };
+    }
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+import { ToolCallDefinition } from "./ToolCallDefinition.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<{
+        response: unknown;
+        value: {
+            id: string;
+            parameters: unknown;
+        } | null;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+}

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

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

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolCallParametersValidationError = void 0;
+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` +
+            `Error message: ${(0, getErrorMessage_js_1.getErrorMessage)(cause)}`);
+        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 = "ToolCallParametersValidationError";
+        this.toolName = toolName;
+        this.cause = cause;
+        this.parameters = parameters;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            toolName: this.toolName,
+            parameter: this.parameters,
+        };
+    }
+}
+exports.ToolCallParametersValidationError = ToolCallParametersValidationError;

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

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

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

@@ -0,0 +1,40 @@
+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` +
+            `Error message: ${getErrorMessage(cause)}`);
+        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 = "ToolCallParametersValidationError";
+        this.toolName = toolName;
+        this.cause = cause;
+        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/generateToolCall.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateToolCall = void 0;
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
+const ToolCallParametersValidationError_js_1 = require("./ToolCallParametersValidationError.cjs");
+const ToolCallGenerationError_js_1 = require("./ToolCallGenerationError.cjs");
+async function generateToolCall(model, tool, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tool)
+        : prompt;
+    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+        functionType: "generate-tool-call",
+        input: expandedPrompt,
+        model,
+        options,
+        generateResponse: async (options) => {
+            try {
+                const result = await model.doGenerateToolCall(tool, expandedPrompt, options);
+                const toolCall = result.value;
+                if (toolCall === null) {
+                    throw new ToolCallGenerationError_js_1.ToolCallsGenerationError({
+                        toolName: tool.name,
+                        cause: "No tool call generated.",
+                    });
+                }
+                const parseResult = tool.parameters.validate(toolCall.parameters);
+                if (!parseResult.success) {
+                    throw new ToolCallParametersValidationError_js_1.ToolCallParametersValidationError({
+                        toolName: tool.name,
+                        parameters: toolCall.parameters,
+                        cause: parseResult.error,
+                    });
+                }
+                return {
+                    response: result.response,
+                    extractedValue: {
+                        id: toolCall.id,
+                        parameters: parseResult.data,
+                    },
+                    usage: result.usage,
+                };
+            }
+            catch (error) {
+                if (error instanceof ToolCallParametersValidationError_js_1.ToolCallParametersValidationError ||
+                    error instanceof ToolCallGenerationError_js_1.ToolCallsGenerationError) {
+                    throw error;
+                }
+                throw new ToolCallGenerationError_js_1.ToolCallsGenerationError({
+                    toolName: tool.name,
+                    cause: error,
+                });
+            }
+        },
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+}
+exports.generateToolCall = generateToolCall;

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

@@ -0,0 +1,20 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ModelCallMetadata } from "../ModelCallMetadata.js";
+import { ToolCallDefinition } from "./ToolCallDefinition.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 & {
+    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 & {
+    returnType: "full";
+}): Promise<{
+    value: {
+        id: string;
+        parameters: PARAMETERS;
+    };
+    response: unknown;
+    metadata: ModelCallMetadata;
+}>;

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

@@ -0,0 +1,54 @@
+import { executeStandardCall } from "../executeStandardCall.js";
+import { ToolCallParametersValidationError } from "./ToolCallParametersValidationError.js";
+import { ToolCallsGenerationError } from "./ToolCallGenerationError.js";
+export async function generateToolCall(model, tool, prompt, options) {
+    // Note: PROMPT must not be a function.
+    const expandedPrompt = typeof prompt === "function"
+        ? prompt(tool)
+        : prompt;
+    const fullResponse = await executeStandardCall({
+        functionType: "generate-tool-call",
+        input: expandedPrompt,
+        model,
+        options,
+        generateResponse: async (options) => {
+            try {
+                const result = await model.doGenerateToolCall(tool, expandedPrompt, options);
+                const toolCall = result.value;
+                if (toolCall === null) {
+                    throw new ToolCallsGenerationError({
+                        toolName: tool.name,
+                        cause: "No tool call generated.",
+                    });
+                }
+                const parseResult = tool.parameters.validate(toolCall.parameters);
+                if (!parseResult.success) {
+                    throw new ToolCallParametersValidationError({
+                        toolName: tool.name,
+                        parameters: toolCall.parameters,
+                        cause: parseResult.error,
+                    });
+                }
+                return {
+                    response: result.response,
+                    extractedValue: {
+                        id: toolCall.id,
+                        parameters: parseResult.data,
+                    },
+                    usage: result.usage,
+                };
+            }
+            catch (error) {
+                if (error instanceof ToolCallParametersValidationError ||
+                    error instanceof ToolCallsGenerationError) {
+                    throw error;
+                }
+                throw new ToolCallsGenerationError({
+                    toolName: tool.name,
+                    cause: error,
+                });
+            }
+        },
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./ToolCallDefinition.cjs"), exports);
+__exportStar(require("./ToolCallParametersValidationError.cjs"), exports);
+__exportStar(require("./ToolCallGenerationEvent.cjs"), exports);
+__exportStar(require("./ToolCallGenerationModel.cjs"), exports);
+__exportStar(require("./generateToolCall.cjs"), exports);

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

@@ -0,0 +1,5 @@
+export * from "./ToolCallDefinition.js";
+export * from "./ToolCallParametersValidationError.js";
+export * from "./ToolCallGenerationEvent.js";
+export * from "./ToolCallGenerationModel.js";
+export * from "./generateToolCall.js";