@tanstack/openai-base 0.2.1 → 0.3.0

package/src/adapters/responses-text.ts

@@ -1,16 +1,22 @@
+import { EventType } from '@tanstack/ai'
 import { BaseTextAdapter } from '@tanstack/ai/adapters'
 import { toRunErrorPayload } from '@tanstack/ai/adapter-internals'
 import { generateId, transformNullsToUndefined } from '@tanstack/ai-utils'
-import { createOpenAICompatibleClient } from '../utils/client'
 import { extractRequestOptions } from '../utils/request-options'
 import { makeStructuredOutputCompatible } from '../utils/schema-converter'
 import { convertToolsToResponsesFormat } from './responses-tool-converter'
+import type OpenAI from 'openai'
 import type {
   StructuredOutputOptions,
   StructuredOutputResult,
 } from '@tanstack/ai/adapters'
-import type OpenAI_SDK from 'openai'
-import type { Responses } from 'openai/resources'
+import type {
+  Response,
+  ResponseCreateParams,
+  ResponseInput,
+  ResponseInputContent,
+  ResponseStreamEvent,
+} from 'openai/resources/responses/responses'
 import type {
   ContentPart,
   DefaultMessageMetadataByModality,
@@ -19,39 +25,16 @@ import type {
   StreamChunk,
   TextOptions,
 } from '@tanstack/ai'
-import type { OpenAICompatibleClientConfig } from '../types/config'
-
-/** Cast an event object to StreamChunk. Adapters construct events with string
- *  literal types which are structurally compatible with the EventType enum. */
-const asChunk = (chunk: Record<string, unknown>) =>
-  chunk as unknown as StreamChunk
 
 /**
- * OpenAI-compatible Responses API Text Adapter
- *
- * A generalized base class for providers that use the OpenAI Responses API
- * (`/v1/responses`). Providers like OpenAI (native), Azure OpenAI, and others
- * that implement the Responses API can extend this class and only need to:
- * - Set `baseURL` in the config
- * - Lock the generic type parameters to provider-specific types
- * - Override specific methods for quirks
- *
- * Key differences from the Chat Completions adapter:
- * - Uses `client.responses.create()` instead of `client.chat.completions.create()`
- * - Messages use `ResponseInput` format
- * - System prompts go in `instructions` field, not as array messages
- * - Streaming events are completely different (9+ event types vs simple delta chunks)
- * - Supports reasoning/thinking tokens via `response.reasoning_text.delta`
- * - Structured output uses `text.format` in the request (not `response_format`)
- * - Tool calls use `response.function_call_arguments.delta`
- * - Content parts are `input_text`, `input_image`, `input_file`
- *
- * All methods that build requests or process responses are `protected` so subclasses
- * can override them.
+ * Shared implementation of the OpenAI Responses API. Holds the stream-event
+ * accumulator + AG-UI lifecycle and calls the OpenAI SDK directly. Subclasses
+ * (today: ai-openai) construct an OpenAI client with their provider-specific
+ * `baseURL` / headers and pass it in.
  */
-export class OpenAICompatibleResponsesTextAdapter<
+export abstract class OpenAIBaseResponsesTextAdapter<
   TModel extends string,
-  TProviderOptions extends Record<string, any> = Record<string, any>,
+  TProviderOptions extends Record<string, unknown> = Record<string, unknown>,
   TInputModalities extends ReadonlyArray<Modality> = ReadonlyArray<Modality>,
   TMessageMetadata extends DefaultMessageMetadataByModality =
     DefaultMessageMetadataByModality,
@@ -65,17 +48,12 @@ export class OpenAICompatibleResponsesTextAdapter<
 > {
   readonly kind = 'text' as const
   readonly name: string
+  protected client: OpenAI
 
-  protected client: OpenAI_SDK
-
-  constructor(
-    config: OpenAICompatibleClientConfig,
-    model: TModel,
-    name: string = 'openai-compatible-responses',
-  ) {
+  constructor(model: TModel, name: string, client: OpenAI) {
     super({}, model)
     this.name = name
-    this.client = createOpenAICompatibleClient(config)
+    this.client = client
   }
 
   async *chatStream(
@@ -87,20 +65,34 @@ export class OpenAICompatibleResponsesTextAdapter<
     // We assign our own indices as we encounter unique tool call IDs.
     const toolCallMetadata = new Map<
       string,
-      { index: number; name: string; started: boolean }
+      {
+        index: number
+        name: string
+        started: boolean
+        // Set once TOOL_CALL_END has been emitted (via args.done or the
+        // output_item.done backfill) so the two paths don't double-emit.
+        ended?: boolean
+        // Set when args.done arrives before TOOL_CALL_START could fire
+        // (output_item.added lacked a name). output_item.done picks these
+        // up to emit the missing END.
+        pendingArguments?: string
+      }
     >()
-    const requestParams = this.mapOptionsToRequest(options)
-    const timestamp = Date.now()
 
     // AG-UI lifecycle tracking
     const aguiState = {
       runId: generateId(this.name),
+      threadId: options.threadId ?? generateId(this.name),
       messageId: generateId(this.name),
-      timestamp,
       hasEmittedRunStarted: false,
     }
 
     try {
+      // mapOptionsToRequest can throw on caller-side validation failures
+      // (empty user content, unsupported parts, webSearchTool() rejection in
+      // the OpenRouter override). Keep it inside the try so those failures
+      // surface as RUN_ERROR events instead of iterator throws.
+      const requestParams = this.mapOptionsToRequest(options)
       options.logger.request(
         `activity=chat provider=${this.name} model=${this.model} messages=${options.messages.length} tools=${options.tools?.length ?? 0} stream=true`,
         { provider: this.name, model: this.model },
@@ -130,22 +122,24 @@ export class OpenAICompatibleResponsesTextAdapter<
       // Emit RUN_STARTED if not yet emitted
       if (!aguiState.hasEmittedRunStarted) {
         aguiState.hasEmittedRunStarted = true
-        yield asChunk({
-          type: 'RUN_STARTED',
+        yield {
+          type: EventType.RUN_STARTED,
           runId: aguiState.runId,
+          threadId: aguiState.threadId,
           model: options.model,
-          timestamp,
-        })
+          timestamp: Date.now(),
+        }
       }
 
       // Emit AG-UI RUN_ERROR
-      yield asChunk({
-        type: 'RUN_ERROR',
-        runId: aguiState.runId,
+      yield {
+        type: EventType.RUN_ERROR,
         model: options.model,
-        timestamp,
+        timestamp: Date.now(),
+        message: errorPayload.message,
+        code: errorPayload.code,
         error: errorPayload,
-      })
+      }
 
       options.logger.errors(`${this.name}.chatStream fatal`, {
         error: errorPayload,
@@ -195,10 +189,7 @@ export class OpenAICompatibleResponsesTextAdapter<
       )
       const response = await this.client.responses.create(
         {
-          ...(cleanParams as Omit<
-            OpenAI_SDK.Responses.ResponseCreateParams,
-            'stream'
-          >),
+          ...(cleanParams as Omit<ResponseCreateParams, 'stream'>),
           stream: false,
           // Configure structured output via text.format
           text: {
@@ -217,9 +208,17 @@ export class OpenAICompatibleResponsesTextAdapter<
       // SDK return type to `Response`, but the explicit annotation makes
       // that contract local rather than relying on inference through the
       // overloaded `client.responses.create` signature.
-      const rawText = this.extractTextFromResponse(
-        response satisfies OpenAI_SDK.Responses.Response,
-      )
+      const rawText = this.extractTextFromResponse(response satisfies Response)
+
+      // Fail loud on empty content rather than letting it cascade into a
+      // confusing "Failed to parse JSON. Content: " error — the root cause
+      // (the model returned no text content for the structured request) is
+      // then visible in logs. Mirrors the chat-completions sibling.
+      if (rawText.length === 0) {
+        throw new Error(
+          `${this.name}.structuredOutput: response contained no content`,
+        )
+      }
 
       // Parse the JSON response
       let parsed: unknown
@@ -231,9 +230,13 @@ export class OpenAICompatibleResponsesTextAdapter<
         )
       }
 
-      // Transform null values to undefined to match original Zod schema expectations
-      // Provider returns null for optional fields we made nullable in the schema
-      const transformed = transformNullsToUndefined(parsed)
+      // Apply the provider-specific post-parse shaping (default: null →
+      // undefined to align with the original Zod schema's optional-field
+      // semantics; subclasses with different conventions can override
+      // `transformStructuredOutput`, mirroring the chat-completions base's
+      // hook so OpenRouter and other providers that preserve nulls in
+      // structured output can opt out without forking `structuredOutput`).
+      const transformed = this.transformStructuredOutput(parsed)
 
       return {
         data: transformed,
@@ -250,6 +253,387 @@ export class OpenAICompatibleResponsesTextAdapter<
     }
   }
 
+  /**
+   * 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.completed`, `response.failed`) and re-emits the standard AG-UI
+   * lifecycle ending with `CUSTOM 'structured-output.complete'`.
+   *
+   * Tools are stripped (structured output is mutually exclusive with tool
+   * calls in this path). Reasoning text is accumulated and surfaced both as
+   * REASONING_* lifecycle events during the stream and on the terminal
+   * CUSTOM event's `value.reasoning`.
+   */
+  async *structuredOutputStream(
+    options: StructuredOutputOptions<TProviderOptions>,
+  ): AsyncIterable<StreamChunk> {
+    const { chatOptions, outputSchema } = options
+    const requestParams = this.mapOptionsToRequest(chatOptions)
+
+    const jsonSchema = this.makeStructuredOutputCompatible(
+      outputSchema,
+      outputSchema.required,
+    )
+
+    const timestamp = Date.now()
+    const aguiState = {
+      runId: generateId(this.name),
+      threadId: chatOptions.threadId ?? generateId(this.name),
+      messageId: generateId(this.name),
+      timestamp,
+      hasEmittedRunStarted: false,
+    }
+
+    let accumulatedContent = ''
+    let accumulatedReasoning = ''
+    let hasEmittedTextMessageStart = false
+    let reasoningMessageId: string | undefined
+    let stepId: string | undefined
+    let hasClosedReasoning = false
+    let model: string = chatOptions.model
+    let usage: OpenAI.Responses.Response['usage'] | undefined
+
+    const closeReasoning = function* (this: {
+      name: string
+    }): Generator<StreamChunk> {
+      if (reasoningMessageId && !hasClosedReasoning) {
+        hasClosedReasoning = true
+        yield {
+          type: EventType.REASONING_MESSAGE_END,
+          messageId: reasoningMessageId,
+          model,
+          timestamp,
+        }
+        yield {
+          type: EventType.REASONING_END,
+          messageId: reasoningMessageId,
+          model,
+          timestamp,
+        }
+        if (stepId) {
+          yield {
+            type: EventType.STEP_FINISHED,
+            stepName: stepId,
+            stepId,
+            model,
+            timestamp,
+            content: accumulatedReasoning,
+          }
+        }
+      }
+    }.bind(this)
+
+    const openReasoning = function* (this: {
+      name: string
+    }): Generator<StreamChunk> {
+      if (reasoningMessageId) return
+      reasoningMessageId = generateId(this.name)
+      stepId = generateId(this.name)
+      yield {
+        type: EventType.REASONING_START,
+        messageId: reasoningMessageId,
+        model,
+        timestamp,
+      }
+      yield {
+        type: EventType.REASONING_MESSAGE_START,
+        messageId: reasoningMessageId,
+        role: 'reasoning' as const,
+        model,
+        timestamp,
+      }
+      yield {
+        type: EventType.STEP_STARTED,
+        stepName: stepId,
+        stepId,
+        model,
+        timestamp,
+        stepType: 'thinking',
+      }
+    }.bind(this)
+
+    try {
+      const { tools: _tools, ...cleanParams } = requestParams
+      void _tools
+
+      chatOptions.logger.request(
+        `activity=structuredOutputStream provider=${this.name} model=${this.model} messages=${chatOptions.messages.length}`,
+        { provider: this.name, model: this.model },
+      )
+
+      const stream = await this.client.responses.create(
+        {
+          ...cleanParams,
+          stream: true,
+          text: {
+            format: {
+              type: 'json_schema',
+              name: 'structured_output',
+              schema: jsonSchema,
+              strict: true,
+            },
+          },
+        },
+        extractRequestOptions(chatOptions.request),
+      )
+
+      for await (const chunk of stream) {
+        chatOptions.logger.provider(
+          `provider=${this.name} type=${chunk.type}`,
+          { provider: this.name, type: chunk.type },
+        )
+
+        if (!aguiState.hasEmittedRunStarted) {
+          aguiState.hasEmittedRunStarted = true
+          yield {
+            type: EventType.RUN_STARTED,
+            runId: aguiState.runId,
+            threadId: aguiState.threadId,
+            model,
+            timestamp,
+          }
+        }
+
+        if (
+          chunk.type === 'response.created' ||
+          chunk.type === 'response.in_progress'
+        ) {
+          const responseModel = (chunk as { response?: { model?: string } })
+            .response?.model
+          if (responseModel) model = responseModel
+          continue
+        }
+
+        if (chunk.type === 'response.refusal.delta') {
+          const delta =
+            typeof (chunk as { delta?: unknown }).delta === 'string'
+              ? (chunk as { delta: string }).delta
+              : ''
+          yield {
+            type: EventType.RUN_ERROR,
+            runId: aguiState.runId,
+            model,
+            timestamp,
+            message: `Model refused: ${delta}`,
+            code: 'refusal',
+            error: { message: `Model refused: ${delta}`, code: 'refusal' },
+          }
+          return
+        }
+
+        if (
+          chunk.type === 'response.reasoning_text.delta' ||
+          chunk.type === 'response.reasoning_summary_text.delta'
+        ) {
+          const raw = (chunk as { delta?: unknown }).delta
+          const reasoningDelta = Array.isArray(raw)
+            ? raw.join('')
+            : typeof raw === 'string'
+              ? raw
+              : ''
+          if (!reasoningDelta) continue
+          yield* openReasoning()
+          // openReasoning() guarantees reasoningMessageId is set on first call;
+          // TS can't see through the generator side-effect.
+          const messageId = reasoningMessageId!
+          accumulatedReasoning += reasoningDelta
+          yield {
+            type: EventType.REASONING_MESSAGE_CONTENT,
+            messageId,
+            delta: reasoningDelta,
+            model,
+            timestamp,
+          }
+          continue
+        }
+
+        if (chunk.type === 'response.output_text.delta') {
+          const raw = (chunk as { delta?: unknown }).delta
+          const textDelta = Array.isArray(raw)
+            ? raw.join('')
+            : typeof raw === 'string'
+              ? raw
+              : ''
+          if (!textDelta) continue
+
+          yield* closeReasoning()
+
+          if (!hasEmittedTextMessageStart) {
+            hasEmittedTextMessageStart = true
+            yield {
+              type: EventType.TEXT_MESSAGE_START,
+              messageId: aguiState.messageId,
+              model,
+              timestamp,
+              role: 'assistant',
+            }
+          }
+          accumulatedContent += textDelta
+          yield {
+            type: EventType.TEXT_MESSAGE_CONTENT,
+            messageId: aguiState.messageId,
+            model,
+            timestamp,
+            delta: textDelta,
+            content: accumulatedContent,
+          }
+          continue
+        }
+
+        if (chunk.type === 'response.completed') {
+          const response = chunk.response
+          if (response.usage) usage = response.usage
+          if (response.model) model = response.model
+          continue
+        }
+
+        if (chunk.type === 'response.failed') {
+          const response = (
+            chunk as {
+              response?: { error?: { message?: string; code?: string } }
+            }
+          ).response
+          const message =
+            response?.error?.message || 'Responses API stream failed'
+          yield {
+            type: EventType.RUN_ERROR,
+            runId: aguiState.runId,
+            model,
+            timestamp,
+            message,
+            code: response?.error?.code,
+            error: { message, code: response?.error?.code },
+          }
+          return
+        }
+      }
+
+      yield* closeReasoning()
+
+      if (hasEmittedTextMessageStart) {
+        yield {
+          type: EventType.TEXT_MESSAGE_END,
+          messageId: aguiState.messageId,
+          model,
+          timestamp,
+        }
+      }
+
+      if (accumulatedContent.length === 0) {
+        yield {
+          type: EventType.RUN_ERROR,
+          runId: aguiState.runId,
+          model,
+          timestamp,
+          message: `${this.name}.structuredOutputStream: response contained no content`,
+          code: 'empty-response',
+          error: {
+            message: `${this.name}.structuredOutputStream: response contained no content`,
+            code: 'empty-response',
+          },
+        }
+        return
+      }
+
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(accumulatedContent)
+      } catch {
+        yield {
+          type: EventType.RUN_ERROR,
+          runId: aguiState.runId,
+          model,
+          timestamp,
+          message: `Failed to parse structured output as JSON. Content: ${accumulatedContent.slice(0, 200)}${accumulatedContent.length > 200 ? '...' : ''}`,
+          code: 'parse-error',
+          error: {
+            message: 'Failed to parse structured output as JSON',
+            code: 'parse-error',
+          },
+        }
+        return
+      }
+
+      const transformed = transformNullsToUndefined(parsed)
+
+      yield {
+        type: EventType.CUSTOM,
+        name: 'structured-output.complete',
+        value: {
+          object: transformed,
+          raw: accumulatedContent,
+          ...(accumulatedReasoning ? { reasoning: accumulatedReasoning } : {}),
+        },
+        model,
+        timestamp,
+      }
+
+      yield {
+        type: EventType.RUN_FINISHED,
+        runId: aguiState.runId,
+        threadId: aguiState.threadId,
+        model,
+        timestamp,
+        finishReason: 'stop',
+        ...(usage && {
+          usage: {
+            promptTokens: usage.input_tokens,
+            completionTokens: usage.output_tokens,
+            totalTokens: usage.total_tokens,
+          },
+        }),
+      }
+    } catch (error: unknown) {
+      if (!aguiState.hasEmittedRunStarted) {
+        aguiState.hasEmittedRunStarted = true
+        yield {
+          type: EventType.RUN_STARTED,
+          runId: aguiState.runId,
+          threadId: aguiState.threadId,
+          model,
+          timestamp,
+        }
+      }
+
+      const isAbort = this.isAbortError(error)
+      const errorPayload = toRunErrorPayload(
+        error,
+        `${this.name}.structuredOutputStream failed`,
+      )
+
+      yield {
+        type: EventType.RUN_ERROR,
+        runId: aguiState.runId,
+        model,
+        timestamp,
+        message: errorPayload.message,
+        code: isAbort ? 'aborted' : errorPayload.code,
+        error: { ...errorPayload, ...(isAbort && { code: 'aborted' }) },
+      }
+
+      chatOptions.logger.errors(`${this.name}.structuredOutputStream fatal`, {
+        error: errorPayload,
+        source: `${this.name}.structuredOutputStream`,
+      })
+    }
+  }
+
+  /**
+   * Cross-SDK abort detection for `structuredOutputStream`. Mirrors the
+   * Chat Completions base; subclasses with proprietary error types override.
+   */
+  protected isAbortError(error: unknown): boolean {
+    if (!error || typeof error !== 'object') return false
+    const e = error as { name?: unknown; code?: unknown }
+    return (
+      e.name === 'APIUserAbortError' ||
+      e.name === 'AbortError' ||
+      e.code === 'ERR_CANCELED'
+    )
+  }
+
   /**
    * Applies provider-specific transformations for structured output compatibility.
    * Override this in subclasses to handle provider-specific quirks.
@@ -261,26 +645,49 @@ export class OpenAICompatibleResponsesTextAdapter<
     return makeStructuredOutputCompatible(schema, originalRequired)
   }
 
+  /**
+   * Final shaping pass applied to parsed structured-output JSON before it is
+   * returned to the caller. Default converts `null` values to `undefined` so
+   * the result aligns with the original Zod schema's optional-field
+   * semantics. Subclasses with different conventions (OpenRouter historically
+   * preserves nulls) can override — mirrors the chat-completions base's hook
+   * so a subclass that opts out of null-stripping doesn't have to fork the
+   * whole `structuredOutput` method.
+   */
+  protected transformStructuredOutput(parsed: unknown): unknown {
+    return transformNullsToUndefined(parsed)
+  }
+
   /**
    * Extract text content from a non-streaming Responses API response.
    * Override this in subclasses for provider-specific response shapes.
    */
-  protected extractTextFromResponse(
-    response: OpenAI_SDK.Responses.Response,
-  ): string {
+  protected extractTextFromResponse(response: Response): string {
     let textContent = ''
     let refusal: string | undefined
+    let sawMessageItem = false
+    const observedItemTypes = new Set<string>()
 
     for (const item of response.output) {
+      observedItemTypes.add(item.type)
       if (item.type === 'message') {
+        sawMessageItem = true
         for (const part of item.content) {
-          if (part.type === 'output_text') {
-            textContent += part.text
+          // Cast off the discriminated union before the type discrimination
+          // so future SDK variants (e.g. `output_audio`, `output_image`) hit
+          // the explicit error path rather than being misreported as refusals
+          // when they get added to the union. Mirrors the streaming side's
+          // handleContentPart.
+          const partType = (part as { type: string }).type
+          if (partType === 'output_text') {
+            textContent += (part as { text?: string }).text ?? ''
+          } else if (partType === 'refusal') {
+            const refusalText = (part as { refusal?: string }).refusal
+            refusal = refusalText || refusal || 'Refused without explanation'
           } else {
-            // The Responses SDK currently models message content as
-            // `output_text | refusal`, so the only non-text branch is a
-            // refusal. Capture it so we can surface a distinct error below.
-            refusal = part.refusal || refusal || 'Refused without explanation'
+            throw new Error(
+              `${this.name}.extractTextFromResponse: unsupported message content part type "${partType}"`,
+            )
           }
         }
       }
@@ -295,6 +702,16 @@ export class OpenAICompatibleResponsesTextAdapter<
       throw err
     }
 
+    // Response had items but none carried message text (e.g. only
+    // function_call or reasoning items). Surface that explicitly so a
+    // downstream structured-output caller doesn't see a misleading
+    // "Failed to parse JSON. Content: " from an empty string.
+    if (!textContent && response.output.length > 0 && !sawMessageItem) {
+      throw new Error(
+        `${this.name}.extractTextFromResponse: response.output contained items of type(s) [${[...observedItemTypes].sort().join(', ')}] but no message text — the model returned a non-text response`,
+      )
+    }
+
     return textContent
   }
 
@@ -314,22 +731,27 @@ export class OpenAICompatibleResponsesTextAdapter<
    * - error
    */
   protected async *processStreamChunks(
-    stream: AsyncIterable<OpenAI_SDK.Responses.ResponseStreamEvent>,
+    stream: AsyncIterable<ResponseStreamEvent>,
     toolCallMetadata: Map<
       string,
-      { index: number; name: string; started: boolean }
+      {
+        index: number
+        name: string
+        started: boolean
+        ended?: boolean
+        pendingArguments?: string
+      }
     >,
     options: TextOptions<TProviderOptions>,
     aguiState: {
       runId: string
+      threadId: string
       messageId: string
-      timestamp: number
       hasEmittedRunStarted: boolean
     },
   ): AsyncIterable<StreamChunk> {
     let accumulatedContent = ''
     let accumulatedReasoning = ''
-    const timestamp = aguiState.timestamp
 
     // Track if we've been streaming deltas to avoid duplicating content from done events
     let hasStreamedContentDeltas = false
@@ -357,12 +779,13 @@ export class OpenAICompatibleResponsesTextAdapter<
         // Emit RUN_STARTED on first chunk
         if (!aguiState.hasEmittedRunStarted) {
           aguiState.hasEmittedRunStarted = true
-          yield asChunk({
-            type: 'RUN_STARTED',
+          yield {
+            type: EventType.RUN_STARTED,
             runId: aguiState.runId,
+            threadId: aguiState.threadId,
             model: model || options.model,
-            timestamp,
-          })
+            timestamp: Date.now(),
+          }
         }
 
         const handleContentPart = (contentPart: {
@@ -372,14 +795,14 @@ export class OpenAICompatibleResponsesTextAdapter<
         }): StreamChunk => {
           if (contentPart.type === 'output_text') {
             accumulatedContent += contentPart.text || ''
-            return asChunk({
-              type: 'TEXT_MESSAGE_CONTENT',
+            return {
+              type: EventType.TEXT_MESSAGE_CONTENT,
               messageId: aguiState.messageId,
               model: model || options.model,
-              timestamp,
+              timestamp: Date.now(),
               delta: contentPart.text || '',
               content: accumulatedContent,
-            })
+            }
           }
 
           if (contentPart.type === 'reasoning_text') {
@@ -391,14 +814,15 @@ export class OpenAICompatibleResponsesTextAdapter<
             if (!stepId) {
               stepId = generateId(this.name)
             }
-            return asChunk({
-              type: 'STEP_FINISHED',
+            return {
+              type: EventType.STEP_FINISHED,
+              stepName: stepId,
               stepId,
               model: model || options.model,
-              timestamp,
+              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
@@ -407,16 +831,15 @@ export class OpenAICompatibleResponsesTextAdapter<
           const message = isRefusal
             ? contentPart.refusal || 'Refused without explanation'
             : `Unsupported response content_part type: ${contentPart.type}`
-          return asChunk({
-            type: 'RUN_ERROR',
-            runId: aguiState.runId,
+          const code = isRefusal ? 'refusal' : contentPart.type
+          return {
+            type: EventType.RUN_ERROR,
             model: model || options.model,
-            timestamp,
-            error: {
-              message,
-              code: isRefusal ? 'refusal' : contentPart.type,
-            },
-          })
+            timestamp: Date.now(),
+            message,
+            code,
+            error: { message, code },
+          }
         }
 
         // Capture model metadata from any of these events (created starts
@@ -451,12 +874,12 @@ export class OpenAICompatibleResponsesTextAdapter<
           chunk.type === 'response.incomplete'
         ) {
           if (hasEmittedTextMessageStart) {
-            yield asChunk({
-              type: 'TEXT_MESSAGE_END',
+            yield {
+              type: EventType.TEXT_MESSAGE_END,
               messageId: aguiState.messageId,
               model: chunk.response.model,
-              timestamp,
-            })
+              timestamp: Date.now(),
+            }
             hasEmittedTextMessageStart = false
           }
           // Coalesce error + incomplete_details into a single RUN_ERROR
@@ -469,23 +892,25 @@ export class OpenAICompatibleResponsesTextAdapter<
               ? 'Response failed'
               : 'Response ended incomplete')
           const errorCode =
-            chunk.response.error?.code ||
-            (chunk.response.incomplete_details ? 'incomplete' : undefined)
+            chunk.response.error?.code ??
+            (chunk.response.incomplete_details ? 'incomplete' : undefined) ??
+            undefined
           // Always emit RUN_ERROR for terminal failure events, even when the
           // upstream omitted both `error` and `incomplete_details`. Skipping
           // emission on a `response.incomplete` with no detail would let the
           // post-loop synthetic block silently coerce the run to a clean
           // `RUN_FINISHED { finishReason: 'stop' }` — masking the failure.
-          yield asChunk({
-            type: 'RUN_ERROR',
-            runId: aguiState.runId,
+          yield {
+            type: EventType.RUN_ERROR,
             model: chunk.response.model,
-            timestamp,
+            timestamp: Date.now(),
+            message: errorMessage,
+            ...(errorCode !== undefined && { code: errorCode }),
             error: {
               message: errorMessage,
               ...(errorCode !== undefined && { code: errorCode }),
             },
-          })
+          }
           // RUN_ERROR is the terminal event for this run; stop processing
           // any further chunks the iterator might still deliver.
           runFinishedEmitted = true
@@ -506,25 +931,25 @@ export class OpenAICompatibleResponsesTextAdapter<
             // Emit TEXT_MESSAGE_START on first text content
             if (!hasEmittedTextMessageStart) {
               hasEmittedTextMessageStart = true
-              yield asChunk({
-                type: 'TEXT_MESSAGE_START',
+              yield {
+                type: EventType.TEXT_MESSAGE_START,
                 messageId: aguiState.messageId,
                 model: model || options.model,
-                timestamp,
+                timestamp: Date.now(),
                 role: 'assistant',
-              })
+              }
             }
 
             accumulatedContent += textDelta
             hasStreamedContentDeltas = true
-            yield asChunk({
-              type: 'TEXT_MESSAGE_CONTENT',
+            yield {
+              type: EventType.TEXT_MESSAGE_CONTENT,
               messageId: aguiState.messageId,
               model: model || options.model,
-              timestamp,
+              timestamp: Date.now(),
               delta: textDelta,
               content: accumulatedContent,
-            })
+            }
           }
         }
 
@@ -543,25 +968,28 @@ export class OpenAICompatibleResponsesTextAdapter<
             if (!hasEmittedStepStarted) {
               hasEmittedStepStarted = true
               stepId = generateId(this.name)
-              yield asChunk({
-                type: 'STEP_STARTED',
+              yield {
+                type: EventType.STEP_STARTED,
+                stepName: stepId,
                 stepId,
                 model: model || options.model,
-                timestamp,
+                timestamp: Date.now(),
                 stepType: 'thinking',
-              })
+              }
             }
 
             accumulatedReasoning += reasoningDelta
             hasStreamedReasoningDeltas = true
-            yield asChunk({
-              type: 'STEP_FINISHED',
-              stepId: stepId || generateId(this.name),
+            const fallbackStepId = stepId || generateId(this.name)
+            yield {
+              type: EventType.STEP_FINISHED,
+              stepName: fallbackStepId,
+              stepId: fallbackStepId,
               model: model || options.model,
-              timestamp,
+              timestamp: Date.now(),
               delta: reasoningDelta,
               content: accumulatedReasoning,
-            })
+            }
           }
         }
 
@@ -579,25 +1007,28 @@ export class OpenAICompatibleResponsesTextAdapter<
             if (!hasEmittedStepStarted) {
               hasEmittedStepStarted = true
               stepId = generateId(this.name)
-              yield asChunk({
-                type: 'STEP_STARTED',
+              yield {
+                type: EventType.STEP_STARTED,
+                stepName: stepId,
                 stepId,
                 model: model || options.model,
-                timestamp,
+                timestamp: Date.now(),
                 stepType: 'thinking',
-              })
+              }
             }
 
             accumulatedReasoning += summaryDelta
             hasStreamedReasoningDeltas = true
-            yield asChunk({
-              type: 'STEP_FINISHED',
-              stepId: stepId || generateId(this.name),
+            const fallbackStepId = stepId || generateId(this.name)
+            yield {
+              type: EventType.STEP_FINISHED,
+              stepName: fallbackStepId,
+              stepId: fallbackStepId,
               model: model || options.model,
-              timestamp,
+              timestamp: Date.now(),
               delta: summaryDelta,
               content: accumulatedReasoning,
-            })
+            }
           }
         }
 
@@ -610,25 +1041,26 @@ export class OpenAICompatibleResponsesTextAdapter<
             !hasEmittedTextMessageStart
           ) {
             hasEmittedTextMessageStart = true
-            yield asChunk({
-              type: 'TEXT_MESSAGE_START',
+            yield {
+              type: EventType.TEXT_MESSAGE_START,
               messageId: aguiState.messageId,
               model: model || options.model,
-              timestamp,
+              timestamp: Date.now(),
               role: 'assistant',
-            })
+            }
           }
           // Emit STEP_STARTED if this is reasoning content
           if (contentPart.type === 'reasoning_text' && !hasEmittedStepStarted) {
             hasEmittedStepStarted = true
             stepId = generateId(this.name)
-            yield asChunk({
-              type: 'STEP_STARTED',
+            yield {
+              type: EventType.STEP_STARTED,
+              stepName: stepId,
               stepId,
               model: model || options.model,
-              timestamp,
+              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
@@ -668,6 +1100,40 @@ export class OpenAICompatibleResponsesTextAdapter<
             continue
           }
 
+          // Upstreams that emit `content_part.done` without any preceding
+          // deltas (or `content_part.added`) still need a START event before
+          // CONTENT — otherwise consumers tracking start/end pairs see content
+          // 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 === 'output_text' &&
+            !hasEmittedTextMessageStart
+          ) {
+            hasEmittedTextMessageStart = true
+            yield {
+              type: EventType.TEXT_MESSAGE_START,
+              messageId: aguiState.messageId,
+              model: model || options.model,
+              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)
           const doneChunk = handleContentPart(contentPart)
           yield doneChunk
@@ -682,27 +1148,35 @@ export class OpenAICompatibleResponsesTextAdapter<
           const item = chunk.item
           if (item.type === 'function_call' && item.id) {
             const existing = toolCallMetadata.get(item.id)
-            // Only emit TOOL_CALL_START on the FIRST output_item.added for
-            // an item id. A duplicate emission (which can happen on retried
-            // streams or replay) would violate AG-UI's start-once contract.
-            if (!existing?.started) {
-              if (!existing) {
-                toolCallMetadata.set(item.id, {
-                  index: chunk.output_index,
-                  name: item.name || '',
-                  started: false,
-                })
-              }
-              yield asChunk({
-                type: 'TOOL_CALL_START',
+            // Track the item as soon as we see it so subsequent arg deltas
+            // aren't logged as orphans, but only emit TOOL_CALL_START when
+            // both id AND name are populated. Emitting START with an empty
+            // name would propagate into TOOL_CALL_END (which reads the same
+            // metadata) and route the tool call to whatever name happens to
+            // match `''` downstream — a silent misroute.
+            if (!existing) {
+              toolCallMetadata.set(item.id, {
+                index: chunk.output_index,
+                name: item.name || '',
+                started: false,
+              })
+            } else if (!existing.name && item.name) {
+              // A later output_item.added for the same id finally carries
+              // the name. Update so the gated emission below can fire.
+              existing.name = item.name
+            }
+            const metadata = toolCallMetadata.get(item.id)!
+            if (!metadata.started && metadata.name) {
+              yield {
+                type: EventType.TOOL_CALL_START,
                 toolCallId: item.id,
-                toolCallName: item.name || '',
-                toolName: item.name || '',
+                toolCallName: metadata.name,
+                toolName: metadata.name,
                 model: model || options.model,
-                timestamp,
+                timestamp: Date.now(),
                 index: chunk.output_index,
-              })
-              toolCallMetadata.get(item.id)!.started = true
+              }
+              metadata.started = true
             }
           }
         }
@@ -735,13 +1209,13 @@ export class OpenAICompatibleResponsesTextAdapter<
             )
             continue
           }
-          yield asChunk({
-            type: 'TOOL_CALL_ARGS',
+          yield {
+            type: EventType.TOOL_CALL_ARGS,
             toolCallId: chunk.item_id,
             model: model || options.model,
-            timestamp,
+            timestamp: Date.now(),
             delta: chunk.delta,
-          })
+          }
         }
 
         if (chunk.type === 'response.function_call_arguments.done') {
@@ -749,13 +1223,19 @@ export class OpenAICompatibleResponsesTextAdapter<
 
           // Get the function name from metadata (captured in output_item.added)
           const metadata = toolCallMetadata.get(item_id)
-          // Skip TOOL_CALL_END for items whose start was never emitted (no
-          // matching `output_item.added`). Emitting END without START would
-          // produce an unbalanced AG-UI lifecycle event downstream consumers
-          // can't pair.
+          // If the matching START was never emitted (the upstream sent an
+          // `output_item.added` without a name and no later event has filled
+          // it in yet), defer END until `output_item.done` or
+          // `response.completed` can backfill the name. We stash the raw
+          // arguments so the late emission has them. Emitting END without
+          // START would produce an unbalanced AG-UI lifecycle event
+          // downstream consumers can't pair.
           if (!metadata?.started) {
+            if (metadata) {
+              metadata.pendingArguments = chunk.arguments
+            }
             options.logger.errors(
-              `${this.name}.processStreamChunks orphan function_call_arguments.done`,
+              `${this.name}.processStreamChunks deferring function_call_arguments.done — TOOL_CALL_START not yet emitted (waiting for name)`,
               {
                 source: `${this.name}.processStreamChunks`,
                 toolCallId: item_id,
@@ -764,7 +1244,12 @@ export class OpenAICompatibleResponsesTextAdapter<
             )
             continue
           }
+          // The output_item.done backstop may have already emitted END (when
+          // it arrived before args.done with a populated item.arguments).
+          // Skip so we never produce a duplicate close for the same id.
+          if (metadata.ended) continue
           const name = metadata.name || ''
+          metadata.ended = true
 
           // Parse arguments. Surface parse failures via the logger so a
           // model emitting malformed JSON is debuggable instead of silently
@@ -792,26 +1277,177 @@ export class OpenAICompatibleResponsesTextAdapter<
             }
           }
 
-          yield asChunk({
-            type: 'TOOL_CALL_END',
+          yield {
+            type: EventType.TOOL_CALL_END,
             toolCallId: item_id,
             toolCallName: name,
             toolName: name,
             model: model || options.model,
-            timestamp,
+            timestamp: Date.now(),
             input: parsedInput,
-          })
+          }
+        }
+
+        // `output_item.done` is the last point at which a function_call's
+        // name is guaranteed to be on the wire — it carries the fully-formed
+        // ResponseFunctionToolCall. Use it as a backstop to recover any
+        // tool call whose name was missing from `output_item.added` (and
+        // whose START + END therefore never fired).
+        if (chunk.type === 'response.output_item.done') {
+          const item = chunk.item
+          if (item.type === 'function_call' && item.id) {
+            const metadata = toolCallMetadata.get(item.id) ?? {
+              index: chunk.output_index,
+              name: item.name || '',
+              started: false,
+            }
+            if (!toolCallMetadata.has(item.id)) {
+              toolCallMetadata.set(item.id, metadata)
+            } else if (!metadata.name && item.name) {
+              metadata.name = item.name
+            }
+            // Emit gated START if we now have a name and never started.
+            if (!metadata.started && metadata.name) {
+              yield {
+                type: EventType.TOOL_CALL_START,
+                toolCallId: item.id,
+                toolCallName: metadata.name,
+                toolName: metadata.name,
+                model: model || options.model,
+                timestamp: Date.now(),
+                index: metadata.index,
+              }
+              metadata.started = true
+            }
+            // Emit END if we have args (either from a previously-deferred
+            // args.done OR from item.arguments) and haven't already ended.
+            const rawArgs =
+              typeof item.arguments === 'string' && item.arguments.length > 0
+                ? item.arguments
+                : metadata.pendingArguments
+            if (metadata.started && !metadata.ended && rawArgs !== undefined) {
+              const name = metadata.name || ''
+              let parsedInput: unknown = {}
+              if (rawArgs) {
+                try {
+                  const parsed = JSON.parse(rawArgs)
+                  parsedInput =
+                    parsed && typeof parsed === 'object' ? parsed : {}
+                } catch (parseError) {
+                  options.logger.errors(
+                    `${this.name}.processStreamChunks tool-args JSON parse failed (output_item.done backfill)`,
+                    {
+                      error: toRunErrorPayload(
+                        parseError,
+                        `tool ${name} (${item.id}) returned malformed JSON arguments`,
+                      ),
+                      source: `${this.name}.processStreamChunks`,
+                      toolCallId: item.id,
+                      toolName: name,
+                      rawArguments: rawArgs,
+                    },
+                  )
+                  parsedInput = {}
+                }
+              }
+              yield {
+                type: EventType.TOOL_CALL_END,
+                toolCallId: item.id,
+                toolCallName: name,
+                toolName: name,
+                model: model || options.model,
+                timestamp: Date.now(),
+                input: parsedInput,
+              }
+              metadata.ended = true
+              metadata.pendingArguments = undefined
+            }
+          }
         }
 
         if (chunk.type === 'response.completed') {
+          // Final backstop for function_call lifecycle: if a function_call
+          // appears in `response.output[]` but was never matched by an
+          // output_item.added/done with a name, recover the missing START
+          // (and END if args were pending). Without this, a tool call could
+          // be silently dropped from the AG-UI stream while `hasFunctionCalls`
+          // below still routes the run's finishReason to 'tool_calls' —
+          // leaving consumers waiting for tool results they never saw start.
+          for (const item of chunk.response.output) {
+            if (item.type !== 'function_call' || !item.id) continue
+            const metadata = toolCallMetadata.get(item.id) ?? {
+              index: 0,
+              name: item.name || '',
+              started: false,
+            }
+            if (!toolCallMetadata.has(item.id)) {
+              toolCallMetadata.set(item.id, metadata)
+            } else if (!metadata.name && item.name) {
+              metadata.name = item.name
+            }
+            if (!metadata.started && metadata.name) {
+              yield {
+                type: EventType.TOOL_CALL_START,
+                toolCallId: item.id,
+                toolCallName: metadata.name,
+                toolName: metadata.name,
+                model: model || options.model,
+                timestamp: Date.now(),
+                index: metadata.index,
+              }
+              metadata.started = true
+            }
+            const rawArgs =
+              typeof item.arguments === 'string' && item.arguments.length > 0
+                ? item.arguments
+                : metadata.pendingArguments
+            if (metadata.started && !metadata.ended) {
+              const name = metadata.name || ''
+              let parsedInput: unknown = {}
+              if (rawArgs) {
+                try {
+                  const parsed = JSON.parse(rawArgs)
+                  parsedInput =
+                    parsed && typeof parsed === 'object' ? parsed : {}
+                } catch (parseError) {
+                  options.logger.errors(
+                    `${this.name}.processStreamChunks tool-args JSON parse failed (response.completed backfill)`,
+                    {
+                      error: toRunErrorPayload(
+                        parseError,
+                        `tool ${name} (${item.id}) returned malformed JSON arguments`,
+                      ),
+                      source: `${this.name}.processStreamChunks`,
+                      toolCallId: item.id,
+                      toolName: name,
+                      rawArguments: rawArgs,
+                    },
+                  )
+                  parsedInput = {}
+                }
+              }
+              yield {
+                type: EventType.TOOL_CALL_END,
+                toolCallId: item.id,
+                toolCallName: name,
+                toolName: name,
+                model: model || options.model,
+                timestamp: Date.now(),
+                input: parsedInput,
+              }
+              metadata.ended = true
+              metadata.pendingArguments = undefined
+            }
+          }
+
           // Emit TEXT_MESSAGE_END if we had text content
           if (hasEmittedTextMessageStart) {
-            yield asChunk({
-              type: 'TEXT_MESSAGE_END',
+            yield {
+              type: EventType.TEXT_MESSAGE_END,
               messageId: aguiState.messageId,
               model: model || options.model,
-              timestamp,
-            })
+              timestamp: Date.now(),
+            }
             hasEmittedTextMessageStart = false
           }
 
@@ -819,43 +1455,62 @@ export class OpenAICompatibleResponsesTextAdapter<
           // Otherwise surface incomplete_details.reason when present so
           // callers can distinguish length-limit / content-filter cutoffs
           // from a clean stop, mirroring the chat-completions adapter.
+          // The Responses API's incomplete_details.reason ('max_output_tokens'
+          // | 'content_filter') maps to the AG-UI finishReason vocabulary:
+          // max_output_tokens → 'length', content_filter → 'content_filter'.
           const hasFunctionCalls = chunk.response.output.some(
             (item: unknown) =>
               (item as { type: string }).type === 'function_call',
           )
-          const finishReason: string = hasFunctionCalls
+          const incompleteReason = chunk.response.incomplete_details?.reason
+          const finishReason:
+            | 'tool_calls'
+            | 'length'
+            | 'content_filter'
+            | 'stop' = hasFunctionCalls
             ? 'tool_calls'
-            : (chunk.response.incomplete_details?.reason ?? 'stop')
-
-          yield asChunk({
-            type: 'RUN_FINISHED',
+            : incompleteReason === 'max_output_tokens'
+              ? 'length'
+              : incompleteReason === 'content_filter'
+                ? 'content_filter'
+                : 'stop'
+
+          yield {
+            type: EventType.RUN_FINISHED,
             runId: aguiState.runId,
+            threadId: aguiState.threadId,
             model: model || options.model,
-            timestamp,
+            timestamp: Date.now(),
             usage: {
               promptTokens: chunk.response.usage?.input_tokens || 0,
               completionTokens: chunk.response.usage?.output_tokens || 0,
               totalTokens: chunk.response.usage?.total_tokens || 0,
             },
             finishReason,
-          })
+          }
           runFinishedEmitted = true
         }
 
         if (chunk.type === 'error') {
-          yield asChunk({
-            type: 'RUN_ERROR',
-            runId: aguiState.runId,
+          yield {
+            type: EventType.RUN_ERROR,
             model: model || options.model,
-            timestamp,
+            timestamp: Date.now(),
+            message: chunk.message,
+            code: chunk.code ?? undefined,
             error: {
               message: chunk.message,
               code: chunk.code ?? undefined,
             },
-          })
+          }
           // RUN_ERROR is terminal — don't let the synthetic RUN_FINISHED
-          // block fire after a top-level stream error event.
+          // block fire after a top-level stream error event, and stop
+          // processing further chunks so no in-flight lifecycle events
+          // (TEXT_MESSAGE_CONTENT, TOOL_CALL_*) leak past the terminal
+          // error. Mirrors the `response.failed` / `response.incomplete`
+          // branches above which return after their RUN_ERROR emission.
           runFinishedEmitted = true
+          return
         }
       }
 
@@ -865,21 +1520,22 @@ export class OpenAICompatibleResponsesTextAdapter<
       // see a terminal event for every started run.
       if (!runFinishedEmitted && aguiState.hasEmittedRunStarted) {
         if (hasEmittedTextMessageStart) {
-          yield asChunk({
-            type: 'TEXT_MESSAGE_END',
+          yield {
+            type: EventType.TEXT_MESSAGE_END,
             messageId: aguiState.messageId,
             model: model || options.model,
-            timestamp,
-          })
+            timestamp: Date.now(),
+          }
         }
-        yield asChunk({
-          type: 'RUN_FINISHED',
+        yield {
+          type: EventType.RUN_FINISHED,
           runId: aguiState.runId,
+          threadId: aguiState.threadId,
           model: model || options.model,
-          timestamp,
+          timestamp: Date.now(),
           usage: undefined,
           finishReason: toolCallMetadata.size > 0 ? 'tool_calls' : 'stop',
-        })
+        }
       }
     } catch (error: unknown) {
       // Narrow before logging: raw SDK errors can carry request metadata
@@ -892,13 +1548,14 @@ export class OpenAICompatibleResponsesTextAdapter<
         error: errorPayload,
         source: `${this.name}.processStreamChunks`,
       })
-      yield asChunk({
-        type: 'RUN_ERROR',
-        runId: aguiState.runId,
+      yield {
+        type: EventType.RUN_ERROR,
         model: options.model,
-        timestamp,
+        timestamp: Date.now(),
+        message: errorPayload.message,
+        code: errorPayload.code,
         error: errorPayload,
-      })
+      }
     }
   }
 
