@ai-sdk/openai-compatible 1.0.0-canary.8 → 1.0.0

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,26 +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_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 = {
@@ -219,7 +236,7 @@ function prepareTools({
         function: {
           name: tool.name,
           description: tool.description,
-          parameters: tool.parameters
+          parameters: tool.inputSchema
         }
       });
     }
@@ -266,16 +283,17 @@ var OpenAICompatibleChatLanguageModel = class {
     this.failedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)(errorStructure);
     this.supportsStructuredOutputs = (_b = config.supportsStructuredOutputs) != null ? _b : false;
   }
-  get defaultObjectGenerationMode() {
-    return this.config.defaultObjectGenerationMode;
-  }
   get provider() {
     return this.config.provider;
   }
   get providerOptionsName() {
     return this.config.provider.split(".")[0].trim();
   }
-  getArgs({
+  get supportedUrls() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.config).supportedUrls) == null ? void 0 : _b.call(_a)) != null ? _c : {};
+  }
+  async getArgs({
     prompt,
     maxOutputTokens,
     temperature,
@@ -293,12 +311,12 @@ var OpenAICompatibleChatLanguageModel = class {
     var _a, _b, _c;
     const warnings = [];
     const compatibleOptions = Object.assign(
-      (_a = (0, import_provider_utils.parseProviderOptions)({
+      (_a = await (0, import_provider_utils.parseProviderOptions)({
         provider: "openai-compatible",
         providerOptions,
         schema: openaiCompatibleProviderOptions
       })) != null ? _a : {},
-      (_b = (0, import_provider_utils.parseProviderOptions)({
+      (_b = await (0, import_provider_utils.parseProviderOptions)({
         provider: this.providerOptionsName,
         providerOptions,
         schema: openaiCompatibleProviderOptions
@@ -345,6 +363,7 @@ var OpenAICompatibleChatLanguageModel = class {
         stop: stopSequences,
         seed,
         ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
+        reasoning_effort: compatibleOptions.reasoningEffort,
         // messages:
         messages: convertToOpenAICompatibleChatMessages(prompt),
         // tools:
@@ -355,8 +374,8 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-    const { args, warnings } = this.getArgs({ ...options });
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    const { args, warnings } = await this.getArgs({ ...options });
     const body = JSON.stringify(args);
     const {
       responseHeaders,
@@ -386,7 +405,6 @@ var OpenAICompatibleChatLanguageModel = class {
     if (reasoning != null && reasoning.length > 0) {
       content.push({
         type: "reasoning",
-        reasoningType: "text",
         text: reasoning
       });
     }
@@ -394,39 +412,34 @@ 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
         });
       }
     }
     const providerMetadata = {
       [this.providerOptionsName]: {},
-      ...(_c = (_b = this.config.metadataExtractor) == null ? void 0 : _b.extractMetadata) == null ? void 0 : _c.call(_b, {
+      ...await ((_c = (_b = this.config.metadataExtractor) == null ? void 0 : _b.extractMetadata) == null ? void 0 : _c.call(_b, {
         parsedBody: rawResponse
-      })
+      }))
     };
     const completionTokenDetails = (_d = responseBody.usage) == null ? void 0 : _d.completion_tokens_details;
-    const promptTokenDetails = (_e = responseBody.usage) == null ? void 0 : _e.prompt_tokens_details;
-    if ((completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens) != null) {
-      providerMetadata[this.providerOptionsName].reasoningTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.reasoning_tokens;
-    }
     if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
       providerMetadata[this.providerOptionsName].acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
     }
     if ((completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens) != null) {
       providerMetadata[this.providerOptionsName].rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
     }
-    if ((promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens) != null) {
-      providerMetadata[this.providerOptionsName].cachedPromptTokens = promptTokenDetails == null ? void 0 : promptTokenDetails.cached_tokens;
-    }
     return {
       content,
       finishReason: mapOpenAICompatibleFinishReason(choice.finish_reason),
       usage: {
-        inputTokens: (_g = (_f = responseBody.usage) == null ? void 0 : _f.prompt_tokens) != null ? _g : void 0,
-        outputTokens: (_i = (_h = responseBody.usage) == null ? void 0 : _h.completion_tokens) != null ? _i : void 0
+        inputTokens: (_f = (_e = responseBody.usage) == null ? void 0 : _e.prompt_tokens) != null ? _f : void 0,
+        outputTokens: (_h = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens) != null ? _h : void 0,
+        totalTokens: (_j = (_i = responseBody.usage) == null ? void 0 : _i.total_tokens) != null ? _j : void 0,
+        reasoningTokens: (_m = (_l = (_k = responseBody.usage) == null ? void 0 : _k.completion_tokens_details) == null ? void 0 : _l.reasoning_tokens) != null ? _m : void 0,
+        cachedInputTokens: (_p = (_o = (_n = responseBody.usage) == null ? void 0 : _n.prompt_tokens_details) == null ? void 0 : _o.cached_tokens) != null ? _p : void 0
       },
       providerMetadata,
       request: { body },
@@ -440,8 +453,13 @@ var OpenAICompatibleChatLanguageModel = class {
   }
   async doStream(options) {
     var _a;
-    const { args, warnings } = this.getArgs({ ...options });
-    const body = JSON.stringify({ ...args, stream: true });
+    const { args, warnings } = await this.getArgs({ ...options });
+    const body = {
+      ...args,
+      stream: true,
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.includeUsage ? { include_usage: true } : void 0
+    };
     const metadataExtractor = (_a = this.config.metadataExtractor) == null ? void 0 : _a.createStreamExtractor();
     const { responseHeaders, value: response } = await (0, import_provider_utils.postJsonToApi)({
       url: this.config.url({
@@ -449,10 +467,7 @@ var OpenAICompatibleChatLanguageModel = class {
         modelId: this.modelId
       }),
       headers: (0, import_provider_utils.combineHeaders)(this.config.headers(), options.headers),
-      body: {
-        ...args,
-        stream: true
-      },
+      body,
       failedResponseHandler: this.failedResponseHandler,
       successfulResponseHandler: (0, import_provider_utils.createEventSourceResponseHandler)(
         this.chunkSchema
@@ -462,7 +477,7 @@ var OpenAICompatibleChatLanguageModel = class {
     });
     const toolCalls = [];
     let finishReason = "unknown";
-    let usage = {
+    const usage = {
       completionTokens: void 0,
       completionTokensDetails: {
         reasoningTokens: void 0,
@@ -472,10 +487,13 @@ var OpenAICompatibleChatLanguageModel = class {
       promptTokens: void 0,
       promptTokensDetails: {
         cachedTokens: void 0
-      }
+      },
+      totalTokens: void 0
     };
     let isFirstChunk = true;
-    let providerOptionsName = this.providerOptionsName;
+    const providerOptionsName = this.providerOptionsName;
+    let isActiveReasoning = false;
+    let isActiveText = false;
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -485,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 });
@@ -508,11 +529,13 @@ var OpenAICompatibleChatLanguageModel = class {
               const {
                 prompt_tokens,
                 completion_tokens,
+                total_tokens,
                 prompt_tokens_details,
                 completion_tokens_details
               } = value.usage;
               usage.promptTokens = prompt_tokens != null ? prompt_tokens : void 0;
               usage.completionTokens = completion_tokens != null ? completion_tokens : void 0;
+              usage.totalTokens = total_tokens != null ? total_tokens : void 0;
               if ((completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens) != null) {
                 usage.completionTokensDetails.reasoningTokens = completion_tokens_details == null ? void 0 : completion_tokens_details.reasoning_tokens;
               }
@@ -537,28 +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",
-                reasoningType: "text",
-                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,
@@ -571,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",
@@ -584,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;
                     }
@@ -612,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;
                 }
@@ -632,29 +668,46 @@ var OpenAICompatibleChatLanguageModel = class {
             }
           },
           flush(controller) {
-            var _a2, _b;
+            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()
             };
-            if (usage.completionTokensDetails.reasoningTokens != null) {
-              providerMetadata[providerOptionsName].reasoningTokens = usage.completionTokensDetails.reasoningTokens;
-            }
             if (usage.completionTokensDetails.acceptedPredictionTokens != null) {
               providerMetadata[providerOptionsName].acceptedPredictionTokens = usage.completionTokensDetails.acceptedPredictionTokens;
             }
             if (usage.completionTokensDetails.rejectedPredictionTokens != null) {
               providerMetadata[providerOptionsName].rejectedPredictionTokens = usage.completionTokensDetails.rejectedPredictionTokens;
             }
-            if (usage.promptTokensDetails.cachedTokens != null) {
-              providerMetadata[providerOptionsName].cachedPromptTokens = usage.promptTokensDetails.cachedTokens;
-            }
             controller.enqueue({
               type: "finish",
               finishReason,
               usage: {
-                inputTokens: (_a2 = usage.promptTokens) != null ? _a2 : void 0,
-                outputTokens: (_b = usage.completionTokens) != null ? _b : 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
             });
@@ -666,68 +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(),
-  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
@@ -737,19 +789,15 @@ 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");
 function convertToOpenAICompatibleCompletionPrompt({
   prompt,
-  inputFormat,
   user = "user",
   assistant = "assistant"
 }) {
-  if (inputFormat === "prompt" && prompt.length === 1 && prompt[0].role === "user" && prompt[0].content.length === 1 && prompt[0].content[0].type === "text") {
-    return { prompt: prompt[0].content[0].text };
-  }
   let text = "";
   if (prompt[0].role === "system") {
     text += `${prompt[0].content}
@@ -819,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.number(), 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
@@ -848,7 +896,6 @@ var OpenAICompatibleCompletionLanguageModel = class {
   // type inferred via constructor
   constructor(modelId, config) {
     this.specificationVersion = "v2";
-    this.defaultObjectGenerationMode = void 0;
     var _a;
     this.modelId = modelId;
     this.config = config;
@@ -864,8 +911,11 @@ var OpenAICompatibleCompletionLanguageModel = class {
   get providerOptionsName() {
     return this.config.provider.split(".")[0].trim();
   }
-  getArgs({
-    inputFormat,
+  get supportedUrls() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.config).supportedUrls) == null ? void 0 : _b.call(_a)) != null ? _c : {};
+  }
+  async getArgs({
     prompt,
     maxOutputTokens,
     temperature,
@@ -882,7 +932,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
   }) {
     var _a;
     const warnings = [];
-    const completionOptions = (_a = (0, import_provider_utils2.parseProviderOptions)({
+    const completionOptions = (_a = await (0, import_provider_utils2.parseProviderOptions)({
       provider: this.providerOptionsName,
       providerOptions,
       schema: openaiCompatibleCompletionProviderOptions
@@ -903,7 +953,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
         details: "JSON response format is not supported."
       });
     }
-    const { prompt: completionPrompt, stopSequences } = convertToOpenAICompatibleCompletionPrompt({ prompt, inputFormat });
+    const { prompt: completionPrompt, stopSequences } = convertToOpenAICompatibleCompletionPrompt({ prompt });
     const stop = [...stopSequences != null ? stopSequences : [], ...userStopSequences != null ? userStopSequences : []];
     return {
       args: {
@@ -931,8 +981,8 @@ var OpenAICompatibleCompletionLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d;
-    const { args, warnings } = this.getArgs(options);
+    var _a, _b, _c, _d, _e, _f;
+    const { args, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
       value: response,
@@ -960,7 +1010,8 @@ var OpenAICompatibleCompletionLanguageModel = class {
       content,
       usage: {
         inputTokens: (_b = (_a = response.usage) == null ? void 0 : _a.prompt_tokens) != null ? _b : void 0,
-        outputTokens: (_d = (_c = response.usage) == null ? void 0 : _c.completion_tokens) != null ? _d : void 0
+        outputTokens: (_d = (_c = response.usage) == null ? void 0 : _c.completion_tokens) != null ? _d : void 0,
+        totalTokens: (_f = (_e = response.usage) == null ? void 0 : _e.total_tokens) != null ? _f : void 0
       },
       finishReason: mapOpenAICompatibleFinishReason(choice.finish_reason),
       request: { body: args },
@@ -973,10 +1024,12 @@ var OpenAICompatibleCompletionLanguageModel = class {
     };
   }
   async doStream(options) {
-    const { args, warnings } = this.getArgs(options);
+    const { args, warnings } = await this.getArgs(options);
     const body = {
       ...args,
-      stream: true
+      stream: true,
+      // only include stream_options when in strict compatibility mode:
+      stream_options: this.config.includeUsage ? { include_usage: true } : void 0
     };
     const { responseHeaders, value: response } = await (0, import_provider_utils2.postJsonToApi)({
       url: this.config.url({
@@ -995,7 +1048,8 @@ var OpenAICompatibleCompletionLanguageModel = class {
     let finishReason = "unknown";
     const usage = {
       inputTokens: void 0,
-      outputTokens: void 0
+      outputTokens: void 0,
+      totalTokens: void 0
     };
     let isFirstChunk = true;
     return {
@@ -1005,7 +1059,10 @@ var OpenAICompatibleCompletionLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b;
+            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 });
@@ -1023,10 +1080,15 @@ 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;
               usage.outputTokens = (_b = value.usage.completion_tokens) != null ? _b : void 0;
+              usage.totalTokens = (_c = value.usage.total_tokens) != null ? _c : void 0;
             }
             const choice = value.choices[0];
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
@@ -1036,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,
@@ -1055,37 +1121,36 @@ var OpenAICompatibleCompletionLanguageModel = class {
     };
   }
 };
-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 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_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: import_zod5.z.object({
-    prompt_tokens: import_zod5.z.number(),
-    completion_tokens: import_zod5.z.number()
-  }).nullish()
+  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: import_zod5.z.object({
-      prompt_tokens: import_zod5.z.number(),
-      completion_tokens: import_zod5.z.number()
-    }).nullish()
+    usage: usageSchema.nullish()
   }),
   errorSchema
 ]);
@@ -1093,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
@@ -1139,12 +1204,12 @@ var OpenAICompatibleEmbeddingModel = class {
   }) {
     var _a, _b, _c;
     const compatibleOptions = Object.assign(
-      (_a = (0, import_provider_utils3.parseProviderOptions)({
+      (_a = await (0, import_provider_utils3.parseProviderOptions)({
         provider: "openai-compatible",
         providerOptions,
         schema: openaiCompatibleEmbeddingProviderOptions
       })) != null ? _a : {},
-      (_b = (0, import_provider_utils3.parseProviderOptions)({
+      (_b = await (0, import_provider_utils3.parseProviderOptions)({
         provider: this.providerOptionsName,
         providerOptions,
         schema: openaiCompatibleEmbeddingProviderOptions
@@ -1191,24 +1256,20 @@ 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, settings, config) {
+  constructor(modelId, config) {
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
-    this.specificationVersion = "v1";
-  }
-  get maxImagesPerCall() {
-    var _a;
-    return (_a = this.settings.maxImagesPerCall) != null ? _a : 10;
+    this.specificationVersion = "v2";
+    this.maxImagesPerCall = 10;
   }
   get provider() {
     return this.config.provider;
@@ -1248,8 +1309,7 @@ var OpenAICompatibleImageModel = class {
         n,
         size,
         ...(_d = providerOptions.openai) != null ? _d : {},
-        response_format: "b64_json",
-        ...this.settings.user ? { user: this.settings.user } : {}
+        response_format: "b64_json"
       },
       failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)(
         (_e = this.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure
@@ -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
@@ -1299,20 +1359,16 @@ function createOpenAICompatible(options) {
   const createLanguageModel = (modelId) => createChatModel(modelId);
   const createChatModel = (modelId) => new OpenAICompatibleChatLanguageModel(modelId, {
     ...getCommonModelConfig("chat"),
-    defaultObjectGenerationMode: "tool"
+    includeUsage: options.includeUsage
+  });
+  const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(modelId, {
+    ...getCommonModelConfig("completion"),
+    includeUsage: options.includeUsage
   });
-  const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(
-    modelId,
-    getCommonModelConfig("completion")
-  );
   const createEmbeddingModel = (modelId) => new OpenAICompatibleEmbeddingModel(modelId, {
     ...getCommonModelConfig("embedding")
   });
-  const createImageModel = (modelId, settings = {}) => new OpenAICompatibleImageModel(
-    modelId,
-    settings,
-    getCommonModelConfig("image")
-  );
+  const createImageModel = (modelId) => new OpenAICompatibleImageModel(modelId, getCommonModelConfig("image"));
   const provider = (modelId) => createLanguageModel(modelId);
   provider.languageModel = createLanguageModel;
   provider.chatModel = createChatModel;