modelfusion 0.48.0 → 0.50.0

package/core/executeFunctionCall.js

@@ -0,0 +1,81 @@
+import { nanoid as createId } from "nanoid";
+import { FunctionEventSource } from "./FunctionEventSource.js";
+import { getGlobalFunctionLogging } from "./GlobalFunctionLogging.js";
+import { getGlobalFunctionObservers } from "./GlobalFunctionObservers.js";
+import { AbortError } from "./api/AbortError.js";
+import { getFunctionCallLogger } from "./getFunctionCallLogger.js";
+import { getRun } from "./getRun.js";
+import { startDurationMeasurement } from "../util/DurationMeasurement.js";
+import { runSafe } from "../util/runSafe.js";
+export async function executeFunctionCall({ options, input, functionType, execute, inputPropertyName = "input", outputPropertyName = "value", }) {
+    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 = {
+        functionType,
+        callId: `call-${createId()}`,
+        parentCallId: options?.parentCallId,
+        runId: run?.runId,
+        sessionId: run?.sessionId,
+        userId: run?.userId,
+        functionId: options?.functionId,
+        [inputPropertyName]: input,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
+    };
+    eventSource.notify({
+        eventType: "started",
+        ...startMetadata,
+    });
+    const result = await runSafe(() => execute({
+        functionId: options?.functionId,
+        logging: options?.logging,
+        observers: options?.observers,
+        run,
+        parentCallId: startMetadata.callId,
+    }));
+    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",
+            [outputPropertyName]: result.value,
+        },
+    });
+    return result.value;
+}

package/guard/GuardEvent.d.ts

@@ -0,0 +1,7 @@
+import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
+export interface GuardStartedEvent extends BaseFunctionStartedEvent {
+    functionType: "guard";
+}
+export interface GuardFinishedEvent extends BaseFunctionFinishedEvent {
+    functionType: "guard";
+}

package/guard/guard.cjs

