modelfusion 0.35.2 → 0.36.0

package/core/FunctionEvent.d.ts

@@ -1,5 +1,6 @@
-import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/ExecuteToolEvent.js";
 import { ModelCallFinishedEvent, ModelCallStartedEvent } from "../model-function/ModelCallEvent.js";
+import { RetrieveFinishedEvent, RetrieveStartedEvent } from "../retriever/RetrieveEvent.js";
+import { ExecuteToolFinishedEvent, ExecuteToolStartedEvent } from "../tool/ExecuteToolEvent.js";
 export interface BaseFunctionEvent {
     /**
      * Unique identifier for the function call.
@@ -72,4 +73,4 @@ export interface BaseFunctionFinishedEvent extends BaseFunctionEvent {
      */
     result: BaseFunctionFinishedEventResult;
 }
-export type FunctionEvent = ModelCallStartedEvent | ExecuteToolStartedEvent | ModelCallFinishedEvent | ExecuteToolFinishedEvent;
+export type FunctionEvent = ModelCallStartedEvent | ExecuteToolStartedEvent | RetrieveStartedEvent | ModelCallFinishedEvent | ExecuteToolFinishedEvent | RetrieveFinishedEvent;

package/core/getFunctionCallLogger.cjs

@@ -17,14 +17,15 @@ function getFunctionCallLogger(logging) {
 exports.getFunctionCallLogger = getFunctionCallLogger;
 const basicTextObserver = {
     onFunctionEvent(event) {
+        const text = `[${event.timestamp.toISOString()}] ${event.callId}${event.functionId != null ? ` (${event.functionId})` : ""} - ${event.functionType} ${event.eventType}`;
         // log based on event type:
         switch (event.eventType) {
             case "started": {
-                console.log(`[${event.timestamp.toISOString()}] ${event.callId} - ${event.functionType} ${event.eventType}`);
+                console.log(text);
                 break;
             }
             case "finished": {
-                console.log(`[${event.timestamp.toISOString()}] ${event.callId} - ${event.functionType} ${event.eventType} in ${event.durationInMs}ms`);
+                console.log(`${text} in ${event.durationInMs}ms`);
                 break;
             }
         }

package/core/getFunctionCallLogger.js

@@ -13,14 +13,15 @@ export function getFunctionCallLogger(logging) {
 }
 const basicTextObserver = {
     onFunctionEvent(event) {
+        const text = `[${event.timestamp.toISOString()}] ${event.callId}${event.functionId != null ? ` (${event.functionId})` : ""} - ${event.functionType} ${event.eventType}`;
         // log based on event type:
         switch (event.eventType) {
             case "started": {
-                console.log(`[${event.timestamp.toISOString()}] ${event.callId} - ${event.functionType} ${event.eventType}`);
+                console.log(text);
                 break;
             }
             case "finished": {
-                console.log(`[${event.timestamp.toISOString()}] ${event.callId} - ${event.functionType} ${event.eventType} in ${event.durationInMs}ms`);
+                console.log(`${text} in ${event.durationInMs}ms`);
                 break;
             }
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modelfusion",
   "description": "Build multimodal applications, chatbots, and agents with JavaScript and TypeScript.",
-  "version": "0.35.2",
+  "version": "0.36.0",
   "author": "Lars Grammel",
   "license": "MIT",
   "keywords": [

package/retriever/RetrieveEvent.cjs

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

package/retriever/RetrieveEvent.d.ts

@@ -0,0 +1,10 @@
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+export interface RetrieveStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "retrieve";
+    query: unknown;
+}
+export interface RetrieveFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "retrieve";
+    query: unknown;
+    results: unknown;
+}

package/retriever/RetrieveEvent.js

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

package/retriever/retrieve.cjs

@@ -1,9 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.retrieve = void 0;
+const nanoid_1 = require("nanoid");
+const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
+const GlobalFunctionLogging_js_1 = require("../core/GlobalFunctionLogging.cjs");
+const GlobalFunctionObservers_js_1 = require("../core/GlobalFunctionObservers.cjs");
+const AbortError_js_1 = require("../core/api/AbortError.cjs");
+const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
+const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
+const runSafe_js_1 = require("../util/runSafe.cjs");
 async function retrieve(retriever, query, options) {
-    // TODO add error handling, events, duration tracking, etc.
-    // TODO metadata handling
-    return retriever.retrieve(query, options);
+    const run = options?.run;
+    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
+        observers: [
+            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, GlobalFunctionLogging_js_1.getGlobalFunctionLogging)()),
+            ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
+            ...(run?.functionObserver != null ? [run.functionObserver] : []),
+            ...(options?.observers ?? []),
+        ],
+        errorHandler: run?.errorHandler,
+    });
+    const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
+    const startMetadata = {
+        functionType: "retrieve",
+        callId: `call-${(0, nanoid_1.nanoid)()}`,
+        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 (0, runSafe_js_1.runSafe)(() => retriever.retrieve(query, options));
+    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_js_1.AbortError();
+        }
+        eventSource.notify({
+            ...finishMetadata,
+            eventType: "finished",
+            result: {
+                status: "error",
+                error: result.error,
+            },
+        });
+        throw result.error;
+    }
+    eventSource.notify({
+        ...finishMetadata,
+        eventType: "finished",
+        result: {
+            status: "success",
+            output: result.output,
+        },
+    });
+    return result.output;
 }
 exports.retrieve = retrieve;

package/retriever/retrieve.js

@@ -1,5 +1,73 @@
+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 { startDurationMeasurement } from "../util/DurationMeasurement.js";
+import { runSafe } from "../util/runSafe.js";
 export async function retrieve(retriever, query, options) {
-    // TODO add error handling, events, duration tracking, etc.
-    // TODO metadata handling
-    return retriever.retrieve(query, options);
+    const run = 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 = {
+        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, options));
+    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",
+            output: result.output,
+        },
+    });
+    return result.output;
 }