modelfusion 0.104.0 → 0.106.0

package/model-provider/openai/{chat/AbstractOpenAIChatModel.cjs → AbstractOpenAIChatModel.cjs}

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIChatResponseFormat = exports.AbstractOpenAIChatModel = void 0;
 const zod_1 = require("zod");
-const callWithRetryAndThrottle_js_1 = require("../../../core/api/callWithRetryAndThrottle.cjs");
-const postToApi_js_1 = require("../../../core/api/postToApi.cjs");
-const parseJSON_js_1 = require("../../../core/schema/parseJSON.cjs");
-const AbstractModel_js_1 = require("../../../model-function/AbstractModel.cjs");
-const parsePartialJson_js_1 = require("../../../model-function/generate-structure/parsePartialJson.cjs");
-const OpenAIApiConfiguration_js_1 = require("../OpenAIApiConfiguration.cjs");
-const OpenAIError_js_1 = require("../OpenAIError.cjs");
-const OpenAIChatStreamIterable_js_1 = require("./OpenAIChatStreamIterable.cjs");
+const callWithRetryAndThrottle_js_1 = require("../../core/api/callWithRetryAndThrottle.cjs");
+const postToApi_js_1 = require("../../core/api/postToApi.cjs");
+const ZodSchema_js_1 = require("../../core/schema/ZodSchema.cjs");
+const parseJSON_js_1 = require("../../core/schema/parseJSON.cjs");
+const AbstractModel_js_1 = require("../../model-function/AbstractModel.cjs");
+const createEventSourceResponseHandler_js_1 = require("../../util/streaming/createEventSourceResponseHandler.cjs");
+const OpenAIApiConfiguration_js_1 = require("./OpenAIApiConfiguration.cjs");
+const OpenAIError_js_1 = require("./OpenAIError.cjs");
 /**
  * Abstract text generation model that calls an API that is compatible with the OpenAI chat API.
  *
@@ -105,9 +105,21 @@ class AbstractOpenAIChatModel extends AbstractModel_js_1.AbstractModel {
     doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
-            responseFormat: exports.OpenAIChatResponseFormat.textDeltaIterable,
+            responseFormat: exports.OpenAIChatResponseFormat.deltaIterable,
         });
     }
+    extractTextDelta(delta) {
+        const chunk = delta;
+        if (chunk.object !== "chat.completion.chunk") {
+            return undefined;
+        }
+        const chatChunk = chunk;
+        const firstChoice = chatChunk.choices[0];
+        if (firstChoice.index > 0) {
+            return undefined;
+        }
+        return firstChoice.delta.content ?? undefined;
+    }
     async doGenerateToolCall(tool, prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
@@ -220,6 +232,54 @@ const openAIChatResponseSchema = zod_1.z.object({
         total_tokens: zod_1.z.number(),
     }),
 });
+const chatCompletionChunkSchema = zod_1.z.object({
+    object: zod_1.z.literal("chat.completion.chunk"),
+    id: zod_1.z.string(),
+    choices: zod_1.z.array(zod_1.z.object({
+        delta: zod_1.z.object({
+            role: zod_1.z.enum(["assistant", "user"]).optional(),
+            content: zod_1.z.string().nullable().optional(),
+            function_call: zod_1.z
+                .object({
+                name: zod_1.z.string().optional(),
+                arguments: zod_1.z.string().optional(),
+            })
+                .optional(),
+            tool_calls: zod_1.z
+                .array(zod_1.z.object({
+                id: zod_1.z.string(),
+                type: zod_1.z.literal("function"),
+                function: zod_1.z.object({
+                    name: zod_1.z.string(),
+                    arguments: zod_1.z.string(),
+                }),
+            }))
+                .optional(),
+        }),
+        finish_reason: zod_1.z
+            .enum([
+            "stop",
+            "length",
+            "tool_calls",
+            "content_filter",
+            "function_call",
+        ])
+            .nullable()
+            .optional(),
+        index: zod_1.z.number(),
+    })),
+    created: zod_1.z.number(),
+    model: zod_1.z.string(),
+    system_fingerprint: zod_1.z.string().optional().nullable(),
+});
+const openaiChatChunkSchema = (0, ZodSchema_js_1.zodSchema)(zod_1.z.union([
+    chatCompletionChunkSchema,
+    zod_1.z.object({
+        object: zod_1.z.string().refine((obj) => obj !== "chat.completion.chunk", {
+            message: "Object must be 'chat.completion.chunk'",
+        }),
+    }),
+]));
 exports.OpenAIChatResponseFormat = {
     /**
      * Returns the response as a JSON object.
@@ -231,12 +291,8 @@ exports.OpenAIChatResponseFormat = {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    textDeltaIterable: {
-        stream: true,
-        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => delta[0]?.delta?.content ?? ""),
-    },
-    structureDeltaIterable: {
+    deltaIterable: {
         stream: true,
-        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => (0, parsePartialJson_js_1.parsePartialJson)(delta[0]?.function_call?.arguments)),
+        handler: (0, createEventSourceResponseHandler_js_1.createEventSourceResponseHandler)(openaiChatChunkSchema),
     },
 };

package/model-provider/openai/{chat/AbstractOpenAIChatModel.d.ts → AbstractOpenAIChatModel.d.ts}

@@ -1,12 +1,11 @@
 import { z } from "zod";
-import { FunctionOptions } from "../../../core/FunctionOptions.js";
-import { ApiConfiguration } from "../../../core/api/ApiConfiguration.js";
-import { ResponseHandler } from "../../../core/api/postToApi.js";
-import { AbstractModel } from "../../../model-function/AbstractModel.js";
-import { Delta } from "../../../model-function/Delta.js";
-import { TextGenerationModelSettings } from "../../../model-function/generate-text/TextGenerationModel.js";
-import { TextGenerationFinishReason } from "../../../model-function/generate-text/TextGenerationResult.js";
-import { ToolDefinition } from "../../../tool/ToolDefinition.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { ApiConfiguration } from "../../core/api/ApiConfiguration.js";
+import { ResponseHandler } from "../../core/api/postToApi.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { TextGenerationModelSettings } from "../../model-function/generate-text/TextGenerationModel.js";
+import { TextGenerationFinishReason } from "../../model-function/generate-text/TextGenerationResult.js";
+import { ToolDefinition } from "../../tool/ToolDefinition.js";
 import { OpenAIChatMessage } from "./OpenAIChatMessage.js";
 export interface AbstractOpenAIChatCallSettings {
     api?: ApiConfiguration;
@@ -138,7 +137,36 @@ export declare abstract class AbstractOpenAIChatModel<SETTINGS extends AbstractO
         };
     }>;
     private translateFinishReason;
-    doStreamText(prompt: OpenAIChatPrompt, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
+    doStreamText(prompt: OpenAIChatPrompt, options?: FunctionOptions): Promise<AsyncIterable<import("../../index.js").Delta<{
+        object: "chat.completion.chunk";
+        model: string;
+        id: string;
+        created: number;
+        choices: {
+            delta: {
+                role?: "user" | "assistant" | undefined;
+                content?: string | null | undefined;
+                function_call?: {
+                    name?: string | undefined;
+                    arguments?: string | undefined;
+                } | undefined;
+                tool_calls?: {
+                    function: {
+                        name: string;
+                        arguments: string;
+                    };
+                    type: "function";
+                    id: string;
+                }[] | undefined;
+            };
+            index: number;
+            finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+        }[];
+        system_fingerprint?: string | null | undefined;
+    } | {
+        object: string;
+    }>>>;
+    extractTextDelta(delta: unknown): string | undefined;
     doGenerateToolCall(tool: ToolDefinition<string, unknown>, prompt: OpenAIChatPrompt, options?: FunctionOptions): Promise<{
         response: {
             object: "chat.completion";
@@ -437,6 +465,210 @@ declare const openAIChatResponseSchema: z.ZodObject<{
     system_fingerprint?: string | null | undefined;
 }>;
 export type OpenAIChatResponse = z.infer<typeof openAIChatResponseSchema>;
+declare const chatCompletionChunkSchema: z.ZodObject<{
+    object: z.ZodLiteral<"chat.completion.chunk">;
+    id: z.ZodString;
+    choices: z.ZodArray<z.ZodObject<{
+        delta: z.ZodObject<{
+            role: z.ZodOptional<z.ZodEnum<["assistant", "user"]>>;
+            content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            function_call: z.ZodOptional<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                arguments: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            }, {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            }>>;
+            tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                type: z.ZodLiteral<"function">;
+                function: z.ZodObject<{
+                    name: z.ZodString;
+                    arguments: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    name: string;
+                    arguments: string;
+                }, {
+                    name: string;
+                    arguments: string;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }, {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        }, {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        }>;
+        finish_reason: z.ZodOptional<z.ZodNullable<z.ZodEnum<["stop", "length", "tool_calls", "content_filter", "function_call"]>>>;
+        index: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }, {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }>, "many">;
+    created: z.ZodNumber;
+    model: z.ZodString;
+    system_fingerprint: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    object: "chat.completion.chunk";
+    model: string;
+    id: string;
+    created: number;
+    choices: {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }[];
+    system_fingerprint?: string | null | undefined;
+}, {
+    object: "chat.completion.chunk";
+    model: string;
+    id: string;
+    created: number;
+    choices: {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }[];
+    system_fingerprint?: string | null | undefined;
+}>;
+export type OpenAIChatCompletionChunk = z.infer<typeof chatCompletionChunkSchema>;
+declare const openaiChatChunkSchema: import("../../core/schema/ZodSchema.js").ZodSchema<{
+    object: "chat.completion.chunk";
+    model: string;
+    id: string;
+    created: number;
+    choices: {
+        delta: {
+            role?: "user" | "assistant" | undefined;
+            content?: string | null | undefined;
+            function_call?: {
+                name?: string | undefined;
+                arguments?: string | undefined;
+            } | undefined;
+            tool_calls?: {
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+                type: "function";
+                id: string;
+            }[] | undefined;
+        };
+        index: number;
+        finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+    }[];
+    system_fingerprint?: string | null | undefined;
+} | {
+    object: string;
+}>;
+export type OpenAIChatChunk = (typeof openaiChatChunkSchema)["_type"];
 export type OpenAIChatResponseFormatType<T> = {
     stream: boolean;
     handler: ResponseHandler<T>;
@@ -446,7 +678,7 @@ export declare const OpenAIChatResponseFormat: {
      * Returns the response as a JSON object.
      */
     json: {
-        stream: false;
+        stream: boolean;
         handler: ResponseHandler<{
             object: "chat.completion";
             usage: {
@@ -484,17 +716,39 @@ export declare const OpenAIChatResponseFormat: {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    textDeltaIterable: {
-        stream: true;
+    deltaIterable: {
+        stream: boolean;
         handler: ({ response }: {
             response: Response;
-        }) => Promise<AsyncIterable<Delta<string>>>;
-    };
-    structureDeltaIterable: {
-        stream: true;
-        handler: ({ response }: {
-            response: Response;
-        }) => Promise<AsyncIterable<Delta<unknown>>>;
+        }) => Promise<AsyncIterable<import("../../index.js").Delta<{
+            object: "chat.completion.chunk";
+            model: string;
+            id: string;
+            created: number;
+            choices: {
+                delta: {
+                    role?: "user" | "assistant" | undefined;
+                    content?: string | null | undefined;
+                    function_call?: {
+                        name?: string | undefined;
+                        arguments?: string | undefined;
+                    } | undefined;
+                    tool_calls?: {
+                        function: {
+                            name: string;
+                            arguments: string;
+                        };
+                        type: "function";
+                        id: string;
+                    }[] | undefined;
+                };
+                index: number;
+                finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+            }[];
+            system_fingerprint?: string | null | undefined;
+        } | {
+            object: string;
+        }>>>;
     };
 };
 export {};

package/model-provider/openai/{chat/AbstractOpenAIChatModel.js → AbstractOpenAIChatModel.js}

@@ -1,12 +1,12 @@
 import { z } from "zod";
-import { callWithRetryAndThrottle } from "../../../core/api/callWithRetryAndThrottle.js";
-import { createJsonResponseHandler, postJsonToApi, } from "../../../core/api/postToApi.js";
-import { parseJSON } from "../../../core/schema/parseJSON.js";
-import { AbstractModel } from "../../../model-function/AbstractModel.js";
-import { parsePartialJson } from "../../../model-function/generate-structure/parsePartialJson.js";
-import { OpenAIApiConfiguration } from "../OpenAIApiConfiguration.js";
-import { failedOpenAICallResponseHandler } from "../OpenAIError.js";
-import { createOpenAIChatDeltaIterableQueue } from "./OpenAIChatStreamIterable.js";
+import { callWithRetryAndThrottle } from "../../core/api/callWithRetryAndThrottle.js";
+import { createJsonResponseHandler, postJsonToApi, } from "../../core/api/postToApi.js";
+import { zodSchema } from "../../core/schema/ZodSchema.js";
+import { parseJSON } from "../../core/schema/parseJSON.js";
+import { AbstractModel } from "../../model-function/AbstractModel.js";
+import { createEventSourceResponseHandler } from "../../util/streaming/createEventSourceResponseHandler.js";
+import { OpenAIApiConfiguration } from "./OpenAIApiConfiguration.js";
+import { failedOpenAICallResponseHandler } from "./OpenAIError.js";
 /**
  * Abstract text generation model that calls an API that is compatible with the OpenAI chat API.
  *
@@ -102,9 +102,21 @@ export class AbstractOpenAIChatModel extends AbstractModel {
     doStreamText(prompt, options) {
         return this.callAPI(prompt, {
             ...options,
-            responseFormat: OpenAIChatResponseFormat.textDeltaIterable,
+            responseFormat: OpenAIChatResponseFormat.deltaIterable,
         });
     }
+    extractTextDelta(delta) {
+        const chunk = delta;
+        if (chunk.object !== "chat.completion.chunk") {
+            return undefined;
+        }
+        const chatChunk = chunk;
+        const firstChoice = chatChunk.choices[0];
+        if (firstChoice.index > 0) {
+            return undefined;
+        }
+        return firstChoice.delta.content ?? undefined;
+    }
     async doGenerateToolCall(tool, prompt, options) {
         const response = await this.callAPI(prompt, {
             ...options,
@@ -216,6 +228,54 @@ const openAIChatResponseSchema = z.object({
         total_tokens: z.number(),
     }),
 });
+const chatCompletionChunkSchema = z.object({
+    object: z.literal("chat.completion.chunk"),
+    id: z.string(),
+    choices: z.array(z.object({
+        delta: z.object({
+            role: z.enum(["assistant", "user"]).optional(),
+            content: z.string().nullable().optional(),
+            function_call: z
+                .object({
+                name: z.string().optional(),
+                arguments: z.string().optional(),
+            })
+                .optional(),
+            tool_calls: z
+                .array(z.object({
+                id: z.string(),
+                type: z.literal("function"),
+                function: z.object({
+                    name: z.string(),
+                    arguments: z.string(),
+                }),
+            }))
+                .optional(),
+        }),
+        finish_reason: z
+            .enum([
+            "stop",
+            "length",
+            "tool_calls",
+            "content_filter",
+            "function_call",
+        ])
+            .nullable()
+            .optional(),
+        index: z.number(),
+    })),
+    created: z.number(),
+    model: z.string(),
+    system_fingerprint: z.string().optional().nullable(),
+});
+const openaiChatChunkSchema = zodSchema(z.union([
+    chatCompletionChunkSchema,
+    z.object({
+        object: z.string().refine((obj) => obj !== "chat.completion.chunk", {
+            message: "Object must be 'chat.completion.chunk'",
+        }),
+    }),
+]));
 export const OpenAIChatResponseFormat = {
     /**
      * Returns the response as a JSON object.
@@ -227,12 +287,8 @@ export const OpenAIChatResponseFormat = {
     /**
      * Returns an async iterable over the text deltas (only the tex different of the first choice).
      */
-    textDeltaIterable: {
-        stream: true,
-        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => delta[0]?.delta?.content ?? ""),
-    },
-    structureDeltaIterable: {
+    deltaIterable: {
         stream: true,
-        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => parsePartialJson(delta[0]?.function_call?.arguments)),
+        handler: createEventSourceResponseHandler(openaiChatChunkSchema),
     },
 };

