modelfusion 0.68.1 → 0.69.0

package/core/schema/JSONParseError.cjs

@@ -34,8 +34,8 @@ class JSONParseError extends Error {
             name: this.name,
             message: this.message,
             cause: this.cause,
-            valueText: this.text,
             stack: this.stack,
+            valueText: this.text,
         };
     }
 }

package/core/schema/JSONParseError.d.ts

@@ -10,7 +10,7 @@ export declare class JSONParseError extends Error {
         name: string;
         message: string;
         cause: unknown;
-        valueText: string;
         stack: string | undefined;
+        valueText: string;
     };
 }

package/core/schema/JSONParseError.js

@@ -31,8 +31,8 @@ export class JSONParseError extends Error {
             name: this.name,
             message: this.message,
             cause: this.cause,
-            valueText: this.text,
             stack: this.stack,
+            valueText: this.text,
         };
     }
 }

package/model-function/ModelCallEvent.d.ts

@@ -6,6 +6,7 @@ import { SpeechGenerationFinishedEvent, SpeechGenerationStartedEvent, SpeechStre
 import { StructureGenerationFinishedEvent, StructureGenerationStartedEvent } from "./generate-structure/StructureGenerationEvent.js";
 import { StructureStreamingFinishedEvent, StructureStreamingStartedEvent } from "./generate-structure/StructureStreamingEvent.js";
 import { TextGenerationFinishedEvent, TextGenerationStartedEvent, TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextGenerationEvent.js";
+import { ToolCallGenerationFinishedEvent, ToolCallGenerationStartedEvent } from "./generate-tool-call/ToolCallGenerationEvent.js";
 import { TranscriptionFinishedEvent, TranscriptionStartedEvent } from "./generate-transcription/TranscriptionEvent.js";
 export interface BaseModelCallStartedEvent extends BaseFunctionStartedEvent {
     model: ModelInformation;
@@ -47,5 +48,5 @@ export interface BaseModelCallFinishedEvent extends BaseFunctionFinishedEvent {
      */
     result: BaseModelCallFinishedEventResult;
 }
-export type ModelCallStartedEvent = EmbeddingStartedEvent | ImageGenerationStartedEvent | SpeechGenerationStartedEvent | SpeechStreamingStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
-export type ModelCallFinishedEvent = EmbeddingFinishedEvent | ImageGenerationFinishedEvent | SpeechGenerationFinishedEvent | SpeechStreamingFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;
+export type ModelCallStartedEvent = EmbeddingStartedEvent | ImageGenerationStartedEvent | SpeechGenerationStartedEvent | SpeechStreamingStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | ToolCallGenerationStartedEvent | TranscriptionStartedEvent;
+export type ModelCallFinishedEvent = EmbeddingFinishedEvent | ImageGenerationFinishedEvent | SpeechGenerationFinishedEvent | SpeechStreamingFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | ToolCallGenerationFinishedEvent | TranscriptionFinishedEvent;

package/model-function/generate-structure/StructureValidationError.cjs

@@ -37,5 +37,16 @@ class StructureValidationError extends Error {
         this.value = value;
         this.valueText = valueText;
     }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            structureName: this.structureName,
+            value: this.value,
+            valueText: this.valueText,
+        };
+    }
 }
 exports.StructureValidationError = StructureValidationError;

package/model-function/generate-structure/StructureValidationError.d.ts

@@ -9,4 +9,13 @@ export declare class StructureValidationError extends Error {
         valueText: string;
         cause: unknown;
     });
+    toJSON(): {
+        name: string;
+        message: string;
+        cause: unknown;
+        stack: string | undefined;
+        structureName: string;
+        value: unknown;
+        valueText: string;
+    };
 }

package/model-function/generate-structure/StructureValidationError.js

@@ -34,4 +34,15 @@ export class StructureValidationError extends Error {
         this.value = value;
         this.valueText = valueText;
     }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            cause: this.cause,
