mixdog 1.2.3 → 1.2.4

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

@@ -2,12 +2,51 @@ import { resolveProviderApiKey } from '../../../shared/provider-api-key.mjs';
 import { enrichModels } from './model-catalog.mjs';
 import { sanitizeModelList } from './model-list-sanitize.mjs';
 import { PROVIDER_GENERATE_TOTAL_TIMEOUT_MS, createTimeoutSignal, resolveTimeoutMs } from '../stall-policy.mjs';
+import { CUSTOM_EFFORT_LEVELS, normalizeCustomEffort } from './custom-reasoning.mjs';
 
 const MODEL_LIST_TIMEOUT_MS = resolveTimeoutMs('MIXDOG_COMPAT_MODEL_LIST_TIMEOUT_MS', 10_000, {
   minMs: 1_000,
   maxMs: PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
 });
 
+/** Preserve endpoint-declared effort levels without inventing a default ladder. */
+export function extractCompatReasoningEffort(model) {
+  if (!model || typeof model !== 'object') return null;
+  const rawLevels = [
+    model.reasoning_efforts,
+    model.reasoning_levels,
+    model.reasoningLevels,
+    model.capabilities?.reasoning_efforts,
+    model.capabilities?.reasoning_effort,
+  ].find(Array.isArray);
+  if (rawLevels) {
+    const declared = new Set(
+      rawLevels
+        .map((level) => (typeof level === 'string' ? level : level?.value))
+        .filter((level) => typeof level === 'string')
+        .map(normalizeCustomEffort)
+        .filter(Boolean)
+    );
+    const levels = CUSTOM_EFFORT_LEVELS.filter((level) => declared.has(level));
+    if (levels.length > 0) {
+      return {
+        supportsReasoning: levels.some((level) => level !== 'none'),
+        reasoningLevels: levels,
+        reasoningOptions: [{ type: 'effort', values: [...levels] }],
+      };
+    }
+    return null;
+  }
+  if (
+    model.supports_reasoning_effort === true ||
+    model.capabilities?.reasoning_effort === true ||
+    model.capabilities?.reasoning_efforts === true
+  ) {
+    return { supportsReasoning: true };
+  }
+  return null;
+}
+
 // `keyless` omits the Authorization header entirely (keyless endpoints);
 // `signal` aborts the request together with the list timeout.
 export async function fetchCompatModelItems(provider, { signal = null, keyless = false } = {}) {
@@ -70,17 +109,14 @@ export async function listCompatModels(provider, { throwOnError = false, signal
           0
       );
       const outputTokens = Number(
-        m?.max_output_tokens ??
-          m?.output_tokens ??
-          m?.maxOutputTokens ??
-          m?.top_provider?.max_completion_tokens ??
-          0
+        m?.max_output_tokens ?? m?.output_tokens ?? m?.maxOutputTokens ?? m?.top_provider?.max_completion_tokens ?? 0
       );
       const mode = nativeMode(m);
       // A catalog alias (OpenRouter `~anthropic/claude-opus-latest`) keeps its
       // own slug for routing; the slug it currently points at is retained for
       // capability lookup only.
       const aliasTarget = typeof m?.alias_target === 'string' ? m.alias_target : m?.alias_target?.slug;
+      const effortInfo = extractCompatReasoningEffort(m);
       models.push({
         id: m?.id,
         name: m?.id,
@@ -90,6 +126,7 @@ export async function listCompatModels(provider, { throwOnError = false, signal
         created: typeof m?.created === 'number' ? m.created : null,
         ...(mode ? { mode } : {}),
         ...(typeof aliasTarget === 'string' && aliasTarget ? { aliasTarget } : {}),
+        ...(effortInfo || {}),
       });
     }
     const filtered = models.filter((m) => m.id);

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

@@ -98,7 +98,10 @@ function thinkingText(thinking) {
   if (typeof thinking === 'string') return thinking;
   if (!Array.isArray(thinking)) return '';
   return thinking
-    .map((inner) => (typeof inner === 'string' ? inner : typeof inner?.text === 'string' ? inner.text : ''))
+    .map((inner) => {
+      if (typeof inner === 'string') return inner;
+      return typeof inner?.text === 'string' ? inner.text : '';
+    })
     .join('');
 }
 
@@ -129,14 +132,15 @@ export function chatContentParts(content) {
  */
 export function readChatMessage(message, { shape = null } = {}) {
   const parts = chatContentParts(message?.content);
-  const content = parts
-    ? parts
-        .filter((part) => part.kind === 'text')
-        .map((part) => part.text)
-        .join('')
-    : typeof message?.content === 'string'
-      ? message.content
-      : '';
+  let content;
+  if (parts) {
+    content = parts
+      .filter((part) => part.kind === 'text')
+      .map((part) => part.text)
+      .join('');
+  } else {
+    content = typeof message?.content === 'string' ? message.content : '';
+  }
   if (typeof message?.reasoning_content === 'string') {
     return { content, reasoningContent: message.reasoning_content, reasoningSource: 'reasoning_content' };
   }

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

@@ -225,9 +225,7 @@ export function normalizeCompatChatResponse({
   // Replay sends reasoning back under the field it arrived on.
   const providerMetadata = {
     ...(reasoningDetails?.length ? { openrouter: { reasoning_details: reasoningDetails } } : {}),
-    ...(reasoningContent !== null && reasoningField
-      ? { [COMPAT_REASONING_METADATA_KEY]: { reasoningField } }
-      : {}),
+    ...(reasoningContent !== null && reasoningField ? { [COMPAT_REASONING_METADATA_KEY]: { reasoningField } } : {}),
   };
   return {
     content: assembled.content || '',

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

@@ -13,7 +13,13 @@ export const SERVER_CALL = {
   execution: 'server',
   arguments: { query: 'q' },
 };
-export const SERVER_OUTPUT = { type: 'tool_search_output', id: 'tso_srv', call_id: null, execution: 'server', tools: [] };
+export const SERVER_OUTPUT = {
+  type: 'tool_search_output',
+  id: 'tso_srv',
+  call_id: null,
+  execution: 'server',
+  tools: [],
+};
 export const REPLY = { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'ok' }] };
 
 export const ROUTES = [
@@ -115,11 +121,14 @@ export function serverSearchReplayHistory(owner) {
 export const COMPAT_CASES = [
   ['native', () => nativeHistory()],
   ['oauth', () => oauthHistory()],
-  ['own-search-output', (name) => {
-    const h = nativeHistory();
-    h[2] = { ...h[2], nativeToolSearch: search(name) };
-    return h;
-  }],
+  [
+    'own-search-output',
+    (name) => {
+      const h = nativeHistory();
+      h[2] = { ...h[2], nativeToolSearch: search(name) };
+      return h;
+    },
+  ],
   ['server-replay', (name, owner = replayOwner(name)) => serverSearchReplayHistory(owner)],
 ];
 
@@ -153,7 +162,9 @@ export async function captureCompat(name, model, history, opts = {}, config = {}
 }
 
 export function captureFirstParty(name, model, history) {
-  return JSON.parse(JSON.stringify(buildRequestBody(history, model, [], { promptCacheProvider: name, sessionId: 'sess-1' })));
+  return JSON.parse(
+    JSON.stringify(buildRequestBody(history, model, [], { promptCacheProvider: name, sessionId: 'sess-1' }))
+  );
 }
 
 export async function captureAll() {

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

@@ -66,6 +66,7 @@ function resolveReasoning(provider, useModel, opts) {
 function customEffortProjection(provider, useModel, messages, opts) {
   if (!isCustomProviderName(provider.name)) return null;
   const projection = projectEffortConfiguration(messages, provider.name, useModel, {
+    ...provider.config,
     ...opts,
     protocol: 'openai-responses',
   });
@@ -101,7 +102,10 @@ function supportsPromptCacheKey(provider, opts) {
 // `responsesNativeItems: true` (opts or config) gets the first-party lowering.
 // Every other route keeps the function-only lowering byte for byte.
 function supportsNativeResponsesItems(provider, opts) {
-  return (opts.responsesNativeItems ?? provider.config?.responsesNativeItems) === true || hasNativeDeferredTools(provider, opts);
+  return (
+    (opts.responsesNativeItems ?? provider.config?.responsesNativeItems) === true ||
+    hasNativeDeferredTools(provider, opts)
+  );
 }
 
 // A session whose pinned route verified native deferred tools on the Responses
@@ -126,6 +130,33 @@ function customSessionCacheKey(provider, opts) {
   );
 }
 
+// HTTP header names are case-insensitive. Do not shadow explicit SDK
+// defaults, combine differently-cased identities, or stringify null deletions.
+function customSessionHeaders(provider, sessionCacheKey, requestHeaders) {
+  if (!sessionCacheKey) return requestHeaders;
+  const headers = { 'session-id': sessionCacheKey, 'x-client-request-id': sessionCacheKey };
+  const clientOptions = provider.config?.clientOptions || {};
+  const configured = Object.hasOwn(clientOptions, 'defaultHeaders')
+    ? clientOptions.defaultHeaders
+    : provider.defaultHeaders;
+  const entries = (source) =>
+    source instanceof Headers || Array.isArray(source) ? source : Object.entries(source || {});
+  const hasValue = (value) => (Array.isArray(value) ? value.some((item) => item !== undefined) : value !== undefined);
+  for (const source of [configured, requestHeaders]) {
+    for (const [name, value] of entries(source)) {
+      if (hasValue(value)) delete headers[name.toLowerCase()];
+    }
+  }
+  if (requestHeaders instanceof Headers) {
+    const merged = new Headers(requestHeaders);
+    for (const [name, value] of Object.entries(headers)) merged.set(name, value);
+    return merged;
+  }
+  if (Array.isArray(requestHeaders)) return [...Object.entries(headers), ...requestHeaders];
+  const supplied = Object.fromEntries(Object.entries(requestHeaders || {}).filter(([, value]) => hasValue(value)));
+  return { ...headers, ...supplied };
+}
+
 /** The request body: lowered transcript plus the per-turn knobs (output cap,
  *  tools and tool choice, reasoning effort, session cache key). */
 function buildCompatResponsesParams({
@@ -300,8 +331,10 @@ async function sendCompatResponsesOnce(provider, messages, useModel, tools, opts
     sessionCacheKey,
   });
   // The session identity also travels as headers; caller headers win.
-  const headers = sessionCacheKey && isCustomProviderName(provider.name)
-    ? { 'session-id': sessionCacheKey, 'x-client-request-id': sessionCacheKey, ...opts.requestHeaders }
+  // Custom routes only: a gateway route that opts into prompt_cache_key keeps
+  // its own headers.
+  const headers = isCustomProviderName(provider.name)
+    ? customSessionHeaders(provider, sessionCacheKey, opts.requestHeaders)
     : opts.requestHeaders;
 
   try {

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

@@ -21,13 +21,18 @@
 //     and jittered by jitterRatio (the advice of the excepted statuses stays raw).
 //   recycleDispatcherOn5xx — a retried 5xx rebuilds the shared HTTP pool.
 //   adviceAtLeastBackoff — the advice is a floor under the jittered backoff step.
+//   firstByteRetries — a header or first-chunk timeout (`timeoutPhase`) is
+//     retried at most this many times, each retry on a doubled window capped
+//     at PROVIDER_MAX_BEFORE_WARN_MS; other transient errors keep the ladder.
 // Every stop is provider-terminal: the profile's limits are final, so the
 // agent loop never re-runs a stopped or exhausted request (see
 // COMPAT_RETRY_POLICY).
 import { markProviderRecoveryExhausted } from './retry-classifier.mjs';
 import { retryAfterMsFromError } from './provider-error-kind.mjs';
 import { STREAM_TRANSPORTS, stampStreamOutcome } from './lib/stream-outcome.mjs';
-import { jitterDelayMs } from './retry-backoff.mjs';
+import { DEFAULT_BACKOFF_MS, DEFAULT_MAX_ATTEMPTS, jitterDelayMs } from './retry-backoff.mjs';
+import { PROVIDER_MAX_BEFORE_WARN_MS, firstBytePolicyBudget, firstByteWindowMs } from '../stall-policy.mjs';
+import { isFirstByteTimeout } from '../../../shared/provider-timeout-phase.mjs';
 
 const statusOf = (err) => Number(err?.httpStatus || err?.status || err?.response?.status || 0);
 
@@ -75,9 +80,11 @@ export const COMPAT_RETRY_PROFILES = Object.freeze({
   }),
   // server budget 8 retries (2s doubling to 30s,
   // ±10%), rate-limit budget 5 retries; 408, 409, 501 and 505 are terminal
-  // (425 stays retryable); a Retry-After beyond 300s is not waited out.
+  // (425 stays retryable); a Retry-After beyond 300s is not waited out. A
+  // first-byte timeout gets one longer retry instead of the whole ladder.
   'mimo-oauth': Object.freeze({
     maxAttempts: 9,
+    firstByteRetries: 1,
     backoffMs: [2000, 2000, 4000, 8000, 16000, 30000],
     retryJitterRatio: 0.1,
     statusRetryCaps: { 429: 5 },
@@ -112,6 +119,40 @@ export function compatRetryOptions(providerName) {
   };
 }
 
+// The provider's first-byte policy (see firstByteWindowMs) on a base window:
+// a profile's `firstByteRetries` caps first-byte retries on a doubling window;
+// without it every attempt keeps the base window.
+function compatFirstBytePolicy(providerName, baseMs) {
+  return {
+    timeoutMs: baseMs,
+    maxMs: PROVIDER_MAX_BEFORE_WARN_MS,
+    retries: COMPAT_RETRY_PROFILES[providerName]?.firstByteRetries ?? null,
+  };
+}
+
+/** First-byte window of an attempt after `timeouts` first-byte timeouts. */
+export function compatFirstByteWindowMs(providerName, baseMs, timeouts = 0) {
+  return firstByteWindowMs(compatFirstBytePolicy(providerName, baseMs), timeouts);
+}
+
+/**
+ * First-response budget of a chat profile that sets its own first-byte window
+ * (`firstByteTimeoutMs`, applied to the headers and to the first chunk): the
+ * worst case over the profile's whole ladder, where drops and 5xx use up
+ * attempts and backoff alongside the first-byte timeouts the profile permits
+ * (see firstBytePolicyBudget). Null for a profile on the shared window, which
+ * the agent watchdog's default already covers.
+ */
+export function compatFirstResponseBudget(providerName, chatProfile) {
+  const windowMs = Number(chatProfile?.firstByteTimeoutMs);
+  if (!(windowMs > 0)) return null;
+  const options = compatRetryOptions(providerName);
+  return firstBytePolicyBudget(compatFirstBytePolicy(providerName, windowMs), {
+    attempts: options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+    backoffMs: options.backoffMs ?? DEFAULT_BACKOFF_MS,
+  });
+}
+
 function profileStops(profile, err, { attempt, elapsedMs }) {
   const status = statusOf(err);
   if (profile.terminalStatuses?.includes(status)) return true;
@@ -170,10 +211,11 @@ export function withCompatRetryProfile(providerName, attemptFn) {
   const profile = COMPAT_RETRY_PROFILES[providerName];
   if (!profile) return attemptFn;
   let emptyRetries = 0;
+  let firstByteTimeouts = 0;
   return async (ctx) => {
     const startedAt = Date.now();
     try {
-      const result = await attemptFn(ctx);
+      const result = await attemptFn({ ...ctx, firstByteTimeouts });
       if (profile.retryEmptyResponse && isEmptyNormalFinish(result)) {
         const bound = profile.retryEmptyResponse === true ? Infinity : profile.retryEmptyResponse;
         if (emptyRetries < bound) {
@@ -183,6 +225,12 @@ export function withCompatRetryProfile(providerName, attemptFn) {
       }
       return result;
     } catch (err) {
+      if (profile.firstByteRetries != null && isFirstByteTimeout(err) && !ctx?.signal?.aborted) {
+        firstByteTimeouts += 1;
+        if (firstByteTimeouts > profile.firstByteRetries) {
+          throw markProviderRecoveryExhausted(err, { owner: `${providerName}-first-byte`, terminal: true });
+        }
+      }
       if (profileStops(profile, err, { attempt: ctx?.attempt | 0, elapsedMs: Date.now() - startedAt })) {
         throw markProviderRecoveryExhausted(err, { owner: `${providerName}-retry-profile`, terminal: true });
       }

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

@@ -15,7 +15,12 @@ import {
 import { withEffortRejectionFallback } from './effort-rejection.mjs';
 import { applyCompatErrorContract } from './openai-compat-error-contract.mjs';
 import { sendCompatResponses } from './openai-compat-responses.mjs';
-import { COMPAT_RETRY_POLICY, COMPAT_RETRY_PROFILES, XAI_COMPAT_RETRY_POLICY } from './openai-compat-retry-profile.mjs';
+import {
+  COMPAT_RETRY_POLICY,
+  COMPAT_RETRY_PROFILES,
+  XAI_COMPAT_RETRY_POLICY,
+  compatFirstResponseBudget,
+} from './openai-compat-retry-profile.mjs';
 import { sendCompatChat, recoverCompatNonStreaming } from './openai-compat-chat-send.mjs';
 import { sendXaiResponses, sendXaiResponsesWebSocket } from './openai-compat-xai-send.mjs';
 import {
@@ -100,6 +105,11 @@ export class OpenAICompatProvider {
       }
     }
   }
+  // First-response budget of a chat profile with its own first-byte window;
+  // null keeps the agent watchdog default.
+  firstResponseBudget() {
+    return compatFirstResponseBudget(this.name, this.config?.chatProfile);
+  }
   get _preconnectFn() {
     return typeof this.config?.preconnectFn === 'function' ? this.config.preconnectFn : preconnect;
   }

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

@@ -6,7 +6,16 @@
  * Returns an OK response whose body is ready to stream; every failure path
  * throws with the initial-response markers the retry classifier reads.
  */
+import { promisify } from 'node:util';
 import zlib from 'node:zlib';
+import {
+  REQ_COMPRESSION_MIN_BYTES,
+  compressBody,
+  createCompressionLatch,
+  hasContentEncoding,
+  resendIfEncodingRejected,
+  withContentEncoding,
+} from './lib/request-compression.mjs';
 import { traceAgentFetch } from '../agent-trace.mjs';
 import { PROVIDER_HTTP_RESPONSE_TIMEOUT_MS, createTimeoutSignal } from '../stall-policy.mjs';
 import { CODEX_REQUEST_RETRY_BACKOFF_MS, CODEX_RETRY_JITTER_RATIO } from './openai-retry-policy.mjs';
@@ -37,7 +46,6 @@ const OPENAI_REQUEST_RETRY_OPTS = Object.freeze({
   retryJitterRatio: CODEX_RETRY_JITTER_RATIO,
 });
 
-
 // Request-layer retry: 5xx and typed transport
 // failures only. 408 and 429 are NOT retried here; they surface to the outer
 // stream-retry layer, which owns their budget and honors Retry-After.
@@ -52,31 +60,29 @@ function isRetryableHttpFailure(err) {
 }
 // Request-body zstd gate. Namespace import: on Node runtimes without zlib
 // zstd bindings the named export would fail at module load, so the call site
-// typeof-guards zlib.zstdCompressSync instead.
-const OPENAI_REQ_ZSTD_MIN_BYTES = 8 * 1024;
-let _openaiReqZstdLatch = false;
-function _openaiReqZstdDisabled() {
-  return _openaiReqZstdLatch || process.env.MIXDOG_OPENAI_REQ_ZSTD === '0';
-}
-function _disableOpenaiReqZstd() {
-  _openaiReqZstdLatch = true;
-}
-function _zstdHeaders(headers, bodyForSend) {
-  return bodyForSend.encoding ? { ...headers, 'Content-Encoding': bodyForSend.encoding } : headers;
-}
+// typeof-guards zlib.zstdCompress instead.
+const _openaiReqZstdLatch = createCompressionLatch('MIXDOG_OPENAI_REQ_ZSTD');
+export const _resetOpenaiReqZstdLatchForTest = _openaiReqZstdLatch.reset;
 
 // Request-body zstd: compression is enabled for the codex backend on the
 // OpenAI provider — the server decompresses Content-Encoding: zstd.
-// openai-direct is excluded: only the codex backend is verified. Env
-// kill-switch plus a process-wide latch flipped on the first 400 seen on
-// a compressed request, which then replays that attempt uncompressed.
-function encodeRequestBody(auth, rawBytes) {
-  return auth?.type !== 'openai-direct' &&
-    !_openaiReqZstdDisabled() &&
-    typeof zlib.zstdCompressSync === 'function' &&
-    rawBytes.length >= OPENAI_REQ_ZSTD_MIN_BYTES
-    ? { bytes: zlib.zstdCompressSync(rawBytes), encoding: 'zstd' }
-    : { bytes: rawBytes, encoding: null };
+// openai-direct is excluded: only the codex backend is verified. Compression
+// runs on the libuv threadpool (zlib.zstdCompress, promisified) so it never
+// blocks the main thread; runtimes without the async zstd binding send plain.
+// Env kill-switch; the 400/415 resend + latch policy is shared
+// (lib/request-compression.mjs).
+async function encodeRequestBody(auth, headers, rawBytes) {
+  const plain = { bytes: rawBytes, encoding: null };
+  if (
+    auth?.type === 'openai-direct' ||
+    _openaiReqZstdLatch.disabled() ||
+    typeof zlib.zstdCompress !== 'function' ||
+    rawBytes.length < REQ_COMPRESSION_MIN_BYTES ||
+    hasContentEncoding(headers)
+  ) {
+    return plain;
+  }
+  return compressBody(rawBytes, promisify(zlib.zstdCompress), 'zstd');
 }
 
 async function postWithRetries({
@@ -91,15 +97,32 @@ async function postWithRetries({
   _sleepFn,
 }) {
   const label = httpLabel(auth);
-  let bodyForSend = encodeRequestBody(auth, rawBytes);
-  let response;
-  let httpError = null;
-  for (let attempt = 0; attempt <= CODEX_REQUEST_MAX_RETRIES; attempt++) {
+  const bodyForSend = await encodeRequestBody(auth, headers, rawBytes);
+  const fetchOnce = async (bytes, sendHeaders) => {
     const headerTimeout = createTimeoutSignal(
       totalTimeout.signal,
       PROVIDER_HTTP_RESPONSE_TIMEOUT_MS,
       `${label} initial response`
     );
+    try {
+      return await fetchFn(responsesUrl, {
+        method: 'POST',
+        headers: sendHeaders,
+        body: bytes,
+        signal: headerTimeout.signal,
+        dispatcher: getLlmDispatcher(),
+      });
+    } catch (err) {
+      throw headerTimeout.signal?.aborted && headerTimeout.signal.reason instanceof Error
+        ? headerTimeout.signal.reason
+        : err;
+    } finally {
+      headerTimeout.cleanup();
+    }
+  };
+  let response;
+  let httpError = null;
+  for (let attempt = 0; attempt <= CODEX_REQUEST_MAX_RETRIES; attempt++) {
     let requestError = null;
     try {
       // Keep the established stage name for consumers, while making each
@@ -113,32 +136,20 @@ async function postWithRetries({
           retry: attempt > 0,
         });
       } catch {}
-      response = await fetchFn(responsesUrl, {
-        method: 'POST',
-        headers: _zstdHeaders(headers, bodyForSend),
-        body: bodyForSend.bytes,
-        signal: headerTimeout.signal,
-        dispatcher: getLlmDispatcher(),
+      response = bodyForSend.encoding
+        ? await fetchOnce(bodyForSend.bytes, withContentEncoding(headers, bodyForSend.encoding))
+        : await fetchOnce(rawBytes, headers);
+      // Encoding rejection (400/415): resent uncompressed inside this attempt,
+      // so it never consumes a retry; the latch flips only if that succeeds.
+      response = await resendIfEncodingRejected({
+        response,
+        encoded: Boolean(bodyForSend.encoding),
+        resend: () => fetchOnce(rawBytes, headers),
+        latch: _openaiReqZstdLatch,
       });
     } catch (err) {
-      requestError =
-        headerTimeout.signal?.aborted && headerTimeout.signal.reason instanceof Error
-          ? headerTimeout.signal.reason
-          : err;
-    } finally {
-      headerTimeout.cleanup();
-    }
-
-    // zstd rejection fallback: a 400 on a compressed request latches
-    // compression OFF process-wide and replays this attempt uncompressed.
-    if (response && response.status === 400 && bodyForSend.encoding) {
-      _disableOpenaiReqZstd();
-      bodyForSend = { bytes: rawBytes, encoding: null };
-      await response.arrayBuffer().catch(() => {});
       response = undefined;
-      // The uncompressed replay is not a retry: it must not consume an attempt.
-      attempt--;
-      continue;
+      requestError = err;
     }
     // The error body is read exactly once, here, into the contract fields.
     httpError = null;
@@ -183,8 +194,9 @@ async function postWithRetries({
       // Uncapped for retryable errors; the attempt count is
       // the bound, and the abort signal cancels the wait.
       // The shared schedule carries a leading duplicate (withRetry convention).
-    const raw = OPENAI_REQUEST_RETRY_OPTS.backoffMs[attempt + 1];
-      const delayMs = retryAfterMsFromError(attemptFailure) ?? jitterDelayMs(raw, OPENAI_REQUEST_RETRY_OPTS.retryJitterRatio);
+      const raw = OPENAI_REQUEST_RETRY_OPTS.backoffMs[attempt + 1];
+      const delayMs =
+        retryAfterMsFromError(attemptFailure) ?? jitterDelayMs(raw, OPENAI_REQUEST_RETRY_OPTS.retryJitterRatio);
       emitProviderRetryStage(onStageChange, {
         attempt: attempt + 2,
         maxAttempts: CODEX_REQUEST_MAX_RETRIES + 1,

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

@@ -119,7 +119,9 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
       // 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`));
+      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;

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

@@ -254,7 +254,8 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
     pushReasoningItems(m, 'after');
   }
   flushToolMedia();
-  if (opts.reasoningByMessageIndex?.has(messages.length)) out.push(...opts.reasoningByMessageIndex.get(messages.length));
+  if (opts.reasoningByMessageIndex?.has(messages.length))
+    out.push(...opts.reasoningByMessageIndex.get(messages.length));
   out.push(...effortUpdates.end());
   // Wire-level pairing guard: replay envelopes can carry a call whose
   // result never committed (cancel/abort). The provider hard-rejects the

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

@@ -119,7 +119,13 @@ function responsesToolsList(tools, opts, nativeToolSearch) {
   // must be a valid 2020-12 object schema -- lowered when it is not, left out
   // and reported when it still is not.
   const sendable = tools?.length
-    ? acceptedWireTools(tools, 'openai', opts.onToolExcluded, `[${opts.promptCacheProvider || 'openai-oauth'}] tool`, isResponsesFreeformTool)
+    ? acceptedWireTools(
+        tools,
+        'openai',
+        opts.onToolExcluded,
+        `[${opts.promptCacheProvider || 'openai-oauth'}] tool`,
+        isResponsesFreeformTool
+      )
     : [];
   const functionTools = sendable.map((t) => toOpenAIResponsesTool(t, { nativeToolSearch }));
   const nativeTools = Array.isArray(opts.nativeTools) ? opts.nativeTools.filter((t) => t && typeof t === 'object') : [];

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

@@ -293,10 +293,7 @@ const TRANSPORT_ONLY_FRAME_FIELDS = new Set(['stream', 'background']);
 // response, so dropping them here strips the system/lead prompt from every
 // continuation turn. Only an empty instructions string is omitted.
 // Full frames pass the body unchanged and keep every key in place.
-export function _buildResponseCreateFrame(
-  body,
-  { previousResponseId = null, inputOverride } = {}
-) {
+export function _buildResponseCreateFrame(body, { previousResponseId = null, inputOverride } = {}) {
   const src = body && typeof body === 'object' ? body : {};
   if (previousResponseId == null && inputOverride === undefined) {
     const frame = { type: 'response.create' };

package/src/runtime/agent/orchestrator/providers/openai-ws-response-state/tool-calls.mjs

@@ -217,7 +217,6 @@ export function createWsToolCalls({ onToolCall, midState, replayItems }) {
     settle();
   }
 
-
   return {
     get calls() {
       return toolCalls;

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

@@ -29,10 +29,13 @@ import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { noteRequestServiceTier } from '../../../shared/llm/usage-context.mjs';
 import { resolveProviderCacheKey, resolveProviderPromptCacheLane } from '../agent-runtime/cache-strategy.mjs';
 
+function isUnsafeToRetry(err) {
+  return err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
+}
+
 function shouldFallbackDirectTransport(err, options) {
   const status = Number(err?.httpStatus || err?.status || 0);
-  const unsafeToRetry = err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
-  if (unsafeToRetry || options?.signal?.aborted || options?.enabled === false) return false;
+  if (isUnsafeToRetry(err) || options?.signal?.aborted || options?.enabled === false) return false;
   // Public OpenAI can reject the WebSocket upgrade while still supporting
   // the same request over HTTP/SSE. Only the shared transport's explicit
   // handshake marker may turn these application-looking statuses into a
@@ -205,8 +208,7 @@ export class OpenAIDirectProvider {
       try {
         return await sendHttp({ ...common, auth: a, opts, fetchFn: opts._fetchFn });
       } catch (err) {
-        const unsafe = err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
-        if (!reload || err?.httpStatus !== 401 || unsafe) throw err;
+        if (!reload || err?.httpStatus !== 401 || isUnsafeToRetry(err)) throw err;
         // The replay discards this attempt; its reported usage stays billed.
         noteErrorUsage(err);
         process.stderr.write('[openai-ws] 401 — reloading apiKey and retrying once over HTTP\n');
@@ -252,8 +254,7 @@ export class OpenAIDirectProvider {
       const status = err?.httpStatus;
       // Live-text/tool invariant: never reissue a turn that already
       // relayed visible output or dispatched a tool call.
-      const unsafeToRetry =
-        err?.liveTextEmitted === true || err?.emittedToolCall === true || err?.unsafeToRetry === true;
+      const unsafeToRetry = isUnsafeToRetry(err);
       // (1) 401 → reload only OpenAI auth and retry once over WS.
       // Ordinary 403 is a permission/policy decision, not evidence that
       // an API key rotated. Match the OAuth path and keep it terminal.