package/model-provider/openai/{chat/OpenAIChatFunctionCallStructureGenerationModel.cjs → OpenAIChatFunctionCallStructureGenerationModel.cjs}

@@ -5,7 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIChatFunctionCallStructureGenerationModel = void 0;
 const secure_json_parse_1 = __importDefault(require("secure-json-parse"));
-const StructureParseError_js_1 = require("../../../model-function/generate-structure/StructureParseError.cjs");
+const StructureParseError_js_1 = require("../../model-function/generate-structure/StructureParseError.cjs");
+const parsePartialJson_js_1 = require("../../model-function/generate-structure/parsePartialJson.cjs");
 const AbstractOpenAIChatModel_js_1 = require("./AbstractOpenAIChatModel.cjs");
 const OpenAIChatPromptTemplate_js_1 = require("./OpenAIChatPromptTemplate.cjs");
 class OpenAIChatFunctionCallStructureGenerationModel {
@@ -132,7 +133,7 @@ class OpenAIChatFunctionCallStructureGenerationModel {
         const expandedPrompt = this.promptTemplate.format(prompt);
         return this.model.callAPI(expandedPrompt, {
             ...options,
-            responseFormat: AbstractOpenAIChatModel_js_1.OpenAIChatResponseFormat.structureDeltaIterable,
+            responseFormat: AbstractOpenAIChatModel_js_1.OpenAIChatResponseFormat.deltaIterable,
             functionCall: { name: this.fnName },
             functions: [
                 {
@@ -143,5 +144,20 @@ class OpenAIChatFunctionCallStructureGenerationModel {
             ],
         });
     }
+    extractStructureTextDelta(delta) {
+        const chunk = delta;
+        if (chunk.object !== "chat.completion.chunk") {
+            return undefined;
+        }
+        const chatChunk = chunk;
+        const firstChoice = chatChunk.choices[0];
+        if (firstChoice.index > 0) {
+            return undefined;
+        }
+        return firstChoice.delta.function_call?.arguments;
+    }
+    parseAccumulatedStructureText(accumulatedText) {
+        return (0, parsePartialJson_js_1.parsePartialJson)(accumulatedText);
+    }
 }
 exports.OpenAIChatFunctionCallStructureGenerationModel = OpenAIChatFunctionCallStructureGenerationModel;

package/model-provider/openai/{chat/OpenAIChatFunctionCallStructureGenerationModel.d.ts → OpenAIChatFunctionCallStructureGenerationModel.d.ts}

@@ -1,11 +1,11 @@
-import { FunctionOptions } from "../../../core/FunctionOptions.js";
-import { JsonSchemaProducer } from "../../../core/schema/JsonSchemaProducer.js";
-import { Schema } from "../../../core/schema/Schema.js";
-import { StructureGenerationModel } from "../../../model-function/generate-structure/StructureGenerationModel.js";
-import { TextGenerationPromptTemplate } from "../../../model-function/generate-text/TextGenerationPromptTemplate.js";
+import { FunctionOptions } from "../../core/FunctionOptions.js";
+import { JsonSchemaProducer } from "../../core/schema/JsonSchemaProducer.js";
+import { Schema } from "../../core/schema/Schema.js";
+import { StructureStreamingModel } from "../../model-function/generate-structure/StructureGenerationModel.js";
+import { TextGenerationPromptTemplate } from "../../model-function/generate-text/TextGenerationPromptTemplate.js";
 import { OpenAIChatPrompt } from "./AbstractOpenAIChatModel.js";
-import { OpenAIChatModel, OpenAIChatSettings } from "./OpenAIChatModel";
-export declare class OpenAIChatFunctionCallStructureGenerationModel<PROMPT_TEMPLATE extends TextGenerationPromptTemplate<unknown, OpenAIChatPrompt>> implements StructureGenerationModel<Parameters<PROMPT_TEMPLATE["format"]>[0], // first argument of the function
+import { OpenAIChatModel, OpenAIChatSettings } from "./OpenAIChatModel.js";
+export declare class OpenAIChatFunctionCallStructureGenerationModel<PROMPT_TEMPLATE extends TextGenerationPromptTemplate<unknown, OpenAIChatPrompt>> implements StructureStreamingModel<Parameters<PROMPT_TEMPLATE["format"]>[0], // first argument of the function
 OpenAIChatSettings> {
     readonly model: OpenAIChatModel;
     readonly fnName: string;
@@ -17,7 +17,7 @@ OpenAIChatSettings> {
         fnDescription?: string;
         promptTemplate: PROMPT_TEMPLATE;
     });
-    get modelInformation(): import("../../../index.js").ModelInformation;
+    get modelInformation(): import("../../index.js").ModelInformation;
     get settings(): OpenAIChatSettings;
     get settingsForEvent(): Partial<OpenAIChatSettings>;
     /**
@@ -27,11 +27,11 @@ OpenAIChatSettings> {
     /**
      * Returns this model with an instruction prompt template.
      */
-    withInstructionPrompt(): OpenAIChatFunctionCallStructureGenerationModel<TextGenerationPromptTemplate<import("../../../index.js").InstructionPrompt, OpenAIChatPrompt>>;
+    withInstructionPrompt(): OpenAIChatFunctionCallStructureGenerationModel<TextGenerationPromptTemplate<import("../../index.js").InstructionPrompt, OpenAIChatPrompt>>;
     /**
      * Returns this model with a chat prompt template.
      */
-    withChatPrompt(): OpenAIChatFunctionCallStructureGenerationModel<TextGenerationPromptTemplate<import("../../../index.js").ChatPrompt, OpenAIChatPrompt>>;
+    withChatPrompt(): OpenAIChatFunctionCallStructureGenerationModel<TextGenerationPromptTemplate<import("../../index.js").ChatPrompt, OpenAIChatPrompt>>;
     withPromptTemplate<TARGET_PROMPT_FORMAT extends TextGenerationPromptTemplate<unknown, OpenAIChatPrompt>>(promptTemplate: TARGET_PROMPT_FORMAT): OpenAIChatFunctionCallStructureGenerationModel<TARGET_PROMPT_FORMAT>;
     withSettings(additionalSettings: Partial<OpenAIChatSettings>): this;
     /**
@@ -85,5 +85,35 @@ OpenAIChatSettings> {
         };
     }>;
     doStreamStructure(schema: Schema<unknown> & JsonSchemaProducer, prompt: Parameters<PROMPT_TEMPLATE["format"]>[0], // first argument of the function
-    options?: FunctionOptions): Promise<AsyncIterable<import("../../../index.js").Delta<unknown>>>;
+    options?: FunctionOptions): Promise<AsyncIterable<import("../../index.js").Delta<{
+        object: "chat.completion.chunk";
+        model: string;
+        id: string;
+        created: number;
+        choices: {
+            delta: {
+                role?: "user" | "assistant" | undefined;
+                content?: string | null | undefined;
+                function_call?: {
+                    name?: string | undefined;
+                    arguments?: string | undefined;
+                } | undefined;
+                tool_calls?: {
+                    function: {
+                        name: string;
+                        arguments: string;
+                    };
+                    type: "function";
+                    id: string;
+                }[] | undefined;
+            };
+            index: number;
+            finish_reason?: "length" | "stop" | "function_call" | "tool_calls" | "content_filter" | null | undefined;
+        }[];
+        system_fingerprint?: string | null | undefined;
+    } | {
+        object: string;
+    }>>>;
+    extractStructureTextDelta(delta: unknown): string | undefined;
+    parseAccumulatedStructureText(accumulatedText: string): unknown;
 }