mixdog 1.3.5 → 1.4.0

package/src/runtime/agent/orchestrator/providers/cursor-wire-transport.mjs

@@ -5,6 +5,7 @@ import http2 from 'node:http2';
 import { MAX_CONNECT_FRAME_BYTES, createCursorByteQueue } from './cursor-wire-guards.mjs';
 import { cursorClientVersion, warmCursorClientVersion } from './cursor-client-version.mjs';
 import { retryAfterMsFromError } from './retry-classifier.mjs';
+import { providerTimeoutError } from '../stall-policy.mjs';
 
 export { warmCursorClientVersion };
 
@@ -153,7 +154,9 @@ export function openCursorStream({ accessToken, path = RUN_PATH, url = API_URL }
     if (closed || session.closed || session.destroyed) return;
     try {
       session.ping(() => {});
-    } catch {}
+    } catch {
+      // the session may have closed since the check above
+    }
   }, H2_PING_INTERVAL_MS);
   ping.unref?.();
 
@@ -175,20 +178,28 @@ export function openCursorStream({ accessToken, path = RUN_PATH, url = API_URL }
     closeError = error || (status >= 400 ? httpStatusError(status, responseHeaders) : null);
     try {
       request.close();
-    } catch {}
+    } catch {
+      // the request stream may already be closed
+    }
     try {
       session.close();
-    } catch {}
+    } catch {
+      // the session may already be closed
+    }
     closeHandler?.(closeError);
   };
   const close = (error = null) => {
     if (closed) return;
     try {
       request.close(http2.constants.NGHTTP2_CANCEL);
-    } catch {}
+    } catch {
+      // the request stream may already be closed
+    }
     try {
       session.destroy();
-    } catch {}
+    } catch {
+      // the session may already be destroyed
+    }
     finish(error);
   };
 
