modelfusion 0.49.0 → 0.50.0

package/tool/useTool.js

@@ -1,3 +1,4 @@
+import { executeFunctionCall } from "../core/executeFunctionCall.js";
 import { generateStructure } from "../model-function/generate-structure/generateStructure.js";
 import { executeTool } from "./executeTool.js";
 /**
@@ -12,14 +13,21 @@ export async function useTool(model, tool, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
         : prompt;
-    const { value } = await generateStructure(model, {
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    }, expandedPrompt, options).asFullResponse();
-    return {
-        tool: tool.name,
-        parameters: value,
-        result: await executeTool(tool, value, options),
-    };
+    return executeFunctionCall({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool",
+        execute: async (options) => {
+            const { value } = await generateStructure(model, {
+                name: tool.name,
+                description: tool.description,
+                schema: tool.inputSchema,
+            }, expandedPrompt, options).asFullResponse();
+            return {
+                tool: tool.name,
+                parameters: value,
+                result: await executeTool(tool, value, options),
+            };
+        },
+    });
 }

package/tool/useToolOrGenerateText.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useToolOrGenerateText = void 0;
+const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
 const generateStructureOrText_js_1 = require("../model-function/generate-structure/generateStructureOrText.cjs");
 const NoSuchToolError_js_1 = require("./NoSuchToolError.cjs");
 const executeTool_js_1 = require("./executeTool.cjs");
@@ -9,31 +10,38 @@ async function useToolOrGenerateText(model, tools, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
         : prompt;
-    const modelResponse = await (0, generateStructureOrText_js_1.generateStructureOrText)(model, tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    })), expandedPrompt, options);
-    const { structure, text } = modelResponse;
-    if (structure == null) {
-        return {
-            tool: null,
-            parameters: null,
-            result: null,
-            text,
-        };
-    }
-    const tool = tools.find((tool) => tool.name === structure);
-    if (tool == null) {
-        throw new NoSuchToolError_js_1.NoSuchToolError(structure.toString());
-    }
-    const toolParameters = modelResponse.value;
-    const result = await (0, executeTool_js_1.executeTool)(tool, toolParameters, options);
-    return {
-        tool: structure,
-        result,
-        parameters: toolParameters,
-        text: text, // string | null is the expected value here
-    };
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool-or-generate-text",
+        execute: async (options) => {
+            const modelResponse = await (0, generateStructureOrText_js_1.generateStructureOrText)(model, tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                schema: tool.inputSchema,
+            })), expandedPrompt, options);
+            const { structure, text } = modelResponse;
+            if (structure == null) {
+                return {
+                    tool: null,
+                    parameters: null,
+                    result: null,
+                    text,
+                };
+            }
+            const tool = tools.find((tool) => tool.name === structure);
+            if (tool == null) {
+                throw new NoSuchToolError_js_1.NoSuchToolError(structure.toString());
+            }
+            const toolParameters = modelResponse.value;
+            const result = await (0, executeTool_js_1.executeTool)(tool, toolParameters, options);
+            return {
+                tool: structure,
+                result,
+                parameters: toolParameters,
+                text: text, // string | null is the expected value here
+            };
+        },
+    });
 }
 exports.useToolOrGenerateText = useToolOrGenerateText;

package/tool/useToolOrGenerateText.js

@@ -1,3 +1,4 @@
+import { executeFunctionCall } from "../core/executeFunctionCall.js";
 import { generateStructureOrText } from "../model-function/generate-structure/generateStructureOrText.js";
 import { NoSuchToolError } from "./NoSuchToolError.js";
 import { executeTool } from "./executeTool.js";
@@ -6,30 +7,37 @@ export async function useToolOrGenerateText(model, tools, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tools)
         : prompt;
-    const modelResponse = await generateStructureOrText(model, tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    })), expandedPrompt, options);
-    const { structure, text } = modelResponse;
-    if (structure == null) {
-        return {
-            tool: null,
-            parameters: null,
-            result: null,
-            text,
-        };
-    }
-    const tool = tools.find((tool) => tool.name === structure);
-    if (tool == null) {
-        throw new NoSuchToolError(structure.toString());
-    }
-    const toolParameters = modelResponse.value;
-    const result = await executeTool(tool, toolParameters, options);
-    return {
-        tool: structure,
-        result,
-        parameters: toolParameters,
-        text: text, // string | null is the expected value here
-    };
+    return executeFunctionCall({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool-or-generate-text",
+        execute: async (options) => {
+            const modelResponse = await generateStructureOrText(model, tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                schema: tool.inputSchema,
+            })), expandedPrompt, options);
+            const { structure, text } = modelResponse;
+            if (structure == null) {
+                return {
+                    tool: null,
+                    parameters: null,
+                    result: null,
+                    text,
+                };
+            }
+            const tool = tools.find((tool) => tool.name === structure);
+            if (tool == null) {
+                throw new NoSuchToolError(structure.toString());
+            }
+            const toolParameters = modelResponse.value;
+            const result = await executeTool(tool, toolParameters, options);
+            return {
+                tool: structure,
+                result,
+                parameters: toolParameters,
+                text: text, // string | null is the expected value here
+            };
+        },
+    });
 }

package/vector-index/UpsertIntoVectorIndexEvent.cjs

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

package/vector-index/UpsertIntoVectorIndexEvent.d.ts

@@ -0,0 +1,9 @@
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+export interface UpsertIntoVectorIndexStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "upsert-into-vector-index";
+    objects: unknown[];
+}
+export interface UpsertIntoVectorIndexFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "upsert-into-vector-index";
+    objects: unknown[];
+}

package/vector-index/UpsertIntoVectorIndexEvent.js

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

package/vector-index/VectorIndexRetriever.cjs

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

package/vector-index/VectorIndexRetriever.js

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

package/vector-index/index.cjs

@@ -14,6 +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("./UpsertIntoVectorIndexEvent.cjs"), exports);
 __exportStar(require("./VectorIndex.cjs"), exports);
 __exportStar(require("./VectorIndexRetriever.cjs"), exports);
 __exportStar(require("./memory/MemoryVectorIndex.cjs"), exports);

package/vector-index/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./UpsertIntoVectorIndexEvent.js";
 export * from "./VectorIndex.js";
 export * from "./VectorIndexRetriever.js";
 export * from "./memory/MemoryVectorIndex.js";

package/vector-index/index.js

@@ -1,3 +1,4 @@
+export * from "./UpsertIntoVectorIndexEvent.js";
 export * from "./VectorIndex.js";
 export * from "./VectorIndexRetriever.js";
 export * from "./memory/MemoryVectorIndex.js";

package/vector-index/upsertIntoVectorIndex.cjs

@@ -2,14 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.upsertIntoVectorIndex = void 0;
 const nanoid_1 = require("nanoid");
+const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
 const embed_js_1 = require("../model-function/embed/embed.cjs");
 async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, generateId = nanoid_1.nanoid, objects, getValueToEmbed, getId, }, 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);
-    await vectorIndex.upsertMany(objects.map((object, i) => ({
-        id: getId?.(object, i) ?? generateId(),
-        vector: embeddings[i],
-        data: object,
-    })));
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: objects,
+        functionType: "upsert-into-vector-index",
+        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);
+            await vectorIndex.upsertMany(objects.map((object, i) => ({
+                id: getId?.(object, i) ?? generateId(),
+                vector: embeddings[i],
+                data: object,
+            })));
+        },
+    });
 }
 exports.upsertIntoVectorIndex = upsertIntoVectorIndex;

package/vector-index/upsertIntoVectorIndex.js

@@ -1,11 +1,20 @@
 import { nanoid as createId } from "nanoid";
+import { executeFunctionCall } from "../core/executeFunctionCall.js";
 import { embedMany } from "../model-function/embed/embed.js";
 export async function upsertIntoVectorIndex({ vectorIndex, embeddingModel, generateId = createId, objects, getValueToEmbed, getId, }, options) {
-    // many embedding models support bulk embedding, so we first embed all texts:
-    const embeddings = await embedMany(embeddingModel, objects.map(getValueToEmbed), options);
-    await vectorIndex.upsertMany(objects.map((object, i) => ({
-        id: getId?.(object, i) ?? generateId(),
-        vector: embeddings[i],
-        data: object,
-    })));
+    return executeFunctionCall({
+        options,
+        input: objects,
+        functionType: "upsert-into-vector-index",
+        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);
+            await vectorIndex.upsertMany(objects.map((object, i) => ({
+                id: getId?.(object, i) ?? generateId(),
+                vector: embeddings[i],
+                data: object,
+            })));
+        },
+    });
 }