@@ -908,7 +1565,7 @@ export class OpenAICompatibleResponsesTextAdapter<
    */
   protected mapOptionsToRequest(
     options: TextOptions<TProviderOptions>,
-  ): Omit<OpenAI_SDK.Responses.ResponseCreateParams, 'stream'> {
+  ): Omit<ResponseCreateParams, 'stream'> {
     const input = this.convertMessagesToInput(options.messages)
 
     const tools = options.tools
@@ -961,8 +1618,8 @@ export class OpenAICompatibleResponsesTextAdapter<
    */
   protected convertMessagesToInput(
     messages: Array<ModelMessage>,
-  ): Responses.ResponseInput {
-    const result: Responses.ResponseInput = []
+  ): ResponseInput {
+    const result: ResponseInput = []
 
     for (const message of messages) {
       // Handle tool messages - convert to FunctionToolCallOutput
@@ -1016,7 +1673,7 @@ export class OpenAICompatibleResponsesTextAdapter<
 
       // Handle user messages (default case) — support multimodal content
       const contentParts = this.normalizeContent(message.content)
-      const inputContent: Array<Responses.ResponseInputContent> = []
+      const inputContent: Array<ResponseInputContent> = []
 
       for (const part of contentParts) {
         inputContent.push(this.convertContentPartToInput(part))
@@ -1049,9 +1706,7 @@ export class OpenAICompatibleResponsesTextAdapter<
    * Handles text, image, and audio content parts.
    * Override this in subclasses for additional content types or provider-specific metadata.
    */
-  protected convertContentPartToInput(
-    part: ContentPart,
-  ): Responses.ResponseInputContent {
+  protected convertContentPartToInput(part: ContentPart): ResponseInputContent {
     switch (part.type) {
       case 'text':
         return {