+            stack: this.stack,
+            structureName: this.structureName,
+            value: this.value,
+            valueText: this.valueText,
+        };
+    }
 }

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";

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

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

package/model-function/index.cjs

@@ -31,6 +31,7 @@ __exportStar(require("./generate-image/generateImage.cjs"), exports);
 __exportStar(require("./generate-speech/index.cjs"), exports);
 __exportStar(require("./generate-structure/index.cjs"), exports);
 __exportStar(require("./generate-text/index.cjs"), exports);
+__exportStar(require("./generate-tool-call/index.cjs"), exports);
 __exportStar(require("./generate-transcription/TranscriptionEvent.cjs"), exports);
 __exportStar(require("./generate-transcription/TranscriptionModel.cjs"), exports);
 __exportStar(require("./generate-transcription/generateTranscription.cjs"), exports);

package/model-function/index.d.ts

@@ -15,6 +15,7 @@ export * from "./generate-image/generateImage.js";
 export * from "./generate-speech/index.js";
 export * from "./generate-structure/index.js";
 export * from "./generate-text/index.js";
+export * from "./generate-tool-call/index.js";
 export * from "./generate-transcription/TranscriptionEvent.js";
 export * from "./generate-transcription/TranscriptionModel.js";
 export * from "./generate-transcription/generateTranscription.js";

package/model-function/index.js

@@ -15,6 +15,7 @@ export * from "./generate-image/generateImage.js";
 export * from "./generate-speech/index.js";
 export * from "./generate-structure/index.js";
 export * from "./generate-text/index.js";
+export * from "./generate-tool-call/index.js";
 export * from "./generate-transcription/TranscriptionEvent.js";
 export * from "./generate-transcription/TranscriptionModel.js";
 export * from "./generate-transcription/generateTranscription.js";

package/model-provider/automatic1111/Automatic1111ImageGenerationModel.d.ts

@@ -19,8 +19,8 @@ export declare class Automatic1111ImageGenerationModel extends AbstractModel<Aut
     get settingsForEvent(): Partial<Automatic1111ImageGenerationSettings>;
     doGenerateImage(prompt: Automatic1111ImageGenerationPrompt, options?: FunctionOptions): Promise<{
         response: {
-            images: string[];
             parameters: {};
+            images: string[];
             info: string;
         };
         base64Image: string;
@@ -42,12 +42,12 @@ declare const Automatic1111ImageGenerationResponseSchema: z.ZodObject<{
     parameters: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
     info: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    images: string[];
     parameters: {};
+    images: string[];
     info: string;
 }, {
-    images: string[];
     parameters: {};
+    images: string[];
     info: string;
 }>;
 export type Automatic1111ImageGenerationResponse = z.infer<typeof Automatic1111ImageGenerationResponseSchema>;

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

@@ -8,6 +8,7 @@ const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
 const zod_1 = require("zod");
 const callWithRetryAndThrottle_js_1 = require("../../../core/api/callWithRetryAndThrottle.cjs");
 const postToApi_js_1 = require("../../../core/api/postToApi.cjs");
+const parseJSON_js_1 = require("../../../core/schema/parseJSON.cjs");
 const AbstractModel_js_1 = require("../../../model-function/AbstractModel.cjs");
 const StructureParseError_js_1 = require("../../../model-function/generate-structure/StructureParseError.cjs");
 const parsePartialJson_js_1 = require("../../../model-function/generate-structure/parsePartialJson.cjs");
@@ -210,9 +211,11 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
             throttle: this.settings.api?.throttle,
             call: async () => callOpenAIChatCompletionAPI({
                 ...this.settings,
-                // function calling:
+                // function & tool calling:
                 functions: options.functions ?? this.settings.functions,
                 functionCall: options.functionCall ?? this.settings.functionCall,
+                tools: options.tools ?? this.settings.tools,
+                toolChoice: options.toolChoice ?? this.settings.toolChoice,
                 // map to OpenAI API names:
                 stop: this.settings.stopSequences,
                 maxTokens: this.settings.maxCompletionTokens,
@@ -358,6 +361,37 @@ class OpenAIChatModel extends AbstractModel_js_1.AbstractModel {
             });
         }
     }
