modelfusion 0.49.0 → 0.51.0

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/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

@@ -17,7 +17,7 @@ const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
  */
 function embedMany(model, values, options) {
     return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "embedding",
+        functionType: "embed",
         input: values,
         model,
         options,
@@ -58,7 +58,7 @@ exports.embedMany = embedMany;
  */
 function embed(model, value, options) {
     return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "embedding",
+        functionType: "embed",
         input: value,
         model,
         options,

package/model-function/embed/embed.js

@@ -14,7 +14,7 @@ import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
  */
 export function embedMany(model, values, options) {
     return new ModelFunctionPromise(executeStandardCall({
-        functionType: "embedding",
+        functionType: "embed",
         input: values,
         model,
         options,
@@ -54,7 +54,7 @@ export function embedMany(model, values, options) {
  */
 export function embed(model, value, options) {
     return new ModelFunctionPromise(executeStandardCall({
-        functionType: "embedding",
+        functionType: "embed",
         input: value,
         model,
         options,

package/model-function/executeStandardCall.cjs

@@ -27,6 +27,7 @@ async function executeStandardCall({ model, options, input, functionType, genera
     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 executeStandardCall({ model, options, input, functionType, genera
         logging: options?.logging,
         observers: options?.observers,
         run,
+        parentCallId: startMetadata.callId,
     }));
     const finishMetadata = {
         eventType: "finished",

package/model-function/executeStandardCall.js

@@ -24,6 +24,7 @@ export async function executeStandardCall({ model, options, input, functionType,
     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 executeStandardCall({ model, options, input, functionType,
         logging: options?.logging,
         observers: options?.observers,
         run,
+        parentCallId: startMetadata.callId,
     }));
     const finishMetadata = {
         eventType: "finished",

package/model-function/executeStreamCall.cjs

@@ -27,6 +27,7 @@ async function executeStreamCall({ model, options, input, functionType, startStr
     const startMetadata = {
         functionType,
         callId: `call-${(0, nanoid_1.nanoid)()}`,
+        parentCallId: options?.parentCallId,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
@@ -47,6 +48,7 @@ async function executeStreamCall({ model, options, input, functionType, startStr
             logging: options?.logging,
             observers: options?.observers,
             run,
+            parentCallId: startMetadata.callId,
         });
         return (async function* () {
             for await (const event of deltaIterable) {

package/model-function/executeStreamCall.js

@@ -24,6 +24,7 @@ export async function executeStreamCall({ model, options, input, functionType, s
     const startMetadata = {
         functionType,
         callId: `call-${createId()}`,
+        parentCallId: options?.parentCallId,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
@@ -44,6 +45,7 @@ export async function executeStreamCall({ model, options, input, functionType, s
             logging: options?.logging,
             observers: options?.observers,
             run,
+            parentCallId: startMetadata.callId,
         });
         return (async function* () {
             for await (const event of deltaIterable) {

package/model-function/generate-image/ImageGenerationEvent.d.ts

@@ -1,6 +1,6 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
 export interface ImageGenerationStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "image-generation";
+    functionType: "generate-image";
 }
 export type ImageGenerationFinishedEventResult = {
     status: "success";
@@ -13,6 +13,6 @@ export type ImageGenerationFinishedEventResult = {
     status: "abort";
 };
 export interface ImageGenerationFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "image-generation";
+    functionType: "generate-image";
     result: ImageGenerationFinishedEventResult;
 }

package/model-function/generate-image/generateImage.cjs

@@ -20,7 +20,7 @@ const ImageGenerationPromise_js_1 = require("./ImageGenerationPromise.cjs");
  */
 function generateImage(model, prompt, options) {
     return new ImageGenerationPromise_js_1.ImageGenerationPromise((0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "image-generation",
+        functionType: "generate-image",
         input: prompt,
         model,
         options,

package/model-function/generate-image/generateImage.js

@@ -17,7 +17,7 @@ import { ImageGenerationPromise } from "./ImageGenerationPromise.js";
  */
 export function generateImage(model, prompt, options) {
     return new ImageGenerationPromise(executeStandardCall({
-        functionType: "image-generation",
+        functionType: "generate-image",
         input: prompt,
         model,
         options,

package/model-function/generate-speech/SpeechGenerationEvent.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
 export interface SpeechGenerationStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "speech-generation";
+    functionType: "generate-speech";
     input: string;
 }
 export type SpeechGenerationFinishedEventResult = {
@@ -15,13 +15,13 @@ export type SpeechGenerationFinishedEventResult = {
     status: "abort";
 };
 export interface SpeechGenerationFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "speech-generation";
+    functionType: "generate-speech";
     input: string;
     result: SpeechGenerationFinishedEventResult;
 }
 export interface SpeechStreamingStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "speech-streaming";
+    functionType: "stream-speech";
 }
 export interface SpeechStreamingFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "speech-streaming";
+    functionType: "stream-speech";
 }

package/model-function/generate-speech/generateSpeech.cjs

@@ -8,7 +8,7 @@ const executeStandardCall_js_1 = require("../executeStandardCall.cjs");
  */
 function generateSpeech(model, text, options) {
     return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "speech-generation",
+        functionType: "generate-speech",
         input: text,
         model,
         options,

package/model-function/generate-speech/generateSpeech.js

@@ -5,7 +5,7 @@ import { executeStandardCall } from "../executeStandardCall.js";
  */
 export function generateSpeech(model, text, options) {
     return new ModelFunctionPromise(executeStandardCall({
-        functionType: "speech-generation",
+        functionType: "generate-speech",
         input: text,
         model,
         options,

package/model-function/generate-speech/streamSpeech.cjs

@@ -20,7 +20,7 @@ function streamSpeech(model, text, options) {
         textStream = text;
     }
     return new AsyncIterableResultPromise_js_1.AsyncIterableResultPromise((0, executeStreamCall_js_1.executeStreamCall)({
-        functionType: "speech-streaming",
+        functionType: "stream-speech",
         input: text,
         model,
         options,

package/model-function/generate-speech/streamSpeech.js

@@ -17,7 +17,7 @@ export function streamSpeech(model, text, options) {
         textStream = text;
     }
     return new AsyncIterableResultPromise(executeStreamCall({
-        functionType: "speech-streaming",
+        functionType: "stream-speech",
         input: text,
         model,
         options,

package/model-function/generate-structure/StructureGenerationEvent.d.ts

@@ -1,6 +1,6 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
 export interface StructureGenerationStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "structure-generation" | "structure-or-text-generation";
+    functionType: "generate-structure" | "generate-structure-or-text";
 }
 export type StructureGenerationFinishedEventResult = {
     status: "success";
@@ -18,6 +18,6 @@ export type StructureGenerationFinishedEventResult = {
     status: "abort";
 };
 export type StructureGenerationFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "structure-generation" | "structure-or-text-generation";
+    functionType: "generate-structure" | "generate-structure-or-text";
     result: StructureGenerationFinishedEventResult;
 };

package/model-function/generate-structure/StructureStreamingEvent.d.ts

@@ -1,7 +1,7 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
 export interface StructureStreamingStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "structure-streaming";
+    functionType: "stream-structure";
 }
 export interface StructureStreamingFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "structure-streaming";
+    functionType: "stream-structure";
 }

package/model-function/generate-structure/generateStructure.cjs

@@ -10,7 +10,7 @@ function generateStructure(model, structureDefinition, prompt, options) {
         ? prompt(structureDefinition)
         : prompt;
     return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "structure-generation",
+        functionType: "generate-structure",
         input: expandedPrompt,
         model,
         options,

package/model-function/generate-structure/generateStructure.js

@@ -7,7 +7,7 @@ export function generateStructure(model, structureDefinition, prompt, options) {
         ? prompt(structureDefinition)
         : prompt;
     return new ModelFunctionPromise(executeStandardCall({
-        functionType: "structure-generation",
+        functionType: "generate-structure",
         input: expandedPrompt,
         model,
         options,

package/model-function/generate-structure/generateStructureOrText.cjs

@@ -11,7 +11,7 @@ function generateStructureOrText(model, structureDefinitions, prompt, options) {
         ? prompt(structureDefinitions)
         : prompt;
     return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "structure-or-text-generation",
+        functionType: "generate-structure-or-text",
         input: expandedPrompt,
         model,
         options,

package/model-function/generate-structure/generateStructureOrText.js

@@ -8,7 +8,7 @@ export function generateStructureOrText(model, structureDefinitions, prompt, opt
         ? prompt(structureDefinitions)
         : prompt;
     return new ModelFunctionPromise(executeStandardCall({
-        functionType: "structure-or-text-generation",
+        functionType: "generate-structure-or-text",
         input: expandedPrompt,
         model,
         options,

package/model-function/generate-structure/streamStructure.cjs

@@ -8,7 +8,7 @@ function streamStructure(model, structureDefinition, prompt, options) {
     let lastStructure;
     let lastFullDelta;
     return new AsyncIterableResultPromise_js_1.AsyncIterableResultPromise((0, executeStreamCall_js_1.executeStreamCall)({
-        functionType: "structure-streaming",
+        functionType: "stream-structure",
         input: prompt,
         model,
         options,

package/model-function/generate-structure/streamStructure.js

@@ -5,7 +5,7 @@ export function streamStructure(model, structureDefinition, prompt, options) {
     let lastStructure;
     let lastFullDelta;
     return new AsyncIterableResultPromise(executeStreamCall({
-        functionType: "structure-streaming",
+        functionType: "stream-structure",
         input: prompt,
         model,
         options,

package/model-function/generate-text/TextGenerationEvent.d.ts

@@ -1,6 +1,6 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
 export interface TextGenerationStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "text-generation";
+    functionType: "generate-text";
 }
 export type TextGenerationFinishedEventResult = {
     status: "success";
@@ -18,12 +18,12 @@ export type TextGenerationFinishedEventResult = {
     status: "abort";
 };
 export interface TextGenerationFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "text-generation";
+    functionType: "generate-text";
     result: TextGenerationFinishedEventResult;
 }
 export interface TextStreamingStartedEvent extends BaseModelCallStartedEvent {
-    functionType: "text-streaming";
+    functionType: "stream-text";
 }
 export interface TextStreamingFinishedEvent extends BaseModelCallFinishedEvent {
-    functionType: "text-streaming";
+    functionType: "stream-text";
 }

package/model-function/generate-text/generateText.cjs

@@ -18,7 +18,7 @@ const ModelFunctionPromise_js_1 = require("../ModelFunctionPromise.cjs");
  */
 function generateText(model, prompt, options) {
     return new ModelFunctionPromise_js_1.ModelFunctionPromise((0, executeStandardCall_js_1.executeStandardCall)({
-        functionType: "text-generation",
+        functionType: "generate-text",
         input: prompt,
         model,
         options,

package/model-function/generate-text/generateText.js

@@ -15,7 +15,7 @@ import { ModelFunctionPromise } from "../ModelFunctionPromise.js";
  */
 export function generateText(model, prompt, options) {
     return new ModelFunctionPromise(executeStandardCall({
-        functionType: "text-generation",
+        functionType: "generate-text",
         input: prompt,
         model,
         options,