modelfusion 0.96.0 → 0.98.0

package/model-provider/cohere/CohereTextEmbeddingModel.d.ts

@@ -74,6 +74,7 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
     get settingsForEvent(): Partial<CohereTextEmbeddingModelSettings>;
     doEmbedValues(texts: string[], options?: FunctionOptions): Promise<{
         response: {
+            embeddings: number[][];
             id: string;
             meta: {
                 api_version: {
@@ -81,7 +82,6 @@ export declare class CohereTextEmbeddingModel extends AbstractModel<CohereTextEm
                 };
             };
             texts: string[];
-            embeddings: number[][];
         };
         embeddings: number[][];
     }>;
@@ -109,6 +109,7 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     }>;
 }, "strip", z.ZodTypeAny, {
+    embeddings: number[][];
     id: string;
     meta: {
         api_version: {
@@ -116,8 +117,8 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     };
     texts: string[];
-    embeddings: number[][];
 }, {
+    embeddings: number[][];
     id: string;
     meta: {
         api_version: {
@@ -125,7 +126,6 @@ declare const cohereTextEmbeddingResponseSchema: z.ZodObject<{
         };
     };
     texts: string[];
-    embeddings: number[][];
 }>;
 export type CohereTextEmbeddingResponse = z.infer<typeof cohereTextEmbeddingResponseSchema>;
 export {};

package/model-provider/ollama/OllamaTextGenerationModel.cjs

@@ -44,15 +44,47 @@ class OllamaTextGenerationModel extends AbstractModel_js_1.AbstractModel {
         return this.settings.contextWindowSize;
     }
     async callAPI(prompt, options) {
+        const { responseFormat } = options;
+        const api = this.settings.api ?? new OllamaApiConfiguration_js_1.OllamaApiConfiguration();
+        const abortSignal = options.run?.abortSignal;
         return (0, callWithRetryAndThrottle_js_1.callWithRetryAndThrottle)({
-            retry: this.settings.api?.retry,
-            throttle: this.settings.api?.throttle,
-            call: async () => callOllamaTextGenerationAPI({
-                ...this.settings,
-                // other
-                abortSignal: options.run?.abortSignal,
-                prompt,
-                responseFormat: options.responseFormat,
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => (0, postToApi_js_1.postJsonToApi)({
+                url: api.assembleUrl(`/api/generate`),
+                headers: api.headers,
+                body: {
+                    stream: responseFormat.stream,
+                    model: this.settings.model,
+                    prompt: prompt.prompt,
+                    images: prompt.images,
+                    format: this.settings.format,
+                    options: {
+                        mirostat: this.settings.mirostat,
+                        mirostat_eta: this.settings.mirostatEta,
+                        mirostat_tau: this.settings.mirostatTau,
+                        num_ctx: this.settings.contextWindowSize,
+                        num_gpu: this.settings.numGpu,
+                        num_gqa: this.settings.numGqa,
+                        num_predict: this.settings.maxCompletionTokens,
+                        num_threads: this.settings.numThreads,
+                        repeat_last_n: this.settings.repeatLastN,
+                        repeat_penalty: this.settings.repeatPenalty,
+                        seed: this.settings.seed,
+                        stop: this.settings.stopSequences,
+                        temperature: this.settings.temperature,
+                        tfs_z: this.settings.tfsZ,
+                        top_k: this.settings.topK,
+                        top_p: this.settings.topP,
+                    },
+                    system: this.settings.system,
+                    template: this.settings.template,
+                    context: this.settings.context,
+                    raw: this.settings.raw,
+                },
+                failedResponseHandler: OllamaError_js_1.failedOllamaCallResponseHandler,
+                successfulResponseHandler: responseFormat.handler,
+                abortSignal,
             }),
         });
     }
@@ -63,17 +95,17 @@ class OllamaTextGenerationModel extends AbstractModel_js_1.AbstractModel {
             "contextWindowSize",
             "temperature",
             "mirostat",
-            "mirostat_eta",
-            "mirostat_tau",
-            "num_gqa",
-            "num_gpu",
-            "num_threads",
-            "repeat_last_n",
-            "repeat_penalty",
+            "mirostatEta",
+            "mirostatTau",
+            "numGqa",
+            "numGpu",
+            "numThreads",
+            "repeatLastN",
+            "repeatPenalty",
             "seed",
-            "tfs_z",
-            "top_k",
-            "top_p",
+            "tfsZ",
+            "topK",
+            "topP",
             "system",
             "template",
             "context",
@@ -110,6 +142,14 @@ class OllamaTextGenerationModel extends AbstractModel_js_1.AbstractModel {
             template: promptTemplate,
         });
     }
+    withTextPrompt() {
+        return this.withPromptTemplate({
+            format(prompt) {
+                return { prompt: prompt };
+            },
+            stopSequences: [],
+        });
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextStreamingModel_js_1.PromptTemplateTextStreamingModel({
             model: this.withSettings({
@@ -131,7 +171,7 @@ const ollamaTextGenerationResponseSchema = zod_1.z.object({
     model: zod_1.z.string(),
     response: zod_1.z.string(),
     total_duration: zod_1.z.number(),
-    load_duration: zod_1.z.number(),
+    load_duration: zod_1.z.number().optional(),
     prompt_eval_count: zod_1.z.number(),
     eval_count: zod_1.z.number(),
     eval_duration: zod_1.z.number(),
@@ -149,7 +189,7 @@ const ollamaTextStreamingResponseSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.d
         model: zod_1.z.string(),
         created_at: zod_1.z.string(),
         total_duration: zod_1.z.number(),
-        load_duration: zod_1.z.number(),
+        load_duration: zod_1.z.number().optional(),
         sample_count: zod_1.z.number().optional(),
         sample_duration: zod_1.z.number().optional(),
         prompt_eval_count: zod_1.z.number(),
@@ -159,43 +199,6 @@ const ollamaTextStreamingResponseSchema = new ZodSchema_js_1.ZodSchema(zod_1.z.d
         context: zod_1.z.array(zod_1.z.number()).optional(),
     }),
 ]));
-async function callOllamaTextGenerationAPI({ api = new OllamaApiConfiguration_js_1.OllamaApiConfiguration(), abortSignal, responseFormat, prompt, model, format, contextWindowSize, maxCompletionTokens, mirostat, mirostat_eta, mirostat_tau, num_gpu, num_gqa, num_threads, repeat_last_n, repeat_penalty, seed, stopSequences, temperature, tfs_z, top_k, top_p, system, template, context, raw, }) {
-    return (0, postToApi_js_1.postJsonToApi)({
-        url: api.assembleUrl(`/api/generate`),
-        headers: api.headers,
-        body: {
-            stream: responseFormat.stream,
-            model,
-            prompt,
-            format,
-            options: {
-                mirostat,
-                mirostat_eta,
-                mirostat_tau,
-                num_ctx: contextWindowSize,
-                num_gpu,
-                num_gqa,
-                num_predict: maxCompletionTokens,
-                num_threads,
-                repeat_last_n,
-                repeat_penalty,
-                seed,
-                stop: stopSequences,
-                temperature,
-                tfs_z,
-                top_k,
-                top_p,
-            },
-            system,
-            template,
-            context,
-            raw,
-        },
-        failedResponseHandler: OllamaError_js_1.failedOllamaCallResponseHandler,
-        successfulResponseHandler: responseFormat.handler,
-        abortSignal,
-    });
-}
 async function createOllamaFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue_js_1.AsyncQueue();
     let accumulatedText = "";

package/model-provider/ollama/OllamaTextGenerationModel.d.ts

@@ -40,39 +40,39 @@ export interface OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE extends n
      * A lower learning rate will result in slower adjustments,
      * while a higher learning rate will make the algorithm more responsive. (Default: 0.1)
      */
-    mirostat_eta?: number;
+    mirostatEta?: number;
     /**
      * Controls the balance between coherence and diversity of the output.
      * A lower value will result in more focused and coherent text. (Default: 5.0)
      */
-    mirostat_tau?: number;
+    mirostatTau?: number;
     /**
      * The number of GQA groups in the transformer layer. Required for some models,
      * for example it is 8 for llama2:70b
      */
-    num_gqa?: number;
+    numGqa?: number;
     /**
      * The number of layers to send to the GPU(s). On macOS it defaults to 1 to
      * enable metal support, 0 to disable.
      */
-    num_gpu?: number;
+    numGpu?: number;
     /**
      * Sets the number of threads to use during computation. By default, Ollama will
      * detect this for optimal performance. It is recommended to set this value to the
      * number of physical CPU cores your system has (as opposed to the logical number of cores).
      */
-    num_threads?: number;
+    numThreads?: number;
     /**
      * Sets how far back for the model to look back to prevent repetition.
      * (Default: 64, 0 = disabled, -1 = num_ctx)
      */
-    repeat_last_n?: number;
+    repeatLastN?: number;
     /**
      * Sets how strongly to penalize repetitions. A higher value (e.g., 1.5)
      * will penalize repetitions more strongly, while a lower value (e.g., 0.9)
      * will be more lenient. (Default: 1.1)
      */
-    repeat_penalty?: number;
+    repeatPenalty?: number;
     /**
      * Sets the random number seed to use for generation. Setting this to a
      * specific number will make the model generate the same text for the same prompt.
@@ -84,19 +84,19 @@ export interface OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE extends n
      * from the output. A higher value (e.g., 2.0) will reduce the impact more,
      * while a value of 1.0 disables this setting. (default: 1)
      */
-    tfs_z?: number;
+    tfsZ?: number;
     /**
      * Reduces the probability of generating nonsense. A higher value (e.g. 100)
      * will give more diverse answers, while a lower value (e.g. 10) will be more
      *  conservative. (Default: 40)
      */
-    top_k?: number;
+    topK?: number;
     /**
      * Works together with top-k. A higher value (e.g., 0.95) will lead to more
      * diverse text, while a lower value (e.g., 0.5) will generate more focused
      * and conservative text. (Default: 0.9)
      */
-    top_p?: number;
+    topP?: number;
     /**
      * When set to true, no formatting will be applied to the prompt and no context
      * will be returned.
@@ -111,35 +111,46 @@ export interface OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE extends n
     template?: string;
     context?: number[];
 }
-export declare class OllamaTextGenerationModel<CONTEXT_WINDOW_SIZE extends number | undefined> extends AbstractModel<OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> implements TextStreamingModel<string, OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> {
+export interface OllamaTextGenerationPrompt {
+    /**
+     * Text prompt.
+     */
+    prompt: string;
+    /**
+     Images. Supports base64-encoded `png` and `jpeg` images up to 100MB in size.
+     */
+    images?: Record<number, string>;
+}
+export declare class OllamaTextGenerationModel<CONTEXT_WINDOW_SIZE extends number | undefined> extends AbstractModel<OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> implements TextStreamingModel<OllamaTextGenerationPrompt, OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>> {
     constructor(settings: OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>);
     readonly provider = "ollama";
     get modelName(): string;
     readonly tokenizer: undefined;
     readonly countPromptTokens: undefined;
     get contextWindowSize(): CONTEXT_WINDOW_SIZE;
-    callAPI<RESPONSE>(prompt: string, options: {
+    callAPI<RESPONSE>(prompt: OllamaTextGenerationPrompt, options: {
         responseFormat: OllamaTextGenerationResponseFormatType<RESPONSE>;
     } & FunctionOptions): Promise<RESPONSE>;
     get settingsForEvent(): Partial<OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>;
-    doGenerateText(prompt: string, options?: FunctionOptions): Promise<{
+    doGenerateText(prompt: OllamaTextGenerationPrompt, options?: FunctionOptions): Promise<{
         response: {
             response: string;
             model: string;
             done: true;
             total_duration: number;
-            load_duration: number;
             prompt_eval_count: number;
             eval_count: number;
             eval_duration: number;
+            load_duration?: number | undefined;
             context?: number[] | undefined;
         };
         text: string;
     }>;
-    doStreamText(prompt: string, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
-    asToolCallGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallPromptTemplate<INPUT_PROMPT, string>): TextGenerationToolCallModel<INPUT_PROMPT, string, this>;
-    asToolCallsOrTextGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallsOrGenerateTextPromptTemplate<INPUT_PROMPT, string>): TextGenerationToolCallsOrGenerateTextModel<INPUT_PROMPT, string, this>;
-    withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, string>): PromptTemplateTextStreamingModel<INPUT_PROMPT, string, OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
+    doStreamText(prompt: OllamaTextGenerationPrompt, options?: FunctionOptions): Promise<AsyncIterable<Delta<string>>>;
+    asToolCallGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallPromptTemplate<INPUT_PROMPT, OllamaTextGenerationPrompt>): TextGenerationToolCallModel<INPUT_PROMPT, OllamaTextGenerationPrompt, this>;
+    asToolCallsOrTextGenerationModel<INPUT_PROMPT>(promptTemplate: ToolCallsOrGenerateTextPromptTemplate<INPUT_PROMPT, OllamaTextGenerationPrompt>): TextGenerationToolCallsOrGenerateTextModel<INPUT_PROMPT, OllamaTextGenerationPrompt, this>;
+    withTextPrompt(): PromptTemplateTextStreamingModel<string, OllamaTextGenerationPrompt, OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
+    withPromptTemplate<INPUT_PROMPT>(promptTemplate: TextGenerationPromptTemplate<INPUT_PROMPT, OllamaTextGenerationPrompt>): PromptTemplateTextStreamingModel<INPUT_PROMPT, OllamaTextGenerationPrompt, OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>, this>;
     withSettings(additionalSettings: Partial<OllamaTextGenerationModelSettings<CONTEXT_WINDOW_SIZE>>): this;
 }
 declare const ollamaTextGenerationResponseSchema: z.ZodObject<{
@@ -147,7 +158,7 @@ declare const ollamaTextGenerationResponseSchema: z.ZodObject<{
     model: z.ZodString;
     response: z.ZodString;
     total_duration: z.ZodNumber;
-    load_duration: z.ZodNumber;
+    load_duration: z.ZodOptional<z.ZodNumber>;
     prompt_eval_count: z.ZodNumber;
     eval_count: z.ZodNumber;
     eval_duration: z.ZodNumber;
@@ -157,20 +168,20 @@ declare const ollamaTextGenerationResponseSchema: z.ZodObject<{
     model: string;
     done: true;
     total_duration: number;
-    load_duration: number;
     prompt_eval_count: number;
     eval_count: number;
     eval_duration: number;
+    load_duration?: number | undefined;
     context?: number[] | undefined;
 }, {
     response: string;
     model: string;
     done: true;
     total_duration: number;
-    load_duration: number;
     prompt_eval_count: number;
     eval_count: number;
     eval_duration: number;
+    load_duration?: number | undefined;
     context?: number[] | undefined;
 }>;
 export type OllamaTextGenerationResponse = z.infer<typeof ollamaTextGenerationResponseSchema>;
@@ -198,10 +209,10 @@ export declare const OllamaTextGenerationResponseFormat: {
             model: string;
             done: true;
             total_duration: number;
-            load_duration: number;
             prompt_eval_count: number;
             eval_count: number;
             eval_duration: number;
+            load_duration?: number | undefined;
             context?: number[] | undefined;
         }>;
     };

package/model-provider/ollama/OllamaTextGenerationModel.js

@@ -41,15 +41,47 @@ export class OllamaTextGenerationModel extends AbstractModel {
         return this.settings.contextWindowSize;
     }
     async callAPI(prompt, options) {
+        const { responseFormat } = options;
+        const api = this.settings.api ?? new OllamaApiConfiguration();
+        const abortSignal = options.run?.abortSignal;
         return callWithRetryAndThrottle({
-            retry: this.settings.api?.retry,
-            throttle: this.settings.api?.throttle,
-            call: async () => callOllamaTextGenerationAPI({
-                ...this.settings,
-                // other
-                abortSignal: options.run?.abortSignal,
-                prompt,
-                responseFormat: options.responseFormat,
+            retry: api.retry,
+            throttle: api.throttle,
+            call: async () => postJsonToApi({
+                url: api.assembleUrl(`/api/generate`),
+                headers: api.headers,
+                body: {
+                    stream: responseFormat.stream,
+                    model: this.settings.model,
+                    prompt: prompt.prompt,
+                    images: prompt.images,
+                    format: this.settings.format,
+                    options: {
+                        mirostat: this.settings.mirostat,
+                        mirostat_eta: this.settings.mirostatEta,
+                        mirostat_tau: this.settings.mirostatTau,
+                        num_ctx: this.settings.contextWindowSize,
+                        num_gpu: this.settings.numGpu,
+                        num_gqa: this.settings.numGqa,
+                        num_predict: this.settings.maxCompletionTokens,
+                        num_threads: this.settings.numThreads,
+                        repeat_last_n: this.settings.repeatLastN,
+                        repeat_penalty: this.settings.repeatPenalty,
+                        seed: this.settings.seed,
+                        stop: this.settings.stopSequences,
+                        temperature: this.settings.temperature,
+                        tfs_z: this.settings.tfsZ,
+                        top_k: this.settings.topK,
+                        top_p: this.settings.topP,
+                    },
+                    system: this.settings.system,
+                    template: this.settings.template,
+                    context: this.settings.context,
+                    raw: this.settings.raw,
+                },
+                failedResponseHandler: failedOllamaCallResponseHandler,
+                successfulResponseHandler: responseFormat.handler,
+                abortSignal,
             }),
         });
     }
@@ -60,17 +92,17 @@ export class OllamaTextGenerationModel extends AbstractModel {
             "contextWindowSize",
             "temperature",
             "mirostat",
-            "mirostat_eta",
-            "mirostat_tau",
-            "num_gqa",
-            "num_gpu",
-            "num_threads",
-            "repeat_last_n",
-            "repeat_penalty",
+            "mirostatEta",
+            "mirostatTau",
+            "numGqa",
+            "numGpu",
+            "numThreads",
+            "repeatLastN",
+            "repeatPenalty",
             "seed",
-            "tfs_z",
-            "top_k",
-            "top_p",
+            "tfsZ",
+            "topK",
+            "topP",
             "system",
             "template",
             "context",
@@ -107,6 +139,14 @@ export class OllamaTextGenerationModel extends AbstractModel {
             template: promptTemplate,
         });
     }
+    withTextPrompt() {
+        return this.withPromptTemplate({
+            format(prompt) {
+                return { prompt: prompt };
+            },
+            stopSequences: [],
+        });
+    }
     withPromptTemplate(promptTemplate) {
         return new PromptTemplateTextStreamingModel({
             model: this.withSettings({
@@ -127,7 +167,7 @@ const ollamaTextGenerationResponseSchema = z.object({
     model: z.string(),
     response: z.string(),
     total_duration: z.number(),
-    load_duration: z.number(),
+    load_duration: z.number().optional(),
     prompt_eval_count: z.number(),
     eval_count: z.number(),
     eval_duration: z.number(),
@@ -145,7 +185,7 @@ const ollamaTextStreamingResponseSchema = new ZodSchema(z.discriminatedUnion("do
         model: z.string(),
         created_at: z.string(),
         total_duration: z.number(),
-        load_duration: z.number(),
+        load_duration: z.number().optional(),
         sample_count: z.number().optional(),
         sample_duration: z.number().optional(),
         prompt_eval_count: z.number(),
@@ -155,43 +195,6 @@ const ollamaTextStreamingResponseSchema = new ZodSchema(z.discriminatedUnion("do
         context: z.array(z.number()).optional(),
     }),
 ]));
-async function callOllamaTextGenerationAPI({ api = new OllamaApiConfiguration(), abortSignal, responseFormat, prompt, model, format, contextWindowSize, maxCompletionTokens, mirostat, mirostat_eta, mirostat_tau, num_gpu, num_gqa, num_threads, repeat_last_n, repeat_penalty, seed, stopSequences, temperature, tfs_z, top_k, top_p, system, template, context, raw, }) {
-    return postJsonToApi({
-        url: api.assembleUrl(`/api/generate`),
-        headers: api.headers,
-        body: {
-            stream: responseFormat.stream,
-            model,
-            prompt,
-            format,
-            options: {
-                mirostat,
-                mirostat_eta,
-                mirostat_tau,
-                num_ctx: contextWindowSize,
-                num_gpu,
-                num_gqa,
-                num_predict: maxCompletionTokens,
-                num_threads,
-                repeat_last_n,
-                repeat_penalty,
-                seed,
-                stop: stopSequences,
-                temperature,
-                tfs_z,
-                top_k,
-                top_p,
-            },
-            system,
-            template,
-            context,
-            raw,
-        },
-        failedResponseHandler: failedOllamaCallResponseHandler,
-        successfulResponseHandler: responseFormat.handler,
-        abortSignal,
-    });
-}
 async function createOllamaFullDeltaIterableQueue(stream) {
     const queue = new AsyncQueue();
     let accumulatedText = "";

package/model-provider/ollama/OllamaTextGenerationModel.test.cjs

@@ -36,7 +36,7 @@ describe("generateText", () => {
         };
         const result = await (0, generateText_js_1.generateText)(new OllamaTextGenerationModel_js_1.OllamaTextGenerationModel({
             model: "test-model",
-        }), "test prompt");
+        }).withTextPrompt(), "test prompt");
         expect(result).toEqual("test response");
     });
     it("should throw retryable ApiCallError when Ollama is overloaded", async () => {
@@ -52,7 +52,7 @@ describe("generateText", () => {
                     retry: (0, retryNever_js_1.retryNever)(),
                 }),
                 model: "test-model",
-            }), "test prompt");
+            }).withTextPrompt(), "test prompt");
             (0, assert_1.fail)("Should have thrown ApiCallError");
         }
         catch (expectedError) {

package/model-provider/ollama/OllamaTextGenerationModel.test.js

@@ -34,7 +34,7 @@ describe("generateText", () => {
         };
         const result = await generateText(new OllamaTextGenerationModel({
             model: "test-model",
-        }), "test prompt");
+        }).withTextPrompt(), "test prompt");
         expect(result).toEqual("test response");
     });
     it("should throw retryable ApiCallError when Ollama is overloaded", async () => {
@@ -50,7 +50,7 @@ describe("generateText", () => {
                     retry: retryNever(),
                 }),
                 model: "test-model",
-            }), "test prompt");
+            }).withTextPrompt(), "test prompt");
             fail("Should have thrown ApiCallError");
         }
         catch (expectedError) {

package/model-provider/openai/chat/AbstractOpenAIChatModel.cjs

@@ -219,7 +219,7 @@ exports.OpenAIChatResponseFormat = {
      */
     textDeltaIterable: {
         stream: true,
-        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => delta[0]?.delta.content ?? ""),
+        handler: async ({ response }) => (0, OpenAIChatStreamIterable_js_1.createOpenAIChatDeltaIterableQueue)(response.body, (delta) => delta[0]?.delta?.content ?? ""),
     },
     structureDeltaIterable: {
         stream: true,

package/model-provider/openai/chat/AbstractOpenAIChatModel.d.ts

@@ -32,16 +32,65 @@ export interface AbstractOpenAIChatCallSettings {
             name: string;
         };
     };
+    /**
+     * An array of strings or a single string that the model will recognize as end-of-text indicators.
+     * The model stops generating more content when it encounters any of these strings.
+     * This is particularly useful in scripted or formatted text generation, where a specific end point is required.
+     * Example: stop: ['\n', 'END']
+     */
     stop?: string | string[];
+    /**
+     * Specifies the maximum number of tokens (words, punctuation, parts of words) that the model can generate in a single response.
+     * It helps to control the length of the output, this can help prevent wasted time and tokens when tweaker topP or temperature.
+     * Example: maxTokens: 1000
+     */
     maxTokens?: number;
+    /**
+     * `temperature`: Controls the randomness and creativity in the model's responses.
+     * A lower temperature (close to 0) results in more predictable, conservative text, while a higher temperature (close to 1) produces more varied and creative output.
+     * Adjust this to balance between consistency and creativity in the model's replies.
+     * Example: temperature: 0.5
+     */
     temperature?: number;
+    /**
+     *  This parameter sets a threshold for token selection based on probability.
+     * The model will only consider the most likely tokens that cumulatively exceed this threshold while generating a response.
+     * It's a way to control the randomness of the output, balancing between diverse responses and sticking to more likely words.
+     * This means a topP of .1 will be far less random than one at .9
+     * Example: topP: 0.2
+     */
     topP?: number;
+    /**
+     * Used to set the initial state for the random number generator in the model.
+     * Providing a specific seed value ensures consistent outputs for the same inputs across different runs - useful for testing and reproducibility.
+     * A `null` value (or not setting it) results in varied, non-repeatable outputs each time.
+     * Example: seed: 89 (or) seed: null
+     */
     seed?: number | null;
     responseFormat?: {
         type?: "text" | "json_object";
     };
+    /**
+     * Specifies the number of responses or completions the model should generate for a given prompt.
+     * This is useful when you need multiple different outputs or ideas for a single prompt.
+     * The model will generate 'n' distinct responses, each based on the same initial prompt.
+     * In a streaming model this will result in both responses streamed back in real time.
+     * Example: n: 3 // The model will produce 3 different responses.
+     */
     n?: number;
+    /**
+     * Discourages the model from repeating the same information or context already mentioned in the conversation or prompt.
+     * Increasing this value encourages the model to introduce new topics or ideas, rather than reiterating what has been said.
+     * This is useful for maintaining a diverse and engaging conversation or for brainstorming sessions where varied ideas are needed.
+     * Example: presencePenalty: 1.0 // Strongly discourages repeating the same content.
+     */
     presencePenalty?: number;
+    /**
+     * This parameter reduces the likelihood of the model repeatedly using the same words or phrases in its responses.
+     * A higher frequency penalty promotes a wider variety of language and expressions in the output.
+     * This is particularly useful in creative writing or content generation tasks where diversity in language is desirable.
+     * Example: frequencyPenalty: 0.5 // Moderately discourages repetitive language.
+     */
     frequencyPenalty?: number;
     logitBias?: Record<number, number>;
 }

package/model-provider/openai/chat/AbstractOpenAIChatModel.js

@@ -215,7 +215,7 @@ export const OpenAIChatResponseFormat = {
      */
     textDeltaIterable: {
         stream: true,
-        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => delta[0]?.delta.content ?? ""),
+        handler: async ({ response }) => createOpenAIChatDeltaIterableQueue(response.body, (delta) => delta[0]?.delta?.content ?? ""),
     },
     structureDeltaIterable: {
         stream: true,