@ai-sdk/openai-compatible 1.0.0-alpha.9 → 1.0.0-beta.10

package/dist/index.js

@@ -31,7 +31,7 @@ module.exports = __toCommonJS(src_exports);
 // src/openai-compatible-chat-language-model.ts
 var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+var import_v43 = require("zod/v4");
 
 // src/convert-to-openai-compatible-chat-messages.ts
 var import_provider = require("@ai-sdk/provider");
@@ -103,7 +103,7 @@ function convertToOpenAICompatibleChatMessages(prompt) {
                 type: "function",
                 function: {
                   name: part.toolName,
-                  arguments: JSON.stringify(part.args)
+                  arguments: JSON.stringify(part.input)
                 },
                 ...partMetadata
               });
@@ -121,11 +121,24 @@ function convertToOpenAICompatibleChatMessages(prompt) {
       }
       case "tool": {
         for (const toolResponse of content) {
+          const output = toolResponse.output;
+          let contentValue;
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value;
+              break;
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value);
+              break;
+          }
           const toolResponseMetadata = getOpenAIMetadata(toolResponse);
           messages.push({
             role: "tool",
             tool_call_id: toolResponse.toolCallId,
-            content: JSON.stringify(toolResponse.result),
+            content: contentValue,
             ...toolResponseMetadata
           });
         }
@@ -171,30 +184,30 @@ function mapOpenAICompatibleFinishReason(finishReason) {
 }
 
 // src/openai-compatible-chat-options.ts
