@ai-sdk/openai 4.0.105 → 4.0.107

package/src/openai-provider.ts

@@ -12,6 +12,8 @@ import type {
   Experimental_SpeechTranslationModelV4 as SpeechTranslationModelV4,
 } from '@ai-sdk/provider';
 import {
+  type Resolvable,
+  resolveWith,
   loadApiKey,
   loadOptionalSetting,
   validateBaseURL,
@@ -175,8 +177,9 @@ export interface OpenAIProviderSettings {
 
   /**
    * API key for authenticating requests.
+   * A function is called before each request and may return a promise.
    */
-  apiKey?: string;
+  apiKey?: Resolvable<string>;
 
   /**
    * OpenAI Organization.
@@ -230,18 +233,20 @@ export function createOpenAI(
   const providerName = options.name ?? 'openai';
 
   const getHeaders = () =>
-    withUserAgentSuffix(
-      {
-        Authorization: `Bearer ${loadApiKey({
-          apiKey: options.apiKey,
-          environmentVariableName: 'OPENAI_API_KEY',
-          description: 'OpenAI',
-        })}`,
-        'OpenAI-Organization': options.organization,
-        'OpenAI-Project': options.project,
-        ...options.headers,
-      },
-      `ai-sdk-openai/${VERSION}`,
+    resolveWith(options.apiKey, apiKey =>
+      withUserAgentSuffix(
+        {
+          Authorization: `Bearer ${loadApiKey({
+            apiKey,
+            environmentVariableName: 'OPENAI_API_KEY',
+            description: 'OpenAI',
+          })}`,
+          'OpenAI-Organization': options.organization,
+          'OpenAI-Project': options.project,
+          ...options.headers,
+        },
+        `ai-sdk-openai/${VERSION}`,
+      ),
     );
 
   const createChatModel = (modelId: OpenAIChatModelId) =>

package/src/realtime/openai-realtime-factory.ts

@@ -5,13 +5,15 @@ import {
   type Experimental_RealtimeModelV4 as RealtimeModelV4,
 } from '@ai-sdk/provider';
 import { OpenAIRealtimeModelLive } from '../live/openai-realtime-model-live';
+import {
+  getOpenAIRealtimeModelEntry,
+  type OpenAIKnownLiveModelId,
+} from '../openai-model-catalog';
 import {
   OpenAIRealtimeModel,
   type OpenAIRealtimeModelConfig,
 } from './openai-realtime-model';
 
-const knownLiveModelIds = ['gpt-live-1'] as const;
-
 export type OpenAIRealtimeOptions = {
   /** Overrides model ID routing, including for early-access models. */
   api?: 'live' | 'realtime';
@@ -21,7 +23,7 @@ export interface OpenAIRealtimeFactory extends RealtimeFactoryV4 {
   (modelId: string, options: { api: 'live' }): OpenAIRealtimeModelLive;
   (modelId: string, options: { api: 'realtime' }): OpenAIRealtimeModel;
   (
-    modelId: (typeof knownLiveModelIds)[number],
+    modelId: OpenAIKnownLiveModelId,
     options?: { api?: undefined },
   ): OpenAIRealtimeModelLive;
   (modelId: string, options?: OpenAIRealtimeOptions): RealtimeModelV4;
@@ -46,9 +48,7 @@ function resolveRealtimeApi(
     return api;
   }
 
-  return knownLiveModelIds.some(knownModelId => knownModelId === modelId)
-    ? 'live'
-    : 'realtime';
+  return getOpenAIRealtimeModelEntry(modelId).requestConfig.realtime.api;
 }
 
 export function createOpenAIRealtimeFactory(

package/src/realtime/openai-realtime-model.ts

@@ -1,3 +1,8 @@
+import {
+  type Resolvable,
+  resolve,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
 import type {
   Experimental_RealtimeModelV4 as RealtimeModelV4,
   Experimental_RealtimeModelV4ClientEvent as RealtimeModelV4ClientEvent,
@@ -6,7 +11,6 @@ import type {
   Experimental_RealtimeModelV4ServerEvent as RealtimeModelV4ServerEvent,
   Experimental_RealtimeModelV4SessionConfig as RealtimeModelV4SessionConfig,
 } from '@ai-sdk/provider';
-import type { FetchFunction } from '@ai-sdk/provider-utils';
 import {
   buildOpenAISessionConfig,
   parseOpenAIRealtimeServerEvent,
@@ -16,7 +20,7 @@ import {
 export type OpenAIRealtimeModelConfig = {
   provider: string;
   baseURL: string;
-  headers: () => Record<string, string | undefined>;
+  headers: Resolvable<Record<string, string | undefined>>;
   fetch?: FetchFunction;
 };
 
@@ -47,7 +51,7 @@ export class OpenAIRealtimeModel implements RealtimeModelV4 {
     const response = await fetchFn(url, {
       method: 'POST',
       headers: {
-        ...this.config.headers(),
+        ...(await resolve(this.config.headers)),
         'Content-Type': 'application/json',
       },
       body: JSON.stringify({

package/src/resolve-openai-reasoning-effort.ts

@@ -0,0 +1,45 @@
+import type {
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
+} from '@ai-sdk/provider';
+import { mapReasoningToProviderEffort } from '@ai-sdk/provider-utils';
+
+type OpenAIReasoningEffort = Exclude<
+  LanguageModelV4CallOptions['reasoning'],
+  'provider-default' | undefined
+>;
+
+const allOpenAIReasoningEfforts: readonly OpenAIReasoningEffort[] = [
+  'none',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+  'max',
+];
+
+/** Resolve portable reasoning against the efforts declared by the catalog. */
+export function resolveOpenAIReasoningEffort({
+  providerReasoningEffort,
+  reasoning,
+  supportedReasoningEfforts,
+  warnings,
+}: {
+  providerReasoningEffort: string | null | undefined;
+  reasoning: LanguageModelV4CallOptions['reasoning'];
+  supportedReasoningEfforts: readonly string[] | undefined;
+  warnings: SharedV4Warning[];
+}): string | undefined {
+  return mapReasoningToProviderEffort({
+    reasoning,
+    providerOptionsEffort: providerReasoningEffort,
+    effortMap: Object.fromEntries(
+      (supportedReasoningEfforts ?? allOpenAIReasoningEfforts).map(effort => [
+        effort,
+        effort,
+      ]),
+    ),
+    warnings,
+  });
+}

package/src/responses/convert-to-openai-responses-input.ts

@@ -8,6 +8,8 @@ import {
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
+  secureJsonParse,
+  stringifyWithBigIntAndCycles,
   lazySchema,
   zodSchema,
   type InferSchema,
@@ -62,7 +64,15 @@ import {
 } from './expand-parallel-tool-call';
 
 function serializeToolCallArguments(input: unknown): string {
-  return JSON.stringify(input === undefined ? {} : input);
+  if (typeof input === 'string') {
+    try {
+      secureJsonParse(input);
+      return input;
+    } catch {
+      return stringifyWithBigIntAndCycles(input);
+    }
+  }
+  return stringifyWithBigIntAndCycles(input === undefined ? {} : input);
 }
 
 function mapToolCaller(
@@ -172,19 +182,23 @@ async function convertFunctionToolResultOutput({
   switch (output.type) {
     case 'text':
       return convertScalarOutput(
-        hasOutputSchema ? JSON.stringify(output.value) : output.value,
+        hasOutputSchema
+          ? stringifyWithBigIntAndCycles(output.value)
+          : output.value,
       );
     case 'error-text':
     case 'error-json':
-      return convertScalarOutput(JSON.stringify({ error: output.value }));
+      return convertScalarOutput(
+        stringifyWithBigIntAndCycles({ error: output.value }),
+      );
     case 'execution-denied': {
       const reason = output.reason ?? 'Tool call execution denied.';
       return convertScalarOutput(
-        hasOutputSchema ? JSON.stringify(reason) : reason,
+        hasOutputSchema ? stringifyWithBigIntAndCycles(reason) : reason,
       );
     }
     case 'json':
-      return convertScalarOutput(JSON.stringify(output.value));
+      return convertScalarOutput(stringifyWithBigIntAndCycles(output.value));
     case 'content':
       return output.value
         .map(item => {
@@ -1074,7 +1088,7 @@ export async function convertToOpenAIResponsesInput({
                   input:
                     typeof part.input === 'string'
                       ? part.input
-                      : JSON.stringify(part.input),
+                      : stringifyWithBigIntAndCycles(part.input),
                   ...(isAsync != null && { async: isAsync }),
                   id,
                 });
@@ -1311,7 +1325,7 @@ export async function convertToOpenAIResponsesInput({
                   } else if (reasoningMessage !== undefined) {
                     warnings.push({
                       type: 'other',
-                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${stringifyWithBigIntAndCycles(part)}.`,
                     });
                   }
 
@@ -1362,7 +1376,7 @@ export async function convertToOpenAIResponsesInput({
                 } else {
                   warnings.push({
                     type: 'other',
-                    message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                    message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${stringifyWithBigIntAndCycles(part)}.`,
                   });
                 }
               }
@@ -1480,7 +1494,9 @@ export async function convertToOpenAIResponsesInput({
                 }),
               );
               const serializedToolOutputs = toolOutputs.map(({ output }) =>
-                typeof output === 'string' ? output : JSON.stringify(output),
+                typeof output === 'string'
+                  ? output
+                  : stringifyWithBigIntAndCycles(output),
               );
               const hasPromptCacheBreakpoint = toolOutputs.some(
                 ({ promptCacheBreakpoint }) => promptCacheBreakpoint != null,
@@ -1663,7 +1679,7 @@ export async function convertToOpenAIResponsesInput({
               case 'error-text':
               case 'error-json':
                 outputValue = convertScalarOutput(
-                  JSON.stringify({ error: output.value }),
+                  stringifyWithBigIntAndCycles({ error: output.value }),
                 );
                 break;
               case 'execution-denied':
@@ -1672,7 +1688,9 @@ export async function convertToOpenAIResponsesInput({
                 );
                 break;
               case 'json':
-                outputValue = convertScalarOutput(JSON.stringify(output.value));
+                outputValue = convertScalarOutput(
+                  stringifyWithBigIntAndCycles(output.value),
+                );
                 break;
               case 'content':
                 outputValue = output.value

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

@@ -17,6 +17,7 @@ import {
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
+  resolve,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
@@ -36,14 +37,12 @@ import {
   type OpenAIConfig,
 } from '../openai-config';
 import { openaiFailedResponseHandler } from '../openai-error';
-import {
-  getOpenAILanguageModelCapabilities,
-  resolveOpenAIReasoningEffort,
-} from '../openai-language-model-capabilities';
+import { getOpenAILanguageModelEntry } from '../openai-model-catalog';
 import {
   createOpenAIProviderStreamError,
   throwIfOpenAIStreamErrorBeforeOutput,
 } from '../openai-stream-error';
+import { resolveOpenAIReasoningEffort } from '../resolve-openai-reasoning-effort';
 import type { applyPatchInputSchema } from '../tool/apply-patch';
 import type {
   codeInterpreterInputSchema,
@@ -226,10 +225,10 @@ function getConfigurationUpdateUnsupportedReason({
   modelCapabilities,
   options,
 }: {
-  modelCapabilities: { supportsConfigurationUpdate: boolean };
+  modelCapabilities: { configurationUpdates: boolean };
   options: OpenAILanguageModelResponsesOptions | undefined;
 }): string | undefined {
-  if (!modelCapabilities.supportsConfigurationUpdate) {
+  if (!modelCapabilities.configurationUpdates) {
     return 'reasoningEffortUpdate is only supported by GPT-6 and later models';
   }
 
@@ -304,7 +303,10 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     options: LanguageModelV4CallOptions;
   }) {
     const warnings: SharedV4Warning[] = [];
-    const modelCapabilities = getOpenAILanguageModelCapabilities(modelId);
+    const {
+      capabilities: { language: modelCapabilities },
+      requestConfig: { language: modelRequestConfig },
+    } = getOpenAILanguageModelEntry(modelId);
 
     if (topK != null) {
       warnings.push({ type: 'unsupported', feature: 'topK' });
@@ -346,7 +348,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     const resolvedReasoningEffort = resolveOpenAIReasoningEffort({
       providerReasoningEffort: openaiOptions?.reasoningEffort,
       reasoning,
-      supportedReasoningEfforts: modelCapabilities.supportedReasoningEfforts,
+      supportedReasoningEfforts: modelCapabilities.reasoning.efforts,
       warnings,
     });
 
@@ -358,7 +360,8 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
           : undefined;
 
     const isReasoningModel =
-      openaiOptions?.forceReasoning ?? modelCapabilities.isReasoningModel;
+      openaiOptions?.forceReasoning ??
+      modelCapabilities.reasoning.support === true;
 
     if (openaiOptions?.conversation && openaiOptions?.previousResponseId) {
       warnings.push({
@@ -402,7 +405,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
       toolNameMapping,
       customProviderToolNames,
       outputSchemaToolNames,
-      supportsAsyncToolCalling: modelCapabilities.supportsAsyncToolCalling,
+      supportsAsyncToolCalling: modelCapabilities.tools.async,
       providerOptionsName,
     });
 
@@ -420,7 +423,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
           openaiOptions?.systemMessageMode ??
           (isReasoningModel
             ? 'developer'
-            : modelCapabilities.systemMessageMode),
+            : modelRequestConfig.systemMessageMode),
         providerOptionsName,
         configurationUpdateUnsupportedReason,
         explicitMessageItemType: config.explicitMessageItemType,
@@ -448,10 +451,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
 
     // The schema accepts update efforts supported by any supported model. Check
     // whether this specific model supports the requested effort.
-    const supportedReasoningEfforts =
-      modelCapabilities.supportedReasoningEfforts as
-        | readonly string[]
-        | undefined;
+    const supportedReasoningEfforts = modelCapabilities.reasoning.efforts;
     const getUpdateEffortUnsupportedReason = (effort: string | undefined) =>
       effort != null && supportedReasoningEfforts?.includes(effort) === false
         ? `${modelId} only supports the following reasoning efforts: ${supportedReasoningEfforts.join(', ')}`
@@ -668,7 +668,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     };
 
     if (
-      modelCapabilities.supportsConfigurationUpdate &&
+      !modelCapabilities.promptCache.retention &&
       baseArgs.prompt_cache_retention != null
     ) {
       baseArgs.prompt_cache_retention = undefined;
@@ -696,7 +696,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
       if (
         !(
           effectiveReasoningEffort === 'none' &&
-          modelCapabilities.supportsNonReasoningParameters
+          modelCapabilities.reasoning.sampling === 'reasoning-effort-none'
         )
       ) {
         if (baseArgs.temperature != null) {
@@ -718,7 +718,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
         }
 
         if (
-          modelCapabilities.supportsConfigurationUpdate &&
+          modelCapabilities.endpoints.responses.logprobsRequireNonReasoning &&
           (baseArgs.top_logprobs != null ||
             baseArgs.include?.includes('message.output_text.logprobs'))
         ) {
@@ -774,7 +774,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     // Validate flex processing support
     if (
       openaiOptions?.serviceTier === 'flex' &&
-      !modelCapabilities.supportsFlexProcessing
+      !modelCapabilities.serviceTiers.flex
     ) {
       warnings.push({
         type: 'unsupported',
@@ -790,7 +790,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     if (
       (openaiOptions?.serviceTier === 'priority' ||
         openaiOptions?.serviceTier === 'fast') &&
-      !modelCapabilities.supportsPriorityProcessing
+      !modelCapabilities.serviceTiers.priority
     ) {
       warnings.push({
         type: 'unsupported',
@@ -860,7 +860,10 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
       rawValue: rawResponse,
     } = await postJsonToApi({
       url,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        options.headers,
+      ),
       body,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
@@ -1563,7 +1566,10 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
 
     const { responseHeaders, value: response } = await postJsonToApi({
       url,
-      headers: combineHeaders(this.config.headers?.(), options.headers),
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        options.headers,
+      ),
       body: {
         ...body,
         stream: true,

package/src/skills/openai-skills.ts

@@ -1,5 +1,7 @@
 import type { SkillsV4, SharedV4Warning } from '@ai-sdk/provider';
 import {
+  type Resolvable,
+  resolve,
   combineHeaders,
   convertInlineFileDataToUint8Array,
   createJsonResponseHandler,
@@ -12,7 +14,7 @@ import { openaiSkillResponseSchema } from './openai-skills-api';
 interface OpenAISkillsConfig {
   provider: string;
   url: (options: { path: string }) => string;
-  headers: () => Record<string, string | undefined>;
+  headers: Resolvable<Record<string, string | undefined>>;
   fetch?: FetchFunction;
 }
 
@@ -50,7 +52,7 @@ export class OpenAISkills implements SkillsV4 {
 
     const { value: response } = await postFormDataToApi({
       url: this.config.url({ path: '/skills' }),
-      headers: combineHeaders(this.config.headers()),
+      headers: combineHeaders(await resolve(this.config.headers)),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(

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

@@ -1,5 +1,6 @@
 import type { SpeechModelV4, SharedV4Warning } from '@ai-sdk/provider';
 import {
+  resolve,
   combineHeaders,
   createBinaryResponseHandler,
   parseProviderOptions,
@@ -131,7 +132,10 @@ export class OpenAISpeechModel implements SpeechModelV4 {
         path: '/audio/speech',
         modelId: this.modelId,
       }),
-      headers: combineHeaders(this.config.headers?.(), options.headers),
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        options.headers,
+      ),
       body: requestBody,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createBinaryResponseHandler(),

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

@@ -6,6 +6,7 @@ import {
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
+  resolve,
   combineHeaders,
   connectToWebSocket,
   convertToBase64,
@@ -101,7 +102,10 @@ export class OpenAISpeechTranslationModel implements SpeechTranslationModelV4 {
       });
     }
 
-    const headers = combineHeaders(this.config.headers?.(), options.headers);
+    const headers = combineHeaders(
+      await resolve(this.config.headers),
+      options.headers,
+    );
     const sessionUpdate = buildOpenAIRealtimeSpeechTranslationSession({
       targetLanguage: options.targetLanguage,
     });

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

@@ -32,6 +32,18 @@ export const openAITranscriptionModelOptions = lazySchema(() =>
        */
       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(),
+
+      /**
+       * 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.
        */