@@ -243,17 +254,21 @@ export async function callCursorUnary({ accessToken, path, body, url = API_URL,
     let status = 0;
     let responseHeaders = null;
     let settled = false;
-    const timeout = setTimeout(() => finish(new Error('Cursor request timed out')), timeoutMs);
+    const timeout = setTimeout(() => finish(providerTimeoutError('Cursor request', timeoutMs)), timeoutMs);
     const finish = (error = null) => {
       if (settled) return;
       settled = true;
       clearTimeout(timeout);
       try {
         request.close();
-      } catch {}
+      } catch {
+        // the request stream may already be closed
+      }
       try {
         session.close();
-      } catch {}
+      } catch {
+        // the session may already be closed
+      }
       if (error) reject(error);
       else if (status >= 400) reject(httpStatusError(status, responseHeaders));
       else resolve(Buffer.concat(chunks));
@@ -322,7 +337,8 @@ export function parseEndStream(bytes) {
     if (!payload?.error) return null;
     const connectCode = String(payload.error.code || 'error').toLowerCase();
     const detail = String(payload.error.message || 'request failed');
-    const tooLarge = connectCode === 'resource_exhausted' && !THROTTLE_CUE_RE.test(detail) && REQUEST_TOO_LARGE_RE.test(detail);
+    const tooLarge =
+      connectCode === 'resource_exhausted' && !THROTTLE_CUE_RE.test(detail) && REQUEST_TOO_LARGE_RE.test(detail);
     const retryAfter =
       payload.error.retryAfter ??
       payload.error.retry_after ??

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

@@ -132,7 +132,9 @@ async function* responseSseEvents(response, signal) {
     if (signal) {
       try {
         signal.removeEventListener('abort', onAbort);
-      } catch {}
+      } catch {
+        // the abort listener may already be gone
+      }
     }
     if (aborted) await reader.cancel().catch(() => {});
   }
@@ -480,16 +482,10 @@ function selectParameterizedCursorVariant(group, requested, sendOpts = {}) {
     availableVariants[0] ||
     null;
   const parameters = { ...(defaultVariant?.parameters || {}), ...aliasParameters };
+  const defaultContext = parameters.context;
   const routeParameters =
     sendOpts.modelParameters && typeof sendOpts.modelParameters === 'object' ? sendOpts.modelParameters : {};
-  // The window picked the mode above: a stored `context` no variant of that
-  // mode offers (a 256k left beside a raised 500K window) is a stale value and
-  // yields to the mode's own; one the mode offers stays the user's choice.
-  const staleContext =
-    Object.hasOwn(routeParameters, 'context') &&
-    !availableVariants.some((variant) => String(variant.parameters?.context ?? '') === String(routeParameters.context));
   for (const definition of group.definitions) {
-    if (staleContext && definition.id === 'context') continue;
     if (Object.hasOwn(routeParameters, definition.id)) {
       parameters[definition.id] = String(routeParameters[definition.id]);
     }
@@ -508,9 +504,18 @@ function selectParameterizedCursorVariant(group, requested, sendOpts = {}) {
   ) {
     parameters.fast = sendOpts.fast === true ? 'true' : 'false';
   }
-  const selected = availableVariants.find((variant) =>
-    Object.entries(parameters).every(([id, value]) => String(variant.parameters?.[id] ?? '') === String(value))
-  );
+  const matches = (variant) =>
+    Object.entries(parameters).every(([id, value]) => String(variant.parameters?.[id] ?? '') === String(value));
+  let selected = availableVariants.find(matches);
+  // Keep a supported explicit context. A persisted context can exist in this
+  // mode but conflict with its requested effort/fast/other options. In that
+  // case try only the mode's default context, preserving every other choice
+  // and still rejecting the request unless the full combination is offered.
+  if (!selected && Object.hasOwn(routeParameters, 'context')) {
+    if (defaultContext === undefined) delete parameters.context;
+    else parameters.context = defaultContext;
+    selected = availableVariants.find(matches);
+  }
   if (!selected && availableVariants.length) {
     throw new Error(`Cursor model ${group.id} does not offer the selected parameter combination`);
   }
@@ -649,7 +654,9 @@ class CursorProviderBase {
     let emittedToolCall = false;
     try {
       sendOpts.onStageChange?.('requesting');
-    } catch {}
+    } catch {
+      // the stage observer is advisory
+    }
     try {
       const response = await runtime.handleChatCompletion(body, accessToken, {
         onStageChange: sendOpts.onStageChange,
@@ -664,7 +671,9 @@ class CursorProviderBase {
       });
       try {
         sendOpts.onStageChange?.('streaming');
-      } catch {}
+      } catch {
+        // the stage observer is advisory
+      }
       return await consumeCompatChatCompletionStream(responseSseEvents(response, signal), {
         signal,
         label: this.name,

package/src/runtime/agent/orchestrator/providers/lib/oauth-token-utils.mjs

@@ -67,10 +67,10 @@ export function sameAccountIdentity(a, b) {
   return Boolean(left.email && right.email && left.email.toLowerCase() === right.email.toLowerCase());
 }
 
-// expires_at may arrive as a unix number (seconds or milliseconds) or an
-// ISO-8601 string. Normalize to epoch milliseconds; 0 means unknown.
+// expires_at may arrive as a unix number (seconds or milliseconds), a numeric
+// string, or an ISO-8601 string. Normalize to epoch milliseconds; 0 means unknown.
 export function normalizeExpiresAtMs(value) {
-  if (typeof value === 'string') {
+  if (typeof value === 'string' && !Number.isFinite(Number(value.trim() || NaN))) {
     const ms = Date.parse(value);
     return Number.isFinite(ms) ? ms : 0;
   }
@@ -79,6 +79,20 @@ export function normalizeExpiresAtMs(value) {
   return n < 1e12 ? n * 1000 : n;
 }
 
+/**
+ * Whether a stored `{ access_token, refresh_token?, expires_at }` document is a
+ * sign-in: it can refresh, or its access token is known to be unexpired. A copy
+ * made without a refresh token (an isolated dev instance, so it cannot rotate
+ * the original's) coasts on the access token until then; one with no known
+ * expiry and no refresh token is incomplete, not a sign-in.
+ */
+export function isSignedInTokenDocument(raw) {
+  if (!raw?.access_token) return false;
+  if (raw.refresh_token) return true;
+  const expiresAt = normalizeExpiresAtMs(raw.expires_at ?? raw.expiresAt) || expiryFromAccessToken(raw.access_token);
+  return expiresAt > Date.now();
+}
+
 /**
  * Status record for a stored OAuth credential that has an access token.
  * `expiresAt` is epoch ms (0 = unknown); `detail` labels the credential source.

package/src/runtime/agent/orchestrator/providers/media-normalization.mjs

@@ -274,7 +274,7 @@ function* walkContentParts(content) {
  * beforehand by preparePdfTextForProvider, so one reaching here is a bug.
  * Null when the part is not a file at all.
  */
-export function textFormOfFilePart(part) {
+function textFormOfFilePart(part) {
   if (part?.type !== 'file' && part?.type !== 'document') return null;
   try {
     const file = fileInfo(part);
@@ -840,6 +840,56 @@ function partCarriesLiveMedia(part) {
   return Array.isArray(part.content) && contentCarriesLiveMedia(part.content);
 }
 
+/** An image part in any spelling the providers use: inline, URL, file id or
+ *  URI, Gemini inline data. */
+function isImagePart(part) {
+  return Boolean(
+    part.type === 'image' ||
+      part.type === 'image_url' ||
+      part.type === 'input_image' ||
+      imageUrlFromPart(part) ||
+      imageFileIdFromPart(part) ||
+      imageFileUriFromPart(part) ||
+      geminiInlineInfo(part)
+  );
+}
+
+function mapPartText(part, mapText) {
+  if (typeof part === 'string') return mapText(part);
+  if (!part || typeof part !== 'object') return part;
+  // Media and attachment references are encodings, never text.
+  if (isAttachmentReference(part) || isImagePart(part) || fileInfo(part)) return part;
+  for (const key of ['text', 'content']) {
+    if (typeof part[key] === 'string') {
+      const next = mapText(part[key]);
+      return next === part[key] ? part : { ...part, [key]: next };
+    }
+  }
+  if (Array.isArray(part.content)) {
+    const nextContent = mapContentText(part.content, mapText);
+    if (nextContent !== part.content) return { ...part, content: nextContent };
+  }
+  return part;
+}
+
+/** `content` with `mapText` applied to its text and nothing else: a string,
+ *  the text a text part or a part's string content carries (textFromPart),
+ *  and nested part content; media parts and attachment references stay as
+ *  they are. The same value when nothing changed. */
+export function mapContentText(content, mapText) {
+  if (typeof content === 'string') return mapText(content);
+  const parts = contentParts(content);
+  if (!parts) return content;
+  let changed = false;
+  const out = parts.map((part) => {
+    const next = mapPartText(part, mapText);
+    if (next !== part) changed = true;
+    return next;
+  });
+  if (!changed) return content;
+  return Array.isArray(content) ? out : { ...content, content: out };
+}
+
 function sanitizePartForStoredHistory(part) {
   if (typeof part === 'string') return part;
   if (!part || typeof part !== 'object') return part;
@@ -849,15 +899,7 @@ function sanitizePartForStoredHistory(part) {
   // reloading the session keeps the provider prompt cache intact.
   const storedImage = part.type === 'image' ? storedImagePart(part) : null;
   if (storedImage) return storedImage;
-  if (
-    part.type === 'image' ||
-    part.type === 'image_url' ||
-    part.type === 'input_image' ||
-    imageUrlFromPart(part) ||
-    imageFileIdFromPart(part) ||
-    imageFileUriFromPart(part) ||
-    geminiInlineInfo(part)
-  ) {
+  if (isImagePart(part)) {
     return { type: 'text', text: storedHistoryImagePlaceholder(part) };
   }
   const file = fileInfo(part);

package/src/runtime/agent/orchestrator/providers/model-proxy-channel.d.mts

@@ -5,7 +5,14 @@ export const MODEL_PROXY_OPERATIONS: Readonly<{
   resolve: 'modelProxyResolve';
   heartbeat: 'modelProxyHeartbeat';
 }>;
-export type ModelProxyMethod = 'send' | 'listModels' | 'refreshModels' | 'isAvailable' | 'resolveWireRoute' | 'providerConfig';
+export type ModelProxyMethod =
+  | 'send'
+  | 'listModels'
+  | 'refreshModels'
+  | 'isAvailable'
+  | 'quotaUsable'
+  | 'resolveWireRoute'
+  | 'providerConfig';
 export const MODEL_PROXY_METHODS: ReadonlyArray<ModelProxyMethod>;
 export const MODEL_PROXY_HEARTBEAT_MS: number;
 export const MODEL_PROXY_LEASE_MS: number;

package/src/runtime/agent/orchestrator/providers/model-proxy-channel.mjs

@@ -34,6 +34,7 @@ export const MODEL_PROXY_METHODS = Object.freeze([
   'listModels',
   'refreshModels',
   'isAvailable',
+  'quotaUsable',
   'resolveWireRoute',
   'providerConfig',
 ]);

package/src/runtime/agent/orchestrator/providers/npm-cli-version.mjs

@@ -8,6 +8,7 @@
 // so a new process (or an offline one) starts from the newest version this
 // machine has seen rather than from a floor that only moves with a release.
 
+import { runAbortable } from '../../../shared/abort-race.mjs';
 import { readLastKnownVersion, rememberLastKnownVersion } from './client-version-store.mjs';
 
 const SEMVER = /^\d+\.\d+\.\d+$/;
@@ -41,11 +42,18 @@ export async function parseNpmLatest(res) {
   return SEMVER.test(v) ? v : null;
 }
 
-/** One GET of `url` parsed to a version; null when offline, slow, or unrecognised. */
+/** One GET of `url` parsed to a version; null when offline, slow, or unrecognised.
+ *  The deadline settles the lookup itself instead of relying on the request
+ *  and its body read to honour the abort: a send awaits this lookup, and its
+ *  timer is unref'd, so once the abort tears the socket down nothing else is
+ *  left to wake a read that missed it. */
 export async function fetchRemoteVersion(url, parse, timeoutMs = TIMEOUT_MS) {
+  const signal = AbortSignal.timeout(timeoutMs);
   try {
-    const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
-    return res.ok ? (await parse(res)) || null : null;
+    return await runAbortable(signal, async () => {
+      const res = await fetch(url, { signal });
+      return res.ok ? (await parse(res)) || null : null;
+    });
   } catch {
     return null;
   }

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -5,6 +5,7 @@ import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { cursorTokenExpiry } from './cursor-auth.mjs';
 import { describeDevinOAuthCredentials } from './devin-auth.mjs';
+import { isSignedInTokenDocument } from './lib/oauth-token-utils.mjs';
 import { isValidMuseCredentialDocument } from './muse-code-oauth-tokens.mjs';
 import { isValidOpenCodeGoCredentialDocument } from './opencode-go-oauth-tokens.mjs';
 import { developerOptionEnabled, developerOptionForProvider } from '../../../shared/developer-options.mjs';
@@ -152,7 +153,7 @@ function openAIOAuthState() {
       join(resolvePluginData(), 'openai-oauth.json'),
   ];
   return memoProbe('openai-oauth', paths, () =>
-    resolveProbeState(paths, (docs) => docs.some((raw) => !!(raw?.access_token && raw?.refresh_token)))
+    resolveProbeState(paths, (docs) => docs.some((raw) => isSignedInTokenDocument(raw)))
   );
 }
 

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

@@ -18,12 +18,15 @@ import { getPluginData } from '../config.mjs';
 import { writeJsonAtomicSync, withFileLock } from '../../../shared/atomic-file.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
+import { TIMEOUT_PHASE } from '../../../shared/provider-timeout-phase.mjs';
 import { modelProxyClientMode, serverModelCredentialsDisabledError } from '../../../shared/model-proxy-mode.mjs';
 import {
   accountIdentityFields,
   decodeJwtPayload,
   expiryFromAccessToken,
+  isSignedInTokenDocument,
   normalizeAccountIdentity,
+  normalizeExpiresAtMs,
   oauthCredentialStatus,
 } from './lib/oauth-token-utils.mjs';
 import { createOpenAIOAuthLogin } from './openai-oauth-login.mjs';
@@ -60,11 +63,8 @@ function getRefreshLockPath() {
   return `${getOwnTokenPath()}.refresh.lock`;
 }
 
-function _normalizeExpiresAt(value) {
-  const n = Number(value || 0);
-  if (!Number.isFinite(n) || n <= 0) return 0;
-  return n < 1e12 ? n * 1000 : n;
-}
+// One normalizer for the store and the sign-in predicate (isSignedInTokenDocument).
+const _normalizeExpiresAt = normalizeExpiresAtMs;
 
 export function extractAccountId(token) {
   return decodeJwtPayload(token)?.['https://api.openai.com/auth']?.chatgpt_account_id;
@@ -117,7 +117,7 @@ export function loadTokens() {
   try {
     const stat = statSync(ownPath);
     const own = JSON.parse(readFileSync(ownPath, 'utf-8'));
-    if (own.access_token && own.refresh_token) {
+    if (isSignedInTokenDocument(own)) {
       const identity = identityFromTokens(own.id_token, own.access_token);
       return {
         ...own,
@@ -144,8 +144,7 @@ export function saveTokens(tokens) {
 // same loader the runtime uses (loadTokens), no parallel hard-coded path probe.
 export function hasOpenAIOAuthCredentials() {
   try {
-    const tokens = loadTokens();
-    return !!(tokens?.access_token && tokens?.refresh_token);
+    return !!loadTokens()?.access_token;
   } catch {
     return false;
   }
@@ -256,7 +255,9 @@ async function exchangeRefreshToken(refreshToken, previousIdentity = null) {
     return tokens;
   } catch (err) {
     if (err?.name === 'AbortError')
-      throw new Error(`OpenAI OAuth token refresh timed out after ${TOKEN_REFRESH_TIMEOUT_MS}ms`);
+      throw Object.assign(new Error(`OpenAI OAuth token refresh timed out after ${TOKEN_REFRESH_TIMEOUT_MS}ms`), {
+        timeoutPhase: TIMEOUT_PHASE.AUTH,
+      });
     throw err;
   } finally {
     clearTimeout(timeout);

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

@@ -7,13 +7,17 @@ import { createStreamSafetyStamps, resolveStallRetryBudget } from '../retry-clas
 import { _codexWsCompatibilityHeaders } from '../openai-codex-metadata.mjs';
 import { createWsSendAttempts } from '../openai-ws-send-attempts.mjs';
 import { createWsSendSpan } from '../openai-ws-send-span.mjs';
+import { emitProviderRetryStage } from '../retry-executor.mjs';
+import { retryReasonClass } from '../provider-error-kind.mjs';
 
 /** Stage callbacks are observers; a throwing one never fails the send. */
 export function notifyStage(onStageChange, stage, detail) {
   try {
     if (detail === undefined) onStageChange?.(stage);
     else onStageChange?.(stage, detail);
-  } catch {}
+  } catch {
+    // the stage observer is advisory
+  }
 }
 
 export function createWsSendContext(opts) {
@@ -81,10 +85,24 @@ export function createWsSendContext(opts) {
   // Single caller-visible recovery path for both handshake/acquire retries
   // and retryable stream failures. The session/TUI stage bridge renders this
   // as non-terminal reconnect progress; transport code must not also print it
-  // to stderr.
-  const emitReconnectProgress = ({ attempt, max, classifier }) => {
+  // to stderr. A retry that knows its failure carries the reason and the wait
+  // (retryAt), so a long server-advised wait counts down with its cause
+  // instead of sitting silently at "n/max".
+  const emitReconnectProgress = ({ attempt, max, classifier, error = null, waitMs = 0 }) => {
     const retryAttempt = Number(attempt) || 1;
     const retryMax = Number(max) || 1;
+    if (error) {
+      // The reason shown is the fixed class, never the server's own text.
+      emitProviderRetryStage(onStageChange, {
+        attempt: retryAttempt,
+        maxAttempts: retryMax,
+        lastErr: error,
+        delayMs: waitMs,
+        classifier,
+        reasonClass: retryReasonClass(error),
+      });
+      return;
+    }
     notifyStage(onStageChange, 'reconnecting', {
       attempt: retryAttempt,
       max: retryMax,
@@ -105,6 +123,7 @@ export function createWsSendContext(opts) {
     retry429,
     stallRetryBudget,
     trace: { poolKey, traceProvider, useModel },
+    traceFn: _agentTraceFn,
     auth,
     body,
   });

package/src/runtime/agent/orchestrator/providers/openai-ws-send-attempts/attempt-context.mjs

@@ -3,7 +3,34 @@
  * WS send, plus the surface/backoff primitives both failure resolvers use.
  */
 import { performance } from 'node:perf_hooks';
+import { appendAgentTrace } from '../../agent-trace.mjs';
 import { _sleepWithAbort, MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT, midstreamBackoffFor, tag } from './policy.mjs';
+import { retryReasonClass, safeRetryErrorCode } from '../provider-error-kind.mjs';
+
+/** One row per WS retry: the server's typed verdict (status, close code, an
+ *  identifier-shaped code, the reason class) and the wait it bought, so a
+ *  long advised wait is diagnosable after the fact. Never the server's free
+ *  text: it can echo request content. Diagnostics only; never throws. */
+function traceRetry(traceFn, trace, err, { attempt, max, classifier, waitMs }) {
+  try {
+    const payload = {
+      provider: trace?.traceProvider || null,
+      model: trace?.useModel || null,
+      transport: 'websocket',
+      attempt,
+      max,
+      classifier: classifier || null,
+      reason: retryReasonClass(err),
+      wait_ms: Math.round(Number(waitMs) || 0),
+      http_status: Number(err?.httpStatus || err?.status || 0) || null,
+      code: safeRetryErrorCode(err),
+      ws_close_code: Number(err?.wsCloseCode || 0) || null,
+    };
+    traceFn({ sessionId: trace?.poolKey || null, kind: 'ws_retry', ...payload, payload });
+  } catch {
+    // the retry trace sink is advisory
+  }
+}
 
 export function createAttemptContext(deps) {
   const { sendSpan, externalSignal, sleepFn, safetyStamps } = deps;
@@ -31,10 +58,13 @@ export function createAttemptContext(deps) {
   };
   // Server advice (Retry-After, or a typed rate limit's "try again in")
   // replaces the local curve, like the reference client's retry deadline.
-  const backoff = async (retryNumber, err = null) => {
+  // Resolved before the retry is announced so the reconnect stage can name
+  // the wait it is about to sit through.
+  const retryWaitMs = (retryNumber, err = null) => midstreamBackoffFor(retryNumber, err);
+  const backoff = async (waitMs) => {
     const sleepStart = performance.now();
     try {
-      await _sleepWithAbort(midstreamBackoffFor(retryNumber, err), externalSignal, sleepFn);
+      await _sleepWithAbort(waitMs, externalSignal, sleepFn);
     } catch (sleepErr) {
       sendSpan.retryBackoffMs += performance.now() - sleepStart;
       sendSpan.emit('error');
@@ -53,14 +83,21 @@ export function createAttemptContext(deps) {
     }
     return first;
   };
-  /** Stash the error a retry is about to leave behind and announce the retry. */
-  const scheduleRetry = (err, { attemptIndex, classifier, retryLimit, remember }) => {
+  /** Stash the error a retry is about to leave behind and announce the retry
+   *  with its cause and the wait before the next attempt. */
+  const scheduleRetry = (err, { attemptIndex, classifier, retryLimit, remember, waitMs = 0 }) => {
     if (remember) {
       state.firstAttemptError = err;
       state.firstAttemptClassifier = classifier;
     }
     tag(err, { midstreamClassifier: classifier });
-    deps.emitReconnectProgress({ attempt: attemptIndex + 1, max: retryLimit, classifier });
+    deps.emitReconnectProgress({ attempt: attemptIndex + 1, max: retryLimit, classifier, error: err, waitMs });
+    traceRetry(deps.traceFn || appendAgentTrace, deps.trace, err, {
+      attempt: attemptIndex + 1,
+      max: retryLimit,
+      classifier,
+      waitMs,
+    });
   };
 
   return {
@@ -69,6 +106,7 @@ export function createAttemptContext(deps) {
     maxMidstreamRetries: MIDSTREAM_WS_TRANSIENT_RETRY_LIMIT,
     stampAll,
     surface,
+    retryWaitMs,
     backoff,
     surfaceFirstAttempt,
     scheduleRetry,

package/src/runtime/agent/orchestrator/providers/openai-ws-send-attempts/handshake-failure.mjs

@@ -81,13 +81,15 @@ export async function resolveHandshakeFailure(
   const retryable =
     classifier && status !== 401 && status !== 426 && err?.unsafeToRetry !== true && !externalSignal?.aborted;
   if (retryable && attemptIndex < ctx.maxMidstreamRetries) {
+    const waitMs = ctx.retryWaitMs(attemptIndex + 1, err);
     ctx.scheduleRetry(err, {
       attemptIndex,
       classifier,
       retryLimit: ctx.maxMidstreamRetries,
       remember: !state.firstAttemptError,
+      waitMs,
     });
-    await ctx.backoff(attemptIndex + 1, err);
+    await ctx.backoff(waitMs);
     return true;
   }
   // A later auth/upgrade decision must win over an earlier transient

package/src/runtime/agent/orchestrator/providers/openai-ws-send-attempts/stream-failure.mjs

@@ -77,7 +77,9 @@ export async function resolveStreamFailure(ctx, err, { attemptIndex, entry, midS
       process.stderr.write(
         `[openai-oauth] stall retry budget exhausted (${STREAM_STALL_RETRY_BUDGET_MS}ms since first stall) — surfacing provider-terminal failure\n`
       );
-    } catch {}
+    } catch {
+      // diagnostic write only; the provider-terminal failure is thrown next
+    }
     throw ctx.surface(markProviderRecoveryExhausted(err, { owner: 'openai-oauth-ws-stall-budget' }));
   }
   const retryLimit = classifier ? midstreamRetryLimit(classifier) : 0;
@@ -89,8 +91,9 @@ export async function resolveStreamFailure(ctx, err, { attemptIndex, entry, midS
       state.carryForwardCache = null;
       tag(entry, { lastResponseId: null });
     }
-    ctx.scheduleRetry(err, { attemptIndex, classifier, retryLimit, remember: true });
-    await ctx.backoff(attemptIndex + 1, err);
+    const waitMs = ctx.retryWaitMs(attemptIndex + 1, err);
+    ctx.scheduleRetry(err, { attemptIndex, classifier, retryLimit, remember: true, waitMs });
+    await ctx.backoff(waitMs);
     return true;
   }
   // Not retryable, OR we've already exhausted the retry budget. Do not