@tanstack/openai-base 0.2.1 → 0.3.1

package/dist/esm/adapters/responses-text.js

@@ -1,29 +1,27 @@
+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.js";
 import { extractRequestOptions } from "../utils/request-options.js";
 import { makeStructuredOutputCompatible } from "../utils/schema-converter.js";
 import { convertToolsToResponsesFormat } from "./responses-tool-converter.js";
-const asChunk = (chunk) => chunk;
-class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
-  constructor(config, model, name = "openai-compatible-responses") {
+class OpenAIBaseResponsesTextAdapter extends BaseTextAdapter {
+  constructor(model, name, client) {
     super({}, model);
     this.kind = "text";
     this.name = name;
-    this.client = createOpenAICompatibleClient(config);
+    this.client = client;
   }
   async *chatStream(options) {
     const toolCallMetadata = /* @__PURE__ */ new Map();
-    const requestParams = this.mapOptionsToRequest(options);
-    const timestamp = Date.now();
     const aguiState = {
       runId: generateId(this.name),
+      threadId: options.threadId ?? generateId(this.name),
       messageId: generateId(this.name),
-      timestamp,
       hasEmittedRunStarted: false
     };
     try {
+      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 }
@@ -48,20 +46,23 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
       );
       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(),
+          parentRunId: options.parentRunId
+        };
       }
-      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,
         source: `${this.name}.chatStream`
@@ -115,9 +116,12 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
         },
         extractRequestOptions(chatOptions.request)
       );
-      const rawText = this.extractTextFromResponse(
-        response
-      );
+      const rawText = this.extractTextFromResponse(response);
+      if (rawText.length === 0) {
+        throw new Error(
+          `${this.name}.structuredOutput: response contained no content`
+        );
+      }
       let parsed;
       try {
         parsed = JSON.parse(rawText);
@@ -126,7 +130,7 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
           `Failed to parse structured output as JSON. Content: ${rawText.slice(0, 200)}${rawText.length > 200 ? "..." : ""}`
         );
       }
-      const transformed = transformNullsToUndefined(parsed);
+      const transformed = this.transformStructuredOutput(parsed);
       return {
         data: transformed,
         rawText
@@ -139,6 +143,324 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
       throw error;
     }
   }
+  /**
+   * 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) {
+    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;
+    let stepId;
+    let hasClosedReasoning = false;
+    let model = chatOptions.model;
+    let usage;
+    const closeReasoning = (function* () {
+      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* () {
+      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",
+        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,
+            parentRunId: chatOptions.parentRunId
+          };
+        }
+        if (chunk.type === "response.created" || chunk.type === "response.in_progress") {
+          const responseModel = chunk.response?.model;
+          if (responseModel) model = responseModel;
+          continue;
+        }
+        if (chunk.type === "response.refusal.delta") {
+          const delta = typeof chunk.delta === "string" ? chunk.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.delta;
+          const reasoningDelta = Array.isArray(raw) ? raw.join("") : typeof raw === "string" ? raw : "";
+          if (!reasoningDelta) continue;
+          yield* openReasoning();
+          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.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.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;
+      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) {
+      if (!aguiState.hasEmittedRunStarted) {
+        aguiState.hasEmittedRunStarted = true;
+        yield {
+          type: EventType.RUN_STARTED,
+          runId: aguiState.runId,
+          threadId: aguiState.threadId,
+          model,
+          timestamp,
+          parentRunId: chatOptions.parentRunId
+        };
+      }
+      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.
+   */
+  isAbortError(error) {
+    if (!error || typeof error !== "object") return false;
+    const e = error;
+    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.
@@ -146,6 +468,18 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
   makeStructuredOutputCompatible(schema, originalRequired) {
     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.
+   */
+  transformStructuredOutput(parsed) {
+    return transformNullsToUndefined(parsed);
+  }
   /**
    * Extract text content from a non-streaming Responses API response.
    * Override this in subclasses for provider-specific response shapes.
@@ -153,13 +487,23 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
   extractTextFromResponse(response) {
     let textContent = "";
     let refusal;
+    let sawMessageItem = false;
+    const observedItemTypes = /* @__PURE__ */ new Set();
     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;
+          const partType = part.type;
+          if (partType === "output_text") {
+            textContent += part.text ?? "";
+          } else if (partType === "refusal") {
+            const refusalText = part.refusal;
+            refusal = refusalText || refusal || "Refused without explanation";
           } else {
-            refusal = part.refusal || refusal || "Refused without explanation";
+            throw new Error(
+              `${this.name}.extractTextFromResponse: unsupported message content part type "${partType}"`
+            );
           }
         }
       }
@@ -169,6 +513,11 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
       err.code = "refusal";
       throw err;
     }
