modelfusion 0.21.0 → 0.22.0

package/model-function/executeCall.js

@@ -1,17 +1,15 @@
 import { nanoid as createId } from "nanoid";
-import { FunctionEventSource } from "../run/FunctionEventSource.js";
-import { getGlobalFunctionObservers } from "../run/GlobalFunctionObservers.js";
+import { FunctionEventSource } from "../core/FunctionEventSource.js";
+import { getGlobalFunctionObservers } from "../core/GlobalFunctionObservers.js";
 import { startDurationMeasurement } from "../util/DurationMeasurement.js";
 import { AbortError } from "../util/api/AbortError.js";
 import { runSafe } from "../util/runSafe.js";
-export function executeCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+export function executeCall({ model, options, input, functionType, generateResponse, extractOutputValue, }) {
     return new ModelFunctionPromise(doExecuteCall({
         model,
         options,
-        getStartEvent,
-        getAbortEvent,
-        getFailureEvent,
-        getSuccessEvent,
+        input,
+        functionType,
         generateResponse,
         extractOutputValue,
     }));
@@ -49,7 +47,7 @@ export class ModelFunctionPromise extends Promise {
         return this.outputPromise.finally(onfinally);
     }
 }
-async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, getFailureEvent, getSuccessEvent, generateResponse, extractOutputValue, }) {
+async function doExecuteCall({ model, options, input, functionType, generateResponse, extractOutputValue, }) {
     if (options?.settings != null) {
         model = model.withSettings(options.settings);
         options = {
@@ -77,13 +75,16 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
+        functionType,
+        input,
+        settings,
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     };
-    eventSource.notify(getStartEvent({
+    eventSource.notify({
         ...startMetadata,
         eventType: "started",
-    }, settings));
+    });
     const result = await runSafe(() => generateResponse({
         functionId: options?.functionId,
         settings,
@@ -97,24 +98,36 @@ async function doExecuteCall({ model, options, getStartEvent, getAbortEvent, get
     };
     if (!result.ok) {
         if (result.isAborted) {
-            eventSource.notify(getAbortEvent({
+            eventSource.notify({
                 ...finishMetadata,
-                status: "abort",
-            }, settings));
+                eventType: "finished",
+                result: {
+                    status: "abort",
+                },
+            });
             throw new AbortError();
         }
-        eventSource.notify(getFailureEvent({
+        eventSource.notify({
             ...finishMetadata,
-            status: "error",
-        }, settings, result.error));
+            eventType: "finished",
+            result: {
+                status: "error",
+                error: result.error,
+            },
+        });
         throw result.error;
     }
     const response = result.output;
     const output = extractOutputValue(response);
-    eventSource.notify(getSuccessEvent({
+    eventSource.notify({
         ...finishMetadata,
-        status: "success",
-    }, settings, response, output));
+        eventType: "finished",
+        result: {
+            status: "success",
+            response,
+            output,
+        },
+    });
     return {
         output,
         response,

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

@@ -1,20 +1,18 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export type ImageGenerationStartedEvent = BaseModelCallStartedEvent & {
+export interface ImageGenerationStartedEvent extends BaseModelCallStartedEvent {
     functionType: "image-generation";
-    settings: unknown;
-    prompt: unknown;
-};
-export type ImageGenerationFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "image-generation";
-    settings: unknown;
-    prompt: unknown;
-} & ({
+}
+export type ImageGenerationFinishedEventResult = {
     status: "success";
     response: unknown;
-    generatedImage: string;
+    output: string;
 } | {
     status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface ImageGenerationFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "image-generation";
+    result: ImageGenerationFinishedEventResult;
+}

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

@@ -19,37 +19,12 @@ const executeCall_js_1 = require("../executeCall.cjs");
  */
 function generateImage(model, prompt, options) {
     return (0, executeCall_js_1.executeCall)({
+        functionType: "image-generation",
+        input: prompt,
         model,
         options,
         generateResponse: (options) => model.generateImageResponse(prompt, options),
         extractOutputValue: model.extractBase64Image,
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-            response,
-            generatedImage: output,
-        }),
     });
 }
 exports.generateImage = generateImage;

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

@@ -16,36 +16,11 @@ import { executeCall } from "../executeCall.js";
  */
 export function generateImage(model, prompt, options) {
     return executeCall({
+        functionType: "image-generation",
+        input: prompt,
         model,
         options,
         generateResponse: (options) => model.generateImageResponse(prompt, options),
         extractOutputValue: model.extractBase64Image,
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "image-generation",
-            settings,
-            prompt,
-            response,
-            generatedImage: output,
-        }),
     });
 }

package/model-function/generate-json/JsonGenerationEvent.d.ts

@@ -1,20 +1,7 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export type JsonGenerationStartedEvent = BaseModelCallStartedEvent & {
+export interface JsonGenerationStartedEvent extends BaseModelCallStartedEvent {
     functionType: "json-generation" | "json-or-text-generation";
-    settings: unknown;
-    prompt: unknown;
-};
+}
 export type JsonGenerationFinishedEvent = BaseModelCallFinishedEvent & {
     functionType: "json-generation" | "json-or-text-generation";
-    settings: unknown;
-    prompt: unknown;
-} & ({
-    status: "success";
-    response: unknown;
-    generatedJson: unknown;
-} | {
-    status: "error";
-    error: unknown;
-} | {
-    status: "abort";
-});
+};

package/model-function/generate-json/generateJson.cjs

@@ -6,6 +6,8 @@ const SchemaValidationError_js_1 = require("./SchemaValidationError.cjs");
 function generateJson(model, schemaDefinition, prompt, options) {
     const expandedPrompt = prompt(schemaDefinition);
     return (0, executeCall_js_1.executeCall)({
+        functionType: "json-generation",
+        input: expandedPrompt,
         model,
         options,
         generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
@@ -21,33 +23,6 @@ function generateJson(model, schemaDefinition, prompt, options) {
             }
             return parseResult.data;
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "json-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "json-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "json-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "json-generation",
-            settings,
-            prompt,
-            response,
-            generatedJson: output,
-        }),
     });
 }
 exports.generateJson = generateJson;

package/model-function/generate-json/generateJson.js

@@ -3,6 +3,8 @@ import { SchemaValidationError } from "./SchemaValidationError.js";
 export function generateJson(model, schemaDefinition, prompt, options) {
     const expandedPrompt = prompt(schemaDefinition);
     return executeCall({
+        functionType: "json-generation",
+        input: expandedPrompt,
         model,
         options,
         generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
@@ -18,32 +20,5 @@ export function generateJson(model, schemaDefinition, prompt, options) {
             }
             return parseResult.data;
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "json-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "json-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "json-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "json-generation",
-            settings,
-            prompt,
-            response,
-            generatedJson: output,
-        }),
     });
 }

