modelfusion 0.40.1 → 0.41.0

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

@@ -5,7 +5,7 @@ export interface ImageGenerationStartedEvent extends BaseModelCallStartedEvent {
 export type ImageGenerationFinishedEventResult = {
     status: "success";
     response: unknown;
-    output: string;
+    value: string;
 } | {
     status: "error";
     error: unknown;

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

@@ -1,8 +1,10 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { Model, ModelSettings } from "../Model.js";
 export interface ImageGenerationModelSettings extends ModelSettings {
 }
-export interface ImageGenerationModel<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings> extends Model<SETTINGS> {
-    generateImageResponse(prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
-    extractBase64Image(response: RESPONSE): string;
+export interface ImageGenerationModel<PROMPT, SETTINGS extends ImageGenerationModelSettings = ImageGenerationModelSettings> extends Model<SETTINGS> {
+    doGenerateImage(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+        response: unknown;
+        base64Image: string;
+    }>;
 }

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

@@ -23,8 +23,13 @@ function generateImage(model, prompt, options) {
         input: prompt,
         model,
         options,
-        generateResponse: (options) => model.generateImageResponse(prompt, options),
-        extractOutputValue: model.extractBase64Image,
+        generateResponse: async (options) => {
+            const result = await model.doGenerateImage(prompt, options);
+            return {
+                response: result.response,
+                extractedValue: result.base64Image,
+            };
+        },
     });
 }
 exports.generateImage = generateImage;

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

@@ -1,4 +1,4 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGenerationModel.js";
 /**
@@ -16,4 +16,4 @@ import { ImageGenerationModel, ImageGenerationModelSettings } from "./ImageGener
  *   ]
  * );
  */
-export declare function generateImage<PROMPT, RESPONSE, SETTINGS extends ImageGenerationModelSettings>(model: ImageGenerationModel<PROMPT, RESPONSE, SETTINGS>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<string, RESPONSE>;
+export declare function generateImage<PROMPT>(model: ImageGenerationModel<PROMPT, ImageGenerationModelSettings>, prompt: PROMPT, options?: FunctionOptions): ModelFunctionPromise<string>;

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

@@ -20,7 +20,12 @@ export function generateImage(model, prompt, options) {
         input: prompt,
         model,
         options,
-        generateResponse: (options) => model.generateImageResponse(prompt, options),
-        extractOutputValue: model.extractBase64Image,
+        generateResponse: async (options) => {
+            const result = await model.doGenerateImage(prompt, options);
+            return {
+                response: result.response,
+                extractedValue: result.base64Image,
+            };
+        },
     });
 }

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

@@ -28,11 +28,12 @@ class StructureFromTextGenerationModel {
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }
-    async generateStructureResponse(structure, prompt, options) {
-        return await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, structure), options);
-    }
-    extractStructure(response) {
-        return this.format.extractStructure(response);
+    async doGenerateStructure(structure, prompt, options) {
+        const { response, value } = await (0, generateText_js_1.generateText)(this.model, this.format.createPrompt(prompt, structure), options).asFullResponse();
+        return {
+            response,
+            structure: this.format.extractStructure(value),
+        };
     }
     withSettings(additionalSettings) {
         return new StructureFromTextGenerationModel({

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

@@ -1,12 +1,12 @@
-import { TextGenerationModel, TextGenerationModelSettings } from "../generate-text/TextGenerationModel.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
+import { TextGenerationModel, TextGenerationModelSettings } from "../generate-text/TextGenerationModel.js";
 import { StructureGenerationModel } from "./StructureGenerationModel.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 export type StructureFromTextPromptFormat<PROMPT> = {
     createPrompt: (prompt: PROMPT, structure: StructureDefinition<string, unknown>) => string;
     extractStructure: (response: string) => unknown;
 };
-export declare class StructureFromTextGenerationModel<PROMPT, MODEL extends TextGenerationModel<string, any, any, TextGenerationModelSettings>> implements StructureGenerationModel<PROMPT, string, undefined, MODEL["settings"]> {
+export declare class StructureFromTextGenerationModel<PROMPT, MODEL extends TextGenerationModel<string, TextGenerationModelSettings>> implements StructureGenerationModel<PROMPT, MODEL["settings"]> {
     private readonly model;
     private readonly format;
     constructor({ model, format, }: {
@@ -16,7 +16,9 @@ export declare class StructureFromTextGenerationModel<PROMPT, MODEL extends Text
     get modelInformation(): import("../ModelInformation.js").ModelInformation;
     get settings(): TextGenerationModelSettings;
     get settingsForEvent(): Partial<MODEL["settings"]>;
-    generateStructureResponse(structure: StructureDefinition<string, unknown>, prompt: PROMPT, options?: ModelFunctionOptions<MODEL["settings"]> | undefined): Promise<string>;
-    extractStructure(response: string): unknown;
+    doGenerateStructure(structure: StructureDefinition<string, unknown>, prompt: PROMPT, options?: FunctionOptions): Promise<{
+        response: unknown;
+        structure: unknown;
+    }>;
     withSettings(additionalSettings: Partial<MODEL["settings"]>): this;
 }

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

@@ -25,11 +25,12 @@ export class StructureFromTextGenerationModel {
     get settingsForEvent() {
         return this.model.settingsForEvent;
     }
-    async generateStructureResponse(structure, prompt, options) {
-        return await generateText(this.model, this.format.createPrompt(prompt, structure), options);
-    }
-    extractStructure(response) {
-        return this.format.extractStructure(response);
+    async doGenerateStructure(structure, prompt, options) {
+        const { response, value } = await generateText(this.model, this.format.createPrompt(prompt, structure), options).asFullResponse();
+        return {
+            response,
+            structure: this.format.extractStructure(value),
+        };
     }
     withSettings(additionalSettings) {
         return new StructureFromTextGenerationModel({

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

@@ -5,7 +5,7 @@ export interface StructureGenerationStartedEvent extends BaseModelCallStartedEve
 export type StructureGenerationFinishedEventResult = {
     status: "success";
     response: unknown;
-    output: unknown;
+    value: unknown;
     usage?: {
         promptTokens: number;
         completionTokens: number;

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

@@ -1,23 +1,20 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
-import { DeltaEvent } from "../DeltaEvent.js";
+import { Delta } from "../../model-function/Delta.js";
 import { Model, ModelSettings } from "../Model.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 export interface StructureGenerationModelSettings extends ModelSettings {
 }
-export interface StructureGenerationModel<PROMPT, RESPONSE, FULL_DELTA, SETTINGS extends StructureGenerationModelSettings> extends Model<SETTINGS> {
-    generateStructureResponse(structure: StructureDefinition<string, unknown>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
-    extractStructure(response: RESPONSE): unknown;
-    extractUsage?(response: RESPONSE): {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
-    /**
-     * Optional. Implement for streaming support.
-     */
-    readonly generateStructureStreamResponse?: (structureDefinition: StructureDefinition<string, unknown>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
-    /**
-     * Optional. Implement for streaming support.
-     */
-    readonly extractPartialStructure?: (fullDelta: FULL_DELTA) => unknown | undefined;
+export interface StructureGenerationModel<PROMPT, SETTINGS extends StructureGenerationModelSettings = StructureGenerationModelSettings> extends Model<SETTINGS> {
+    doGenerateStructure(structure: StructureDefinition<string, unknown>, prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+        response: unknown;
+        structure: unknown;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+}
+export interface StructureStreamingModel<PROMPT, SETTINGS extends StructureGenerationModelSettings = StructureGenerationModelSettings> extends StructureGenerationModel<PROMPT, SETTINGS> {
+    doStreamStructure(structureDefinition: StructureDefinition<string, unknown>, prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<unknown>>>;
 }

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

@@ -1,22 +1,24 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
 import { Model, ModelSettings } from "../Model.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 export interface StructureOrTextGenerationModelSettings extends ModelSettings {
 }
-export interface StructureOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS extends StructureOrTextGenerationModelSettings> extends Model<SETTINGS> {
-    generateStructureOrTextResponse(structureDefinitions: Array<StructureDefinition<string, unknown>>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
-    extractStructureAndText(response: RESPONSE): {
-        structure: null;
-        value: null;
-        text: string;
-    } | {
-        structure: string;
-        value: unknown;
-        text: string | null;
-    };
-    extractUsage?(response: RESPONSE): {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-    };
+export interface StructureOrTextGenerationModel<PROMPT, SETTINGS extends StructureOrTextGenerationModelSettings> extends Model<SETTINGS> {
+    doGenerateStructureOrText(structureDefinitions: Array<StructureDefinition<string, unknown>>, prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+        response: unknown;
+        structureAndText: {
+            structure: null;
+            value: null;
+            text: string;
+        } | {
+            structure: string;
+            value: unknown;
+            text: string | null;
+        };
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
 }

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

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStructure = void 0;
 const executeCall_js_1 = require("../executeCall.cjs");
 const StructureValidationError_js_1 = require("./StructureValidationError.cjs");
-function generateStructure(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-model, structureDefinition, prompt, options) {
+function generateStructure(model, structureDefinition, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinition)
@@ -15,9 +13,9 @@ model, structureDefinition, prompt, options) {
         input: expandedPrompt,
         model,
         options,
-        generateResponse: (options) => model.generateStructureResponse(structureDefinition, expandedPrompt, options),
-        extractOutputValue: (response) => {
-            const structure = model.extractStructure(response);
+        generateResponse: async (options) => {
+            const result = await model.doGenerateStructure(structureDefinition, expandedPrompt, options);
+            const structure = result.structure;
             const parseResult = structureDefinition.schema.validate(structure);
             if (!parseResult.success) {
                 throw new StructureValidationError_js_1.StructureValidationError({
@@ -26,9 +24,13 @@ model, structureDefinition, prompt, options) {
                     cause: parseResult.error,
                 });
             }
-            return parseResult.value;
+            const value = parseResult.value;
+            return {
+                response: result.response,
+                extractedValue: value,
+                usage: result.usage,
+            };
         },
-        extractUsage: (result) => model.extractUsage?.(result),
     });
 }
 exports.generateStructure = generateStructure;

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

@@ -1,5 +1,5 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { StructureGenerationModel, StructureGenerationModelSettings } from "./StructureGenerationModel.js";
-export declare function generateStructure<STRUCTURE, PROMPT, RESPONSE, NAME extends string, SETTINGS extends StructureGenerationModelSettings>(model: StructureGenerationModel<PROMPT, RESPONSE, any, SETTINGS>, structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: PROMPT | ((structureDefinition: StructureDefinition<NAME, STRUCTURE>) => PROMPT), options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<STRUCTURE, RESPONSE>;
+export declare function generateStructure<STRUCTURE, PROMPT, NAME extends string, SETTINGS extends StructureGenerationModelSettings>(model: StructureGenerationModel<PROMPT, SETTINGS>, structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: PROMPT | ((structureDefinition: StructureDefinition<NAME, STRUCTURE>) => PROMPT), options?: FunctionOptions): ModelFunctionPromise<STRUCTURE>;

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

@@ -1,8 +1,6 @@
 import { executeCall } from "../executeCall.js";
 import { StructureValidationError } from "./StructureValidationError.js";
-export function generateStructure(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-model, structureDefinition, prompt, options) {
+export function generateStructure(model, structureDefinition, prompt, options) {
     // Note: PROMPT must not be a function.
     const expandedPrompt = typeof prompt === "function"
         ? prompt(structureDefinition)
@@ -12,9 +10,9 @@ model, structureDefinition, prompt, options) {
         input: expandedPrompt,
         model,
         options,
-        generateResponse: (options) => model.generateStructureResponse(structureDefinition, expandedPrompt, options),
-        extractOutputValue: (response) => {
-            const structure = model.extractStructure(response);
+        generateResponse: async (options) => {
+            const result = await model.doGenerateStructure(structureDefinition, expandedPrompt, options);
+            const structure = result.structure;
             const parseResult = structureDefinition.schema.validate(structure);
             if (!parseResult.success) {
                 throw new StructureValidationError({
@@ -23,8 +21,12 @@ model, structureDefinition, prompt, options) {
                     cause: parseResult.error,
                 });
             }
-            return parseResult.value;
+            const value = parseResult.value;
+            return {
+                response: result.response,
+                extractedValue: value,
+                usage: result.usage,
+            };
         },
-        extractUsage: (result) => model.extractUsage?.(result),
     });
 }

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

@@ -14,12 +14,16 @@ function generateStructureOrText(model, structureDefinitions, prompt, options) {
         input: expandedPrompt,
         model,
         options,
-        generateResponse: (options) => model.generateStructureOrTextResponse(structureDefinitions, expandedPrompt, options),
-        extractOutputValue: (response) => {
-            const { structure, value, text } = model.extractStructureAndText(response);
+        generateResponse: async (options) => {
+            const result = await model.doGenerateStructureOrText(structureDefinitions, expandedPrompt, options);
+            const { structure, value, text } = result.structureAndText;
             // text generation:
             if (structure == null) {
-                return { structure, value, text };
+                return {
+                    response: result.response,
+                    extractedValue: { structure, value, text },
+                    usage: result.usage,
+                };
             }
             const definition = structureDefinitions.find((d) => d.name === structure);
             if (definition == undefined) {
@@ -34,12 +38,15 @@ function generateStructureOrText(model, structureDefinitions, prompt, options) {
                 });
             }
             return {
-                structure: structure,
-                value: parseResult.value,
-                text: text, // text is string | null, which is part of the response for schema values
+                response: result.response,
+                extractedValue: {
+                    structure: structure,
+                    value: parseResult.value,
+                    text: text, // text is string | null, which is part of the response for schema values
+                },
+                usage: result.usage,
             };
         },
-        extractUsage: (result) => model.extractUsage?.(result),
     });
 }
 exports.generateStructureOrText = generateStructureOrText;

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

@@ -1,7 +1,7 @@
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
 import { ModelFunctionPromise } from "../executeCall.js";
 import { StructureOrTextGenerationModel, StructureOrTextGenerationModelSettings } from "./StructureOrTextGenerationModel.js";
-import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
 type StructureDefinitionArray<T extends StructureDefinition<any, any>[]> = T;
 type ToStructureDefinitionMap<T extends StructureDefinitionArray<StructureDefinition<any, any>[]>> = {
     [K in T[number]["name"]]: Extract<T[number], StructureDefinition<K, any>>;
@@ -14,9 +14,9 @@ type ToStructureUnion<T> = {
     } : never;
 }[keyof T];
 type ToOutputValue<STRUCTURES extends StructureDefinitionArray<StructureDefinition<any, any>[]>> = ToStructureUnion<ToStructureDefinitionMap<STRUCTURES>>;
-export declare function generateStructureOrText<STRUCTURES extends StructureDefinition<any, any>[], PROMPT, RESPONSE, SETTINGS extends StructureOrTextGenerationModelSettings>(model: StructureOrTextGenerationModel<PROMPT, RESPONSE, SETTINGS>, structureDefinitions: STRUCTURES, prompt: PROMPT | ((structureDefinitions: STRUCTURES) => PROMPT), options?: ModelFunctionOptions<SETTINGS>): ModelFunctionPromise<{
+export declare function generateStructureOrText<STRUCTURES extends StructureDefinition<any, any>[], PROMPT>(model: StructureOrTextGenerationModel<PROMPT, StructureOrTextGenerationModelSettings>, structureDefinitions: STRUCTURES, prompt: PROMPT | ((structureDefinitions: STRUCTURES) => PROMPT), options?: FunctionOptions): ModelFunctionPromise<{
     structure: null;
     value: null;
     text: string;
-} | ToOutputValue<STRUCTURES>, RESPONSE>;
+} | ToOutputValue<STRUCTURES>>;
 export {};

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

@@ -11,12 +11,16 @@ export function generateStructureOrText(model, structureDefinitions, prompt, opt
         input: expandedPrompt,
         model,
         options,
-        generateResponse: (options) => model.generateStructureOrTextResponse(structureDefinitions, expandedPrompt, options),
-        extractOutputValue: (response) => {
-            const { structure, value, text } = model.extractStructureAndText(response);
+        generateResponse: async (options) => {
+            const result = await model.doGenerateStructureOrText(structureDefinitions, expandedPrompt, options);
+            const { structure, value, text } = result.structureAndText;
             // text generation:
             if (structure == null) {
-                return { structure, value, text };
+                return {
+                    response: result.response,
+                    extractedValue: { structure, value, text },
+                    usage: result.usage,
+                };
             }
             const definition = structureDefinitions.find((d) => d.name === structure);
             if (definition == undefined) {
@@ -31,11 +35,14 @@ export function generateStructureOrText(model, structureDefinitions, prompt, opt
                 });
             }
             return {
-                structure: structure,
-                value: parseResult.value,
-                text: text, // text is string | null, which is part of the response for schema values
+                response: result.response,
+                extractedValue: {
+                    structure: structure,
+                    value: parseResult.value,
+                    text: text, // text is string | null, which is part of the response for schema values
+                },
+                usage: result.usage,
             };
         },
-        extractUsage: (result) => model.extractUsage?.(result),
     });
 }

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

@@ -19,14 +19,6 @@ function streamStructure(model, structureDefinition, prompt, options) {
 }
 exports.streamStructure = streamStructure;
 async function doStreamStructure(model, structureDefinition, prompt, options) {
-    if (options?.settings != null) {
-        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 FunctionEventSource_js_1.FunctionEventSource({
@@ -58,11 +50,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
         ...startMetadata,
     });
     const result = await (0, runSafe_js_1.runSafe)(async () => {
-        const deltaIterable = await model.generateStructureStreamResponse(structureDefinition, prompt, {
-            functionId: options?.functionId,
-            settings,
-            run,
-        });
+        const deltaIterable = await model.doStreamStructure(structureDefinition, prompt, options);
         return (async function* () {
             function reportError(error) {
                 const finishMetadata = {
@@ -95,7 +83,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
                 }
                 if (event?.type === "delta") {
                     const latestFullDelta = event.fullDelta;
-                    const latestStructure = model.extractPartialStructure(latestFullDelta);
+                    const latestStructure = event.valueDelta;
                     // only send a new part into the stream when the partial structure has changed:
                     if (!(0, deep_equal_1.default)(lastStructure, latestStructure, {
                         strict: true,
@@ -130,7 +118,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
                 result: {
                     status: "success",
                     response: lastFullDelta,
-                    output: lastStructure,
+                    value: lastStructure,
                 },
             });
         })();
@@ -161,7 +149,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
         throw result.error;
     }
     return {
-        output: result.output,
+        output: result.value,
         metadata: startMetadata,
     };
 }

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

@@ -1,8 +1,7 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
 import { AsyncIterableResultPromise } from "../AsyncIterableResultPromise.js";
-import { DeltaEvent } from "../DeltaEvent.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
-import { StructureGenerationModel, StructureGenerationModelSettings } from "./StructureGenerationModel.js";
+import { StructureStreamingModel } from "./StructureGenerationModel.js";
 export type StructureStreamPart<STRUCTURE> = {
     isComplete: false;
     value: unknown;
@@ -10,7 +9,4 @@ export type StructureStreamPart<STRUCTURE> = {
     isComplete: true;
     value: STRUCTURE;
 };
-export declare function streamStructure<STRUCTURE, PROMPT, FULL_DELTA, NAME extends string, SETTINGS extends StructureGenerationModelSettings>(model: StructureGenerationModel<PROMPT, unknown, FULL_DELTA, SETTINGS> & {
-    generateStructureStreamResponse: (structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
-    extractPartialStructure: (fullDelta: FULL_DELTA) => unknown | undefined;
-}, structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: PROMPT, options?: ModelFunctionOptions<SETTINGS>): AsyncIterableResultPromise<StructureStreamPart<STRUCTURE>>;
+export declare function streamStructure<STRUCTURE, PROMPT, NAME extends string>(model: StructureStreamingModel<PROMPT>, structureDefinition: StructureDefinition<NAME, STRUCTURE>, prompt: PROMPT, options?: FunctionOptions): AsyncIterableResultPromise<StructureStreamPart<STRUCTURE>>;

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

@@ -12,14 +12,6 @@ export function streamStructure(model, structureDefinition, prompt, options) {
     return new AsyncIterableResultPromise(doStreamStructure(model, structureDefinition, prompt, options));
 }
 async function doStreamStructure(model, structureDefinition, prompt, options) {
-    if (options?.settings != null) {
-        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 FunctionEventSource({
@@ -51,11 +43,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
         ...startMetadata,
     });
     const result = await runSafe(async () => {
-        const deltaIterable = await model.generateStructureStreamResponse(structureDefinition, prompt, {
-            functionId: options?.functionId,
-            settings,
-            run,
-        });
+        const deltaIterable = await model.doStreamStructure(structureDefinition, prompt, options);
         return (async function* () {
             function reportError(error) {
                 const finishMetadata = {
@@ -88,7 +76,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
                 }
                 if (event?.type === "delta") {
                     const latestFullDelta = event.fullDelta;
-                    const latestStructure = model.extractPartialStructure(latestFullDelta);
+                    const latestStructure = event.valueDelta;
                     // only send a new part into the stream when the partial structure has changed:
                     if (!deepEqual(lastStructure, latestStructure, {
                         strict: true,
@@ -123,7 +111,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
                 result: {
                     status: "success",
                     response: lastFullDelta,
-                    output: lastStructure,
+                    value: lastStructure,
                 },
             });
         })();
@@ -154,7 +142,7 @@ async function doStreamStructure(model, structureDefinition, prompt, options) {
         throw result.error;
     }
     return {
-        output: result.output,
+        output: result.value,
         metadata: startMetadata,
     };
 }

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

@@ -5,7 +5,7 @@ export interface TextGenerationStartedEvent extends BaseModelCallStartedEvent {
 export type TextGenerationFinishedEventResult = {
     status: "success";
     response: unknown;
-    output: string;
+    value: string;
     usage?: {
         promptTokens: number;
         completionTokens: number;

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

@@ -1,9 +1,10 @@
+import { FunctionOptions } from "../../core/FunctionOptions.js";
 import { PromptFormat } from "../../prompt/PromptFormat.js";
 import { PromptFormatTextGenerationModel } from "../../prompt/PromptFormatTextGenerationModel.js";
-import { DeltaEvent } from "../DeltaEvent.js";
 import { Model, ModelSettings } from "../Model.js";
-import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 import { BasicTokenizer, FullTokenizer } from "../tokenize-text/Tokenizer.js";
+import { Delta } from "../Delta.js";
+import { PromptFormatTextStreamingModel } from "index.js";
 export interface TextGenerationModelSettings extends ModelSettings {
     /**
      * Maximum number of tokens to generate.
@@ -21,27 +22,25 @@ export interface TextGenerationModelSettings extends ModelSettings {
      */
     trimWhitespace?: boolean;
 }
-export interface TextGenerationModel<PROMPT, RESPONSE, FULL_DELTA, SETTINGS extends TextGenerationModelSettings> extends Model<SETTINGS> {
+export interface TextGenerationModel<PROMPT, SETTINGS extends TextGenerationModelSettings = TextGenerationModelSettings> extends Model<SETTINGS> {
     readonly contextWindowSize: number | undefined;
     readonly tokenizer: BasicTokenizer | FullTokenizer | undefined;
     /**
      * 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?: ModelFunctionOptions<SETTINGS>): PromiseLike<RESPONSE>;
-    extractText(response: RESPONSE): string;
-    /**
-     * Optional. Implement for streaming support.
-     */
-    readonly generateDeltaStreamResponse?: (prompt: PROMPT, options: ModelFunctionOptions<SETTINGS>) => PromiseLike<AsyncIterable<DeltaEvent<FULL_DELTA>>>;
-    /**
-     * Optional. Implement for streaming support.
-     */
-    readonly extractTextDelta?: (fullDelta: FULL_DELTA) => string | 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>;
+    doGenerateText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<{
+        response: unknown;
+        text: string;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+    }>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextGenerationModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
+}
+export interface TextStreamingModel<PROMPT, SETTINGS extends TextGenerationModelSettings = TextGenerationModelSettings> extends TextGenerationModel<PROMPT, SETTINGS> {
+    doStreamText(prompt: PROMPT, options?: FunctionOptions): PromiseLike<AsyncIterable<Delta<string>>>;
+    withPromptFormat<INPUT_PROMPT>(promptFormat: PromptFormat<INPUT_PROMPT, PROMPT>): PromptFormatTextStreamingModel<INPUT_PROMPT, PROMPT, SETTINGS, this>;
 }