@ai-sdk/openai-compatible 3.0.0-beta.23 → 3.0.0-beta.24

package/dist/index.js

@@ -1,38 +1,19 @@
-"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 {
+  InvalidResponseDataError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  isCustomReasoning,
+  isParsableJson,
+  parseProviderOptions,
+  postJsonToApi
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
 
 // src/utils/to-camel-case.ts
 function toCamelCase(str) {
@@ -61,16 +42,16 @@ function warnIfDeprecatedProviderOptionsKey({
 }
 
 // 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 = {
@@ -118,8 +99,14 @@ 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,
+  isProviderReference
+} 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 : {};
@@ -164,8 +151,8 @@ function convertToOpenAICompatibleChatMessages(prompt) {
                 return { type: "text", text: part.text, ...partMetadata };
               }
               case "file": {
-                if ((0, import_provider_utils.isProviderReference)(part.data)) {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                if (isProviderReference(part.data)) {
+                  throw new UnsupportedFunctionalityError({
                     functionality: "file parts with provider references"
                   });
                 }
@@ -174,27 +161,27 @@ function convertToOpenAICompatibleChatMessages(prompt) {
                   return {
                     type: "image_url",
                     image_url: {
-                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${(0, import_provider_utils.convertToBase64)(part.data)}`
+                      url: part.data instanceof URL ? part.data.toString() : `data:${mediaType};base64,${convertToBase64(part.data)}`
                     },
                     ...partMetadata
                   };
                 }
                 if (part.mediaType.startsWith("audio/")) {
                   if (part.data instanceof URL) {
-                    throw new import_provider.UnsupportedFunctionalityError({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "audio file parts with URLs"
                     });
                   }
                   const format = getAudioFormat(part.mediaType);
                   if (format === null) {
-                    throw new import_provider.UnsupportedFunctionalityError({
+                    throw new UnsupportedFunctionalityError({
                       functionality: `audio media type ${part.mediaType}`
                     });
                   }
                   return {
                     type: "input_audio",
                     input_audio: {
-                      data: (0, import_provider_utils.convertToBase64)(part.data),
+                      data: convertToBase64(part.data),
                       format
                     },
                     ...partMetadata
@@ -202,7 +189,7 @@ function convertToOpenAICompatibleChatMessages(prompt) {
                 }
                 if (part.mediaType === "application/pdf") {
                   if (part.data instanceof URL) {
-                    throw new import_provider.UnsupportedFunctionalityError({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "PDF file parts with URLs"
                     });
                   }
@@ -210,14 +197,14 @@ function convertToOpenAICompatibleChatMessages(prompt) {
                     type: "file",
                     file: {
                       filename: (_a2 = part.filename) != null ? _a2 : "document.pdf",
-                      file_data: `data:application/pdf;base64,${(0, import_provider_utils.convertToBase64)(part.data)}`
+                      file_data: `data:application/pdf;base64,${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)
+                    convertBase64ToUint8Array(part.data)
                   ) : new TextDecoder().decode(part.data);
                   return {
                     type: "text",
@@ -225,7 +212,7 @@ function convertToOpenAICompatibleChatMessages(prompt) {
                     ...partMetadata
                   };
                 }
-                throw new import_provider.UnsupportedFunctionalityError({
+                throw new UnsupportedFunctionalityError({
                   functionality: `file part media type ${part.mediaType}`
                 });
               }
@@ -353,21 +340,21 @@ function mapOpenAICompatibleFinishReason(finishReason) {
 }
 
 // src/chat/openai-compatible-chat-options.ts
-var import_v42 = require("zod/v4");
-var openaiCompatibleLanguageModelChatOptions = import_v42.z.object({
+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.
@@ -375,11 +362,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
@@ -428,7 +417,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -447,7 +436,7 @@ 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;
   }
   get provider() {
@@ -482,7 +471,7 @@ var OpenAICompatibleChatLanguageModel = class {
   }) {
     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
@@ -501,17 +490,17 @@ var OpenAICompatibleChatLanguageModel = class {
     });
     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 : {},
-      (_c = await (0, import_provider_utils2.parseProviderOptions)({
+      (_c = await parseProviderOptions({
         provider: toCamelCase(this.providerOptionsName),
         providerOptions,
         schema: openaiCompatibleLanguageModelChatOptions
@@ -574,7 +563,7 @@ var OpenAICompatibleChatLanguageModel = class {
             ).includes(key)
           )
         ),
-        reasoning_effort: (_f = compatibleOptions.reasoningEffort) != null ? _f : (0, import_provider_utils2.isCustomReasoning)(reasoning) && reasoning !== "none" ? reasoning : void 0,
+        reasoning_effort: (_f = compatibleOptions.reasoningEffort) != null ? _f : isCustomReasoning(reasoning) && reasoning !== "none" ? reasoning : void 0,
         verbosity: compatibleOptions.textVerbosity,
         // messages:
         messages: convertToOpenAICompatibleChatMessages(prompt),
@@ -594,15 +583,15 @@ var OpenAICompatibleChatLanguageModel = class {
       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(this.config.headers(), options.headers),
       body: transformedBody,
       failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         OpenAICompatibleChatResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -626,7 +615,7 @@ var OpenAICompatibleChatLanguageModel = class {
         const thoughtSignature = (_c = (_b = toolCall.extra_content) == null ? void 0 : _b.google) == null ? void 0 : _c.thought_signature;
         content.push({
           type: "tool-call",
-          toolCallId: (_d = toolCall.id) != null ? _d : (0, import_provider_utils2.generateId)(),
+          toolCallId: (_d = toolCall.id) != null ? _d : generateId(),
           toolName: toolCall.function.name,
           input: toolCall.function.arguments,
           ...thoughtSignature ? {
@@ -679,15 +668,15 @@ 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(this.config.headers(), options.headers),
       body,
       failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler(
         this.chunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -795,13 +784,13 @@ var OpenAICompatibleChatLanguageModel = class {
                 const index = (_c = toolCallDelta.index) != null ? _c : toolCalls.length;
                 if (toolCalls[index] == null) {
                   if (toolCallDelta.id == null) {
-                    throw new import_provider3.InvalidResponseDataError({
+                    throw new 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({
+                    throw new InvalidResponseDataError({
                       data: toolCallDelta,
                       message: `Expected 'function.name' to be a string.`
                     });
@@ -830,14 +819,14 @@ var OpenAICompatibleChatLanguageModel = class {
                         delta: toolCall2.function.arguments
                       });
                     }
-                    if ((0, import_provider_utils2.isParsableJson)(toolCall2.function.arguments)) {
+                    if (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)(),
+                        toolCallId: (_k = toolCall2.id) != null ? _k : generateId(),
                         toolName: toolCall2.function.name,
                         input: toolCall2.function.arguments,
                         ...toolCall2.thoughtSignature ? {
@@ -865,14 +854,14 @@ var OpenAICompatibleChatLanguageModel = class {
                   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)) {
+                if (((_p = toolCall.function) == null ? void 0 : _p.name) != null && ((_q = toolCall.function) == null ? void 0 : _q.arguments) != null && 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)(),
+                    toolCallId: (_r = toolCall.id) != null ? _r : generateId(),
                     toolName: toolCall.function.name,
                     input: toolCall.function.arguments,
                     ...toolCall.thoughtSignature ? {
@@ -905,7 +894,7 @@ var OpenAICompatibleChatLanguageModel = class {
               });
               controller.enqueue({
                 type: "tool-call",
-                toolCallId: (_a2 = toolCall.id) != null ? _a2 : (0, import_provider_utils2.generateId)(),
+                toolCallId: (_a2 = toolCall.id) != null ? _a2 : generateId(),
                 toolName: toolCall.function.name,
                 input: toolCall.function.arguments,
                 ...toolCall.thoughtSignature ? {
@@ -941,92 +930,99 @@ 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
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
 
 // src/completion/convert-openai-compatible-completion-usage.ts
 function convertOpenAICompatibleCompletionUsage(usage) {
@@ -1066,7 +1062,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",
@@ -1082,7 +1081,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
         });
@@ -1108,7 +1107,7 @@ ${userMessage}
               return part.text;
             }
             case "tool-call": {
-              throw new import_provider4.UnsupportedFunctionalityError({
+              throw new UnsupportedFunctionalityError3({
                 functionality: "tool-call messages"
               });
             }
@@ -1121,7 +1120,7 @@ ${assistantMessage}
         break;
       }
       case "tool": {
-        throw new import_provider4.UnsupportedFunctionalityError({
+        throw new UnsupportedFunctionalityError3({
           functionality: "tool messages"
         });
       }
@@ -1171,28 +1170,28 @@ function mapOpenAICompatibleFinishReason2(finishReason) {
 }
 
 // src/completion/openai-compatible-completion-options.ts
-var import_v44 = require("zod/v4");
-var openaiCompatibleLanguageModelCompletionOptions = import_v44.z.object({
+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
@@ -1207,7 +1206,7 @@ var OpenAICompatibleCompletionLanguageModel = class {
     this.chunkSchema = createOpenAICompatibleCompletionChunkSchema(
       errorStructure.errorSchema
     );
-    this.failedResponseHandler = (0, import_provider_utils3.createJsonErrorResponseHandler)(errorStructure);
+    this.failedResponseHandler = createJsonErrorResponseHandler2(errorStructure);
   }
   get provider() {
     return this.config.provider;
@@ -1242,12 +1241,12 @@ var OpenAICompatibleCompletionLanguageModel = class {
       warnings
     });
     const completionOptions = Object.assign(
-      (_a = await (0, import_provider_utils3.parseProviderOptions)({
+      (_a = await parseProviderOptions2({
         provider: this.providerOptionsName,
         providerOptions,
         schema: openaiCompatibleLanguageModelCompletionOptions
       })) != null ? _a : {},
-      (_b = await (0, import_provider_utils3.parseProviderOptions)({
+      (_b = await parseProviderOptions2({
         provider: toCamelCase(this.providerOptionsName),
         providerOptions,
         schema: openaiCompatibleLanguageModelCompletionOptions
@@ -1303,15 +1302,15 @@ var OpenAICompatibleCompletionLanguageModel = class {
       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(this.config.headers(), options.headers),
       body: args,
       failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler2(
         openaiCompatibleCompletionResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -1346,15 +1345,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(this.config.headers(), options.headers),
       body,
       failedResponseHandler: this.failedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(
+      successfulResponseHandler: createEventSourceResponseHandler2(
         this.chunkSchema
       ),
       abortSignal: options.abortSignal,
@@ -1434,33 +1433,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()
@@ -1469,23 +1468,31 @@ 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
+} 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({
+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
@@ -1517,7 +1524,7 @@ var OpenAICompatibleEmbeddingModel = class {
   }) {
     var _a, _b, _c;
     const warnings = [];
-    const deprecatedOptions = await (0, import_provider_utils4.parseProviderOptions)({
+    const deprecatedOptions = await parseProviderOptions3({
       provider: "openai-compatible",
       providerOptions,
       schema: openaiCompatibleEmbeddingModelOptions
@@ -1536,19 +1543,19 @@ var OpenAICompatibleEmbeddingModel = class {
     });
     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,
@@ -1559,12 +1566,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(this.config.headers(), headers),
       body: {
         model: this.modelId,
         input: values,
@@ -1572,10 +1579,10 @@ var OpenAICompatibleEmbeddingModel = class {
         dimensions: compatibleOptions.dimensions,
         user: compatibleOptions.user
       },
-      failedResponseHandler: (0, import_provider_utils4.createJsonErrorResponseHandler)(
+      failedResponseHandler: createJsonErrorResponseHandler3(
         (_c = this.config.errorStructure) != null ? _c : defaultOpenAICompatibleErrorStructure
       ),
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler3(
         openaiTextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -1590,15 +1597,24 @@ 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");
+import {
+  combineHeaders as combineHeaders4,
+  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  convertToFormData,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  downloadBlob,
+  postFormDataToApi,
+  postJsonToApi as postJsonToApi4
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
 var OpenAICompatibleImageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -1653,13 +1669,13 @@ var OpenAICompatibleImageModel = class {
     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, 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(this.config.headers(), headers),
+        formData: convertToFormData({
           model: this.modelId,
           prompt,
           image: await Promise.all(files.map((file) => fileToBlob(file))),
@@ -1668,10 +1684,10 @@ var OpenAICompatibleImageModel = class {
           size,
           ...args
         }),
-        failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)(
+        failedResponseHandler: createJsonErrorResponseHandler4(
           (_d = this.config.errorStructure) != null ? _d : defaultOpenAICompatibleErrorStructure
         ),
-        successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler4(
           openaiCompatibleImageResponseSchema
         ),
         abortSignal,
@@ -1687,12 +1703,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(this.config.headers(), headers),
       body: {
         model: this.modelId,
         prompt,
@@ -1701,10 +1717,10 @@ var OpenAICompatibleImageModel = class {
         ...args,
         response_format: "b64_json"
       },
-      failedResponseHandler: (0, import_provider_utils5.createJsonErrorResponseHandler)(
+      failedResponseHandler: createJsonErrorResponseHandler4(
         (_e = this.config.errorStructure) != null ? _e : defaultOpenAICompatibleErrorStructure
       ),
-      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler4(
         openaiCompatibleImageResponseSchema
       ),
       abortSignal,
@@ -1721,32 +1737,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 });
 }
 
 // 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.23" : "0.0.0-test";
+var VERSION = true ? "3.0.0-beta.24" : "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 }) => {
@@ -1785,13 +1804,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