package/model-function/generate-json/generateJsonOrText.cjs

@@ -7,6 +7,8 @@ const SchemaValidationError_js_1 = require("./SchemaValidationError.cjs");
 function generateJsonOrText(model, schemaDefinitions, prompt, options) {
     const expandedPrompt = prompt(schemaDefinitions);
     return (0, executeCall_js_1.executeCall)({
+        functionType: "json-or-text-generation",
+        input: expandedPrompt,
         model,
         options,
         generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
@@ -34,33 +36,6 @@ function generateJsonOrText(model, schemaDefinitions, prompt, options) {
                 text: text, // text is string | null, which is part of the response for schema values
             };
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "json-or-text-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "json-or-text-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "json-or-text-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "json-or-text-generation",
-            settings,
-            prompt,
-            response,
-            generatedJson: output,
-        }),
     });
 }
 exports.generateJsonOrText = generateJsonOrText;

package/model-function/generate-json/generateJsonOrText.js

@@ -4,6 +4,8 @@ import { SchemaValidationError } from "./SchemaValidationError.js";
 export function generateJsonOrText(model, schemaDefinitions, prompt, options) {
     const expandedPrompt = prompt(schemaDefinitions);
     return executeCall({
+        functionType: "json-or-text-generation",
+        input: expandedPrompt,
         model,
         options,
         generateResponse: (options) => model.generateJsonResponse(expandedPrompt, options),
@@ -31,32 +33,5 @@ export function generateJsonOrText(model, schemaDefinitions, prompt, options) {
                 text: text, // text is string | null, which is part of the response for schema values
             };
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "json-or-text-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "json-or-text-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "json-or-text-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "json-or-text-generation",
-            settings,
-            prompt,
-            response,
-            generatedJson: output,
-        }),
     });
 }

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

