@ai-sdk/openai-compatible 3.0.74 → 3.0.76

package/dist/internal/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/chat/openai-compatible-api-types.ts","../../src/chat/convert-to-openai-compatible-chat-messages.ts","../../src/chat/convert-openai-compatible-chat-usage.ts","../../src/chat/map-openai-compatible-finish-reason.ts","../../src/chat/get-response-metadata.ts","../../src/chat/openai-compatible-prepare-tools.ts","../../src/openai-compatible-error.ts","../../src/chat/openai-compatible-metadata-extractor.ts","../../src/chat/openai-compatible-chat-language-model.ts"],"mappings":";;;;KAEY,6BAA6B,MAAM;KAEnC,0BACR,gCACA,8BACA,mCACA;KAIC,WAAW,aAAa,eAE3B,YAAY,cAAc,IAAI;UAGf,sCAAsC;EACrD;EACA;;UAGe,oCAAoC,WAAW;EAC9D;EACA,kBAAkB,MAAM;;KAGd,8BACR,kCACA,mCACA,mCACA,wCACA;UAEa,wCAAwC;EACvD;EACA;;UAGe,yCAAyC;EACxD;EACA;IAAa;;;UAIE,yCAAyC;EACxD;EACA;IAAa;;;UAIE,8CAA8C;EAC7D;EACA;IAAe;IAAc;;;UAGd,wCAAwC;EACvD;EACA;IAAQ;IAAkB;;IAAwB;;;UAGnC,yCAAyC,WAAW;EACnE;EACA;EACA;EACA,aAAa,MAAM;;UAGJ,wCAAwC;EACvD;EACA;EACA;IACE;IACA;;;;;;EAMF;IACE;MACE;;;;UAKW,oCAAoC;EACnD;EACA,kBAAkB,MAAM;EACxB;;;;wBCmGc,sCACd,QAAQ,yBAEN,UACA,oBACA;EAEA;EACA;EACA;IAED;;;wBCpMa,iCACd;EAEM;EACA;EACA;IACE;;EAEF;IACE;;uBAKP;;;wBCfa,gCACd,0CACC;;;wBCFa,sBACd,IACA,OACA;EAEA;EACA;EACA;+BACD;;;wBCLe,eACd,OACA;EAEA,OAAO;EACP,aAAa;;EAEb,mBAEI;IACE;IACA;MACE;MACA;MACA;MACA;;;EAGR;IACM;IAAkB;MAAY;;;EAKpC,cAAc;;;;KCXJ,uBAAuB;EACjC,aAAa,QAAQ;EACrB,iBAAiB,OAAO;EACxB,eAAe,UAAU,UAAU,QAAQ;;;;;;;;;KCdjC;;;;;;;;;EASV,oBACE;IAEA;QACI,QAAQ;;;;;;;;EASd;;;;;;;IAOE,aAAa;;;;;;;;IASb,iBAAiB;;;;;KCgBT;EACV;EACA,gBAAgB;EAChB,MAAM;IAAW;IAAiB;;EAClC,QAAQ;EACR;EACA,iBAAiB;EACjB,oBAAoB;;;;EAKpB;;;;EAKA;;;;EAKA,sBAAsB;;;;;;;EAQtB,wBACE,MAAM,qBACN,WAAW,sBACR;;;;;EAML,gBACE,OAAO,EAAE,aAAa,sCACnB;;cA8qBD,kCAAgC,EAAA,YAAA,EAAA,YAAA,EAAA;;;;;;;;;;;;GAkB1B,EAAA,KAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/chat/openai-compatible-api-types.ts","../../src/chat/convert-to-openai-compatible-chat-messages.ts","../../src/chat/convert-openai-compatible-chat-usage.ts","../../src/chat/map-openai-compatible-finish-reason.ts","../../src/chat/get-response-metadata.ts","../../src/chat/openai-compatible-prepare-tools.ts","../../src/openai-compatible-error.ts","../../src/chat/openai-compatible-metadata-extractor.ts","../../src/chat/openai-compatible-chat-language-model.ts"],"mappings":";;;;KAEY,6BAA6B,MAAM;KAEnC,0BACR,gCACA,8BACA,mCACA;KAIC,WAAW,aAAa,eAE3B,YAAY,cAAc,IAAI;UAGf,sCAAsC;EACrD;EACA;;UAGe,oCAAoC,WAAW;EAC9D;EACA,kBAAkB,MAAM;;KAGd,8BACR,kCACA,mCACA,mCACA,wCACA;UAEa,wCAAwC;EACvD;EACA;;UAGe,yCAAyC;EACxD;EACA;IAAa;;;UAIE,yCAAyC;EACxD;EACA;IAAa;;;UAIE,8CAA8C;EAC7D;EACA;IAAe;IAAc;;;UAGd,wCAAwC;EACvD;EACA;IAAQ;IAAkB;;IAAwB;;;UAGnC,yCAAyC,WAAW;EACnE;EACA;EACA;EACA,aAAa,MAAM;;UAGJ,wCAAwC;EACvD;EACA;EACA;IACE;IACA;;;;;;EAMF;IACE;MACE;;;;UAKW,oCAAoC;EACnD;EACA,kBAAkB,MAAM;EACxB;;;;wBCmGc,sCACd,QAAQ,yBAEN,UACA,oBACA;EAEA;EACA;EACA;IAED;;;wBCpMa,iCACd;EAEM;EACA;EACA;IACE;;EAEF;IACE;;uBAKP;;;wBCfa,gCACd,0CACC;;;wBCFa,sBACd,IACA,OACA;EAEA;EACA;EACA;+BACD;;;wBCLe,eACd,OACA;EAEA,OAAO;EACP,aAAa;;EAEb,mBAEI;IACE;IACA;MACE;MACA;MACA;MACA;;;EAGR;IACM;IAAkB;MAAY;;;EAKpC,cAAc;;;;KCXJ,uBAAuB;EACjC,aAAa,QAAQ;EACrB,iBAAiB,OAAO;EACxB,eAAe,UAAU,UAAU,QAAQ;;;;;;;;;KCdjC;;;;;;;;;EASV,oBACE;IAEA;QACI,QAAQ;;;;;;;;EASd;;;;;;;IAOE,aAAa;;;;;;;;IASb,iBAAiB;;;;;KCkBT;EACV;EACA,gBAAgB;EAChB,MAAM;IAAW;IAAiB;;EAClC,QAAQ;EACR;EACA,iBAAiB;EACjB,oBAAoB;;;;EAKpB;;;;EAKA;;;;EAKA,sBAAsB;;;;;;;EAQtB,wBACE,MAAM,qBACN,WAAW,sBACR;;;;;EAML,gBACE,OAAO,EAAE,MAAM,kBAAkB,uCAC9B;;cAirBD,wCAAgC,EAAA,YAAA,EAAA,YAAA,EAAA;;;;;;;;;;;;GAmBxB,EAAA,KAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai-compatible",
-  "version": "3.0.74",
+  "version": "3.0.76",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.31",
-    "@ai-sdk/provider-utils": "5.0.64"
+    "@ai-sdk/provider": "4.0.32",
+    "@ai-sdk/provider-utils": "5.0.66"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

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

