🤖 fix: preserve OpenAI reasoning providerMetadata for Responses API

When OpenAI's Responses API returns reasoning parts, they include
providerMetadata.openai.itemId which is required when sending
reasoning parts back to continue a conversation. Without this,
the AI SDK warns 'Non-OpenAI reasoning parts are not supported'
and skips the reasoning content.

Changes:
- Add providerMetadata field to MuxReasoningPart type
- Update ReasoningDeltaPart interface to capture providerMetadata from SDK
- Store providerMetadata when processing reasoning-delta events
- Add test verifying providerOptions preservation during coalescing

The AI SDK's convertToModelMessages() already maps providerMetadata
to providerOptions, so storing it on reasoning parts is sufficient.

---
_Generated with `mux` • Model: `anthropic:claude-opus-4-5` • Thinking: `high`_

Author: ibetitsmike

src/browser/utils/messages/modelMessageTransform.test.ts

@@ -637,6 +637,49 @@ describe("modelMessageTransform", () => {
         { type: "text", text: "Final answer" },
       ]);
     });
+
+    it("should preserve providerOptions when coalescing reasoning parts for OpenAI", () => {
+      // OpenAI's Responses API returns reasoning with providerOptions.openai.itemId
+      // When coalescing multiple reasoning deltas, we should preserve providerOptions
+      const messages: ModelMessage[] = [
+        {
+          role: "user",
+          content: [{ type: "text", text: "Complex task" }],
+        },
+        {
+          role: "assistant",
+          content: [
+            {
+              type: "reasoning",
+              text: "First delta...",
+              providerOptions: { openai: { itemId: "reasoning_item_123" } },
+            },
+            {
+              type: "reasoning",
+              text: "Second delta...",
+              providerOptions: { openai: { itemId: "reasoning_item_123" } },
+            },
+            { type: "text", text: "Final answer" },
+          ],
+        },
+      ];
+
+      const result = transformModelMessages(messages, "openai");
+
+      expect(result).toHaveLength(2);
+      const assistantContent = (result[1] as AssistantModelMessage).content;
+      expect(Array.isArray(assistantContent)).toBe(true);
+      if (Array.isArray(assistantContent)) {
+        const reasoningPart = assistantContent.find((p) => p.type === "reasoning");
+        expect(reasoningPart).toBeDefined();
+        // Text should be merged
+        expect(reasoningPart?.text).toBe("First delta...Second delta...");
+        // providerOptions from first part should be preserved
+        expect(reasoningPart?.providerOptions).toEqual({
+          openai: { itemId: "reasoning_item_123" },
+        });
+      }
+    });
   });
 });
 

src/common/types/message.ts

@@ -145,6 +145,9 @@ export interface MuxReasoningPart {
   type: "reasoning";
   text: string;
   timestamp?: number;
+  // Provider-specific metadata (e.g., OpenAI itemId for Responses API)
+  // Required to reconstruct reasoning parts when sending back to the provider
+  providerMetadata?: Record<string, unknown>;
 }
 
 // File/Image part type for multimodal messages (matches AI SDK FileUIPart)

src/node/services/streamManager.ts

@@ -45,7 +45,10 @@ import { normalizeGatewayModel } from "@/common/utils/ai/models";
 // Type definitions for stream parts with extended properties
 interface ReasoningDeltaPart {
   type: "reasoning-delta";
+  id: string;
   text?: string;
+  // Provider-specific metadata (e.g., OpenAI's itemId for Responses API)
+  providerMetadata?: Record<string, unknown>;
 }
 
 // Branded types for compile-time safety
@@ -848,13 +851,19 @@ export class StreamManager extends EventEmitter {
 
           case "reasoning-delta": {
             // Both Anthropic and OpenAI use reasoning-delta for streaming reasoning content
-            const delta = (part as ReasoningDeltaPart).text ?? "";
+            const reasoningDelta = part as ReasoningDeltaPart;
+            const delta = reasoningDelta.text ?? "";
 
             // Append each delta as a new part (merging happens at display time)
+            // Preserve providerMetadata for OpenAI Responses API (contains itemId)
             const reasoningPart = {
               type: "reasoning" as const,
               text: delta,
               timestamp: Date.now(),
+              // Include provider metadata if present (required for OpenAI reasoning)
+              ...(reasoningDelta.providerMetadata && {
+                providerMetadata: reasoningDelta.providerMetadata,
+              }),
             };
             streamInfo.parts.push(reasoningPart);