@ai-sdk/openai-compatible 2.0.86 → 2.0.87

package/dist/internal/index.d.ts

@@ -192,9 +192,9 @@ type OpenAICompatibleChatConfig = {
      * Optional usage converter for OpenAI-compatible providers with different
      * token accounting semantics.
      */
-    convertUsage?: (usage: z.infer<typeof openaiCompatibleTokenUsageSchema>) => LanguageModelV3Usage;
+    convertUsage?: (usage: z.infer<ReturnType<typeof openaiCompatibleTokenUsageSchema>>) => LanguageModelV3Usage;
 };
-declare const openaiCompatibleTokenUsageSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+declare const openaiCompatibleTokenUsageSchema: () => z.ZodOptional<z.ZodNullable<z.ZodObject<{
     prompt_tokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     completion_tokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     total_tokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai-compatible",
-  "version": "2.0.86",
+  "version": "2.0.87",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "3.0.19",
-    "@ai-sdk/provider-utils": "4.0.61"
+    "@ai-sdk/provider-utils": "4.0.62"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/chat/openai-compatible-chat-language-model.ts

@@ -13,6 +13,8 @@ import {
   type SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   StreamingToolCallTracker,
   combineHeaders,
   createEventSourceResponseHandler,
@@ -88,7 +90,7 @@ export type OpenAICompatibleChatConfig = {
    * token accounting semantics.
    */
   convertUsage?: (
-    usage: z.infer<typeof openaiCompatibleTokenUsageSchema>,
+    usage: z.infer<ReturnType<typeof openaiCompatibleTokenUsageSchema>>,
   ) => LanguageModelV3Usage;
 };
 
@@ -137,7 +139,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
   }
 
   private convertUsage(
-    usage: z.infer<typeof openaiCompatibleTokenUsageSchema>,
+    usage: z.infer<ReturnType<typeof openaiCompatibleTokenUsageSchema>>,
   ): LanguageModelV3Usage {
     return (
       this.config.convertUsage?.(usage) ??
@@ -487,13 +489,14 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
     };
 
     let finishReason: LanguageModelV3FinishReason | undefined;
-    let usage: z.infer<typeof openaiCompatibleTokenUsageSchema> | undefined =
-      undefined;
+    let usage:
+      | z.infer<ReturnType<typeof openaiCompatibleTokenUsageSchema>>
+      | undefined = undefined;
     let isFirstChunk = true;
     let isActiveReasoning = false;
     let isActiveText = false;
     const convertUsage = (
-      usage: z.infer<typeof openaiCompatibleTokenUsageSchema>,
+      usage: z.infer<ReturnType<typeof openaiCompatibleTokenUsageSchema>>,
     ) => this.convertUsage(usage);
 
     return {
@@ -549,7 +552,9 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
 
             // TODO we lost type safety on Chunk, most likely due to the error schema. MUST FIX
             // remove this workaround when the issue is fixed
-            const value = chunk.value as z.infer<typeof chunkBaseSchema>;
+            const value = chunk.value as z.infer<
+              ReturnType<typeof chunkBaseSchema>
+            >;
 
             if (isFirstChunk) {
               isFirstChunk = false;
@@ -721,39 +726,41 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {
 }
 
 // Loose, nested objects included: the parsed value is returned as `usage.raw`.
-const openaiCompatibleTokenUsageSchema = z
-  .looseObject({
-    prompt_tokens: z.number().nullish(),
-    completion_tokens: z.number().nullish(),
-    total_tokens: z.number().nullish(),
-    prompt_tokens_details: z
-      .looseObject({
-        cached_tokens: z.number().nullish(),
-      })
-      .nullish(),
-    completion_tokens_details: z
-      .looseObject({
-        reasoning_tokens: z.number().nullish(),
-        accepted_prediction_tokens: z.number().nullish(),
-        rejected_prediction_tokens: z.number().nullish(),
-      })
-      .nullish(),
-  })
-  .nullish();
-
-const openAICompatibleContentSchema = z
-  .union([
-    z.string(),
-    z.array(
-      z.looseObject({
-        type: z.string(),
-      }),
-    ),
-  ])
-  .nullish();
+const openaiCompatibleTokenUsageSchema = () =>
+  z
+    .looseObject({
+      prompt_tokens: z.number().nullish(),
+      completion_tokens: z.number().nullish(),
+      total_tokens: z.number().nullish(),
+      prompt_tokens_details: z
+        .looseObject({
+          cached_tokens: z.number().nullish(),
+        })
+        .nullish(),
+      completion_tokens_details: z
+        .looseObject({
+          reasoning_tokens: z.number().nullish(),
+          accepted_prediction_tokens: z.number().nullish(),
+          rejected_prediction_tokens: z.number().nullish(),
+        })
+        .nullish(),
+    })
+    .nullish();
+
+const openAICompatibleContentSchema = () =>
+  z
+    .union([
+      z.string(),
+      z.array(
+        z.looseObject({
+          type: z.string(),
+        }),
+      ),
+    ])
+    .nullish();
 
 function convertOpenAICompatibleContent(
-  content: z.infer<typeof openAICompatibleContentSchema>,
+  content: z.infer<ReturnType<typeof openAICompatibleContentSchema>>,
 ): Array<Extract<LanguageModelV3Content, { type: 'text' | 'reasoning' }>> {
   if (content == null) {
     return [];
@@ -797,88 +804,93 @@ function convertOpenAICompatibleContent(
 
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const OpenAICompatibleChatResponseSchema = z.looseObject({
-  id: z.string().nullish(),
-  created: z.number().nullish(),
-  model: z.string().nullish(),
-  choices: z.array(
-    z.object({
-      message: z.object({
-        role: z.literal('assistant').nullish(),
-        content: openAICompatibleContentSchema,
-        reasoning_content: z.string().nullish(),
-        reasoning: z.string().nullish(),
-        tool_calls: z
-          .array(
-            z.object({
-              id: z.string().nullish(),
-              function: z.object({
-                name: z.string(),
-                arguments: z.string(),
-              }),
-              // Support for Google Gemini thought signatures via OpenAI compatibility
-              extra_content: z
-                .object({
-                  google: z
+const OpenAICompatibleChatResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.looseObject({
+      id: z.string().nullish(),
+      created: z.number().nullish(),
+      model: z.string().nullish(),
+      choices: z.array(
+        z.object({
+          message: z.object({
+            role: z.literal('assistant').nullish(),
+            content: openAICompatibleContentSchema(),
+            reasoning_content: z.string().nullish(),
+            reasoning: z.string().nullish(),
+            tool_calls: z
+              .array(
+                z.object({
+                  id: z.string().nullish(),
+                  function: z.object({
+                    name: z.string(),
+                    arguments: z.string(),
+                  }),
+                  // Support for Google Gemini thought signatures via OpenAI compatibility
+                  extra_content: z
                     .object({
-                      thought_signature: z.string().nullish(),
+                      google: z
+                        .object({
+                          thought_signature: z.string().nullish(),
+                        })
+                        .nullish(),
                     })
                     .nullish(),
-                })
-                .nullish(),
-            }),
-          )
-          .nullish(),
-      }),
-      finish_reason: z.string().nullish(),
-    }),
-  ),
-  usage: openaiCompatibleTokenUsageSchema,
-});
-
-const chunkBaseSchema = z.looseObject({
-  id: z.string().nullish(),
-  created: z.number().nullish(),
-  model: z.string().nullish(),
-  choices: z.array(
-    z.object({
-      delta: z
-        .object({
-          role: z.enum(['assistant', '']).nullish(),
-          content: openAICompatibleContentSchema,
-          // Most openai-compatible models set `reasoning_content`, but some
-          // providers serving `gpt-oss` set `reasoning`. See #7866
-          reasoning_content: z.string().nullish(),
-          reasoning: z.string().nullish(),
-          tool_calls: z
-            .array(
-              z.object({
-                index: z.number().nullish(), //google does not send index
-                id: z.string().nullish(),
-                function: z.object({
-                  name: z.string().nullish(),
-                  arguments: z.string().nullish(),
                 }),
-                // Support for Google Gemini thought signatures via OpenAI compatibility
-                extra_content: z
-                  .object({
-                    google: z
-                      .object({
-                        thought_signature: z.string().nullish(),
-                      })
-                      .nullish(),
-                  })
-                  .nullish(),
-              }),
-            )
-            .nullish(),
-        })
-        .nullish(),
-      finish_reason: z.string().nullish(),
+              )
+              .nullish(),
+          }),
+          finish_reason: z.string().nullish(),
+        }),
+      ),
+      usage: openaiCompatibleTokenUsageSchema(),
     }),
   ),
-  usage: openaiCompatibleTokenUsageSchema,
-});
+);
+
+const chunkBaseSchema = () =>
+  z.looseObject({
+    id: z.string().nullish(),
+    created: z.number().nullish(),
+    model: z.string().nullish(),
+    choices: z.array(
+      z.object({
+        delta: z
+          .object({
+            role: z.enum(['assistant', '']).nullish(),
+            content: openAICompatibleContentSchema(),
+            // Most openai-compatible models set `reasoning_content`, but some
+            // providers serving `gpt-oss` set `reasoning`. See #7866
+            reasoning_content: z.string().nullish(),
+            reasoning: z.string().nullish(),
+            tool_calls: z
+              .array(
+                z.object({
+                  index: z.number().nullish(), //google does not send index
+                  id: z.string().nullish(),
+                  function: z.object({
+                    name: z.string().nullish(),
+                    arguments: z.string().nullish(),
+                  }),
+                  // Support for Google Gemini thought signatures via OpenAI compatibility
+                  extra_content: z
+                    .object({
+                      google: z
+                        .object({
+                          thought_signature: z.string().nullish(),
+                        })
+                        .nullish(),
+                    })
+                    .nullish(),
+                }),
+              )
+              .nullish(),
+          })
+          .nullish(),
+        finish_reason: z.string().nullish(),
+      }),
+    ),
+    usage: openaiCompatibleTokenUsageSchema(),
+  });
 
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
@@ -886,4 +898,4 @@ const createOpenAICompatibleChatChunkSchema = <
   ERROR_SCHEMA extends z.core.$ZodType,
 >(
   errorSchema: ERROR_SCHEMA,
-) => z.union([chunkBaseSchema, errorSchema]);
+) => z.union([chunkBaseSchema(), errorSchema]);

package/src/completion/openai-compatible-completion-language-model.ts

@@ -10,6 +10,8 @@ import type {
   SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
@@ -351,26 +353,31 @@ export class OpenAICompatibleCompletionLanguageModel implements LanguageModelV3
 }
 
 // Loose: the parsed value is returned as `usage.raw`.
-const usageSchema = z.looseObject({
-  prompt_tokens: z.number(),
-  completion_tokens: z.number(),
-  total_tokens: z.number(),
-});
+const usageSchema = () =>
+  z.looseObject({
+    prompt_tokens: z.number(),
+    completion_tokens: z.number(),
+    total_tokens: z.number(),
+  });
 
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const openaiCompatibleCompletionResponseSchema = z.object({
-  id: z.string().nullish(),
-  created: z.number().nullish(),
-  model: z.string().nullish(),
-  choices: z.array(
+const openaiCompatibleCompletionResponseSchema = lazySchema(() =>
+  zodSchema(
     z.object({
-      text: z.string(),
-      finish_reason: z.string(),
+      id: z.string().nullish(),
+      created: z.number().nullish(),
+      model: z.string().nullish(),
+      choices: z.array(
+        z.object({
+          text: z.string(),
+          finish_reason: z.string(),
+        }),
+      ),
+      usage: usageSchema().nullish(),
     }),
   ),
-  usage: usageSchema.nullish(),
-});
+);
 
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
@@ -391,7 +398,7 @@ const createOpenAICompatibleCompletionChunkSchema = <
           index: z.number(),
         }),
       ),
-      usage: usageSchema.nullish(),
+      usage: usageSchema().nullish(),
     }),
     errorSchema,
   ]);

package/src/completion/openai-compatible-completion-options.ts

@@ -1,33 +1,42 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 export type OpenAICompatibleCompletionModelId = string;
 
-export const openaiCompatibleLanguageModelCompletionOptions = z.object({
-  /**
-   * Echo back the prompt in addition to the completion.
-   */
-  echo: z.boolean().optional(),
+export const openaiCompatibleLanguageModelCompletionOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * Echo back the prompt in addition to the completion.
+       */
+      echo: z.boolean().optional(),
 
-  /**
-   * Modify the likelihood of specified tokens appearing in the completion.
-   *
-   * Accepts a JSON object that maps tokens (specified by their token ID in
-   * the GPT tokenizer) to an associated bias value from -100 to 100.
-   */
-  logitBias: z.record(z.string(), z.number()).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: z.record(z.string(), z.number()).optional(),
 
-  /**
-   * The suffix that comes after a completion of inserted text.
-   */
-  suffix: z.string().optional(),
+      /**
+       * The suffix that comes after a completion of inserted text.
+       */
+      suffix: z.string().optional(),
 
-  /**
-   * A unique identifier representing your end-user, which can help providers to
-   * monitor and detect abuse.
-   */
-  user: z.string().optional(),
-});
+      /**
+       * A unique identifier representing your end-user, which can help providers to
+       * monitor and detect abuse.
+       */
+      user: z.string().optional(),
+    }),
+  ),
+);
 
