@tanstack/openai-base 0.10.2 → 0.10.5

package/src/adapters/chat-completions-text.ts

@@ -27,8 +27,7 @@ import type {
   DefaultMessageMetadataByModality,
   Modality,
   ModelMessage,
-  RunFinishedEvent,
-  StreamChunk,
+  AdapterYieldChunk,
   TextOptions,
 } from '@tanstack/ai'
 
@@ -71,7 +70,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
 
   async *chatStream(
     options: TextOptions<TProviderOptions>,
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     // AG-UI lifecycle tracking (mutable state object for ESLint compatibility)
     const aguiState = {
       runId: generateId(this.name),
@@ -112,7 +111,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
     options: TextOptions,
     aguiState: ChatStreamState,
     source: 'chatStream' | 'processStreamChunks',
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     // Narrow before logging: raw SDK errors can carry request metadata
     // (including auth headers) which we must never surface to user loggers.
     const errorPayload = toRunErrorPayload(
@@ -187,6 +186,8 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
 
     yield {
       type: EventType.RUN_ERROR,
+      runId: aguiState.runId,
+      threadId: aguiState.threadId,
       model: options.model,
       timestamp: Date.now(),
       message: errorPayload.message,
@@ -322,7 +323,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
    */
   async *structuredOutputStream(
     options: StructuredOutputOptions<TProviderOptions>,
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     const { chatOptions, outputSchema } = options
     const requestParams = this.mapOptionsToRequest(chatOptions)
 
@@ -351,7 +352,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
 
     const closeReasoningLifecycle = function* (this: {
       name: string
-    }): Generator<StreamChunk> {
+    }): Generator<AdapterYieldChunk> {
       if (reasoningMessageId && !hasClosedReasoning) {
         hasClosedReasoning = true
         yield {
@@ -376,6 +377,9 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
             content: accumulatedReasoning,
           }
         }
+        reasoningMessageId = undefined
+        stepId = undefined
+        hasClosedReasoning = false
       }
     }.bind(this)
 
@@ -705,7 +709,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
     stream: AsyncIterable<ChatCompletionChunk>,
     options: TextOptions,
     aguiState: ChatStreamState,
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     const normalizeToolInput = createToolInputNormalizer(
       options.tools,
       (schema, required) =>
@@ -1140,7 +1144,7 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
         // tool results that would never arrive. OpenAI's legacy
         // `function_call` value (from the v1 function-calling API) is
         // normalized to `tool_calls` — semantically the same termination.
-        const finishReason: NonNullable<RunFinishedEvent['finishReason']> =
+        const finishReason: NonNullable<AdapterYieldChunk['finishReason']> =
           emittedAnyToolCallEnd
             ? 'tool_calls'
             : pendingFinishReason === 'tool_calls'
@@ -1427,9 +1431,9 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
    * Handles backward compatibility with string content.
    */
   protected normalizeContent(
-    content: string | null | Array<ContentPart>,
+    content: string | null | undefined | Array<ContentPart>,
   ): Array<ContentPart> {
-    if (content === null) {
+    if (content === null || content === undefined) {
       return []
     }
     if (typeof content === 'string') {
@@ -1442,9 +1446,12 @@ export abstract class OpenAIBaseChatCompletionsTextAdapter<
    * Extracts text content from a content value that may be string, null, or ContentPart array.
    */
   protected extractTextContent(
-    content: string | null | Array<ContentPart>,
+    content: string | null | undefined | Array<ContentPart>,
   ): string {
-    if (content === null) {
+    // Tool-call-only assistant turns (e.g. an approval resume replaying the
+    // pending call) carry no text and arrive as `null` or `undefined`; both
+    // must collapse to '' rather than crash on `.filter`.
+    if (content === null || content === undefined) {
       return ''
     }
     if (typeof content === 'string') {

package/src/adapters/responses-text.ts

@@ -29,7 +29,7 @@ import type {
   DefaultMessageMetadataByModality,
   Modality,
   ModelMessage,
-  StreamChunk,
+  AdapterYieldChunk,
   TextOptions,
 } from '@tanstack/ai'
 
@@ -58,6 +58,16 @@ interface StreamedFunctionCallMetadata {
   pendingArguments?: string | undefined
 }
 
+/**
+ * The pre-2025-07 spec name for `response.reasoning_text.delta`. Removed from
+ * the openai SDK, but OpenAI-compatible providers frozen on the older spec
+ * (e.g. Amazon Bedrock's Mantle endpoint serving Gemma) still emit it.
+ */
+interface LegacyReasoningDeltaEvent {
+  type: 'response.reasoning.delta'
+  delta?: unknown
+}
+
 /**
  * Shared implementation of the OpenAI Responses API. Holds the stream-event
  * accumulator + AG-UI lifecycle and calls the OpenAI SDK directly. Subclasses
@@ -91,7 +101,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
 
   async *chatStream(
     options: TextOptions<TProviderOptions>,
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     // Key streamed state by output item ID because argument deltas reference
     // `item_id`. The state separately retains `call_id`, which is the public
     // tool-call ID and the correlation key for function_call_output.
@@ -289,7 +299,8 @@ export abstract class OpenAIBaseResponsesTextAdapter<
    * Stream structured output via the Responses API: single request with
    * `text.format: json_schema` + `stream: true`. Consumes Responses-API
    * events (`response.output_text.delta`, `response.reasoning_text.delta`,
-   * `response.reasoning_summary_text.delta`, `response.refusal.delta`,
+   * `response.reasoning_summary_text.delta`, the legacy
+   * `response.reasoning.delta`, `response.refusal.delta`,
    * `response.completed`, `response.failed`) and re-emits the standard AG-UI
    * lifecycle ending with `CUSTOM 'structured-output.complete'`.
    *
@@ -300,7 +311,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
    */
   async *structuredOutputStream(
     options: StructuredOutputOptions<TProviderOptions>,
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     const { chatOptions, outputSchema } = options
     const requestParams = this.mapOptionsToRequest(chatOptions)
 
@@ -327,7 +338,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
 
     const closeReasoning = function* (this: {
       name: string
-    }): Generator<StreamChunk> {
+    }): Generator<AdapterYieldChunk> {
       if (reasoningMessageId && !hasClosedReasoning) {
         hasClosedReasoning = true
         yield {
@@ -352,12 +363,15 @@ export abstract class OpenAIBaseResponsesTextAdapter<
             content: accumulatedReasoning,
           }
         }
+        reasoningMessageId = undefined
+        stepId = undefined
+        hasClosedReasoning = false
       }
     }.bind(this)
 
     const openReasoning = function* (this: {
       name: string
-    }): Generator<StreamChunk> {
+    }): Generator<AdapterYieldChunk> {
       if (reasoningMessageId) return
       reasoningMessageId = generateId(this.name)
       stepId = generateId(this.name)
@@ -393,7 +407,9 @@ export abstract class OpenAIBaseResponsesTextAdapter<
         { provider: this.name, model: this.model },
       )
 
-      const stream = await this.client.responses.create(
+      const stream: AsyncIterable<
+        ResponseStreamEvent | LegacyReasoningDeltaEvent
+      > = await this.client.responses.create(
         {
           ...cleanParams,
           stream: true,
@@ -456,7 +472,8 @@ export abstract class OpenAIBaseResponsesTextAdapter<
 
         if (
           chunk.type === 'response.reasoning_text.delta' ||
-          chunk.type === 'response.reasoning_summary_text.delta'
+          chunk.type === 'response.reasoning_summary_text.delta' ||
+          chunk.type === 'response.reasoning.delta'
         ) {
           const raw = (chunk as { delta?: unknown }).delta
           const reasoningDelta = Array.isArray(raw)
@@ -781,6 +798,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
    * - response.created / response.incomplete / response.failed
    * - response.output_text.delta
    * - response.reasoning_text.delta
+   * - response.reasoning.delta (the legacy type used before response.reasoning_text.delta)
    * - response.reasoning_summary_text.delta
    * - response.content_part.added / response.content_part.done
    * - response.output_item.added
@@ -789,7 +807,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
    * - error
    */
   protected async *processStreamChunks(
-    stream: AsyncIterable<ResponseStreamEvent>,
+    stream: AsyncIterable<ResponseStreamEvent | LegacyReasoningDeltaEvent>,
     toolCallMetadata: Map<string, StreamedFunctionCallMetadata>,
     options: TextOptions<TProviderOptions>,
     aguiState: {
@@ -798,7 +816,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
       messageId: string
       hasEmittedRunStarted: boolean
     },
-  ): AsyncIterable<StreamChunk> {
+  ): AsyncIterable<AdapterYieldChunk> {
     const normalizeToolInput = createToolInputNormalizer(
       options.tools,
       (schema, required) =>
@@ -817,12 +835,95 @@ export abstract class OpenAIBaseResponsesTextAdapter<
     // AG-UI lifecycle tracking
     let stepId: string | null = null
     let hasEmittedTextMessageStart = false
-    let hasEmittedStepStarted = false
+    let reasoningMessageId: string | undefined
+    let hasClosedReasoning = false
     // Track whether we've emitted a terminal RUN_FINISHED so the
     // end-of-stream fallback below knows to synthesise one when the upstream
     // cuts off without a response.completed event.
     let runFinishedEmitted = false
 
+    const adapterName = this.name
+    const emitModel = () => model || options.model
+
+    const openReasoning = function* (): Generator<AdapterYieldChunk> {
+      if (reasoningMessageId) return
+      reasoningMessageId = generateId(adapterName)
+      stepId = generateId(adapterName)
+      const timestamp = Date.now()
+      const currentModel = emitModel()
+      yield {
+        type: EventType.REASONING_START,
+        messageId: reasoningMessageId,
+        model: currentModel,
+        timestamp,
+      }
+      yield {
+        type: EventType.REASONING_MESSAGE_START,
+        messageId: reasoningMessageId,
+        role: 'reasoning' as const,
+        model: currentModel,
+        timestamp,
+      }
+      yield {
+        type: EventType.STEP_STARTED,
+        stepName: stepId,
+        stepId,
+        model: currentModel,
+        timestamp,
+        stepType: 'thinking',
+      }
+    }
+
+    const closeReasoning = function* (): Generator<AdapterYieldChunk> {
+      if (!reasoningMessageId || hasClosedReasoning) return
+      hasClosedReasoning = true
+      const timestamp = Date.now()
+      const currentModel = emitModel()
+      yield {
+        type: EventType.REASONING_MESSAGE_END,
+        messageId: reasoningMessageId,
+        model: currentModel,
+        timestamp,
+      }
+      yield {
+        type: EventType.REASONING_END,
+        messageId: reasoningMessageId,
+        model: currentModel,
+        timestamp,
+      }
+      if (stepId) {
+        yield {
+          type: EventType.STEP_FINISHED,
+          stepName: stepId,
+          stepId,
+          model: currentModel,
+          timestamp,
+          content: accumulatedReasoning,
+        }
+      }
+      reasoningMessageId = undefined
+      stepId = null
+      hasClosedReasoning = false
+      accumulatedReasoning = ''
+    }
+
+    const emitReasoningDelta = function* (
+      text: string,
+    ): Generator<AdapterYieldChunk> {
+      if (!text) return
+      yield* openReasoning()
+      if (!reasoningMessageId) return
+      accumulatedReasoning += text
+      hasStreamedReasoningDeltas = true
+      yield {
+        type: EventType.REASONING_MESSAGE_CONTENT,
+        messageId: reasoningMessageId,
+        delta: text,
+        model: emitModel(),
+        timestamp: Date.now(),
+      }
+    }
+
     try {
       for await (const chunk of stream) {
         options.logger.provider(`provider=${this.name} type=${chunk.type}`, {
@@ -847,7 +948,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
           type: string
           text?: string
           refusal?: string
-        }): StreamChunk => {
+        }): AdapterYieldChunk => {
           if (contentPart.type === 'output_text') {
             accumulatedContent += contentPart.text || ''
             return {
@@ -860,25 +961,6 @@ export abstract class OpenAIBaseResponsesTextAdapter<
             }
           }
 
-          if (contentPart.type === 'reasoning_text') {
-            accumulatedReasoning += contentPart.text || ''
-            // Cache the fallback stepId rather than generating a fresh one
-            // on every call — otherwise multiple reasoning chunks arriving
-            // before STEP_STARTED was emitted (e.g. via response.content_part.done
-            // alone) would each get a different stepId and break correlation.
-            if (!stepId) {
-              stepId = generateId(this.name)
-            }
-            return {
-              type: EventType.STEP_FINISHED,
-              stepName: stepId,
-              stepId,
-              model: model || options.model,
-              timestamp: Date.now(),
-              delta: contentPart.text || '',
-              content: accumulatedReasoning,
-            }
-          }
           // Either a real refusal or an unknown content_part type. Surface
           // the part type in the error so unknown parts are debuggable
           // instead of being misreported as "Unknown refusal".
@@ -913,7 +995,9 @@ export abstract class OpenAIBaseResponsesTextAdapter<
           hasStreamedContentDeltas = false
           hasStreamedReasoningDeltas = false
           hasEmittedTextMessageStart = false
-          hasEmittedStepStarted = false
+          reasoningMessageId = undefined
+          hasClosedReasoning = false
+          stepId = null
           accumulatedContent = ''
           accumulatedReasoning = ''
         }
@@ -928,6 +1012,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
           chunk.type === 'response.failed' ||
           chunk.type === 'response.incomplete'
         ) {
+          yield* closeReasoning()
           if (hasEmittedTextMessageStart) {
             yield {
               type: EventType.TEXT_MESSAGE_END,
@@ -983,6 +1068,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
               : ''
 
           if (textDelta) {
+            yield* closeReasoning()
             // Emit TEXT_MESSAGE_START on first text content
             if (!hasEmittedTextMessageStart) {
               hasEmittedTextMessageStart = true
@@ -1010,81 +1096,27 @@ export abstract class OpenAIBaseResponsesTextAdapter<
 
         // Handle reasoning deltas (token-by-token thinking/reasoning streaming)
         // response.reasoning_text.delta provides incremental reasoning updates
-        if (chunk.type === 'response.reasoning_text.delta' && chunk.delta) {
-          // Delta can be an array of strings or a single string
+        if (
+          (chunk.type === 'response.reasoning_text.delta' ||
+            chunk.type === 'response.reasoning.delta') &&
+          chunk.delta
+        ) {
           const reasoningDelta = Array.isArray(chunk.delta)
             ? chunk.delta.join('')
             : typeof chunk.delta === 'string'
               ? chunk.delta
               : ''
-
-          if (reasoningDelta) {
-            // Emit STEP_STARTED on first reasoning content
-            if (!hasEmittedStepStarted) {
-              hasEmittedStepStarted = true
-              stepId = generateId(this.name)
-              yield {
-                type: EventType.STEP_STARTED,
-                stepName: stepId,
-                stepId,
-                model: model || options.model,
-                timestamp: Date.now(),
-                stepType: 'thinking',
-              }
-            }
-
-            accumulatedReasoning += reasoningDelta
-            hasStreamedReasoningDeltas = true
-            const fallbackStepId = stepId || generateId(this.name)
-            yield {
-              type: EventType.STEP_FINISHED,
-              stepName: fallbackStepId,
-              stepId: fallbackStepId,
-              model: model || options.model,
-              timestamp: Date.now(),
-              delta: reasoningDelta,
-              content: accumulatedReasoning,
-            }
-          }
+          yield* emitReasoningDelta(reasoningDelta)
         }
 
         // Handle reasoning summary deltas (when using reasoning.summary option)
-        // response.reasoning_summary_text.delta provides incremental summary updates
         if (
           chunk.type === 'response.reasoning_summary_text.delta' &&
           chunk.delta
         ) {
           const summaryDelta =
             typeof chunk.delta === 'string' ? chunk.delta : ''
-
-          if (summaryDelta) {
-            // Emit STEP_STARTED on first reasoning content
-            if (!hasEmittedStepStarted) {
-              hasEmittedStepStarted = true
-              stepId = generateId(this.name)
-              yield {
-                type: EventType.STEP_STARTED,
-                stepName: stepId,
-                stepId,
-                model: model || options.model,
-                timestamp: Date.now(),
-                stepType: 'thinking',
-              }
-            }
-
-            accumulatedReasoning += summaryDelta
-            hasStreamedReasoningDeltas = true
-            const fallbackStepId = stepId || generateId(this.name)
-            yield {
-              type: EventType.STEP_FINISHED,
-              stepName: fallbackStepId,
-              stepId: fallbackStepId,
-              model: model || options.model,
-              timestamp: Date.now(),
-              delta: summaryDelta,
-              content: accumulatedReasoning,
-            }
-          }
+          yield* emitReasoningDelta(summaryDelta)
         }
 
         // handle content_part added events for text, reasoning and refusals
@@ -1101,11 +1133,15 @@ export abstract class OpenAIBaseResponsesTextAdapter<
           ) {
             continue
           }
-          // Emit TEXT_MESSAGE_START if this is text content
+          if (contentPart.type === 'reasoning_text') {
+            yield* emitReasoningDelta(contentPart.text || '')
+            continue
+          }
           if (
             contentPart.type === 'output_text' &&
             !hasEmittedTextMessageStart
           ) {
+            yield* closeReasoning()
             hasEmittedTextMessageStart = true
             yield {
               type: EventType.TEXT_MESSAGE_START,
@@ -1115,27 +1151,12 @@ export abstract class OpenAIBaseResponsesTextAdapter<
               role: 'assistant',
             }
           }
-          // Emit STEP_STARTED if this is reasoning content
-          if (contentPart.type === 'reasoning_text' && !hasEmittedStepStarted) {
-            hasEmittedStepStarted = true
-            stepId = generateId(this.name)
-            yield {
-              type: EventType.STEP_STARTED,
-              stepName: stepId,
-              stepId,
-              model: model || options.model,
-              timestamp: Date.now(),
-              stepType: 'thinking',
-            }
-          }
           // Mark whichever stream we just emitted into so a subsequent
           // `content_part.done` doesn't duplicate the same text. Without
           // this flag, an `added` event carrying the full text followed by
           // a matching `done` event would emit TEXT_MESSAGE_CONTENT twice.
           if (contentPart.type === 'output_text') {
             hasStreamedContentDeltas = true
-          } else if (contentPart.type === 'reasoning_text') {
-            hasStreamedReasoningDeltas = true
           }
           const partChunk = handleContentPart(contentPart)
           yield partChunk
@@ -1172,10 +1193,15 @@ export abstract class OpenAIBaseResponsesTextAdapter<
           // without a start and never see an end. Emit the lifecycle opener
           // for whichever stream this content_part belongs to before yielding
           // the CONTENT chunk; the post-loop block emits the matching END.
+          if (contentPart.type === 'reasoning_text') {
+            yield* emitReasoningDelta(contentPart.text || '')
+            continue
+          }
           if (
             contentPart.type === 'output_text' &&
             !hasEmittedTextMessageStart
           ) {
+            yield* closeReasoning()
             hasEmittedTextMessageStart = true
             yield {
               type: EventType.TEXT_MESSAGE_START,
@@ -1184,20 +1210,6 @@ export abstract class OpenAIBaseResponsesTextAdapter<
               timestamp: Date.now(),
               role: 'assistant',
             }
-          } else if (
-            contentPart.type === 'reasoning_text' &&
-            !hasEmittedStepStarted
-          ) {
-            hasEmittedStepStarted = true
-            stepId = generateId(this.name)
-            yield {
-              type: EventType.STEP_STARTED,
-              stepName: stepId,
-              stepId,
-              model: model || options.model,
-              timestamp: Date.now(),
-              stepType: 'thinking',
-            }
           }
 
           // Only emit if we haven't been streaming deltas (e.g., for non-streaming responses)
@@ -1573,6 +1585,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
             }
           }
 
+          yield* closeReasoning()
           // Emit TEXT_MESSAGE_END if we had text content
           if (hasEmittedTextMessageStart) {
             yield {
@@ -1655,6 +1668,7 @@ export abstract class OpenAIBaseResponsesTextAdapter<
       // mirrors the chat-completions adapter's behavior so consumers always
       // see a terminal event for every started run.
       if (!runFinishedEmitted && aguiState.hasEmittedRunStarted) {
+        yield* closeReasoning()
         if (hasEmittedTextMessageStart) {
           yield {
             type: EventType.TEXT_MESSAGE_END,
@@ -2035,9 +2049,9 @@ export abstract class OpenAIBaseResponsesTextAdapter<
    * Handles backward compatibility with string content.
    */
   protected normalizeContent(
-    content: string | null | Array<ContentPart>,
+    content: string | null | undefined | Array<ContentPart>,
   ): Array<ContentPart> {
-    if (content === null) {
+    if (content === null || content === undefined) {
       return []
     }
     if (typeof content === 'string') {
@@ -2050,9 +2064,9 @@ export abstract class OpenAIBaseResponsesTextAdapter<
    * Extracts text content from a content value that may be string, null, or ContentPart array.
    */
   protected extractTextContent(
-    content: string | null | Array<ContentPart>,
+    content: string | null | undefined | Array<ContentPart>,
   ): string {
-    if (content === null) {
+    if (content === null || content === undefined) {
       return ''
     }
     if (typeof content === 'string') {