mixdog 0.9.87 → 0.9.89

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

@@ -80,13 +80,15 @@ function normalizeGeminiSdkStreamError(err, label) {
 }
 
 // CC-rule safety stamp for Gemini stream failures (provider-stall audit):
-// once text has been relayed to the live gateway or a leaked tool call was
-// dispatched, replaying the request would double-render/double-execute — the
+// once text has actually been RELAYED to the live gateway or a leaked tool
+// call was dispatched, replaying would double-render/double-execute — the
 // outer withRetry() in gemini.mjs wraps the WHOLE stream, and a bare
 // EGEMINITIMEOUT classifies transient, so without these markers a mid-stream
-// stall after visible output was silently retried. Visible-text stalls also
-// gain streamStalled + partialContent so the loop's partial-final path can
-// keep the streamed output instead of dropping the turn.
+// stall after visible output was silently retried. Text that was only
+// BUFFERED (no onTextDelta sink, or still held inside the leak guard) was
+// never shown, so it is not a replay boundary. Relayed-text stalls also gain
+// streamStalled + partialContent so the loop's partial-final path can keep
+// the streamed output instead of dropping the turn.
 function stampGeminiStreamFailure(err, {
     relayedText = '',
     textLeakGuard = null,
@@ -95,7 +97,7 @@ function stampGeminiStreamFailure(err, {
 } = {}) {
     if (!err || typeof err !== 'object') return err;
     const leaked = (textLeakGuard?.getLeakedToolCalls?.() || []).length > 0;
-    const finalizedText = textLeakGuard?.getVisibleText?.();
+    const finalizedText = textLeakGuard?.getRelayedText?.();
     const visibleText = typeof finalizedText === 'string' ? finalizedText : relayedText;
     const visible = visibleText.length > 0;
     // Native functionCall chunks are only dispatched after successful stream
@@ -205,10 +207,13 @@ export function geminiChunkText(chunk) {
     return text;
 }
 
+// Returns the text actually RELAYED to the live sink (''  when it was only
+// buffered), so callers can track visible output rather than raw stream text.
 function relayGeminiStreamText(t, { onTextDelta, textLeakGuard }) {
-    if (!t) return;
-    if (textLeakGuard) textLeakGuard.feedText(t);
-    else if (onTextDelta) { try { onTextDelta(t); } catch {} }
+    if (!t) return '';
+    if (textLeakGuard) { textLeakGuard.feedText(t); return ''; }
+    if (onTextDelta) { try { onTextDelta(t); } catch {} return t; }
+    return '';
 }
 
 /**
@@ -223,7 +228,7 @@ export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolC
     const _enabled = _knownTools.size > 0;
     const _isKnownTool = (name) => _knownTools.has(name);
     let leakBuffer = '';
-    let visibleText = '';
+    let relayedText = '';
     const leakedCalls = [];
     const dispatchedFingerprints = new Set();
 
@@ -259,11 +264,12 @@ export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolC
         if (!leakBuffer && !final) return;
         const { emit, calls, rest } = scanLeakedToolCalls(leakBuffer, { isKnownTool: _isKnownTool, final });
         leakBuffer = rest;
+        // Only text handed to the live sink counts as relayed/visible. Without
+        // an onTextDelta sink the scrubbed text is buffered for the final
+        // result and never shown, so it must not deny a replay.
         if (emit && onTextDelta) {
-            visibleText += emit;
+            relayedText += emit;
             try { onTextDelta(emit); } catch {}
-        } else if (emit) {
-            visibleText += emit;
         }
         for (const c of calls) dispatchLeakedCall(c);
     };
@@ -273,8 +279,10 @@ export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolC
         feedText(text) {
             if (!text) return;
             if (!_enabled) {
-                visibleText += text;
-                try { onTextDelta?.(text); } catch {}
+                if (onTextDelta) {
+                    relayedText += text;
+                    try { onTextDelta(text); } catch {}
+                }
                 return;
             }
             leakBuffer += text;
@@ -304,8 +312,8 @@ export function createGeminiTextLeakGuard({ knownToolNames, onTextDelta, onToolC
         getLeakedToolCalls() {
             return leakedCalls.length ? [...leakedCalls] : [];
         },
-        getVisibleText() {
-            return visibleText;
+        getRelayedText() {
+            return relayedText;
         },
     };
 }
@@ -422,8 +430,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
                 if (!sawFunctionCall && geminiChunkHasFunctionCall(parsed)) sawFunctionCall = true;
                 if (onTextDelta || textLeakGuard) {
                     const t = geminiChunkText(parsed);
-                    if (t) relayedText += t;
-                    relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
+                    relayedText += relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
                 }
             }
         }
@@ -443,8 +450,7 @@ export async function consumeGeminiRestStreamResponse(response, { signal, onStre
                         if (!sawFunctionCall && geminiChunkHasFunctionCall(parsed)) sawFunctionCall = true;
                         if (onTextDelta || textLeakGuard) {
                             const t = geminiChunkText(parsed);
-                            if (t) relayedText += t;
-                            relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
+                            relayedText += relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
                         }
                     } catch (cause) {
                         throw geminiStreamCorruptionError(`${label} corrupt SSE tail JSON`, cause);
@@ -675,8 +681,7 @@ export async function consumeGeminiSdkStream(streamResult, {
             if (!sawFunctionCall && geminiChunkHasFunctionCall(step.value)) sawFunctionCall = true;
             if (onTextDelta || textLeakGuard) {
                 const t = geminiChunkText(step.value);
-                if (t) relayedText += t;
-                relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
+                relayedText += relayGeminiStreamText(t, { onTextDelta, textLeakGuard });
             }
         }
         if (idleTimedOut) {

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

@@ -75,6 +75,11 @@ function geminiRestError(res, text, label) {
     err.status = res.status;
     err.httpStatus = res.status;
     err.headers = res.headers;
+    // Initial-response failure: the request was rejected before any sample was
+    // produced, so withRetry's typed rules decide: a known transient status
+    // retries with bounded backoff (Retry-After honored), anything unknown or
+    // deterministic surfaces as an error.
+    err.initialResponseError = true;
     if (detail) {
         err.error = detail;
         err.data = payload;
@@ -486,8 +491,11 @@ export class GeminiProvider {
         try {
             return await this._doSend(messages, model, tools, sendOpts);
         } catch (err) {
-            if (err?.status === 401 || err?.status === 403
-                || (err?.message && (err.message.includes('401') || err.message.includes('403')))) {
+            // Credential reload + reissue requires a TYPED 401: message text is
+            // not evidence, and a typed 403 (permission/quota decision) is not
+            // fixed by re-reading the key, so it surfaces unchanged.
+            const status = Number(err?.status || err?.httpStatus || err?.response?.status || 0);
+            if (status === 401) {
                 if (err.liveTextEmitted === true || err.emittedToolCall === true || err.unsafeToRetry === true) {
                     throw err;
                 }

package/src/runtime/agent/orchestrator/providers/grok-oauth-login.mjs

@@ -26,7 +26,6 @@ import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import { OpenAICompatProvider } from './openai-compat.mjs';
 import { createTimeoutSignal } from '../stall-policy.mjs';
-import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { normalizeGrokToolSchemas } from './lib/grok-tool-schema.mjs';
 

package/src/runtime/agent/orchestrator/providers/grok-oauth-tokens.mjs

@@ -26,7 +26,6 @@ import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import { OpenAICompatProvider } from './openai-compat.mjs';
 import { createTimeoutSignal } from '../stall-policy.mjs';
-import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { normalizeGrokToolSchemas } from './lib/grok-tool-schema.mjs';
 

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

@@ -25,7 +25,6 @@ import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { makeModelCache } from './model-cache.mjs';
 import { OpenAICompatProvider } from './openai-compat.mjs';
 import { createTimeoutSignal } from '../stall-policy.mjs';
-import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { normalizeGrokToolSchemas } from './lib/grok-tool-schema.mjs';
 
@@ -311,10 +310,8 @@ export class GrokOAuthProvider {
             return await inner._doSend(messages, useModel, grokTools, sendOpts);
         } catch (err) {
             // Refresh-and-retry on a server-rejected OAuth session (401/403).
-            // Resolve the status from the structured field (falling back to the
-            // shared classifier that derives it from the error text) rather than
-            // ad-hoc string matching.
-            populateHttpStatusFromMessage(err);
+            // TYPED status only: a rejection whose only evidence is message
+            // text is never treated as an auth failure worth re-issuing.
             const rejectedStatus = Number(err?.httpStatus || err?.status);
             if (rejectedStatus === 401 || rejectedStatus === 403) {
                 // A stream-level rejection after text/tool dispatch cannot be safely

package/src/runtime/agent/orchestrator/providers/lib/anthropic-native-blocks.mjs

@@ -0,0 +1,27 @@
+/**
+ * anthropic-native-blocks.mjs — single source of truth for Anthropic NATIVE
+ * (server-side) tool block types.
+ *
+ * Anthropic executes these itself and returns BOTH the CALL block
+ * (`server_tool_use` / `mcp_tool_use`) and its RESULT block
+ * (`web_search_tool_result`, …). They are never dispatched to the agent loop,
+ * so they only survive a continuation turn (`stop_reason:'pause_turn'`) when
+ * the provider boundary preserves them verbatim, in original block order — a
+ * result block is valid ONLY immediately after the call block that produced
+ * it. Shared by the SSE parser (streaming) and the non-streaming normalizer.
+ */
+export const NATIVE_SERVER_TOOL_CALL_BLOCK_TYPES = new Set(['server_tool_use', 'mcp_tool_use']);
+
+export const NATIVE_SERVER_TOOL_RESULT_BLOCK_TYPES = new Set([
+    'web_search_tool_result',
+    'web_fetch_tool_result',
+    'code_execution_tool_result',
+    'bash_code_execution_tool_result',
+    'text_editor_code_execution_tool_result',
+    'mcp_tool_result',
+]);
+
+export function isNativeServerToolBlockType(type) {
+    return NATIVE_SERVER_TOOL_CALL_BLOCK_TYPES.has(type)
+        || NATIVE_SERVER_TOOL_RESULT_BLOCK_TYPES.has(type);
+}

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

@@ -1,4 +1,5 @@
 import { providerNativeToolPrefixCount } from '../../../../../session-runtime/provider-request-tools.mjs';
+import { isNativeServerToolBlockType } from './anthropic-native-blocks.mjs';
 
 export const ANTHROPIC_CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };
 export const ANTHROPIC_CACHE_TTL_VOLATILE = { type: 'ephemeral' };
@@ -55,6 +56,11 @@ export function clampAnthropicThinkingBudget(value, maxTokens) {
     return Math.max(1024, Math.min(desired, ceiling));
 }
 
+// Assistant blocks that are replayable verbatim alongside native server-tool
+// blocks. `text` is handled separately (empty text blocks are dropped, exactly
+// like parseSSEStream's assistantBlocks list).
+const REPLAYABLE_ASSISTANT_BLOCK_TYPES = new Set(['thinking', 'redacted_thinking', 'tool_use']);
+
 export function normalizeAnthropicNonStreamingResponse(message, fallbackModel = '') {
     const blocks = Array.isArray(message?.content) ? message.content : [];
     const text = blocks
@@ -71,6 +77,22 @@ export function normalizeAnthropicNonStreamingResponse(message, fallbackModel =
     const thinkingBlocks = blocks.filter((block) => (
         block?.type === 'thinking' || block?.type === 'redacted_thinking'
     ));
+    // Anthropic NATIVE server-tool turns (web search / web fetch / code
+    // execution / native MCP) cannot be rebuilt from the flattened
+    // text/toolCalls/thinking projections above: `server_tool_use` and its
+    // `*_tool_result` are opaque and order-bound (a result block is valid ONLY
+    // right after its call block). Keep the ordered raw list so the loop can
+    // replay the paused turn verbatim on the `pause_turn` continuation —
+    // mirror of parseSSEStream's assistantBlocks, including its
+    // absent-for-ordinary-turns rule, so plain text/thinking/tool_use
+    // responses keep the existing lowering and never double-replay.
+    const nativeAssistantBlocks = blocks.some((block) => isNativeServerToolBlockType(block?.type))
+        ? blocks.filter((block) => block && typeof block === 'object' && (
+            isNativeServerToolBlockType(block.type)
+            || REPLAYABLE_ASSISTANT_BLOCK_TYPES.has(block.type)
+            || (block.type === 'text' && typeof block.text === 'string' && block.text.length > 0)
+        ))
+        : [];
     const usage = message?.usage || {};
     const input = Number(usage.input_tokens) || 0;
     const cacheRead = Number(usage.cache_read_input_tokens) || 0;
@@ -83,6 +105,7 @@ export function normalizeAnthropicNonStreamingResponse(message, fallbackModel =
         hasThinkingContent: thinkingBlocks.length > 0,
         contentBlockTypes: blocks.map((block) => block?.type).filter(Boolean),
         thinkingBlocks: thinkingBlocks.length ? thinkingBlocks : undefined,
+        assistantBlocks: nativeAssistantBlocks.length ? nativeAssistantBlocks : undefined,
         usage: {
             inputTokens: input,
             outputTokens: Number(usage.output_tokens) || 0,

package/src/runtime/agent/orchestrator/providers/lib/stream-outcome.mjs

@@ -0,0 +1,329 @@
+/**
+ * stream-outcome.mjs — canonical provider stream outcome / safety contract.
+ *
+ * ONE record describes how a provider stream ended, across every transport:
+ * OpenAI Responses WS, OpenAI Responses HTTP/SSE, Anthropic API-key SSE,
+ * Anthropic OAuth SSE and its non-streaming fallback, and any adapter that
+ * only attaches partial state to a thrown error.
+ *
+ * Historically each consumer (retry classifier, transport fallback,
+ * send-with-recovery, ask-session persistence) re-derived safety from a
+ * DIFFERENT subset of scattered per-provider flags (liveTextEmitted,
+ * emittedText, emittedToolCall, toolCallEmitted, partialToolCall,
+ * emittedThinking, emittedReasoning, startedToolCall, partialToolCalls,
+ * pendingToolUse, unsafeToRetry, sawCompleted, ...). A provider that set only
+ * SOME of them (Anthropic's stall error carries partialContent but neither
+ * liveTextEmitted nor unsafeToRetry) silently fell through the gaps: streamed
+ * text was dropped from history, or an ambiguous end-of-stream was treated as
+ * a clean success / a replayable request.
+ *
+ * ── Schema (canonical record, frozen) ───────────────────────────────────────
+ *   version              1
+ *   provider             string|null   informational
+ *   transport            'ws'|'http-sse'|'sse'|'non-streaming'|'unknown'
+ *   terminalObserved     bool  provider signalled end-of-turn (response.completed
+ *                              / response.done / message_stop / explicit finish
+ *                              reason / early-settle on a complete tool call)
+ *   continuation         bool  stream ended WITHOUT a terminal signal (stall,
+ *                              truncation, abnormal close, EOF mid-message)
+ *   textEmitted          bool  non-empty text RELAYED to the client (visible)
+ *   textObservedChars    int   assistant text accumulated by the adapter,
+ *                              whether or not it was relayed
+ *   reasoningEmitted     bool  thinking/reasoning deltas or blocks exposed
+ *   toolCallsStarted     bool  tool input began streaming (args may be partial)
+ *   toolCallsComplete    int   fully parsed tool calls
+ *   toolCallsDispatched  int   tool calls handed to onToolCall (side effect may
+ *                              already have run)
+ *   dispatchAmbiguous    bool  dispatch count was INFERRED, not reported
+ *   pendingToolInput     bool  a tool_use/function_call input never completed
+ *   userAbort            bool  caller cancelled
+ *   stallObserved        bool  watchdog/idle stall produced this outcome
+ *   truncatedStream      bool  message_start-without-message_stop class
+ *
+ * ── Derived invariants ──────────────────────────────────────────────────────
+ *   terminalObserved clears continuation ONLY when the turn was not declared
+ *   a same-user-turn continuation. A terminal sample frame may still say
+ *   `end_turn=false` (Responses) / continuationDeclared: the turn is NOT over,
+ *   so continuation stays true and successEligible stays false.
+ *   visibleOutput      = textEmitted || reasoningEmitted
+ *   observedOutput     = visibleOutput || textObservedChars > 0
+ *                        || toolCallsComplete > 0 || toolCallsDispatched > 0
+ *   sideEffectDispatched = toolCallsDispatched > 0
+ *   replayUnsafe       = the ONE architecture-specific deny MixDog adds on top
+ *                        of the Codex retry rules, because it streams UI text
+ *                        and dispatches tools eagerly:
+ *                        visibleOutput || sideEffectDispatched
+ *                        || dispatchAmbiguous || unsafe marker
+ *   replaySafe         = !replayUnsafe && !userAbort
+ *   successEligible    = terminalObserved && !continuation && !pendingToolInput
+ *
+ * This record does NOT decide retries on its own. Whether a failure is retried
+ * at all is the TYPED question owned by retry-classifier.mjs (known transient
+ * status / errno / close code → bounded backoff + transport fallback; unknown
+ * or untyped → error). `replaySafe` only answers "would re-issuing this turn
+ * duplicate something the user already saw or a side effect that already ran".
+ * Buffered-but-never-relayed text and a tool input that never completed (and
+ * therefore never dispatched) are NOT replay denials; `observedOutput` remains
+ * the signal for partial-failure PERSISTENCE, not for replay permission.
+ * An absent or ambiguous terminal can never be promoted to success
+ * (successEligible=false): an explicit terminal stream event is required.
+ *
+ * Compatibility: stampStreamOutcome() writes the canonical record AND the
+ * historical alias flags (never clearing one that is already true), so every
+ * legacy reader keeps working unchanged.
+ */
+
+export const STREAM_OUTCOME_VERSION = 1
+
+export const STREAM_TRANSPORTS = Object.freeze({
+  WS: 'ws',
+  HTTP_SSE: 'http-sse',
+  SSE: 'sse',
+  NON_STREAMING: 'non-streaming',
+  UNKNOWN: 'unknown',
+})
+
+const TRUE = (v) => v === true
+const COUNT = (v) => {
+  const n = Number(v)
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0
+}
+
+function _isAbortLike(source) {
+  const name = String(source?.name || '')
+  return name === 'AbortError' || name === 'APIUserAbortError' || source?.code === 'ABORT_ERR'
+}
+
+/** Raw (pre-derivation) signal read of ONE source object (error or midState). */
+function _signalsOf(source) {
+  if (!source || (typeof source !== 'object' && typeof source !== 'function')) return null
+
+  const partialContent = typeof source.partialContent === 'string' ? source.partialContent : ''
+  const partialToolCalls = Array.isArray(source.partialToolCalls) ? source.partialToolCalls.length : 0
+  const explicitComplete = COUNT(source.toolCallsComplete)
+  const toolCallsComplete = Math.max(partialToolCalls, explicitComplete)
+
+  const textEmitted = TRUE(source.textEmitted) || TRUE(source.liveTextEmitted) || TRUE(source.emittedText)
+  const textObservedChars = Math.max(
+    COUNT(source.textObservedChars),
+    COUNT(source.emittedTextChars),
+    partialContent.trim().length > 0 ? partialContent.length : 0,
+  )
+  const reasoningEmitted = TRUE(source.reasoningEmitted) || TRUE(source.emittedThinking)
+    || TRUE(source.emittedReasoning) || TRUE(source.partialReasoningEmitted)
+  // NOTE: `partialHasThinking` (an extended-thinking block EXISTED, possibly
+  // empty / signature-only) is deliberately NOT read here: a thinking block
+  // the user never saw is not exposed reasoning.
+
+  // `pendingToolUse` alone is NOT "started": a tool_use whose input JSON never
+  // completed was never dispatched, so re-requesting stays idempotent (the
+  // documented truncated-stream retry). Only explicit partial-args markers
+  // count as exposure.
+  const toolCallsStarted = TRUE(source.toolCallsStarted) || TRUE(source.partialToolCall)
+    || TRUE(source.startedToolCall) || TRUE(source.partialToolCallStarted)
+    || toolCallsComplete > 0
+
+  const dispatchReported = Object.prototype.hasOwnProperty.call(source, 'toolCallsDispatched')
+  const dispatchFlag = TRUE(source.emittedToolCall) || TRUE(source.toolCallEmitted)
+  let toolCallsDispatched = dispatchReported ? COUNT(source.toolCallsDispatched) : 0
+  let dispatchAmbiguous = false
+  if (!dispatchReported) {
+    if (dispatchFlag) {
+      toolCallsDispatched = Math.max(1, toolCallsComplete)
+      dispatchAmbiguous = toolCallsComplete === 0
+    } else if (toolCallsComplete > 0) {
+      // Fail closed: every streaming adapter dispatches eagerly at
+      // content_block_stop / function_call_arguments.done, so a complete tool
+      // call with no dispatch report must be assumed to have side effects.
+      toolCallsDispatched = toolCallsComplete
+      dispatchAmbiguous = true
+    }
+  }
+
+  const truncatedStream = TRUE(source.truncatedStream) || source.code === 'TRUNCATED_STREAM'
+  const stallObserved = TRUE(source.streamStalled) || source.code === 'ESTREAMSTALL'
+    || String(source.name || '') === 'StreamStalledError'
+    || String(source.name || '') === 'StreamStalledAbortError'
+    || String(source.name || '') === 'AgentStallAbortError'
+    || String(source.watchdogAbort || '') !== ''
+
+  const terminalObserved = TRUE(source.terminalObserved) || TRUE(source.sawCompleted)
+    || TRUE(source.completed)
+    || (TRUE(source.providerIncomplete) && !!source.finishReason)
+  const streamStarted = TRUE(source.sawMessageStart) || TRUE(source.sawResponseCreated)
+    || textEmitted || reasoningEmitted || textObservedChars > 0 || toolCallsStarted
+  // Protocol distinction: a TERMINAL sample frame can still declare that the
+  // same user turn continues (Responses `end_turn=false`). That is a
+  // continuation, not a finished turn.
+  const declaredContinuation = source.endTurn === false || TRUE(source.continuationDeclared)
+
+  return {
+    provider: source.provider ?? source.providerName ?? null,
+    transport: typeof source.transport === 'string' ? source.transport : null,
+    terminalObserved,
+    continuation: !terminalObserved
+      && (truncatedStream || stallObserved || streamStarted || TRUE(source.continuation)),
+    declaredContinuation,
+    textEmitted,
+    textObservedChars,
+    reasoningEmitted,
+    toolCallsStarted,
+    toolCallsComplete,
+    toolCallsDispatched,
+    // Monotonic across canonical round-trips: an already-recorded ambiguity is
+    // never downgraded by a later read that happens to see a dispatch count.
+    dispatchAmbiguous: TRUE(source.dispatchAmbiguous) || dispatchAmbiguous,
+    pendingToolInput: TRUE(source.pendingToolInput) || TRUE(source.pendingToolUse),
+    userAbort: TRUE(source.userAbort) || _isAbortLike(source),
+    stallObserved,
+    truncatedStream,
+    unsafeMarker: TRUE(source.unsafeToRetry),
+  }
+}
+
+const EMPTY_SIGNALS = {
+  provider: null, transport: null,
+  terminalObserved: false, continuation: false, declaredContinuation: false,
+  textEmitted: false, textObservedChars: 0, reasoningEmitted: false,
+  toolCallsStarted: false, toolCallsComplete: 0, toolCallsDispatched: 0,
+  dispatchAmbiguous: false, pendingToolInput: false, userAbort: false,
+  stallObserved: false, truncatedStream: false, unsafeMarker: false,
+}
+
+function _merge(a, b) {
+  if (!b) return a
+  if (!a) return b
+  return {
+    provider: a.provider || b.provider || null,
+    transport: a.transport || b.transport || null,
+    terminalObserved: a.terminalObserved || b.terminalObserved,
+    continuation: a.continuation || b.continuation,
+    declaredContinuation: a.declaredContinuation || b.declaredContinuation,
+    textEmitted: a.textEmitted || b.textEmitted,
+    textObservedChars: Math.max(a.textObservedChars, b.textObservedChars),
+    reasoningEmitted: a.reasoningEmitted || b.reasoningEmitted,
+    toolCallsStarted: a.toolCallsStarted || b.toolCallsStarted,
+    toolCallsComplete: Math.max(a.toolCallsComplete, b.toolCallsComplete),
+    toolCallsDispatched: Math.max(a.toolCallsDispatched, b.toolCallsDispatched),
+    dispatchAmbiguous: a.dispatchAmbiguous || b.dispatchAmbiguous,
+    pendingToolInput: a.pendingToolInput || b.pendingToolInput,
+    userAbort: a.userAbort || b.userAbort,
+    stallObserved: a.stallObserved || b.stallObserved,
+    truncatedStream: a.truncatedStream || b.truncatedStream,
+    unsafeMarker: a.unsafeMarker || b.unsafeMarker,
+  }
+}
+
+function _finalize(signals) {
+  const s = signals || EMPTY_SIGNALS
+  const terminalObserved = s.terminalObserved === true
+  const visibleOutput = s.textEmitted || s.reasoningEmitted
+  const sideEffectDispatched = s.toolCallsDispatched > 0
+  const observedOutput = visibleOutput || s.textObservedChars > 0
+    || s.toolCallsComplete > 0 || sideEffectDispatched
+  // The architecture-specific deny: a replay would duplicate output the user
+  // already saw, or re-run a tool that was already handed off (including the
+  // ambiguous case where a complete tool call carries no dispatch report).
+  const replayUnsafe = visibleOutput || sideEffectDispatched
+    || s.dispatchAmbiguous === true || s.unsafeMarker === true
+  const replaySafe = !replayUnsafe && s.userAbort !== true
+  // A terminal frame that declared `end_turn=false` keeps the turn open.
+  const continuation = s.declaredContinuation === true
+    ? true
+    : (terminalObserved ? false : s.continuation === true)
+  return Object.freeze({
+    version: STREAM_OUTCOME_VERSION,
+    provider: s.provider || null,
+    transport: s.transport || STREAM_TRANSPORTS.UNKNOWN,
+    terminalObserved,
+    continuation,
+    declaredContinuation: s.declaredContinuation === true,
+    textEmitted: s.textEmitted === true,
+    textObservedChars: s.textObservedChars | 0,
+    reasoningEmitted: s.reasoningEmitted === true,
+    toolCallsStarted: s.toolCallsStarted === true,
+    toolCallsComplete: s.toolCallsComplete | 0,
+    toolCallsDispatched: s.toolCallsDispatched | 0,
+    dispatchAmbiguous: s.dispatchAmbiguous === true,
+    pendingToolInput: s.pendingToolInput === true,
+    userAbort: s.userAbort === true,
+    stallObserved: s.stallObserved === true,
+    truncatedStream: s.truncatedStream === true,
+    // Derived verdicts.
+    visibleOutput,
+    observedOutput,
+    sideEffectDispatched,
+    replayUnsafe,
+    replaySafe,
+    successEligible: terminalObserved && !continuation && s.pendingToolInput !== true,
+  })
+}
+
+/**
+ * Normalize any number of sources (thrown error, provider midState, explicit
+ * hint object) into the canonical record. Sources are OR/max merged; an
+ * already-canonical `source.streamOutcome` is merged in as well.
+ */
+export function readStreamOutcome(...sources) {
+  let signals = null
+  for (const source of sources) {
+    if (!source) continue
+    const existing = source.streamOutcome
+    if (existing && existing.version === STREAM_OUTCOME_VERSION) {
+      signals = _merge(signals, _signalsOf(existing))
+    }
+    signals = _merge(signals, _signalsOf(source))
+  }
+  return _finalize(signals || EMPTY_SIGNALS)
+}
+
+/** Alias kept for callers that read a provider midState directly. */
+export const streamOutcomeFromState = readStreamOutcome
+
+/**
+ * Attach the canonical record to `target` (usually a thrown error) and mirror
+ * it onto the historical alias flags. Aliases are only ever SET, never
+ * cleared, so a provider that already stamped one keeps it. Text that was
+ * merely observed (buffered, never relayed) does NOT set liveTextEmitted:
+ * only relayed text is a visibility/no-replay boundary.
+ */
+export function stampStreamOutcome(target, ...sources) {
+  if (!target || (typeof target !== 'object' && typeof target !== 'function')) return target
+  const outcome = readStreamOutcome(target, ...sources)
+  try {
+    target.streamOutcome = outcome
+    if (outcome.textEmitted) { target.liveTextEmitted = true; target.emittedText = true }
+    if (outcome.reasoningEmitted) target.emittedThinking = true
+    if (outcome.toolCallsStarted) target.partialToolCall = true
+    if (outcome.sideEffectDispatched) { target.emittedToolCall = true; target.toolCallEmitted = true }
+    if (outcome.pendingToolInput) target.pendingToolUse = true
+    if (outcome.truncatedStream) target.truncatedStream = true
+    if (outcome.replayUnsafe) target.unsafeToRetry = true
+  } catch { /* frozen/exotic targets keep the returned record only */ }
+  return outcome
+}
+
+/** True when re-issuing the turn would not duplicate exposure or side effects. */
+export function isReplaySafe(source) {
+  return readStreamOutcome(source).replaySafe
+}
+
+/** True when there is positive evidence that a replay would duplicate output. */
+export function isReplayUnsafe(source) {
+  return readStreamOutcome(source).replayUnsafe
+}
+
+/** True when the outcome may be promoted to a normal successful response. */
+export function canPromoteToSuccess(source) {
+  return readStreamOutcome(source).successEligible
+}
+
+/** True when anything the model produced was observed (visible or buffered). */
+export function hasObservedOutput(source) {
+  return readStreamOutcome(source).observedOutput
+}
+
+/** True when a tool call was handed off and may already have run. */
+export function hasDispatchedToolCalls(source) {
+  return readStreamOutcome(source).sideEffectDispatched
+}

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

@@ -236,6 +236,18 @@ function normalizeOpenAICodexResetCredits(data, accountId = '') {
   const availableRows = credits.filter((credit) => credit.status === 'available');
   if (explicitCount === null && !credits.length) return null;
   const availableCount = Math.max(0, Math.floor(explicitCount ?? availableRows.length));
+  const availableCredits = availableRows
+    .map((credit) => ({
+      ...(Number.isFinite(credit.expiresAt) && credit.expiresAt > 0
+        ? { expiresAt: credit.expiresAt }
+        : {}),
+      ...(Number.isFinite(credit.grantedAt) && credit.grantedAt > 0
+        ? { grantedAt: credit.grantedAt }
+        : {}),
+    }))
+    .sort((left, right) =>
+      (left.expiresAt ?? Number.POSITIVE_INFINITY)
+      - (right.expiresAt ?? Number.POSITIVE_INFINITY));
   const expiryCandidates = availableRows
     .map((credit) => credit.expiresAt)
     .filter((value) => Number.isFinite(value) && value > 0);
@@ -249,6 +261,7 @@ function normalizeOpenAICodexResetCredits(data, accountId = '') {
   })).digest('hex')}`;
   return {
     availableCount,
+    availableCredits,
     ...(nextExpiresAt ? { nextExpiresAt } : {}),
     offerRevision,
   };
@@ -600,7 +613,16 @@ async function fetchOpenAICodexUsage(providerObj) {
   if (!res.ok) throw new Error(`openai-oauth usage ${res.status}`);
   const data = await res.json();
   const usage = normalizeOpenAIWhamUsage(data);
-  return usage && resetCredits ? { ...usage, resetCredits } : usage;
+  // Orca parity: Codex may include the authoritative available count directly
+  // in /wham/usage while the detail endpoint is unavailable. Keep that count
+  // usable (including a scoped offer revision), then let the dedicated endpoint
+  // replace it when richer expiry details arrive.
+  const embeddedResetCredits = normalizeOpenAICodexResetCredits(
+    data?.rate_limit_reset_credits,
+    auth.accountId,
+  );
+  const resolvedResetCredits = resetCredits || embeddedResetCredits;
+  return usage && resolvedResetCredits ? { ...usage, resetCredits: resolvedResetCredits } : usage;
 }
 
 async function fetchAnthropicUsage(providerObj) {