modelfusion 0.20.1 → 0.22.0

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

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

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

@@ -2,7 +2,7 @@ import { TextGenerationModel, TextGenerationModelSettings } from "../generate-te
 import { SchemaDefinition } from "./SchemaDefinition.js";
 import { InstructionWithSchema } from "./InstructionWithSchemaPrompt.js";
 import { GenerateJsonModel } from "./GenerateJsonModel.js";
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 export type JsonTextPromptFormat = {
     createPrompt: (prompt: {
         instruction: string;
@@ -19,7 +19,7 @@ export declare class JsonTextGenerationModel<SETTINGS extends TextGenerationMode
     });
     get modelInformation(): import("../ModelInformation.js").ModelInformation;
     get settings(): SETTINGS;
-    generateJsonResponse(prompt: InstructionWithSchema<string, unknown>, options?: FunctionOptions<SETTINGS> | undefined): Promise<string>;
+    generateJsonResponse(prompt: InstructionWithSchema<string, unknown>, options?: ModelFunctionOptions<SETTINGS> | undefined): Promise<string>;
     extractJson(response: string): unknown;
     withSettings(additionalSettings: Partial<SETTINGS>): this;
 }

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,36 +23,6 @@ function generateJson(model, schemaDefinition, prompt, options) {
             }
             return parseResult.data;
         },
-        getStartEvent: (metadata, settings) => ({
-            type: "json-generation-started",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "json-generation-finished",
-            status: "abort",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "json-generation-finished",
-            status: "failure",
-            metadata,
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "json-generation-finished",
-            status: "success",
-            metadata,
-            settings,
-            prompt,
-            response,
-            generatedJson: output,
-        }),
     });
 }
 exports.generateJson = generateJson;

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

@@ -1,5 +1,5 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { GenerateJsonModel, GenerateJsonModelSettings } from "./GenerateJsonModel.js";
 import { SchemaDefinition } from "./SchemaDefinition.js";
-export declare function generateJson<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends GenerateJsonModelSettings>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinition: SchemaDefinition<NAME, STRUCTURE>, prompt: (schemaDefinition: SchemaDefinition<NAME, STRUCTURE>) => PROMPT, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, STRUCTURE, RESPONSE>;
+export declare function generateJson<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends GenerateJsonModelSettings>(model: GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinition: SchemaDefinition<NAME, STRUCTURE>, prompt: (schemaDefinition: SchemaDefinition<NAME, STRUCTURE>) => PROMPT, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, STRUCTURE, RESPONSE>;

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,35 +20,5 @@ export function generateJson(model, schemaDefinition, prompt, options) {
             }
             return parseResult.data;
         },
-        getStartEvent: (metadata, settings) => ({
-            type: "json-generation-started",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "json-generation-finished",
-            status: "abort",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "json-generation-finished",
-            status: "failure",
-            metadata,
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "json-generation-finished",
-            status: "success",
-            metadata,
-            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,36 +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) => ({
-            type: "json-or-text-generation-started",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "json-or-text-generation-finished",
-            status: "abort",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "json-or-text-generation-finished",
-            status: "failure",
-            metadata,
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "json-or-text-generation-finished",
-            status: "success",
-            metadata,
-            settings,
-            prompt,
-            response,
-            generatedJson: output,
-        }),
     });
 }
 exports.generateJsonOrText = generateJsonOrText;

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { GenerateJsonOrTextModel, GenerateJsonOrTextModelSettings, GenerateJsonOrTextPrompt } from "./GenerateJsonOrTextModel.js";
 import { SchemaDefinition } from "./SchemaDefinition.js";
@@ -14,7 +14,7 @@ type ToSchemaUnion<T> = {
     } : never;
 }[keyof T];
 type ToOutputValue<SCHEMAS extends SchemaDefinitionArray<SchemaDefinition<any, any>[]>> = ToSchemaUnion<ToSchemaDefinitionsMap<SCHEMAS>>;
-export declare function generateJsonOrText<SCHEMAS extends SchemaDefinition<any, any>[], PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinitions: SCHEMAS, prompt: (schemaDefinitions: SCHEMAS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, {
+export declare function generateJsonOrText<SCHEMAS extends SchemaDefinition<any, any>[], PROMPT, RESPONSE, SETTINGS extends GenerateJsonOrTextModelSettings>(model: GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinitions: SCHEMAS, prompt: (schemaDefinitions: SCHEMAS) => PROMPT & GenerateJsonOrTextPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, {
     schema: null;
     value: null;
     text: string;

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,35 +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) => ({
-            type: "json-or-text-generation-started",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "json-or-text-generation-finished",
-            status: "abort",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "json-or-text-generation-finished",
-            status: "failure",
-            metadata,
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "json-or-text-generation-finished",
-            status: "success",
-            metadata,
-            settings,
-            prompt,
-            response,
-            generatedJson: output,
-        }),
     });
 }

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

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

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