-export type OpenAICompatibleLanguageModelCompletionOptions = z.infer<
+export type OpenAICompatibleLanguageModelCompletionOptions = InferSchema<
   typeof openaiCompatibleLanguageModelCompletionOptions
 >;

package/src/embedding/openai-compatible-embedding-model.ts

@@ -4,6 +4,8 @@ import {
   type SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
@@ -157,10 +159,14 @@ export class OpenAICompatibleEmbeddingModel implements EmbeddingModelV3 {
 
 // minimal version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const openaiTextEmbeddingResponseSchema = z.object({
-  data: z.array(z.object({ embedding: z.array(z.number()) })),
-  usage: z.object({ prompt_tokens: z.number() }).nullish(),
-  providerMetadata: z
-    .record(z.string(), z.record(z.string(), z.any()))
-    .optional(),
-});
+const openaiTextEmbeddingResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      data: z.array(z.object({ embedding: z.array(z.number()) })),
+      usage: z.object({ prompt_tokens: z.number() }).nullish(),
+      providerMetadata: z
+        .record(z.string(), z.record(z.string(), z.any()))
+        .optional(),
+    }),
+  ),
+);

package/src/embedding/openai-compatible-embedding-options.ts

@@ -1,21 +1,30 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 export type OpenAICompatibleEmbeddingModelId = string;
 