@@ -13,6 +13,8 @@ import {
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
@@ -99,7 +101,7 @@ export type OpenAICompatibleChatConfig = {
    * token accounting semantics.
    */
   convertUsage?: (
-    usage: z.infer<typeof openaiCompatibleTokenUsageSchema>,
+    usage: z.infer<ReturnType<typeof openaiCompatibleTokenUsageSchema>>,
   ) => LanguageModelV4Usage;
 };
 
@@ -174,7 +176,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV4 {
   }
 
   private convertUsage(
-    usage: z.infer<typeof openaiCompatibleTokenUsageSchema>,
+    usage: z.infer<ReturnType<typeof openaiCompatibleTokenUsageSchema>>,
   ): LanguageModelV4Usage {
     return (
       this.config.convertUsage?.(usage) ??
@@ -546,13 +548,14 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV4 {
     };
 
     let finishReason: LanguageModelV4FinishReason | undefined;
-    let usage: z.infer<typeof openaiCompatibleTokenUsageSchema> | undefined =
-      undefined;
+    let usage:
+      | z.infer<ReturnType<typeof openaiCompatibleTokenUsageSchema>>
+      | undefined = undefined;
     let metadataExtracted = false;
     let isActiveReasoning = false;
     let isActiveText = false;
     const convertUsage = (
-      usage: z.infer<typeof openaiCompatibleTokenUsageSchema>,
+      usage: z.infer<ReturnType<typeof openaiCompatibleTokenUsageSchema>>,
     ) => this.convertUsage(usage);
 
     return {
@@ -608,7 +611,9 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV4 {
 
             // 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>
+            >;
 
             // Extract and emit response metadata once. Usually it comes in the
             // first chunk, but some providers prepend a placeholder chunk with
@@ -786,39 +791,41 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV4 {
 }
 
 // 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<LanguageModelV4Content, { type: 'text' | 'reasoning' }>> {
   if (content == null) {
     return [];
@@ -862,88 +869,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
@@ -951,4 +963,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-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/completion/openai-compatible-completion-language-model.ts

@@ -10,6 +10,8 @@ import type {
   SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonErrorResponseHandler,
@@ -380,26 +382,31 @@ export class OpenAICompatibleCompletionLanguageModel implements LanguageModelV4
 }
 
 // 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
@@ -420,7 +427,7 @@ const createOpenAICompatibleCompletionChunkSchema = <
           index: z.number(),
         }),
       ),
-      usage: usageSchema.nullish(),
+      usage: usageSchema().nullish(),
     }),
     errorSchema,
   ]);

