modelfusion 0.33.1 → 0.35.0

package/README.md

@@ -133,7 +133,7 @@ for (const choice of response.choices) {
 console.log(`Duration: ${metadata.durationInMs}ms`);
 ```
 
-### [Generate Structure](https://modelfusion.dev/guide/function/generate-structure)
+### [Generate Structure](https://modelfusion.dev/guide/function/generate-structure#generatestructure)
 
 Generate a structure that matches a schema.
 
@@ -168,6 +168,52 @@ const sentiment = await generateStructure(
 
 Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai)
 
+### [Stream Structure](https://modelfusion.dev/guide/function/generate-structure#streamstructure)
+
+Stream a structure that matches a schema. Partial structures before the final part are untyped JSON.
+
+```ts
+const structureStream = await streamStructure(
+  new OpenAIChatModel({
+    model: "gpt-3.5-turbo",
+    temperature: 0,
+    maxCompletionTokens: 2000,
+  }),
+  new ZodStructureDefinition({
+    name: "generateCharacter" as const,
+    description: "Generate character descriptions.",
+    schema: z.object({
+      characters: z.array(
+        z.object({
+          name: z.string(),
+          class: z
+            .string()
+            .describe("Character class, e.g. warrior, mage, or thief."),
+          description: z.string(),
+        })
+      ),
+    }),
+  }),
+  [
+    OpenAIChatMessage.user(
+      "Generate 3 character descriptions for a fantasy role playing game."
+    ),
+  ]
+);
+
+for await (const part of structureStream) {
+  if (!part.isComplete) {
+    const unknownPartialStructure = part.value;
+    console.log("partial value", unknownPartialStructure);
+  } else {
+    const fullyTypedStructure = part.value;
+    console.log("final value", fullyTypedStructure);
+  }
+}
+```
+
+Providers: [OpenAI](https://modelfusion.dev/integration/model-provider/openai)
+
 ### [Generate Structure or Text](https://modelfusion.dev/guide/function/generate-structure-or-text)
 
 Generate a structure (or text as a fallback) using a prompt and multiple schemas.

package/{model-function/generate-text → event-source}/AsyncQueue.cjs

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncQueue = void 0;
-/**
- * @internal
- */
 class AsyncQueue {
     constructor() {
         Object.defineProperty(this, "queue", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
         Object.defineProperty(this, "resolvers", {
             enumerable: true,
@@ -22,11 +19,8 @@ class AsyncQueue {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: false
         });
-        this.queue = [];
-        this.resolvers = [];
-        this.closed = false;
     }
     push(value) {
         if (this.closed) {
@@ -43,6 +37,7 @@ class AsyncQueue {
     close() {
         while (this.resolvers.length) {
             const resolve = this.resolvers.shift();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             resolve?.({ value: undefined, done: true });
         }
         this.closed = true;
@@ -51,13 +46,19 @@ class AsyncQueue {
         return {
             next: () => {
                 if (this.queue.length > 0) {
-                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                    return Promise.resolve({
+                        value: this.queue.shift(),
+                        done: false,
+                    });
                 }
                 else if (this.closed) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     return Promise.resolve({ value: undefined, done: true });
                 }
                 else {
-                    return new Promise((resolve) => this.resolvers.push(resolve));
+                    return new Promise((resolve) => {
+                        this.resolvers.push(resolve);
+                    });
                 }
             },
         };

package/event-source/AsyncQueue.d.ts

@@ -0,0 +1,8 @@
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    private closed;
+    push(value: T): void;
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}

package/{model-function/generate-text → event-source}/AsyncQueue.js

@@ -1,13 +1,10 @@
-/**
- * @internal
- */
 export class AsyncQueue {
     constructor() {
         Object.defineProperty(this, "queue", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: []
         });
         Object.defineProperty(this, "resolvers", {
             enumerable: true,
@@ -19,11 +16,8 @@ export class AsyncQueue {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: false
         });
-        this.queue = [];
-        this.resolvers = [];
-        this.closed = false;
     }
     push(value) {
         if (this.closed) {
@@ -40,6 +34,7 @@ export class AsyncQueue {
     close() {
         while (this.resolvers.length) {
             const resolve = this.resolvers.shift();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             resolve?.({ value: undefined, done: true });
         }
         this.closed = true;
@@ -48,13 +43,19 @@ export class AsyncQueue {
         return {
             next: () => {
                 if (this.queue.length > 0) {
-                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                    return Promise.resolve({
+                        value: this.queue.shift(),
+                        done: false,
+                    });
                 }
                 else if (this.closed) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     return Promise.resolve({ value: undefined, done: true });
                 }
                 else {
-                    return new Promise((resolve) => this.resolvers.push(resolve));
+                    return new Promise((resolve) => {
+                        this.resolvers.push(resolve);
+                    });
                 }
             },
         };

package/event-source/EventSourceParserStream.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSourceParserStream = void 0;
+const eventsource_parser_1 = require("eventsource-parser");
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
+ *
+ * @example
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ */
+// Copied from https://github.com/rexxars/eventsource-parser/blob/main/src/stream.ts to avoid issues with the commonjs build.
+class EventSourceParserStream extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = (0, eventsource_parser_1.createParser)((event) => {
+                    if (event.type === "event") {
+                        controller.enqueue(event);
+                    }
+                });
+            },
+            transform(chunk) {
+                parser.feed(chunk);
+            },
+        });
+    }
+}
+exports.EventSourceParserStream = EventSourceParserStream;

package/event-source/EventSourceParserStream.d.ts

@@ -0,0 +1,15 @@
+import { ParsedEvent } from "eventsource-parser";
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
+ *
+ * @example
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ */
+export declare class EventSourceParserStream extends TransformStream<string, ParsedEvent> {
+    constructor();
+}

package/event-source/EventSourceParserStream.js

@@ -0,0 +1,30 @@
+import { createParser, } from "eventsource-parser";
+/**
+ * A TransformStream that ingests a stream of strings and produces a stream of ParsedEvents.
+ *
+ * @example
+ * ```
+ * const eventStream =
+ *   response.body
+ *     .pipeThrough(new TextDecoderStream())
+ *     .pipeThrough(new EventSourceParserStream())
+ * ```
+ */
+// Copied from https://github.com/rexxars/eventsource-parser/blob/main/src/stream.ts to avoid issues with the commonjs build.
+export class EventSourceParserStream extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = createParser((event) => {
+                    if (event.type === "event") {
+                        controller.enqueue(event);
+                    }
+                });
+            },
+            transform(chunk) {
+                parser.feed(chunk);
+            },
+        });
+    }
+}

package/event-source/convertReadableStreamToAsyncIterable.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertReadableStreamToAsyncIterable = void 0;
+async function* convertReadableStreamToAsyncIterable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return; // This will close the generator
+            }
+            yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+exports.convertReadableStreamToAsyncIterable = convertReadableStreamToAsyncIterable;

package/event-source/convertReadableStreamToAsyncIterable.d.ts

@@ -0,0 +1 @@
+export declare function convertReadableStreamToAsyncIterable<T>(stream: ReadableStream<T>): AsyncIterable<T>;

package/event-source/convertReadableStreamToAsyncIterable.js

@@ -0,0 +1,15 @@
+export async function* convertReadableStreamToAsyncIterable(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return; // This will close the generator
+            }
+            yield value;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/event-source/createEventSourceStream.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventSourceStream = void 0;
+const textEncoder = new TextEncoder();
+function createEventSourceStream(events) {
+    return new ReadableStream({
+        async start(controller) {
+            for await (const event of events) {
+                controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+            }
+            controller.close();
+        },
+    });
+}
+exports.createEventSourceStream = createEventSourceStream;

package/event-source/createEventSourceStream.d.ts

@@ -0,0 +1 @@
+export declare function createEventSourceStream(events: AsyncIterable<unknown>): ReadableStream<any>;

package/event-source/createEventSourceStream.js

@@ -0,0 +1,11 @@
+const textEncoder = new TextEncoder();
+export function createEventSourceStream(events) {
+    return new ReadableStream({
+        async start(controller) {
+            for await (const event of events) {
+                controller.enqueue(textEncoder.encode(`data: ${JSON.stringify(event)}\n\n`));
+            }
+            controller.close();
+        },
+    });
+}

package/event-source/index.cjs

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AsyncQueue.cjs"), exports);
+__exportStar(require("./createEventSourceStream.cjs"), exports);
+__exportStar(require("./readEventSourceStream.cjs"), exports);

package/event-source/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./AsyncQueue.js";
+export * from "./createEventSourceStream.js";
+export * from "./readEventSourceStream.js";

package/event-source/index.js

@@ -0,0 +1,3 @@
+export * from "./AsyncQueue.js";
+export * from "./createEventSourceStream.js";
+export * from "./readEventSourceStream.js";

package/event-source/parseEventSourceStream.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEventSourceStream = void 0;
+const convertReadableStreamToAsyncIterable_js_1 = require("./convertReadableStreamToAsyncIterable.cjs");
+const EventSourceParserStream_js_1 = require("./EventSourceParserStream.cjs");
+async function parseEventSourceStream({ stream, }) {
+    const eventStream = stream
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new EventSourceParserStream_js_1.EventSourceParserStream());
+    return (0, convertReadableStreamToAsyncIterable_js_1.convertReadableStreamToAsyncIterable)(eventStream);
+}
+exports.parseEventSourceStream = parseEventSourceStream;

package/event-source/parseEventSourceStream.d.ts

@@ -0,0 +1,4 @@
+import { ParsedEvent } from "eventsource-parser";
+export declare function parseEventSourceStream({ stream, }: {
+    stream: ReadableStream<Uint8Array>;
+}): Promise<AsyncIterable<ParsedEvent>>;

package/event-source/parseEventSourceStream.js

@@ -0,0 +1,8 @@
+import { convertReadableStreamToAsyncIterable } from "./convertReadableStreamToAsyncIterable.js";
+import { EventSourceParserStream } from "./EventSourceParserStream.js";
+export async function parseEventSourceStream({ stream, }) {
+    const eventStream = stream
+        .pipeThrough(new TextDecoderStream())
+        .pipeThrough(new EventSourceParserStream());
+    return convertReadableStreamToAsyncIterable(eventStream);
+}

package/event-source/readEventSourceStream.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEventSourceStream = void 0;
+const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
+const AsyncQueue_js_1 = require("./AsyncQueue.cjs");
+const parseEventSourceStream_js_1 = require("./parseEventSourceStream.cjs");
+function readEventSourceStream({ stream, schema, errorHandler, }) {
+    const queue = new AsyncQueue_js_1.AsyncQueue();
+    // run async (no await on purpose):
+    (0, parseEventSourceStream_js_1.parseEventSourceStream)({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                queue.push(schema.parse(secure_json_parse_1.default.parse(event.data)));
+            }
+        }
+        catch (error) {
+            errorHandler?.(error);
+        }
+        finally {
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        errorHandler?.(error);
+        queue.close();
+    });
+    return queue;
+}
+exports.readEventSourceStream = readEventSourceStream;

package/event-source/readEventSourceStream.d.ts

@@ -0,0 +1,6 @@
+import { ErrorHandler } from "../util/ErrorHandler.js";
+export declare function readEventSourceStream<T>({ stream, schema, errorHandler, }: {
+    stream: ReadableStream<Uint8Array>;
+    schema: Zod.Schema<T>;
+    errorHandler?: ErrorHandler;
+}): AsyncIterable<T>;

package/event-source/readEventSourceStream.js

@@ -0,0 +1,26 @@
+import SecureJSON from "secure-json-parse";
+import { AsyncQueue } from "./AsyncQueue.js";
+import { parseEventSourceStream } from "./parseEventSourceStream.js";
+export function readEventSourceStream({ stream, schema, errorHandler, }) {
+    const queue = new AsyncQueue();
+    // run async (no await on purpose):
+    parseEventSourceStream({ stream })
+        .then(async (events) => {
+        try {
+            for await (const event of events) {
+                queue.push(schema.parse(SecureJSON.parse(event.data)));
+            }
+        }
+        catch (error) {
+            errorHandler?.(error);
+        }
+        finally {
+            queue.close();
+        }
+    })
+        .catch((error) => {
+        errorHandler?.(error);
+        queue.close();
+    });
+    return queue;
+}

package/index.cjs

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./composed-function/index.cjs"), exports);
 __exportStar(require("./core/index.cjs"), exports);
 __exportStar(require("./cost/index.cjs"), exports);
+__exportStar(require("./event-source/index.cjs"), exports);
 __exportStar(require("./model-function/index.cjs"), exports);
 __exportStar(require("./model-provider/index.cjs"), exports);
 __exportStar(require("./observability/index.cjs"), exports);

package/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./composed-function/index.js";
 export * from "./core/index.js";
 export * from "./cost/index.js";
+export * from "./event-source/index.js";
 export * from "./model-function/index.js";
 export * from "./model-provider/index.js";
 export * from "./observability/index.js";

package/index.js

@@ -1,6 +1,7 @@
 export * from "./composed-function/index.js";
 export * from "./core/index.js";
 export * from "./cost/index.js";
+export * from "./event-source/index.js";
 export * from "./model-function/index.js";
 export * from "./model-provider/index.js";
 export * from "./observability/index.js";

package/model-function/AsyncIterableResultPromise.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncIterableResultPromise = void 0;
+class AsyncIterableResultPromise extends Promise {
+    constructor(fullPromise) {
+        super((resolve) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            resolve(null); // we override the resolve function
+        });
+        Object.defineProperty(this, "fullPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fullPromise
+        });
+        Object.defineProperty(this, "outputPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.outputPromise = fullPromise.then((result) => result.output);
+    }
+    asFullResponse() {
+        return this.fullPromise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.outputPromise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.outputPromise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.outputPromise.finally(onfinally);
+    }
+}
+exports.AsyncIterableResultPromise = AsyncIterableResultPromise;

package/model-function/AsyncIterableResultPromise.d.ts

@@ -0,0 +1,16 @@
+import { ModelCallMetadata } from "./executeCall.js";
+export declare class AsyncIterableResultPromise<T> extends Promise<AsyncIterable<T>> {
+    private fullPromise;
+    private outputPromise;
+    constructor(fullPromise: Promise<{
+        output: AsyncIterable<T>;
+        metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
+    }>);
+    asFullResponse(): Promise<{
+        output: AsyncIterable<T>;
+        metadata: Omit<ModelCallMetadata, "durationInMs" | "finishTimestamp">;
+    }>;
+    then<TResult1 = AsyncIterable<T>, TResult2 = never>(onfulfilled?: ((value: AsyncIterable<T>) => 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<T> | TResult>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<AsyncIterable<T>>;
+}

package/model-function/AsyncIterableResultPromise.js

@@ -0,0 +1,33 @@
+export class AsyncIterableResultPromise extends Promise {
+    constructor(fullPromise) {
+        super((resolve) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            resolve(null); // we override the resolve function
+        });
+        Object.defineProperty(this, "fullPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fullPromise
+        });
+        Object.defineProperty(this, "outputPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.outputPromise = fullPromise.then((result) => result.output);
+    }
+    asFullResponse() {
+        return this.fullPromise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.outputPromise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.outputPromise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.outputPromise.finally(onfinally);
+    }
+}

package/model-function/{generate-text/DeltaEvent.d.ts → DeltaEvent.d.ts}

@@ -4,4 +4,4 @@ export type DeltaEvent<FULL_DELTA> = {
 } | {
     type: "error";
     error: unknown;
-} | undefined;
+};

package/model-function/ModelCallEvent.d.ts

@@ -4,6 +4,7 @@ import { ImageDescriptionFinishedEvent, ImageDescriptionStartedEvent } from "./d
 import { TextEmbeddingFinishedEvent, TextEmbeddingStartedEvent } from "./embed-text/TextEmbeddingEvent.js";
 import { ImageGenerationFinishedEvent, ImageGenerationStartedEvent } from "./generate-image/ImageGenerationEvent.js";
 import { StructureGenerationFinishedEvent, StructureGenerationStartedEvent } from "./generate-structure/StructureGenerationEvent.js";
+import { StructureStreamingFinishedEvent, StructureStreamingStartedEvent } from "./generate-structure/StructureStreamingEvent.js";
 import { TextGenerationFinishedEvent, TextGenerationStartedEvent } from "./generate-text/TextGenerationEvent.js";
 import { TextStreamingFinishedEvent, TextStreamingStartedEvent } from "./generate-text/TextStreamingEvent.js";
 import { SpeechSynthesisFinishedEvent, SpeechSynthesisStartedEvent } from "./synthesize-speech/SpeechSynthesisEvent.js";
@@ -48,5 +49,5 @@ export interface BaseModelCallFinishedEvent extends BaseFunctionFinishedEvent {
      */
     result: BaseModelCallFinishedEventResult;
 }
-export type ModelCallStartedEvent = ImageDescriptionStartedEvent | ImageGenerationStartedEvent | StructureGenerationStartedEvent | SpeechSynthesisStartedEvent | TextEmbeddingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
-export type ModelCallFinishedEvent = ImageDescriptionFinishedEvent | ImageGenerationFinishedEvent | StructureGenerationFinishedEvent | SpeechSynthesisFinishedEvent | TextEmbeddingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;
+export type ModelCallStartedEvent = ImageDescriptionStartedEvent | ImageGenerationStartedEvent | StructureGenerationStartedEvent | StructureStreamingStartedEvent | SpeechSynthesisStartedEvent | TextEmbeddingStartedEvent | TextGenerationStartedEvent | TextStreamingStartedEvent | TranscriptionStartedEvent;
+export type ModelCallFinishedEvent = ImageDescriptionFinishedEvent | ImageGenerationFinishedEvent | StructureGenerationFinishedEvent | StructureStreamingFinishedEvent | SpeechSynthesisFinishedEvent | TextEmbeddingFinishedEvent | TextGenerationFinishedEvent | TextStreamingFinishedEvent | TranscriptionFinishedEvent;

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

@@ -6,7 +6,7 @@ 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, MODEL["settings"]> {
+export declare class StructureFromTextGenerationModel<PROMPT, MODEL extends TextGenerationModel<string, any, any, TextGenerationModelSettings>> implements StructureGenerationModel<PROMPT, string, undefined, MODEL["settings"]> {
     private readonly model;
     private readonly format;
     constructor({ model, format, }: {

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

@@ -1,9 +1,10 @@
 import { StructureDefinition } from "../../core/structure/StructureDefinition.js";
+import { DeltaEvent } from "../DeltaEvent.js";
 import { Model, ModelSettings } from "../Model.js";
 import { ModelFunctionOptions } from "../ModelFunctionOptions.js";
 export interface StructureGenerationModelSettings extends ModelSettings {
 }
-export interface StructureGenerationModel<PROMPT, RESPONSE, SETTINGS extends StructureGenerationModelSettings> extends Model<SETTINGS> {
+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): {
@@ -11,4 +12,12 @@ export interface StructureGenerationModel<PROMPT, RESPONSE, SETTINGS extends Str
         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;
 }

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });