mixdog 1.2.1 → 1.2.3

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-events/terminal-frames.mjs

@@ -8,9 +8,11 @@ import { typedStatusFrom } from '../../retry-classifier.mjs';
 import {
   endTurnFromEvent,
   incompleteReasonFromEvent,
+  isIncompleteToolItem,
   isMaxOutputIncompleteReason,
 } from '../../lib/responses-terminal-fields.mjs';
-import { LABEL, toolInputPending } from '../response-state.mjs';
+import { applyErrorContract, markContentFilter } from '../../openai-error-contract.mjs';
+import { toolInputPending } from '../response-state.mjs';
 import { normalizeWsUsage } from '../../openai-ws-response-state/usage.mjs';
 
 // Typed status only — nothing is synthesized from text. The frame itself is
@@ -19,11 +21,14 @@ import { normalizeWsUsage } from '../../openai-ws-response-state/usage.mjs';
 function wireFailureError(message, event, detail, typedSources) {
   const err = new Error(message);
   err.responseFailed = event;
-  const typed = typedStatusFrom(...typedSources);
-  if (typed) err.httpStatus = typed;
   const code = detail?.code ?? detail?.type ?? null;
   if (typeof code === 'string' && code) err.providerErrorCode = code;
-  return err;
+  return applyErrorContract(err, {
+    status: typedStatusFrom(...typedSources),
+    code: typeof code === 'string' ? code : undefined,
+    error: detail,
+    event,
+  });
 }
 
 export function createTerminalFrameEvents({ state, items, text, outcome, meaningful }) {
@@ -32,6 +37,13 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
   const absorbCompletedOutput = (output) => {
     let reported = false;
     for (const item of output) {
+      if (isIncompleteToolItem(item)) {
+        state.toolTracker.mark(item);
+        state.toolInFlight = true;
+        meaningful('tool');
+        reported = true;
+        continue;
+      }
       items.pushResponseItem(item);
       if (item.type === 'message') {
         if (text.absorbCompletedMessage(item)) reported = true;
@@ -89,7 +101,7 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
     absorbTerminalResponse(event.response || {});
     const reason = incompleteReasonFromEvent(event);
     if (!isMaxOutputIncompleteReason(reason)) {
-      const err = new Error(`${LABEL} ${frame}: ${reason}`);
+      const err = markContentFilter(new Error(`${state.label} ${frame}: ${reason}`), reason);
       // Still billed: the provider-boundary accounting records reported usage.
       if (state.usage) {
         err.partialUsage = state.usage;
@@ -97,31 +109,47 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
       }
       throw err;
     }
+    for (const item of event.response?.output || []) {
+      if (isIncompleteToolItem(item)) {
+        state.toolTracker.mark(item);
+        state.toolInFlight = true;
+      }
+    }
     if (toolInputPending(state)) {
-      const err = outcome.stampToolSafety(new Error(`${LABEL} ${frame} (max_output_tokens) with tool call in flight`));
+      // Same carried state as the WS path: text (leak-guard tail flushed),
+      // the calls already complete and dispatched, model and billed usage.
+      text.flushLeak();
+      const err = outcome.stampToolSafety(new Error(`${state.label} ${frame} (max_output_tokens) with tool call in flight`));
+      outcome.attachStreamPartial(err);
       err.streamStalled = true;
       err.pendingToolUse = true;
-      err.partialContent = state.content;
-      err.partialModel = state.model || undefined;
+      err.incompleteReason = reason;
       if (state.usage) err.partialUsage = state.usage;
       throw err;
     }
     state.completed = true;
     state.stopReason = 'length';
+    state.incompleteReason = reason;
   };
 
   const onDone = (event) => {
-    if (!event.response || event.response.status === 'completed') {
-      if (event.response) absorbTerminalResponse(event.response);
+    if (!event.response) {
       state.completed = true;
       // Terminal success frame for streams that never emit a separate
       // response.completed — same optional end_turn.
       setEndTurn(event);
+    } else if (event.response.status === 'completed') {
+      // Same terminal as response.completed: usage, end_turn and the output
+      // bundle reconciled through the same deduplicated collectors.
+      onCompleted(event);
     } else if (event.response.status === 'failed') {
       const msg = event.response?.error?.message || 'response.done failed';
-      const err = new Error(`${LABEL} response.done failed: ${msg}`);
-      const typed = typedStatusFrom(event.response?.error, event.error, event);
-      if (typed) err.httpStatus = typed;
+      const err = new Error(`${state.label} response.done failed: ${msg}`);
+      applyErrorContract(err, {
+        status: typedStatusFrom(event.response?.error, event.error, event),
+        error: event.response?.error || event.error || null,
+        event,
+      });
       throw withFailedUsage(err, event);
     } else if (event.response.status === 'incomplete') {
       onIncomplete(event, 'response.done incomplete');
@@ -131,7 +159,7 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
   const failedFrameError = (event) =>
     withFailedUsage(
       wireFailureError(
-        `${LABEL} response.failed: ${event.response?.error?.message || event.error?.message || event.message || 'response.failed'}`,
+        `${state.label} response.failed: ${event.response?.error?.message || event.error?.message || event.message || 'response.failed'}`,
         event,
         event.response?.error || event.error || null,
         [event.response?.error, event.error, event]
@@ -142,7 +170,7 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
   // Same wire-error contract as response.failed.
   const errorFrameError = (event) =>
     wireFailureError(
-      `${LABEL} error: ${event.message || event.error?.message || 'unknown'}`,
+      `${state.label} error: ${event.message || event.error?.message || 'unknown'}`,
       event,
       { code: event.error?.code ?? event.error?.type ?? event.code ?? null },
       [event.error, event]

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-events.mjs

@@ -42,6 +42,16 @@ export function createResponseEvents({ state, items, text, outcome, meaningful,
       case 'response.function_call_arguments.done':
         output.onFunctionCallArgumentsDone(event);
         break;
+      // Refusal text is collected for the typed refusal result, never relayed
+      // as visible answer text.
+      case 'response.refusal.delta':
+        state.refusals.delta(event);
+        meaningful('semantic');
+        break;
+      case 'response.refusal.done':
+        state.refusals.done(event);
+        meaningful('semantic');
+        break;
       case 'response.output_item.done':
         output.onOutputItemDone(event.item || {});
         break;

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-items.mjs

@@ -5,7 +5,12 @@
  * pending function_call completion.
  */
 import { makeInvalidToolArgsMarker } from '../lib/openai-tool-args.mjs';
-import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from '../custom-tool-wire.mjs';
+import {
+  customToolCallFromResponseItem,
+  nativeToolSearchCallFromArguments,
+  qualifiedToolCallName,
+  withToolCallNamespace,
+} from '../custom-tool-wire.mjs';
 
 // Completed function_call.arguments parse for the OpenAI Responses stream.
 // A function_call item arrives only on a completion/done signal, so a
@@ -37,7 +42,7 @@ export function createResponseItems({ state, onToolCall }) {
     if (!call?.id) return;
     if (state.emittedToolCallIds.has(call.id)) return;
     state.emittedToolCallIds.add(call.id);
-    if (!state.toolDedupe.shouldDispatch(call.name, call.arguments, call.id)) return;
+    if (!state.toolDedupe.shouldDispatch(qualifiedToolCallName(call), call.arguments, call.id)) return;
     state.emittedToolCall = true;
     try {
       onToolCall?.(call);
@@ -77,6 +82,8 @@ export function createResponseItems({ state, onToolCall }) {
   };
   const pushToolSearchCall = (item) => {
     if (item?.type !== 'tool_search_call') return;
+    // Server-executed search already ran inside the response; replay-only.
+    if (item.execution === 'server') return;
     const callId = item.call_id || item.id || '';
     if (!callId || state.toolCalls.some((t) => t.id === callId)) return;
     let args = {};
@@ -104,6 +111,7 @@ export function createResponseItems({ state, onToolCall }) {
   const completePendingCall = (tc, item) => {
     if (!tc.id && item.call_id) tc.id = item.call_id;
     if (!tc.name && item.name) tc.name = item.name;
+    withToolCallNamespace(tc, item);
     if (tc.id && tc.name) {
       delete tc._pendingItemId;
       emitToolCall(tc);
@@ -119,11 +127,14 @@ export function createResponseItems({ state, onToolCall }) {
     if (tc) {
       completePendingCall(tc, item);
     } else if (item.call_id && item.name) {
-      const call = {
-        id: item.call_id,
-        name: item.name,
-        arguments: parseJsonObject(item.arguments),
-      };
+      const call = withToolCallNamespace(
+        {
+          id: item.call_id,
+          name: item.name,
+          arguments: parseJsonObject(item.arguments),
+        },
+        item
+      );
       state.toolCalls.push(call);
       emitToolCall(call);
     }

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-outcome.mjs

@@ -8,8 +8,8 @@ import { traceAgentSse, traceAgentUsage } from '../../agent-trace.mjs';
 import { dedupeToolCallList } from '../lib/leaked-toolcall.mjs';
 import { _displayCodexModel } from '../openai-codex-model.mjs';
 import { createProviderReplay } from '../lib/provider-replay.mjs';
-import { LABEL } from './response-state.mjs';
 import { createResponseStamps } from './response-stamps.mjs';
+import { refusalResultFields } from '../openai-ws-response-state/refusals.mjs';
 
 export function createResponseOutcome({ state }) {
   const { stampToolSafety, stampOutcome, stallPartial, stampStreamError, attachStreamPartial, endedEarlyError } =
@@ -50,7 +50,7 @@ export function createResponseOutcome({ state }) {
       throw stampOutcome(
         stampToolSafety(
           new Error(
-            `${LABEL} function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`
+            `${state.label} function_call salvage failed: missing call_id/name for item_id=${unresolved._pendingItemId || '?'}`
           )
         )
       );
@@ -75,6 +75,7 @@ export function createResponseOutcome({ state }) {
       webSearchCalls: state.webSearchCalls.length ? state.webSearchCalls : undefined,
       usage: state.usage || undefined,
       stopReason: state.stopReason || undefined,
+      incompleteReason: state.incompleteReason || undefined,
       // Only present when the terminal frame carried the wire field.
       ...(typeof state.endTurn === 'boolean' ? { endTurn: state.endTurn } : {}),
       // Text-only max-output cutoff (status:'incomplete'/reason=max_output_tokens
@@ -84,6 +85,8 @@ export function createResponseOutcome({ state }) {
       ...(state.stopReason === 'length' && state.content.length > 0 ? { truncated: true } : {}),
       responseId: state.responseId || undefined,
       serviceTier: state.serviceTier || undefined,
+      // A refused turn: typed stop reason and the refusal text.
+      ...refusalResultFields(state.refusals, state.content),
     };
   };
 

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-stamps.mjs

@@ -9,7 +9,7 @@
  */
 import { stampStreamOutcome, STREAM_TRANSPORTS } from '../lib/stream-outcome.mjs';
 import { createProviderReplay } from '../lib/provider-replay.mjs';
-import { LABEL, toolInputPending } from './response-state.mjs';
+import { toolInputPending } from './response-state.mjs';
 
 export function createResponseStamps({ state }) {
   const stampToolSafety = (err) => {
@@ -111,7 +111,7 @@ export function createResponseStamps({ state }) {
     const err = attachStreamPartial(
       stampToolSafety(
         new Error(
-          `${LABEL} ended before response.completed (text=${state.content.length} chars, toolCalls=${state.toolCalls.length})`
+          `${state.label} ended before response.completed (text=${state.content.length} chars, toolCalls=${state.toolCalls.length})`
         )
       )
     );

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

@@ -7,11 +7,11 @@
  */
 import { createActiveToolItemTracker } from '../tool-stream-state.mjs';
 import { createToolCallDedupe } from '../lib/leaked-toolcall.mjs';
+import { createRefusals } from '../openai-ws-response-state/refusals.mjs';
 
-export const LABEL = 'OpenAI OAuth HTTP fallback';
-
-export function createResponseState() {
+export function createResponseState(label) {
   return {
+    label,
     content: '',
     model: '',
     responseId: '',
@@ -32,8 +32,12 @@ export function createResponseState() {
     citationKeys: new Set(),
     webSearchCalls: [],
     webSearchCallKeys: new Set(),
+    // Refusal parts (streamed and final), folded into one typed refusal.
+    refusals: createRefusals(),
     completed: false,
     stopReason: null,
+    // Why a max-output cutoff completed the turn (response.incomplete_details).
+    incompleteReason: null,
     // Normalized wire `end_turn` from the terminal frame; undefined unless the
     // server actually supplied a boolean.
     endTurn: undefined,

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/text-relay.mjs

@@ -97,10 +97,18 @@ export function createTextRelay({ state, body, onTextDelta, meaningful, emitTool
   };
   const absorbCompletedMessage = (item) => {
     let reported = false;
+    // Decided once per message item (as the WS completed-item fold does), so
+    // every content part of an item with no streamed text is absorbed rather
+    // than only the first one that fills `state.content`.
+    const absorbText = !state.content;
     for (const part of item.content || []) {
-      if (!state.content && part.type === 'output_text' && absorbCompletedText(part)) reported = true;
+      if (absorbText && part.type === 'output_text' && absorbCompletedText(part)) reported = true;
       if (part.type === 'output_text') pushOutputTextAnnotations(part, state.citations, state.citationKeys);
     }
+    if (state.refusals.absorbMessage(item)) {
+      meaningful('semantic');
+      reported = true;
+    }
     return reported;
   };
 

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

@@ -26,8 +26,8 @@ import { createResponseEvents } from './openai-http-sse-response-state/response-
  * @param {(kind: string) => void} deps.meaningful  semantic progress (re-arms the idle watchdog)
  * @param {() => void} deps.onServerEvent  first-event → semantic-idle handover
  */
-export function createHttpSseResponseState({ body, onToolCall, onTextDelta, meaningful, onServerEvent }) {
-  const state = createResponseState();
+export function createHttpSseResponseState({ body, onToolCall, onTextDelta, meaningful, onServerEvent, label }) {
+  const state = createResponseState(label);
   const outcome = createResponseOutcome({ state });
   const items = createResponseItems({ state, onToolCall });
   const text = createTextRelay({ state, body, onTextDelta, meaningful, emitToolCall: items.emitToolCall });

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

@@ -20,8 +20,6 @@ import {
   streamStalledError,
 } from '../stall-policy.mjs';
 
-const LABEL = 'OpenAI OAuth HTTP fallback';
-
 function positiveOverride(value) {
   const ms = Number(value);
   return Number.isFinite(ms) && ms > 0 ? ms : 0;
@@ -34,7 +32,7 @@ function positiveOverride(value) {
  * @param {{ signal?: AbortSignal, cleanup(): void }} deps.totalTimeout
  * @param {() => object} deps.stallPartial  streamed partial state attached to a semantic-idle stall
  */
-export function createHttpSseWatchdogs({ opts, reader, totalTimeout, stallPartial }) {
+export function createHttpSseWatchdogs({ opts, reader, totalTimeout, stallPartial, label: LABEL }) {
   let abortReason = null;
   let pendingReadReject = null;
   const rejectPendingRead = (err) => {

package/src/runtime/agent/orchestrator/providers/openai-model-capabilities.mjs

@@ -0,0 +1,80 @@
+// Public OpenAI API model capabilities for Responses request construction.
+// Catalog metadata decides where it declares a capability; otherwise the
+// documented model-family rules below apply. The Codex (openai-oauth) route is
+// separate: its backend serves only current GPT-5.x models and keeps its own
+// defaults, so none of these gates apply to it.
+//   reasoning:    https://developers.openai.com/api/docs/guides/reasoning/
+//   tool_search:  https://developers.openai.com/api/docs/guides/tools-tool-search/ (gpt-5.4 and later)
+//   cache:        https://developers.openai.com/api/docs/guides/prompt-caching/
+import { getModelMetadataSync } from '../../../shared/llm/model-catalog.mjs';
+
+const SNAPSHOT_SUFFIX = /-\d{4}-\d{2}-\d{2}$/;
+const modelId = (model) => String(model?.id || model || '').trim();
+
+// The catalog metadata of one model. A dated snapshot reads as its undated
+// alias when only the alias is listed.
+export function openAiCatalogMeta(model) {
+  const id = modelId(model);
+  for (const candidate of new Set([id, id.replace(SNAPSHOT_SUFFIX, '')])) {
+    const meta = candidate ? getModelMetadataSync(candidate, 'openai') : null;
+    if (meta) return meta;
+  }
+  return null;
+}
+
+// gpt-5.4 -> [5, 4]; gpt-6-astra -> [6, 0]; non-GPT ids -> null.
+// A bare multi-digit major with no minor or family suffix (gpt-60) is not a
+// generation id.
+function gptVersion(id) {
+  const m = /^gpt-(\d+)(?:\.(\d+))?(?=-|$)/.exec(id);
+  if (!m || (m[1].length > 1 && m[2] === undefined && m[0] === id)) return null;
+  return [Number(m[1]), Number(m[2] || 0)];
+}
+const atLeast = (version, major, minor) =>
+  Boolean(version) && (version[0] > major || (version[0] === major && version[1] >= minor));
+
+// Reasoning models: the o-series and GPT-5 and later (gpt-5-chat-latest is the
+// non-reasoning chat snapshot).
+export function openAiPublicSupportsReasoning(model) {
+  const flag = openAiCatalogMeta(model)?.supportsReasoning;
+  if (typeof flag === 'boolean') return flag;
+  const id = modelId(model);
+  if (/^gpt-5-chat/.test(id)) return false;
+  return /^o\d/.test(id) || atLeast(gptVersion(id), 5, 0);
+}
+
+// text.verbosity is documented for GPT-5 and later.
+export function openAiPublicSupportsVerbosity(model) {
+  return atLeast(gptVersion(modelId(model)), 5, 0);
+}
+
+// Native tool_search: Responses API gpt-5.4 and later.
+export function openAiPublicSupportsToolSearch(model) {
+  return atLeast(gptVersion(modelId(model)), 5, 4);
+}
+
+// GPT-5.6 and later take prompt_cache_options.ttl instead of prompt_cache_retention.
+export function openAiUsesPromptCacheOptions(model) {
+  return atLeast(gptVersion(modelId(model)), 5, 6);
+}
+
+// Documented extended (24h) prompt_cache_retention list; dated snapshots read
+// as their alias.
+const EXTENDED_RETENTION = new Set([
+  'gpt-5.5',
+  'gpt-5.5-pro',
+  'gpt-5.4',
+  'gpt-5.2',
+  'gpt-5.1-codex-max',
+  'gpt-5.1',
+  'gpt-5.1-codex',
+  'gpt-5.1-codex-mini',
+  'gpt-5.1-chat-latest',
+  'gpt-5',
+  'gpt-5-codex',
+  'gpt-4.1',
+]);
+export function openAiSupportsExtendedRetention(model) {
+  const id = modelId(model);
+  return EXTENDED_RETENTION.has(id) || EXTENDED_RETENTION.has(id.replace(SNAPSHOT_SUFFIX, ''));
+}

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

@@ -13,6 +13,9 @@ import { codexCatalogHas } from './openai-oauth-catalog.mjs';
 import { _displayCodexModel } from './openai-codex-model.mjs';
 import { _envFlag, _shouldUseOpenAIHttpFallback } from './openai-oauth-http-sse.mjs';
 import { isWsMessageTooBigClose } from './retry-classifier.mjs';
+import { waitForRetryDeadline } from './openai-error-contract.mjs';
+import { isReplaySafe } from './lib/stream-outcome.mjs';
+import { noteErrorUsage } from './lib/note-error-usage.mjs';
 
 function openAiOAuthHandshakeErrorPolicy({ status }) {
   if (Number(status) === 404) {
@@ -99,7 +102,9 @@ export function createOpenAiOAuthDispatch({
     for (const [key, expiresAt] of provider._httpFallbackUntilByPoolKey) {
       if (!(expiresAt > now)) provider._httpFallbackUntilByPoolKey.delete(key);
     }
-    return (provider._httpFallbackUntilByPoolKey.get(poolKey) || 0) > now;
+    // A forked transport scope follows its session's switch; it records its own.
+    const sessionUntil = opts.sessionId ? provider._httpFallbackUntilByPoolKey.get(opts.sessionId) || 0 : 0;
+    return Math.max(provider._httpFallbackUntilByPoolKey.get(poolKey) || 0, sessionUntil) > now;
   };
   const markStickyHttpFallback = () => {
     if (!poolKey) return;
@@ -130,6 +135,17 @@ export function createOpenAiOAuthDispatch({
       });
     } catch {}
   };
+  // A 401 is recoverable once per send, and only while nothing the turn
+  // produced could be duplicated by reissuing it.
+  const canReissueAfter401 = (err) =>
+    Number(err?.httpStatus || err?.status || 0) === 401 &&
+    authState.authRefreshed !== true &&
+    !externalSignal?.aborted &&
+    err?.liveTextEmitted !== true &&
+    err?.emittedToolCall !== true &&
+    err?.toolCallEmitted !== true &&
+    err?.unsafeToRetry !== true &&
+    isReplaySafe(err);
   const dispatchHttp = async (reason, originalErr = null, { sticky = false } = {}) => {
     // Transport switching is a session decision, not an HTTP-success
     // side effect. Persist it before the fallback can fail or abort.
@@ -158,9 +174,10 @@ export function createOpenAiOAuthDispatch({
       if (!process.env.MIXDOG_QUIET_PROVIDER_LOG)
         process.stderr.write(`[openai-oauth] WebSocket unhealthy (${reason}); falling back to HTTP/SSE\n`);
     }
-    let result;
-    try {
-      result = await sendHttp({
+    // The server's retry deadline outlives a transport switch.
+    if (originalErr && reason !== 'forced') await waitForRetryDeadline(originalErr, externalSignal, opts._sleepFn);
+    const sendHttpOnce = () =>
+      sendHttp({
         auth: authState.tokens,
         body,
         opts,
@@ -175,6 +192,22 @@ export function createOpenAiOAuthDispatch({
         useModel,
         fetchFn: opts._fetchFn,
       });
+    let result;
+    try {
+      try {
+        result = await sendHttpOnce();
+      } catch (firstErr) {
+        if (!canReissueAfter401(firstErr)) throw firstErr;
+        // Same bounded, replay-safe recovery the WS path applies: one forced
+        // refresh per send, one reissue of the identical request.
+        noteErrorUsage(firstErr);
+        traceTransportError(firstErr, 'primary', 'http');
+        process.stderr.write('[openai-oauth-http] 401 — forcing refresh and retrying once over HTTP/SSE\n');
+        authState.authRefreshed = true;
+        provider._refreshFallbackUntil = 0;
+        authState.tokens = await provider.ensureAuth({ forceRefresh: true, reason: '401' });
+        result = await sendHttpOnce();
+      }
     } catch (httpErr) {
       // The current transport owns the terminal decision, including
       // auth, rate limits, cancellation and output-safety markers.

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

@@ -16,9 +16,12 @@ import { CODEX_OAUTH_ORIGINATOR } from './openai-codex-endpoints.mjs';
 import { parseProviderJsonBatch } from './stream-json-pool.mjs';
 import { envFlag as _envFlag } from '../../../shared/env.mjs';
 import { activateCodexTurnState } from './openai-turn-state.mjs';
+import { httpLabel } from './openai-error-contract.mjs';
 import { openHttpSseResponse } from './openai-http-sse-request.mjs';
 import { createHttpSseWatchdogs } from './openai-http-sse-watchdogs.mjs';
 import { createHttpSseResponseState } from './openai-http-sse-response-state.mjs';
+import { codexUserAgent, codexVersionHeader } from './codex-client-meta.mjs';
+import { _codexBetaFeatures } from './openai-ws-headers.mjs';
 export { _envFlag };
 
 function _sseEventsFromBuffer(buffer) {
@@ -72,6 +75,11 @@ export function _buildOpenAIHttpFallbackHeaders({
     originator: CODEX_OAUTH_ORIGINATOR,
     'chatgpt-account-id': auth.account_id || '',
     'x-client-request-id': randomBytes(16).toString('hex'),
+    // Codex identity shared with the WS handshake (build_responses_headers);
+    // WS-only OpenAI-Beta value stays HTTP-specific above.
+    'User-Agent': codexUserAgent(),
+    version: codexVersionHeader(),
+    'x-codex-beta-features': _codexBetaFeatures(),
   };
   if (cacheKey && !statelessConversation) {
     const sid = String(cacheKey);
@@ -165,6 +173,7 @@ export async function sendViaHttpSse({
     onStageChange?.('streaming');
   } catch {}
   const sseStartedAt = Date.now();
+  const label = httpLabel(auth);
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let ttftMs = null;
@@ -173,6 +182,7 @@ export async function sendViaHttpSse({
     reader,
     totalTimeout,
     stallPartial: () => state.stallPartial(),
+    label,
   });
   const meaningful = (kind = 'semantic') => {
     if (ttftMs == null) ttftMs = Date.now() - sseStartedAt;
@@ -187,6 +197,7 @@ export async function sendViaHttpSse({
     onTextDelta,
     meaningful,
     onServerEvent: watchdogs.noteServerEvent,
+    label,
   });
   const foldFrames = async (text) => {
     const parsed = _sseEventsFromBuffer(text);
@@ -202,7 +213,7 @@ export async function sendViaHttpSse({
       if (totalTimeout.signal?.aborted) {
         watchdogs.clearSemanticIdle();
         const reason = totalTimeout.signal.reason;
-        throw reason instanceof Error ? reason : new Error('OpenAI OAuth HTTP fallback aborted');
+        throw reason instanceof Error ? reason : new Error(`${label} aborted`);
       }
       const abortReason = watchdogs.abortReason();
       if (abortReason) throw abortReason;

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

@@ -189,6 +189,7 @@ export function forgetOpenAIOAuthCredentials() {
 }
 
 // --- Token refresh ---
+const PERMANENT_REFRESH_FAILURE_RE = /invalid_grant|revoked|reused|refresh_token_(?:expired|invalidated)/i;
 async function exchangeRefreshToken(refreshToken, previousIdentity = null) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), TOKEN_REFRESH_TIMEOUT_MS);
@@ -214,10 +215,17 @@ async function exchangeRefreshToken(refreshToken, previousIdentity = null) {
       // CLI's single-use lineage) from transient failures, so the caller can
       // re-read disk and retry once with a newer token instead of
       // collapsing every failure to a generic null.
-      if (res.status === 400 || res.status === 401 || /invalid_grant|revoked|reused/i.test(text)) {
+      // Only a CONFIRMED permanent refusal sets reauthRequired: a 401, or a
+      // typed refresh-token code. A bare 400/5xx/429 is not evidence the
+      // refresh token is dead.
+      if (res.status === 401 || PERMANENT_REFRESH_FAILURE_RE.test(text)) {
         throw Object.assign(new Error(`OpenAI OAuth token refresh ${res.status} (invalid_grant)`), {
           isInvalidGrant: true,
           reauthRequired: true,
+          status: res.status,
+          httpStatus: res.status,
+          code: 'invalid_grant',
+          headers: res.headers,
         });
       }
       return null;
@@ -312,7 +320,19 @@ async function refreshUnderLock({ currentToken, force, reason, startingTokens })
       process.stderr.write(`[openai-oauth] Refresh failed (${msg}); using still-valid current token\n`);
       return { tokens: reusable, coastOnCurrent: true };
     }
-    throw new Error(`OpenAI OAuth token refresh failed (${msg}). Re-authenticate via provider login.`);
+    const failure = new Error(`OpenAI OAuth token refresh failed (${msg}). Re-authenticate via provider login.`);
+    // The wrapper must not hide a confirmed permanent refusal from the account pool.
+    if (err?.reauthRequired === true) {
+      Object.assign(failure, {
+        reauthRequired: true,
+        isInvalidGrant: true,
+        status: err.status,
+        httpStatus: err.httpStatus,
+        code: err.code,
+        headers: err.headers,
+      });
+    }
+    throw failure;
   }
 }
 

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

@@ -86,6 +86,9 @@ export class OpenAIOAuthProvider {
   // so input alone is the context footprint. See registry.mjs.
   static inputExcludesCache = false;
   name = 'openai-oauth';
+  // Loop retry policy (send-with-recovery loopRetryPolicy): a connect failure waits for
+  // the network, and a content_filter refusal is replayed under the budget.
+  retryPolicy = Object.freeze({ unboundedConnectionRetry: true, contentFilterRetryable: true });
   tokens = null;
   _refreshFallbackUntil = 0;
   // Sticky transport fallback is isolated by the WS pool/session key. A
@@ -149,6 +152,11 @@ export class OpenAIOAuthProvider {
     return this.tokens;
   }
 
+  /** Drop a disposed transport scope's sticky transport record. */
+  releaseTransportScope(scope) {
+    this._httpFallbackUntilByPoolKey.delete(scope);
+  }
+
   send(messages, model, tools, sendOpts) {
     return withEffortConfigurationFallback('openai-oauth', model, sendOpts || {}, (opts) =>
       this._sendOnce(messages, model, tools, opts)
@@ -204,7 +212,8 @@ export class OpenAIOAuthProvider {
     // session. cacheKey is body.prompt_cache_key and affects prompt-cache
     // routing only; Codex handshake identity comes from sendOpts and remains
     // independent so a future cache-lane policy cannot merge conversations.
-    const poolKey = opts.sessionId || null;
+    // A forked request runs in its own transport scope (transport-scope.mjs).
+    const poolKey = opts.transportScope || opts.sessionId || null;
     const cacheKey = body.prompt_cache_key || resolveProviderCacheKey(opts, 'openai-oauth');
     const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;
     const sendWs = typeof opts._sendViaWebSocketFn === 'function' ? opts._sendViaWebSocketFn : sendViaWebSocket;
@@ -277,6 +286,8 @@ export class OpenAIOAuthProvider {
           process.stderr.write(`[agent-trace] provider-${status}-retry attempt=1\n`);
         }
         this._refreshFallbackUntil = 0;
+        // One forced refresh per send, shared with the HTTP/SSE dispatch.
+        authState.authRefreshed = true;
         authState.tokens = await this.ensureAuth({ forceRefresh: true, reason: String(status) });
         try {
           const result = await dispatch.dispatchWs(true);