mixdog 0.9.87 → 0.9.89

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

@@ -6,7 +6,8 @@ import {
     createTimeoutSignal,
     providerTimeoutError,
 } from '../stall-policy.mjs';
-import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
+import { typedStatusFrom } from './retry-classifier.mjs';
+import { stampStreamOutcome, STREAM_TRANSPORTS } from './lib/stream-outcome.mjs';
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
 import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';
 import { randomBytes } from 'crypto';
@@ -295,6 +296,12 @@ export async function consumeCompatChatCompletionStream(stream, {
     // must be treated as permanent — the rendered text cannot be withdrawn and
     // a retry would concatenate a second attempt.
     let emittedText = false;
+    // Reasoning exposure invariant: reasoning_content / reasoning / thinking
+    // deltas are relayed to the client (onStreamDelta('reasoning')) and kept in
+    // the assembled message, so they are OBSERVED, VISIBLE output. A failure
+    // afterwards must never be replayed — a retry (or a non-streaming reset
+    // recovery) would duplicate the exposed reasoning.
+    let emittedReasoning = false;
     let model = '';
     let responseId = '';
     let stopReason = null;
@@ -327,6 +334,32 @@ export async function consumeCompatChatCompletionStream(stream, {
         return call;
     };
     const leakedCalls = [];
+    // Canonical stream-outcome stamp for EVERY reject path of this consumer.
+    // Without it the failure is "unknown" to the replay gates, and an upstream
+    // recovery (withRetry, transport fallback, non-streaming reset) could
+    // re-issue a turn whose text/reasoning was already relayed or whose tool
+    // call was already dispatched.
+    const _stampCompatOutcome = (err, extra = {}) => {
+        try {
+            stampStreamOutcome(err, {
+                transport: STREAM_TRANSPORTS.SSE,
+                provider: 'openai-compat',
+                terminalObserved: !!stopReason,
+                continuation: !stopReason,
+                textEmitted: emittedText === true,
+                textObservedChars: content.length,
+                reasoningEmitted: emittedReasoning === true || reasoningContent.length > 0,
+                toolCallsStarted: toolAcc.size > 0 || leakedCalls.length > 0,
+                toolCallsComplete: leakedCalls.length,
+                toolCallsDispatched: streamEmitState.emittedToolCall === true
+                    ? Math.max(1, leakedCalls.length)
+                    : 0,
+                pendingToolInput: toolAcc.size > 0,
+                ...extra,
+            });
+        } catch { /* stamping is best-effort */ }
+        return err;
+    };
     const relayText = (delta) => {
         const { text, calls } = leakGuard.push(delta);
         if (text) {
@@ -407,6 +440,7 @@ export async function consumeCompatChatCompletionStream(stream, {
             if (reasoningDelta !== null) {
                 reasoningContent += reasoningDelta;
                 if (reasoningDelta) {
+                    emittedReasoning = true;
                     reportProgress('reasoning');
                 }
             }
@@ -432,7 +466,7 @@ export async function consumeCompatChatCompletionStream(stream, {
                 err.pendingToolUse = toolAcc.size > 0 || leakedCalls.length > 0;
                 err.partialModel = model || undefined;
             } catch { /* best-effort */ }
-            throw markUnsafeRetryIfToolEmitted(err, streamEmitState);
+            throw _stampCompatOutcome(markUnsafeRetryIfToolEmitted(err, streamEmitState));
         }
         // Partial-final recovery: on a mid-stream stall, attach the
         // streamed partial state so the loop can accept a wedged FINAL no-tool
@@ -445,13 +479,14 @@ export async function consumeCompatChatCompletionStream(stream, {
                 err.partialModel = model || undefined;
             } catch { /* best-effort */ }
         }
-        throw markUnsafeRetryIfToolEmitted(err, streamEmitState);
+        throw _stampCompatOutcome(markUnsafeRetryIfToolEmitted(err, streamEmitState));
     } finally {
         firstByteTimeout.cleanup();
     }
     if (!sawFirstEvent) {
-        if (firstByteTimeout.signal?.aborted) throw firstByteCompatStreamError(label);
-        throw firstByteCompatStreamError(label);
+        // Pre-output: nothing was sampled, so this stays replay-safe.
+        if (firstByteTimeout.signal?.aborted) throw _stampCompatOutcome(firstByteCompatStreamError(label));
+        throw _stampCompatOutcome(firstByteCompatStreamError(label));
     }
     if (!stopReason) {
         const err = truncatedCompatStreamError(label, 'no finish_reason');
@@ -468,7 +503,7 @@ export async function consumeCompatChatCompletionStream(stream, {
                 err.partialModel = model || undefined;
             } catch { /* best-effort */ }
         }
-        throw markUnsafeRetryIfToolEmitted(err, streamEmitState);
+        throw _stampCompatOutcome(markUnsafeRetryIfToolEmitted(err, streamEmitState));
     }
     const message = {
         content: content || null,
@@ -496,7 +531,7 @@ export async function consumeCompatChatCompletionStream(stream, {
             try { err.message += ` finish_reason=${stopReason}`; } catch {}
         }
         if (emittedText) markErrorLiveTextEmitted(err);
-        throw markUnsafeRetryIfToolEmitted(err, streamEmitState);
+        throw _stampCompatOutcome(markUnsafeRetryIfToolEmitted(err, streamEmitState));
     }
     if (Array.isArray(toolCalls) && toolCalls.length) {
         for (const call of toolCalls) emitCompatToolCallOnce(streamEmitState, call, onToolCall);
@@ -572,6 +607,11 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
         case 'response.reasoning_text.delta':
         case 'response.reasoning_summary_text.delta':
             if (event.delta) {
+                // Reasoning exposure latch (mirrors the Chat path): set at
+                // DELTA time, not at completion. Exposed reasoning cannot be
+                // withdrawn, so any later failure is non-replayable — a retry
+                // or non-streaming reset would duplicate it.
+                state.emittedReasoning = true;
                 try { onStreamDelta?.('reasoning'); } catch {}
             }
             break;
@@ -737,7 +777,7 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
             else if (event.response.status === 'failed') {
                 const msg = event.response?.error?.message || 'response.done failed';
                 const err = new Error(`xAI Responses stream response.done failed: ${msg}`);
-                populateHttpStatusFromMessage(err, msg);
+                _applyTypedResponsesFailure(err, event);
                 throw err;
             } else if (event.response.status === 'incomplete') {
                 const reason = incompleteReasonFromResponsesEvent(event);
@@ -764,11 +804,10 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
         case 'response.failed': {
             const msg = event.response?.error?.message || event.error?.message || event.message || 'response.failed';
             const err = new Error(`xAI Responses stream response.failed: ${msg}`);
-            populateHttpStatusFromMessage(err, msg);
-            // xAI's reference sampler treats protocol-level failed/error
-            // events as synthetic HTTP 500s. Gate by the xAI stream label so
-            // shared compat consumers retain their existing classification.
-            if (String(label || '').toLowerCase().startsWith('xai')) err.httpStatus = 500;
+            // The wire event's OWN typed status/code is preserved verbatim. A
+            // forbidden/unknown failure is never coerced into a synthetic 500:
+            // without typed evidence it stays unclassified and is surfaced.
+            _applyTypedResponsesFailure(err, event);
             throw err;
         }
         case 'response.incomplete': {
@@ -791,8 +830,7 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
         case 'error': {
             const msg = event.message || event.error?.message || 'unknown';
             const err = new Error(`xAI Responses stream error: ${msg}`);
-            populateHttpStatusFromMessage(err, msg);
-            if (String(label || '').toLowerCase().startsWith('xai')) err.httpStatus = 500;
+            _applyTypedResponsesFailure(err, event);
             throw err;
         }
         default:
@@ -800,6 +838,20 @@ function handleCompatResponsesStreamEvent(event, state, { label, parseResponsesT
     }
 }
 
+// Copy the TYPED failure evidence a Responses `response.failed` / `error`
+// event carries (numeric HTTP status, provider error code/type) onto the
+// thrown error. Message text is never parsed, and nothing is synthesized when
+// the event declares no typed status.
+function _applyTypedResponsesFailure(err, event) {
+    const detail = event?.response?.error || event?.error || null;
+    const typed = typedStatusFrom(detail, event);
+    if (typed) err.httpStatus = typed;
+    const code = detail?.code ?? detail?.type ?? event?.code ?? null;
+    if (code != null && code !== '') err.providerErrorCode = String(code);
+    if (detail) err.providerError = detail;
+    return err;
+}
+
 export async function consumeCompatResponsesStream(stream, {
     signal,
     label,
@@ -847,6 +899,10 @@ export async function consumeCompatResponsesStream(stream, {
         // has been forwarded. A later failure is non-retryable (rendered text
         // cannot be withdrawn; a retry would concatenate attempts).
         emittedText: false,
+        // Reasoning-exposure invariant, latched by
+        // handleCompatResponsesStreamEvent on the first non-empty reasoning
+        // delta (see the Chat path's emittedReasoning).
+        emittedReasoning: false,
         semanticIdleDeadlineAt: 0,
     };
     const reportProgress = (kind) => {
@@ -894,6 +950,34 @@ export async function consumeCompatResponsesStream(stream, {
         for (const c of calls) dispatchLeakedCall(c);
     };
     const deps = { label, parseResponsesToolCalls, responseOutputText, onStreamDelta: reportProgress, onToolCall, onTextDelta, relayLeakText };
+    // Canonical stream-outcome stamp for EVERY reject path of the Responses
+    // consumer — identical contract to the Chat consumer. Without it a failure
+    // is "unknown" to the replay gates and an upstream retry / transport
+    // fallback / non-streaming reset could duplicate exposed output.
+    const _toolInFlight = () => (state.pendingCalls?.size > 0)
+        || (state.toolTracker?.items?.size > 0)
+        || state.toolInFlight === true;
+    const _stampResponsesOutcome = (err, extra = {}) => {
+        try {
+            stampStreamOutcome(err, {
+                transport: STREAM_TRANSPORTS.SSE,
+                provider: 'openai-compat-responses',
+                terminalObserved: state.completed === true,
+                continuation: state.completed !== true,
+                textEmitted: state.emittedText === true,
+                textObservedChars: (state.content || '').length,
+                reasoningEmitted: state.emittedReasoning === true,
+                toolCallsStarted: state.toolCalls.length > 0 || leakedCalls.length > 0 || _toolInFlight(),
+                toolCallsComplete: state.toolCalls.length + leakedCalls.length,
+                toolCallsDispatched: state.emittedToolCall === true
+                    ? Math.max(1, state.emittedToolCallKeys?.size || 0)
+                    : 0,
+                pendingToolInput: _toolInFlight(),
+                ...extra,
+            });
+        } catch { /* stamping is best-effort */ }
+        return err;
+    };
     try {
         while (true) {
             const { value: event, done } = await nextAsyncWithWatchdog(iterator, {
@@ -930,13 +1014,14 @@ export async function consumeCompatResponsesStream(stream, {
                 err.partialModel = state.model || undefined;
             } catch { /* best-effort */ }
         }
-        throw markUnsafeRetryIfToolEmitted(err, state);
+        throw _stampResponsesOutcome(markUnsafeRetryIfToolEmitted(err, state));
     } finally {
         firstByteTimeout.cleanup();
     }
     if (!sawFirstEvent) {
-        if (firstByteTimeout.signal?.aborted) throw firstByteCompatStreamError(label);
-        throw firstByteCompatStreamError(label);
+        // Pre-output: nothing was sampled, so this stays replay-safe.
+        if (firstByteTimeout.signal?.aborted) throw _stampResponsesOutcome(firstByteCompatStreamError(label));
+        throw _stampResponsesOutcome(firstByteCompatStreamError(label));
     }
     if (!state.completed) {
         const err = truncatedCompatStreamError(label, 'no response.completed');
@@ -957,11 +1042,13 @@ export async function consumeCompatResponsesStream(stream, {
                 err.partialModel = state.model || undefined;
             } catch { /* best-effort */ }
         }
-        throw err;
+        throw _stampResponsesOutcome(err);
     }
     const unresolved = state.toolCalls.find(t => t._pendingItemId);
     if (unresolved) {
-        throw new Error(`xAI Responses stream function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`);
+        throw _stampResponsesOutcome(new Error(
+            `xAI Responses stream function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`,
+        ));
     }
     const response = state.completedResponse || {
         id: state.responseId || null,

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

@@ -286,9 +286,10 @@ export class OpenAICompatProvider {
             const structuredStatus = [err?.status, err?.httpStatus, err?.response?.status]
                 .map(value => Number(value))
                 .find(value => Number.isFinite(value) && value > 0) || 0;
-            const status = structuredStatus > 0
-                ? structuredStatus
-                : (/\b401\b/.test(String(err?.message || '')) ? 401 : 0);
+            // Credential reload + reissue requires a TYPED 401. A message that
+            // merely mentions "401" is not evidence, and a typed 403 is a
+            // permission decision — reloading the key cannot change it.
+            const status = structuredStatus;
             if (status === 401) {
                 if (err.liveTextEmitted === true || err.emittedToolCall === true || err.unsafeToRetry === true) {
                     throw err;

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

@@ -22,11 +22,13 @@ import {
     createPassthroughSignal,
 } from '../stall-policy.mjs';
 import {
+    classifyError,
     jitterDelayMs,
-    populateHttpStatusFromMessage,
     shouldFallbackTransport,
     sleepWithAbort,
+    typedStatusFrom,
 } from './retry-classifier.mjs';
+import { stampStreamOutcome, readStreamOutcome, STREAM_TRANSPORTS } from './lib/stream-outcome.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
 import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';
@@ -111,6 +113,19 @@ function _isMaxOutputIncompleteReason(reason) {
     return /^(?:max_output_tokens|max_tokens|length|output_token_limit)$/i.test(String(reason || '').trim());
 }
 
+// Wire-level `end_turn` on a terminal Responses frame (codex-rs
+// codex-api/src/sse/responses.rs ResponseCompleted.end_turn: Option<bool>).
+// Optional by contract: only a real boolean normalizes; a missing/non-boolean
+// field stays undefined so absence is never collapsed into false.
+export function _endTurnFromEvent(event) {
+    if (!event || typeof event !== 'object') return undefined;
+    const fromResponse = event.response?.end_turn;
+    if (typeof fromResponse === 'boolean') return fromResponse;
+    const topLevel = event.end_turn;
+    if (typeof topLevel === 'boolean') return topLevel;
+    return undefined;
+}
+
 function _pushOutputTextAnnotations(part, citations, citationKeys) {
     const annotations = Array.isArray(part?.annotations) ? part.annotations : [];
     for (const raw of annotations) {
@@ -166,6 +181,9 @@ function _buildOpenAIHttpFallbackHeaders({ auth, cacheKey }) {
 // transport fallback, even if a caller has marked a prior WS attempt exhausted.
 export function _shouldUseOpenAIHttpFallback(err, externalSignal) {
     if (Number(err?.httpStatus || 0) === 429) return false;
+    // Codex switches WS→HTTPS on a typed transport failure; the only extra
+    // deny is exposure (relayed text / dispatched tool), which the shared
+    // predicate reads off the canonical record stamped by the WS transport.
     return shouldFallbackTransport(err, {
         signal: externalSignal,
         enabled: _envFlag('MIXDOG_OPENAI_OAUTH_HTTP_FALLBACK', true),
@@ -250,10 +268,26 @@ export async function sendViaHttpSse({
         }
 
         const retryableStatus = response && response.status >= 500 && response.status <= 599;
+        // Typed transient transport failures only (errno / SDK connection
+        // type). An unknown pre-response failure throws immediately instead of
+        // re-issuing the POST.
         const retryableTransport = !response && requestError
+            && classifyError(requestError) === 'transient'
             && !externalSignal?.aborted
             && !totalTimeout.signal?.aborted;
         if (attempt < CODEX_REQUEST_MAX_RETRIES && (retryableStatus || retryableTransport)) {
+            // Reissuing the POST is a REPLAY: allowed for a typed transient
+            // failure of the initial request, denied once the failure carries
+            // exposure evidence (relayed output / dispatched tool call).
+            const attemptFailure = requestError || Object.assign(
+                new Error(`OpenAI OAuth HTTP fallback ${response.status}`),
+                { httpStatus: response.status, headers: response.headers, initialResponseError: true },
+            );
+            if (readStreamOutcome(attemptFailure).replaySafe !== true) {
+                if (response) await response.arrayBuffer().catch(() => {});
+                totalTimeout.cleanup();
+                throw attemptFailure;
+            }
             // A non-success response has not exposed any streamed output. Drain
             // its body before reissuing so the dispatcher can reuse the socket.
             if (response) await response.arrayBuffer().catch(() => {});
@@ -269,6 +303,8 @@ export async function sendViaHttpSse({
         }
         if (requestError) {
             totalTimeout.cleanup();
+            // The initial response never arrived: nothing was sampled, so the
+            // typed rules upstream decide whether to retry.
             throw requestError;
         }
         break;
@@ -288,13 +324,13 @@ export async function sendViaHttpSse({
         const err = new Error(`OpenAI OAuth HTTP fallback ${response.status}: ${text.slice(0, 200)}`);
         err.httpStatus = response.status;
         err.headers = response.headers;
-        populateHttpStatusFromMessage(err, text);
+        err.initialResponseError = true;
         totalTimeout.cleanup();
         throw err;
     }
     if (!response.body) {
         totalTimeout.cleanup();
-        throw new Error('OpenAI OAuth HTTP fallback returned no response body');
+        throw Object.assign(new Error('OpenAI OAuth HTTP fallback returned no response body'), { initialResponseError: true });
     }
 
     try { onStreamDelta?.('transport'); } catch {}
@@ -423,12 +459,21 @@ export async function sendViaHttpSse({
     const webSearchCallKeys = new Set();
     let completed = false;
     let stopReason = null;
+    // Normalized wire `end_turn` from the terminal frame; undefined unless the
+    // server actually supplied a boolean.
+    let endTurn;
     // Gateway live-text relay invariant: set once a non-empty text chunk has
     // been forwarded to the client. A failure afterwards is non-retryable —
     // the rendered text cannot be withdrawn and a re-request would concatenate
     // a second attempt.
     let emittedText = false;
 
+    // Reasoning-exposure invariant: set the moment a reasoning/summary delta is
+    // seen (NOT at completion, where reasoningItems is assembled). Exposed
+    // reasoning is a replay boundary for retry, transport fallback and the
+    // reactive compact retry.
+    let emittedReasoning = false;
+
     // Tool-emit invariant (mirrors emittedText, WS path's emittedToolCall): set
     // once onToolCall has actually dispatched a call. A failure afterwards is
     // non-retryable — the side-effecting tool already ran, and any upstream
@@ -439,6 +484,32 @@ export async function sendViaHttpSse({
         if (emittedToolCall && err) { try { err.emittedToolCall = true; err.unsafeToRetry = true; } catch {} }
         return err;
     };
+    // Canonical stream-outcome contract for the HTTP/SSE transport. ONE hint
+    // builder is shared by the mid-stream catch and by every post-loop reject
+    // so no reject path can escape unstamped (an unstamped outcome is
+    // "unknown", which the consumers treat as fail-closed).
+    const _outcomeHints = (extra = {}) => ({
+        transport: STREAM_TRANSPORTS.HTTP_SSE,
+        provider: 'openai-responses',
+        terminalObserved: completed === true,
+        continuation: completed !== true,
+        textEmitted: emittedText === true,
+        textObservedChars: content.length,
+        reasoningEmitted: emittedReasoning === true || reasoningItems.length > 0,
+        toolCallsStarted: pendingCalls.size > 0 || activeToolItems.size > 0
+            || _toolInFlight === true || toolCalls.length > 0,
+        toolCallsComplete: toolCalls.length,
+        toolCallsDispatched: emittedToolCallIds.size,
+        pendingToolInput: pendingCalls.size > 0 || activeToolItems.size > 0 || _toolInFlight === true,
+        // Protocol distinction: a terminal frame carrying end_turn=false keeps
+        // the SAME user turn open — terminal observed, still a continuation.
+        ...(endTurn === false ? { continuationDeclared: true } : {}),
+        ...extra,
+    });
+    const _stampOutcome = (err, extra = {}) => {
+        try { stampStreamOutcome(err, _outcomeHints(extra)); } catch { /* best-effort */ }
+        return err;
+    };
 
     // Single-emit guard for tool calls (matches the WS path's
     // emittedToolCall intent). The HTTP/SSE event stream can surface the
@@ -593,7 +664,13 @@ export async function sendViaHttpSse({
                 break;
             case 'response.reasoning_text.delta':
             case 'response.reasoning_summary_text.delta':
-                if (event.delta) meaningful('reasoning');
+                if (event.delta) {
+                    // Reasoning exposure is a replay boundary the MOMENT a delta
+                    // arrives — not at response completion. A failure after this
+                    // point must never be re-issued (duplicate exposed thinking).
+                    emittedReasoning = true;
+                    meaningful('reasoning');
+                }
                 break;
             case 'response.output_item.added':
                 if (event.item?.type === 'function_call') {
@@ -786,14 +863,24 @@ export async function sendViaHttpSse({
                 }
                 if (!reportedBundleProgress) meaningful('semantic');
                 completed = true;
+                {
+                    const wireEndTurn = _endTurnFromEvent(event);
+                    if (typeof wireEndTurn === 'boolean') endTurn = wireEndTurn;
+                }
                 break;
             }
             case 'response.done':
-                if (!event.response || event.response.status === 'completed') completed = true;
-                else if (event.response.status === 'failed') {
+                if (!event.response || event.response.status === 'completed') {
+                    completed = true;
+                    // Terminal success frame for streams that never emit a
+                    // separate response.completed — same optional end_turn.
+                    const wireEndTurn = _endTurnFromEvent(event);
+                    if (typeof wireEndTurn === 'boolean') endTurn = wireEndTurn;
+                } else if (event.response.status === 'failed') {
                     const msg = event.response?.error?.message || 'response.done failed';
                     const err = new Error(`OpenAI OAuth HTTP fallback response.done failed: ${msg}`);
-                    populateHttpStatusFromMessage(err, msg);
+                    const typed = typedStatusFrom(event.response?.error, event.error, event);
+                    if (typed) err.httpStatus = typed;
                     throw err;
                 } else if (event.response.status === 'incomplete') {
                     const reason = _incompleteReasonFromEvent(event);
@@ -822,7 +909,9 @@ export async function sendViaHttpSse({
             case 'response.failed': {
                 const msg = event.response?.error?.message || event.error?.message || event.message || 'response.failed';
                 const err = new Error(`OpenAI OAuth HTTP fallback response.failed: ${msg}`);
-                populateHttpStatusFromMessage(err, msg);
+                // Typed status only — a text-only failure stays unclassified.
+                const typed = typedStatusFrom(event.response?.error, event.error, event);
+                if (typed) err.httpStatus = typed;
                 throw err;
             }
             case 'response.incomplete': {
@@ -848,7 +937,8 @@ export async function sendViaHttpSse({
             case 'error': {
                 const msg = event.message || event.error?.message || 'unknown';
                 const err = new Error(`OpenAI OAuth HTTP fallback error: ${msg}`);
-                populateHttpStatusFromMessage(err, msg);
+                const typed = typedStatusFrom(event.error, event);
+                if (typed) err.httpStatus = typed;
                 throw err;
             }
             default:
@@ -903,6 +993,8 @@ export async function sendViaHttpSse({
         // Tool-emit invariant: an error after a dispatched tool call must not
         // reissue the turn (double-execution). Stamp emittedToolCall too.
         _stampToolSafety(err);
+        // Canonical record (same shape as the WS path); aliases above preserved.
+        _stampOutcome(err);
         throw err;
     } finally {
         _pendingReadReject = null;
@@ -917,10 +1009,28 @@ export async function sendViaHttpSse({
 
     const unresolved = toolCalls.find(t => t._pendingItemId);
     if (unresolved) {
-        throw _stampToolSafety(new Error(`OpenAI OAuth HTTP fallback function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`));
+        throw _stampOutcome(_stampToolSafety(new Error(
+            `OpenAI OAuth HTTP fallback function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`,
+        )));
     }
-    if (!completed && !content && !toolCalls.length) {
-        throw _stampToolSafety(new Error('OpenAI OAuth HTTP fallback ended before response.completed'));
+    // EOF without a terminal frame is ALWAYS a failure, regardless of how much
+    // partial text or how many tool calls were streamed. The turn has no
+    // terminal signal, so it is a continuation: returning it would report an
+    // unfinished sample as a completed assistant turn (and, with tool calls
+    // already dispatched, a half-finished side-effecting turn). The partial
+    // rides on the error for interrupted-turn persistence.
+    if (!completed) {
+        const err = _stampToolSafety(new Error(
+            `OpenAI OAuth HTTP fallback ended before response.completed `
+            + `(text=${content.length} chars, toolCalls=${toolCalls.length})`,
+        ));
+        try {
+            err.partialContent = content;
+            err.partialToolCalls = toolCalls.length ? toolCalls.slice() : undefined;
+            err.partialModel = model || undefined;
+            err.pendingToolUse = pendingCalls.size > 0 || activeToolItems.size > 0 || _toolInFlight === true;
+        } catch { /* best-effort enrichment */ }
+        throw _stampOutcome(err, { terminalObserved: false, continuation: true });
     }
 
     const liveModel = model || useModel;
@@ -963,6 +1073,8 @@ export async function sendViaHttpSse({
         webSearchCalls: webSearchCalls.length ? webSearchCalls : undefined,
         usage: usage || undefined,
         stopReason: stopReason || undefined,
+        // Only present when the terminal frame carried the wire field.
+        ...(typeof endTurn === 'boolean' ? { endTurn } : {}),
         // P1 audit fix: text-only max-output cutoff (openai-oauth HTTP/SSE
         // fallback maps status:'incomplete'/reason=max_output_tokens to
         // stopReason='length' above and treats it as success). Flag it so

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

@@ -40,6 +40,7 @@ import {
     MIDSTREAM_RETRY_POLICY,
     sleepWithAbort,
 } from './retry-classifier.mjs';
+import { stampStreamOutcome, STREAM_TRANSPORTS } from './lib/stream-outcome.mjs';
 import {
     WS_IDLE_MS,
     acquireWebSocket,
@@ -977,15 +978,31 @@ export async function sendViaWebSocket({
             // 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.
+            // Exposed reasoning is a visibility boundary. A tool call that only
+            // STARTED assembling was never dispatched, so it is recorded but is
+            // NOT a side effect and must not veto a retry.
             if (midState.emittedReasoning || midState.startedToolCall) {
                 try {
-                    err.unsafeToRetry = true;
-                    if (midState.emittedReasoning) err.partialReasoningEmitted = true;
+                    if (midState.emittedReasoning) {
+                        err.unsafeToRetry = true;
+                        err.partialReasoningEmitted = true;
+                    }
                     if (midState.startedToolCall) err.partialToolCallStarted = true;
                 } catch {}
             }
             _stampLiveText(err);
             _stampTool(err);
+            // Canonical stream-outcome record for the WS transport, merged
+            // with the cross-attempt safety latches above. _streamResponse
+            // already stamps its own reject paths; this covers frame-send /
+            // handshake-adjacent failures that never reached the stream loop.
+            try {
+                stampStreamOutcome(err, midState, {
+                    transport: STREAM_TRANSPORTS.WS,
+                    provider: 'openai-oauth',
+                    continuation: midState.sawCompleted !== true,
+                });
+            } catch { /* stamping is best-effort */ }
             const classifier = err?.unsafeToRetry === true
                 ? null
                 : _classifyMidstreamError(err, midState);

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

@@ -39,7 +39,7 @@ import {
     createTimeoutSignal,
     createPassthroughSignal,
 } from '../stall-policy.mjs';
-import { populateHttpStatusFromMessage, shouldFallbackTransport } from './retry-classifier.mjs';
+import { shouldFallbackTransport } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
 import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';

package/src/runtime/agent/orchestrator/providers/openai-responses-payload.mjs

@@ -40,7 +40,7 @@ import {
     createTimeoutSignal,
     createPassthroughSignal,
 } from '../stall-policy.mjs';
-import { populateHttpStatusFromMessage, shouldFallbackTransport } from './retry-classifier.mjs';
+import { shouldFallbackTransport } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { makeInvalidToolArgsMarker } from './openai-compat-stream.mjs';
 import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './anthropic-leaked-toolcall.mjs';