@@ -1,6 +1,6 @@
 import { PromptFormat } from "../../prompt/PromptFormat.js";
 import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 import { BasicTokenizer, FullTokenizer } from "../tokenize-text/Tokenizer.js";
 import { DeltaEvent } from "./DeltaEvent.js";
@@ -28,12 +28,12 @@ export interface TextGenerationModel<PROMPT, RESPONSE, FULL_DELTA, SETTINGS exte
      * Optional. Implement if you have a tokenizer and want to count the number of tokens in a prompt.
      */
     readonly countPromptTokens: ((prompt: PROMPT) => PromiseLike<number>) | undefined;
-    generateTextResponse(prompt: PROMPT, options?: FunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    generateTextResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
     extractText(response: RESPONSE): string;
     /**
      * Optional. Implement for streaming support.
      */
-    readonly generateDeltaStreamResponse: ((prompt: PROMPT, options: FunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>) | undefined;
+    readonly generateDeltaStreamResponse: ((prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>) | undefined;
     /**
      * Optional. Implement for streaming support.
      */

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

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

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,36 +29,6 @@ model, prompt, options) {
                 ? model.extractText(result).trim()
                 : model.extractText(result);
         },
-        getStartEvent: (metadata, settings) => ({
-            type: "text-generation-started",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "text-generation-finished",
-            status: "abort",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "text-generation-finished",
-            status: "failure",
-            metadata,
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-generation-finished",
-            status: "success",
-            metadata,
-            settings,
-            prompt,
-            response,
-            generatedText: output,
-        }),
     });
 }
 exports.generateText = generateText;

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
 /**
@@ -13,4 +13,4 @@ import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerati
  *   "Write a short story about a robot learning to love:\n\n"
  * );
  */
-export declare function generateText<PROMPT, RESPONSE, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, prompt: PROMPT, options?: FunctionOptions<SETTINGS>): ModelFunctionPromise<TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, string, RESPONSE>;
+export declare function generateText<PROMPT, RESPONSE, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<TextGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, string, RESPONSE>;

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,35 +26,5 @@ model, prompt, options) {
                 ? model.extractText(result).trim()
                 : model.extractText(result);
         },
-        getStartEvent: (metadata, settings) => ({
-            type: "text-generation-started",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getAbortEvent: (metadata, settings) => ({
-            type: "text-generation-finished",
-            status: "abort",
-            metadata,
-            settings,
-            prompt,
-        }),
-        getFailureEvent: (metadata, settings, error) => ({
-            type: "text-generation-finished",
-            status: "failure",
-            metadata,
-            settings,
-            prompt,
-            error,
-        }),
-        getSuccessEvent: (metadata, settings, response, output) => ({
-            type: "text-generation-finished",
-            status: "success",
-            metadata,
-            settings,
-            prompt,
-            response,
-            generatedText: output,
-        }),
     });
 }

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

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamText = exports.StreamTextPromise = void 0;
 const nanoid_1 = require("nanoid");
-const RunFunctionEventSource_js_1 = require("../../run/RunFunctionEventSource.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");
@@ -50,13 +51,19 @@ async function doStreamText(model, prompt, options) {
         model = model.withSettings(options.settings);
         options = {
             functionId: options.functionId,
+            observers: options.observers,
             run: options.run,
         };
     }
     const run = options?.run;
     const settings = model.settings;
-    const eventSource = new RunFunctionEventSource_js_1.RunFunctionEventSource({
-        observers: [...(settings.observers ?? []), ...(run?.observers ?? [])],
+    const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
+        observers: [
+            ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
+            ...(settings.observers ?? []),
+            ...(run?.observers ?? []),
+            ...(options?.observers ?? []),
+        ],
         errorHandler: run?.errorHandler,
     });
     const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
