@ai-sdk/openai-compatible 1.1.0-beta.9 → 2.0.0-beta.11

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @ai-sdk/openai-compatible
 
+## 2.0.0-beta.11
+
+### Patch Changes
+
+- 95f65c2: chore: use import \* from zod/v4
+- Updated dependencies [95f65c2]
+- Updated dependencies [95f65c2]
+  - @ai-sdk/provider-utils@4.0.0-beta.11
+
+## 2.0.0-beta.10
+
+### Major Changes
+
+- dee8b05: ai SDK 6 beta
+
+### Patch Changes
+
+- Updated dependencies [dee8b05]
+  - @ai-sdk/provider@3.0.0-beta.6
+  - @ai-sdk/provider-utils@4.0.0-beta.10
+
 ## 1.1.0-beta.9
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 import { SharedV3ProviderMetadata, LanguageModelV3, EmbeddingModelV3, ImageModelV3, ProviderV3 } from '@ai-sdk/provider';
 import { FetchFunction } from '@ai-sdk/provider-utils';
-import { z, ZodType } from 'zod/v4';
+import * as z from 'zod/v4';
+import { ZodType, z as z$1 } from 'zod/v4';
 
 type OpenAICompatibleChatModelId = string;
 declare const openaiCompatibleProviderOptions: z.ZodObject<{
@@ -9,15 +10,15 @@ declare const openaiCompatibleProviderOptions: z.ZodObject<{
 }, z.core.$strip>;
 type OpenAICompatibleProviderOptions = z.infer<typeof openaiCompatibleProviderOptions>;
 
-declare const openaiCompatibleErrorDataSchema: z.ZodObject<{
-    error: z.ZodObject<{
-        message: z.ZodString;
-        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        param: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
-        code: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-type OpenAICompatibleErrorData = z.infer<typeof openaiCompatibleErrorDataSchema>;
+declare const openaiCompatibleErrorDataSchema: z$1.ZodObject<{
+    error: z$1.ZodObject<{
+        message: z$1.ZodString;
+        type: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+        param: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodAny>>;
+        code: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber]>>>;
+    }, z$1.core.$strip>;
+}, z$1.core.$strip>;
+type OpenAICompatibleErrorData = z$1.infer<typeof openaiCompatibleErrorDataSchema>;
 type ProviderErrorStructure<T> = {
     errorSchema: ZodType<T>;
     errorToMessage: (error: T) => string;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { SharedV3ProviderMetadata, LanguageModelV3, EmbeddingModelV3, ImageModelV3, ProviderV3 } from '@ai-sdk/provider';
 import { FetchFunction } from '@ai-sdk/provider-utils';
-import { z, ZodType } from 'zod/v4';
+import * as z from 'zod/v4';
+import { ZodType, z as z$1 } from 'zod/v4';
 
 type OpenAICompatibleChatModelId = string;
 declare const openaiCompatibleProviderOptions: z.ZodObject<{
@@ -9,15 +10,15 @@ declare const openaiCompatibleProviderOptions: z.ZodObject<{
 }, z.core.$strip>;
 type OpenAICompatibleProviderOptions = z.infer<typeof openaiCompatibleProviderOptions>;
 
-declare const openaiCompatibleErrorDataSchema: z.ZodObject<{
-    error: z.ZodObject<{
-        message: z.ZodString;
-        type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        param: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
-        code: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-type OpenAICompatibleErrorData = z.infer<typeof openaiCompatibleErrorDataSchema>;
+declare const openaiCompatibleErrorDataSchema: z$1.ZodObject<{
+    error: z$1.ZodObject<{
+        message: z$1.ZodString;
+        type: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+        param: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodAny>>;
+        code: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber]>>>;
+    }, z$1.core.$strip>;
+}, z$1.core.$strip>;
+type OpenAICompatibleErrorData = z$1.infer<typeof openaiCompatibleErrorDataSchema>;
 type ProviderErrorStructure<T> = {
     errorSchema: ZodType<T>;
     errorToMessage: (error: T) => string;

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -32,7 +42,7 @@ module.exports = __toCommonJS(src_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");
+var z3 = __toESM(require("zod/v4"));
 
 // src/chat/convert-to-openai-compatible-chat-messages.ts
 var import_provider = require("@ai-sdk/provider");
@@ -190,30 +200,30 @@ function mapOpenAICompatibleFinishReason(finishReason) {
 }
 
 // src/chat/openai-compatible-chat-options.ts
-var import_v4 = require("zod/v4");
-var openaiCompatibleProviderOptions = import_v4.z.object({
+var z = __toESM(require("zod/v4"));
+var openaiCompatibleProviderOptions = z.object({
   /**
    * A unique identifier representing your end-user, which can help the provider to
    * monitor and detect abuse.
    */
-  user: import_v4.z.string().optional(),
+  user: z.string().optional(),
   /**
    * Reasoning effort for reasoning models. Defaults to `medium`.
    */
-  reasoningEffort: import_v4.z.string().optional()
+  reasoningEffort: z.string().optional()
 });
 
 // src/openai-compatible-error.ts
-var import_v42 = require("zod/v4");
-var openaiCompatibleErrorDataSchema = import_v42.z.object({
-  error: import_v42.z.object({
-    message: import_v42.z.string(),
+var import_v4 = require("zod/v4");
+var openaiCompatibleErrorDataSchema = import_v4.z.object({
+  error: import_v4.z.object({
+    message: import_v4.z.string(),
     // The additional information below is handled loosely to support
     // OpenAI-compatible providers that have slightly different error
     // responses:
-    type: import_v42.z.string().nullish(),
-    param: import_v42.z.any().nullish(),
-    code: import_v42.z.union([import_v42.z.string(), import_v42.z.number()]).nullish()
+    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()
   })
 });
 var defaultOpenAICompatibleErrorStructure = {
@@ -732,71 +742,71 @@ var OpenAICompatibleChatLanguageModel = class {
     };
   }
 };
-var openaiCompatibleTokenUsageSchema = import_v43.z.object({
-  prompt_tokens: import_v43.z.number().nullish(),
-  completion_tokens: import_v43.z.number().nullish(),
-  total_tokens: import_v43.z.number().nullish(),
-  prompt_tokens_details: import_v43.z.object({
-    cached_tokens: import_v43.z.number().nullish()
+var openaiCompatibleTokenUsageSchema = z3.object({
+  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.object({
-  id: import_v43.z.string().nullish(),
-  created: import_v43.z.number().nullish(),
-  model: import_v43.z.string().nullish(),
-  choices: import_v43.z.array(
-    import_v43.z.object({
-      message: import_v43.z.object({
-        role: import_v43.z.literal("assistant").nullish(),
-        content: import_v43.z.string().nullish(),
-        reasoning_content: import_v43.z.string().nullish(),
-        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.object({
+  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()
             })
           })
         ).nullish()
       }),
-      finish_reason: import_v43.z.string().nullish()
+      finish_reason: z3.string().nullish()
     })
   ),
   usage: openaiCompatibleTokenUsageSchema
 });
-var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v43.z.union([
-  import_v43.z.object({
-    id: import_v43.z.string().nullish(),
-    created: import_v43.z.number().nullish(),
-    model: import_v43.z.string().nullish(),
-    choices: import_v43.z.array(
-      import_v43.z.object({
-        delta: import_v43.z.object({
-          role: import_v43.z.enum(["assistant"]).nullish(),
-          content: import_v43.z.string().nullish(),
+var createOpenAICompatibleChatChunkSchema = (errorSchema) => z3.union([
+  z3.object({
+    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(),
-              id: import_v43.z.string().nullish(),
-              function: import_v43.z.object({
-                name: import_v43.z.string().nullish(),
-                arguments: import_v43.z.string().nullish()
+          reasoning_content: z3.string().nullish(),
+          reasoning: z3.string().nullish(),
+          tool_calls: z3.array(
+            z3.object({
+              index: z3.number(),
+              id: z3.string().nullish(),
+              function: z3.object({
+                name: z3.string().nullish(),
+                arguments: z3.string().nullish()
               })
             })
           ).nullish()
         }).nullish(),
-        finish_reason: import_v43.z.string().nullish()
+        finish_reason: z3.string().nullish()
       })
     ),
     usage: openaiCompatibleTokenUsageSchema
@@ -806,7 +816,7 @@ var createOpenAICompatibleChatChunkSchema = (errorSchema) => import_v43.z.union(
 
 // src/completion/openai-compatible-completion-language-model.ts
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
+var z5 = __toESM(require("zod/v4"));
 
 // src/completion/convert-to-openai-compatible-completion-prompt.ts
 var import_provider4 = require("@ai-sdk/provider");
@@ -914,28 +924,28 @@ function mapOpenAICompatibleFinishReason2(finishReason) {
 }
 
 // src/completion/openai-compatible-completion-options.ts
-var import_v44 = require("zod/v4");
-var openaiCompatibleCompletionProviderOptions = import_v44.z.object({
+var z4 = __toESM(require("zod/v4"));
+var openaiCompatibleCompletionProviderOptions = 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
@@ -1168,33 +1178,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()
@@ -1205,21 +1215,21 @@ 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");
+var z7 = __toESM(require("zod/v4"));
 
 // src/embedding/openai-compatible-embedding-options.ts
-var import_v46 = require("zod/v4");
-var openaiCompatibleEmbeddingProviderOptions = import_v46.z.object({
+var z6 = __toESM(require("zod/v4"));
+var openaiCompatibleEmbeddingProviderOptions = 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
@@ -1304,15 +1314,15 @@ 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 z8 = __toESM(require("zod/v4"));
 var OpenAICompatibleImageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -1380,15 +1390,15 @@ 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() }))
 });
 
 // src/openai-compatible-provider.ts
 var import_provider_utils6 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "1.1.0-beta.9" : "0.0.0-test";
+var VERSION = true ? "2.0.0-beta.11" : "0.0.0-test";
 
 // src/openai-compatible-provider.ts
 function createOpenAICompatible(options) {