mixdog 0.9.50 → 0.9.52

package/src/runtime/agent/orchestrator/providers/openai-oauth-ws.mjs

@@ -40,9 +40,6 @@ import {
     MIDSTREAM_RETRY_POLICY,
     sleepWithAbort,
 } from './retry-classifier.mjs';
-import {
-    PROVIDER_RETRY_MAX_ATTEMPTS,
-} from '../stall-policy.mjs';
 import {
     WS_IDLE_MS,
     acquireWebSocket,
@@ -84,12 +81,14 @@ export {
 globalThis.__mixdogOpenaiWsRuntimeLoaded = true;
 
 // --- WS_PRE_RESPONSE_CREATED_MS / WS_INTER_CHUNK_MS: extracted to openai-ws-stream.mjs ---
-// Mid-stream retry budgets + backoff now live in the shared MIDSTREAM_RETRY_POLICY
-// table (retry-classifier.mjs). These aliases keep the local call sites readable
-// and ensure the numbers exist in exactly ONE place.
+// The official Codex Responses policy has one five-retry stream budget shared
+// by connect/handshake and pre-output stream failures.
 const MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT = MIDSTREAM_RETRY_POLICY.ws.transientCloseRetries;
 const MIDSTREAM_DEFAULT_RETRY_LIMIT = MIDSTREAM_RETRY_POLICY.ws.defaultRetries;
-const MIDSTREAM_BACKOFF_MS = MIDSTREAM_RETRY_POLICY.ws.backoff;
+// Codex core/src/util.rs uses a 200ms base, factor 2, and symmetric ±10%
+// jitter for each of its five stream retries.
+const MIDSTREAM_BACKOFF_MS = Object.freeze([200, 400, 800, 1600, 3200]);
+const CODEX_RETRY_JITTER_RATIO = 0.1;
 // Policy object passed to the shared classifyMidstreamError for the WS path.
 const WS_MIDSTREAM_POLICY = {
     mode: 'ws',
@@ -97,20 +96,12 @@ const WS_MIDSTREAM_POLICY = {
     defaultRetries: MIDSTREAM_RETRY_POLICY.ws.defaultRetries,
 };
 
-// Handshake retry policy. The `ws` library surfaces a bare
-// `Opening handshake has timed out` Error after handshakeTimeout; transient
-// network blips (DNS, reset, 5xx) similarly produce single-shot failures that
-// waste the caller's turn when they'd succeed on retry. We wrap the acquire
-// step with bounded exponential backoff. Permanent auth/quota (4xx) must NOT
-// retry because a second attempt will hit the same deterministic server
-// decision and just double the user-visible latency.
-// Aligned to the cross-provider default (retry-classifier DEFAULT_MAX_ATTEMPTS=5,
-// anthropic-oauth MAX_ATTEMPTS=5, withRetry-using providers all default to 5).
-// Bumped from 3 so this provider exhausts the same number of transient-5xx
-// attempts as the others before surfacing failure to the caller.
-const HANDSHAKE_MAX_ATTEMPTS = PROVIDER_RETRY_MAX_ATTEMPTS;
-const HANDSHAKE_BACKOFF_BASE_MS = 500;
-const HANDSHAKE_BACKOFF_CAP_MS = 5000;
+// Kept for the exported _acquireWithRetry test seam and non-Codex callers.
+// sendViaWebSocket deliberately invokes it with maxAttempts:1 so handshake
+// failures consume the same stream budget as pre-output disconnects.
+const HANDSHAKE_MAX_ATTEMPTS = MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT + 1;
+const HANDSHAKE_BACKOFF_BASE_MS = 200;
+const HANDSHAKE_BACKOFF_CAP_MS = 3200;
 
 // --- WS pool/handshake/acquire/release: extracted to openai-ws-pool.mjs ---
 
@@ -152,22 +143,21 @@ export function _classifyHandshakeError(err) {
  *     after the 101 upgrade but before the first response.created event,
  *     AND the pre-`response.created` first-byte timeout
  *     (state.firstByteTimeout), which is permitted a bounded retry here
- *   - HTTP 401 / 403 / 429 surfaced on the error
+ *   - HTTP 401 / 403 / 429 surfaced after the WS handshake
  *   - state.attemptIndex has reached the classifier-specific retry budget
  */
 // Thin wrapper: the full WS mid-stream decision tree now lives in the shared
 // classifyMidstreamError (retry-classifier.mjs, policy.mode='ws'). Kept as a
 // named export so internal call sites and any external importer keep resolving
-// the same symbol. Behavior is byte-identical — the shared function is the
-// relocated original, with the per-classifier budget gating supplied by
-// WS_MIDSTREAM_POLICY (transientCloseRetries=4, defaultRetries=2).
+// the same symbol. The per-classifier gates both use the official five-retry
+// stream budget.
 export function _classifyMidstreamError(err, state) {
     return classifyMidstreamError(err, state, WS_MIDSTREAM_POLICY);
 }
 
 // Per-classifier retry budget, used by the sendViaWebSocket loop to bound the
 // attempt count once classifyMidstreamError returns a bucket. Mirrors the
-// shared _midstreamLimitFor(ws) — the numbers come from MIDSTREAM_RETRY_POLICY.
+// shared _midstreamLimitFor(ws) — both values are the same unified budget.
 function _midstreamRetryLimit(classifier) {
     return classifier === 'ws_1006' || classifier === 'ws_1011'
         ? MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT
@@ -176,13 +166,13 @@ function _midstreamRetryLimit(classifier) {
 
 function _midstreamBackoffFor(retryNumber) {
     const raw = MIDSTREAM_BACKOFF_MS[Math.min(Math.max(retryNumber, 1), MIDSTREAM_BACKOFF_MS.length) - 1];
-    return jitterDelayMs(raw);
+    return jitterDelayMs(raw, CODEX_RETRY_JITTER_RATIO);
 }
 
 function _backoffFor(attempt) {
     // attempt is 1-based. retry 1 → 500, retry 2 → 1000, retry 3 → 2000 … capped.
     const raw = HANDSHAKE_BACKOFF_BASE_MS * (1 << (attempt - 1));
-    return jitterDelayMs(Math.min(raw, HANDSHAKE_BACKOFF_CAP_MS));
+    return jitterDelayMs(Math.min(raw, HANDSHAKE_BACKOFF_CAP_MS), CODEX_RETRY_JITTER_RATIO);
 }
 
 const _defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -648,6 +638,11 @@ export async function sendViaWebSocket({
     traceProvider = 'openai-oauth',
     logSuppressedReasoningDeltas = true,
     warmupBody = null,
+    // Provider-specific handshake policy seam. OAuth leaves this null and
+    // retains the Codex retry budget. Direct OpenAI uses it to surface
+    // unsupported-WS handshake statuses immediately so its wrapper can make
+    // the single WS→HTTP decision without nested WS retries.
+    handshakeErrorPolicy = null,
     // Test seams (undefined in production). Let the unit test drive the
     // retry state machine without opening real sockets or touching the
     // handshake-retry layer.
@@ -656,18 +651,11 @@ export async function sendViaWebSocket({
     _sendFrameFn = _sendFrame,
     _sleepFn = _defaultSleep,
     _sendSpanTraceFn = appendAgentTrace,
+    _agentTraceFn = appendAgentTrace,
 }) {
-    // Bounded mid-stream retry: if an attempt's stream dies after
-    // response.created but before response.completed from a transient cause
-    // (watchdog abort / ws 1006/1011/1012/4000 / response.failed with network
-    // error), tear down the socket and reissue the full request from scratch
-    // with a classifier-specific budget. ws_1006/ws_1011 get two retries with
-    // 250ms/1s backoff; other legacy transient buckets keep the prior one retry.
-    // No delta resume — content restarts, which is the accepted tradeoff for
-    // reviewer/worker flows that need the complete answer.
-    // Retries are layered ABOVE the handshake retry loop (_acquireWithRetry
-    // owns connect-level transience); the two never interleave because we
-    // force a brand-new acquire for the retry attempt.
+    // One bounded Codex stream retry budget covers transient handshake and
+    // pre-output stream failures. Every retry acquires a fresh connection.
+    // No replay is permitted after live text or an emitted tool call.
     const MAX_MIDSTREAM_RETRIES = MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT;
     let firstAttemptError = null;
     let firstAttemptClassifier = null;
@@ -783,20 +771,28 @@ export async function sendViaWebSocket({
                 // one is either torn down or in an unknown state.
                 forceFresh: forceFresh || attemptIndex > 0,
                 externalSignal,
-                maxAttempts: HANDSHAKE_MAX_ATTEMPTS,
+                // No nested connect retry budget: the outer stream loop owns
+                // all retries for this logical request.
+                maxAttempts: 1,
                 onRetry: (info) => {
                     handshakeRetries += 1;
                     sendSpan.handshakeRetries += 1;
                     if (info?.classifier) handshakeRetryClassifiers.push(info.classifier);
                     const attempt = Number(info?.attempt) || handshakeRetries;
-                    const max = Number(info?.max) || Math.max(HANDSHAKE_MAX_ATTEMPTS - 1, 1);
+                    const max = Number(info?.max) || MAX_MIDSTREAM_RETRIES;
                     emitReconnectProgress({ attempt, max, classifier: info?.classifier });
                 },
                 onBackoffSlept: (ms) => { sendSpan.retryBackoffMs += ms; },
             });
         } catch (err) {
             sendSpan.poolAcquireMs += performance.now() - handshakeStart;
-            const classifier = err?.retryClassifier || (err?.code === 'EWSACQUIRETIMEOUT' ? 'acquire_timeout' : null);
+            // Provenance only; policy remains provider-owned below. This lets
+            // the direct wrapper distinguish an upgrade rejection from an
+            // application error carrying the same HTTP status.
+            try { err.wsFailurePhase = 'handshake'; } catch {}
+            const classifier = err?.retryClassifier
+                || _classifyHandshakeError(err)
+                || (err?.code === 'EWSACQUIRETIMEOUT' ? 'acquire_timeout' : null);
             const classifiers = [...handshakeRetryClassifiers];
             if (classifier && !classifiers.includes(classifier)) classifiers.push(classifier);
             if (err?.httpStatus != null || classifier || handshakeRetries > 0 || classifiers.length > 0) {
@@ -811,12 +807,70 @@ export async function sendViaWebSocket({
                     handshakeRetryClassifiers: classifiers,
                 });
             }
-            // Handshake-layer failure. Don't double-wrap: if this is the retry
-            // attempt, surface the ORIGINAL first-attempt error (which is what
-            // the caller's turn actually tripped on).
+            const handshakeDecision = typeof handshakeErrorPolicy === 'function'
+                ? handshakeErrorPolicy({
+                    error: err,
+                    status: Number(err?.httpStatus || 0),
+                    classifier,
+                    attempt: attemptIndex + 1,
+                    maxAttempts: MAX_MIDSTREAM_RETRIES + 1,
+                })
+                : null;
+            if (handshakeDecision?.retry === false) {
+                try {
+                    err.wsFailurePhase = 'handshake';
+                    err.wsHttpFallbackEligible = handshakeDecision.httpFallback === true;
+                    if (classifier) err.retryClassifier = classifier;
+                } catch {}
+                emitSendSpan('error');
+                throw _stampTool(_stampLiveText(err));
+            }
+            // HTTP 401 is reserved for caller-owned auth refresh. HTTP 426 is
+            // caller-owned immediate HTTPS fallback. Every other recognized
+            // transport failure spends the shared stream retry budget.
+            const retryable = classifier
+                && Number(err?.httpStatus || 0) !== 401
+                && Number(err?.httpStatus || 0) !== 426
+                && !externalSignal?.aborted;
+            if (retryable && attemptIndex < MAX_MIDSTREAM_RETRIES) {
+                if (!firstAttemptError) {
+                    firstAttemptError = err;
+                    firstAttemptClassifier = classifier;
+                }
+                try { err.midstreamClassifier = classifier; } catch {}
+                const retryNumber = attemptIndex + 1;
+                emitReconnectProgress({
+                    attempt: retryNumber,
+                    max: MAX_MIDSTREAM_RETRIES,
+                    classifier,
+                });
+                const sleepStart = performance.now();
+                try {
+                    await _sleepWithAbort(_midstreamBackoffFor(retryNumber), externalSignal, _sleepFn);
+                } catch (sleepErr) {
+                    sendSpan.retryBackoffMs += performance.now() - sleepStart;
+                    emitSendSpan('error');
+                    throw sleepErr;
+                }
+                sendSpan.retryBackoffMs += performance.now() - sleepStart;
+                continue;
+            }
+            // A later auth/upgrade decision must win over an earlier transient
+            // failure so the caller can refresh or switch transport. Likewise,
+            // never replace a current cancellation with stale retry history.
+            const currentStatus = Number(err?.httpStatus || 0);
+            const surfaceCurrent = currentStatus === 401
+                || currentStatus === 426
+                || externalSignal?.aborted
+                || err?.unsafeToRetry === true;
+            if (surfaceCurrent) {
+                emitSendSpan('error');
+                throw _stampTool(_stampLiveText(err));
+            }
             if (attemptIndex > 0 && firstAttemptError) {
                 try { firstAttemptError.midstreamRetries = attemptIndex; } catch {}
-                if (err?.wsRetriesExhausted === true) {
+                try { firstAttemptError.midstreamClassifier = firstAttemptClassifier; } catch {}
+                if (attemptIndex >= MAX_MIDSTREAM_RETRIES) {
                     try { firstAttemptError.wsRetriesExhausted = true; } catch {}
                 }
                 emitSendSpan('error');
@@ -885,6 +939,7 @@ export async function sendViaWebSocket({
         let deltaReason = null;
         let strippedResponseItems = 0;
         let skippedResponseItems = 0;
+        let responseOutputMismatch = null;
         let wireFrameHadTurnState = false;
         let wireFrameMetadataTrace = _metadataTrace(null);
         let framePrefixHash = null;
@@ -976,7 +1031,7 @@ export async function sendViaWebSocket({
                         output_tokens: warmupResult.usage?.outputTokens || 0,
                         prompt_tokens: warmupResult.usage?.promptTokens || 0,
                     };
-                    appendAgentTrace({
+                    _agentTraceFn({
                         sessionId: poolKey,
                         iteration,
                         kind: 'cache_warmup',
@@ -1020,6 +1075,7 @@ export async function sendViaWebSocket({
             deltaReason = delta.reason || null;
             strippedResponseItems = delta.strippedResponseItems || 0;
             skippedResponseItems = delta.skippedResponseItems || 0;
+            responseOutputMismatch = delta.responseOutputMismatch || null;
             const wireFrame = _withCodexWsClientMetadata(frame, entry, useCodexWsClientMetadata, codexMetadataContext);
             wireFrameHadTurnState = !!wireFrame?.client_metadata?.['x-codex-turn-state'];
             wireFrameMetadataTrace = _metadataTrace(wireFrame?.client_metadata);
@@ -1082,6 +1138,10 @@ export async function sendViaWebSocket({
                 knownToolNames,
             });
         } catch (err) {
+            // Preserve failure provenance for the direct provider. This marker
+            // is observational for OAuth and does not change its classifier or
+            // retry budget.
+            try { err.wsFailurePhase = 'stream'; } catch {}
             // Snapshot the xAI conversation anchor BEFORE releasing the
             // entry. release closes the socket but leaves state fields
             // intact; the next forceFresh acquire creates a new entry into
@@ -1111,9 +1171,24 @@ export async function sendViaWebSocket({
             if (midState.emittedToolCall) {
                 _safetyStamps.markTool();
             }
+            // Reasoning deltas and an in-progress tool input are already
+            // observable turn progress even though neither is final assistant
+            // text nor a dispatched tool call. Reissuing from the beginning can
+            // duplicate exposed thinking/tool argument streams and can make a
+            // partially generated side-effecting call diverge. Keep the Codex
+            // retry budget only for failures before any such model output.
+            if (midState.emittedReasoning || midState.startedToolCall) {
+                try {
+                    err.unsafeToRetry = true;
+                    if (midState.emittedReasoning) err.partialReasoningEmitted = true;
+                    if (midState.startedToolCall) err.partialToolCallStarted = true;
+                } catch {}
+            }
             _stampLiveText(err);
             _stampTool(err);
-            const classifier = _classifyMidstreamError(err, midState);
+            const classifier = err?.unsafeToRetry === true
+                ? null
+                : _classifyMidstreamError(err, midState);
             const retryLimit = classifier ? _midstreamRetryLimit(classifier) : 0;
             if (classifier && attemptIndex < retryLimit) {
                 // Retry-eligible: stash the first-attempt error, emit progress,
@@ -1141,6 +1216,17 @@ export async function sendViaWebSocket({
                 continue;
             }
             // Not retryable, OR we've already exhausted the retry budget.
+            // Do not let stale retry history mask a current auth/upgrade
+            // decision, cancellation, or newly unsafe-to-replay outcome.
+            const currentStatus = Number(err?.httpStatus || 0);
+            const surfaceCurrent = currentStatus === 401
+                || currentStatus === 426
+                || externalSignal?.aborted
+                || err?.unsafeToRetry === true;
+            if (surfaceCurrent) {
+                emitSendSpan('error');
+                throw _stampTool(_stampLiveText(err));
+            }
             if (attemptIndex > 0 && firstAttemptError) {
                 // Exhausted path: surface the first-attempt error (the one
                 // the user's turn actually tripped on), tag actual retry count.
@@ -1292,7 +1378,7 @@ export async function sendViaWebSocket({
             : null;
         if (cacheObservation.actualMiss) {
             try {
-                appendAgentTrace({
+                _agentTraceFn({
                     sessionId: poolKey,
                     iteration,
                     kind: 'cache_miss',
@@ -1389,6 +1475,7 @@ export async function sendViaWebSocket({
                 chain_delta_reason: mode === 'delta' ? null : deltaReason,
                 chain_stripped_response_items: strippedResponseItems,
                 chain_skipped_response_items: skippedResponseItems,
+                ...(responseOutputMismatch || {}),
                 chain_response_items: Array.isArray(result.responseItems) ? result.responseItems.length : 0,
                 body_input_items: Array.isArray(requestBody.input) ? requestBody.input.length : null,
                 frame_input_items: Array.isArray(frame.input) ? frame.input.length : null,
@@ -1400,7 +1487,7 @@ export async function sendViaWebSocket({
                 keep_socket: keepSocket,
                 keep_response_chain: keepResponseChain,
             };
-            appendAgentTrace({
+            _agentTraceFn({
                 sessionId: poolKey,
                 iteration,
                 kind: 'transport',
@@ -1411,7 +1498,10 @@ export async function sendViaWebSocket({
                 && deltaReason
                 && !['no_anchor', 'full_forced', 'full_default', 'delta_missing_turn_state'].includes(deltaReason);
             if (chainFallback || (mode === 'delta' && deltaReason)) {
-                appendAgentTrace({
+                const intentionalTransition = typeof sendOpts?.cacheBreakIntent === 'string'
+                    ? sendOpts.cacheBreakIntent
+                    : null;
+                _agentTraceFn({
                     sessionId: poolKey,
                     iteration,
                     kind: 'cache_break',
@@ -1423,6 +1513,8 @@ export async function sendViaWebSocket({
                         transport: 'websocket',
                         ws_mode: mode,
                         reason: mode === 'delta' ? deltaReason : (deltaReason || 'full_frame'),
+                        intentional_transition: intentionalTransition,
+                        request_tool_choice: requestBody.tool_choice ?? null,
                         cache_key_hash: transportCacheKeyHash,
                         cached_tokens: cacheObservation.cachedTokens,
                         prompt_tokens: cacheObservation.promptTokens,
@@ -1432,6 +1524,7 @@ export async function sendViaWebSocket({
                         request_has_previous_response_id: transportPayload.request_has_previous_response_id,
                         chain_stripped_response_items: strippedResponseItems,
                         chain_skipped_response_items: skippedResponseItems,
+                        ...(responseOutputMismatch || {}),
                         chain_response_items: Array.isArray(result.responseItems) ? result.responseItems.length : 0,
                         body_input_items: Array.isArray(requestBody.input) ? requestBody.input.length : null,
                         frame_input_items: Array.isArray(frame.input) ? frame.input.length : null,

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

@@ -58,7 +58,6 @@ import {
 import {
     sendViaHttpSse,
     _envFlag,
-    _envPositiveInt,
     _shouldUseOpenAIHttpFallback,
 } from './openai-oauth-http-sse.mjs';
 import { createOpenAIOAuthLogin } from './openai-oauth-login.mjs';
@@ -830,8 +829,9 @@ export class OpenAIOAuthProvider {
         };
         const markStickyHttpFallback = () => {
             if (!poolKey) return;
-            const ttlMs = _envPositiveInt('MIXDOG_OPENAI_OAUTH_HTTP_FALLBACK_STICKY_MS', 60_000);
-            this._httpFallbackUntilByPoolKey.set(poolKey, Date.now() + ttlMs);
+            // Codex disables WebSockets for the remainder of this session after
+            // stream retry exhaustion (or an explicit 426 upgrade rejection).
+            this._httpFallbackUntilByPoolKey.set(poolKey, Number.POSITIVE_INFINITY);
         };
         const traceWsError = (err, stage = 'primary') => {
             try {
@@ -854,6 +854,9 @@ export class OpenAIOAuthProvider {
             } catch {}
         };
         const dispatchHttp = async (reason, originalErr = null, { sticky = false } = {}) => {
+            // Transport switching is a session decision, not an HTTP-success
+            // side effect. Persist it before the fallback can fail or abort.
+            if (sticky) markStickyHttpFallback();
             appendAgentTrace({
                 sessionId: poolKey,
                 iteration,
@@ -892,7 +895,6 @@ export class OpenAIOAuthProvider {
                 useModel,
                 fetchFn: opts._fetchFn,
             });
-            if (sticky) markStickyHttpFallback();
             if (process.env.MIXDOG_DEBUG_AGENT) {
                 process.stderr.write(`[agent-trace] provider-send-end elapsed=${Date.now() - _t1}ms result=ok transport=http-fallback\n`);
             }
@@ -933,6 +935,13 @@ export class OpenAIOAuthProvider {
                 ? { ...body, generate: false }
                 : null,
         });
+        const mustSurfaceFallbackError = (fallbackErr) => externalSignal?.aborted
+            || fallbackErr?.name === 'AbortError'
+            || fallbackErr?.code === 'ABORT_ERR'
+            || fallbackErr?.liveTextEmitted === true
+            || fallbackErr?.emittedToolCall === true
+            || fallbackErr?.toolCallEmitted === true
+            || fallbackErr?.unsafeToRetry === true;
         if (transportPolicy.transport === 'http'
             || (transportPolicy.allowHttpFallback && (
                 opts.forceHttpFallback === true
@@ -959,7 +968,7 @@ export class OpenAIOAuthProvider {
             // the retry (and the HTTP fallback below already refuses) and
             // surface the original error.
             const liveTextEmitted = err?.liveTextEmitted === true || err?.unsafeToRetry === true;
-            if ((status === 401 || status === 403) && !liveTextEmitted) {
+            if (status === 401 && !liveTextEmitted) {
                 process.stderr.write(`[openai-oauth-ws] ${status} — forcing refresh and retrying once over WS\n`);
                 if (process.env.MIXDOG_DEBUG_AGENT) { process.stderr.write(`[agent-trace] provider-${status}-retry attempt=1\n`); }
                 this._refreshFallbackUntil = 0;
@@ -971,7 +980,7 @@ export class OpenAIOAuthProvider {
                 } catch (retryErr) {
                     traceWsError(retryErr, 'auth_retry');
                     if (httpFallbackEnabled
-                        && retryErr?.wsRetriesExhausted === true
+                        && (retryErr?.httpStatus === 426 || retryErr?.wsRetriesExhausted === true)
                         && _shouldUseOpenAIHttpFallback(retryErr, externalSignal)) {
                         try {
                             return await dispatchHttp(
@@ -980,6 +989,10 @@ export class OpenAIOAuthProvider {
                                 { sticky: true },
                             );
                         } catch (fallbackErr) {
+                            // Cancellation and post-output failures are the
+                            // current terminal outcome; replacing either with
+                            // stale WS history could permit upstream replay.
+                            if (mustSurfaceFallbackError(fallbackErr)) throw fallbackErr;
                             try { retryErr.fallbackError = fallbackErr; } catch {}
                             throw retryErr;
                         }
@@ -988,7 +1001,7 @@ export class OpenAIOAuthProvider {
                 }
             }
             // Auth failure after live text already emitted: never reissue.
-            if ((status === 401 || status === 403) && liveTextEmitted) {
+            if (status === 401 && liveTextEmitted) {
                 throw err;
             }
             const msg = err?.message || '';
@@ -1004,7 +1017,7 @@ export class OpenAIOAuthProvider {
                 return this.send(messages, model, tools, { ...opts, _modelRetry: true });
             }
             if (httpFallbackEnabled
-                && err?.wsRetriesExhausted === true
+                && (status === 426 || err?.wsRetriesExhausted === true)
                 && _shouldUseOpenAIHttpFallback(err, externalSignal)) {
                 try {
                     return await dispatchHttp(
@@ -1013,6 +1026,7 @@ export class OpenAIOAuthProvider {
                         { sticky: true },
                     );
                 } catch (fallbackErr) {
+                    if (mustSurfaceFallbackError(fallbackErr)) throw fallbackErr;
                     try { err.fallbackError = fallbackErr; } catch {}
                     throw err;
                 }

package/src/runtime/agent/orchestrator/providers/openai-ws-delta.mjs

@@ -15,6 +15,7 @@ import {
     RESPONSES_TRANSPORT_CAPABILITIES,
     FULL_RESPONSES_TRANSPORT_CAPS,
 } from './openai-transport-policy.mjs';
+import { createHash } from 'node:crypto';
 
 // If the cached request (sans input) matches the current one and the current
 // input starts with the cached input, return only the tail. Otherwise return
@@ -157,6 +158,67 @@ function _isReplayLikeHead(item, responseItem) {
     return inputType === responseType;
 }
 
+// The hash input follows the same per-item normalizations used by
+// _logicalResponseItemMatch, but is never emitted itself. This retains a
+// stable comparison fingerprint after history compaction without putting
+// message content, tool arguments, or custom-tool input into traces.
+function _normalizedResponseItemDiagnosticShape(item) {
+    if (!item || typeof item !== 'object') return item || null;
+    const type = item.type || (item.role === 'assistant' ? 'message' : '');
+    if (type === 'function_call' || type === 'tool_search_call') {
+        return {
+            type,
+            call_id: String(item.call_id || ''),
+            name: type === 'function_call' ? String(item.name || '') : undefined,
+            arguments: _normalizeArguments(item.arguments),
+        };
+    }
+    if (type === 'custom_tool_call') {
+        return {
+            type,
+            call_id: String(item.call_id || ''),
+            name: String(item.name || ''),
+            input: String(item.input || ''),
+        };
+    }
+    if (type === 'message') {
+        return {
+            type,
+            role: item.role || 'assistant',
+            content: Array.isArray(item.content) ? item.content.map(_normalizeContentPart) : [],
+        };
+    }
+    if (type === 'reasoning') {
+        return {
+            type,
+            id: item.id || null,
+            encrypted_content: item.encrypted_content || null,
+        };
+    }
+    if (type === 'web_search_call') {
+        return { type, id: item.id || null, action: item.action || null };
+    }
+    const { id: _id, status: _status, ...rest } = item;
+    return { type, ...rest };
+}
+
+function _normalizedResponseItemDiagnosticHash(item) {
+    return createHash('sha256')
+        .update(_stableStringify(_normalizedResponseItemDiagnosticShape(item)))
+        .digest('hex');
+}
+
+function _responseOutputMismatchDiagnostics(inputItem, responseItem, replayItemCount, responseItemCount) {
+    return {
+        response_output_mismatch_expected_type: responseItem?.type || 'unknown',
+        response_output_mismatch_expected_hash: _normalizedResponseItemDiagnosticHash(responseItem),
+        response_output_mismatch_expected_response_item_count: responseItemCount,
+        response_output_mismatch_actual_type: inputItem?.type || (inputItem?.role === 'assistant' ? 'message' : 'unknown'),
+        response_output_mismatch_actual_hash: _normalizedResponseItemDiagnosticHash(inputItem),
+        response_output_mismatch_actual_replayed_input_item_count: replayItemCount,
+    };
+}
+
 export function _stripResponseItemsFromHead(items, responseItems) {
     const tail = Array.isArray(items) ? items : [];
     const outputs = Array.isArray(responseItems) ? responseItems : [];
@@ -177,6 +239,12 @@ export function _stripResponseItemsFromHead(items, responseItems) {
                 tail,
                 stripped,
                 skipped,
+                responseOutputMismatch: _responseOutputMismatchDiagnostics(
+                    tail[cursor],
+                    output,
+                    tail.length,
+                    outputs.length,
+                ),
             };
         }
         skipped += 1;
@@ -291,7 +359,12 @@ export function _computeDelta({ entry, body, traceProvider }) {
     }
     const stripped = _stripResponseItemsFromHead(afterPreviousInput, entry.lastResponseItems);
     if (!stripped.ok) {
-        return { mode: 'full', reason: stripped.reason, frame: buildFrame(body) };
+        return {
+            mode: 'full',
+            reason: stripped.reason,
+            responseOutputMismatch: stripped.responseOutputMismatch,
+            frame: buildFrame(body),
+        };
     }
     return {
         mode: 'delta',