mixdog 0.9.151 → 0.9.152

package/src/runtime/agent/orchestrator/providers/anthropic-sse.mjs

@@ -23,8 +23,14 @@ import {
     NATIVE_SERVER_TOOL_CALL_BLOCK_TYPES,
     NATIVE_SERVER_TOOL_RESULT_BLOCK_TYPES,
 } from './lib/anthropic-native-blocks.mjs';
-import { parseProviderJsonBatch } from './stream-json-pool.mjs';
+import {
+    frameProviderSseChunk,
+    releaseProviderSseStream,
+    retainProviderSseStream,
+} from './stream-json-pool.mjs';
+import { splitSseRegion } from './lib/sse-framing.mjs';
 import { stampStreamOutcome, STREAM_TRANSPORTS, STREAM_OUTCOME_VERSION } from './lib/stream-outcome.mjs';
+import { createProviderReplay } from './lib/provider-replay.mjs';
 import {
     anthropicFallbackProviderMetadata,
     parseAnthropicFallbackBlock,
@@ -46,6 +52,11 @@ const SSE_MIDSTREAM_POLICY = {
 
 // --- SSE parser ---
 
+// Per-stream identity for the shared framing pool: every chunk of one stream
+// settles in submission order (and prefers one worker) regardless of whether
+// it was framed inline or offloaded.
+let _sseStreamSequence = 0;
+
 function _captureMidstreamAbort(state, reason) {
     if (!state) return;
     const reasonName = reason?.name || '';
@@ -142,6 +153,7 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
     // do not mistake transport heartbeats for model output.
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
+    const streamKey = `anthropic-sse#${++_sseStreamSequence}`;
     // Transport-idle window. The legacy semanticIdleTimeoutMs seam remains as
     // a fallback for existing tests/callers, but production uses the shared
     // byte/event inactivity policy.
@@ -199,15 +211,20 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
         .filter(([index]) => !pendingNativeToolInputs.has(index));
     const _orderedAssistantBlocks = () => {
         const nativeBlocks = _completedNativeBlocks();
-        if (!nativeBlocks.length) return undefined;
-        return [
+        const entries = [
             ...[...thinkingBlocks.entries()],
             ...[...textBlocks.entries()]
                 .filter(([, text]) => typeof text === 'string' && text.length > 0)
                 .map(([index, text]) => [index, { type: 'text', text }]),
             ...nativeBlocks,
             ...[...clientToolUseBlocks.entries()],
-        ]
+        ];
+        if (!entries.length) return undefined;
+        // A leaked plain-text tool call has no provider content_block index.
+        // Falling back to the legacy flattened projection is safer than
+        // claiming an exact replay while silently omitting that synthetic call.
+        if (toolCalls.length > 0 && clientToolUseBlocks.size !== toolCalls.length) return undefined;
+        return entries
             .sort((a, b) => a[0] - b[0])
             .map(([, block]) => block);
     };
@@ -430,6 +447,7 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
             if (_c && typeof _c.catch === 'function') _c.catch(() => {});
         } catch {}
     };
+    retainProviderSseStream(streamKey);
     try {
         // Reader ownership begins at getReader() above, so even a signal that
         // was already aborted must pass through this try/finally cleanup path.
@@ -478,36 +496,35 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
             if (state?.sawMessageStart) resetIdleTimer();
             try { onStreamDelta?.('transport'); } catch {}
             buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-
-            for (const line of lines) {
-                if (line.startsWith(':')) {
-                    // SSE comment frame (Anthropic `:ping` keepalive). The raw
-                    // chunk already refreshed transport activity above; it is
-                    // intentionally not counted as visible model progress.
-                    continue;
-                }
-                // Blank lines are SSE record separators — emitted after EVERY
-                // frame, including `:ping` keepalives — so they are NOT semantic
-                // progress and must not reset the idle timer (else a ping frame's
-                // trailing blank would keep a wedge alive forever).
-                if (line === '') continue;
-                if (line.startsWith('event: ')) {
-                    currentEvent = line.slice(7).trim();
-                    continue;
-                }
-                if (!line.startsWith('data: ')) continue;
-                const data = line.slice(6).trim();
-                if (!data) continue;
+            // ONE unit of work per network chunk. The previous loop split the
+            // chunk into a line array and awaited a JSON parse per SSE event,
+            // so a single readable chunk cost O(events) allocations and
+            // O(events) microtask hops on the shared daemon event loop. The
+            // pool now frames + parses the whole chunk (in a worker once it is
+            // worth the round-trip, otherwise inline and synchronously).
+            // Framing rules — `:` keepalive comments, blank record separators,
+            // sticky `event:` names, trimmed `data:` payloads — are unchanged;
+            // `region` holds only complete records and the trailing partial
+            // line stays in `buffer`, exactly as split()/pop() left it.
+            const { region, rest } = splitSseRegion(buffer);
+            buffer = rest;
+            if (!region) continue;
+            // A completed reader.read() owns these frames even if abort races
+            // immediately afterward, so framing is deliberately NOT signal
+            // canceled: the next read observes the cancellation after the
+            // frames of this chunk are relayed.
+            const framed = frameProviderSseChunk(region, { currentEvent, streamKey });
+            const framedChunk = typeof framed?.then === 'function' ? await framed : framed;
+            currentEvent = framedChunk.currentEvent;
 
+            for (const framedEvent of framedChunk.events) {
+                // A malformed record is skipped exactly like the former
+                // per-event JSON.parse throw — and, unlike a whole-batch
+                // rejection, the well-formed records beside it still run.
+                if (framedEvent.error) continue;
+                const event = framedEvent.value;
                 try {
-                    // A completed reader.read() owns this frame even if abort
-                    // races immediately afterward; the next read observes the
-                    // cancellation after this frame is relayed.
-                    const [event] = await parseProviderJsonBatch([data]);
-
-                    if (currentEvent === 'error' || event?.type === 'error' || event?.error) {
+                    if (framedEvent.name === 'error' || event?.type === 'error' || event?.error) {
                         throw _anthropicSseError(event);
                     }
 
@@ -897,6 +914,7 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
                 err.partialHasThinking = hasThinkingContent;
                 err.partialThinkingBlocks = _orderedThinkingBlocks();
                 err.partialAssistantBlocks = _orderedAssistantBlocks();
+                err.partialProviderReplay = createProviderReplay('anthropic', err.partialAssistantBlocks);
                 err.partialStopReason = stopReason || undefined;
             } catch { /* best-effort enrichment */ }
             // Truncation is a continuation, never a terminal turn. A pending
@@ -921,6 +939,7 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
             throw err;
         }
 
+        const assistantBlocks = _orderedAssistantBlocks();
         return {
             content,
             model,
@@ -941,12 +960,14 @@ export async function parseSSEStream(response, signal, abortStream, onStreamDelt
             // replays this list verbatim (see toAnthropicMessages'
             // assistantBlocks branch). Absent for every ordinary turn, which
             // keeps the existing text/thinking/tool_use lowering untouched.
-            assistantBlocks: _orderedAssistantBlocks(),
+            assistantBlocks,
+            providerReplay: createProviderReplay('anthropic', assistantBlocks),
             providerMetadata: anthropicFallbackProviderMetadata(fallbackEvents),
         };
     } finally {
         if (idleTimer) clearTimeout(idleTimer);
         clearFirstMessageTimer();
+        try { releaseProviderSseStream(streamKey); } catch {}
         if (signal) signal.removeEventListener('abort', onAbort);
         // message_stop deliberately exits before EOF because Anthropic may keep
         // sending pings. Cancel the reader so the successful response body and

package/src/runtime/agent/orchestrator/providers/anthropic.mjs

@@ -318,6 +318,7 @@ export class AnthropicProvider {
                 assistantBlocks: Array.isArray(parseResult.assistantBlocks) && parseResult.assistantBlocks.length
                     ? parseResult.assistantBlocks
                     : undefined,
+                ...(parseResult.providerReplay ? { providerReplay: parseResult.providerReplay } : {}),
                 ...(parseResult.providerMetadata && typeof parseResult.providerMetadata === 'object'
                     ? { providerMetadata: parseResult.providerMetadata }
                     : {}),

package/src/runtime/agent/orchestrator/providers/antigravity-oauth.mjs

@@ -14,6 +14,7 @@
 import { randomUUID, createHash } from 'crypto';
 import { withRetry } from './retry-classifier.mjs';
 import { traceAgentUsage } from '../agent-trace.mjs';
+import { createProviderReplay } from './lib/provider-replay.mjs';
 import {
     createPassthroughSignal,
     createTimeoutSignal,
@@ -353,6 +354,10 @@ export class AntigravityOAuthProvider {
             ? textLeakGuard.scrubAssistantText(rawContent)
             : rawContent;
         const leakedToolCalls = textLeakGuard?.getLeakedToolCalls() ?? [];
+        const providerReplay = createProviderReplay(
+            'antigravity',
+            leakedToolCalls.length ? [] : responseParts,
+        );
         let nativeToolCalls = parseToolCalls(responseParts);
         if (textLeakGuard?.enabled) nativeToolCalls = textLeakGuard.filterNativeToolCalls(nativeToolCalls);
         let toolCalls = nativeToolCalls;
@@ -373,6 +378,7 @@ export class AntigravityOAuthProvider {
                 finishReason,
                 partialContent: content,
                 partialToolCalls: toolCalls,
+                partialProviderReplay: providerReplay,
                 providerMetadata,
                 model: useModel,
                 rawUsage: response.usageMetadata || null,
@@ -407,6 +413,7 @@ export class AntigravityOAuthProvider {
             model: useModel,
             toolCalls,
             citations: citations.length ? citations : undefined,
+            providerReplay,
             providerMetadata,
             providerState: opts.providerState,
             usage,

package/src/runtime/agent/orchestrator/providers/gemini-schema.mjs

@@ -11,6 +11,7 @@
 import { SchemaType } from '@google/generative-ai';
 import { traceHash, stableTraceStringify } from './trace-utils.mjs';
 import { normalizeContentForGeminiParts, splitToolContentForGemini } from './media-normalization.mjs';
+import { providerReplayItems } from './lib/provider-replay.mjs';
 
 function explicitGeminiMediaPart(part) {
     if (!part || typeof part !== 'object') return null;
@@ -617,6 +618,12 @@ function toGeminiToolContent(message, toolNameByCallId, capabilities) {
 
 function toGeminiContent(message, toolNameByCallId, capabilities) {
     if (!message || message.role === 'system') return null;
+    const orderedReplay = message.role === 'assistant'
+        ? providerReplayItems(message, ['gemini', 'antigravity'])
+        : undefined;
+    if (orderedReplay?.length) {
+        return { role: 'model', parts: orderedReplay };
+    }
     if (message.role === 'assistant' && message.toolCalls?.length) {
         const parts = geminiThoughtPartsFromMetadata(message);
         if (message.content) {

package/src/runtime/agent/orchestrator/providers/gemini-stream.mjs

@@ -198,14 +198,9 @@ export function aggregateGeminiStreamChunks(responses) {
                         };
                     }
                     for (const part of candidate.content.parts) {
-                        const newPart = {};
-                        if (part.text) newPart.text = part.text;
-                        if (part.thought === true) newPart.thought = true;
-                        if (part.functionCall) newPart.functionCall = part.functionCall;
-                        if (part.thoughtSignature) newPart.thoughtSignature = part.thoughtSignature;
-                        if (part.thought_signature) newPart.thought_signature = part.thought_signature;
-                        if (part.executableCode) newPart.executableCode = part.executableCode;
-                        if (part.codeExecutionResult) newPart.codeExecutionResult = part.codeExecutionResult;
+                        let newPart;
+                        try { newPart = structuredClone(part); }
+                        catch { newPart = { ...part }; }
                         if (Object.keys(newPart).length === 0) newPart.text = '';
                         aggCand.content.parts.push(newPart);
                     }

package/src/runtime/agent/orchestrator/providers/gemini.mjs

@@ -2,6 +2,7 @@ import { GoogleGenerativeAI } from '@google/generative-ai';
 import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
 import { canFallbackNonStreaming, withRetry } from './retry-classifier.mjs';
 import { traceAgentUsage, appendAgentTrace } from '../agent-trace.mjs';
+import { createProviderReplay } from './lib/provider-replay.mjs';
 import {
     PROVIDER_FIRST_BYTE_TIMEOUT_MS,
     PROVIDER_MAX_BEFORE_WARN_MS,
@@ -907,6 +908,10 @@ export class GeminiProvider {
             ? textLeakGuard.scrubAssistantText(rawContent)
             : rawContent;
         const leakedToolCalls = textLeakGuard?.getLeakedToolCalls() ?? [];
+        const providerReplay = createProviderReplay(
+            'gemini',
+            leakedToolCalls.length ? [] : responseParts,
+        );
         let nativeToolCalls = parseToolCalls(candidate?.content?.parts ?? []);
         if (textLeakGuard?.enabled) {
             nativeToolCalls = textLeakGuard.filterNativeToolCalls(nativeToolCalls);
@@ -943,6 +948,7 @@ export class GeminiProvider {
                     finishReason,
                     partialContent: content,
                     partialToolCalls: toolCalls,
+                    partialProviderReplay: providerReplay,
                     providerMetadata,
                     model: useModel,
                     rawUsage: response.usageMetadata || null,
@@ -1015,6 +1021,7 @@ export class GeminiProvider {
             model: useModel,
             toolCalls,
             citations: citations.length ? citations : undefined,
+            providerReplay,
             providerMetadata,
             providerState: opts.providerState,
             // Use the same normalized usage object traceAgentUsage recorded,

package/src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs

@@ -2,6 +2,7 @@ import { providerNativeToolPrefixCount } from '../../../../../session-runtime/pr
 import { isNativeServerToolBlockType } from './anthropic-native-blocks.mjs';
 import { sanitizeAnthropicContentPairs, foldUserTextIntoToolResultTail } from '../../session/context-utils.mjs';
 import { normalizeContentForAnthropic } from '../media-normalization.mjs';
+import { createProviderReplay, providerReplayItems } from './provider-replay.mjs';
 import {
     anthropicFallbackProviderMetadata,
     parseAnthropicFallbackBlock,
@@ -93,9 +94,14 @@ export function toAnthropicMessages(messages) {
     for (let idx = 0; idx < messages.length; idx++) {
         const m = messages[idx];
         if (m.role === 'system') continue;
-        if (m.role === 'assistant' && (m.toolCalls?.length || m.assistantBlocks?.length || m.thinkingBlocks?.length)) {
+        const orderedReplay = m.role === 'assistant'
+            ? providerReplayItems(m, 'anthropic')
+            : undefined;
+        if (m.role === 'assistant' && (orderedReplay?.length || m.toolCalls?.length || m.assistantBlocks?.length || m.thinkingBlocks?.length)) {
             let content;
-            if (m.assistantBlocks?.length) {
+            if (orderedReplay?.length) {
+                content = orderedReplay;
+            } else if (m.assistantBlocks?.length) {
                 content = m.assistantBlocks.slice();
             } else {
                 content = [];
@@ -211,6 +217,7 @@ export function normalizeAnthropicNonStreamingResponse(message, fallbackModel =
             || (block.type === 'text' && typeof block.text === 'string' && block.text.length > 0)
         ))
         : [];
+    const replayableBlocks = blocks.filter((block) => block && typeof block === 'object');
     const usage = message?.usage || {};
     const input = Number(usage.input_tokens) || 0;
     const cacheRead = Number(usage.cache_read_input_tokens) || 0;
@@ -224,6 +231,7 @@ export function normalizeAnthropicNonStreamingResponse(message, fallbackModel =
         contentBlockTypes: blocks.map((block) => block?.type).filter(Boolean),
         thinkingBlocks: thinkingBlocks.length ? thinkingBlocks : undefined,
         assistantBlocks: nativeAssistantBlocks.length ? nativeAssistantBlocks : undefined,
+        providerReplay: createProviderReplay('anthropic', replayableBlocks),
         providerMetadata: anthropicFallbackProviderMetadata(fallbackEvents),
         usage: {
             inputTokens: input,

package/src/runtime/agent/orchestrator/providers/lib/provider-replay.mjs

@@ -0,0 +1,50 @@
+/**
+ * Provider-owned assistant output that must be replayed in its original item
+ * order. Flattened content/tool/reasoning projections remain available to the
+ * agent loop, but provider adapters prefer this envelope when rebuilding wire
+ * history for the same provider family.
+ */
+export const PROVIDER_REPLAY_VERSION = 1;
+
+function cloneReplayValue(value) {
+    try { return structuredClone(value); }
+    catch {
+        try { return JSON.parse(JSON.stringify(value)); }
+        catch { return value; }
+    }
+}
+
+export function createProviderReplay(provider, items) {
+    const id = typeof provider === 'string' ? provider.trim() : '';
+    if (!id || !Array.isArray(items) || items.length === 0) return undefined;
+    return {
+        version: PROVIDER_REPLAY_VERSION,
+        provider: id,
+        items: cloneReplayValue(items),
+    };
+}
+
+export function cloneProviderReplay(replay) {
+    if (!replay || typeof replay !== 'object'
+        || replay.version !== PROVIDER_REPLAY_VERSION
+        || typeof replay.provider !== 'string' || !replay.provider
+        || !Array.isArray(replay.items) || replay.items.length === 0) {
+        return undefined;
+    }
+    return createProviderReplay(replay.provider, replay.items);
+}
+
+export function providerReplayItems(messageOrReplay, acceptedProviders) {
+    const replay = messageOrReplay?.providerReplay ?? messageOrReplay;
+    const cloned = cloneProviderReplay(replay);
+    if (!cloned) return undefined;
+    const accepted = Array.isArray(acceptedProviders)
+        ? new Set(acceptedProviders)
+        : new Set([acceptedProviders]);
+    if (!accepted.has(cloned.provider)) return undefined;
+    return cloned.items;
+}
+
+export function hasProviderReplay(message) {
+    return cloneProviderReplay(message?.providerReplay) !== undefined;
+}

package/src/runtime/agent/orchestrator/providers/lib/sse-framing.mjs

@@ -0,0 +1,93 @@
+/**
+ * sse-framing.mjs — shared SSE record framing for provider streams.
+ *
+ * One network chunk carries many SSE records. Splitting it into an array of
+ * lines and then awaiting one JSON parse per record turned a single readable
+ * chunk into O(records) allocations plus O(records) microtask hops on the
+ * shared daemon event loop. These helpers frame a chunk in a single scan with
+ * no per-line array, and they are pure so the exact same code runs inline on
+ * the event loop and inside the provider stream worker (a worker failure can
+ * therefore always be re-run inline with identical results).
+ *
+ * Framing rules are byte-identical to the previous inline Anthropic loop:
+ *   - `:`-prefixed lines are comment/keepalive frames and are dropped.
+ *   - blank lines are record separators and are dropped.
+ *   - `event: ` sets the current event name, which persists (across chunks)
+ *     until the next `event: ` line.
+ *   - `data: ` payloads are trimmed; empty payloads are dropped.
+ *   - any other line is ignored.
+ * CRLF transports behave as before: the trailing `\r` is removed by trim() on
+ * the value lines, and a bare `\r` line matches no prefix and is ignored.
+ */
+
+const COLON_CODE = 58; // ':'
+
+/**
+ * Split a decoded buffer into the complete-record region and the residual
+ * partial line. Equivalent to `const lines = buffer.split('\n'); buffer = lines.pop()`
+ * without materializing the line array.
+ */
+export function splitSseRegion(buffer) {
+    const cut = buffer.lastIndexOf('\n');
+    if (cut < 0) return { region: '', rest: buffer };
+    return { region: buffer.slice(0, cut + 1), rest: buffer.slice(cut + 1) };
+}
+
+/**
+ * Frame a complete-record region into ordered `{ name, data }` records.
+ * `currentEvent` carries the last `event:` name into and out of the region so
+ * a record split across network chunks keeps its event name.
+ */
+export function frameSseRegion(text, currentEvent = '') {
+    const frames = [];
+    let name = String(currentEvent || '');
+    const length = text.length;
+    let index = 0;
+    while (index < length) {
+        let end = text.indexOf('\n', index);
+        if (end < 0) end = length;
+        const start = index;
+        index = end + 1;
+        if (end === start) continue; // record separator
+        if (text.charCodeAt(start) === COLON_CODE) continue; // comment / ping keepalive
+        if (text.startsWith('event: ', start)) {
+            name = text.slice(start + 7, end).trim();
+            continue;
+        }
+        if (!text.startsWith('data: ', start)) continue;
+        const data = text.slice(start + 6, end).trim();
+        if (!data) continue;
+        frames.push({ name, data });
+    }
+    return { frames, currentEvent: name };
+}
+
+/**
+ * Parse framed records with per-record error isolation. A malformed record
+ * must never discard the well-formed records batched beside it: the consumer
+ * skips entries that carry `error` exactly like the previous per-event
+ * try/catch did.
+ */
+export function parseSseFrames(frames) {
+    const events = [];
+    for (const frame of frames) {
+        try {
+            events.push({ name: frame.name, value: JSON.parse(frame.data) });
+        } catch (error) {
+            events.push({
+                name: frame.name,
+                error: {
+                    name: String(error?.name || 'SyntaxError'),
+                    message: String(error?.message || error || 'invalid JSON'),
+                },
+            });
+        }
+    }
+    return events;
+}
+
+/** Frame + parse in one pass (the unit of work posted to the stream worker). */
+export function frameAndParseSse(text, currentEvent = '') {
+    const framed = frameSseRegion(text, currentEvent);
+    return { events: parseSseFrames(framed.frames), currentEvent: framed.currentEvent };
+}

package/src/runtime/agent/orchestrator/providers/model-list-sanitize.mjs

@@ -25,7 +25,7 @@ const CODING_UNFIT_ID_RE = /-search(-preview)?(\b|-|$)|-(audio|realtime)-preview
 const HOSTED_PROVIDERS = new Set([
   'openai', 'openai-oauth', 'openai-ws', 'anthropic', 'anthropic-oauth',
   'gemini', 'google', 'xai', 'grok-oauth', 'deepseek', 'groq', 'mistral',
-  'opencode-go', 'azure',
+  'opencode-go', 'openrouter', 'azure',
 ]);
 
 // (a) Non-chat modality ids. Matched as whole word-ish tokens on the id so we
@@ -166,9 +166,9 @@ function _stalenessFamily(row, id) {
 
 function _staleMonths() {
   const raw = process.env.MIXDOG_MODEL_STALE_MONTHS;
-  if (raw == null || raw === '') return 12;
+  if (raw == null || raw === '') return 9;
   const n = Number(raw);
-  return Number.isFinite(n) ? n : 12;
+  return Number.isFinite(n) ? n : 9;
 }
 
 // Apply catalog-driven staleness to the already-filtered `kept` rows.

package/src/runtime/agent/orchestrator/providers/openai-compat-presets.mjs

@@ -14,6 +14,14 @@ export const OPENAI_COMPAT_PRESETS = {
         baseURL: 'https://opencode.ai/zen/go/v1',
         defaultModel: 'glm-5.2',
     },
+    openrouter: {
+        baseURL: 'https://openrouter.ai/api/v1',
+        defaultModel: 'openrouter/auto',
+        extraHeaders: {
+            'HTTP-Referer': 'https://github.com/tribgames/mixdog',
+            'X-OpenRouter-Title': 'mixdog',
+        },
+    },
     ollama: {
         baseURL: 'http://localhost:11434/v1',
         defaultModel: 'llama3.3:latest',

package/src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs

@@ -296,6 +296,7 @@ export async function consumeCompatChatCompletionStream(stream, {
     let sawFirstEvent = false;
     let content = '';
     let reasoningContent = '';
+    const reasoningDetails = [];
     // Invariant flag for the gateway live-text relay: set once a non-empty
     // text chunk has been forwarded to the client. A failure after this point
     // must be treated as permanent — the rendered text cannot be withdrawn and
@@ -435,6 +436,10 @@ export async function consumeCompatChatCompletionStream(stream, {
             // use reasoning, and some local compatibility shims expose
             // thinking. They are aliases, never concatenate multiple aliases
             // from the same chunk.
+            if (Array.isArray(choice?.delta?.reasoning_details) && choice.delta.reasoning_details.length) {
+                reasoningDetails.push(...choice.delta.reasoning_details);
+                reportProgress('reasoning');
+            }
             const reasoningDelta = typeof choice?.delta?.reasoning_content === 'string'
                 ? choice.delta.reasoning_content
                 : typeof choice?.delta?.reasoning === 'string'
@@ -513,6 +518,7 @@ export async function consumeCompatChatCompletionStream(stream, {
     const message = {
         content: content || null,
         ...(reasoningContent ? { reasoning_content: reasoningContent } : {}),
+        ...(reasoningDetails.length ? { reasoning_details: reasoningDetails } : {}),
     };
     const rawToolCalls = [...toolAcc.values()]
         .sort((a, b) => a._order - b._order)
@@ -557,6 +563,7 @@ export async function consumeCompatChatCompletionStream(stream, {
         toolCalls,
         stopReason,
         reasoningContent: reasoningContent || null,
+        reasoningDetails: reasoningDetails.length ? reasoningDetails : null,
         rawUsage,
     };
 }

package/src/runtime/agent/orchestrator/providers/openai-compat-wire.mjs

@@ -20,6 +20,7 @@ import {
 import {
     customToolCallFromResponseItem,
 } from './custom-tool-wire.mjs';
+import { providerReplayItems } from './lib/provider-replay.mjs';
 
 export function positiveTokenInt(value) {
     const n = Number(value);
@@ -56,6 +57,12 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
         || providerName === 'xai';
     const out = [];
     const pendingToolMedia = [];
+    const openRouterReasoningDetails = (message) => {
+        if (providerName !== 'openrouter') return null;
+        const metadata = message?.providerMetadata?.openrouter;
+        const details = metadata?.reasoning_details ?? metadata?.reasoningDetails;
+        return Array.isArray(details) && details.length ? details : null;
+    };
     const flushToolMedia = () => {
         if (!pendingToolMedia.length) return;
         out.push({ role: 'user', content: pendingToolMedia.splice(0) });
@@ -83,11 +90,20 @@ export function toOpenAIMessages(messages, providerName, options = {}) {
                 })),
             };
             if (replaysReasoningContent && m.reasoningContent) msg.reasoning_content = m.reasoningContent;
+            const reasoningDetails = openRouterReasoningDetails(m);
+            if (reasoningDetails) msg.reasoning_details = reasoningDetails;
             out.push(msg);
             continue;
         }
-        if (m.role === 'assistant' && replaysReasoningContent && m.reasoningContent) {
-            out.push({ role: m.role, content: normalizeContentForOpenAIChat(m.content, { role: 'assistant' }), reasoning_content: m.reasoningContent });
+        const reasoningDetails = m.role === 'assistant' ? openRouterReasoningDetails(m) : null;
+        if (m.role === 'assistant' && ((replaysReasoningContent && m.reasoningContent) || reasoningDetails)) {
+            const msg = {
+                role: m.role,
+                content: normalizeContentForOpenAIChat(m.content, { role: 'assistant' }),
+            };
+            if (replaysReasoningContent && m.reasoningContent) msg.reasoning_content = m.reasoningContent;
+            if (reasoningDetails) msg.reasoning_details = reasoningDetails;
+            out.push(msg);
             continue;
         }
         out.push({ role: m.role, content: normalizeContentForOpenAIChat(m.content, { role: m.role }) });
@@ -392,6 +408,13 @@ export function toXaiResponsesInput(messages, providerState, options = {}) {
         const m = messages[messageIndex];
         if (!includeSystem && m.role === 'system') continue;
         if (m.role !== 'tool') flushToolMedia();
+        const orderedReplay = m.role === 'assistant'
+            ? providerReplayItems(m, 'xai-responses')
+            : undefined;
+        if (orderedReplay?.length) {
+            input.push(...orderedReplay);
+            continue;
+        }
         const reasoningItems = reasoningByMessageIndex.get(messageIndex);
         if (reasoningItems) input.push(...reasoningItems);
         if (dropToolHistory && m.role === 'tool') continue;