+    async doGenerateToolCall(tool, prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: exports.OpenAIChatResponseFormat.json,
+            toolChoice: {
+                type: "function",
+                function: { name: tool.name },
+            },
+            tools: [
+                {
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: tool.parameters.getJsonSchema(),
+                    },
+                },
+            ],
+        });
+        const toolCalls = response.choices[0]?.message.tool_calls;
+        return {
+            response,
+            value: toolCalls == null || toolCalls.length === 0
+                ? null
+                : {
+                    id: toolCalls[0].id,
+                    parameters: (0, parseJSON_js_1.parseJSON)({ text: toolCalls[0].function.arguments }),
+                },
+            usage: this.extractUsage(response),
+        };
+    }
     extractUsage(response) {
         return {
             promptTokens: response.usage.prompt_tokens,
@@ -405,6 +439,16 @@ const openAIChatResponseSchema = zod_1.z.object({
                 arguments: zod_1.z.string(),
             })
                 .optional(),
+            tool_calls: zod_1.z
+                .array(zod_1.z.object({
+                id: zod_1.z.string(),
+                type: zod_1.z.literal("function"),
+                function: zod_1.z.object({
+                    name: zod_1.z.string(),
+                    arguments: zod_1.z.string(),
+                }),
+            }))
+                .optional(),
         }),
         index: zod_1.z.number(),
         logprobs: zod_1.z.nullable(zod_1.z.any()),
@@ -429,7 +473,7 @@ const openAIChatResponseSchema = zod_1.z.object({
         total_tokens: zod_1.z.number(),
     }),
 });
