modelfusion 0.121.2 → 0.122.0

package/tool/generate-tool-calls/TextGenerationToolCallsModel.cjs

@@ -30,9 +30,11 @@ class TextGenerationToolCallsModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCalls(tools, prompt, options) {
-        const { rawResponse, text: generatedText, metadata, } = await (0, generateText_js_1.generateText)(this.model, this.template.createPrompt(prompt, tools), {
-            ...options,
+        const { rawResponse, text: generatedText, metadata, } = await (0, generateText_js_1.generateText)({
+            model: this.model,
+            prompt: this.template.createPrompt(prompt, tools),
             fullResponse: true,
+            ...options,
         });
         try {
             const { text, toolCalls } = this.template.extractToolCallsAndText(generatedText);

package/tool/generate-tool-calls/TextGenerationToolCallsModel.js

@@ -27,9 +27,11 @@ export class TextGenerationToolCallsModel {
         return this.model.settingsForEvent;
     }
     async doGenerateToolCalls(tools, prompt, options) {
-        const { rawResponse, text: generatedText, metadata, } = await generateText(this.model, this.template.createPrompt(prompt, tools), {
-            ...options,
+        const { rawResponse, text: generatedText, metadata, } = await generateText({
+            model: this.model,
+            prompt: this.template.createPrompt(prompt, tools),
             fullResponse: true,
+            ...options,
         });
         try {
             const { text, toolCalls } = this.template.extractToolCallsAndText(generatedText);

package/tool/generate-tool-calls/generateToolCalls.cjs

@@ -4,12 +4,12 @@ exports.generateToolCalls = 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 generateToolCalls(model, tools, prompt, options) {
+async function generateToolCalls({ model, tools, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
         : prompt;
-    const fullResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
+    const callResponse = await (0, executeStandardCall_js_1.executeStandardCall)({
         functionType: "generate-tool-calls",
         input: expandedPrompt,
         model,
@@ -58,6 +58,6 @@ async function generateToolCalls(model, tools, prompt, options) {
             };
         },
     });
-    return options?.fullResponse ? fullResponse : fullResponse.value;
+    return fullResponse ? callResponse : callResponse.value;
 }
 exports.generateToolCalls = generateToolCalls;

package/tool/generate-tool-calls/generateToolCalls.d.ts

@@ -14,15 +14,21 @@ type ToToolCallUnion<T> = {
     } : never;
 }[keyof T];
 type ToOutputValue<TOOL_CALLS extends ToolCallDefinitionArray<ToolDefinition<any, any>[]>> = ToToolCallUnion<ToToolCallDefinitionMap<TOOL_CALLS>>;
-export declare function generateToolCalls<TOOLS extends Array<ToolDefinition<any, any>>, PROMPT>(model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options?: FunctionOptions & {
+export declare function generateToolCalls<TOOLS extends Array<ToolDefinition<any, any>>, PROMPT>(params: {
+    model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>;
+    tools: TOOLS;
+    prompt: PROMPT | ((tools: TOOLS) => PROMPT);
     fullResponse?: false;
-}): Promise<{
+} & FunctionOptions): Promise<{
     text: string | null;
     toolCalls: Array<ToOutputValue<TOOLS>> | null;
 }>;
-export declare function generateToolCalls<TOOLS extends ToolDefinition<any, any>[], PROMPT>(model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options: FunctionOptions & {
-    fullResponse?: boolean;
-}): Promise<{
+export declare function generateToolCalls<TOOLS extends ToolDefinition<any, any>[], PROMPT>(params: {
+    model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>;
+    tools: TOOLS;
+    prompt: PROMPT | ((tools: TOOLS) => PROMPT);
+    fullResponse: true;
+} & FunctionOptions): Promise<{
     value: {
         text: string | null;
         toolCalls: Array<ToOutputValue<TOOLS>>;

package/tool/generate-tool-calls/generateToolCalls.js

@@ -1,12 +1,12 @@
 import { executeStandardCall } from "../../model-function/executeStandardCall.js";
 import { NoSuchToolDefinitionError } from "../NoSuchToolDefinitionError.js";
 import { ToolCallArgumentsValidationError } from "../ToolCallArgumentsValidationError.js";
-export async function generateToolCalls(model, tools, prompt, options) {
+export async function generateToolCalls({ model, tools, prompt, fullResponse, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
         : prompt;
-    const fullResponse = await executeStandardCall({
+    const callResponse = await executeStandardCall({
         functionType: "generate-tool-calls",
         input: expandedPrompt,
         model,
@@ -55,5 +55,5 @@ export async function generateToolCalls(model, tools, prompt, options) {
             };
         },
     });
-    return options?.fullResponse ? fullResponse : fullResponse.value;
+    return fullResponse ? callResponse : callResponse.value;
 }

package/tool/use-tool/useTool.cjs

@@ -15,7 +15,7 @@ const generateToolCall_js_1 = require("../generate-tool-call/generateToolCall.cj
  * @see {@link generateToolCall}
  * @see {@link executeTool}
  */
-async function useTool(model, tool, prompt, options) {
+async function useTool({ model, tool, prompt, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
@@ -24,7 +24,7 @@ async function useTool(model, tool, prompt, options) {
         options,
         input: expandedPrompt,
         functionType: "use-tool",
-        execute: async (options) => (0, safeExecuteToolCall_js_1.safeExecuteToolCall)(tool, await (0, generateToolCall_js_1.generateToolCall)(model, tool, expandedPrompt, options), options),
+        execute: async (options) => (0, safeExecuteToolCall_js_1.safeExecuteToolCall)(tool, await (0, generateToolCall_js_1.generateToolCall)({ model, tool, prompt: expandedPrompt, ...options }), options),
     });
 }
 exports.useTool = useTool;

package/tool/use-tool/useTool.d.ts

@@ -13,4 +13,8 @@ import { ToolCallGenerationModel, ToolCallGenerationModelSettings } from "../gen
  * @see {@link generateToolCall}
  * @see {@link executeTool}
  */
-export declare function useTool<PROMPT, TOOL extends Tool<string, any, any>>(model: ToolCallGenerationModel<PROMPT, ToolCallGenerationModelSettings>, tool: TOOL, prompt: PROMPT | ((tool: TOOL) => PROMPT), options?: FunctionOptions): Promise<ToolCallResult<TOOL["name"], TOOL["parameters"], Awaited<ReturnType<TOOL["execute"]>>>>;
+export declare function useTool<PROMPT, TOOL extends Tool<string, any, any>>({ model, tool, prompt, ...options }: {
+    model: ToolCallGenerationModel<PROMPT, ToolCallGenerationModelSettings>;
+    tool: TOOL;
+    prompt: PROMPT | ((tool: TOOL) => PROMPT);
+} & FunctionOptions): Promise<ToolCallResult<TOOL["name"], TOOL["parameters"], Awaited<ReturnType<TOOL["execute"]>>>>;

package/tool/use-tool/useTool.js

@@ -12,7 +12,7 @@ import { generateToolCall } from "../generate-tool-call/generateToolCall.js";
  * @see {@link generateToolCall}
  * @see {@link executeTool}
  */
-export async function useTool(model, tool, prompt, options) {
+export async function useTool({ model, tool, prompt, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
@@ -21,6 +21,6 @@ export async function useTool(model, tool, prompt, options) {
         options,
         input: expandedPrompt,
         functionType: "use-tool",
-        execute: async (options) => safeExecuteToolCall(tool, await generateToolCall(model, tool, expandedPrompt, options), options),
+        execute: async (options) => safeExecuteToolCall(tool, await generateToolCall({ model, tool, prompt: expandedPrompt, ...options }), options),
     });
 }

package/tool/use-tools/useTools.cjs

@@ -5,7 +5,7 @@ const executeFunctionCall_js_1 = require("../../core/executeFunctionCall.cjs");
 const ToolCallError_js_1 = require("../ToolCallError.cjs");
 const safeExecuteToolCall_js_1 = require("../execute-tool/safeExecuteToolCall.cjs");
 const generateToolCalls_js_1 = require("../generate-tool-calls/generateToolCalls.cjs");
-async function useTools(model, tools, prompt, options) {
+async function useTools({ model, tools, prompt, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
@@ -15,7 +15,13 @@ async function useTools(model, tools, prompt, options) {
         input: expandedPrompt,
         functionType: "use-tools",
         execute: async (options) => {
-            const modelResponse = await (0, generateToolCalls_js_1.generateToolCalls)(model, tools, expandedPrompt, { ...options, fullResponse: false });
+            const modelResponse = await (0, generateToolCalls_js_1.generateToolCalls)({
+                model,
+                tools,
+                prompt: expandedPrompt,
+                fullResponse: false,
+                ...options,
+            });
             const { toolCalls, text } = modelResponse;
             // no tool calls:
             if (toolCalls == null) {

package/tool/use-tools/useTools.d.ts

@@ -11,7 +11,11 @@ type ToToolCallUnion<T> = {
     [KEY in StringKeys<T>]: T[KEY] extends Tool<any, infer PARAMETERS, infer OUTPUT> ? ToolCallResult<KEY, PARAMETERS, OUTPUT> : never;
 }[StringKeys<T>];
 type ToOutputValue<TOOLS extends ToolArray<Tool<any, any, any>[]>> = ToToolCallUnion<ToToolMap<TOOLS>>;
-export declare function useTools<PROMPT, TOOLS extends Array<Tool<any, any, any>>>(model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>, tools: TOOLS, prompt: PROMPT | ((tools: TOOLS) => PROMPT), options?: FunctionOptions): Promise<{
+export declare function useTools<PROMPT, TOOLS extends Array<Tool<any, any, any>>>({ model, tools, prompt, ...options }: {
+    model: ToolCallsGenerationModel<PROMPT, ToolCallsGenerationModelSettings>;
+    tools: TOOLS;
+    prompt: PROMPT | ((tools: TOOLS) => PROMPT);
+} & FunctionOptions): Promise<{
     text: string | null;
     toolResults: Array<ToOutputValue<TOOLS>> | null;
 }>;

package/tool/use-tools/useTools.js

@@ -2,7 +2,7 @@ import { executeFunctionCall } from "../../core/executeFunctionCall.js";
 import { ToolCallError } from "../ToolCallError.js";
 import { safeExecuteToolCall } from "../execute-tool/safeExecuteToolCall.js";
 import { generateToolCalls } from "../generate-tool-calls/generateToolCalls.js";
-export async function useTools(model, tools, prompt, options) {
+export async function useTools({ model, tools, prompt, ...options }) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
@@ -12,7 +12,13 @@ export async function useTools(model, tools, prompt, options) {
         input: expandedPrompt,
         functionType: "use-tools",
         execute: async (options) => {
-            const modelResponse = await generateToolCalls(model, tools, expandedPrompt, { ...options, fullResponse: false });
+            const modelResponse = await generateToolCalls({
+                model,
+                tools,
+                prompt: expandedPrompt,
+                fullResponse: false,
+                ...options,
+            });
             const { toolCalls, text } = modelResponse;
             // no tool calls:
             if (toolCalls == null) {

package/vector-index/VectorIndexRetriever.cjs

@@ -31,7 +31,11 @@ class VectorIndexRetriever {
         };
     }
     async retrieve(query, options) {
-        const embedding = await (0, embed_js_1.embed)(this.embeddingModel, query, options);
+        const embedding = await (0, embed_js_1.embed)({
+            model: this.embeddingModel,
+            value: query,
+            ...options,
+        });
         const queryResult = await this.vectorIndex.queryByVector({
             queryVector: embedding,
             maxResults: this.settings.maxResults ?? 1,

package/vector-index/VectorIndexRetriever.js

@@ -28,7 +28,11 @@ export class VectorIndexRetriever {
         };
     }
     async retrieve(query, options) {
-        const embedding = await embed(this.embeddingModel, query, options);
+        const embedding = await embed({
+            model: this.embeddingModel,
+            value: query,
+            ...options,
+        });
         const queryResult = await this.vectorIndex.queryByVector({
             queryVector: embedding,
             maxResults: this.settings.maxResults ?? 1,

package/vector-index/upsertIntoVectorIndex.cjs

@@ -12,7 +12,11 @@ async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, generateId =
         inputPropertyName: "objects",
         execute: async (options) => {
             // many embedding models support bulk embedding, so we first embed all texts:
-            const embeddings = await (0, embed_js_1.embedMany)(embeddingModel, objects.map(getValueToEmbed), options);
+            const embeddings = await (0, embed_js_1.embedMany)({
+                model: embeddingModel,
+                values: objects.map(getValueToEmbed),
+                ...options,
+            });
             await vectorIndex.upsertMany(objects.map((object, i) => ({
                 id: getId?.(object, i) ?? generateId(),
                 vector: embeddings[i],

package/vector-index/upsertIntoVectorIndex.js

@@ -9,7 +9,11 @@ export async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, gener
         inputPropertyName: "objects",
         execute: async (options) => {
             // many embedding models support bulk embedding, so we first embed all texts:
-            const embeddings = await embedMany(embeddingModel, objects.map(getValueToEmbed), options);
+            const embeddings = await embedMany({
+                model: embeddingModel,
+                values: objects.map(getValueToEmbed),
+                ...options,
+            });
             await vectorIndex.upsertMany(objects.map((object, i) => ({
                 id: getId?.(object, i) ?? generateId(),
                 vector: embeddings[i],