modelfusion 0.21.0 → 0.23.0

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

@@ -1,20 +1,23 @@
 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;
-} & ({
+}
+export type JsonGenerationFinishedEventResult = {
     status: "success";
     response: unknown;
-    generatedJson: unknown;
+    output: unknown;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
 } | {
     status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export type JsonGenerationFinishedEvent = BaseModelCallFinishedEvent & {
+    functionType: "json-generation" | "json-or-text-generation";
+    result: JsonGenerationFinishedEventResult;
+};

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

@@ -0,0 +1,13 @@
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface JsonGenerationModelSettings extends ModelSettings {
+}
+export interface JsonGenerationModel<PROMPT, RESPONSE, SETTINGS extends JsonGenerationModelSettings> extends Model<SETTINGS> {
+    generateJsonResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    extractJson(response: RESPONSE): unknown;
+    extractUsage?(response: RESPONSE): {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}

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

@@ -0,0 +1,23 @@
+import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { Model, ModelSettings } from "../Model.js";
+export interface JsonOrTextGenerationModelSettings extends ModelSettings {
+}
+export interface JsonOrTextGenerationPrompt<RESPONSE> {
+    extractJsonAndText(response: RESPONSE): {
+        schema: null;
+        value: null;
+        text: string;
+    } | {
+        schema: string;
+        value: unknown;
+        text: string | null;
+    };
+}
+export interface JsonOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS extends JsonOrTextGenerationModelSettings> extends Model<SETTINGS> {
+    generateJsonResponse(prompt: PROMPT & JsonOrTextGenerationPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
+    extractUsage?(response: RESPONSE): {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}

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

@@ -25,6 +25,9 @@ class JsonTextGenerationModel {
     get settings() {
         return this.model.settings;
     }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
     async generateJsonResponse(prompt, options) {
         return await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt), options);
     }

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

@@ -1,7 +1,7 @@
 import { TextGenerationModel, TextGenerationModelSettings } from "../generate-text/TextGenerationModel.js";
 import { SchemaDefinition } from "./SchemaDefinition.js";
 import { InstructionWithSchema } from "./InstructionWithSchemaPrompt.js";
-import { GenerateJsonModel } from "./GenerateJsonModel.js";
+import { JsonGenerationModel } from "./JsonGenerationModel.js";
 import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 export type JsonTextPromptFormat = {
     createPrompt: (prompt: {
@@ -10,7 +10,7 @@ export type JsonTextPromptFormat = {
     }) => string;
     extractJson: (response: string) => unknown;
 };
-export declare class JsonTextGenerationModel<SETTINGS extends TextGenerationModelSettings, MODEL extends TextGenerationModel<string, any, any, SETTINGS>> implements GenerateJsonModel<InstructionWithSchema<string, unknown>, string, SETTINGS> {
+export declare class JsonTextGenerationModel<MODEL extends TextGenerationModel<string, any, any, TextGenerationModelSettings>> implements JsonGenerationModel<InstructionWithSchema<string, unknown>, string, MODEL["settings"]> {
     private readonly model;
     private readonly format;
     constructor({ model, format, }: {
@@ -18,8 +18,9 @@ export declare class JsonTextGenerationModel<SETTINGS extends TextGenerationMode
         format: JsonTextPromptFormat;
     });
     get modelInformation(): import("../ModelInformation.js").ModelInformation;
-    get settings(): SETTINGS;
-    generateJsonResponse(prompt: InstructionWithSchema<string, unknown>, options?: ModelFunctionOptions<SETTINGS> | undefined): Promise<string>;
+    get settings(): TextGenerationModelSettings;
+    get settingsForEvent(): Partial<MODEL["settings"]>;
+    generateJsonResponse(prompt: InstructionWithSchema<string, unknown>, options?: ModelFunctionOptions<MODEL["settings"]> | undefined): Promise<string>;
     extractJson(response: string): unknown;
-    withSettings(additionalSettings: Partial<SETTINGS>): this;
+    withSettings(additionalSettings: Partial<MODEL["settings"]>): this;
 }

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

@@ -22,6 +22,9 @@ export class JsonTextGenerationModel {
     get settings() {
         return this.model.settings;
     }
+    get settingsForEvent() {
+        return this.model.settingsForEvent;
+    }
     async generateJsonResponse(prompt, options) {
         return await generateText(this.model, this.format.createPrompt(prompt), options);
     }

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,7 @@ 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,
-        }),
+        extractUsage: (result) => model.extractUsage?.(result),
     });
 }
 exports.generateJson = generateJson;

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

@@ -1,5 +1,5 @@
 import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
-import { GenerateJsonModel, GenerateJsonModelSettings } from "./GenerateJsonModel.js";
+import { JsonGenerationModel, JsonGenerationModelSettings } from "./JsonGenerationModel.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?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<GenerateJsonModel<PROMPT, RESPONSE, SETTINGS>, STRUCTURE, RESPONSE>;
+export declare function generateJson<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends JsonGenerationModelSettings>(model: JsonGenerationModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinition: SchemaDefinition<NAME, STRUCTURE>, prompt: (schemaDefinition: SchemaDefinition<NAME, STRUCTURE>) => PROMPT, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<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,32 +20,6 @@ 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,
-        }),
+        extractUsage: (result) => model.extractUsage?.(result),
     });
 }

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,7 @@ 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,
-        }),
+        extractUsage: (result) => model.extractUsage?.(result),
     });
 }
 exports.generateJsonOrText = generateJsonOrText;

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

@@ -1,6 +1,6 @@
 import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