-async function callOpenAIChatCompletionAPI({ api = new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration(), abortSignal, responseFormat, model, messages, functions, functionCall, temperature, topP, n, stop, maxTokens, presencePenalty, frequencyPenalty, logitBias, user, openAIResponseFormat, seed, }) {
+async function callOpenAIChatCompletionAPI({ api = new OpenAIApiConfiguration_js_1.OpenAIApiConfiguration(), abortSignal, responseFormat, model, messages, functions, functionCall, tools, toolChoice, temperature, topP, n, stop, maxTokens, presencePenalty, frequencyPenalty, logitBias, user, openAIResponseFormat, seed, }) {
     // empty arrays are not allowed for stop:
     if (stop != null && Array.isArray(stop) && stop.length === 0) {
         stop = undefined;
@@ -443,6 +487,8 @@ async function callOpenAIChatCompletionAPI({ api = new OpenAIApiConfiguration_js
             messages,
             functions,
             function_call: functionCall,
+            tools,
+            tool_choice: toolChoice,
             temperature,
             top_p: topP,
             n,

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

@@ -10,6 +10,8 @@ import { StructureOrTextGenerationModel } from "../../../model-function/generate
 import { PromptFormatTextStreamingModel } from "../../../model-function/generate-text/PromptFormatTextStreamingModel.js";
 import { TextGenerationModelSettings, TextStreamingModel } from "../../../model-function/generate-text/TextGenerationModel.js";
 import { TextGenerationPromptFormat } from "../../../model-function/generate-text/TextGenerationPromptFormat.js";
+import { ToolCallDefinition } from "../../../model-function/generate-tool-call/ToolCallDefinition.js";
+import { ToolCallGenerationModel } from "../../../model-function/generate-tool-call/ToolCallGenerationModel.js";
 import { TikTokenTokenizer } from "../TikTokenTokenizer.js";
 import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
 export declare const OPENAI_CHAT_MODELS: {
@@ -117,6 +119,20 @@ export interface OpenAIChatCallSettings {
     functionCall?: "none" | "auto" | {
         name: string;
     };
+    tools?: Array<{
+        type: "function";
+        function: {
+            name: string;
+            description?: string;
+            parameters: unknown;
+        };
+    }>;
+    toolChoice?: "none" | "auto" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
     stop?: string | string[];
     maxTokens?: number;
     temperature?: number;
@@ -152,7 +168,7 @@ export interface OpenAIChatSettings extends TextGenerationModelSettings, Omit<Op
  *   ),
  * ]);
  */
-export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextStreamingModel<OpenAIChatMessage[], OpenAIChatSettings>, StructureGenerationModel<OpenAIChatMessage[], OpenAIChatSettings>, StructureOrTextGenerationModel<OpenAIChatMessage[], OpenAIChatSettings> {
+export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> implements TextStreamingModel<OpenAIChatMessage[], OpenAIChatSettings>, StructureGenerationModel<OpenAIChatMessage[], OpenAIChatSettings>, StructureOrTextGenerationModel<OpenAIChatMessage[], OpenAIChatSettings>, ToolCallGenerationModel<OpenAIChatMessage[], OpenAIChatSettings> {
     constructor(settings: OpenAIChatSettings);
     readonly provider: "openai";
     get modelName(): OpenAIChatModelType;
@@ -166,14 +182,10 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
     callAPI<RESULT>(messages: Array<OpenAIChatMessage>, options: {
         responseFormat: OpenAIChatResponseFormatType<RESULT>;
     } & FunctionOptions & {
-        functions?: Array<{
-            name: string;
-            description?: string;
-            parameters: unknown;
-        }>;
-        functionCall?: "none" | "auto" | {
-            name: string;
-        };
+        functions?: OpenAIChatCallSettings["functions"];
+        functionCall?: OpenAIChatCallSettings["functionCall"];
+        tools?: OpenAIChatCallSettings["tools"];
+        toolChoice?: OpenAIChatCallSettings["toolChoice"];
     }): Promise<RESULT>;
     get settingsForEvent(): Partial<OpenAIChatSettings>;
     doGenerateText(prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
@@ -194,6 +206,14 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
                         name: string;
                         arguments: string;
                     } | undefined;
+                    tool_calls?: {
+                        function: {
+                            name: string;
+                            arguments: string;
+                        };
+                        type: "function";
+                        id: string;
+                    }[] | undefined;
                 };
                 index: number;
                 logprobs?: any;
@@ -235,6 +255,14 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
                         name: string;
                         arguments: string;
                     } | undefined;
+                    tool_calls?: {
+                        function: {
+                            name: string;
+                            arguments: string;
+                        };
+                        type: "function";
+                        id: string;
+                    }[] | undefined;
                 };
                 index: number;
                 logprobs?: any;
@@ -270,6 +298,14 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
                         name: string;
                         arguments: string;
                     } | undefined;
+                    tool_calls?: {
+                        function: {
+                            name: string;
+                            arguments: string;
+                        };
+                        type: "function";
+                        id: string;
+                    }[] | undefined;
                 };
                 index: number;
                 logprobs?: any;
@@ -307,6 +343,14 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
                         name: string;
                         arguments: string;
                     } | undefined;
+                    tool_calls?: {
+                        function: {
+                            name: string;
+                            arguments: string;
+                        };
+                        type: "function";
+                        id: string;
+                    }[] | undefined;
                 };
                 index: number;
                 logprobs?: any;
@@ -327,6 +371,50 @@ export declare class OpenAIChatModel extends AbstractModel<OpenAIChatSettings> i
             totalTokens: number;
         };
     }>;