@@ -67,13 +74,15 @@ async function doStreamText(model, prompt, options) {
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
-        startEpochSeconds: durationMeasurement.startEpochSeconds,
-    };
-    eventSource.notifyRunFunctionStarted({
-        type: "text-streaming-started",
-        metadata: startMetadata,
+        functionType: "text-streaming",
+        input: prompt,
         settings,
-        prompt,
+        timestamp: durationMeasurement.startDate,
+        startTimestamp: durationMeasurement.startDate,
+    };
+    eventSource.notify({
+        ...startMetadata,
+        eventType: "started",
     });
     const result = await (0, runSafe_js_1.runSafe)(async () => (0, extractTextDeltas_js_1.extractTextDeltas)({
         deltaIterable: await model.generateDeltaStreamResponse(prompt, {
@@ -85,63 +94,64 @@ async function doStreamText(model, prompt, options) {
         onDone: (fullText, lastFullDelta) => {
             const finishMetadata = {
                 ...startMetadata,
+                eventType: "finished",
+                finishTimestamp: new Date(),
                 durationInMs: durationMeasurement.durationInMs,
             };
-            eventSource.notifyRunFunctionFinished({
-                type: "text-streaming-finished",
-                status: "success",
-                metadata: finishMetadata,
-                settings,
-                prompt,
-                response: lastFullDelta,
-                generatedText: fullText,
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "success",
+                    response: lastFullDelta,
+                    output: fullText,
+                },
             });
         },
         onError: (error) => {
             const finishMetadata = {
                 ...startMetadata,
+                eventType: "finished",
+                finishTimestamp: new Date(),
                 durationInMs: durationMeasurement.durationInMs,
             };
-            eventSource.notifyRunFunctionFinished(error instanceof AbortError_js_1.AbortError
+            eventSource.notify(error instanceof AbortError_js_1.AbortError
                 ? {
-                    type: "text-streaming-finished",
-                    status: "abort",
-                    metadata: finishMetadata,
-                    settings,
-                    prompt,
+                    ...finishMetadata,
+                    result: {
+                        status: "abort",
+                    },
                 }
                 : {
-                    type: "text-streaming-finished",
-                    status: "failure",
-                    metadata: finishMetadata,
-                    settings,
-                    prompt,
-                    error,
+                    ...finishMetadata,
+                    result: {
+                        status: "error",
+                        error,
+                    },
                 });
         },
     }));
     if (!result.ok) {
         const finishMetadata = {
             ...startMetadata,
+            eventType: "finished",
+            finishTimestamp: new Date(),
             durationInMs: durationMeasurement.durationInMs,
         };
         if (result.isAborted) {
-            eventSource.notifyRunFunctionFinished({
-                type: "text-streaming-finished",
-                status: "abort",
-                metadata: finishMetadata,
-                settings,
-                prompt,
+            eventSource.notify({
+                ...finishMetadata,
+                result: {
+                    status: "abort",
+                },
             });
             throw new AbortError_js_1.AbortError();
         }
-        eventSource.notifyRunFunctionFinished({
-            type: "text-streaming-finished",
-            status: "failure",
-            metadata: finishMetadata,
-            settings,
-            prompt,
-            error: result.error,
+        eventSource.notify({
+            ...finishMetadata,
+            result: {
+                status: "error",
+                error: result.error,
+            },
         });
         throw result.error;
     }

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

@@ -1,4 +1,4 @@
-import { FunctionOptions } from "../FunctionOptions.js";
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { CallMetadata } from "../executeCall.js";
 import { DeltaEvent } from "./DeltaEvent.js";
 import { TextGenerationModel, TextGenerationModelSettings } from "./TextGenerationModel.js";
@@ -7,17 +7,17 @@ export declare class StreamTextPromise<PROMPT, FULL_DELTA, SETTINGS extends Text
     private outputPromise;
     constructor(fullPromise: Promise<{
         output: AsyncIterable<string>;
-        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs">;
+        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs" | "finishTimestamp">;
     }>);
     asFullResponse(): Promise<{
         output: AsyncIterable<string>;
-        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs">;
+        metadata: Omit<CallMetadata<TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS>>, "durationInMs" | "finishTimestamp">;
     }>;
     then<TResult1 = AsyncIterable<string>, TResult2 = never>(onfulfilled?: ((value: AsyncIterable<string>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
     catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<AsyncIterable<string> | TResult>;
     finally(onfinally?: (() => void) | undefined | null): Promise<AsyncIterable<string>>;
 }
 export declare function streamText<PROMPT, FULL_DELTA, SETTINGS extends TextGenerationModelSettings>(model: TextGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS> & {
-    generateDeltaStreamResponse: (prompt: PROMPT, options: FunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
+    generateDeltaStreamResponse: (prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
     extractTextDelta: (fullDelta: FULL_DELTA) => string | undefined;
-}, prompt: PROMPT, options?: FunctionOptions<SETTINGS>): StreamTextPromise<PROMPT, FULL_DELTA, SETTINGS>;
+}, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): StreamTextPromise<PROMPT, FULL_DELTA, SETTINGS>;