+    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;
   }
   /**
@@ -189,7 +538,6 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
   async *processStreamChunks(stream, toolCallMetadata, options, aguiState) {
     let accumulatedContent = "";
     let accumulatedReasoning = "";
-    const timestamp = aguiState.timestamp;
     let hasStreamedContentDeltas = false;
     let hasStreamedReasoningDeltas = false;
     let model = options.model;
@@ -205,51 +553,53 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
         });
         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(),
+            parentRunId: options.parentRunId
+          };
         }
         const handleContentPart = (contentPart) => {
           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") {
             accumulatedReasoning += contentPart.text || "";
             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
-            });
+            };
           }
           const isRefusal = contentPart.type === "refusal";
           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 }
+          };
         };
         if (chunk.type === "response.created" || chunk.type === "response.incomplete" || chunk.type === "response.failed") {
           model = chunk.response.model;
@@ -264,26 +614,27 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
         }
         if (chunk.type === "response.failed" || 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;
           }
           const errorMessage = chunk.response.error?.message || chunk.response.incomplete_details?.reason || (chunk.type === "response.failed" ? "Response failed" : "Response ended incomplete");
-          const errorCode = chunk.response.error?.code || (chunk.response.incomplete_details ? "incomplete" : void 0);
-          yield asChunk({
-            type: "RUN_ERROR",
-            runId: aguiState.runId,
+          const errorCode = chunk.response.error?.code ?? (chunk.response.incomplete_details ? "incomplete" : void 0) ?? void 0;
+          yield {
+            type: EventType.RUN_ERROR,
             model: chunk.response.model,
-            timestamp,
+            timestamp: Date.now(),
+            message: errorMessage,
+            ...errorCode !== void 0 && { code: errorCode },
             error: {
               message: errorMessage,
               ...errorCode !== void 0 && { code: errorCode }
             }
-          });
+          };
           runFinishedEmitted = true;
           return;
         }
@@ -292,24 +643,24 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
           if (textDelta) {
             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
-            });
+            };
           }
         }
         if (chunk.type === "response.reasoning_text.delta" && chunk.delta) {
@@ -318,24 +669,27 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
             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
-            });
+            };
           }
         }
         if (chunk.type === "response.reasoning_summary_text.delta" && chunk.delta) {
@@ -344,48 +698,52 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
             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
-            });
+            };
           }
         }
         if (chunk.type === "response.content_part.added") {
           const contentPart = chunk.part;
           if (contentPart.type === "output_text" && !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"
-            });
+            };
           }
           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"
-            });
+            };
           }
           if (contentPart.type === "output_text") {
             hasStreamedContentDeltas = true;
@@ -407,6 +765,27 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
           if (contentPart.type === "reasoning_text" && hasStreamedReasoningDeltas) {
             continue;
           }
+          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"
+            };
+          }
           const doneChunk = handleContentPart(contentPart);
           yield doneChunk;
           if (doneChunk.type === "RUN_ERROR") {
@@ -418,24 +797,27 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
           const item = chunk.item;
           if (item.type === "function_call" && item.id) {
             const existing = toolCallMetadata.get(item.id);
-            if (!existing?.started) {
-              if (!existing) {
-                toolCallMetadata.set(item.id, {
-                  index: chunk.output_index,
-                  name: item.name || "",
-                  started: false
-                });
-              }
-              yield asChunk({
-                type: "TOOL_CALL_START",
+            if (!existing) {
+              toolCallMetadata.set(item.id, {
+                index: chunk.output_index,
+                name: item.name || "",
+                started: false
+              });
+            } else if (!existing.name && item.name) {
+              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;
             }
           }
         }
@@ -452,20 +834,23 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
             );
             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") {
           const { item_id } = chunk;
           const metadata = toolCallMetadata.get(item_id);
           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,
@@ -474,7 +859,9 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
             );
             continue;
           }
+          if (metadata.ended) continue;
           const name = metadata.name || "";
+          metadata.ended = true;
           let parsedInput = {};
           if (chunk.arguments) {
             try {
@@ -497,75 +884,206 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
               parsedInput = {};
             }
           }
-          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
-          });
+          };
+        }
+        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;
+            }
+            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 && rawArgs !== void 0) {
+              const name = metadata.name || "";
+              let parsedInput = {};
+              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 = void 0;
+            }
+          }
         }
         if (chunk.type === "response.completed") {
+          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 = {};
+              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 = void 0;
+            }
+          }
           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;
           }
           const hasFunctionCalls = chunk.response.output.some(
             (item) => item.type === "function_call"
           );
-          const finishReason = hasFunctionCalls ? "tool_calls" : chunk.response.incomplete_details?.reason ?? "stop";
-          yield asChunk({
-            type: "RUN_FINISHED",
+          const incompleteReason = chunk.response.incomplete_details?.reason;
+          const finishReason = hasFunctionCalls ? "tool_calls" : 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 ?? void 0,
             error: {
               message: chunk.message,
               code: chunk.code ?? void 0
             }
-          });
+          };
           runFinishedEmitted = true;
+          return;
         }
       }
       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: void 0,
           finishReason: toolCallMetadata.size > 0 ? "tool_calls" : "stop"
-        });
+        };
       }
     } catch (error) {
       const errorPayload = toRunErrorPayload(
@@ -576,13 +1094,14 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
         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
-      });
+      };
     }
   }
   /**
@@ -755,6 +1274,6 @@ class OpenAICompatibleResponsesTextAdapter extends BaseTextAdapter {
   }
 }
 export {
-  OpenAICompatibleResponsesTextAdapter
+  OpenAIBaseResponsesTextAdapter
 };
 //# sourceMappingURL=responses-text.js.map