+    doGenerateToolCall(tool: ToolCallDefinition<string, unknown>, prompt: OpenAIChatMessage[], options?: FunctionOptions): Promise<{
+        response: {
+            object: "chat.completion";
+            usage: {
+                prompt_tokens: number;
+                total_tokens: number;
+                completion_tokens: number;
+            };
+            model: string;
+            id: string;
+            choices: {
+                message: {
+                    content: string | null;
+                    role: "assistant";
+                    function_call?: {
+                        name: string;
+                        arguments: string;
+                    } | undefined;
+                    tool_calls?: {
+                        function: {
+                            name: string;
+                            arguments: string;
+                        };
+                        type: "function";
+                        id: string;
+                    }[] | undefined;
+                };
+                index: number;
+                logprobs?: any;
+                finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+            }[];
+            created: number;
+            system_fingerprint?: string | undefined;
+        };
+        value: {
+            id: string;
+            parameters: unknown;
+        } | null;
+        usage: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
     extractUsage(response: OpenAIChatResponse): {
         promptTokens: number;
         completionTokens: number;
@@ -359,6 +447,34 @@ declare const openAIChatResponseSchema: z.ZodObject<{
                 name: string;
                 arguments: string;
             }>>;
+            tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    arguments: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    arguments: string;
+                }, {
+                    name: string;
+                    arguments: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }>, "many">>;
         }, "strip", z.ZodTypeAny, {
             content: string | null;
             role: "assistant";
@@ -366,6 +482,14 @@ declare const openAIChatResponseSchema: z.ZodObject<{
                 name: string;
                 arguments: string;
             } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
         }, {
             content: string | null;
             role: "assistant";
@@ -373,6 +497,14 @@ declare const openAIChatResponseSchema: z.ZodObject<{
                 name: string;
                 arguments: string;
             } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
         }>;
         index: z.ZodNumber;
         logprobs: z.ZodNullable<z.ZodAny>;
@@ -385,6 +517,14 @@ declare const openAIChatResponseSchema: z.ZodObject<{
                 name: string;
                 arguments: string;
             } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
         };
         index: number;
         logprobs?: any;
@@ -397,6 +537,14 @@ declare const openAIChatResponseSchema: z.ZodObject<{
                 name: string;
                 arguments: string;
             } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
         };
         index: number;
         logprobs?: any;
@@ -436,6 +584,14 @@ declare const openAIChatResponseSchema: z.ZodObject<{
                 name: string;
                 arguments: string;
             } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
         };
         index: number;
         logprobs?: any;
@@ -460,6 +616,14 @@ declare const openAIChatResponseSchema: z.ZodObject<{
                 name: string;
                 arguments: string;
             } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
         };
         index: number;
         logprobs?: any;
@@ -496,6 +660,14 @@ export declare const OpenAIChatResponseFormat: {
                         name: string;
                         arguments: string;
                     } | undefined;
+                    tool_calls?: {
+                        function: {
+                            name: string;
+                            arguments: string;
+                        };
+                        type: "function";
+                        id: string;
+                    }[] | undefined;
                 };
                 index: number;
                 logprobs?: any;

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

@@ -2,6 +2,7 @@ import SecureJSON from "secure-json-parse";
 import { z } from "zod";
 import { callWithRetryAndThrottle } from "../../../core/api/callWithRetryAndThrottle.js";
 import { createJsonResponseHandler, postJsonToApi, } from "../../../core/api/postToApi.js";
+import { parseJSON } from "../../../core/schema/parseJSON.js";
 import { AbstractModel } from "../../../model-function/AbstractModel.js";
 import { StructureParseError } from "../../../model-function/generate-structure/StructureParseError.js";
 import { parsePartialJson } from "../../../model-function/generate-structure/parsePartialJson.js";
@@ -201,9 +202,11 @@ export class OpenAIChatModel extends AbstractModel {
             throttle: this.settings.api?.throttle,
             call: async () => callOpenAIChatCompletionAPI({
                 ...this.settings,
-                // function calling:
+                // function & tool calling:
                 functions: options.functions ?? this.settings.functions,
                 functionCall: options.functionCall ?? this.settings.functionCall,
+                tools: options.tools ?? this.settings.tools,
+                toolChoice: options.toolChoice ?? this.settings.toolChoice,
                 // map to OpenAI API names:
                 stop: this.settings.stopSequences,
                 maxTokens: this.settings.maxCompletionTokens,
@@ -349,6 +352,37 @@ export class OpenAIChatModel extends AbstractModel {
             });
         }
     }