@@ -1,20 +1,20 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export type TextGenerationStartedEvent = BaseModelCallStartedEvent & {
+export interface TextGenerationStartedEvent extends BaseModelCallStartedEvent {
     functionType: "text-generation";
-    settings: unknown;
     prompt: unknown;
-};
-export type TextGenerationFinishedEvent = BaseModelCallFinishedEvent & {
-    functionType: "text-generation";
-    settings: unknown;
-    prompt: unknown;
-} & ({
+}
+export type TextGenerationFinishedEventResult = {
     status: "success";
     response: unknown;
-    generatedText: string;
+    output: string;
 } | {
     status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface TextGenerationFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "text-generation";
+    prompt: unknown;
+    result: TextGenerationFinishedEventResult;
+}

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

@@ -1,20 +1,7 @@
 import { BaseModelCallFinishedEvent, BaseModelCallStartedEvent } from "../ModelCallEvent.js";
-export type TextStreamingStartedEvent = BaseModelCallStartedEvent & {
+export interface TextStreamingStartedEvent extends BaseModelCallStartedEvent {
     functionType: "text-streaming";
-    settings: unknown;
-    prompt: unknown;
-};
-export type TextStreamingFinishedEvent = BaseModelCallFinishedEvent & {
+}
+export interface TextStreamingFinishedEvent extends BaseModelCallFinishedEvent {
     functionType: "text-streaming";
-    settings: unknown;
-    prompt: unknown;
-} & ({
-    status: "success";
-    response: unknown;
-    generatedText: string;
-} | {
-    status: "error";
-    error: unknown;
-} | {
-    status: "abort";
-});
+}

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

@@ -18,6 +18,8 @@ function generateText(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 model, prompt, options) {
     return (0, executeCall_js_1.executeCall)({
+        functionType: "text-generation",
+        input: prompt,
         model,
         options,
         generateResponse: (options) => model.generateTextResponse(prompt, options),
@@ -27,33 +29,6 @@ model, prompt, options) {
                 ? model.extractText(result).trim()
                 : model.extractText(result);
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-generation",
-            settings,
-            prompt,
-            response,
-            generatedText: output,
-        }),
     });
 }
 exports.generateText = generateText;

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

@@ -15,6 +15,8 @@ export function generateText(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 model, prompt, options) {
     return executeCall({
+        functionType: "text-generation",
+        input: prompt,
         model,
         options,
         generateResponse: (options) => model.generateTextResponse(prompt, options),
@@ -24,32 +26,5 @@ model, prompt, options) {
                 ? model.extractText(result).trim()
                 : model.extractText(result);
         },
-        getStartEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-generation",
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            ...metadata,
-            functionType: "text-generation",
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            ...metadata,
-            functionType: "text-generation",
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            ...metadata,
-            functionType: "text-generation",
-            settings,
-            prompt,
-            response,
-            generatedText: output,
-        }),
     });
 }

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamText = exports.StreamTextPromise = void 0;
 const nanoid_1 = require("nanoid");
-const FunctionEventSource_js_1 = require("../../run/FunctionEventSource.cjs");
-const GlobalFunctionObservers_js_1 = require("../../run/GlobalFunctionObservers.cjs");
+const FunctionEventSource_js_1 = require("../../core/FunctionEventSource.cjs");
+const GlobalFunctionObservers_js_1 = require("../../core/GlobalFunctionObservers.cjs");
 const DurationMeasurement_js_1 = require("../../util/DurationMeasurement.cjs");
 const AbortError_js_1 = require("../../util/api/AbortError.cjs");
 const runSafe_js_1 = require("../../util/runSafe.cjs");
@@ -74,15 +74,15 @@ async function doStreamText(model, prompt, options) {
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
+        functionType: "text-streaming",
+        input: prompt,
+        settings,
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     };
     eventSource.notify({
         ...startMetadata,
-        functionType: "text-streaming",
         eventType: "started",
-        settings,
-        prompt,
     });
     const result = await (0, runSafe_js_1.runSafe)(async () => (0, extractTextDeltas_js_1.extractTextDeltas)({
         deltaIterable: await model.generateDeltaStreamResponse(prompt, {
@@ -100,12 +100,11 @@ async function doStreamText(model, prompt, options) {
             };
             eventSource.notify({
                 ...finishMetadata,
-                functionType: "text-streaming",
-                status: "success",
-                settings,
-                prompt,
-                response: lastFullDelta,
-                generatedText: fullText,
+                result: {
+                    status: "success",
+                    response: lastFullDelta,
+                    output: fullText,
+                },
             });
         },
         onError: (error) => {
@@ -118,18 +117,16 @@ async function doStreamText(model, prompt, options) {
             eventSource.notify(error instanceof AbortError_js_1.AbortError
                 ? {
                     ...finishMetadata,
-                    functionType: "text-streaming",
-                    status: "abort",
-                    settings,
-                    prompt,
+                    result: {
+                        status: "abort",
+                    },
                 }
                 : {
                     ...finishMetadata,
-                    functionType: "text-streaming",
-                    status: "error",
-                    settings,
-                    prompt,
-                    error,
+                    result: {
+                        status: "error",
+                        error,
+                    },
                 });
         },
     }));
@@ -143,20 +140,18 @@ async function doStreamText(model, prompt, options) {
         if (result.isAborted) {
             eventSource.notify({
                 ...finishMetadata,
-                functionType: "text-streaming",
-                status: "abort",
-                settings,
-                prompt,
+                result: {
+                    status: "abort",
+                },
             });
             throw new AbortError_js_1.AbortError();
         }
         eventSource.notify({
             ...finishMetadata,
-            functionType: "text-streaming",
-            status: "error",
-            settings,
-            prompt,
-            error: result.error,
+            result: {
+                status: "error",
+                error: result.error,
+            },
         });
         throw result.error;
     }