@@ -1,72 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.guard = void 0;
+const executeFunctionCall_js_1 = require("../core/executeFunctionCall.cjs");
 async function guard(execute, input, guards, options) {
-    if (typeof guards === "function") {
-        guards = [guards];
-    }
+    const guardList = Array.isArray(guards) ? guards : [guards];
     const maxRetries = options?.maxRetries ?? 1;
-    let attempts = 0;
-    while (attempts <= maxRetries) {
-        let result;
-        try {
-            result = {
-                type: "value",
-                input,
-                output: await execute(input),
-            };
-        }
-        catch (error) {
-            result = {
-                type: "error",
-                input,
-                error,
-            };
-        }
-        let isValid = true;
-        for (const guard of guards) {
-            const guardResult = await guard(result);
-            if (guardResult === undefined) {
-                continue;
-            }
-            switch (guardResult.action) {
-                case "passThrough": {
-                    break;
-                }
-                case "retry": {
-                    input = guardResult.input;
-                    isValid = false;
-                    break;
-                }
-                case "return": {
+    return (0, executeFunctionCall_js_1.executeFunctionCall)({
+        options,
+        input,
+        functionType: "guard",
+        execute: async (options) => {
+            let attempts = 0;
+            while (attempts <= maxRetries) {
+                let result;
+                try {
                     result = {
                         type: "value",
                         input,
-                        output: guardResult.output,
+                        output: await execute(input, options),
                     };
-                    break;
                 }
-                case "throwError": {
+                catch (error) {
                     result = {
                         type: "error",
                         input,
-                        error: guardResult.error,
+                        error,
                     };
-                    break;
                 }
+                let isValid = true;
+                for (const guard of guardList) {
+                    const guardResult = await guard(result);
+                    if (guardResult === undefined) {
+                        continue;
+                    }
+                    switch (guardResult.action) {
+                        case "passThrough": {
+                            break;
+                        }
+                        case "retry": {
+                            input = guardResult.input;
+                            isValid = false;
+                            break;
+                        }
+                        case "return": {
+                            result = {
+                                type: "value",
+                                input,
+                                output: guardResult.output,
+                            };
+                            break;
+                        }
+                        case "throwError": {
+                            result = {
+                                type: "error",
+                                input,
+                                error: guardResult.error,
+                            };
+                            break;
+                        }
+                    }
+                }
+                if (isValid) {
+                    if (result.type === "value") {
+                        return result.output;
+                    }
+                    else {
+                        throw result.error;
+                    }
+                }
+                attempts++;
             }
-        }
-        if (isValid) {
-            if (result.type === "value") {
-                return result.output;
-            }
-            else {
-                throw result.error;
-            }
-        }
-        attempts++;
-    }
-    throw new Error(`Maximum retry attempts of ${maxRetries} reached ` +
-        `without producing a valid output or handling an error after ${attempts} attempts.`);
+            throw new Error(`Maximum retry attempts of ${maxRetries} reached ` +
+                `without producing a valid output or handling an error after ${attempts} attempts.`);
+        },
+    });
 }
 exports.guard = guard;

package/guard/guard.d.ts

@@ -1,3 +1,4 @@
+import { FunctionOptions } from "../core/FunctionOptions.js";
 type OutputResult<INPUT, OUTPUT> = {
     type: "value";
     input: INPUT;
@@ -22,7 +23,7 @@ export type Guard<INPUT, OUTPUT> = ({ type, input, output, error, }: OutputResul
 } | {
     action: "passThrough";
 } | undefined>;
-export declare function guard<INPUT, OUTPUT>(execute: (input: INPUT) => PromiseLike<OUTPUT>, input: INPUT, guards: Guard<INPUT, OUTPUT> | Array<Guard<INPUT, OUTPUT>>, options?: {
+export declare function guard<INPUT, OUTPUT>(execute: (input: INPUT, options?: FunctionOptions) => PromiseLike<OUTPUT>, input: INPUT, guards: Guard<INPUT, OUTPUT> | Array<Guard<INPUT, OUTPUT>>, options?: FunctionOptions & {
     maxRetries: number;
 }): Promise<OUTPUT | undefined>;
 export {};

package/guard/guard.js

@@ -1,68 +1,74 @@
+import { executeFunctionCall } from "../core/executeFunctionCall.js";
 export async function guard(execute, input, guards, options) {
-    if (typeof guards === "function") {
-        guards = [guards];
-    }
+    const guardList = Array.isArray(guards) ? guards : [guards];
     const maxRetries = options?.maxRetries ?? 1;
-    let attempts = 0;
-    while (attempts <= maxRetries) {
-        let result;
-        try {
-            result = {
-                type: "value",
-                input,
-                output: await execute(input),
-            };
-        }
-        catch (error) {
-            result = {
-                type: "error",
-                input,
-                error,
-            };
-        }
-        let isValid = true;
-        for (const guard of guards) {
-            const guardResult = await guard(result);
-            if (guardResult === undefined) {
-                continue;
-            }
-            switch (guardResult.action) {
-                case "passThrough": {
-                    break;
-                }
-                case "retry": {
-                    input = guardResult.input;
-                    isValid = false;
-                    break;
-                }
-                case "return": {
+    return executeFunctionCall({
+        options,
+        input,
+        functionType: "guard",
+        execute: async (options) => {
+            let attempts = 0;
+            while (attempts <= maxRetries) {
+                let result;
+                try {
                     result = {
                         type: "value",
                         input,
-                        output: guardResult.output,
+                        output: await execute(input, options),
                     };
-                    break;
                 }
-                case "throwError": {
+                catch (error) {
                     result = {
                         type: "error",
                         input,
-                        error: guardResult.error,
+                        error,
                     };
-                    break;
                 }
+                let isValid = true;
+                for (const guard of guardList) {
+                    const guardResult = await guard(result);
+                    if (guardResult === undefined) {
+                        continue;
+                    }
+                    switch (guardResult.action) {
+                        case "passThrough": {
+                            break;
+                        }
+                        case "retry": {
+                            input = guardResult.input;
+                            isValid = false;
+                            break;
+                        }
+                        case "return": {
+                            result = {
+                                type: "value",
+                                input,
+                                output: guardResult.output,
+                            };
+                            break;
+                        }
+                        case "throwError": {
+                            result = {
+                                type: "error",
+                                input,
+                                error: guardResult.error,
+                            };
+                            break;
+                        }
+                    }
+                }
+                if (isValid) {
+                    if (result.type === "value") {
+                        return result.output;
+                    }
+                    else {
+                        throw result.error;
+                    }
+                }
+                attempts++;
             }
-        }
-        if (isValid) {
-            if (result.type === "value") {
-                return result.output;
-            }
-            else {
-                throw result.error;
-            }
-        }
-        attempts++;
-    }
-    throw new Error(`Maximum retry attempts of ${maxRetries} reached ` +
-        `without producing a valid output or handling an error after ${attempts} attempts.`);
+            throw new Error(`Maximum retry attempts of ${maxRetries} reached ` +
+                `without producing a valid output or handling an error after ${attempts} attempts.`);
+        },
+    });
 }

package/guard/index.cjs

@@ -14,5 +14,6 @@ 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("./GuardEvent.cjs"), exports);
 __exportStar(require("./fixStructure.cjs"), exports);
 __exportStar(require("./guard.cjs"), exports);

package/guard/index.d.ts

@@ -1,2 +1,3 @@
+export * from "./GuardEvent.js";
 export * from "./fixStructure.js";
 export * from "./guard.js";

package/guard/index.js

@@ -1,2 +1,3 @@
+export * from "./GuardEvent.js";
 export * from "./fixStructure.js";
 export * from "./guard.js";

package/model-function/AsyncIterableResultPromise.cjs

@@ -13,25 +13,25 @@ class AsyncIterableResultPromise extends Promise {
             writable: true,
             value: fullPromise
         });
-        Object.defineProperty(this, "outputPromise", {
+        Object.defineProperty(this, "valuePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.outputPromise = fullPromise.then((result) => result.output);
+        this.valuePromise = fullPromise.then((result) => result.value);
     }
     asFullResponse() {
         return this.fullPromise;
     }
     then(onfulfilled, onrejected) {
-        return this.outputPromise.then(onfulfilled, onrejected);
+        return this.valuePromise.then(onfulfilled, onrejected);
     }
     catch(onrejected) {
-        return this.outputPromise.catch(onrejected);
+        return this.valuePromise.catch(onrejected);
     }
     finally(onfinally) {
-        return this.outputPromise.finally(onfinally);
+        return this.valuePromise.finally(onfinally);
     }
 }
 exports.AsyncIterableResultPromise = AsyncIterableResultPromise;

package/model-function/AsyncIterableResultPromise.d.ts

@@ -1,13 +1,13 @@
 import { ModelCallMetadata } from "./ModelCallMetadata.js";
 export declare class AsyncIterableResultPromise<T> extends Promise<AsyncIterable<T>> {
     private fullPromise;
-    private outputPromise;
+    private valuePromise;
     constructor(fullPromise: Promise<{
-        output: AsyncIterable<T>;
+        value: AsyncIterable<T>;
         metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
     }>);
     asFullResponse(): Promise<{
-        output: AsyncIterable<T>;
+        value: AsyncIterable<T>;
         metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
     }>;
     then<TResult1 = AsyncIterable<T>, TResult2 = never>(onfulfilled?: ((value: AsyncIterable<T>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;

package/model-function/AsyncIterableResultPromise.js

@@ -10,24 +10,24 @@ export class AsyncIterableResultPromise extends Promise {
             writable: true,
             value: fullPromise
         });
-        Object.defineProperty(this, "outputPromise", {
+        Object.defineProperty(this, "valuePromise", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.outputPromise = fullPromise.then((result) => result.output);
+        this.valuePromise = fullPromise.then((result) => result.value);
     }
     asFullResponse() {
         return this.fullPromise;
     }
     then(onfulfilled, onrejected) {
-        return this.outputPromise.then(onfulfilled, onrejected);
+        return this.valuePromise.then(onfulfilled, onrejected);
     }
     catch(onrejected) {
-        return this.outputPromise.catch(onrejected);
+        return this.valuePromise.catch(onrejected);
     }
     finally(onfinally) {
-        return this.outputPromise.finally(onfinally);
+        return this.valuePromise.finally(onfinally);
     }
 }

package/model-function/Model.d.ts

@@ -18,7 +18,7 @@ export interface Model<SETTINGS extends ModelSettings> {
      * The `withSettings` method creates a new model with the same configuration as the original model, but with the specified settings changed.
      *
      * @example
-     * const model = new OpenAITextGenerationModel({
+     * const model = new OpenAICompletionModel({
      *   model: "gpt-3.5-turbo-instruct",
      *   maxCompletionTokens: 500,
      * });

package/model-function/ModelCallEvent.d.ts

@@ -1,14 +1,12 @@
 import { BaseFunctionFinishedEvent, BaseFunctionStartedEvent } from "../core/FunctionEvent.js";
 import { ModelInformation } from "./ModelInformation.js";
-import { ImageDescriptionFinishedEvent, ImageDescriptionStartedEvent } from "./describe-image/ImageDescriptionEvent.js";
 import { EmbeddingFinishedEvent, EmbeddingStartedEvent } from "./embed/EmbeddingEvent.js";
 import { ImageGenerationFinishedEvent, ImageGenerationStartedEvent } from "./generate-image/ImageGenerationEvent.js";
+import { SpeechGenerationFinishedEvent, SpeechGenerationStartedEvent, SpeechStreamingFinishedEvent, SpeechStreamingStartedEvent } from "./generate-speech/SpeechGenerationEvent.js";
 import { StructureGenerationFinishedEvent, StructureGenerationStartedEvent } from "./generate-structure/StructureGenerationEvent.js";
 import { StructureStreamingFinishedEvent, StructureStreamingStartedEvent } from "./generate-structure/StructureStreamingEvent.js";
-import { TextGenerationFinishedEvent, TextGenerationStartedEvent } from "./generate-text/TextGenerationEvent.js";
-import { TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextStreamingEvent.js";
-import { SpeechSynthesisFinishedEvent, SpeechSynthesisStartedEvent } from "./synthesize-speech/SpeechSynthesisEvent.js";
-import { TranscriptionFinishedEvent, TranscriptionStartedEvent } from "./transcribe-speech/TranscriptionEvent.js";
+import { TextGenerationFinishedEvent, TextGenerationStartedEvent, TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextGenerationEvent.js";
+import { TranscriptionFinishedEvent, TranscriptionStartedEvent } from "./generate-transcription/TranscriptionEvent.js";
 export interface BaseModelCallStartedEvent extends BaseFunctionStartedEvent {
     model: ModelInformation;
     /**
@@ -49,5 +47,5 @@ export interface BaseModelCallFinishedEvent extends BaseFunctionFinishedEvent {
      */
     result: BaseModelCallFinishedEventResult;
 }
-export type ModelCallStartedEvent = EmbeddingStartedEvent | ImageDescriptionStartedEvent | ImageGenerationStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | SpeechSynthesisStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
-export type ModelCallFinishedEvent = EmbeddingFinishedEvent | ImageDescriptionFinishedEvent | ImageGenerationFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | SpeechSynthesisFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;
+export type ModelCallStartedEvent = EmbeddingStartedEvent | ImageGenerationStartedEvent | SpeechGenerationStartedEvent | SpeechStreamingStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
+export type ModelCallFinishedEvent = EmbeddingFinishedEvent | ImageGenerationFinishedEvent | SpeechGenerationFinishedEvent | SpeechStreamingFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;

package/model-function/embed/EmbeddingEvent.d.ts

@@ -1,7 +1,7 @@
 import { Vector } from "../../core/Vector.js";
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
 export interface EmbeddingStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "embedding";
+    functionType: "embed";
     input: unknown | Array<unknown>;
 }
 export type EmbeddingFinishedEventResult = {
@@ -15,7 +15,7 @@ export type EmbeddingFinishedEventResult = {
     status: "abort";
 };
 export interface EmbeddingFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "embedding";
+    functionType: "embed";
     input: unknown | Array<unknown>;
     result: EmbeddingFinishedEventResult;
 }

package/model-function/embed/embed.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.embed = exports.embedMany = void 0;
-const executeCall_js_1 = require("../executeCall.cjs");
+const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
 const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
 /**
  * Generate embeddings for multiple values.
@@ -16,8 +16,8 @@ const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
  * );
  */
 function embedMany(model, values, options) {
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
-        functionType: "embedding",
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
+        functionType: "embed",
         input: values,
         model,
         options,
@@ -57,8 +57,8 @@ exports.embedMany = embedMany;
  * );
  */
 function embed(model, value, options) {
-    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeCall_js_1.executeCall)({
-        functionType: "embedding",
+    return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
+        functionType: "embed",
         input: value,
         model,
         options,

package/model-function/embed/embed.js

@@ -1,4 +1,4 @@
-import { executeCall } from "../executeCall.js";
+import { executeStandardCall } from "../executeStandardCall.js";
 import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
 /**
  * Generate embeddings for multiple values.
@@ -13,8 +13,8 @@ import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
  * );
  */
 export function embedMany(model, values, options) {
-    return new ModelFunctionPromise(executeCall({
-        functionType: "embedding",
+    return new ModelFunctionPromise(executeStandardCall({
+        functionType: "embed",
         input: values,
         model,
         options,
@@ -53,8 +53,8 @@ export function embedMany(model, values, options) {
  * );
  */
 export function embed(model, value, options) {
-    return new ModelFunctionPromise(executeCall({
-        functionType: "embedding",
+    return new ModelFunctionPromise(executeStandardCall({
+        functionType: "embed",
         input: value,
         model,
         options,

package/model-function/{executeCall.cjs → executeStandardCall.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeCall = void 0;
+exports.executeStandardCall = void 0;
 const nanoid_1 = require("nanoid");
 const FunctionEventSource_js_1 = require("../core/FunctionEventSource.cjs");
 const GlobalFunctionLogging_js_1 = require("../core/GlobalFunctionLogging.cjs");
@@ -10,7 +10,7 @@ const getFunctionCallLogger_js_1 = require("../core/getFunctionCallLogger.cjs");
 const getRun_js_1 = require("../core/getRun.cjs");
 const DurationMeasurement_js_1 = require("../util/DurationMeasurement.cjs");
 const runSafe_js_1 = require("../util/runSafe.cjs");
-async function executeCall({ model, options, input, functionType, generateResponse, }) {
+async function executeStandardCall({ model, options, input, functionType, generateResponse, }) {
     const run = await (0, getRun_js_1.getRun)(options?.run);
     const settings = model.settings;
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
@@ -27,6 +27,7 @@ async function executeCall({ model, options, input, functionType, generateRespon
     const startMetadata = {
         functionType,
         callId: `call-${(0, nanoid_1.nanoid)()}`,
+        parentCallId: options?.parentCallId,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
@@ -46,6 +47,7 @@ async function executeCall({ model, options, input, functionType, generateRespon
         logging: options?.logging,
         observers: options?.observers,
         run,
+        parentCallId: startMetadata.callId,
     }));
     const finishMetadata = {
         eventType: "finished",
@@ -104,4 +106,4 @@ async function executeCall({ model, options, input, functionType, generateRespon
         },
     };
 }
-exports.executeCall = executeCall;
+exports.executeStandardCall = executeStandardCall;

package/model-function/{executeCall.d.ts → executeStandardCall.d.ts}

@@ -2,7 +2,7 @@ import { FunctionOptions } from "../core/FunctionOptions.js";
 import { Model, ModelSettings } from "./Model.js";
 import { ModelCallStartedEvent } from "./ModelCallEvent.js";
 import { ModelCallMetadata } from "./ModelCallMetadata.js";
-export declare function executeCall<VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, generateResponse, }: {
+export declare function executeStandardCall<VALUE, MODEL extends Model<ModelSettings>>({ model, options, input, functionType, generateResponse, }: {
     model: MODEL;
     options?: FunctionOptions;
     input: unknown;

package/model-function/{executeCall.js → executeStandardCall.js}

@@ -7,7 +7,7 @@ import { getFunctionCallLogger } from "../core/getFunctionCallLogger.js";
 import { getRun } from "../core/getRun.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { runSafe } from "../util/runSafe.js";
-export async function executeCall({ model, options, input, functionType, generateResponse, }) {
+export async function executeStandardCall({ model, options, input, functionType, generateResponse, }) {
     const run = await getRun(options?.run);
     const settings = model.settings;
     const eventSource = new FunctionEventSource({
@@ -24,6 +24,7 @@ export async function executeCall({ model, options, input, functionType, generat
     const startMetadata = {
         functionType,
         callId: `call-${createId()}`,
+        parentCallId: options?.parentCallId,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
@@ -43,6 +44,7 @@ export async function executeCall({ model, options, input, functionType, generat
         logging: options?.logging,
         observers: options?.observers,
         run,
+        parentCallId: startMetadata.callId,
     }));
     const finishMetadata = {
         eventType: "finished",