+    async doGenerateToolCall(tool, prompt, options) {
+        const response = await this.callAPI(prompt, {
+            ...options,
+            responseFormat: OpenAIChatResponseFormat.json,
+            toolChoice: {
+                type: "function",
+                function: { name: tool.name },
+            },
+            tools: [
+                {
+                    type: "function",
+                    function: {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: tool.parameters.getJsonSchema(),
+                    },
+                },
+            ],
+        });
+        const toolCalls = response.choices[0]?.message.tool_calls;
+        return {
+            response,
+            value: toolCalls == null || toolCalls.length === 0
+                ? null
+                : {
+                    id: toolCalls[0].id,
+                    parameters: parseJSON({ text: toolCalls[0].function.arguments }),
+                },
+            usage: this.extractUsage(response),
+        };
+    }
     extractUsage(response) {
         return {
             promptTokens: response.usage.prompt_tokens,
@@ -395,6 +429,16 @@ const openAIChatResponseSchema = z.object({
                 arguments: z.string(),
             })
                 .optional(),
+            tool_calls: z
+                .array(z.object({
+                id: z.string(),
+                type: z.literal("function"),
+                function: z.object({
+                    name: z.string(),
+                    arguments: z.string(),
+                }),
+            }))
+                .optional(),
         }),
         index: z.number(),
         logprobs: z.nullable(z.any()),
@@ -419,7 +463,7 @@ const openAIChatResponseSchema = z.object({
         total_tokens: z.number(),
     }),
 });
-async function callOpenAIChatCompletionAPI({ api = new OpenAIApiConfiguration(), abortSignal, responseFormat, model, messages, functions, functionCall, temperature, topP, n, stop, maxTokens, presencePenalty, frequencyPenalty, logitBias, user, openAIResponseFormat, seed, }) {
+async function callOpenAIChatCompletionAPI({ api = new OpenAIApiConfiguration(), abortSignal, responseFormat, model, messages, functions, functionCall, tools, toolChoice, temperature, topP, n, stop, maxTokens, presencePenalty, frequencyPenalty, logitBias, user, openAIResponseFormat, seed, }) {
     // empty arrays are not allowed for stop:
     if (stop != null && Array.isArray(stop) && stop.length === 0) {
         stop = undefined;
@@ -433,6 +477,8 @@ async function callOpenAIChatCompletionAPI({ api = new OpenAIApiConfiguration(),
             messages,
             functions,
             function_call: functionCall,
+            tools,
+            tool_choice: toolChoice,
             temperature,
             top_p: topP,
             n,

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

@@ -18,6 +18,16 @@ const chatResponseStreamEventSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.objec
                 arguments: zod_1.z.string().optional(),
             })
                 .optional(),
+            tool_calls: zod_1.z
+                .array(zod_1.z.object({
+                id: zod_1.z.string(),
+                type: zod_1.z.literal("function"),
+                function: zod_1.z.object({
+                    name: zod_1.z.string(),
+                    arguments: zod_1.z.string(),
+                }),
+            }))
+                .optional(),
         }),
         finish_reason: zod_1.z
             .enum([

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

@@ -15,6 +15,16 @@ const chatResponseStreamEventSchema = new ZodSchema(z.object({
                 arguments: z.string().optional(),
             })
                 .optional(),
+            tool_calls: z
+                .array(z.object({
+                id: z.string(),
+                type: z.literal("function"),
+                function: z.object({
+                    name: z.string(),
+                    arguments: z.string(),
+                }),
+            }))
+                .optional(),
         }),
         finish_reason: z
             .enum([

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.68.1",
+  "version": "0.69.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [
@@ -81,8 +81,8 @@
     "eslint-config-prettier": "9.0.0",
     "fastify": "^4.0.0",
     "husky": "^8.0.3",
-    "lint-staged": "15.0.2",
-    "prettier": "3.0.3",
+    "lint-staged": "15.1.0",
+    "prettier": "3.1.0",
     "rimraf": "5.0.5",
     "typescript": "5.2.2",
     "vitest": "^0.34.5"