modelfusion 0.70.0 → 0.72.0

package/tool/{executeTool.js → execute-tool/executeTool.js}

@@ -1,20 +1,20 @@
 import { nanoid as createId } from "nanoid";
-import { FunctionEventSource } from "../core/FunctionEventSource.js";
-import { getGlobalFunctionLogging } from "../core/GlobalFunctionLogging.js";
-import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
-import { AbortError } from "../core/api/AbortError.js";
-import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
-import { getRun } from "../core/getRun.js";
-import { startDurationMeasurement } from "../util/DurationMeasurement.js";
-import { runSafe } from "../util/runSafe.js";
-import { ToolExecutionError } from "./ToolExecutionError.js";
+import { FunctionEventSource } from "../../core/FunctionEventSource.js";
+import { getGlobalFunctionLogging } from "../../core/GlobalFunctionLogging.js";
+import { getGlobalFunctionObservers } from "../../core/GlobalFunctionObservers.js";
+import { AbortError } from "../../core/api/AbortError.js";
+import { getFunctionCallLogger } from "../../core/getFunctionCallLogger.js";
+import { getRun } from "../../core/getRun.js";
+import { startDurationMeasurement } from "../../util/DurationMeasurement.js";
+import { runSafe } from "../../util/runSafe.js";
+import { ToolExecutionError } from "../ToolExecutionError.js";
 export async function executeTool(// eslint-disable-line @typescript-eslint/no-explicit-any
-tool, input, options) {
-    const fullResponse = await doExecuteTool(tool, input, options);
+tool, args, options) {
+    const fullResponse = await doExecuteTool(tool, args, options);
     return options?.returnType === "full" ? fullResponse : fullResponse.output;
 }
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-async function doExecuteTool(tool, input, options) {
+async function doExecuteTool(tool, args, options) {
     const run = await getRun(options?.run);
     const eventSource = new FunctionEventSource({
         observers: [
@@ -35,7 +35,7 @@ async function doExecuteTool(tool, input, options) {
         userId: run?.userId,
         functionId: options?.functionId,
         toolName: tool.name,
-        input,
+        input: args,
     };
     eventSource.notify({
         ...metadata,
@@ -43,7 +43,7 @@ async function doExecuteTool(tool, input, options) {
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     });
-    const result = await runSafe(() => tool.execute(input, {
+    const result = await runSafe(() => tool.execute(args, {
         functionId: options?.functionId,
         logging: options?.logging,
         observers: options?.observers,
@@ -77,7 +77,7 @@ async function doExecuteTool(tool, input, options) {
         });
         throw new ToolExecutionError({
             toolName: tool.name,
-            input,
+            input: args,
             cause: result.error,
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             message: result.error?.message,

package/tool/execute-tool/index.cjs

@@ -0,0 +1,18 @@
+"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("./ExecuteToolEvent.cjs"), exports);
+__exportStar(require("./executeTool.cjs"), exports);

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

@@ -0,0 +1,2 @@
+export * from "./ExecuteToolEvent.js";
+export * from "./executeTool.js";

package/tool/execute-tool/index.js

@@ -0,0 +1,2 @@
+export * from "./ExecuteToolEvent.js";
+export * from "./executeTool.js";

package/tool/execute-tool/safeExecuteToolCall.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeExecuteToolCall = void 0;
+const ToolCallError_js_1 = require("../ToolCallError.cjs");
+const ToolExecutionError_js_1 = require("../ToolExecutionError.cjs");
+const executeTool_js_1 = require("./executeTool.cjs");
+async function safeExecuteToolCall(tool, toolCall, options) {
+    try {
+        return {
+            tool: toolCall.name,
+            toolCall,
+            args: toolCall.args,
+            ok: true,
+            result: await (0, executeTool_js_1.executeTool)(tool, toolCall.args, options),
+        };
+    }
+    catch (error) {
+        // If the error is an AbortError, rethrow it.
+        if (error instanceof Error && error.name === "AbortError") {
+            throw error;
+        }
+        return {
+            tool: toolCall.name,
+            toolCall,
+            args: toolCall.args,
+            ok: false,
+            result: new ToolCallError_js_1.ToolCallError({
+                toolCall,
+                cause: error instanceof ToolExecutionError_js_1.ToolExecutionError ? error.cause : error,
+            }),
+        };
+    }
+}
+exports.safeExecuteToolCall = safeExecuteToolCall;

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

@@ -0,0 +1,5 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Tool } from "../Tool.js";
+import { ToolCall } from "../ToolCall.js";
+import { ToolCallResult } from "../ToolCallResult.js";
+export declare function safeExecuteToolCall<TOOL extends Tool<string, unknown, any>>(tool: TOOL, toolCall: ToolCall<TOOL["name"], TOOL["parameters"]>, options?: FunctionOptions): Promise<ToolCallResult<TOOL["name"], TOOL["parameters"], Awaited<ReturnType<TOOL["execute"]>>>>;

package/tool/execute-tool/safeExecuteToolCall.js

@@ -0,0 +1,30 @@
+import { ToolCallError } from "../ToolCallError.js";
+import { ToolExecutionError } from "../ToolExecutionError.js";
+import { executeTool } from "./executeTool.js";
+export async function safeExecuteToolCall(tool, toolCall, options) {
+    try {
+        return {
+            tool: toolCall.name,
+            toolCall,
+            args: toolCall.args,
+            ok: true,
+            result: await executeTool(tool, toolCall.args, options),
+        };
+    }
+    catch (error) {
+        // If the error is an AbortError, rethrow it.
+        if (error instanceof Error && error.name === "AbortError") {
+            throw error;
+        }
+        return {
+            tool: toolCall.name,
+            toolCall,
+            args: toolCall.args,
+            ok: false,
+            result: new ToolCallError({
+                toolCall,
+                cause: error instanceof ToolExecutionError ? error.cause : error,
+            }),
+        };
+    }
+}

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextGenerationToolCallModel = void 0;
+const generateText_js_1 = require("../../model-function/generate-text/generateText.cjs");
+const ToolCallParseError_js_1 = require("../ToolCallParseError.cjs");
+class TextGenerationToolCallModel {
+    constructor({ model, format, }) {
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "format", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = model;
+        this.format = format;
+    }
+    get modelInformation() {
+        return this.model.modelInformation;
+    }
+    get settings() {
+        return this.model.settings;
+    }
+    get settingsForEvent() {
+        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), {
+            ...options,
+            returnType: "full",
+        });
+        try {
+            return {
+                response,
+                toolCall: this.format.extractToolCall(value),
+                usage: metadata?.usage,
+            };
+        }
+        catch (error) {
+            throw new ToolCallParseError_js_1.ToolCallParseError({
+                toolName: tool.name,
+                valueText: value,
+                cause: error,
+            });
+        }
+    }
+    withSettings(additionalSettings) {
+        return new TextGenerationToolCallModel({
+            model: this.model.withSettings(additionalSettings),
+            format: this.format,
+        });
+    }
+}
+exports.TextGenerationToolCallModel = TextGenerationToolCallModel;

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

@@ -0,0 +1,35 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { ToolDefinition } from "../ToolDefinition.js";
+import { ToolCallGenerationModel } from "./ToolCallGenerationModel.js";
+export interface ToolCallTextPromptFormat<PROMPT> {
+    createPrompt: (prompt: PROMPT, tool: ToolDefinition<string, unknown>) => string;
+    extractToolCall: (response: string) => {
+        id: string;
+        args: unknown;
+    } | null;
+}
+export declare class TextGenerationToolCallModel<PROMPT, MODEL extends TextGenerationModel<string, TextGenerationModelSettings>> implements ToolCallGenerationModel<PROMPT, MODEL["settings"]> {
+    private readonly model;
+    private readonly format;
+    constructor({ model, format, }: {
+        model: MODEL;
+        format: ToolCallTextPromptFormat<PROMPT>;
+    });
+    get modelInformation(): import("../../index.js").ModelInformation;
+    get settings(): TextGenerationModelSettings;
+    get settingsForEvent(): Partial<MODEL["settings"]>;
+    doGenerateToolCall(tool: ToolDefinition<string, unknown>, prompt: PROMPT, options?: FunctionOptions): Promise<{
+        response: unknown;
+        toolCall: {
+            id: string;
+            args: unknown;
+        } | null;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        } | undefined;
+    }>;
+    withSettings(additionalSettings: Partial<MODEL["settings"]>): this;
+}

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

@@ -0,0 +1,55 @@
+import { generateText } from "../../model-function/generate-text/generateText.js";
+import { ToolCallParseError } from "../ToolCallParseError.js";
+export class TextGenerationToolCallModel {
+    constructor({ model, format, }) {
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "format", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.model = model;
+        this.format = format;
+    }
+    get modelInformation() {
+        return this.model.modelInformation;
+    }
+    get settings() {
+        return this.model.settings;
+    }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
+    async doGenerateToolCall(tool, prompt, options) {
+        const { response, value, metadata } = await generateText(this.model, this.format.createPrompt(prompt, tool), {
+            ...options,
+            returnType: "full",
+        });
+        try {
+            return {
+                response,
+                toolCall: this.format.extractToolCall(value),
+                usage: metadata?.usage,
+            };
+        }
+        catch (error) {
+            throw new ToolCallParseError({
+                toolName: tool.name,
+                valueText: value,
+                cause: error,
+            });
+        }
+    }
+    withSettings(additionalSettings) {
+        return new TextGenerationToolCallModel({
+            model: this.model.withSettings(additionalSettings),
+            format: this.format,
+        });
+    }
+}

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

@@ -1,4 +1,4 @@
-import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../../model-function/ModelCallEvent.js";
 export interface ToolCallGenerationStartedEvent extends BaseModelCallStartedEvent {
     functionType: "generate-tool-call";
 }

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

@@ -1,14 +1,14 @@
 import { FunctionOptions } from "../../core/FunctionOptions.js";
-import { Model, ModelSettings } from "../Model.js";
-import { ToolCallDefinition } from "./ToolCallDefinition.js";
+import { Model, ModelSettings } from "../../model-function/Model.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;
+            args: unknown;
         } | null;
         usage?: {
             promptTokens: number;

package/{model-function → tool}/generate-tool-call/generateToolCall.cjs

@@ -1,9 +1,9 @@
 "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");
+const executeStandardCall_js_1 = require("../../model-function/executeStandardCall.cjs");
+const ToolCallArgumentsValidationError_js_1 = require("../ToolCallArgumentsValidationError.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"
@@ -17,18 +17,18 @@ 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({
+                    throw new ToolCallGenerationError_js_1.ToolCallGenerationError({
                         toolName: tool.name,
                         cause: "No tool call generated.",
                     });
                 }
-                const parseResult = tool.parameters.validate(toolCall.parameters);
+                const parseResult = tool.parameters.validate(toolCall.args);
                 if (!parseResult.success) {
-                    throw new ToolCallParametersValidationError_js_1.ToolCallParametersValidationError({
+                    throw new ToolCallArgumentsValidationError_js_1.ToolCallArgumentsValidationError({
                         toolName: tool.name,
-                        parameters: toolCall.parameters,
+                        args: toolCall.args,
                         cause: parseResult.error,
                     });
                 }
@@ -36,17 +36,18 @@ async function generateToolCall(model, tool, prompt, options) {
                     response: result.response,
                     extractedValue: {
                         id: toolCall.id,
-                        parameters: parseResult.data,
+                        name: tool.name,
+                        args: parseResult.data,
                     },
                     usage: result.usage,
                 };
             }
             catch (error) {
-                if (error instanceof ToolCallParametersValidationError_js_1.ToolCallParametersValidationError ||
-                    error instanceof ToolCallGenerationError_js_1.ToolCallsGenerationError) {
+                if (error instanceof ToolCallArgumentsValidationError_js_1.ToolCallArgumentsValidationError ||
+                    error instanceof ToolCallGenerationError_js_1.ToolCallGenerationError) {
                     throw error;
                 }
-                throw new ToolCallGenerationError_js_1.ToolCallsGenerationError({
+                throw new ToolCallGenerationError_js_1.ToolCallGenerationError({
                     toolName: tool.name,
                     cause: error,
                 });

package/{model-function → tool}/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 { ModelCallMetadata } from "../../model-function/ModelCallMetadata.js";
+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: ToolCallDefinition<NAME, PARAMETERS>, prompt: PROMPT | ((tool: ToolCallDefinition<NAME, PARAMETERS>) => PROMPT), options?: FunctionOptions & {
+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 → tool}/generate-tool-call/generateToolCall.js

@@ -1,6 +1,6 @@
-import { executeStandardCall } from "../executeStandardCall.js";
-import { ToolCallParametersValidationError } from "./ToolCallParametersValidationError.js";
-import { ToolCallsGenerationError } from "./ToolCallGenerationError.js";
+import { executeStandardCall } from "../../model-function/executeStandardCall.js";
+import { ToolCallArgumentsValidationError } from "../ToolCallArgumentsValidationError.js";
+import { ToolCallGenerationError } from "../ToolCallGenerationError.js";
 export async function generateToolCall(model, tool, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
@@ -14,18 +14,18 @@ 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({
+                    throw new ToolCallGenerationError({
                         toolName: tool.name,
                         cause: "No tool call generated.",
                     });
                 }
-                const parseResult = tool.parameters.validate(toolCall.parameters);
+                const parseResult = tool.parameters.validate(toolCall.args);
                 if (!parseResult.success) {
-                    throw new ToolCallParametersValidationError({
+                    throw new ToolCallArgumentsValidationError({
                         toolName: tool.name,
-                        parameters: toolCall.parameters,
+                        args: toolCall.args,
                         cause: parseResult.error,
                     });
                 }
@@ -33,17 +33,18 @@ export async function generateToolCall(model, tool, prompt, options) {
                     response: result.response,
                     extractedValue: {
                         id: toolCall.id,
-                        parameters: parseResult.data,
+                        name: tool.name,
+                        args: parseResult.data,
                     },
                     usage: result.usage,
                 };
             }
             catch (error) {
-                if (error instanceof ToolCallParametersValidationError ||
-                    error instanceof ToolCallsGenerationError) {
+                if (error instanceof ToolCallArgumentsValidationError ||
+                    error instanceof ToolCallGenerationError) {
                     throw error;
                 }
-                throw new ToolCallsGenerationError({
+                throw new ToolCallGenerationError({
                     toolName: tool.name,
                     cause: error,
                 });

package/{model-function → tool}/generate-tool-call/index.cjs

@@ -14,8 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ToolCallDefinition.cjs"), exports);
-__exportStar(require("./ToolCallParametersValidationError.cjs"), exports);
+__exportStar(require("./TextGenerationToolCallModel.cjs"), exports);
 __exportStar(require("./ToolCallGenerationEvent.cjs"), exports);
 __exportStar(require("./ToolCallGenerationModel.cjs"), exports);
 __exportStar(require("./generateToolCall.cjs"), exports);

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

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

package/{model-function → tool}/generate-tool-call/index.js

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

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

@@ -0,0 +1,23 @@
+import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../../model-function/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/tool/generate-tool-calls-or-text/ToolCallsOrTextGenerationModel.cjs

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

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

@@ -0,0 +1,21 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { Model, ModelSettings } from "../../model-function/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;
+            args: unknown;
+        }> | null;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+}

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

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

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateToolCallsOrText = void 0;
+const executeStandardCall_js_1 = require("../../model-function/executeStandardCall.cjs");
+const NoSuchToolDefinitionError_js_1 = require("../NoSuchToolDefinitionError.cjs");
+const ToolCallArgumentsValidationError_js_1 = require("../ToolCallArgumentsValidationError.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.args,
+                    });
+                }
+                const parseResult = tool.parameters.validate(rawToolCall.args);
+                if (!parseResult.success) {
+                    throw new ToolCallArgumentsValidationError_js_1.ToolCallArgumentsValidationError({
+                        toolName: tool.name,
+                        args: rawToolCall.args,
+                        cause: parseResult.error,
+                    });
+                }
+                return {
+                    id: rawToolCall.id,
+                    name: tool.name,
+                    args: parseResult.data,
+                };
+            });
+            return {
+                response: result.response,
+                extractedValue: {
+                    text,
+                    toolCalls: toolCalls,
+                },
+                usage: result.usage,
+            };
+        },
+    });
+    return options?.returnType === "full" ? fullResponse : fullResponse.value;
+}
+exports.generateToolCallsOrText = generateToolCallsOrText;