-var import_zod = require("zod");
-var openaiCompatibleProviderOptions = import_zod.z.object({
+var import_v4 = require("zod/v4");
+var openaiCompatibleProviderOptions = import_v4.z.object({
   /**
    * A unique identifier representing your end-user, which can help the provider to
    * monitor and detect abuse.
    */
-  user: import_zod.z.string().optional(),
+  user: import_v4.z.string().optional(),
   /**
    * Reasoning effort for reasoning models. Defaults to `medium`.
    */
-  reasoningEffort: import_zod.z.enum(["low", "medium", "high"]).optional()
+  reasoningEffort: import_v4.z.string().optional()
 });
 
 // src/openai-compatible-error.ts
-var import_zod2 = require("zod");
-var openaiCompatibleErrorDataSchema = import_zod2.z.object({
-  error: import_zod2.z.object({
-    message: import_zod2.z.string(),
+var import_v42 = require("zod/v4");
+var openaiCompatibleErrorDataSchema = import_v42.z.object({
+  error: import_v42.z.object({
+    message: import_v42.z.string(),
     // The additional information below is handled loosely to support
     // OpenAI-compatible providers that have slightly different error
     // responses:
-    type: import_zod2.z.string().nullish(),
-    param: import_zod2.z.any().nullish(),
-    code: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).nullish()
+    type: import_v42.z.string().nullish(),
+    param: import_v42.z.any().nullish(),
+    code: import_v42.z.union([import_v42.z.string(), import_v42.z.number()]).nullish()
   })
 });
 var defaultOpenAICompatibleErrorStructure = {
@@ -223,7 +236,7 @@ function prepareTools({
         function: {
           name: tool.name,
           description: tool.description,
-          parameters: tool.parameters
+          parameters: tool.inputSchema
         }
       });
     }
@@ -399,10 +412,9 @@ var OpenAICompatibleChatLanguageModel = class {
       for (const toolCall of choice.message.tool_calls) {
         content.push({
           type: "tool-call",
-          toolCallType: "function",
           toolCallId: (_a = toolCall.id) != null ? _a : (0, import_provider_utils.generateId)(),
           toolName: toolCall.function.name,
-          args: toolCall.function.arguments
+          input: toolCall.function.arguments
         });
       }
     }
@@ -480,6 +492,8 @@ var OpenAICompatibleChatLanguageModel = class {
     };
     let isFirstChunk = true;
     const providerOptionsName = this.providerOptionsName;
+    let isActiveReasoning = false;
+    let isActiveText = false;
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -489,6 +503,9 @@ var OpenAICompatibleChatLanguageModel = class {
           // TODO we lost type safety on Chunk, most likely due to the error schema. MUST FIX
           transform(chunk, controller) {
             var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -543,27 +560,34 @@ var OpenAICompatibleChatLanguageModel = class {
             }
             const delta = choice.delta;
             if (delta.reasoning_content != null) {
+              if (!isActiveReasoning) {
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: "reasoning-0"
+                });
+                isActiveReasoning = true;
+              }
               controller.enqueue({
-                type: "reasoning",
-                text: delta.reasoning_content
+                type: "reasoning-delta",
+                id: "reasoning-0",
+                delta: delta.reasoning_content
               });
             }
             if (delta.content != null) {
+              if (!isActiveText) {
+                controller.enqueue({ type: "text-start", id: "txt-0" });
+                isActiveText = true;
+              }
               controller.enqueue({
-                type: "text",
-                text: delta.content
+                type: "text-delta",
+                id: "txt-0",
+                delta: delta.content
               });
             }
             if (delta.tool_calls != null) {
               for (const toolCallDelta of delta.tool_calls) {
                 const index = toolCallDelta.index;
                 if (toolCalls[index] == null) {
-                  if (toolCallDelta.type !== "function") {
-                    throw new import_provider3.InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'function' type.`
-                    });
-                  }
                   if (toolCallDelta.id == null) {
                     throw new import_provider3.InvalidResponseDataError({
                       data: toolCallDelta,
@@ -576,6 +600,11 @@ var OpenAICompatibleChatLanguageModel = class {
                       message: `Expected 'function.name' to be a string.`
                     });
                   }
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolCallDelta.id,
+                    toolName: toolCallDelta.function.name
+                  });
                   toolCalls[index] = {
                     id: toolCallDelta.id,
                     type: "function",
@@ -589,20 +618,21 @@ var OpenAICompatibleChatLanguageModel = class {
                   if (((_c = toolCall2.function) == null ? void 0 : _c.name) != null && ((_d = toolCall2.function) == null ? void 0 : _d.arguments) != null) {
                     if (toolCall2.function.arguments.length > 0) {
                       controller.enqueue({
-                        type: "tool-call-delta",
-                        toolCallType: "function",
-                        toolCallId: toolCall2.id,
-                        toolName: toolCall2.function.name,
-                        argsTextDelta: toolCall2.function.arguments
+                        type: "tool-input-start",
+                        id: toolCall2.id,
+                        toolName: toolCall2.function.name
                       });
                     }
                     if ((0, import_provider_utils.isParsableJson)(toolCall2.function.arguments)) {
+                      controller.enqueue({
+                        type: "tool-input-end",
+                        id: toolCall2.id
+                      });
                       controller.enqueue({
                         type: "tool-call",
-                        toolCallType: "function",
                         toolCallId: (_e = toolCall2.id) != null ? _e : (0, import_provider_utils.generateId)(),
                         toolName: toolCall2.function.name,
-                        args: toolCall2.function.arguments
+                        input: toolCall2.function.arguments
                       });
                       toolCall2.hasFinished = true;
                     }
@@ -617,19 +647,20 @@ var OpenAICompatibleChatLanguageModel = class {
                   toolCall.function.arguments += (_h = (_g = toolCallDelta.function) == null ? void 0 : _g.arguments) != null ? _h : "";
                 }
                 controller.enqueue({
-                  type: "tool-call-delta",
-                  toolCallType: "function",
-                  toolCallId: toolCall.id,
-                  toolName: toolCall.function.name,
-                  argsTextDelta: (_i = toolCallDelta.function.arguments) != null ? _i : ""
+                  type: "tool-input-delta",
+                  id: toolCall.id,
+                  delta: (_i = toolCallDelta.function.arguments) != null ? _i : ""
                 });
                 if (((_j = toolCall.function) == null ? void 0 : _j.name) != null && ((_k = toolCall.function) == null ? void 0 : _k.arguments) != null && (0, import_provider_utils.isParsableJson)(toolCall.function.arguments)) {
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.id
+                  });
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallType: "function",
                     toolCallId: (_l = toolCall.id) != null ? _l : (0, import_provider_utils.generateId)(),
                     toolName: toolCall.function.name,
-                    args: toolCall.function.arguments
+                    input: toolCall.function.arguments
                   });
                   toolCall.hasFinished = true;
                 }
@@ -637,7 +668,27 @@ var OpenAICompatibleChatLanguageModel = class {
             }
           },
           flush(controller) {
-            var _a2, _b, _c, _d, _e;
+            var _a2, _b, _c, _d, _e, _f;
+            if (isActiveReasoning) {
+              controller.enqueue({ type: "reasoning-end", id: "reasoning-0" });
+            }
+            if (isActiveText) {
+              controller.enqueue({ type: "text-end", id: "txt-0" });
+            }
+            for (const toolCall of toolCalls.filter(
+              (toolCall2) => !toolCall2.hasFinished
+            )) {
+              controller.enqueue({
+                type: "tool-input-end",
+                id: toolCall.id
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: (_a2 = toolCall.id) != null ? _a2 : (0, import_provider_utils.generateId)(),
+                toolName: toolCall.function.name,
+                input: toolCall.function.arguments
+              });
+            }
             const providerMetadata = {
               [providerOptionsName]: {},
               ...metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata()
@@ -652,11 +703,11 @@ var OpenAICompatibleChatLanguageModel = class {
               type: "finish",
               finishReason,
               usage: {
-                inputTokens: (_a2 = usage.promptTokens) != null ? _a2 : void 0,
-                outputTokens: (_b = usage.completionTokens) != null ? _b : void 0,
-                totalTokens: (_c = usage.totalTokens) != null ? _c : void 0,
-                reasoningTokens: (_d = usage.completionTokensDetails.reasoningTokens) != null ? _d : void 0,
-                cachedInputTokens: (_e = usage.promptTokensDetails.cachedTokens) != null ? _e : void 0
+                inputTokens: (_b = usage.promptTokens) != null ? _b : void 0,
+                outputTokens: (_c = usage.completionTokens) != null ? _c : void 0,
+                totalTokens: (_d = usage.totalTokens) != null ? _d : void 0,
+                reasoningTokens: (_e = usage.completionTokensDetails.reasoningTokens) != null ? _e : void 0,
+                cachedInputTokens: (_f = usage.promptTokensDetails.cachedTokens) != null ? _f : void 0
               },
               providerMetadata
             });
@@ -668,69 +719,67 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
 };
-var openaiCompatibleTokenUsageSchema = import_zod3.z.object({
-  prompt_tokens: import_zod3.z.number().nullish(),
-  completion_tokens: import_zod3.z.number().nullish(),
-  total_tokens: import_zod3.z.number().nullish(),
-  prompt_tokens_details: import_zod3.z.object({
-    cached_tokens: import_zod3.z.number().nullish()
+var openaiCompatibleTokenUsageSchema = import_v43.z.object({
+  prompt_tokens: import_v43.z.number().nullish(),
+  completion_tokens: import_v43.z.number().nullish(),
+  total_tokens: import_v43.z.number().nullish(),
+  prompt_tokens_details: import_v43.z.object({
+    cached_tokens: import_v43.z.number().nullish()
   }).nullish(),
-  completion_tokens_details: import_zod3.z.object({
-    reasoning_tokens: import_zod3.z.number().nullish(),
-    accepted_prediction_tokens: import_zod3.z.number().nullish(),
-    rejected_prediction_tokens: import_zod3.z.number().nullish()
+  completion_tokens_details: import_v43.z.object({
+    reasoning_tokens: import_v43.z.number().nullish(),
+    accepted_prediction_tokens: import_v43.z.number().nullish(),
+    rejected_prediction_tokens: import_v43.z.number().nullish()
   }).nullish()
 }).nullish();
-var OpenAICompatibleChatResponseSchema = import_zod3.z.object({
-  id: import_zod3.z.string().nullish(),
-  created: import_zod3.z.number().nullish(),
-  model: import_zod3.z.string().nullish(),
-  choices: import_zod3.z.array(
-    import_zod3.z.object({
-      message: import_zod3.z.object({
-        role: import_zod3.z.literal("assistant").nullish(),
-        content: import_zod3.z.string().nullish(),
-        reasoning_content: import_zod3.z.string().nullish(),
-        tool_calls: import_zod3.z.array(
-          import_zod3.z.object({
-            id: import_zod3.z.string().nullish(),
-            type: import_zod3.z.literal("function"),
-            function: import_zod3.z.object({
-              name: import_zod3.z.string(),
-              arguments: import_zod3.z.string()
+var OpenAICompatibleChatResponseSchema = import_v43.z.object({
+  id: import_v43.z.string().nullish(),
+  created: import_v43.z.number().nullish(),
+  model: import_v43.z.string().nullish(),
+  choices: import_v43.z.array(
+    import_v43.z.object({
+      message: import_v43.z.object({
+        role: import_v43.z.literal("assistant").nullish(),
+        content: import_v43.z.string().nullish(),
+        reasoning_content: import_v43.z.string().nullish(),
+        tool_calls: import_v43.z.array(
+          import_v43.z.object({
+            id: import_v43.z.string().nullish(),
+            function: import_v43.z.object({
+              name: import_v43.z.string(),
+              arguments: import_v43.z.string()
             })
           })
         ).nullish()
       }),
-      finish_reason: import_zod3.z.string().nullish()
+      finish_reason: import_v43.z.string().nullish()
     })
   ),
   usage: openaiCompatibleTokenUsageSchema
 });
-var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_zod3.z.union([
-  import_zod3.z.object({
-    id: import_zod3.z.string().nullish(),
-    created: import_zod3.z.number().nullish(),
-    model: import_zod3.z.string().nullish(),
-    choices: import_zod3.z.array(
-      import_zod3.z.object({
-        delta: import_zod3.z.object({
-          role: import_zod3.z.enum(["assistant"]).nullish(),
-          content: import_zod3.z.string().nullish(),
-          reasoning_content: import_zod3.z.string().nullish(),
-          tool_calls: import_zod3.z.array(
-            import_zod3.z.object({
-              index: import_zod3.z.number(),
-              id: import_zod3.z.string().nullish(),
-              type: import_zod3.z.literal("function").nullish(),
-              function: import_zod3.z.object({
-                name: import_zod3.z.string().nullish(),
-                arguments: import_zod3.z.string().nullish()
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v43.z.union([
+  import_v43.z.object({
+    id: import_v43.z.string().nullish(),
+    created: import_v43.z.number().nullish(),
+    model: import_v43.z.string().nullish(),
+    choices: import_v43.z.array(
+      import_v43.z.object({
+        delta: import_v43.z.object({
+          role: import_v43.z.enum(["assistant"]).nullish(),
+          content: import_v43.z.string().nullish(),
+          reasoning_content: import_v43.z.string().nullish(),
+          tool_calls: import_v43.z.array(
+            import_v43.z.object({
+              index: import_v43.z.number(),
+              id: import_v43.z.string().nullish(),
+              function: import_v43.z.object({
+                name: import_v43.z.string().nullish(),
+                arguments: import_v43.z.string().nullish()
               })
             })
           ).nullish()
         }).nullish(),
-        finish_reason: import_zod3.z.string().nullish()
+        finish_reason: import_v43.z.string().nullish()
       })
     ),
     usage: openaiCompatibleTokenUsageSchema
@@ -740,7 +789,7 @@ var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_zod3.z.union
 
 // src/openai-compatible-completion-language-model.ts
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod5 = require("zod");
+var import_v45 = require("zod/v4");
 
 // src/convert-to-openai-compatible-completion-prompt.ts
 var import_provider4 = require("@ai-sdk/provider");
@@ -818,28 +867,28 @@ ${user}:`]
 }
 
 // src/openai-compatible-completion-options.ts
-var import_zod4 = require("zod");
-var openaiCompatibleCompletionProviderOptions = import_zod4.z.object({
+var import_v44 = require("zod/v4");
+var openaiCompatibleCompletionProviderOptions = import_v44.z.object({
   /**
    * Echo back the prompt in addition to the completion.
    */
-  echo: import_zod4.z.boolean().optional(),
+  echo: import_v44.z.boolean().optional(),
   /**
    * Modify the likelihood of specified tokens appearing in the completion.
    *
    * Accepts a JSON object that maps tokens (specified by their token ID in
    * the GPT tokenizer) to an associated bias value from -100 to 100.
    */
-  logitBias: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.number()).optional(),
+  logitBias: import_v44.z.record(import_v44.z.string(), import_v44.z.number()).optional(),
   /**
    * The suffix that comes after a completion of inserted text.
    */
-  suffix: import_zod4.z.string().optional(),
+  suffix: import_v44.z.string().optional(),
   /**
    * A unique identifier representing your end-user, which can help providers to
    * monitor and detect abuse.
    */
-  user: import_zod4.z.string().optional()
+  user: import_v44.z.string().optional()
 });
 
 // src/openai-compatible-completion-language-model.ts
@@ -1011,6 +1060,9 @@ var OpenAICompatibleCompletionLanguageModel = class {
           },
           transform(chunk, controller) {
             var _a, _b, _c;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
             if (!chunk.success) {
               finishReason = "error";
               controller.enqueue({ type: "error", error: chunk.error });
@@ -1028,6 +1080,10 @@ var OpenAICompatibleCompletionLanguageModel = class {
                 type: "response-metadata",
                 ...getResponseMetadata(value)
               });
+              controller.enqueue({
+                type: "text-start",
+                id: "0"
+              });
             }
             if (value.usage != null) {
               usage.inputTokens = (_a = value.usage.prompt_tokens) != null ? _a : void 0;
@@ -1042,12 +1098,16 @@ var OpenAICompatibleCompletionLanguageModel = class {
             }
             if ((choice == null ? void 0 : choice.text) != null) {
               controller.enqueue({
-                type: "text",
-                text: choice.text
+                type: "text-delta",
+                id: "0",
+                delta: choice.text
               });
             }
           },
           flush(controller) {
+            if (!isFirstChunk) {
+              controller.enqueue({ type: "text-end", id: "0" });
+            }
             controller.enqueue({
               type: "finish",
               finishReason,
@@ -1061,33 +1121,33 @@ var OpenAICompatibleCompletionLanguageModel = class {
     };
   }
 };
-var usageSchema = import_zod5.z.object({
-  prompt_tokens: import_zod5.z.number(),
-  completion_tokens: import_zod5.z.number(),
-  total_tokens: import_zod5.z.number()
+var usageSchema = import_v45.z.object({
+  prompt_tokens: import_v45.z.number(),
+  completion_tokens: import_v45.z.number(),
+  total_tokens: import_v45.z.number()
 });
-var openaiCompatibleCompletionResponseSchema = import_zod5.z.object({
-  id: import_zod5.z.string().nullish(),
-  created: import_zod5.z.number().nullish(),
-  model: import_zod5.z.string().nullish(),
-  choices: import_zod5.z.array(
-    import_zod5.z.object({
-      text: import_zod5.z.string(),
-      finish_reason: import_zod5.z.string()
+var openaiCompatibleCompletionResponseSchema = import_v45.z.object({
+  id: import_v45.z.string().nullish(),
+  created: import_v45.z.number().nullish(),
+  model: import_v45.z.string().nullish(),
+  choices: import_v45.z.array(
+    import_v45.z.object({
+      text: import_v45.z.string(),
+      finish_reason: import_v45.z.string()
     })
   ),
   usage: usageSchema.nullish()
 });
-var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => import_zod5.z.union([
-  import_zod5.z.object({
-    id: import_zod5.z.string().nullish(),
-    created: import_zod5.z.number().nullish(),
-    model: import_zod5.z.string().nullish(),
-    choices: import_zod5.z.array(
-      import_zod5.z.object({
-        text: import_zod5.z.string(),
-        finish_reason: import_zod5.z.string().nullish(),
-        index: import_zod5.z.number()
+var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => import_v45.z.union([
+  import_v45.z.object({
+    id: import_v45.z.string().nullish(),
+    created: import_v45.z.number().nullish(),
+    model: import_v45.z.string().nullish(),
+    choices: import_v45.z.array(
+      import_v45.z.object({
+        text: import_v45.z.string(),
+        finish_reason: import_v45.z.string().nullish(),
+        index: import_v45.z.number()
       })
     ),
     usage: usageSchema.nullish()
@@ -1098,21 +1158,21 @@ var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => import_zod5.z
 // src/openai-compatible-embedding-model.ts
 var import_provider5 = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod7 = require("zod");
+var import_v47 = require("zod/v4");
 
 // src/openai-compatible-embedding-options.ts
-var import_zod6 = require("zod");
-var openaiCompatibleEmbeddingProviderOptions = import_zod6.z.object({
+var import_v46 = require("zod/v4");
+var openaiCompatibleEmbeddingProviderOptions = import_v46.z.object({
   /**
    * The number of dimensions the resulting output embeddings should have.
    * Only supported in text-embedding-3 and later models.
    */
-  dimensions: import_zod6.z.number().optional(),
+  dimensions: import_v46.z.number().optional(),
   /**
    * A unique identifier representing your end-user, which can help providers to
    * monitor and detect abuse.
    */
-  user: import_zod6.z.string().optional()
+  user: import_v46.z.string().optional()
 });
 
 // src/openai-compatible-embedding-model.ts
@@ -1196,14 +1256,14 @@ var OpenAICompatibleEmbeddingModel = class {
     };
   }
 };
-var openaiTextEmbeddingResponseSchema = import_zod7.z.object({
-  data: import_zod7.z.array(import_zod7.z.object({ embedding: import_zod7.z.array(import_zod7.z.number()) })),
-  usage: import_zod7.z.object({ prompt_tokens: import_zod7.z.number() }).nullish()
+var openaiTextEmbeddingResponseSchema = import_v47.z.object({
+  data: import_v47.z.array(import_v47.z.object({ embedding: import_v47.z.array(import_v47.z.number()) })),
+  usage: import_v47.z.object({ prompt_tokens: import_v47.z.number() }).nullish()
 });
 
 // src/openai-compatible-image-model.ts
 var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_zod8 = require("zod");
+var import_v48 = require("zod/v4");
 var OpenAICompatibleImageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -1271,8 +1331,8 @@ var OpenAICompatibleImageModel = class {
     };
   }
 };
-var openaiCompatibleImageResponseSchema = import_zod8.z.object({
-  data: import_zod8.z.array(import_zod8.z.object({ b64_json: import_zod8.z.string() }))
+var openaiCompatibleImageResponseSchema = import_v48.z.object({
+  data: import_v48.z.array(import_v48.z.object({ b64_json: import_v48.z.string() }))
 });
 
 // src/openai-compatible-provider.ts
@@ -1297,14 +1357,14 @@ function createOpenAICompatible(options) {
     fetch: options.fetch
   });
   const createLanguageModel = (modelId) => createChatModel(modelId);
-  const createChatModel = (modelId) => new OpenAICompatibleChatLanguageModel(
-    modelId,
-    getCommonModelConfig("chat")
-  );
-  const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(
-    modelId,
-    getCommonModelConfig("completion")
-  );
+  const createChatModel = (modelId) => new OpenAICompatibleChatLanguageModel(modelId, {
+    ...getCommonModelConfig("chat"),
+    includeUsage: options.includeUsage
+  });
+  const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(modelId, {
+    ...getCommonModelConfig("completion"),
+    includeUsage: options.includeUsage
+  });
   const createEmbeddingModel = (modelId) => new OpenAICompatibleEmbeddingModel(modelId, {
     ...getCommonModelConfig("embedding")
   });