-import { GenerateJsonOrTextModel, GenerateJsonOrTextModelSettings, GenerateJsonOrTextPrompt } from "./GenerateJsonOrTextModel.js";
+import { JsonOrTextGenerationModel, JsonOrTextGenerationModelSettings, JsonOrTextGenerationPrompt } from "./JsonOrTextGenerationModel.js";
 import { SchemaDefinition } from "./SchemaDefinition.js";
 type SchemaDefinitionArray<T extends SchemaDefinition<any, any>[]> = T;
 type ToSchemaDefinitionsMap<T extends SchemaDefinitionArray<SchemaDefinition<any, any>[]>> = {
@@ -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?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<GenerateJsonOrTextModel<PROMPT, RESPONSE, SETTINGS>, {
+export declare function generateJsonOrText<SCHEMAS extends SchemaDefinition<any, any>[], PROMPT, RESPONSE, SETTINGS extends JsonOrTextGenerationModelSettings>(model: JsonOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS>, schemaDefinitions: SCHEMAS, prompt: (schemaDefinitions: SCHEMAS) => PROMPT & JsonOrTextGenerationPrompt<RESPONSE>, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<{
     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,32 +33,6 @@ 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,
-        }),
+        extractUsage: (result) => model.extractUsage?.(result),
     });
 }

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

@@ -1,20 +1,23 @@
 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;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
 } | {
     status: "error";
     error: unknown;
 } | {
     status: "abort";
-});
+};
+export interface TextGenerationFinishedEvent extends BaseModelCallFinishedEvent {
+    functionType: "text-generation";
+    result: TextGenerationFinishedEventResult;
+}

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

@@ -38,5 +38,10 @@ export interface TextGenerationModel<PROMPT, RESPONSE, FULL_DELTA, SETTINGS exte
      * Optional. Implement for streaming support.
      */
     readonly extractTextDelta: ((fullDelta: FULL_DELTA) => string | undefined) | undefined;
+    extractUsage?(response: RESPONSE): {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
     withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, RESPONSE, FULL_DELTA, SETTINGS, this>;
 }

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,7 @@ 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,
-        }),
+        extractUsage: (result) => model.extractUsage?.(result),
     });
 }
 exports.generateText = generateText;

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

@@ -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?: ModelFunctionOptions<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<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,32 +26,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,
-        }),
+        extractUsage: (result) => model.extractUsage?.(result),
     });
 }

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

@@ -2,8 +2,10 @@
 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 GlobalFunctionLogging_js_1 = require("../../core/GlobalFunctionLogging.cjs");
+const GlobalFunctionObservers_js_1 = require("../../core/GlobalFunctionObservers.cjs");
+const getFunctionCallLogger_js_1 = require("../../core/getFunctionCallLogger.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");
@@ -59,6 +61,7 @@ async function doStreamText(model, prompt, options) {
     const settings = model.settings;
     const eventSource = new FunctionEventSource_js_1.FunctionEventSource({
         observers: [
+            ...(0, getFunctionCallLogger_js_1.getFunctionCallLogger)(options?.logging ?? (0, GlobalFunctionLogging_js_1.getGlobalFunctionLogging)()),
             ...(0, GlobalFunctionObservers_js_1.getGlobalFunctionObservers)(),
             ...(settings.observers ?? []),
             ...(run?.observers ?? []),
@@ -68,21 +71,21 @@ async function doStreamText(model, prompt, options) {
     });
     const durationMeasurement = (0, DurationMeasurement_js_1.startDurationMeasurement)();
     const startMetadata = {
+        functionType: "text-streaming",
         callId: `call-${(0, nanoid_1.nanoid)()}`,
         runId: run?.runId,
         sessionId: run?.sessionId,
         userId: run?.userId,
         functionId: options?.functionId,
         model: model.modelInformation,
+        settings: model.settingsForEvent,
+        input: prompt,
         timestamp: durationMeasurement.startDate,
         startTimestamp: durationMeasurement.startDate,
     };
     eventSource.notify({
-        ...startMetadata,
-        functionType: "text-streaming",
         eventType: "started",
-        settings,
-        prompt,
+        ...startMetadata,
     });
     const result = await (0, runSafe_js_1.runSafe)(async () => (0, extractTextDeltas_js_1.extractTextDeltas)({
         deltaIterable: await model.generateDeltaStreamResponse(prompt, {
@@ -93,70 +96,65 @@ async function doStreamText(model, prompt, options) {
         extractDelta: (fullDelta) => model.extractTextDelta(fullDelta),
         onDone: (fullText, lastFullDelta) => {
             const finishMetadata = {
-                ...startMetadata,
                 eventType: "finished",
+                ...startMetadata,
                 finishTimestamp: new Date(),
                 durationInMs: durationMeasurement.durationInMs,
             };
             eventSource.notify({
                 ...finishMetadata,
-                functionType: "text-streaming",
-                status: "success",
-                settings,
-                prompt,
-                response: lastFullDelta,
-                generatedText: fullText,
+                result: {
+                    status: "success",
+                    response: lastFullDelta,
+                    output: fullText,
+                },
             });
         },
         onError: (error) => {
             const finishMetadata = {
-                ...startMetadata,
                 eventType: "finished",
+                ...startMetadata,
                 finishTimestamp: new Date(),
                 durationInMs: durationMeasurement.durationInMs,
             };
             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,
+                    },
                 });
         },
     }));
     if (!result.ok) {
         const finishMetadata = {
-            ...startMetadata,
             eventType: "finished",
+            ...startMetadata,
             finishTimestamp: new Date(),
             durationInMs: durationMeasurement.durationInMs,
         };
         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;
     }