@ai-sdk/openai-compatible 3.0.0-beta.4 → 3.0.0-beta.57

package/dist/index.js

@@ -1,50 +1,57 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  OpenAICompatibleChatLanguageModel: () => OpenAICompatibleChatLanguageModel,
-  OpenAICompatibleCompletionLanguageModel: () => OpenAICompatibleCompletionLanguageModel,
-  OpenAICompatibleEmbeddingModel: () => OpenAICompatibleEmbeddingModel,
-  OpenAICompatibleImageModel: () => OpenAICompatibleImageModel,
-  VERSION: () => VERSION,
-  createOpenAICompatible: () => createOpenAICompatible
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/chat/openai-compatible-chat-language-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  isCustomReasoning,
+  parseProviderOptions,
+  postJsonToApi,
+  serializeModelOptions,
+  StreamingToolCallTracker,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
+
+// src/utils/to-camel-case.ts
+function toCamelCase(str) {
+  return str.replace(/[_-]([a-z])/g, (g) => g[1].toUpperCase());
+}
+function resolveProviderOptionsKey(rawName, providerOptions) {
+  const camelName = toCamelCase(rawName);
+  if (camelName !== rawName && (providerOptions == null ? void 0 : providerOptions[camelName]) != null) {
+    return camelName;
+  }
+  return rawName;
+}
+function warnIfDeprecatedProviderOptionsKey({
+  rawName,
+  providerOptions,
+  warnings
+}) {
+  const camelName = toCamelCase(rawName);
+  if (camelName !== rawName && (providerOptions == null ? void 0 : providerOptions[rawName]) != null) {
+    warnings.push({
+      type: "deprecated",
+      setting: `providerOptions key '${rawName}'`,
+      message: `Use '${camelName}' instead.`
+    });
+  }
+}
 
 // src/openai-compatible-error.ts
