@ai-sdk/openai 4.0.104 → 4.0.106

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/openai-responses-language-model.ts

@@ -17,12 +17,12 @@ import {
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
+  resolve,
   combineHeaders,
   createEventSourceResponseHandler,
   createJsonResponseHandler,
   createToolNameMapping,
   generateId,
-  isCustomReasoning,
   parseProviderOptions,
   postJsonToApi,
   serializeModelOptions,
@@ -37,11 +37,12 @@ import {
   type OpenAIConfig,
 } from '../openai-config';
 import { openaiFailedResponseHandler } from '../openai-error';
-import { getOpenAILanguageModelCapabilities } 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,
@@ -224,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';
   }
 
@@ -302,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' });
@@ -341,24 +345,12 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
       });
     }
 
-    let resolvedReasoningEffort =
-      openaiOptions?.reasoningEffort ??
-      (isCustomReasoning(reasoning) ? reasoning : undefined);
-
-    if (
-      resolvedReasoningEffort != null &&
-      modelCapabilities.supportedReasoningEfforts != null &&
-      !modelCapabilities.supportedReasoningEfforts.includes(
-        resolvedReasoningEffort,
-      )
-    ) {
-      warnings.push({
-        type: 'unsupported',
-        feature: 'reasoningEffort',
-        details: `${modelId} only supports the following reasoning efforts: ${modelCapabilities.supportedReasoningEfforts.join(', ')}`,
-      });
-      resolvedReasoningEffort = undefined;
-    }
+    const resolvedReasoningEffort = resolveOpenAIReasoningEffort({
+      providerReasoningEffort: openaiOptions?.reasoningEffort,
+      reasoning,
+      supportedReasoningEfforts: modelCapabilities.reasoning.efforts,
+      warnings,
+    });
 
     const resolvedReasoningSummary =
       openaiOptions?.reasoningSummary !== undefined
@@ -368,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({
@@ -412,7 +405,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
       toolNameMapping,
       customProviderToolNames,
       outputSchemaToolNames,
-      supportsAsyncToolCalling: modelCapabilities.supportsAsyncToolCalling,
+      supportsAsyncToolCalling: modelCapabilities.tools.async,
       providerOptionsName,
     });
 
@@ -430,7 +423,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
           openaiOptions?.systemMessageMode ??
           (isReasoningModel
             ? 'developer'
-            : modelCapabilities.systemMessageMode),
+            : modelRequestConfig.systemMessageMode),
         providerOptionsName,
         configurationUpdateUnsupportedReason,
         explicitMessageItemType: config.explicitMessageItemType,
@@ -458,10 +451,10 @@ 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.reasoning.efforts;
     const getUpdateEffortUnsupportedReason = (effort: string | undefined) =>
-      effort != null &&
-      modelCapabilities.supportedReasoningEfforts?.includes(effort) === false
-        ? `${modelId} only supports the following reasoning efforts: ${modelCapabilities.supportedReasoningEfforts.join(', ')}`
+      effort != null && supportedReasoningEfforts?.includes(effort) === false
+        ? `${modelId} only supports the following reasoning efforts: ${supportedReasoningEfforts.join(', ')}`
         : undefined;
 
     // Reject configuration updates whose effort value is unsupported by the selected model.