-export const openaiCompatibleEmbeddingModelOptions = z.object({
-  /**
-   * The number of dimensions the resulting output embeddings should have.
-   * Only supported in text-embedding-3 and later models.
-   */
-  dimensions: z.number().optional(),
+export const openaiCompatibleEmbeddingModelOptions = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * The number of dimensions the resulting output embeddings should have.
+       * Only supported in text-embedding-3 and later models.
+       */
+      dimensions: z.number().optional(),
 
-  /**
-   * A unique identifier representing your end-user, which can help providers to
-   * monitor and detect abuse.
-   */
-  user: z.string().optional(),
-});
+      /**
+       * A unique identifier representing your end-user, which can help providers to
+       * monitor and detect abuse.
+       */
+      user: z.string().optional(),
+    }),
+  ),
+);
 
-export type OpenAICompatibleEmbeddingModelOptions = z.infer<
+export type OpenAICompatibleEmbeddingModelOptions = InferSchema<
   typeof openaiCompatibleEmbeddingModelOptions
 >;

package/src/image/openai-compatible-image-model.ts

@@ -7,6 +7,9 @@ import {
 } from '@ai-sdk/provider';
 import { toCamelCase } from '../utils/to-camel-case';
 import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
   combineHeaders,
   convertBase64ToUint8Array,
   convertToFormData,
@@ -184,7 +187,7 @@ export class OpenAICompatibleImageModel implements ImageModelV3 {
   }
 
   private async getImages(
-    data: z.infer<typeof openaiCompatibleImageResponseSchema>['data'],
+    data: InferSchema<typeof openaiCompatibleImageResponseSchema>['data'],
     options: {
       url: string;
       headers: Record<string, string | undefined>;
@@ -228,18 +231,22 @@ export class OpenAICompatibleImageModel implements ImageModelV3 {
 
 // minimal version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const openaiCompatibleImageResponseSchema = z.object({
-  data: z.array(
-    z
-      .object({
-        b64_json: z.string().nullish(),
-        url: z.string().nullish(),
-      })
-      .refine(image => image.b64_json != null || image.url != null, {
-        message: 'Expected b64_json or url in the image response',
-      }),
+const openaiCompatibleImageResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      data: z.array(
+        z
+          .object({
+            b64_json: z.string().nullish(),
+            url: z.string().nullish(),
+          })
+          .refine(image => image.b64_json != null || image.url != null, {
+            message: 'Expected b64_json or url in the image response',
+          }),
+      ),
+    }),
   ),
-});
+);
 
 type OpenAICompatibleFormDataInput = {
   model: string;