modelfusion 0.49.0 → 0.51.0

package/retriever/retrieve.js

@@ -1,79 +1,11 @@
-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 { executeFunctionCall } from "../core/executeFunctionCall.js";
 export async function retrieve(retriever, query, options) {
-    const run = await getRun(options?.run);
-    const eventSource = new FunctionEventSource({
-        observers: [
-            ...getFunctionCallLogger(options?.logging ?? getGlobalFunctionLogging()),
-            ...getGlobalFunctionObservers(),
-            ...(run?.functionObserver != null ? [run.functionObserver] : []),
-            ...(options?.observers ?? []),
-        ],
-        errorHandler: run?.errorHandler,
-    });
-    const durationMeasurement = startDurationMeasurement();
-    const startMetadata = {
+    return executeFunctionCall({
+        options,
+        input: query,
         functionType: "retrieve",
-        callId: `call-${createId()}`,
-        runId: run?.runId,
-        sessionId: run?.sessionId,
-        userId: run?.userId,
-        functionId: options?.functionId,
-        query,
-        timestamp: durationMeasurement.startDate,
-        startTimestamp: durationMeasurement.startDate,
-    };
-    eventSource.notify({
-        eventType: "started",
-        ...startMetadata,
-    });
-    const result = await runSafe(() => retriever.retrieve(query, {
-        functionId: options?.functionId,
-        logging: options?.logging,
-        observers: options?.observers,
-        run,
-    }));
-    const finishMetadata = {
-        eventType: "finished",
-        ...startMetadata,
-        finishTimestamp: new Date(),
-        durationInMs: durationMeasurement.durationInMs,
-    };
-    if (!result.ok) {
-        if (result.isAborted) {
-            eventSource.notify({
-                ...finishMetadata,
-                eventType: "finished",
-                result: {
-                    status: "abort",
-                },
-            });
-            throw new AbortError();
-        }
-        eventSource.notify({
-            ...finishMetadata,
-            eventType: "finished",
-            result: {
-                status: "error",
-                error: result.error,
-            },
-        });
-        throw result.error;
-    }
-    eventSource.notify({
-        ...finishMetadata,
-        eventType: "finished",
-        result: {
-            status: "success",
-            value: result.value,
-        },
+        execute: (options) => retriever.retrieve(query, options),
+        inputPropertyName: "query",
+        outputPropertyName: "results",
     });
-    return result.value;
 }

package/tool/UseToolEvent.cjs

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

package/tool/UseToolEvent.d.ts

@@ -0,0 +1,7 @@
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+export interface UseToolStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "use-tool";
+}
+export interface UseToolFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "use-tool";
+}

package/tool/UseToolEvent.js

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

package/tool/UseToolOrGenerateTextEvent.cjs

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

package/tool/UseToolOrGenerateTextEvent.d.ts

@@ -0,0 +1,7 @@
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+export interface UseToolOrGenerateTextStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "use-tool-or-generate-text";
+}
+export interface UseToolOrGenerateTextFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "use-tool-or-generate-text";
+}

package/tool/UseToolOrGenerateTextEvent.js

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

package/tool/executeTool.cjs

@@ -69,6 +69,7 @@ async function doExecuteTool(tool, input, options) {
     const metadata = {
         functionType: "execute-tool",
         callId: `call-${(0, nanoid_1.nanoid)()}`,
+        parentCallId: options?.parentCallId,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
@@ -87,6 +88,7 @@ async function doExecuteTool(tool, input, options) {
         logging: options?.logging,
         observers: options?.observers,
         run,
+        parentCallId: metadata.callId,
     }));
     const finishMetadata = {
         ...metadata,

package/tool/executeTool.js

@@ -64,6 +64,7 @@ async function doExecuteTool(tool, input, options) {
     const metadata = {
         functionType: "execute-tool",
         callId: `call-${createId()}`,
+        parentCallId: options?.parentCallId,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
@@ -82,6 +83,7 @@ async function doExecuteTool(tool, input, options) {
         logging: options?.logging,
         observers: options?.observers,
         run,
+        parentCallId: metadata.callId,
     }));
     const finishMetadata = {
         ...metadata,

package/tool/index.cjs

@@ -19,6 +19,8 @@ __exportStar(require("./InvalidToolNameError.cjs"), exports);
 __exportStar(require("./NoSuchToolError.cjs"), exports);
 __exportStar(require("./Tool.cjs"), exports);
 __exportStar(require("./ToolExecutionError.cjs"), exports);
+__exportStar(require("./UseToolEvent.cjs"), exports);
+__exportStar(require("./UseToolOrGenerateTextEvent.cjs"), exports);
 __exportStar(require("./WebSearchTool.cjs"), exports);
 __exportStar(require("./executeTool.cjs"), exports);
 __exportStar(require("./useTool.cjs"), exports);

package/tool/index.d.ts

@@ -3,6 +3,8 @@ export * from "./InvalidToolNameError.js";
 export * from "./NoSuchToolError.js";
 export * from "./Tool.js";
 export * from "./ToolExecutionError.js";
+export * from "./UseToolEvent.js";
+export * from "./UseToolOrGenerateTextEvent.js";
 export * from "./WebSearchTool.js";
 export * from "./executeTool.js";
 export * from "./useTool.js";

package/tool/index.js

@@ -3,6 +3,8 @@ export * from "./InvalidToolNameError.js";
 export * from "./NoSuchToolError.js";
 export * from "./Tool.js";
 export * from "./ToolExecutionError.js";
+export * from "./UseToolEvent.js";
+export * from "./UseToolOrGenerateTextEvent.js";
 export * from "./WebSearchTool.js";
 export * from "./executeTool.js";
 export * from "./useTool.js";

package/tool/useTool.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useTool = void 0;
+const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
 const generateStructure_js_1 = require("../model-function/generate-structure/generateStructure.cjs");
 const executeTool_js_1 = require("./executeTool.cjs");
 /**
@@ -15,15 +16,22 @@ async function useTool(model, tool, prompt, options) {
     const expandedPrompt = typeof prompt === "function"
         ? prompt(tool)
         : prompt;
-    const { value } = await (0, generateStructure_js_1.generateStructure)(model, {
-        name: tool.name,
-        description: tool.description,
-        schema: tool.inputSchema,
-    }, expandedPrompt, options).asFullResponse();
-    return {
-        tool: tool.name,
-        parameters: value,
-        result: await (0, executeTool_js_1.executeTool)(tool, value, options),
-    };
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input: expandedPrompt,
+        functionType: "use-tool",
+        execute: async (options) => {
+            const { value } = await (0, generateStructure_js_1.generateStructure)(model, {
+                name: tool.name,
+                description: tool.description,
+                schema: tool.inputSchema,
+            }, expandedPrompt, options).asFullResponse();
+            return {
+                tool: tool.name,
+                parameters: value,
+                result: await (0, executeTool_js_1.executeTool)(tool, value, options),
+            };
+        },
+    });
 }
 exports.useTool = useTool;

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,
+            })));
+        },
+    });
 }