package/src/embedding/openai-compatible-embedding-model-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/embedding/openai-compatible-embedding-model.ts

@@ -4,6 +4,8 @@ import {
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
+  lazySchema,
+  zodSchema,
   combineHeaders,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
@@ -184,10 +186,14 @@ export class OpenAICompatibleEmbeddingModel implements EmbeddingModelV4 {
 
 // 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/image/openai-compatible-image-model-options.ts

@@ -1,3 +1,8 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 /**
@@ -5,41 +10,45 @@ import { z } from 'zod/v4';
  *
  * Additional provider-specific options are passed through to the API.
  */
-export const openaiCompatibleImageModelOptions = z.looseObject({
-  /**
-   * Dimensions of the generated image.
-   *
-   * Supported values depend on the provider and model.
-   */
-  size: z.string().optional(),
+export const openaiCompatibleImageModelOptions = lazySchema(() =>
+  zodSchema(
+    z.looseObject({
+      /**
+       * Dimensions of the generated image.
+       *
+       * Supported values depend on the provider and model.
+       */
+      size: z.string().optional(),
 
-  /**
-   * Quality of the generated image.
-   *
-   * Supported values depend on the provider and model.
-   */
-  quality: z.string().optional(),
+      /**
+       * Quality of the generated image.
+       *
+       * Supported values depend on the provider and model.
+       */
+      quality: z.string().optional(),
 
-  /**
-   * File format of the generated image.
-   *
-   * Supported values depend on the provider and model.
-   */
-  output_format: z.string().optional(),
+      /**
+       * File format of the generated image.
+       *
+       * Supported values depend on the provider and model.
+       */
+      output_format: z.string().optional(),
 
-  /**
-   * Compression level for JPEG and WebP images.
-   */
-  output_compression: z.number().min(0).max(100).optional(),
+      /**
+       * Compression level for JPEG and WebP images.
+       */
+      output_compression: z.number().min(0).max(100).optional(),
 
-  /**
-   * Background behavior for the generated image.
-   *
-   * Supported values depend on the provider and model.
-   */
-  background: z.string().optional(),
-});
+      /**
+       * Background behavior for the generated image.
+       *
+       * Supported values depend on the provider and model.
+       */
+      background: z.string().optional(),
+    }),
+  ),
+);
 
-export type OpenAICompatibleImageModelOptions = z.infer<
+export type OpenAICompatibleImageModelOptions = InferSchema<
   typeof openaiCompatibleImageModelOptions
 >;