@ai-sdk/openai 4.0.32 → 4.0.34

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

@@ -226,7 +226,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
     return this.config.provider;
   }
 
-  private async getArgs({
+  protected async getArgs({
     maxOutputTokens,
     temperature,
     stopSequences,
@@ -1380,6 +1380,20 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
       }
     > = {};
 
+    // OpenAI-compatible providers can rotate opaque item ids between events.
+    // output_index remains stable for the lifetime of an output item.
+    const activeOutputItemIds: Record<number, string | undefined> = {};
+    const resolveOutputItemId = ({
+      itemId,
+      outputIndex,
+    }: {
+      itemId: string;
+      outputIndex?: number | null;
+    }) =>
+      outputIndex == null
+        ? itemId
+        : (activeOutputItemIds[outputIndex] ?? itemId);
+
     let serviceTier: string | undefined;
     let reasoningContext: ResponsesProviderMetadata['reasoningContext'];
     const hostedToolSearchCallIds: string[] = [];
@@ -1608,6 +1622,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
               } else if (value.item.type === 'shell_call_output') {
                 // shell_call_output is handled in output_item.done
               } else if (value.item.type === 'message') {
+                activeOutputItemIds[value.output_index] = value.item.id;
                 ongoingAnnotations.splice(0, ongoingAnnotations.length);
                 activeMessagePhase = value.item.phase ?? undefined;
                 controller.enqueue({
@@ -1626,6 +1641,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
                 isResponseOutputItemAddedChunk(value) &&
                 value.item.type === 'reasoning'
               ) {
+                activeOutputItemIds[value.output_index] = value.item.id;
                 activeReasoning[value.item.id] = {
                   encryptedContent: value.item.encrypted_content,
                   summaryParts: { 0: 'active' },
@@ -1645,14 +1661,18 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
               }
             } else if (isResponseOutputItemDoneChunk(value)) {
               if (value.item.type === 'message') {
+                const itemId = resolveOutputItemId({
+                  itemId: value.item.id,
+                  outputIndex: value.output_index,
+                });
                 const phase = value.item.phase ?? activeMessagePhase;
                 activeMessagePhase = undefined;
                 controller.enqueue({
                   type: 'text-end',
-                  id: value.item.id,
+                  id: itemId,
                   providerMetadata: {
                     [providerOptionsName]: {
-                      itemId: value.item.id,
+                      itemId,
                       ...(phase != null && { phase }),
                       ...(ongoingAnnotations.length > 0 && {
                         annotations: ongoingAnnotations,
@@ -1660,6 +1680,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
                     } satisfies ResponsesTextProviderMetadata,
                   },
                 });
+                activeOutputItemIds[value.output_index] = undefined;
               } else if (value.item.type === 'function_call') {
                 ongoingToolCalls[value.output_index] = undefined;
                 hasFunctionCall = true;
@@ -2128,34 +2149,41 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
                   } satisfies InferSchema<typeof shellOutputSchema>,
                 });
               } else if (value.item.type === 'reasoning') {
-                const activeReasoningPart = activeReasoning[value.item.id];
-
-                // get all active or can-conclude summary parts' ids
-                // to conclude ongoing reasoning parts:
-                const summaryPartIndices = Object.entries(
-                  activeReasoningPart.summaryParts,
-                )
-                  .filter(
-                    ([_, status]) =>
-                      status === 'active' || status === 'can-conclude',
+                const itemId = resolveOutputItemId({
+                  itemId: value.item.id,
+                  outputIndex: value.output_index,
+                });
+                const activeReasoningPart = activeReasoning[itemId];
+
+                if (activeReasoningPart != null) {
+                  // get all active or can-conclude summary parts' ids
+                  // to conclude ongoing reasoning parts:
+                  const summaryPartIndices = Object.entries(
+                    activeReasoningPart.summaryParts,
                   )
-                  .map(([summaryIndex]) => summaryIndex);
+                    .filter(
+                      ([_, status]) =>
+                        status === 'active' || status === 'can-conclude',
+                    )
+                    .map(([summaryIndex]) => summaryIndex);
 
-                for (const summaryIndex of summaryPartIndices) {
-                  controller.enqueue({
-                    type: 'reasoning-end',
-                    id: `${value.item.id}:${summaryIndex}`,
-                    providerMetadata: {
-                      [providerOptionsName]: {
-                        itemId: value.item.id,
-                        reasoningEncryptedContent:
-                          value.item.encrypted_content ?? null,
-                      } satisfies ResponsesReasoningProviderMetadata,
-                    },
-                  });
-                }
+                  for (const summaryIndex of summaryPartIndices) {
+                    controller.enqueue({
+                      type: 'reasoning-end',
+                      id: `${itemId}:${summaryIndex}`,
+                      providerMetadata: {
+                        [providerOptionsName]: {
+                          itemId,
+                          reasoningEncryptedContent:
+                            value.item.encrypted_content ?? null,
+                        } satisfies ResponsesReasoningProviderMetadata,
+                      },
+                    });
+                  }
 
-                delete activeReasoning[value.item.id];
+                  delete activeReasoning[itemId];
+                }
+                activeOutputItemIds[value.output_index] = undefined;
               } else if (value.item.type === 'compaction') {
                 controller.enqueue({
                   type: 'custom',
@@ -2285,9 +2313,13 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
                 modelId: value.response.model,
               });
             } else if (isTextDeltaChunk(value)) {
+              const itemId = resolveOutputItemId({
+                itemId: value.item_id,
+                outputIndex: value.output_index,
+              });
               controller.enqueue({
                 type: 'text-delta',
-                id: value.item_id,
+                id: itemId,
                 delta: value.delta,
               });
 
@@ -2298,83 +2330,98 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV4 {
                 logprobs.push(value.logprobs);
               }
             } else if (value.type === 'response.reasoning_summary_part.added') {
+              const itemId = resolveOutputItemId({
+                itemId: value.item_id,
+                outputIndex: value.output_index,
+              });
               // the first reasoning start is pushed in isResponseOutputItemAddedReasoningChunk
               if (value.summary_index > 0) {
-                const activeReasoningPart = activeReasoning[value.item_id]!;
-
-                activeReasoningPart.summaryParts[value.summary_index] =
-                  'active';
-
-                // since there is a new active summary part, we can conclude all can-conclude summary parts
-                for (const summaryIndex of Object.keys(
-                  activeReasoningPart.summaryParts,
-                )) {
-                  if (
-                    activeReasoningPart.summaryParts[summaryIndex] ===
-                    'can-conclude'
-                  ) {
-                    controller.enqueue({
-                      type: 'reasoning-end',
-                      id: `${value.item_id}:${summaryIndex}`,
-                      providerMetadata: {
-                        [providerOptionsName]: {
-                          itemId: value.item_id,
-                        } satisfies ResponsesReasoningProviderMetadata,
-                      },
-                    });
-                    activeReasoningPart.summaryParts[summaryIndex] =
-                      'concluded';
+                const activeReasoningPart = activeReasoning[itemId];
+
+                if (activeReasoningPart != null) {
+                  activeReasoningPart.summaryParts[value.summary_index] =
+                    'active';
+
+                  // since there is a new active summary part, we can conclude all can-conclude summary parts
+                  for (const summaryIndex of Object.keys(
+                    activeReasoningPart.summaryParts,
+                  )) {
+                    if (
+                      activeReasoningPart.summaryParts[summaryIndex] ===
+                      'can-conclude'
+                    ) {
+                      controller.enqueue({
+                        type: 'reasoning-end',
+                        id: `${itemId}:${summaryIndex}`,
+                        providerMetadata: {
+                          [providerOptionsName]: {
+                            itemId,
+                          } satisfies ResponsesReasoningProviderMetadata,
+                        },
+                      });
+                      activeReasoningPart.summaryParts[summaryIndex] =
+                        'concluded';
+                    }
                   }
-                }
 
-                controller.enqueue({
-                  type: 'reasoning-start',
-                  id: `${value.item_id}:${value.summary_index}`,
-                  providerMetadata: {
-                    [providerOptionsName]: {
-                      itemId: value.item_id,
-                      reasoningEncryptedContent:
-                        activeReasoning[value.item_id]?.encryptedContent ??
-                        null,
-                    } satisfies ResponsesReasoningProviderMetadata,
-                  },
-                });
+                  controller.enqueue({
+                    type: 'reasoning-start',
+                    id: `${itemId}:${value.summary_index}`,
+                    providerMetadata: {
+                      [providerOptionsName]: {
+                        itemId,
+                        reasoningEncryptedContent:
+                          activeReasoningPart.encryptedContent ?? null,
+                      } satisfies ResponsesReasoningProviderMetadata,
+                    },
+                  });
+                }
               }
             } else if (value.type === 'response.reasoning_summary_text.delta') {
+              const itemId = resolveOutputItemId({
+                itemId: value.item_id,
+                outputIndex: value.output_index,
+              });
               controller.enqueue({
                 type: 'reasoning-delta',
-                id: `${value.item_id}:${value.summary_index}`,
+                id: `${itemId}:${value.summary_index}`,
                 delta: value.delta,
                 providerMetadata: {
                   [providerOptionsName]: {
-                    itemId: value.item_id,
+                    itemId,
                   } satisfies ResponsesReasoningProviderMetadata,
                 },
               });
             } else if (value.type === 'response.reasoning_summary_part.done') {
-              // when OpenAI stores the message data, we can immediately conclude the reasoning part
-              // since we do not need to send the encrypted content.
-              if (store) {
-                controller.enqueue({
-                  type: 'reasoning-end',
-                  id: `${value.item_id}:${value.summary_index}`,
-                  providerMetadata: {
-                    [providerOptionsName]: {
-                      itemId: value.item_id,
-                    } satisfies ResponsesReasoningProviderMetadata,
-                  },
-                });
+              const itemId = resolveOutputItemId({
+                itemId: value.item_id,
+                outputIndex: value.output_index,
+              });
+              const activeReasoningPart = activeReasoning[itemId];
 
-                // mark the summary part as concluded
-                activeReasoning[value.item_id]!.summaryParts[
-                  value.summary_index
-                ] = 'concluded';
-              } else {
-                // mark the summary part as can-conclude only
-                // because we need to have a final summary part with the encrypted content
-                activeReasoning[value.item_id]!.summaryParts[
-                  value.summary_index
-                ] = 'can-conclude';
+              if (activeReasoningPart != null) {
+                // when OpenAI stores the message data, we can immediately conclude the reasoning part
+                // since we do not need to send the encrypted content.
+                if (store) {
+                  controller.enqueue({
+                    type: 'reasoning-end',
+                    id: `${itemId}:${value.summary_index}`,
+                    providerMetadata: {
+                      [providerOptionsName]: {
+                        itemId,
+                      } satisfies ResponsesReasoningProviderMetadata,
+                    },
+                  });
+
+                  // mark the summary part as concluded
+                  activeReasoningPart.summaryParts[value.summary_index] =
+                    'concluded';
+                } else {
+                  // mark the summary part as can-conclude only
+                  // because we need to have a final summary part with the encrypted content
+                  activeReasoningPart.summaryParts[value.summary_index] =
+                    'can-conclude';
+                }
               }
             } else if (isResponseFinishedChunk(value)) {
               finishReason = {

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

@@ -0,0 +1,18 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export type OpenAISpeechTranslationModelId =
+  | 'gpt-realtime-translate'
+  | (string & {});
+
+export const openAISpeechTranslationModelOptions = lazySchema(() =>
+  zodSchema(z.object({})),
+);
+
+export type OpenAISpeechTranslationModelOptions = InferSchema<
+  typeof openAISpeechTranslationModelOptions
+>;

package/src/{translation/openai-translation-model.ts → speech-translation/openai-speech-translation-model.ts}

@@ -1,6 +1,6 @@
 import {
   InvalidArgumentError,
-  type Experimental_SpeechTranslationModelV4 as TranslationModelV4,
+  type Experimental_SpeechTranslationModelV4 as SpeechTranslationModelV4,
   type Experimental_SpeechTranslationModelV4StreamOptions as SpeechTranslationModelV4StreamOptions,
   type Experimental_SpeechTranslationModelV4StreamPart as SpeechTranslationModelV4StreamPart,
   type SharedV4Warning,
@@ -21,26 +21,26 @@ import {
 } from '@ai-sdk/provider-utils';
 import type { OpenAIConfig } from '../openai-config';
 import {
-  openAITranslationModelOptions,
-  type OpenAITranslationModelId,
-} from './openai-translation-model-options';
+  openAISpeechTranslationModelOptions,
+  type OpenAISpeechTranslationModelId,
+} from './openai-speech-translation-model-options';
 
-type OpenAIRealtimeTranslationEvent = {
+type OpenAIRealtimeSpeechTranslationEvent = {
   type?: string;
   delta?: string;
   error?: { message?: string };
 };
 
-interface OpenAITranslationModelConfig extends OpenAIConfig {
+interface OpenAISpeechTranslationModelConfig extends OpenAIConfig {
   _internal?: {
     currentDate?: () => Date;
   };
 }
 
-export class OpenAITranslationModel implements TranslationModelV4 {
+export class OpenAISpeechTranslationModel implements SpeechTranslationModelV4 {
   readonly specificationVersion = 'v4';
 
-  static [WORKFLOW_SERIALIZE](model: OpenAITranslationModel) {
+  static [WORKFLOW_SERIALIZE](model: OpenAISpeechTranslationModel) {
     return serializeModelOptions({
       modelId: model.modelId,
       config: model.config,
@@ -48,10 +48,10 @@ export class OpenAITranslationModel implements TranslationModelV4 {
   }
 
   static [WORKFLOW_DESERIALIZE](options: {
-    modelId: OpenAITranslationModelId;
-    config: OpenAITranslationModelConfig;
+    modelId: OpenAISpeechTranslationModelId;
+    config: OpenAISpeechTranslationModelConfig;
   }) {
-    return new OpenAITranslationModel(options.modelId, options.config);
+    return new OpenAISpeechTranslationModel(options.modelId, options.config);
   }
 
   get provider(): string {
@@ -59,13 +59,13 @@ export class OpenAITranslationModel implements TranslationModelV4 {
   }
 
   constructor(
-    readonly modelId: OpenAITranslationModelId,
-    private readonly config: OpenAITranslationModelConfig,
+    readonly modelId: OpenAISpeechTranslationModelId,
+    private readonly config: OpenAISpeechTranslationModelConfig,
   ) {}
 
   async doStream(
     options: SpeechTranslationModelV4StreamOptions,
-  ): Promise<Awaited<ReturnType<TranslationModelV4['doStream']>>> {
+  ): Promise<Awaited<ReturnType<SpeechTranslationModelV4['doStream']>>> {
     if (options.targetLanguage == null) {
       throw new InvalidArgumentError({
         argument: 'targetLanguage',
@@ -77,11 +77,11 @@ export class OpenAITranslationModel implements TranslationModelV4 {
     await parseProviderOptions({
       provider: 'openai',
       providerOptions: options.providerOptions,
-      schema: openAITranslationModelOptions,
+      schema: openAISpeechTranslationModelOptions,
     });
     const warnings: SharedV4Warning[] = [];
 
-    validateOpenAITranslationInputAudioFormat(options.inputAudioFormat);
+    validateOpenAISpeechTranslationInputAudioFormat(options.inputAudioFormat);
 
     if (options.sourceLanguage != null) {
       warnings.push({
@@ -102,7 +102,7 @@ export class OpenAITranslationModel implements TranslationModelV4 {
     }
 
     const headers = combineHeaders(this.config.headers?.(), options.headers);
-    const sessionUpdate = buildOpenAIRealtimeTranslationSession({
+    const sessionUpdate = buildOpenAIRealtimeSpeechTranslationSession({
       targetLanguage: options.targetLanguage,
     });
 
@@ -112,7 +112,7 @@ export class OpenAITranslationModel implements TranslationModelV4 {
         timestamp: currentDate,
         modelId: this.modelId,
       },
-      stream: createOpenAIRealtimeTranslationStream({
+      stream: createOpenAIRealtimeSpeechTranslationStream({
         webSocket: this.config.webSocket,
         url: toWebSocketUrl(
           this.config.url({
@@ -131,7 +131,7 @@ export class OpenAITranslationModel implements TranslationModelV4 {
   }
 }
 
-function createOpenAIRealtimeTranslationStream({
+function createOpenAIRealtimeSpeechTranslationStream({
   webSocket,
   url,
   headers,
@@ -249,7 +249,7 @@ function createOpenAIRealtimeTranslationStream({
           if (finished) return;
           const parsed = await safeParseJSON({ text });
           if (!parsed.success) return;
-          const raw = parsed.value as OpenAIRealtimeTranslationEvent;
+          const raw = parsed.value as OpenAIRealtimeSpeechTranslationEvent;
 
           if (includeRawChunks) {
             controller.enqueue({ type: 'raw', rawValue: raw });
@@ -324,7 +324,7 @@ function createOpenAIRealtimeTranslationStream({
   });
 }
 
-function buildOpenAIRealtimeTranslationSession({
+function buildOpenAIRealtimeSpeechTranslationSession({
   targetLanguage,
 }: {
   targetLanguage: string;
@@ -347,7 +347,7 @@ function buildOpenAIRealtimeTranslationSession({
   };
 }
 
-function validateOpenAITranslationInputAudioFormat(
+function validateOpenAISpeechTranslationInputAudioFormat(
   inputAudioFormat: SpeechTranslationModelV4StreamOptions['inputAudioFormat'],
 ) {
   if (

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

@@ -1,16 +0,0 @@
-import {
-  lazySchema,
-  zodSchema,
-  type InferSchema,
-} from '@ai-sdk/provider-utils';
-import { z } from 'zod/v4';
-
-export type OpenAITranslationModelId = 'gpt-realtime-translate' | (string & {});
-
-export const openAITranslationModelOptions = lazySchema(() =>
-  zodSchema(z.object({})),
-);
-
-export type OpenAITranslationModelOptions = InferSchema<
-  typeof openAITranslationModelOptions
->;