@ai-sdk/openai 4.0.110 → 4.0.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/openai",
-  "version": "4.0.110",
+  "version": "4.0.111",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.36",
-    "@ai-sdk/provider-utils": "5.0.75"
+    "@ai-sdk/provider": "4.0.37",
+    "@ai-sdk/provider-utils": "5.0.76"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

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

@@ -19,8 +19,8 @@ import {
   createJsonResponseHandler,
   generateId,
   isCustomReasoning,
-  parseProviderOptions,
   postJsonToApi,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
@@ -123,13 +123,20 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
   }: LanguageModelV4CallOptions) {
     const warnings: SharedV4Warning[] = [];
 
-    // Parse provider options
+    // `openai` and the Azure key are merged; the Azure key wins (like Azure
+    // completion models).
+    const providerOptionsNames = this.config.provider.includes('azure')
+      ? (['openai', 'azure'] as const)
+      : (['openai'] as const);
     const openaiOptions =
-      (await parseProviderOptions({
-        provider: 'openai',
-        providerOptions,
-        schema: openaiLanguageModelChatOptions,
-      })) ?? {};
+      (
+        await resolveProviderOptions({
+          providerOptions,
+          namespaces: providerOptionsNames,
+          resolution: 'merge',
+          schema: openaiLanguageModelChatOptions,
+        })
+      ).options ?? {};
 
     const {
       capabilities: { language: modelCapabilities },
@@ -178,7 +185,11 @@ export class OpenAIChatLanguageModel implements LanguageModelV4 {
 
     // reasoningSummary is a Responses API option that the chat options schema strips,
     // so check the raw provider options to avoid silently ignoring it:
-    if (providerOptions?.openai?.reasoningSummary != null) {
+    if (
+      providerOptionsNames.some(
+        name => providerOptions?.[name]?.reasoningSummary != null,
+      )
+    ) {
       warnings.push({
         type: 'unsupported',
         feature: 'reasoningSummary',

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

@@ -14,8 +14,8 @@ import {
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
-  parseProviderOptions,
   postJsonToApi,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
@@ -111,18 +111,16 @@ export class OpenAICompletionLanguageModel implements LanguageModelV4 {
     const warnings: SharedV4Warning[] = [];
 
     // Parse provider options
-    const openaiOptions = {
-      ...(await parseProviderOptions({
-        provider: 'openai',
-        providerOptions,
-        schema: openaiLanguageModelCompletionOptions,
-      })),
-      ...(await parseProviderOptions({
-        provider: this.providerOptionsName,
-        providerOptions,
-        schema: openaiLanguageModelCompletionOptions,
-      })),
-    };
+    // `openai` and the provider key are merged; the provider key wins.
+    const openaiOptions =
+      (
+        await resolveProviderOptions({
+          providerOptions,
+          namespaces: ['openai', this.providerOptionsName],
+          resolution: 'merge',
+          schema: openaiLanguageModelCompletionOptions,
+        })
+      ).options ?? {};
 
     if (topK != null) {
       warnings.push({ type: 'unsupported', feature: 'topK' });

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

@@ -100,71 +100,82 @@ export type OpenAIImageModelOptions = InferSchema<
   typeof openaiImageModelOptions
 >;
 
+/**
+ * Shape of the OpenAI image generation options. Exported so that routers
+ * that also call the OpenAI image API (e.g. Azure) can accept these options
+ * under their own providerOptions key.
+ */
+export const openaiImageModelGenerationOptionsShape = () =>
+  baseImageModelOptionsObject().extend({
+    /**
+     * Style of the generated image. `vivid` produces hyper-real and
+     * dramatic images; `natural` produces more subdued, less hyper-real
+     * looking images.
+     */
+    style: z.enum(['vivid', 'natural']).optional(),
+
+    /**
+     * Format in which the generated image(s) are returned. `gif` produces
+     * an animated GIF and is supported by GPT Image 2.6 models.
+     */
+    outputFormat: z.enum(['png', 'jpeg', 'webp', 'gif']).optional(),
+
+    /**
+     * Number of frames (2-64) of an animated GIF. Only applies to the `gif`
+     * output format. The API defaults to 9.
+     */
+    frameCount: z.number().int().min(2).max(64).optional(),
+
+    /**
+     * Duration of each frame in milliseconds (20-2000) of an animated GIF.
+     * The API rounds it to the nearest 10 ms. Only applies to the `gif`
+     * output format. The API defaults to 200.
+     */
+    frameDurationMs: z.number().int().min(20).max(2000).optional(),
+
+    /**
+     * Content moderation level for the generated image(s). `low` applies
+     * less restrictive filtering.
+     */
+    moderation: z.enum(['auto', 'low']).optional(),
+  }).shape;
+
 export const openaiImageModelGenerationOptions = lazySchema(() =>
-  zodSchema(
-    baseImageModelOptionsObject().extend({
-      /**
-       * Style of the generated image. `vivid` produces hyper-real and
-       * dramatic images; `natural` produces more subdued, less hyper-real
-       * looking images.
-       */
-      style: z.enum(['vivid', 'natural']).optional(),
-
-      /**
-       * Format in which the generated image(s) are returned. `gif` produces
-       * an animated GIF and is supported by GPT Image 2.6 models.
-       */
-      outputFormat: z.enum(['png', 'jpeg', 'webp', 'gif']).optional(),
-
-      /**
-       * Number of frames (2-64) of an animated GIF. Only applies to the `gif`
-       * output format. The API defaults to 9.
-       */
-      frameCount: z.number().int().min(2).max(64).optional(),
-
-      /**
-       * Duration of each frame in milliseconds (20-2000) of an animated GIF.
-       * The API rounds it to the nearest 10 ms. Only applies to the `gif`
-       * output format. The API defaults to 200.
-       */
-      frameDurationMs: z.number().int().min(20).max(2000).optional(),
-
-      /**
-       * Content moderation level for the generated image(s). `low` applies
-       * less restrictive filtering.
-       */
-      moderation: z.enum(['auto', 'low']).optional(),
-    }),
-  ),
+  zodSchema(z.object(openaiImageModelGenerationOptionsShape())),
 );
 
 export type OpenAIImageModelGenerationOptions = InferSchema<
   typeof openaiImageModelGenerationOptions
 >;
 
+/**
+ * Shape of the OpenAI image edit options. Exported so that routers can accept
+ * these options under their own providerOptions key.
+ */
+export const openaiImageModelEditOptionsShape = () =>
+  baseImageModelOptionsObject().extend({
+    /**
+     * Fidelity of the output image(s) to the input image(s).
+     */
+    inputFidelity: z.enum(['high', 'low']).optional(),
+
+    /**
+     * A transparent PNG overlaid on the first input image to mark up the
+     * regions to change, as an HTTPS URL or a base64 data URL. It must match
+     * the dimensions of the first image. Supported by GPT Image 2.5 and 2.6
+     * models. Cannot be combined with a `mask`.
+     */
+    markup: z.string().optional(),
+
+    /**
+     * Content moderation level for the edited image(s). `low` applies
+     * less restrictive filtering. Supported by GPT Image models.
+     */
+    moderation: z.enum(['auto', 'low']).optional(),
+  }).shape;
+
 export const openaiImageModelEditOptions = lazySchema(() =>
-  zodSchema(
-    baseImageModelOptionsObject().extend({
-      /**
-       * Fidelity of the output image(s) to the input image(s).
-       */
-      inputFidelity: z.enum(['high', 'low']).optional(),
-
-      /**
-       * A transparent PNG overlaid on the first input image to mark up the
-       * regions to change, as an HTTPS URL or a base64 data URL. It must match
-       * the dimensions of the first image. Supported by GPT Image 2.5 and 2.6
-       * models. Cannot be combined with a `mask`.
-       */
-      markup: z.string().optional(),
-
-      /**
-       * Content moderation level for the edited image(s). `low` applies
-       * less restrictive filtering. Supported by GPT Image models.
-       */
-      moderation: z.enum(['auto', 'low']).optional(),
-    }),
-  ),
+  zodSchema(z.object(openaiImageModelEditOptionsShape())),
 );
 
 export type OpenAIImageModelEditOptions = InferSchema<

package/src/responses/openai-responses-language-model.ts

@@ -23,8 +23,8 @@ import {
   createJsonResponseHandler,
   createToolNameMapping,
   generateId,
-  parseProviderOptions,
   postJsonToApi,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_DESERIALIZE,
   WORKFLOW_SERIALIZE,
@@ -331,20 +331,15 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     const providerOptionsName = config.provider.includes('azure')
       ? 'azure'
       : 'openai';
-    let openaiOptions = await parseProviderOptions({
-      provider: providerOptionsName,
+    // The provider key (`azure`) and `openai` are alternatives: the first
+    // present one is used as a whole.
+    const { options: openaiOptions } = await resolveProviderOptions({
       providerOptions,
+      namespaces: [providerOptionsName, 'openai'],
+      resolution: 'first',
       schema: openaiLanguageModelResponsesOptionsSchema,
     });
 
-    if (openaiOptions == null && providerOptionsName !== 'openai') {
-      openaiOptions = await parseProviderOptions({
-        provider: 'openai',
-        providerOptions,
-        schema: openaiLanguageModelResponsesOptionsSchema,
-      });
-    }
-
     const resolvedReasoningEffort = resolveOpenAIReasoningEffort({
       providerReasoningEffort: openaiOptions?.reasoningEffort,
       reasoning,

package/src/speech/openai-speech-model-options.ts

@@ -16,13 +16,18 @@ export type OpenAISpeechModelId =
   | (string & {});
 
 // https://platform.openai.com/docs/api-reference/audio/createSpeech
+/**
+ * Shape of the OpenAI speech model options. Exported so that routers that
+ * also call the OpenAI speech API (e.g. Azure) can accept these options under
+ * their own providerOptions key.
+ */
+export const openaiSpeechModelOptionsShape = () => ({
+  instructions: z.string().nullish(),
+  speed: z.number().min(0.25).max(4.0).nullish(),
+});
+
 export const openaiSpeechModelOptionsSchema = lazySchema(() =>
-  zodSchema(
-    z.object({
-      instructions: z.string().nullish(),
-      speed: z.number().min(0.25).max(4.0).nullish(),
-    }),
-  ),
+  zodSchema(z.object(openaiSpeechModelOptionsShape())),
 );
 
 export type OpenAISpeechModelOptions = InferSchema<

package/src/transcription/openai-transcription-model-options.ts

@@ -18,91 +18,92 @@ export type OpenAITranscriptionModelId =
   | (string & {});
 
 // https://platform.openai.com/docs/api-reference/audio/createTranscription
-export const openAITranscriptionModelOptions = lazySchema(() =>
-  zodSchema(
-    z.object({
-      /**
-       * Additional information to include in the transcription response.
-       */
+/**
+ * Shape of the OpenAI transcription model options. Exported so that routers
+ * that also call the OpenAI transcription API (e.g. Azure) can accept these
+ * options under their own providerOptions key.
+ */
+export const openAITranscriptionModelOptionsShape = () => ({
+  /**
+   * Additional information to include in the transcription response.
+   */
 
-      include: z.array(z.string()).optional(),
+  include: z.array(z.string()).optional(),
 
-      /**
-       * The language of the input audio in ISO-639-1 format.
-       */
-      language: z.string().optional(),
+  /**
+   * The language of the input audio in ISO-639-1 format.
+   */
+  language: z.string().optional(),
 
-      /**
-       * Expected languages for REST transcription, e.g. with gpt-transcribe.
-       * Use this instead of language. The API validates model support.
-       */
-      languages: z.array(z.string()).optional(),
+  /**
+   * Expected languages for REST transcription, e.g. with gpt-transcribe.
+   * Use this instead of language. The API validates model support.
+   */
+  languages: z.array(z.string()).optional(),
 
-      /**
-       * Vocabulary hints for REST transcription, e.g. names or technical terms.
-       * The API validates model support.
-       */
-      keywords: z.array(z.string()).optional(),
+  /**
+   * Vocabulary hints for REST transcription, e.g. names or technical terms.
+   * The API validates model support.
+   */
+  keywords: z.array(z.string()).optional(),
 
-      /**
-       * An optional text to guide the model's style or continue a previous audio segment.
-       */
-      prompt: z.string().optional(),
+  /**
+   * An optional text to guide the model's style or continue a previous audio segment.
+   */
+  prompt: z.string().optional(),
 
-      /**
-       * The sampling temperature, between 0 and 1.
-       * @default 0
-       */
-      temperature: z.number().min(0).max(1).default(0).optional(),
+  /**
+   * The sampling temperature, between 0 and 1.
+   * @default 0
+   */
+  temperature: z.number().min(0).max(1).default(0).optional(),
 
-      /**
-       * The timestamp granularities to populate for this transcription.
-       * Defaults to ['segment'] when the response format is verbose_json.
-       */
-      timestampGranularities: z.array(z.enum(['word', 'segment'])).optional(),
+  /**
+   * The timestamp granularities to populate for this transcription.
+   * Defaults to ['segment'] when the response format is verbose_json.
+   */
+  timestampGranularities: z.array(z.enum(['word', 'segment'])).optional(),
 
-      /**
-       * The format of the transcription response.
-       */
-      responseFormat: z
-        .enum(['json', 'verbose_json', 'diarized_json'])
-        .optional(),
+  /**
+   * The format of the transcription response.
+   */
+  responseFormat: z.enum(['json', 'verbose_json', 'diarized_json']).optional(),
+
+  /**
+   * Controls how the audio is split into chunks before transcription.
+   */
+  chunkingStrategy: z
+    .union([
+      z.literal('auto'),
+      z.object({
+        type: z.literal('server_vad'),
+        threshold: z.number().min(0).max(1).optional(),
+        prefixPaddingMs: z.number().int().min(0).optional(),
+        silenceDurationMs: z.number().int().min(0).optional(),
+      }),
+    ])
+    .optional(),
 
+  /**
+   * Options for streaming transcription models such as `gpt-live-transcribe`.
+   */
+  streaming: z
+    .object({
       /**
-       * Controls how the audio is split into chunks before transcription.
+       * Latency/accuracy tradeoff for realtime transcription.
        */
-      chunkingStrategy: z
-        .union([
-          z.literal('auto'),
-          z.object({
-            type: z.literal('server_vad'),
-            threshold: z.number().min(0).max(1).optional(),
-            prefixPaddingMs: z.number().int().min(0).optional(),
-            silenceDurationMs: z.number().int().min(0).optional(),
-          }),
-        ])
-        .optional(),
+      delay: z.enum(['minimal', 'low', 'medium', 'high', 'xhigh']).optional(),
 
       /**
-       * Options for streaming transcription models such as `gpt-live-transcribe`.
+       * Additional fields to include in realtime transcription events.
        */
-      streaming: z
-        .object({
-          /**
-           * Latency/accuracy tradeoff for realtime transcription.
-           */
-          delay: z
-            .enum(['minimal', 'low', 'medium', 'high', 'xhigh'])
-            .optional(),
+      include: z.array(z.string()).optional(),
+    })
+    .optional(),
+});
 
-          /**
-           * Additional fields to include in realtime transcription events.
-           */
-          include: z.array(z.string()).optional(),
-        })
-        .optional(),
-    }),
-  ),
+export const openAITranscriptionModelOptions = lazySchema(() =>
+  zodSchema(z.object(openAITranscriptionModelOptionsShape())),
 );
 
 export type OpenAITranscriptionModelOptions = InferSchema<