@@ -675,7 +668,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     };
 
     if (
-      modelCapabilities.supportsConfigurationUpdate &&
+      !modelCapabilities.promptCache.retention &&
       baseArgs.prompt_cache_retention != null
     ) {
       baseArgs.prompt_cache_retention = undefined;
@@ -703,7 +696,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
       if (
         !(
           effectiveReasoningEffort === 'none' &&
-          modelCapabilities.supportsNonReasoningParameters
+          modelCapabilities.reasoning.sampling === 'reasoning-effort-none'
         )
       ) {
         if (baseArgs.temperature != null) {
@@ -725,7 +718,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
         }
 
         if (
-          modelCapabilities.supportedReasoningEfforts != null &&
+          modelCapabilities.endpoints.responses.logprobsRequireNonReasoning &&
           (baseArgs.top_logprobs != null ||
             baseArgs.include?.includes('message.output_text.logprobs'))
         ) {
@@ -781,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',
@@ -797,7 +790,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     if (
       (openaiOptions?.serviceTier === 'priority' ||
         openaiOptions?.serviceTier === 'fast') &&
-      !modelCapabilities.supportsPriorityProcessing
+      !modelCapabilities.serviceTiers.priority
     ) {
       warnings.push({
         type: 'unsupported',
@@ -867,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(
@@ -1570,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.ts

@@ -6,6 +6,7 @@ import {
   type TranscriptionModelV4CallOptions,
 } from '@ai-sdk/provider';
 import {
+  resolve,
   combineHeaders,
   convertBase64ToUint8Array,
   convertToBase64,
@@ -25,6 +26,7 @@ import {
 } from '@ai-sdk/provider-utils';
 import type { OpenAIConfig } from '../openai-config';
 import { openaiFailedResponseHandler } from '../openai-error';
+import { getOpenAITranscriptionModelEntry } from '../openai-model-catalog';
 import { openaiTranscriptionResponseSchema } from './openai-transcription-api';
 import {
   openAITranscriptionModelOptions,
@@ -57,47 +59,6 @@ type OpenAIRealtimeTranscriptionEvent = {
   error?: { message?: string };
 };
 
-/**
- * Whether `modelId` is `base` or one of its dated snapshots
- * (e.g. `gpt-realtime-whisper-2026-01-01`).
- */
-function isModelOrSnapshot(modelId: string, base: string): boolean {
-  return modelId === base || modelId.startsWith(`${base}-`);
-}
-
-/**
- * Model IDs that stream over the realtime transcription WebSocket and do not
- * support the REST transcription endpoint.
- */
-function isRealtimeTranscriptionModelId(modelId: string): boolean {
-  return (
-    isModelOrSnapshot(modelId, 'gpt-realtime-whisper') ||
-    isModelOrSnapshot(modelId, 'gpt-live-transcribe')
-  );
-}
-
-/**
- * Model IDs that support streaming transcription. `gpt-transcribe` also
- * supports the REST transcription endpoint.
- */
-function supportsStreamingTranscription(modelId: string): boolean {
-  return (
-    isRealtimeTranscriptionModelId(modelId) ||
-    isModelOrSnapshot(modelId, 'gpt-transcribe')
-  );
-}
-
-/**
- * Models whose realtime transcription session takes a `languages` list
- * instead of the singular `language` field.
- */
-function usesLanguagesList(modelId: string): boolean {
-  return (
-    isModelOrSnapshot(modelId, 'gpt-live-transcribe') ||
-    isModelOrSnapshot(modelId, 'gpt-transcribe')
-  );
-}
-
 interface OpenAITranscriptionModelConfig extends OpenAIConfig {
   _internal?: {
     currentDate?: () => Date;
@@ -226,15 +187,12 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
       `audio.${fileExtension}`,
     );
 
-    const isDiarizationModel = this.modelId === 'gpt-4o-transcribe-diarize';
+    const { transcription: requestConfig } = getOpenAITranscriptionModelEntry(
+      this.modelId,
+    ).requestConfig;
 
     const responseFormat =
-      openAIOptions?.responseFormat ??
-      (isDiarizationModel
-        ? 'diarized_json'
-        : this.modelId === 'whisper-1'
-          ? 'verbose_json'
-          : undefined);
+      openAIOptions?.responseFormat ?? requestConfig.responseFormat;
 
     // Timestamps are only returned with verbose_json, so only default to
     // segments when that format is used.
@@ -243,8 +201,7 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
       (responseFormat === 'verbose_json' ? ['segment'] : undefined);
 
     const chunkingStrategy =
-      openAIOptions?.chunkingStrategy ??
-      (isDiarizationModel ? 'auto' : undefined);
+      openAIOptions?.chunkingStrategy ?? requestConfig.chunkingStrategy;
 
     const transcriptionModelOptions = {
       response_format: responseFormat,
@@ -296,7 +253,10 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
   async doGenerate(
     options: OpenAITranscriptionCallOptions,
   ): Promise<Awaited<ReturnType<TranscriptionModelV4['doGenerate']>>> {
-    if (isRealtimeTranscriptionModelId(this.modelId)) {
+    if (
+      getOpenAITranscriptionModelEntry(this.modelId).capabilities.transcription
+        .transcription === false
+    ) {
       throw new UnsupportedFunctionalityError({
         functionality: `non-streaming transcription with ${this.modelId}`,
       });
@@ -314,7 +274,10 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
         path: '/audio/transcriptions',
         modelId: this.modelId,
       }),
-      headers: combineHeaders(this.config.headers?.(), options.headers),
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        options.headers,
+      ),
       formData,
       failedResponseHandler: openaiFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
@@ -401,7 +364,8 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
   ): Promise<
     Awaited<ReturnType<NonNullable<TranscriptionModelV4['doStream']>>>
   > {
-    if (!supportsStreamingTranscription(this.modelId)) {
+    const entry = getOpenAITranscriptionModelEntry(this.modelId);
+    if (entry.capabilities.transcription.streaming !== true) {
       throw new UnsupportedFunctionalityError({
         functionality: `streaming transcription with ${this.modelId}`,
       });
@@ -434,7 +398,8 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
     }
 
     // gpt-transcribe transcribes each committed turn, so it has no delay setting:
-    const supportsDelay = !isModelOrSnapshot(this.modelId, 'gpt-transcribe');
+    const supportsDelay =
+      entry.capabilities.transcription.streamingDelay === true;
     if (!supportsDelay && openAIOptions?.streaming?.delay != null) {
       warnings.push({
         type: 'unsupported',
@@ -443,7 +408,10 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
       });
     }
 
-    const headers = combineHeaders(this.config.headers?.(), options.headers);
+    const headers = combineHeaders(
+      await resolve(this.config.headers),
+      options.headers,
+    );
     const sessionUpdate = buildOpenAIRealtimeTranscriptionSession({
       modelId: this.modelId,
       inputAudioFormat: options.inputAudioFormat,
@@ -659,7 +627,8 @@ function buildOpenAIRealtimeTranscriptionSession({
           transcription: {
             model: modelId,
             ...(providerOptions?.language != null
-              ? usesLanguagesList(modelId)
+              ? getOpenAITranscriptionModelEntry(modelId).requestConfig
+                  .transcription.languageField === 'languages'
                 ? { languages: [providerOptions.language] }
                 : { language: providerOptions.language }
               : {}),

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

@@ -1,101 +0,0 @@
-export type OpenAILanguageModelCapabilities = {
-  isReasoningModel: boolean;
-  systemMessageMode: 'remove' | 'system' | 'developer';
-  supportsFlexProcessing: boolean;
-  supportsPriorityProcessing: boolean;
-  supportsConfigurationUpdate: boolean;
-  supportsAsyncToolCalling: boolean;
-  supportedReasoningEfforts: readonly string[] | undefined;
-
-  /**
-   * Allow temperature, topP, logProbs when reasoningEffort is none.
-   */
-  supportsNonReasoningParameters: boolean;
-};
-
-export function getOpenAILanguageModelCapabilities(
-  modelId: string,
-): OpenAILanguageModelCapabilities {
-  const oSeriesVersion = getOSeriesVersion(modelId);
-  const gptVersion = getGptVersion(modelId);
-  const isGptChatModel =
-    gptVersion?.minor == null &&
-    (gptVersion?.variant?.startsWith('chat') ?? false);
-  const isGptNanoModel = gptVersion?.variant?.startsWith('nano') ?? false;
-  const isGpt6OrLaterModel = gptVersion != null && gptVersion.major >= 6;
-
-  const isGpt6OrLaterModelWithNoneEffort =
-    modelId === 'gpt-6-sol' ||
-    modelId === 'gpt-6-luna' ||
-    modelId === 'gpt-6.1-terra';
-
-  const supportsFlexProcessing =
-    (oSeriesVersion != null && oSeriesVersion >= 3) ||
-    (gptVersion != null && gptVersion.major >= 5 && !isGptChatModel);
-
-  const supportsPriorityProcessing =
-    modelId.startsWith('gpt-4') ||
-    (gptVersion != null &&
-      gptVersion.major >= 5 &&
-      !isGptNanoModel &&
-      !isGptChatModel) ||
-    (oSeriesVersion != null && oSeriesVersion >= 3);
-
-  // Only recognizable OpenAI model families should use the developer role.
-  // Fine-tuned, third-party, and custom model IDs keep conservative defaults.
-  const isReasoningModel =
-    oSeriesVersion != null ||
-    (gptVersion != null && gptVersion.major >= 5 && !isGptChatModel);
-
-  // https://platform.openai.com/docs/guides/latest-model#gpt-5-1-parameter-compatibility
-  // GPT-5.1 through GPT-5.x, GPT-6 Sol/Luna, and GPT-6.1 Terra support
-  // temperature, topP, and logProbs when reasoningEffort is none.
-  const supportsNonReasoningParameters =
-    isGpt6OrLaterModelWithNoneEffort ||
-    (!isGpt6OrLaterModel &&
-      gptVersion != null &&
-      (gptVersion.major > 5 ||
-        (gptVersion.major === 5 && (gptVersion.minor ?? 0) >= 1)));
-
-  const systemMessageMode = isReasoningModel ? 'developer' : 'system';
-
-  return {
-    supportsFlexProcessing,
-    supportsPriorityProcessing,
-    supportsConfigurationUpdate: isGpt6OrLaterModel,
-    supportsAsyncToolCalling: isGpt6OrLaterModel,
-    supportedReasoningEfforts: isGpt6OrLaterModelWithNoneEffort
-      ? ['none', 'low', 'medium', 'high', 'xhigh', 'max']
-      : isGpt6OrLaterModel
-        ? ['low', 'medium', 'high', 'xhigh', 'max']
-        : undefined,
-    isReasoningModel,
-    systemMessageMode,
-    supportsNonReasoningParameters,
-  };
-}
-
-function getOSeriesVersion(modelId: string): number | undefined {
-  const match = /^o(\d+)(?:-|$)/.exec(modelId);
-  return match == null ? undefined : Number(match[1]);
-}
-
-function getGptVersion(modelId: string):
-  | {
-      major: number;
-      minor: number | undefined;
-      variant: string | undefined;
-    }
-  | undefined {
-  const match = /^gpt-(\d+)(?:\.(\d+))?(?:-(.+))?$/.exec(modelId);
-
-  if (match == null) {
-    return undefined;
-  }
-
-  return {
-    major: Number(match[1]),
-    minor: match[2] == null ? undefined : Number(match[2]),
-    variant: match[3],
-  };
-}