-var import_v4 = require("zod/v4");
-var openaiCompatibleErrorDataSchema = import_v4.z.object({
-  error: import_v4.z.object({
-    message: import_v4.z.string(),
+import { z } from "zod/v4";
+var openaiCompatibleErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
     // The additional information below is handled loosely to support
     // OpenAI-compatible providers that have slightly different error
     // responses:
-    type: import_v4.z.string().nullish(),
-    param: import_v4.z.any().nullish(),
-    code: import_v4.z.union([import_v4.z.string(), import_v4.z.number()]).nullish()
+    type: z.string().nullish(),
+    param: z.any().nullish(),
+    code: z.union([z.string(), z.number()]).nullish()
   })
 });
 var defaultOpenAICompatibleErrorStructure = {
@@ -92,8 +99,15 @@ function convertOpenAICompatibleChatUsage(usage) {
 }
 
 // src/chat/convert-to-openai-compatible-chat-messages.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import {
+  convertBase64ToUint8Array,
+  convertToBase64,
+  getTopLevelMediaType,
+  resolveFullMediaType
+} from "@ai-sdk/provider-utils";
 function getOpenAIMetadata(message) {
   var _a, _b;
   return (_b = (_a = message == null ? void 0 : message.providerOptions) == null ? void 0 : _a.openaiCompatible) != null ? _b : {};
@@ -138,65 +152,87 @@ function convertToOpenAICompatibleChatMessages(prompt) {
                 return { type: "text", text: part.text, ...partMetadata };
               }
               case "file": {
-                if (part.mediaType.startsWith("image/")) {
-                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
-                  return {
-                    type: "image_url",
-                    image_url: {
-                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${(0, import_provider_utils.convertToBase64)(part.data)}`
-                    },
-                    ...partMetadata
-                  };
-                }
-                if (part.mediaType.startsWith("audio/")) {
-                  if (part.data instanceof URL) {
-                    throw new import_provider.UnsupportedFunctionalityError({
-                      functionality: "audio file parts with URLs"
+                switch (part.data.type) {
+                  case "reference": {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "file parts with provider references"
                     });
                   }
-                  const format = getAudioFormat(part.mediaType);
-                  if (format === null) {
-                    throw new import_provider.UnsupportedFunctionalityError({
-                      functionality: `audio media type ${part.mediaType}`
+                  case "text": {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "text file parts"
                     });
                   }
-                  return {
-                    type: "input_audio",
-                    input_audio: {
-                      data: (0, import_provider_utils.convertToBase64)(part.data),
-                      format
-                    },
-                    ...partMetadata
-                  };
-                }
-                if (part.mediaType === "application/pdf") {
-                  if (part.data instanceof URL) {
-                    throw new import_provider.UnsupportedFunctionalityError({
-                      functionality: "PDF file parts with URLs"
+                  case "url":
+                  case "data": {
+                    const topLevel = getTopLevelMediaType(part.mediaType);
+                    if (topLevel === "image") {
+                      return {
+                        type: "image_url",
+                        image_url: {
+                          url: part.data.type === "url" ? part.data.url.toString() : `data:${resolveFullMediaType({ part })};base64,${convertToBase64(part.data.data)}`
+                        },
+                        ...partMetadata
+                      };
+                    }
+                    if (topLevel === "audio") {
+                      if (part.data.type === "url") {
+                        throw new UnsupportedFunctionalityError({
+                          functionality: "audio file parts with URLs"
+                        });
+                      }
+                      const fullMediaType = resolveFullMediaType({ part });
+                      const format = getAudioFormat(fullMediaType);
+                      if (format === null) {
+                        throw new UnsupportedFunctionalityError({
+                          functionality: `audio media type ${fullMediaType}`
+                        });
+                      }
+                      return {
+                        type: "input_audio",
+                        input_audio: {
+                          data: convertToBase64(part.data.data),
+                          format
+                        },
+                        ...partMetadata
+                      };
+                    }
+                    if (topLevel === "application") {
+                      if (part.data.type === "url") {
+                        throw new UnsupportedFunctionalityError({
+                          functionality: "PDF file parts with URLs"
+                        });
+                      }
+                      const fullMediaType = resolveFullMediaType({ part });
+                      if (fullMediaType !== "application/pdf") {
+                        throw new UnsupportedFunctionalityError({
+                          functionality: `file part media type ${fullMediaType}`
+                        });
+                      }
+                      return {
+                        type: "file",
+                        file: {
+                          filename: (_a2 = part.filename) != null ? _a2 : "document.pdf",
+                          file_data: `data:application/pdf;base64,${convertToBase64(part.data.data)}`
+                        },
+                        ...partMetadata
+                      };
+                    }
+                    if (topLevel === "text") {
+                      const textContent = part.data.type === "url" ? part.data.url.toString() : typeof part.data.data === "string" ? new TextDecoder().decode(
+                        convertBase64ToUint8Array(part.data.data)
+                      ) : new TextDecoder().decode(part.data.data);
+                      return {
+                        type: "text",
+                        text: textContent,
+                        ...partMetadata
+                      };
+                    }
+                    throw new UnsupportedFunctionalityError({
+                      functionality: `file part media type ${part.mediaType}`
                     });
                   }
-                  return {
-                    type: "file",
-                    file: {
-                      filename: (_a2 = part.filename) != null ? _a2 : "document.pdf",
-                      file_data: `data:application/pdf;base64,${(0, import_provider_utils.convertToBase64)(part.data)}`
-                    },
-                    ...partMetadata
-                  };
-                }
-                if (part.mediaType.startsWith("text/")) {
-                  const textContent = part.data instanceof URL ? part.data.toString() : typeof part.data === "string" ? new TextDecoder().decode(
-                    (0, import_provider_utils.convertBase64ToUint8Array)(part.data)
-                  ) : new TextDecoder().decode(part.data);
-                  return {
-                    type: "text",
-                    text: textContent,
-                    ...partMetadata
-                  };
                 }
-                throw new import_provider.UnsupportedFunctionalityError({
-                  functionality: `file part media type ${part.mediaType}`
-                });
               }
             }
           }),
@@ -244,7 +280,7 @@ function convertToOpenAICompatibleChatMessages(prompt) {
         }
         messages.push({
           role: "assistant",
-          content: text,
+          content: toolCalls.length > 0 ? text || null : text,
           ...reasoning.length > 0 ? { reasoning_content: reasoning } : {},
           tool_calls: toolCalls.length > 0 ? toolCalls : void 0,
           ...metadata
@@ -264,7 +300,7 @@ function convertToOpenAICompatibleChatMessages(prompt) {
               contentValue = output.value;
               break;
             case "execution-denied":
-              contentValue = (_c = output.reason) != null ? _c : "Tool execution denied.";
+              contentValue = (_c = output.reason) != null ? _c : "Tool call execution denied.";
               break;
             case "content":
             case "json":
@@ -321,22 +357,22 @@ function mapOpenAICompatibleFinishReason(finishReason) {
   }
 }
 
-// src/chat/openai-compatible-chat-options.ts
-var import_v42 = require("zod/v4");
-var openaiCompatibleLanguageModelChatOptions = import_v42.z.object({
+// src/chat/openai-compatible-chat-language-model-options.ts
+import { z as z2 } from "zod/v4";
+var openaiCompatibleLanguageModelChatOptions = z2.object({
   /**
    * A unique identifier representing your end-user, which can help the provider to
    * monitor and detect abuse.
    */
-  user: import_v42.z.string().optional(),
+  user: z2.string().optional(),
   /**
    * Reasoning effort for reasoning models. Defaults to `medium`.
    */
-  reasoningEffort: import_v42.z.string().optional(),
+  reasoningEffort: z2.string().optional(),
   /**
    * Controls the verbosity of the generated text. Defaults to `medium`.
    */
-  textVerbosity: import_v42.z.string().optional(),
+  textVerbosity: z2.string().optional(),
   /**
    * Whether to use strict JSON schema validation.
    * When true, the model uses constrained decoding to guarantee schema compliance.
@@ -344,11 +380,13 @@ var openaiCompatibleLanguageModelChatOptions = import_v42.z.object({
    *
    * @default true
    */
-  strictJsonSchema: import_v42.z.boolean().optional()
+  strictJsonSchema: z2.boolean().optional()
 });
 
 // src/chat/openai-compatible-prepare-tools.ts
-var import_provider2 = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
 function prepareTools({
   tools,
   toolChoice
@@ -397,7 +435,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -405,8 +443,7 @@ function prepareTools({
 }
 
 // src/chat/openai-compatible-chat-language-model.ts
-var OpenAICompatibleChatLanguageModel = class {
-  // type inferred via constructor
+var OpenAICompatibleChatLanguageModel = class _OpenAICompatibleChatLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     var _a, _b;
@@ -416,9 +453,22 @@ var OpenAICompatibleChatLanguageModel = class {
     this.chunkSchema = createOpenAICompatibleChatChunkSchema(
       errorStructure.errorSchema
     );
-    this.failedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)(errorStructure);
+    this.failedResponseHandler = createJsonErrorResponseHandler(errorStructure);
     this.supportsStructuredOutputs = (_b = config.supportsStructuredOutputs) != null ? _b : false;
   }
+  // type inferred via constructor
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _OpenAICompatibleChatLanguageModel(
+      options.modelId,
+      options.config
+    );
+  }
   get provider() {
     return this.config.provider;
   }
@@ -433,6 +483,10 @@ var OpenAICompatibleChatLanguageModel = class {
     var _a, _b, _c;
     return (_c = (_b = (_a = this.config).transformRequestBody) == null ? void 0 : _b.call(_a, args)) != null ? _c : args;
   }
+  convertUsage(usage) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.config).convertUsage) == null ? void 0 : _b.call(_a, usage)) != null ? _c : convertOpenAICompatibleChatUsage(usage);
+  }
   async getArgs({
     prompt,
     maxOutputTokens,
@@ -441,6 +495,7 @@ var OpenAICompatibleChatLanguageModel = class {
     topK,
     frequencyPenalty,
     presencePenalty,
+    reasoning,
     providerOptions,
     stopSequences,
     responseFormat,
@@ -448,33 +503,44 @@ var OpenAICompatibleChatLanguageModel = class {
     toolChoice,
     tools
   }) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
     const warnings = [];
-    const deprecatedOptions = await (0, import_provider_utils2.parseProviderOptions)({
+    const deprecatedOptions = await parseProviderOptions({
       provider: "openai-compatible",
       providerOptions,
       schema: openaiCompatibleLanguageModelChatOptions
     });
     if (deprecatedOptions != null) {
       warnings.push({
-        type: "other",
-        message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
+        type: "deprecated",
+        setting: "providerOptions key 'openai-compatible'",
+        message: "Use 'openaiCompatible' instead."
       });
     }
+    warnIfDeprecatedProviderOptionsKey({
+      rawName: this.providerOptionsName,
+      providerOptions,
+      warnings
+    });
     const compatibleOptions = Object.assign(
       deprecatedOptions != null ? deprecatedOptions : {},
-      (_a = await (0, import_provider_utils2.parseProviderOptions)({
+      (_a = await parseProviderOptions({
         provider: "openaiCompatible",
         providerOptions,
         schema: openaiCompatibleLanguageModelChatOptions
       })) != null ? _a : {},
-      (_b = await (0, import_provider_utils2.parseProviderOptions)({
+      (_b = await parseProviderOptions({
         provider: this.providerOptionsName,
         providerOptions,
         schema: openaiCompatibleLanguageModelChatOptions
-      })) != null ? _b : {}
+      })) != null ? _b : {},
+      (_c = await parseProviderOptions({
+        provider: toCamelCase(this.providerOptionsName),
+        providerOptions,
+        schema: openaiCompatibleLanguageModelChatOptions
+      })) != null ? _c : {}
     );
-    const strictJsonSchema = (_c = compatibleOptions == null ? void 0 : compatibleOptions.strictJsonSchema) != null ? _c : true;
+    const strictJsonSchema = (_d = compatibleOptions == null ? void 0 : compatibleOptions.strictJsonSchema) != null ? _d : true;
     if (topK != null) {
       warnings.push({ type: "unsupported", feature: "topK" });
     }
@@ -493,7 +559,12 @@ var OpenAICompatibleChatLanguageModel = class {
       tools,
       toolChoice
     });
+    const metadataKey = resolveProviderOptionsKey(
+      this.providerOptionsName,
+      providerOptions
+    );
     return {
+      metadataKey,
       args: {
         // model id:
         model: this.modelId,
@@ -510,22 +581,23 @@ var OpenAICompatibleChatLanguageModel = class {
           json_schema: {
             schema: responseFormat.schema,
             strict: strictJsonSchema,
-            name: (_d = responseFormat.name) != null ? _d : "response",
+            name: (_e = responseFormat.name) != null ? _e : "response",
             description: responseFormat.description
           }
         } : { type: "json_object" } : void 0,
         stop: stopSequences,
         seed,
         ...Object.fromEntries(
-          Object.entries(
-            (_e = providerOptions == null ? void 0 : providerOptions[this.providerOptionsName]) != null ? _e : {}
-          ).filter(
+          Object.entries({
+            ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
+            ...providerOptions == null ? void 0 : providerOptions[toCamelCase(this.providerOptionsName)]
+          }).filter(
             ([key]) => !Object.keys(
               openaiCompatibleLanguageModelChatOptions.shape
             ).includes(key)
           )
         ),
-        reasoning_effort: compatibleOptions.reasoningEffort,
+        reasoning_effort: (_f = compatibleOptions.reasoningEffort) != null ? _f : isCustomReasoning(reasoning) && reasoning !== "none" ? reasoning : void 0,
         verbosity: compatibleOptions.textVerbosity,
         // messages:
         messages: convertToOpenAICompatibleChatMessages(prompt),
@@ -537,23 +609,23 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const { args, warnings } = await this.getArgs({ ...options });
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    const { args, warnings, metadataKey } = await this.getArgs({ ...options });
     const transformedBody = this.transformRequestBody(args);
     const body = JSON.stringify(transformedBody);
     const {
       responseHeaders,
       value: responseBody,
       rawValue: rawResponse
-    } = await (0, import_provider_utils2.postJsonToApi)({
+    } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body: transformedBody,
       failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         OpenAICompatibleChatResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -565,7 +637,7 @@ var OpenAICompatibleChatLanguageModel = class {
     if (text != null && text.length > 0) {
       content.push({ type: "text", text });
     }
-    const reasoning = (_a = choice.message.reasoning_content) != null ? _a : choice.message.reasoning;
+    const reasoning = (_c = choice.message.reasoning_content) != null ? _c : choice.message.reasoning;
     if (reasoning != null && reasoning.length > 0) {
       content.push({
         type: "reasoning",
@@ -574,40 +646,40 @@ var OpenAICompatibleChatLanguageModel = class {
     }
     if (choice.message.tool_calls != null) {
       for (const toolCall of choice.message.tool_calls) {
-        const thoughtSignature = (_c = (_b = toolCall.extra_content) == null ? void 0 : _b.google) == null ? void 0 : _c.thought_signature;
+        const thoughtSignature = (_e = (_d = toolCall.extra_content) == null ? void 0 : _d.google) == null ? void 0 : _e.thought_signature;
         content.push({
           type: "tool-call",
-          toolCallId: (_d = toolCall.id) != null ? _d : (0, import_provider_utils2.generateId)(),
+          toolCallId: (_f = toolCall.id) != null ? _f : generateId(),
           toolName: toolCall.function.name,
           input: toolCall.function.arguments,
           ...thoughtSignature ? {
             providerMetadata: {
-              [this.providerOptionsName]: { thoughtSignature }
+              [metadataKey]: { thoughtSignature }
             }
           } : {}
         });
       }
     }
     const providerMetadata = {
-      [this.providerOptionsName]: {},
-      ...await ((_f = (_e = this.config.metadataExtractor) == null ? void 0 : _e.extractMetadata) == null ? void 0 : _f.call(_e, {
+      [metadataKey]: {},
+      ...await ((_h = (_g = this.config.metadataExtractor) == null ? void 0 : _g.extractMetadata) == null ? void 0 : _h.call(_g, {
         parsedBody: rawResponse
       }))
     };
-    const completionTokenDetails = (_g = responseBody.usage) == null ? void 0 : _g.completion_tokens_details;
+    const completionTokenDetails = (_i = responseBody.usage) == null ? void 0 : _i.completion_tokens_details;
     if ((completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens) != null) {
-      providerMetadata[this.providerOptionsName].acceptedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.accepted_prediction_tokens;
+      providerMetadata[metadataKey].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;
+      providerMetadata[metadataKey].rejectedPredictionTokens = completionTokenDetails == null ? void 0 : completionTokenDetails.rejected_prediction_tokens;
     }
     return {
       content,
       finishReason: {
         unified: mapOpenAICompatibleFinishReason(choice.finish_reason),
-        raw: (_h = choice.finish_reason) != null ? _h : void 0
+        raw: (_j = choice.finish_reason) != null ? _j : void 0
       },
-      usage: convertOpenAICompatibleChatUsage(responseBody.usage),
+      usage: this.convertUsage(responseBody.usage),
       providerMetadata,
       request: { body },
       response: {
@@ -619,8 +691,10 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
   async doStream(options) {
-    var _a;
-    const { args, warnings } = await this.getArgs({ ...options });
+    var _a, _b, _c;
+    const { args, warnings, metadataKey } = await this.getArgs({
+      ...options
+    });
     const body = this.transformRequestBody({
       ...args,
       stream: true,
@@ -628,38 +702,96 @@ var OpenAICompatibleChatLanguageModel = class {
       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_utils2.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi({
       url: this.config.url({
         path: "/chat/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_c = (_b = this.config).headers) == null ? void 0 : _c.call(_b), options.headers),
       body,
       failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         this.chunkSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const toolCalls = [];
+    const providerOptionsName = metadataKey;
+    let toolCallTracker;
+    const pendingToolCalls = /* @__PURE__ */ new Map();
+    const forwardedToolCallIndices = /* @__PURE__ */ new Set();
+    const processToolCallDelta = (toolCallDelta) => {
+      var _a2, _b2, _c2, _d, _e;
+      const index = toolCallDelta.index;
+      if (index == null || forwardedToolCallIndices.has(index)) {
+        toolCallTracker.processDelta(toolCallDelta);
+        return;
+      }
+      let pending = pendingToolCalls.get(index);
+      if (pending == null) {
+        pending = {
+          id: (_a2 = toolCallDelta.id) != null ? _a2 : null,
+          bufferedArguments: "",
+          extraContent: (_b2 = toolCallDelta.extra_content) != null ? _b2 : null
+        };
+        pendingToolCalls.set(index, pending);
+      } else {
+        if (pending.id == null && toolCallDelta.id != null) {
+          pending.id = toolCallDelta.id;
+        }
+        if (pending.extraContent == null && toolCallDelta.extra_content != null) {
+          pending.extraContent = toolCallDelta.extra_content;
+        }
+      }
+      const argumentsDelta = (_c2 = toolCallDelta.function) == null ? void 0 : _c2.arguments;
+      if (argumentsDelta != null) {
+        pending.bufferedArguments += argumentsDelta;
+      }
+      const name = (_d = toolCallDelta.function) == null ? void 0 : _d.name;
+      if (name != null) {
+        const forwardDelta = {
+          index,
+          id: pending.id,
+          function: {
+            name,
+            arguments: pending.bufferedArguments
+          },
+          extra_content: (_e = pending.extraContent) != null ? _e : void 0
+        };
+        toolCallTracker.processDelta(forwardDelta);
+        pendingToolCalls.delete(index);
+        forwardedToolCallIndices.add(index);
+      }
+    };
     let finishReason = {
       unified: "other",
       raw: void 0
     };
     let usage = void 0;
     let isFirstChunk = true;
-    const providerOptionsName = this.providerOptionsName;
     let isActiveReasoning = false;
     let isActiveText = false;
+    const convertUsage = (usage2) => this.convertUsage(usage2);
     return {
       stream: response.pipeThrough(
         new TransformStream({
           start(controller) {
+            toolCallTracker = new StreamingToolCallTracker(
+              controller,
+              {
+                generateId,
+                extractMetadata: (delta) => {
+                  var _a2, _b2;
+                  const thoughtSignature = (_b2 = (_a2 = delta.extra_content) == null ? void 0 : _a2.google) == null ? void 0 : _b2.thought_signature;
+                  return thoughtSignature ? { [providerOptionsName]: { thoughtSignature } } : void 0;
+                },
+                buildToolCallProviderMetadata: (metadata) => metadata
+              }
+            );
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
+            var _a2, _b2;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -699,7 +831,7 @@ var OpenAICompatibleChatLanguageModel = class {
               return;
             }
             const delta = choice.delta;
-            const reasoningContent = (_b = delta.reasoning_content) != null ? _b : delta.reasoning;
+            const reasoningContent = (_b2 = delta.reasoning_content) != null ? _b2 : delta.reasoning;
             if (reasoningContent) {
               if (!isActiveReasoning) {
                 controller.enqueue({
@@ -741,145 +873,41 @@ var OpenAICompatibleChatLanguageModel = class {
                 isActiveReasoning = false;
               }
               for (const toolCallDelta of delta.tool_calls) {
-                const index = (_c = toolCallDelta.index) != null ? _c : toolCalls.length;
-                if (toolCalls[index] == null) {
-                  if (toolCallDelta.id == null) {
-                    throw new import_provider3.InvalidResponseDataError({
-                      data: toolCallDelta,
-                      message: `Expected 'id' to be a string.`
-                    });
-                  }
-                  if (((_d = toolCallDelta.function) == null ? void 0 : _d.name) == null) {
-                    throw new import_provider3.InvalidResponseDataError({
-                      data: toolCallDelta,
-                      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",
-                    function: {
-                      name: toolCallDelta.function.name,
-                      arguments: (_e = toolCallDelta.function.arguments) != null ? _e : ""
-                    },
-                    hasFinished: false,
-                    thoughtSignature: (_h = (_g = (_f = toolCallDelta.extra_content) == null ? void 0 : _f.google) == null ? void 0 : _g.thought_signature) != null ? _h : void 0
-                  };
-                  const toolCall2 = toolCalls[index];
-                  if (((_i = toolCall2.function) == null ? void 0 : _i.name) != null && ((_j = toolCall2.function) == null ? void 0 : _j.arguments) != null) {
-                    if (toolCall2.function.arguments.length > 0) {
-                      controller.enqueue({
-                        type: "tool-input-delta",
-                        id: toolCall2.id,
-                        delta: toolCall2.function.arguments
-                      });
-                    }
-                    if ((0, import_provider_utils2.isParsableJson)(toolCall2.function.arguments)) {
-                      controller.enqueue({
-                        type: "tool-input-end",
-                        id: toolCall2.id
-                      });
-                      controller.enqueue({
-                        type: "tool-call",
-                        toolCallId: (_k = toolCall2.id) != null ? _k : (0, import_provider_utils2.generateId)(),
-                        toolName: toolCall2.function.name,
-                        input: toolCall2.function.arguments,
-                        ...toolCall2.thoughtSignature ? {
-                          providerMetadata: {
-                            [providerOptionsName]: {
-                              thoughtSignature: toolCall2.thoughtSignature
-                            }
-                          }
-                        } : {}
-                      });
-                      toolCall2.hasFinished = true;
-                    }
-                  }
-                  continue;
-                }
-                const toolCall = toolCalls[index];
-                if (toolCall.hasFinished) {
-                  continue;
-                }
-                if (((_l = toolCallDelta.function) == null ? void 0 : _l.arguments) != null) {
-                  toolCall.function.arguments += (_n = (_m = toolCallDelta.function) == null ? void 0 : _m.arguments) != null ? _n : "";
-                }
-                controller.enqueue({
-                  type: "tool-input-delta",
-                  id: toolCall.id,
-                  delta: (_o = toolCallDelta.function.arguments) != null ? _o : ""
-                });
-                if (((_p = toolCall.function) == null ? void 0 : _p.name) != null && ((_q = toolCall.function) == null ? void 0 : _q.arguments) != null && (0, import_provider_utils2.isParsableJson)(toolCall.function.arguments)) {
-                  controller.enqueue({
-                    type: "tool-input-end",
-                    id: toolCall.id
-                  });
-                  controller.enqueue({
-                    type: "tool-call",
-                    toolCallId: (_r = toolCall.id) != null ? _r : (0, import_provider_utils2.generateId)(),
-                    toolName: toolCall.function.name,
-                    input: toolCall.function.arguments,
-                    ...toolCall.thoughtSignature ? {
-                      providerMetadata: {
-                        [providerOptionsName]: {
-                          thoughtSignature: toolCall.thoughtSignature
-                        }
-                      }
-                    } : {}
-                  });
-                  toolCall.hasFinished = true;
-                }
+                processToolCallDelta(toolCallDelta);
               }
             }
           },
           flush(controller) {
-            var _a2, _b, _c, _d, _e;
+            var _a2, _b2, _c2, _d;
             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_utils2.generateId)(),
-                toolName: toolCall.function.name,
-                input: toolCall.function.arguments,
-                ...toolCall.thoughtSignature ? {
-                  providerMetadata: {
-                    [providerOptionsName]: {
-                      thoughtSignature: toolCall.thoughtSignature
-                    }
-                  }
-                } : {}
+            for (const [index, pending] of pendingToolCalls) {
+              toolCallTracker.processDelta({
+                index,
+                id: pending.id,
+                function: { arguments: pending.bufferedArguments }
               });
             }
+            pendingToolCalls.clear();
+            toolCallTracker.flush();
             const providerMetadata = {
               [providerOptionsName]: {},
               ...metadataExtractor == null ? void 0 : metadataExtractor.buildMetadata()
             };
-            if (((_b = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _b.accepted_prediction_tokens) != null) {
-              providerMetadata[providerOptionsName].acceptedPredictionTokens = (_c = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _c.accepted_prediction_tokens;
+            if (((_a2 = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _a2.accepted_prediction_tokens) != null) {
+              providerMetadata[providerOptionsName].acceptedPredictionTokens = (_b2 = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _b2.accepted_prediction_tokens;
             }
-            if (((_d = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _d.rejected_prediction_tokens) != null) {
-              providerMetadata[providerOptionsName].rejectedPredictionTokens = (_e = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _e.rejected_prediction_tokens;
+            if (((_c2 = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _c2.rejected_prediction_tokens) != null) {
+              providerMetadata[providerOptionsName].rejectedPredictionTokens = (_d = usage == null ? void 0 : usage.completion_tokens_details) == null ? void 0 : _d.rejected_prediction_tokens;
             }
             controller.enqueue({
               type: "finish",
               finishReason,
-              usage: convertOpenAICompatibleChatUsage(usage),
+              usage: convertUsage(usage),
               providerMetadata
             });
           }
@@ -890,92 +918,102 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
 };
-var openaiCompatibleTokenUsageSchema = import_v43.z.looseObject({
-  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()
+var openaiCompatibleTokenUsageSchema = z3.looseObject({
+  prompt_tokens: z3.number().nullish(),
+  completion_tokens: z3.number().nullish(),
+  total_tokens: z3.number().nullish(),
+  prompt_tokens_details: z3.object({
+    cached_tokens: z3.number().nullish()
   }).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()
+  completion_tokens_details: z3.object({
+    reasoning_tokens: z3.number().nullish(),
+    accepted_prediction_tokens: z3.number().nullish(),
+    rejected_prediction_tokens: z3.number().nullish()
   }).nullish()
 }).nullish();
-var OpenAICompatibleChatResponseSchema = import_v43.z.looseObject({
-  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(),
-        reasoning: 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()
+var OpenAICompatibleChatResponseSchema = z3.looseObject({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      message: z3.object({
+        role: z3.literal("assistant").nullish(),
+        content: z3.string().nullish(),
+        reasoning_content: z3.string().nullish(),
+        reasoning: z3.string().nullish(),
+        tool_calls: z3.array(
+          z3.object({
+            id: z3.string().nullish(),
+            function: z3.object({
+              name: z3.string(),
+              arguments: z3.string()
             }),
             // Support for Google Gemini thought signatures via OpenAI compatibility
-            extra_content: import_v43.z.object({
-              google: import_v43.z.object({
-                thought_signature: import_v43.z.string().nullish()
+            extra_content: z3.object({
+              google: z3.object({
+                thought_signature: z3.string().nullish()
               }).nullish()
             }).nullish()
           })
         ).nullish()
       }),
-      finish_reason: import_v43.z.string().nullish()
+      finish_reason: z3.string().nullish()
     })
   ),
   usage: openaiCompatibleTokenUsageSchema
 });
-var chunkBaseSchema = import_v43.z.looseObject({
-  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(),
+var chunkBaseSchema = z3.looseObject({
+  id: z3.string().nullish(),
+  created: z3.number().nullish(),
+  model: z3.string().nullish(),
+  choices: z3.array(
+    z3.object({
+      delta: z3.object({
+        role: z3.enum(["assistant", ""]).nullish(),
+        content: z3.string().nullish(),
         // Most openai-compatible models set `reasoning_content`, but some
         // providers serving `gpt-oss` set `reasoning`. See #7866
-        reasoning_content: import_v43.z.string().nullish(),
-        reasoning: import_v43.z.string().nullish(),
-        tool_calls: import_v43.z.array(
-          import_v43.z.object({
-            index: import_v43.z.number().nullish(),
+        reasoning_content: z3.string().nullish(),
+        reasoning: z3.string().nullish(),
+        tool_calls: z3.array(
+          z3.object({
+            index: z3.number().nullish(),
             //google does not send index
-            id: import_v43.z.string().nullish(),
-            function: import_v43.z.object({
-              name: import_v43.z.string().nullish(),
-              arguments: import_v43.z.string().nullish()
+            id: z3.string().nullish(),
+            function: z3.object({
+              name: z3.string().nullish(),
+              arguments: z3.string().nullish()
             }),
             // Support for Google Gemini thought signatures via OpenAI compatibility
-            extra_content: import_v43.z.object({
-              google: import_v43.z.object({
-                thought_signature: import_v43.z.string().nullish()
+            extra_content: z3.object({
+              google: z3.object({
+                thought_signature: z3.string().nullish()
               }).nullish()
             }).nullish()
           })
         ).nullish()
       }).nullish(),
-      finish_reason: import_v43.z.string().nullish()
+      finish_reason: z3.string().nullish()
     })
   ),
   usage: openaiCompatibleTokenUsageSchema
 });
-var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v43.z.union([chunkBaseSchema, errorSchema]);
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => z3.union([chunkBaseSchema, errorSchema]);
 
 // src/completion/openai-compatible-completion-language-model.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
+import {
+  combineHeaders as combineHeaders2,
+  createEventSourceResponseHandler as createEventSourceResponseHandler2,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi as postJsonToApi2,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
 
 // src/completion/convert-openai-compatible-completion-usage.ts
 function convertOpenAICompatibleCompletionUsage(usage) {
@@ -1015,7 +1053,10 @@ function convertOpenAICompatibleCompletionUsage(usage) {
 }
 
 // src/completion/convert-to-openai-compatible-completion-prompt.ts
-var import_provider4 = require("@ai-sdk/provider");
+import {
+  InvalidPromptError,
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError3
+} from "@ai-sdk/provider";
 function convertToOpenAICompatibleCompletionPrompt({
   prompt,
   user = "user",
@@ -1031,7 +1072,7 @@ function convertToOpenAICompatibleCompletionPrompt({
   for (const { role, content } of prompt) {
     switch (role) {
       case "system": {
-        throw new import_provider4.InvalidPromptError({
+        throw new InvalidPromptError({
           message: "Unexpected system message in prompt: ${content}",
           prompt
         });
@@ -1057,7 +1098,7 @@ ${userMessage}
               return part.text;
             }
             case "tool-call": {
-              throw new import_provider4.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError3({
                 functionality: "tool-call messages"
               });
             }
@@ -1070,7 +1111,7 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new import_provider4.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError3({
           functionality: "tool messages"
         });
       }
@@ -1119,34 +1160,33 @@ function mapOpenAICompatibleFinishReason2(finishReason) {
   }
 }
 
-// src/completion/openai-compatible-completion-options.ts
-var import_v44 = require("zod/v4");
-var openaiCompatibleLanguageModelCompletionOptions = import_v44.z.object({
+// src/completion/openai-compatible-completion-language-model-options.ts
+import { z as z4 } from "zod/v4";
+var openaiCompatibleLanguageModelCompletionOptions = z4.object({
   /**
    * Echo back the prompt in addition to the completion.
    */
-  echo: import_v44.z.boolean().optional(),
+  echo: z4.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_v44.z.record(import_v44.z.string(), import_v44.z.number()).optional(),
+  logitBias: z4.record(z4.string(), z4.number()).optional(),
   /**
    * The suffix that comes after a completion of inserted text.
    */
-  suffix: import_v44.z.string().optional(),
+  suffix: z4.string().optional(),
   /**
    * A unique identifier representing your end-user, which can help providers to
    * monitor and detect abuse.
    */
-  user: import_v44.z.string().optional()
+  user: z4.string().optional()
 });
 
 // src/completion/openai-compatible-completion-language-model.ts
-var OpenAICompatibleCompletionLanguageModel = class {
-  // type inferred via constructor
+var OpenAICompatibleCompletionLanguageModel = class _OpenAICompatibleCompletionLanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     var _a;
@@ -1156,7 +1196,20 @@ var OpenAICompatibleCompletionLanguageModel = class {
     this.chunkSchema = createOpenAICompatibleCompletionChunkSchema(
       errorStructure.errorSchema
     );
-    this.failedResponseHandler = (0, import_provider_utils3.createJsonErrorResponseHandler)(errorStructure);
+    this.failedResponseHandler = createJsonErrorResponseHandler2(errorStructure);
+  }
+  // type inferred via constructor
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE2](options) {
+    return new _OpenAICompatibleCompletionLanguageModel(
+      options.modelId,
+      options.config
+    );
   }
   get provider() {
     return this.config.provider;
@@ -1183,13 +1236,25 @@ var OpenAICompatibleCompletionLanguageModel = class {
     tools,
     toolChoice
   }) {
-    var _a;
+    var _a, _b;
     const warnings = [];
-    const completionOptions = (_a = await (0, import_provider_utils3.parseProviderOptions)({
-      provider: this.providerOptionsName,
+    warnIfDeprecatedProviderOptionsKey({
+      rawName: this.providerOptionsName,
       providerOptions,
-      schema: openaiCompatibleLanguageModelCompletionOptions
-    })) != null ? _a : {};
+      warnings
+    });
+    const completionOptions = Object.assign(
+      (_a = await parseProviderOptions2({
+        provider: this.providerOptionsName,
+        providerOptions,
+        schema: openaiCompatibleLanguageModelCompletionOptions
+      })) != null ? _a : {},
+      (_b = await parseProviderOptions2({
+        provider: toCamelCase(this.providerOptionsName),
+        providerOptions,
+        schema: openaiCompatibleLanguageModelCompletionOptions
+      })) != null ? _b : {}
+    );
     if (topK != null) {
       warnings.push({ type: "unsupported", feature: "topK" });
     }
@@ -1225,6 +1290,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
         presence_penalty: presencePenalty,
         seed,
         ...providerOptions == null ? void 0 : providerOptions[this.providerOptionsName],
+        ...providerOptions == null ? void 0 : providerOptions[toCamelCase(this.providerOptionsName)],
         // prompt:
         prompt: completionPrompt,
         // stop sequences:
@@ -1234,20 +1300,21 @@ var OpenAICompatibleCompletionLanguageModel = class {
     };
   }
   async doGenerate(options) {
+    var _a, _b;
     const { args, warnings } = await this.getArgs(options);
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils3.postJsonToApi)({
+    } = await postJsonToApi2({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders2((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body: args,
       failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler2(
         openaiCompatibleCompletionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -1275,6 +1342,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
     };
   }
   async doStream(options) {
+    var _a, _b;
     const { args, warnings } = await this.getArgs(options);
     const body = {
       ...args,
@@ -1282,15 +1350,15 @@ var OpenAICompatibleCompletionLanguageModel = class {
       // 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_utils3.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi2({
       url: this.config.url({
         path: "/completions",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders2((_b = (_a = this.config).headers) == null ? void 0 : _b.call(_a), options.headers),
       body,
       failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler2(
         this.chunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -1309,7 +1377,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a;
+            var _a2;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -1342,7 +1410,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
             if ((choice == null ? void 0 : choice.finish_reason) != null) {
               finishReason = {
                 unified: mapOpenAICompatibleFinishReason2(choice.finish_reason),
-                raw: (_a = choice.finish_reason) != null ? _a : void 0
+                raw: (_a2 = choice.finish_reason) != null ? _a2 : void 0
               };
             }
             if ((choice == null ? void 0 : choice.text) != null) {
@@ -1370,33 +1438,33 @@ var OpenAICompatibleCompletionLanguageModel = class {
     };
   }
 };
-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 usageSchema = z5.object({
+  prompt_tokens: z5.number(),
+  completion_tokens: z5.number(),
+  total_tokens: z5.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()
+var openaiCompatibleCompletionResponseSchema = z5.object({
+  id: z5.string().nullish(),
+  created: z5.number().nullish(),
+  model: z5.string().nullish(),
+  choices: z5.array(
+    z5.object({
+      text: z5.string(),
+      finish_reason: z5.string()
     })
   ),
   usage: usageSchema.nullish()
 });
-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()
+var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => z5.union([
+  z5.object({
+    id: z5.string().nullish(),
+    created: z5.number().nullish(),
+    model: z5.string().nullish(),
+    choices: z5.array(
+      z5.object({
+        text: z5.string(),
+        finish_reason: z5.string().nullish(),
+        index: z5.number()
       })
     ),
     usage: usageSchema.nullish()
@@ -1405,27 +1473,38 @@ var createOpenAICompatibleCompletionChunkSchema = (errorSchema) => import_v45.z.
 ]);
 
 // src/embedding/openai-compatible-embedding-model.ts
-var import_provider5 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
+import {
+  TooManyEmbeddingValuesForCallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders3,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi3,
+  serializeModelOptions as serializeModelOptions3,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3
+} from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
 
-// src/embedding/openai-compatible-embedding-options.ts
-var import_v46 = require("zod/v4");
-var openaiCompatibleEmbeddingModelOptions = import_v46.z.object({
+// src/embedding/openai-compatible-embedding-model-options.ts
+import { z as z6 } from "zod/v4";
+var openaiCompatibleEmbeddingModelOptions = z6.object({
   /**
    * The number of dimensions the resulting output embeddings should have.
    * Only supported in text-embedding-3 and later models.
    */
-  dimensions: import_v46.z.number().optional(),
+  dimensions: z6.number().optional(),
   /**
    * A unique identifier representing your end-user, which can help providers to
    * monitor and detect abuse.
    */
-  user: import_v46.z.string().optional()
+  user: z6.string().optional()
 });
 
 // src/embedding/openai-compatible-embedding-model.ts
-var OpenAICompatibleEmbeddingModel = class {
+var OpenAICompatibleEmbeddingModel = class _OpenAICompatibleEmbeddingModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     this.modelId = modelId;
@@ -1442,6 +1521,15 @@ var OpenAICompatibleEmbeddingModel = class {
     var _a;
     return (_a = this.config.supportsParallelCalls) != null ? _a : true;
   }
+  static [WORKFLOW_SERIALIZE3](model) {
+    return serializeModelOptions3({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE3](options) {
+    return new _OpenAICompatibleEmbeddingModel(options.modelId, options.config);
+  }
   get providerOptionsName() {
     return this.config.provider.split(".")[0].trim();
   }
@@ -1451,34 +1539,40 @@ var OpenAICompatibleEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const warnings = [];
-    const deprecatedOptions = await (0, import_provider_utils4.parseProviderOptions)({
+    const deprecatedOptions = await parseProviderOptions3({
       provider: "openai-compatible",
       providerOptions,
       schema: openaiCompatibleEmbeddingModelOptions
     });
     if (deprecatedOptions != null) {
       warnings.push({
-        type: "other",
-        message: `The 'openai-compatible' key in providerOptions is deprecated. Use 'openaiCompatible' instead.`
+        type: "deprecated",
+        setting: "providerOptions key 'openai-compatible'",
+        message: "Use 'openaiCompatible' instead."
       });
     }
+    warnIfDeprecatedProviderOptionsKey({
+      rawName: this.providerOptionsName,
+      providerOptions,
+      warnings
+    });
     const compatibleOptions = Object.assign(
       deprecatedOptions != null ? deprecatedOptions : {},
-      (_a = await (0, import_provider_utils4.parseProviderOptions)({
+      (_a = await parseProviderOptions3({
         provider: "openaiCompatible",
         providerOptions,
         schema: openaiCompatibleEmbeddingModelOptions
       })) != null ? _a : {},
-      (_b = await (0, import_provider_utils4.parseProviderOptions)({
+      (_b = await parseProviderOptions3({
         provider: this.providerOptionsName,
         providerOptions,
         schema: openaiCompatibleEmbeddingModelOptions
       })) != null ? _b : {}
     );
     if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider5.TooManyEmbeddingValuesForCallError({
+      throw new TooManyEmbeddingValuesForCallError({
         provider: this.provider,
         modelId: this.modelId,
         maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
@@ -1489,12 +1583,12 @@ var OpenAICompatibleEmbeddingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils4.postJsonToApi)({
+    } = await postJsonToApi3({
       url: this.config.url({
         path: "/embeddings",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders3((_d = (_c = this.config).headers) == null ? void 0 : _d.call(_c), headers),
       body: {
         model: this.modelId,
         input: values,
@@ -1502,10 +1596,10 @@ var OpenAICompatibleEmbeddingModel = class {
         dimensions: compatibleOptions.dimensions,
         user: compatibleOptions.user
       },
-      failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)(
-        (_c = this.config.errorStructure) != null ? _c : defaultOpenAICompatibleErrorStructure
+      failedResponseHandler: createJsonErrorResponseHandler3(
+        (_e = this.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure
       ),
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler3(
         openaiTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -1520,16 +1614,28 @@ var OpenAICompatibleEmbeddingModel = class {
     };
   }
 };
-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(),
-  providerMetadata: import_v47.z.record(import_v47.z.string(), import_v47.z.record(import_v47.z.string(), import_v47.z.any())).optional()
+var openaiTextEmbeddingResponseSchema = z7.object({
+  data: z7.array(z7.object({ embedding: z7.array(z7.number()) })),
+  usage: z7.object({ prompt_tokens: z7.number() }).nullish(),
+  providerMetadata: z7.record(z7.string(), z7.record(z7.string(), z7.any())).optional()
 });
 
 // src/image/openai-compatible-image-model.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
-var OpenAICompatibleImageModel = class {
+import {
+  combineHeaders as combineHeaders4,
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  convertToFormData,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  downloadBlob,
+  postFormDataToApi,
+  postJsonToApi as postJsonToApi4,
+  serializeModelOptions as serializeModelOptions4,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE4,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE4
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var OpenAICompatibleImageModel = class _OpenAICompatibleImageModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
@@ -1545,8 +1651,21 @@ var OpenAICompatibleImageModel = class {
   get providerOptionsKey() {
     return this.config.provider.split(".")[0].trim();
   }
-  // TODO: deprecate non-camelCase keys and remove in future major version
-  getArgs(providerOptions) {
+  static [WORKFLOW_SERIALIZE4](model) {
+    return serializeModelOptions4({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE4](options) {
+    return new _OpenAICompatibleImageModel(options.modelId, options.config);
+  }
+  getArgs(providerOptions, warnings) {
+    warnIfDeprecatedProviderOptionsKey({
+      rawName: this.providerOptionsKey,
+      providerOptions,
+      warnings
+    });
     return {
       ...providerOptions[this.providerOptionsKey],
       ...providerOptions[toCamelCase(this.providerOptionsKey)]
@@ -1564,7 +1683,7 @@ var OpenAICompatibleImageModel = class {
     files,
     mask
   }) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const warnings = [];
     if (aspectRatio != null) {
       warnings.push({
@@ -1577,15 +1696,15 @@ var OpenAICompatibleImageModel = class {
       warnings.push({ type: "unsupported", feature: "seed" });
     }
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
-    const args = this.getArgs(providerOptions);
+    const args = this.getArgs(providerOptions, warnings);
     if (files != null && files.length > 0) {
-      const { value: response2, responseHeaders: responseHeaders2 } = await (0, import_provider_utils5.postFormDataToApi)({
+      const { value: response2, responseHeaders: responseHeaders2 } = await postFormDataToApi({
         url: this.config.url({
           path: "/images/edits",
           modelId: this.modelId
         }),
-        headers: (0, import_provider_utils5.combineHeaders)(this.config.headers(), headers),
-        formData: (0, import_provider_utils5.convertToFormData)({
+        headers: combineHeaders4((_e = (_d = this.config).headers) == null ? void 0 : _e.call(_d), headers),
+        formData: convertToFormData({
           model: this.modelId,
           prompt,
           image: await Promise.all(files.map((file) => fileToBlob(file))),
@@ -1594,10 +1713,10 @@ var OpenAICompatibleImageModel = class {
           size,
           ...args
         }),
-        failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)(
-          (_d = this.config.errorStructure) != null ? _d : defaultOpenAICompatibleErrorStructure
+        failedResponseHandler: createJsonErrorResponseHandler4(
+          (_f = this.config.errorStructure) != null ? _f : defaultOpenAICompatibleErrorStructure
         ),
-        successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler4(
           openaiCompatibleImageResponseSchema
         ),
         abortSignal,
@@ -1613,12 +1732,12 @@ var OpenAICompatibleImageModel = class {
         }
       };
     }
-    const { value: response, responseHeaders } = await (0, import_provider_utils5.postJsonToApi)({
+    const { value: response, responseHeaders } = await postJsonToApi4({
       url: this.config.url({
         path: "/images/generations",
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils5.combineHeaders)(this.config.headers(), headers),
+      headers: combineHeaders4((_h = (_g = this.config).headers) == null ? void 0 : _h.call(_g), headers),
       body: {
         model: this.modelId,
         prompt,
@@ -1627,10 +1746,10 @@ var OpenAICompatibleImageModel = class {
         ...args,
         response_format: "b64_json"
       },
-      failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)(
-        (_e = this.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure
+      failedResponseHandler: createJsonErrorResponseHandler4(
+        (_i = this.config.errorStructure) != null ? _i : defaultOpenAICompatibleErrorStructure
       ),
-      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler4(
         openaiCompatibleImageResponseSchema
       ),
       abortSignal,
@@ -1647,35 +1766,35 @@ var OpenAICompatibleImageModel = class {
     };
   }
 };
-var openaiCompatibleImageResponseSchema = import_v48.z.object({
-  data: import_v48.z.array(import_v48.z.object({ b64_json: import_v48.z.string() }))
+var openaiCompatibleImageResponseSchema = z8.object({
+  data: z8.array(z8.object({ b64_json: z8.string() }))
 });
 async function fileToBlob(file) {
   if (file.type === "url") {
-    return (0, import_provider_utils5.downloadBlob)(file.url);
+    return downloadBlob(file.url);
   }
-  const data = file.data instanceof Uint8Array ? file.data : (0, import_provider_utils5.convertBase64ToUint8Array)(file.data);
+  const data = file.data instanceof Uint8Array ? file.data : convertBase64ToUint8Array2(file.data);
   return new Blob([data], { type: file.mediaType });
 }
-function toCamelCase(str) {
-  return str.replace(/[_-]([a-z])/g, (g) => g[1].toUpperCase());
-}
 
 // src/openai-compatible-provider.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+import {
+  withoutTrailingSlash,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "3.0.0-beta.4" : "0.0.0-test";
+var VERSION = true ? "3.0.0-beta.57" : "0.0.0-test";
 
 // src/openai-compatible-provider.ts
 function createOpenAICompatible(options) {
-  const baseURL = (0, import_provider_utils6.withoutTrailingSlash)(options.baseURL);
+  const baseURL = withoutTrailingSlash(options.baseURL);
   const providerName = options.name;
   const headers = {
     ...options.apiKey && { Authorization: `Bearer ${options.apiKey}` },
     ...options.headers
   };
-  const getHeaders = () => (0, import_provider_utils6.withUserAgentSuffix)(headers, `ai-sdk/openai-compatible/${VERSION}`);
+  const getHeaders = () => withUserAgentSuffix(headers, `ai-sdk/openai-compatible/${VERSION}`);
   const getCommonModelConfig = (modelType) => ({
     provider: `${providerName}.${modelType}`,
     url: ({ path }) => {
@@ -1693,8 +1812,10 @@ function createOpenAICompatible(options) {
     ...getCommonModelConfig("chat"),
     includeUsage: options.includeUsage,
     supportsStructuredOutputs: options.supportsStructuredOutputs,
+    supportedUrls: options.supportedUrls,
     transformRequestBody: options.transformRequestBody,
-    metadataExtractor: options.metadataExtractor
+    metadataExtractor: options.metadataExtractor,
+    convertUsage: options.convertUsage
   });
   const createCompletionModel = (modelId) => new OpenAICompatibleCompletionLanguageModel(modelId, {
     ...getCommonModelConfig("completion"),
@@ -1714,13 +1835,12 @@ function createOpenAICompatible(options) {
   provider.imageModel = createImageModel;
   return provider;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   OpenAICompatibleChatLanguageModel,
   OpenAICompatibleCompletionLanguageModel,
   OpenAICompatibleEmbeddingModel,
   OpenAICompatibleImageModel,
   VERSION,
   createOpenAICompatible
-});
+};
 //# sourceMappingURL=index.js.map