@ai-sdk/openai 4.0.105 → 4.0.107

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,13 +201,14 @@ 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,
       include: openAIOptions?.include,
       language: openAIOptions?.language,
+      languages: openAIOptions?.languages,
+      keywords: openAIOptions?.keywords,
       prompt: openAIOptions?.prompt,
       temperature: openAIOptions?.temperature,
       timestamp_granularities: timestampGranularities,
@@ -296,7 +255,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 +276,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 +366,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}`,
       });
@@ -420,6 +386,8 @@ export class OpenAITranscriptionModel implements TranscriptionModelV4 {
     const rawOpenAIOptions = options.providerOptions?.openai ?? {};
     for (const option of [
       'include',
+      'languages',
+      'keywords',
       'prompt',
       'temperature',
       'timestampGranularities',
@@ -434,7 +402,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 +412,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 +631,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,196 +0,0 @@
-import type {
-  LanguageModelV4CallOptions,
-  SharedV4Warning,
-} from '@ai-sdk/provider';
-import { mapReasoningToProviderEffort } from '@ai-sdk/provider-utils';
-
-type OpenAIReasoningEffort = Exclude<
-  LanguageModelV4CallOptions['reasoning'],
-  'provider-default' | undefined
->;
-
-// Unknown model families send the reasoning value directly.
-const ALL_OPENAI_REASONING_EFFORTS: readonly OpenAIReasoningEffort[] = [
-  'none',
-  'minimal',
-  'low',
-  'medium',
-  'high',
-  'xhigh',
-  'max',
-];
-
-export type OpenAILanguageModelCapabilities = {
-  isReasoningModel: boolean;
-  systemMessageMode: 'remove' | 'system' | 'developer';
-  supportsFlexProcessing: boolean;
-  supportsPriorityProcessing: boolean;
-  supportsConfigurationUpdate: boolean;
-  supportsAsyncToolCalling: boolean;
-  /**
-   * Reasoning efforts supported by the model family, or `undefined` when they
-   * are not known.
-   */
-  supportedReasoningEfforts: readonly OpenAIReasoningEffort[] | undefined;
-
-  /**
-   * Whether function tools can be combined with a reasoning effort other than
-   * `none` in the Chat Completions API.
-   */
-  supportsChatFunctionToolsWithReasoning: boolean;
-
-  /**
-   * 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;
-
-  // Pro, codex, and chat variants are excluded because their supported
-  // efforts are not known.
-  const isStandardGpt5Model =
-    gptVersion?.major === 5 &&
-    (gptVersion.variant == null ||
-      /^(?:(?:mini|nano|sol|luna|terra)(?:-\d{4}-\d{2}-\d{2})?|\d{4}-\d{2}-\d{2})$/.test(
-        gptVersion.variant,
-      ));
-
-  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']
-        : isStandardGpt5Model
-          ? getGpt5ReasoningEfforts(gptVersion.minor ?? 0)
-          : undefined,
-    // GPT-5.6 rejects function tools with reasoning in the Chat Completions API.
-    supportsChatFunctionToolsWithReasoning: !(
-      gptVersion?.major === 5 && (gptVersion.minor ?? 0) >= 6
-    ),
-    isReasoningModel,
-    systemMessageMode,
-    supportsNonReasoningParameters,
-  };
-}
-
-function getGpt5ReasoningEfforts(
-  minor: number,
-): readonly OpenAIReasoningEffort[] {
-  if (minor === 0) {
-    return ['minimal', 'low', 'medium', 'high'];
-  }
-
-  if (minor === 1) {
-    return ['none', 'low', 'medium', 'high'];
-  }
-
-  if (minor < 6) {
-    return ['none', 'low', 'medium', 'high', 'xhigh'];
-  }
-
-  return ['none', 'low', 'medium', 'high', 'xhigh', 'max'];
-}
-
-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],
-  };
-}
-
-/**
- * Resolves the reasoning effort to send to OpenAI.
- *
- * A reasoning effort from provider options is sent unchanged. Otherwise the
- * top-level reasoning value is mapped to the closest effort that the model
- * family supports, or sent directly when the supported efforts are not known.
- */
-export function resolveOpenAIReasoningEffort({
-  providerReasoningEffort,
-  reasoning,
-  supportedReasoningEfforts,
-  warnings,
-}: {
-  providerReasoningEffort: string | null | undefined;
-  reasoning: LanguageModelV4CallOptions['reasoning'];
-  supportedReasoningEfforts: readonly OpenAIReasoningEffort[] | undefined;
-  warnings: SharedV4Warning[];
-}): string | undefined {
-  return mapReasoningToProviderEffort({
-    reasoning,
-    providerOptionsEffort: providerReasoningEffort,
-    effortMap: Object.fromEntries(
-      (supportedReasoningEfforts ?? ALL_OPENAI_REASONING_EFFORTS).map(
-        effort => [effort, effort],
-      ),
-    ),
-    warnings,
-  });
-}