mixdog 0.9.45 → 0.9.47

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

@@ -252,6 +252,7 @@ export async function sendViaHttpSse({
         throw new Error('OpenAI OAuth HTTP fallback returned no response body');
     }
 
+    try { onStreamDelta?.('transport'); } catch {}
     try { onStageChange?.('streaming'); } catch {}
     const sseStartedAt = Date.now();
     const reader = response.body.getReader();
@@ -266,6 +267,13 @@ export async function sendViaHttpSse({
     // partial response surface as success — so record the abort reason and
     // re-throw it after the loop unblocks (see below).
     let _streamAbortReason = null;
+    let _pendingReadReject = null;
+    const _rejectPendingRead = (err) => {
+        if (!_pendingReadReject) return;
+        const reject = _pendingReadReject;
+        _pendingReadReject = null;
+        reject(err);
+    };
     let _onTotalAbort = null;
     if (totalTimeout.signal) {
         _onTotalAbort = () => {
@@ -274,6 +282,7 @@ export async function sendViaHttpSse({
                 ? reason
                 : new Error('OpenAI OAuth HTTP fallback aborted');
             try { reader.cancel(_streamAbortReason).catch(() => {}); } catch {}
+            _rejectPendingRead(_streamAbortReason);
         };
         if (totalTimeout.signal.aborted) _onTotalAbort();
         else totalTimeout.signal.addEventListener('abort', _onTotalAbort, { once: true });
@@ -286,11 +295,17 @@ export async function sendViaHttpSse({
     const _clearSemanticIdle = () => {
         if (_semanticIdleTimer) { clearTimeout(_semanticIdleTimer); _semanticIdleTimer = null; }
     };
+    const semanticIdleOverrideMs = Number(opts?._semanticIdleTimeoutMs);
+    const semanticIdleMs = Number.isFinite(semanticIdleOverrideMs) && semanticIdleOverrideMs > 0
+        ? semanticIdleOverrideMs
+        : PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS;
+    const semanticIdleEnabled = (Number.isFinite(semanticIdleOverrideMs) && semanticIdleOverrideMs > 0)
+        || PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
     const _armSemanticIdle = () => {
-        if (!PROVIDER_SSE_IDLE_WATCHDOG_ENABLED || !(PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS > 0)) return;
+        if (!semanticIdleEnabled || !(semanticIdleMs > 0)) return;
         _clearSemanticIdle();
         _semanticIdleTimer = setTimeout(() => {
-            _streamAbortReason = streamStalledError('OpenAI OAuth HTTP fallback', PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS, { emittedToolCall: emittedToolCallIds.size > 0 });
+            _streamAbortReason = streamStalledError('OpenAI OAuth HTTP fallback', semanticIdleMs, { emittedToolCall: emittedToolCallIds.size > 0 });
             // Partial-final recovery: attach the
             // streamed partial state so the agent loop can accept a wedged FINAL
             // no-tool summary as a successful partial-final instead of dropping
@@ -310,7 +325,8 @@ export async function sendViaHttpSse({
                 _streamAbortReason.partialModel = model || undefined;
             } catch { /* best-effort enrichment */ }
             try { reader.cancel(_streamAbortReason).catch(() => {}); } catch {}
-        }, PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS);
+            _rejectPendingRead(_streamAbortReason);
+        }, semanticIdleMs);
         try { _semanticIdleTimer.unref?.(); } catch {}
     };
     let buffer = '';
@@ -404,6 +420,7 @@ export async function sendViaHttpSse({
         };
         toolCalls.push(call);
         emitToolCall(call);
+        meaningful('tool');
     };
     const relayLeakText = (delta) => {
         if (!leakGuard.enabled) {
@@ -412,11 +429,13 @@ export async function sendViaHttpSse({
                 emittedText = true;
                 try { onTextDelta(delta); } catch {}
             }
+            if (delta) meaningful('text');
             return;
         }
         const { text, calls } = leakGuard.push(delta);
         if (text) {
             content += text;
+            meaningful('text');
             if (onTextDelta) {
                 emittedText = true;
                 try { onTextDelta(text); } catch {}
@@ -482,10 +501,10 @@ export async function sendViaHttpSse({
         toolCalls.push(call);
         emitToolCall(call);
     };
-    const meaningful = () => {
+    const meaningful = (kind = 'semantic') => {
         if (ttftMs == null) ttftMs = Date.now() - sseStartedAt;
         _armSemanticIdle();
-        try { onStreamDelta?.(); } catch {}
+        try { onStreamDelta?.(kind); } catch {}
     };
     const handleEvent = (event) => {
         if (!event || typeof event.type !== 'string') return;
@@ -493,14 +512,14 @@ export async function sendViaHttpSse({
             case 'response.created':
                 if (event.response?.model) model = event.response.model;
                 if (event.response?.id) responseId = event.response.id;
+                meaningful('semantic');
                 break;
             case 'response.output_text.delta':
-                meaningful();
                 relayLeakText(event.delta || '');
                 break;
             case 'response.reasoning_text.delta':
             case 'response.reasoning_summary_text.delta':
-                meaningful();
+                if (event.delta) meaningful('reasoning');
                 break;
             case 'response.output_item.added':
                 if (event.item?.type === 'function_call') {
@@ -537,16 +556,17 @@ export async function sendViaHttpSse({
                     markActiveToolItem(event.item);
                     _toolInFlight = true;
                 }
+                meaningful(_toolInFlight ? 'tool' : 'semantic');
                 break;
             case 'response.function_call_arguments.delta':
                 markActiveToolItem(null, event.item_id);
                 _toolInFlight = true;
-                meaningful();
+                meaningful('tool');
                 break;
             case 'response.function_call_arguments.done': {
                 const itemId = event.item_id || '';
                 const pending = pendingCalls.get(itemId);
-                if (pending?.kind === 'tool_search') { meaningful(); break; }
+                if (pending?.kind === 'tool_search') { meaningful('tool'); break; }
                 const call = {
                     id: pending?.callId || event.call_id || '',
                     name: pending?.name || event.name || '',
@@ -558,13 +578,13 @@ export async function sendViaHttpSse({
                     delete call._pendingItemId;
                     emitToolCall(call);
                 }
-                meaningful();
+                meaningful('tool');
                 break;
             }
             case 'response.custom_tool_call_input.delta':
                 markActiveToolItem(null, event.item_id);
                 _toolInFlight = true;
-                meaningful();
+                meaningful('tool');
                 break;
             case 'response.output_item.done': {
                 const item = event.item || {};
@@ -597,8 +617,10 @@ export async function sendViaHttpSse({
                     pushCustomToolCall(item);
                     clearActiveToolItem(item, item.id || '');
                     _toolInFlight = pendingCalls.size > 0 || activeToolItems.size > 0;
-                    meaningful();
                 }
+                meaningful(item.type === 'reasoning'
+                    ? 'reasoning'
+                    : (/tool|function_call/.test(item.type || '') ? 'tool' : 'semantic'));
                 break;
             }
             case 'response.completed': {
@@ -615,6 +637,7 @@ export async function sendViaHttpSse({
                         raw: serviceTier ? { ...resp.usage, service_tier: serviceTier } : resp.usage,
                     };
                 }
+                let reportedBundleProgress = false;
                 for (const item of resp.output || []) {
                     if (item.type === 'message') {
                         for (const part of item.content || []) {
@@ -627,22 +650,38 @@ export async function sendViaHttpSse({
                                 if (leakGuard.enabled) {
                                     const { text, calls } = leakGuard.push(part.text || '', true);
                                     content += text;
+                                    if (text) {
+                                        meaningful('text');
+                                        reportedBundleProgress = true;
+                                    }
                                     for (const c of calls) dispatchLeakedCall(c);
+                                    if (calls.length) reportedBundleProgress = true;
                                 } else {
                                     content += part.text || '';
+                                    if (part.text) {
+                                        meaningful('text');
+                                        reportedBundleProgress = true;
+                                    }
                                 }
                             }
                             if (part.type === 'output_text') _pushOutputTextAnnotations(part, citations, citationKeys);
                         }
                     } else if (item.type === 'reasoning') {
                         pushReasoningItem(item);
+                        meaningful('reasoning');
+                        reportedBundleProgress = true;
                     } else if (item.type === 'web_search_call') {
                         pushWebSearchCall(item);
+                        meaningful('tool');
+                        reportedBundleProgress = true;
                     } else if (item.type === 'tool_search_call') {
                         pushToolSearchCall(item);
+                        meaningful('tool');
+                        reportedBundleProgress = true;
                     } else if (item.type === 'custom_tool_call') {
                         pushCustomToolCall(item);
-                        meaningful();
+                        meaningful('tool');
+                        reportedBundleProgress = true;
                     } else if (item.type === 'function_call') {
                         // Match the still-pending placeholder by item id, or
                         // an already-recorded call by its canonical call_id —
@@ -667,8 +706,11 @@ export async function sendViaHttpSse({
                             toolCalls.push(call);
                             emitToolCall(call);
                         }
+                        meaningful('tool');
+                        reportedBundleProgress = true;
                     }
                 }
+                if (!reportedBundleProgress) meaningful('semantic');
                 completed = true;
                 break;
             }
@@ -754,8 +796,13 @@ export async function sendViaHttpSse({
                 throw reason instanceof Error ? reason : new Error('OpenAI OAuth HTTP fallback aborted');
             }
             if (_streamAbortReason) throw _streamAbortReason;
-            const { value, done } = await reader.read();
+            const { value, done } = await new Promise((resolve, reject) => {
+                _pendingReadReject = reject;
+                reader.read().then(resolve, reject);
+            });
+            _pendingReadReject = null;
             if (done) break;
+            try { onStreamDelta?.('transport'); } catch {}
             buffer += decoder.decode(value, { stream: true });
             const parsed = _sseEventsFromBuffer(buffer);
             buffer = parsed.rest;
@@ -786,6 +833,7 @@ export async function sendViaHttpSse({
         _stampToolSafety(err);
         throw err;
     } finally {
+        _pendingReadReject = null;
         _clearSemanticIdle();
         try { reader.releaseLock?.(); } catch {}
         if (_onTotalAbort && totalTimeout.signal) {

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

@@ -24,6 +24,7 @@
  * parsing, and tracing.
  */
 import { createHash } from 'crypto';
+import { performance } from 'node:perf_hooks';
 import {
     traceAgentFetch,
     traceAgentSse,
@@ -76,6 +77,7 @@ export {
     parseToolSearchArgs,
     _streamResponse,
     _cacheObservation as _cacheObservationForTest,
+    _cacheContinuityResetReason as _cacheContinuityResetReasonForTest,
     _warmupContinuityTrace as _warmupContinuityTraceForTest,
 };
 
@@ -412,7 +414,7 @@ export function _withCodexWsClientMetadata(frame, entry, enabled, context = {})
     };
 }
 
-function _cacheObservation({ entry, result }) {
+function _cacheObservation({ entry, result, continuityResetReason = null }) {
     const inputTokens = _num(result?.usage?.inputTokens, 0);
     const promptTokens = _num(result?.usage?.promptTokens, 0) || inputTokens;
     const cachedTokens = _num(result?.usage?.cachedTokens, 0);
@@ -421,7 +423,11 @@ function _cacheObservation({ entry, result }) {
     const promptThreshold = _envPositiveInt('MIXDOG_OAI_CACHE_MISS_PROMPT_TOKENS', 4096);
     const dropRatio = _envRatio('MIXDOG_OAI_CACHE_MISS_DROP_RATIO', 0.6);
     const dropThreshold = Math.floor(previousMaxCached * dropRatio);
-    const wasWarm = previousMaxCached >= warmThreshold;
+    // A full-frame chain break (most commonly compaction/input-prefix rewrite)
+    // starts a new prompt shape. Comparing its small new prompt against the
+    // old shape's lifetime high-water creates a "cache drop" on every following
+    // iteration until the new transcript grows past 60% of the old one.
+    const wasWarm = !continuityResetReason && previousMaxCached >= warmThreshold;
     const cacheRatio = promptTokens > 0 ? cachedTokens / promptTokens : null;
     const zeroMiss = wasWarm && promptTokens >= promptThreshold && cachedTokens === 0;
     const partialDrop = wasWarm
@@ -443,6 +449,7 @@ function _cacheObservation({ entry, result }) {
         dropThreshold,
         cacheRatio,
         actualMiss,
+        continuityResetReason,
         missReason: zeroMiss
             ? 'warm_session_zero_cached_tokens'
             : partialDrop
@@ -451,6 +458,34 @@ function _cacheObservation({ entry, result }) {
     };
 }
 
+function _requestInputExtends(previousInput, currentInput) {
+    if (!Array.isArray(previousInput) || !Array.isArray(currentInput)) return false;
+    if (currentInput.length < previousInput.length) return false;
+    return previousInput.every(
+        (item, index) => _stableStringify(item) === _stableStringify(currentInput[index]),
+    );
+}
+
+function _cacheContinuityResetReason({ mode, deltaReason, entry, body }) {
+    if (mode === 'delta') return null;
+    if (deltaReason && !['no_anchor', 'full_forced', 'full_default'].includes(deltaReason)) {
+        return deltaReason;
+    }
+    // ws-full bypasses _computeDelta's structural comparisons and reports only
+    // full_default. Re-run the two cheap snapshot checks so compaction or any
+    // other prompt rewrite still retires the old prompt's cache high-water.
+    if (deltaReason !== 'full_default' || !entry?.lastResponseId) return null;
+    const currentSansInput = _stableStringify(_sansInput(body));
+    if (entry.lastRequestSansInput && currentSansInput !== entry.lastRequestSansInput) {
+        return 'request_properties_changed';
+    }
+    if (Array.isArray(entry.lastRequestInput)
+        && !_requestInputExtends(entry.lastRequestInput, Array.isArray(body?.input) ? body.input : [])) {
+        return 'input_prefix_mismatch';
+    }
+    return null;
+}
+
 // Warmup→first-real continuity trace (Codex prewarm_websocket parity
 // observability). Pure/deterministic so it unit-tests without a live socket.
 // The R23 finding forbids the post-warmup request rewrite, so parity is
@@ -495,6 +530,7 @@ export async function _acquireWithRetry({
     codexHeaders,
     forceFresh,
     onRetry,
+    onBackoffSlept,
     externalSignal,
     _acquire = acquireWebSocket,
     _sleepFn = _defaultSleep,
@@ -560,8 +596,10 @@ export async function _acquireWithRetry({
             } catch {}
             // Sleep is abort-aware: an abort during backoff rejects immediately
             // instead of burning the remaining wait.
-            if (externalSignal) {
-                await new Promise((resolve, reject) => {
+            const sleepStart = performance.now();
+            try {
+                if (externalSignal) {
+                    await new Promise((resolve, reject) => {
                     const t = setTimeout(() => {
                         externalSignal.removeEventListener('abort', onAbort);
                         resolve();
@@ -573,9 +611,12 @@ export async function _acquireWithRetry({
                     };
                     if (externalSignal.aborted) { onAbort(); return; }
                     externalSignal.addEventListener('abort', onAbort, { once: true });
-                });
-            } else {
-                await _sleepFn(backoff);
+                    });
+                } else {
+                    await _sleepFn(backoff);
+                }
+            } finally {
+                try { onBackoffSlept?.(performance.now() - sleepStart); } catch {}
             }
         }
     }
@@ -624,6 +665,7 @@ export async function sendViaWebSocket({
     _streamFn = _streamResponse,
     _sendFrameFn = _sendFrame,
     _sleepFn = _defaultSleep,
+    _sendSpanTraceFn = appendAgentTrace,
 }) {
     // Bounded mid-stream retry: if an attempt's stream dies after
     // response.created but before response.completed from a transient cause
@@ -678,12 +720,53 @@ export async function sendViaWebSocket({
     const codexHandshakeHeaders = useCodexWsClientMetadata
         ? _codexWsCompatibilityHeaders({ ...codexMetadataContext, handshake: true })
         : null;
+    // One compact row per logical iteration. Values aggregate all handshake
+    // and mid-stream attempts, including warmup, without retaining request data.
+    const sendSpan = {
+        poolAcquireMs: 0,
+        requestBuildSerializationMs: 0,
+        preResponseCreatedMs: 0,
+        firstEventMs: 0,
+        retryBackoffMs: 0,
+        handshakeRetries: 0,
+        acquireAttempts: 0,
+        acquireMode: null,
+        emitted: false,
+    };
+    const emitSendSpan = (outcome) => {
+        if (sendSpan.emitted) return;
+        sendSpan.emitted = true;
+        const payload = {
+            provider: traceProvider,
+            model: useModel,
+            transport: 'websocket',
+            acquire_mode: sendSpan.acquireMode || 'failed',
+            acquire_attempts: sendSpan.acquireAttempts,
+            handshake_retries: sendSpan.handshakeRetries,
+            pool_acquire_ms: sendSpan.poolAcquireMs,
+            request_build_serialization_ms: sendSpan.requestBuildSerializationMs,
+            pre_response_created_ms: sendSpan.preResponseCreatedMs,
+            first_event_ms: sendSpan.firstEventMs,
+            retry_backoff_ms: sendSpan.retryBackoffMs,
+            outcome,
+        };
+        try {
+            _sendSpanTraceFn({
+                sessionId: poolKey,
+                iteration,
+                kind: 'send_spans',
+                ...payload,
+                payload,
+            });
+        } catch {}
+    };
 
     for (let attemptIndex = 0; attemptIndex <= MAX_MIDSTREAM_RETRIES; attemptIndex++) {
-        const handshakeStart = Date.now();
+        const handshakeStart = performance.now();
         let acquired;
         let handshakeRetries = 0;
         const handshakeRetryClassifiers = [];
+        sendSpan.acquireAttempts += 1;
         try { onStageChange?.('requesting'); } catch {}
         try {
             acquired = await _acquireWithRetryFn({
@@ -703,17 +786,20 @@ export async function sendViaWebSocket({
                 maxAttempts: (fastFallback && attemptIndex === 0) ? 1 : HANDSHAKE_MAX_ATTEMPTS,
                 onRetry: (info) => {
                     handshakeRetries += 1;
+                    sendSpan.handshakeRetries += 1;
                     if (info?.classifier) handshakeRetryClassifiers.push(info.classifier);
                 },
+                onBackoffSlept: (ms) => { sendSpan.retryBackoffMs += ms; },
             });
         } catch (err) {
+            sendSpan.poolAcquireMs += performance.now() - handshakeStart;
             const classifier = err?.retryClassifier || (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) {
                 traceAgentFetch({
                     sessionId: poolKey,
-                    headersMs: Date.now() - handshakeStart,
+                    headersMs: performance.now() - handshakeStart,
                     httpStatus: Number(err?.httpStatus || 0),
                     provider: traceProvider,
                     model: useModel,
@@ -727,11 +813,15 @@ export async function sendViaWebSocket({
             // the caller's turn actually tripped on).
             if (attemptIndex > 0 && firstAttemptError) {
                 try { firstAttemptError.midstreamRetries = attemptIndex; } catch {}
+                emitSendSpan('error');
                 throw _stampTool(_stampLiveText(firstAttemptError));
             }
+            emitSendSpan('error');
             throw _stampTool(_stampLiveText(err));
         }
         const { entry, reused } = acquired;
+        sendSpan.poolAcquireMs += performance.now() - handshakeStart;
+        sendSpan.acquireMode = entry?.ephemeral ? 'ephemeral' : (reused ? 'reused' : 'new');
         // Re-seed the retry attempt's fresh entry with the prior attempt's
         // last successful anchor so _computeDelta sees a non-null
         // lastInputPrefixHash and prev_response_id, keeping the same xAI
@@ -746,7 +836,7 @@ export async function sendViaWebSocket({
         }
         traceAgentFetch({
             sessionId: poolKey,
-            headersMs: Date.now() - handshakeStart,
+            headersMs: performance.now() - handshakeStart,
             httpStatus: reused ? 0 : 101,
             provider: traceProvider,
             model: useModel,
@@ -801,6 +891,7 @@ export async function sendViaWebSocket({
             // has no prior request state. A reused pooled socket with a live
             // chain must go straight to the real request.
             if (warmupBody && typeof warmupBody === 'object' && attemptIndex === 0 && !entry.lastResponseId) {
+                const warmupBuildStart = performance.now();
                 // Codex WS prewarm parity (opt-in): codex's prewarm frame is a
                 // minimal generate:false request that omits transport-only
                 // fields (stream/background) on the wire (prewarm_websocket,
@@ -824,7 +915,8 @@ export async function sendViaWebSocket({
                 const wireWarmupFrame = _withCodexWsClientMetadata(warmupFrame, entry, useCodexWsClientMetadata, warmupMetadataContext);
                 wireFrameHadTurnState = !!wireWarmupFrame?.client_metadata?.['x-codex-turn-state'];
                 wireFrameMetadataTrace = _metadataTrace(wireWarmupFrame?.client_metadata);
-                await _sendFrameFn(entry, wireWarmupFrame);
+                sendSpan.requestBuildSerializationMs += performance.now() - warmupBuildStart;
+                await _sendFrameFn(entry, wireWarmupFrame, sendSpan);
                 const warmupStart = Date.now();
                 const warmupState = {
                     attemptIndex,
@@ -835,6 +927,8 @@ export async function sendViaWebSocket({
                     model: useModel,
                     traceProvider,
                     warmup: true,
+                    sendSpan,
+                    sendStartedAt: performance.now(),
                 };
                 warmupResult = await _streamFn({
                     entry,
@@ -914,6 +1008,7 @@ export async function sendViaWebSocket({
                     lastInputPrefixHash: null,
                 }
                 : entry;
+            const requestBuildStart = performance.now();
             const delta = _computeDelta({ entry: deltaEntry, body: requestBody, traceProvider });
             ({ mode, frame } = delta);
             deltaReason = delta.reason || null;
@@ -959,10 +1054,13 @@ export async function sendViaWebSocket({
                 const reason = externalSignal.reason;
                 throw reason instanceof Error ? reason : new Error('Aborted');
             }
-            await _sendFrameFn(entry, wireFrame);
+            sendSpan.requestBuildSerializationMs += performance.now() - requestBuildStart;
+            await _sendFrameFn(entry, wireFrame, sendSpan);
+            midState.sendSpan = sendSpan;
+            midState.sendStartedAt = performance.now();
 
             if (process.env.MIXDOG_DEBUG_AGENT) {
-                process.stderr.write(`[agent-trace] ws-streaming-start sinceAcquire=${Date.now() - handshakeStart}ms\n`);
+                process.stderr.write(`[agent-trace] ws-streaming-start sinceAcquire=${Math.round(performance.now() - handshakeStart)}ms\n`);
             }
             try { onStageChange?.('streaming'); } catch {}
             result = await _streamFn({
@@ -1034,7 +1132,15 @@ export async function sendViaWebSocket({
                     if (!process.env.MIXDOG_QUIET_PROVIDER_LOG) process.stderr.write(line);
                     emittedProgress.push(line);
                 } catch {}
-                await _sleepWithAbort(backoff, externalSignal, _sleepFn);
+                const sleepStart = performance.now();
+                try {
+                    await _sleepWithAbort(backoff, externalSignal, _sleepFn);
+                } catch (sleepErr) {
+                    sendSpan.retryBackoffMs += performance.now() - sleepStart;
+                    emitSendSpan('error');
+                    throw sleepErr;
+                }
+                sendSpan.retryBackoffMs += performance.now() - sleepStart;
                 continue;
             }
             // Not retryable, OR we've already exhausted the retry budget.
@@ -1056,8 +1162,10 @@ export async function sendViaWebSocket({
                         firstAttemptError.suppressed = list;
                     }
                 } catch {}
+                emitSendSpan('error');
                 throw _stampTool(_stampLiveText(firstAttemptError));
             }
+            emitSendSpan('error');
             throw _stampTool(_stampLiveText(err));
         }
         const liveModel = result.model || useModel;
@@ -1099,6 +1207,12 @@ export async function sendViaWebSocket({
         const priorEntryResponseId = typeof entry?.lastResponseId === 'string' && entry.lastResponseId.length > 0
             ? entry.lastResponseId
             : null;
+        const cacheContinuityResetReason = _cacheContinuityResetReason({
+            mode,
+            deltaReason,
+            entry,
+            body: requestBody,
+        });
         if (result.responseId && keepResponseChain) {
             entry.lastResponseId = result.responseId;
             entry.lastRequestSansInput = _stableStringify(_sansInput(requestBody));
@@ -1124,7 +1238,11 @@ export async function sendViaWebSocket({
         // warmup usage in first (R18) made prompt_tokens spike on it=1 and
         // then "shrink" on it=2, faking prefix-rewrite/cache-drop signals in
         // every warmup session (debugger 2026-07-03).
-        const cacheObservation = _cacheObservation({ entry, result });
+        const cacheObservation = _cacheObservation({
+            entry,
+            result,
+            continuityResetReason: cacheContinuityResetReason,
+        });
         if (warmupResult?.usage) {
             result.usage = _combineUsageWithWarmup(result.usage, warmupResult.usage);
         }
@@ -1207,10 +1325,13 @@ export async function sendViaWebSocket({
                 });
             } catch {}
         }
-        entry.promptCacheMaxCachedTokens = Math.max(
-            _num(entry.promptCacheMaxCachedTokens, 0),
-            cacheObservation.cachedTokens,
-        );
+        // Rebase after a genuine provider retreat so one eviction produces one
+        // diagnostic instead of a long run of duplicate "dropped" rows. The
+        // request that exposed the retreat has already rebuilt the prefix; its
+        // observed cached count is the correct baseline for recovery.
+        entry.promptCacheMaxCachedTokens = (cacheObservation.actualMiss || cacheObservation.continuityResetReason)
+            ? cacheObservation.cachedTokens
+            : Math.max(_num(entry.promptCacheMaxCachedTokens, 0), cacheObservation.cachedTokens);
         // Early-session cache-miss ledger (first up-to-3 real requests on this
         // socket) for the warmup→first-real continuity trace below. Warmup
         // itself is excluded — this block only runs on the real send.
@@ -1340,6 +1461,7 @@ export async function sendViaWebSocket({
         // Leave a breadcrumb on the result so downstream callers can observe
         // that a retry was used (0 = first-try success, up to 2 for ws_1006/1011).
         try { Object.defineProperty(out, '__midstreamRetries', { value: attemptIndex, enumerable: false }); } catch {}
+        emitSendSpan('ok');
         return out;
     }
     // Unreachable — the loop either returns or throws above.

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

@@ -9,11 +9,12 @@
  */
 import { createHash } from 'crypto';
 import { readFileSync, existsSync, mkdirSync, statSync, unlinkSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { getPluginData } from '../config.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
-import { writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
+import { writeJsonAtomicSync, withFileLock } from '../../../shared/atomic-file.mjs';
+import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { makeModelCache } from './model-cache.mjs';
 
 import { sendViaWebSocket } from './openai-oauth-ws.mjs';
@@ -171,6 +172,10 @@ export async function ensureLatestCodexModel(provider) {
 }
 
 function getOwnTokenPath() {
+    const bound = boundProviderAuthPath('openai-oauth');
+    if (bound) return resolve(bound);
+    const explicit = process.env.OPENAI_OAUTH_CREDENTIALS_PATH;
+    if (explicit) return resolve(explicit);
     const dir = getPluginData();
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
@@ -255,6 +260,9 @@ function saveTokens(tokens) {
     const target = getOwnTokenPath();
     writeJsonAtomicSync(target, tokens, { lock: true, fsyncDir: true, mode: 0o600, secret: true });
 }
+function getRefreshLockPath() {
+    return `${getOwnTokenPath()}.refresh.lock`;
+}
 
 export function forgetOpenAIOAuthCredentials() {
     let removed = false;
@@ -682,7 +690,7 @@ export class OpenAIOAuthProvider {
         }
 
         const startingTokens = this.tokens || disk;
-        _oauthRefreshInFlight = (async () => {
+        _oauthRefreshInFlight = withFileLock(getRefreshLockPath(), async () => {
             const latest = loadTokens() || startingTokens;
             const latestValidAfter = Date.now() + (force ? 0 : TOKEN_REFRESH_SKEW_MS);
             if (latest?.access_token && latest.access_token !== currentToken
@@ -720,7 +728,7 @@ export class OpenAIOAuthProvider {
                 }
                 throw new Error(`OpenAI OAuth token refresh failed (${msg}). Re-authenticate via provider login.`);
             }
-        })().finally(() => { _oauthRefreshInFlight = null; });
+        }).finally(() => { _oauthRefreshInFlight = null; });
 
         this.tokens = await _oauthRefreshInFlight;
         return this.tokens;