mixdog 0.8.1 → 0.9.1

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

@@ -1,7 +1,7 @@
 /**
  * OpenAI Direct API — WebSocket transport via Responses API.
  *
- * Uses the same `sendViaWebSocket` plumbing as openai-oauth (Codex), with two
+ * Uses the same `sendViaWebSocket` plumbing as openai-oauth, with two
  * differences encoded in the `auth.type === 'openai-direct'` branch inside
  * openai-oauth-ws.mjs:
  *   1. Authorization header: Bearer <OPENAI_API_KEY> (no account_id, no
@@ -18,7 +18,7 @@ import { enrichModels } from './model-catalog.mjs';
 import {
     resolveProviderCacheKey,
     resolveProviderPromptCacheLane,
-} from '../smart-bridge/cache-strategy.mjs';
+} from '../agent-runtime/cache-strategy.mjs';
 
 const OPENAI_DIRECT_PRIORITY_MODEL_PATTERNS = Object.freeze([
     /^gpt-5\.5(?:-\d{4}|$)/,
@@ -67,13 +67,13 @@ export class OpenAIDirectProvider {
             promptCacheLane,
         });
         // Public OpenAI API priority support is documented separately from the
-        // Codex OAuth catalog. Keep this provider's service-tier decision local
-        // so gpt-5.4-mini can opt into Priority even when the Codex catalog does
+        // openai-oauth catalog. Keep this provider's service-tier decision local
+        // so gpt-5.4-mini can opt into Priority even when the OAuth catalog does
         // not advertise a Fast tier for its OAuth endpoint.
         applyOpenAIDirectFastTier(body, useModel, opts);
         // Public Responses API supports prompt_cache_retention='24h' at no
         // extra cost (same cached_input_tokens billing as the default 5–10
-        // min in-memory cache). Codex/oauth rejects the parameter, so it's
+        // min in-memory cache). openai-oauth rejects the parameter, so it's
         // injected only on the direct path. See openai-oauth.mjs:290-294
         // for the rationale.
         body.prompt_cache_retention = '24h';
@@ -85,7 +85,7 @@ export class OpenAIDirectProvider {
         // cacheKey (prompt_cache_key) only groups the server-side prefix-cache
         // shard — safe to share across sessions, unlike the sessionId poolKey
         // above. buildRequestBody derives it from the base namespace plus a
-        // model/system/tools hash, mirroring the Codex OAuth path while keeping
+        // model/system/tools hash, mirroring the openai-oauth path while keeping
         // public OpenAI's 24h retention below.
         const cacheKey = body.prompt_cache_key || resolveProviderCacheKey(opts, 'openai');
         const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;

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

@@ -1,21 +1,30 @@
-import { OpenAICompatProvider, OPENAI_COMPAT_PRESETS } from './openai-compat.mjs';
-import { AnthropicProvider } from './anthropic.mjs';
-import { OpenCodeGoProvider } from './opencode-go.mjs';
-import { GeminiProvider } from './gemini.mjs';
-import { OpenAIOAuthProvider, hasOpenAIOAuthCredentials } from './openai-oauth.mjs';
-import { AnthropicOAuthProvider, hasAnthropicOAuthCredentials } from './anthropic-oauth.mjs';
-import { GrokOAuthProvider, hasGrokOAuthCredentials } from './grok-oauth.mjs';
-import { OpenAIDirectProvider } from './openai-ws.mjs';
+import { OPENAI_COMPAT_PRESETS } from './openai-compat-presets.mjs';
+import {
+    hasAnthropicOAuthCredentials,
+    hasOpenAIOAuthCredentials,
+    hasGrokOAuthCredentials,
+} from './oauth-credential-probes.mjs';
 import { refreshCatalog as refreshMetadataCatalog, warmModelMetadataCatalogs } from './model-catalog.mjs';
-// OpenAI-compat provider names are self-declared by openai-compat.mjs via
+// OpenAI-compat provider names are self-declared by openai-compat-presets.mjs via
 // OPENAI_COMPAT_PRESETS. No parallel list maintained here.
 const providers = new Map();
+const providerCtors = new Map();
+const providerModulePromises = new Map();
 // Parallel map: provider name -> signature of the config it was built from.
 // Lets initProviders() skip reconstructing a provider whose config is byte-for-
 // byte identical to the live one, so lazy-init misses that re-run initProviders
 // don't churn (tear down + rebuild) every live provider instance on every call.
 const signatures = new Map();
 
+// Module-level init serialization. agent-tool.mjs's ensureProvider() already
+// serializes inits per provider on a chain promise, but its gateOnPrior() lets
+// a queued init PROCEED once a 120s gate expires even if the prior init has
+// not settled — so a slow-but-still-running init and a newer one can reach
+// initProviders() concurrently. This chain makes the clear()+rebuild section
+// strictly sequential at the registry level, independent of any caller gating,
+// so two different config signatures can never interleave their rebuilds.
+let _initChain = Promise.resolve();
+
 // Deterministic structural signature of a provider config. Recursively sorts
 // object keys so signature equality reflects config-value equality regardless
 // of key insertion order. Invariant: same config in -> same string out.
@@ -37,7 +46,51 @@ function configSignature(cfg) {
         return null;
     }
 }
+
+async function loadProviderExport(cacheKey, spec, exportName) {
+    if (!providerModulePromises.has(cacheKey)) {
+        providerModulePromises.set(cacheKey, import(spec));
+    }
+    const mod = await providerModulePromises.get(cacheKey);
+    const value = mod?.[exportName];
+    if (typeof value !== 'function') throw new Error(`provider export missing: ${exportName}`);
+    providerCtors.set(cacheKey, value);
+    return value;
+}
+
+async function loadProviderCtor(name) {
+    if (name === 'anthropic') return loadProviderExport('anthropic', './anthropic.mjs', 'AnthropicProvider');
+    if (name === 'gemini') return loadProviderExport('gemini', './gemini.mjs', 'GeminiProvider');
+    if (name === 'openai-oauth') return loadProviderExport('openai-oauth', './openai-oauth.mjs', 'OpenAIOAuthProvider');
+    if (name === 'anthropic-oauth') return loadProviderExport('anthropic-oauth', './anthropic-oauth.mjs', 'AnthropicOAuthProvider');
+    if (name === 'grok-oauth') return loadProviderExport('grok-oauth', './grok-oauth.mjs', 'GrokOAuthProvider');
+    if (name === 'openai') return loadProviderExport('openai', './openai-ws.mjs', 'OpenAIDirectProvider');
+    if (name === 'opencode-go') return loadProviderExport('opencode-go', './opencode-go.mjs', 'OpenCodeGoProvider');
+    if (Object.prototype.hasOwnProperty.call(OPENAI_COMPAT_PRESETS, name)) {
+        return loadProviderExport('openai-compat', './openai-compat.mjs', 'OpenAICompatProvider');
+    }
+    throw new Error(`unknown enabled provider: ${name}`);
+}
+
+function instantiateProvider(name, Ctor, cfg) {
+    if (Object.prototype.hasOwnProperty.call(OPENAI_COMPAT_PRESETS, name) && name !== 'opencode-go') {
+        return new Ctor(name, cfg);
+    }
+    return new Ctor(cfg);
+}
+
 export async function initProviders(config) {
+    // Serialize ALL inits through a single chain so two different config
+    // signatures can never run their clear()+rebuild concurrently, regardless
+    // of caller-side gating (agent-tool gateOnPrior may release a queued init
+    // before the prior one settled). Errors do not poison the chain.
+    const run = () => _initProvidersUnsynchronized(config);
+    const next = _initChain.then(run, run);
+    _initChain = next.then(() => {}, () => {});
+    return next;
+}
+
+async function _initProvidersUnsynchronized(config) {
     // Invariant: never wipe the live registry based on an empty / all-disabled
     // config. Without this guard, a stale `loadAgentConfig()` (e.g. mid-reload
     // or a transient FS hiccup) would land here as `{}` or `{...,enabled:false}`,
@@ -51,54 +104,30 @@ export async function initProviders(config) {
     }
     const next = new Map();
     const nextSignatures = new Map();
-    for (const [name, cfg] of entries) {
-        if (!cfg.enabled)
-            continue;
+    const enabledResults = await Promise.all(entries.map(async ([name, cfg]) => {
+        if (!cfg.enabled) return null;
         // Idempotent reuse: an enabled provider whose config signature is
         // unchanged from the live registry is carried forward as-is. Only
         // added or changed providers are (re)constructed below.
         const sig = configSignature(cfg);
         if (sig !== null && providers.has(name) && signatures.get(name) === sig) {
-            next.set(name, providers.get(name));
-            nextSignatures.set(name, sig);
-            continue;
+            return { name, inst: providers.get(name), sig };
         }
         try {
-            let inst;
-            if (name === 'anthropic') {
-                inst = new AnthropicProvider(cfg);
-            }
-            else if (name === 'gemini') {
-                inst = new GeminiProvider(cfg);
-            }
-            else if (name === 'openai-oauth') {
-                inst = new OpenAIOAuthProvider(cfg);
-            }
-            else if (name === 'anthropic-oauth') {
-                inst = new AnthropicOAuthProvider(cfg);
-            }
-            else if (name === 'grok-oauth') {
-                inst = new GrokOAuthProvider(cfg);
-            }
-            else if (name === 'openai') {
-                inst = new OpenAIDirectProvider(cfg);
-            }
-            else if (name === 'opencode-go') {
-                inst = new OpenCodeGoProvider(cfg);
-            }
-            else if (Object.prototype.hasOwnProperty.call(OPENAI_COMPAT_PRESETS, name)) {
-                inst = new OpenAICompatProvider(name, cfg);
-            }
-            else {
-                throw new Error(`unknown enabled provider: ${name}`);
-            }
-            next.set(name, inst);
-            if (sig !== null) nextSignatures.set(name, sig);
+            const Ctor = await loadProviderCtor(name);
+            const inst = instantiateProvider(name, Ctor, cfg);
+            return { name, inst, sig };
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`[provider] Failed to init "${name}": ${msg}`);
+            return { name, error: new Error(`[provider] Failed to init "${name}": ${msg}`) };
         }
+    }));
+    for (const result of enabledResults) {
+        if (!result) continue;
+        if (result.error) throw result.error;
+        next.set(result.name, result.inst);
+        if (result.sig !== null) nextSignatures.set(result.name, result.sig);
     }
     // Second guard: every entry was disabled. Same reasoning — keep the
     // existing registry rather than going dark.
@@ -136,19 +165,27 @@ export function getProvider(name) {
     // failure) — initProviders then skipped the entry entirely so there is
     // nothing for the preservation guard to carry forward. Re-probe the
     // credential each miss: if the credential is now valid, register the
-    // instance on the spot so subsequent calls hit the cached entry.
+    // instance on the spot when that provider module has already been loaded,
+    // so subsequent calls hit the cached entry without making registry import
+    // pay every provider runtime at boot.
     if (name === 'anthropic-oauth' && hasAnthropicOAuthCredentials()) {
-        const inst = new AnthropicOAuthProvider({});
+        const Ctor = providerCtors.get('anthropic-oauth');
+        if (!Ctor) return undefined;
+        const inst = new Ctor({});
         providers.set(name, inst);
         return inst;
     }
     if (name === 'openai-oauth' && hasOpenAIOAuthCredentials()) {
-        const inst = new OpenAIOAuthProvider({});
+        const Ctor = providerCtors.get('openai-oauth');
+        if (!Ctor) return undefined;
+        const inst = new Ctor({});
         providers.set(name, inst);
         return inst;
     }
     if (name === 'grok-oauth' && hasGrokOAuthCredentials()) {
-        const inst = new GrokOAuthProvider({});
+        const Ctor = providerCtors.get('grok-oauth');
+        if (!Ctor) return undefined;
+        const inst = new Ctor({});
         providers.set(name, inst);
         return inst;
     }
@@ -173,7 +210,7 @@ export function getAllProviders() {
 }
 // Background catalog warm-up. Each provider's listModels() either hits its
 // own cached model list (no-op) or fires a single HTTP refresh. Called from
-// agent.init() after providers are registered so the first bridge LLM call
+// agent.init() after providers are registered so the first agent dispatch call
 // (e.g. cycle1 on session start) does not pay the catalog refresh latency
 // inline. Fire-and-forget: failures are logged inside each provider.
 export function warmupCatalogs() {

package/src/runtime/agent/orchestrator/providers/retry-classifier.mjs

@@ -27,10 +27,10 @@ import {
 
 // HTTP statuses considered transient — safe to retry with backoff.
 //   408 — request timeout
-//   429 — rate limit (caller may still respect Retry-After, but the kind
-//         classification here only signals "retryable"; sub-error in the
-//         provider can still treat 429 as permanent for quota-exhausted)
 //   500/502/503/504 — server errors (overload / bad gateway / timeout)
+//   429 is deliberately excluded: rate-limit/quota windows are deterministic
+//   for the current call and must surface immediately instead of sleeping until
+//   an outer watchdog reports a misleading timeout.
 const TRANSIENT_STATUSES = new Set([408, 500, 502, 503, 504])
 
 // HTTP statuses that mean "permanent: stop retrying, surface to caller".
@@ -44,7 +44,7 @@ const PERMANENT_STATUSES = new Set([400, 404, 405, 410, 415, 422])
 // payload but no explicit status code — we sniff the text and assign the most
 // likely HTTP equivalent so the retry layer can use the same rules.
 const MESSAGE_PATTERNS = [
-  // OpenAI/Codex sometimes surfaces generic backend failures only as
+  // OpenAI OAuth/API sometimes surfaces generic backend failures only as
   // message text plus a request ID, with no HTTP status on the WS event.
   { regex: /(?:an error occurred while processing your request|please include the request id)/i, status: 503 },
   // Overload / transient 5xx — server is asking us to back off. The `\b`
@@ -58,7 +58,7 @@ const MESSAGE_PATTERNS = [
   // by classifyError because per-call retry won't change the answer (the
   // window must elapse). Providers that want time-bounded retry should
   // honor Retry-After on the original response, not loop here.
-  { regex: /(?:rate ?limit|quota)/i, status: 429 },
+  { regex: /(?:rate[_ -]?limit|quota|too many requests|resource exhausted|insufficient_quota|quota_exceeded)/i, status: 429 },
   // Auth — never retryable from our side.
   { regex: /\b(?:unauthorized|unauthorised|authentication|not authenticated|token expired|access token|invalid api key)\b/i, status: 401 },
   { regex: /\b(?:forbidden|permission denied|policy violation)\b/i, status: 403 },
@@ -212,6 +212,13 @@ export function isRetryable(err) {
 const DEFAULT_BACKOFF_MS = PROVIDER_RETRY_BACKOFF_MS
 const DEFAULT_MAX_ATTEMPTS = PROVIDER_RETRY_MAX_ATTEMPTS
 
+export const MIDSTREAM_BACKOFF_MS = [250, 1000, 2000, 4000]
+
+export function midstreamBackoffFor(retryNumber, schedule = MIDSTREAM_BACKOFF_MS) {
+  const raw = schedule[Math.min(Math.max(retryNumber, 1), schedule.length) - 1]
+  return jitterDelayMs(raw)
+}
+
 export function jitterDelayMs(ms, ratio = PROVIDER_RETRY_JITTER_RATIO, mode = 'symmetric') {
   const base = Number(ms) || 0
   if (base <= 0) return 0
@@ -224,6 +231,264 @@ export function jitterDelayMs(ms, ratio = PROVIDER_RETRY_JITTER_RATIO, mode = 's
   return Math.max(0, Math.round(base + offset))
 }
 
+// ── Shared network-resilience interface ──────────────────────────────────────
+// One home for the logic that used to be copied per provider: mid-stream
+// classifier (WS + SSE), transport fallback predicate, stream-safety stamp
+// latches, abort-aware sleep, handshake classifier, and the retry-budget table.
+// Provider differences are passed as ARGUMENTS (policy objects), never branched
+// on a hardcoded provider name. Behavior is preserved EXACTLY — each path below
+// is the relocated original, selected by policy.mode.
+
+// F) Retry-budget profiles as DATA. The numbers live ONLY here now.
+//    ws.transientCloseRetries (4) — ws_1006 / ws_1011 connection-loss buckets.
+//    ws.defaultRetries (2)        — every other WS mid-stream bucket.
+//    sse.defaultRetries (3)       — anthropic single-shot SSE mid-stream budget.
+export const MIDSTREAM_RETRY_POLICY = {
+  ws: { transientCloseRetries: 4, defaultRetries: 2, backoff: [250, 1000, 2000, 4000] },
+  sse: { defaultRetries: 3, backoff: [250, 1000, 2000, 4000] },
+}
+
+// WS buckets that earn the larger transient-close retry budget.
+const WS_TRANSIENT_CLOSE_CLASSIFIERS = new Set(['ws_1006', 'ws_1011'])
+
+function _midstreamLimitFor(classifier, policy) {
+  if (policy.mode === 'ws') {
+    return WS_TRANSIENT_CLOSE_CLASSIFIERS.has(classifier)
+      ? policy.transientCloseRetries
+      : policy.defaultRetries
+  }
+  return policy.defaultRetries
+}
+
+// WS gates each classifier against its own budget (mirrors the old
+// _allowMidstreamRetry). SSE applies a single top-of-function budget gate and
+// then returns raw classifier strings, so perClassifierGate:false returns the
+// classifier unconditionally here.
+function _allowMidstream(classifier, attemptIndex, policy) {
+  if (policy.perClassifierGate === false) return classifier
+  return attemptIndex < _midstreamLimitFor(classifier, policy) ? classifier : null
+}
+
+// A) Unified mid-stream classifier. Returns a classifier string or null.
+//    `signals` is the provider's mid-stream state object (field names unchanged
+//    from each provider's midState). `policy.mode` selects the WS or SSE path so
+//    both providers reproduce their exact current branch order and gating.
+export function classifyMidstreamError(err, signals, policy = {}) {
+  if (!signals) return null
+  const attemptIndex = signals.attemptIndex | 0
+  if (policy.mode === 'sse') return _classifyMidstreamSse(err, signals, attemptIndex, policy)
+  return _classifyMidstreamWs(err, signals, attemptIndex, policy)
+}
+
+// Verbatim relocation of openai-oauth-ws's _classifyMidstreamError. `signals`
+// carries sawResponseCreated / sawCompleted / emittedText / emittedToolCall /
+// wsCloseCode / firstByteTimeout / firstMeaningfulTimeout / wsSendFailed /
+// userAbort / watchdogAbort / responseFailedPayload exactly as before.
+function _classifyMidstreamWs(err, state, attemptIndex, policy) {
+  if (state.sawCompleted) return null
+  if (state.emittedToolCall) {
+    const _cc = Number(err?.wsCloseCode || state.wsCloseCode || 0)
+    if (!(_cc === 1000 && state.sawResponseCreated && !state.sawCompleted)) return null
+  }
+  if (state.emittedText || err?.liveTextEmitted) return null
+  if (state.firstByteTimeout || err?.firstByteTimeout) {
+    return _allowMidstream('first_byte_timeout', attemptIndex, policy)
+  }
+  if (state.firstMeaningfulTimeout || err?.firstMeaningfulTimeout) {
+    return _allowMidstream('first_meaningful_timeout', attemptIndex, policy)
+  }
+  if (err?.wsSendFailed || state.wsSendFailed) {
+    return _allowMidstream('ws_send_failed', attemptIndex, policy)
+  }
+  if (!state.sawResponseCreated) {
+    const closeCode = Number(err?.wsCloseCode || state.wsCloseCode || 0)
+    if (closeCode !== 1011 && closeCode !== 1012) return null
+  }
+  if (state.userAbort) return null
+
+  if (!err) return null
+  const status = Number(err?.httpStatus || 0)
+  if (status === 401 || status === 403 || status === 429) return null
+  if (status >= 500 && status < 600) {
+    return _allowMidstream(`http_${status}`, attemptIndex, policy)
+  }
+
+  const name = err?.name || ''
+  if (name === 'AgentStallAbortError') return _allowMidstream('agent_stall', attemptIndex, policy)
+  if (name === 'StreamStalledAbortError') return _allowMidstream('stream_stalled', attemptIndex, policy)
+
+  if (state.watchdogAbort === 'AgentStallAbortError') return _allowMidstream('agent_stall', attemptIndex, policy)
+  if (state.watchdogAbort === 'StreamStalledAbortError') return _allowMidstream('stream_stalled', attemptIndex, policy)
+
+  const closeCode = Number(err?.wsCloseCode || state.wsCloseCode || 0)
+  if (closeCode === 1006) return _allowMidstream('ws_1006', attemptIndex, policy)
+  if (closeCode === 1011) return _allowMidstream('ws_1011', attemptIndex, policy)
+  if (closeCode === 1012) return _allowMidstream('ws_1012', attemptIndex, policy)
+  if (closeCode >= 4000 && closeCode < 5000 && closeCode !== 4000) return null
+  if (closeCode === 4000) return _allowMidstream('ws_4000', attemptIndex, policy)
+  if (closeCode === 1000 && state.sawResponseCreated && !state.sawCompleted) return _allowMidstream('ws_1000', attemptIndex, policy)
+
+  const failed = err?.responseFailed || state.responseFailedPayload
+  if (failed) {
+    try {
+      const blob = JSON.stringify(failed).toLowerCase()
+      if (blob.includes('stream_disconnected')) return _allowMidstream('response_failed_disconnected', attemptIndex, policy)
+      if (blob.includes('network_error')) return _allowMidstream('response_failed_network', attemptIndex, policy)
+      if (blob.includes('auth context expired')) return _allowMidstream('response_failed_auth_expired', attemptIndex, policy)
+    } catch {}
+  }
+
+  return null
+}
+
+// Verbatim relocation of anthropic-oauth's _classifyMidstreamError. `signals`
+// carries sawMessageStart / sawCompleted / emittedToolCall / userAbort /
+// watchdogAbort exactly as before.
+function _classifyMidstreamSse(err, state, attemptIndex, policy) {
+  if (attemptIndex >= policy.defaultRetries) return null
+  if (state.sawCompleted) return null
+  if (!state.sawMessageStart) return null
+  if (state.userAbort) return null
+  if (state.emittedToolCall) return null
+
+  if (!err) return null
+  const status = Number(err?.httpStatus || 0)
+  if (status === 401 || status === 403 || status === 429) return null
+
+  const name = err?.name || ''
+  if (name === 'AgentStallAbortError') return 'agent_stall'
+  if (name === 'StreamStalledAbortError') return 'stream_stalled'
+  if (state.watchdogAbort === 'AgentStallAbortError') return 'agent_stall'
+  if (state.watchdogAbort === 'StreamStalledAbortError') return 'stream_stalled'
+
+  const code = err?.code || err?.cause?.code || ''
+  if (code === 'ECONNRESET') return 'reset'
+  if (code === 'ETIMEDOUT' || code === 'ESOCKETTIMEDOUT') return 'timeout'
+  if (code === 'ENOTFOUND' || code === 'EAI_AGAIN' || code === 'EAI_NODATA') return 'dns'
+
+  const msg = String(err?.message || '').toLowerCase()
+  if (msg.includes('stream timed out after') && msg.includes('of inactivity')) return 'sse_idle_timeout'
+  if (msg.includes('body stream') && msg.includes('terminated')) return 'stream_terminated'
+  if (msg.includes('fetch failed')) return 'fetch_failed'
+
+  return null
+}
+
+// B) Unified transport (WS→HTTP) fallback predicate. Identical deny-order +
+//    allow-list to the two former copies; `enabled` replaces the per-provider
+//    env-flag check (caller computes the flag and passes it).
+const TRANSPORT_FALLBACK_CLASSIFIERS = new Set([
+  'timeout', 'reset', 'dns', 'refused', 'network', 'acquire_timeout', 'http_5xx',
+  'first_byte_timeout', 'first_meaningful_timeout',
+  'ws_1006', 'ws_1011', 'ws_1012', 'ws_1000', 'ws_4000', 'agent_stall', 'stream_stalled',
+  'response_failed_disconnected', 'response_failed_network', 'response_failed_auth_expired',
+  'ws_send_failed',
+])
+const TRANSPORT_FALLBACK_ERRNO = new Set([
+  'EWSACQUIRETIMEOUT', 'ETIMEDOUT', 'ESOCKETTIMEDOUT', 'ECONNRESET', 'EAI_AGAIN',
+  'ENOTFOUND', 'EAI_NODATA', 'ECONNREFUSED', 'ENETUNREACH', 'EHOSTUNREACH', 'EPIPE',
+])
+
+export function shouldFallbackTransport(err, { signal, enabled = true } = {}) {
+  if (!enabled) return false
+  if (signal?.aborted) return false
+  if (err?.liveTextEmitted === true) return false
+  if (err?.emittedToolCall === true || err?.unsafeToRetry === true) return false
+  const status = Number(err?.httpStatus || err?.status || 0)
+  if (status === 401 || status === 403 || status === 404 || status === 429) return false
+  if (status >= 500 && status < 600) return true
+  const code = String(err?.code || '')
+  if (TRANSPORT_FALLBACK_ERRNO.has(code)) return true
+  const classifier = String(err?.retryClassifier || err?.midstreamClassifier || '')
+  if (TRANSPORT_FALLBACK_CLASSIFIERS.has(classifier)) return true
+  if (/^http_5\d\d$/.test(classifier)) return true
+  if (err?.firstByteTimeout) return true
+  if (err?.firstMeaningfulTimeout) return true
+  const msg = String(err?.message || '')
+  return /opening handshake has timed out|socket hang up|acquire timed out|no first server event|no meaningful output/i.test(msg)
+}
+
+// C) Stream-safety stamp latches. Mirrors openai-oauth-ws's _stampLiveText /
+//    _stampTool: once text/tool has been marked, every subsequent throw path
+//    re-applies the liveTextEmitted/emittedToolCall + unsafeToRetry markers so
+//    no upstream gate can reissue the turn and concatenate attempts.
+export function createStreamSafetyStamps() {
+  let textLatched = false
+  let toolLatched = false
+  const stampText = (e) => {
+    if (textLatched && e) { try { e.liveTextEmitted = true; e.unsafeToRetry = true } catch {} }
+    return e
+  }
+  const stampTool = (e) => {
+    if (toolLatched && e) { try { e.emittedToolCall = true; e.unsafeToRetry = true } catch {} }
+    return e
+  }
+  return {
+    markText() { textLatched = true },
+    markTool() { toolLatched = true },
+    stampText,
+    stampTool,
+    stampAll: (e) => stampTool(stampText(e)),
+  }
+}
+
+const _defaultAbortSleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+// D) Abort-aware sleep (single copy). Resolves after `ms`, or rejects with the
+//    signal's reason (or `abortMessage`) the moment the signal aborts. `sleepFn`
+//    is the injectable no-signal sleep (test seam); `abortMessage` preserves
+//    each caller's prior fallback text when the abort reason is not an Error.
+export async function sleepWithAbort(ms, signal, sleepFn = _defaultAbortSleep, abortMessage = 'sleep aborted') {
+  if (!ms) return
+  if (!signal) {
+    await (sleepFn || _defaultAbortSleep)(ms)
+    return
+  }
+  await new Promise((resolve, reject) => {
+    const t = setTimeout(() => {
+      try { signal.removeEventListener('abort', onAbort) } catch {}
+      resolve()
+    }, ms)
+    const onAbort = () => {
+      clearTimeout(t)
+      const reason = signal.reason
+      reject(reason instanceof Error ? reason : new Error(abortMessage))
+    }
+    if (signal.aborted) { onAbort(); return }
+    signal.addEventListener('abort', onAbort, { once: true })
+  })
+}
+
+// E) Handshake classifier (moved here from openai-oauth-ws). Default-deny:
+//    anything not recognized as transient returns null. 401/403/404/429 are
+//    permanent. Returns 'timeout' | 'reset' | 'dns' | 'refused' | 'network' |
+//    'acquire_timeout' | `http_5xx` | null.
+export function classifyHandshakeError(err) {
+  if (!err) return null
+  const code = err.code || ''
+  const msg = String(err.message || '')
+  const status = Number(err.httpStatus || 0)
+
+  if (status === 401 || status === 403 || status === 404 || status === 429) {
+    return null
+  }
+  if (status >= 500 && status < 600) {
+    return `http_${status}`
+  }
+
+  if (code === 'ECONNRESET') return 'reset'
+  if (code === 'EAI_AGAIN' || code === 'ENOTFOUND' || code === 'EAI_NODATA') return 'dns'
+  if (code === 'ECONNREFUSED') return 'refused'
+  if (code === 'ETIMEDOUT' || code === 'ESOCKETTIMEDOUT') return 'timeout'
+  if (code === 'EWSACQUIRETIMEOUT') return 'acquire_timeout'
+  if (code === 'ENETUNREACH' || code === 'EHOSTUNREACH' || code === 'EPIPE') return 'network'
+
+  if (/opening handshake has timed out/i.test(msg)) return 'timeout'
+  if (/socket hang up/i.test(msg)) return 'reset'
+
+  return null
+}
+
 /**
  * Run an async function with exponential-backoff retry on transient errors.
  *
@@ -296,13 +561,17 @@ export async function withRetry(fn, opts = {}) {
       }
       lastErr = caught
       populateHttpStatusFromMessage(caught)
-      const retryAfterMs = retryAfterMsFromError(caught)
       const status = Number(caught?.httpStatus || caught?.status || caught?.response?.status || 0)
       const kind = classifyError(caught)
-      const retryableRateLimit = status === 429 && retryAfterMs != null
-      if (kind !== 'transient' && !retryableRateLimit) throw caught
+      const unsafeToRetry = caught?.unsafeToRetry === true
+        || caught?.providerQuota === true
+        || caught?.quotaExceeded === true
+      if (unsafeToRetry) throw caught
+      if (status === 429) throw caught
+      if (kind !== 'transient') throw caught
       // Last attempt failed transiently — propagate to caller.
       if (attempt === maxAttempts - 1) throw caught
+      const retryAfterMs = retryAfterMsFromError(caught)
       if (retryAfterMs != null) {
         nextDelayMs = Math.max(0, Math.min(retryAfterMs, maxRetryAfterMs))
         nextDelayReason = 'retry-after'
@@ -316,7 +585,7 @@ export async function withRetry(fn, opts = {}) {
 }
 
 function _sleepWithAbort(ms, signal) {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     let onAbort = null
     const t = setTimeout(() => {
       if (signal && onAbort) {
@@ -325,8 +594,17 @@ function _sleepWithAbort(ms, signal) {
       resolve()
     }, ms)
     if (!signal) return
-    if (signal.aborted) { clearTimeout(t); resolve(); return }
-    onAbort = () => { clearTimeout(t); resolve() }
+    if (signal.aborted) {
+      clearTimeout(t)
+      const reason = signal.reason
+      reject(reason instanceof Error ? reason : new Error('sleep aborted'))
+      return
+    }
+    onAbort = () => {
+      clearTimeout(t)
+      const reason = signal.reason
+      reject(reason instanceof Error ? reason : new Error('sleep aborted'))
+    }
     signal.addEventListener('abort', onAbort, { once: true })
   })
 }

package/src/runtime/agent/orchestrator/providers/statusline-route-meta.mjs

@@ -1,11 +1,44 @@
-let routeMeta;
+let routeMeta = null;
+let routeMetaPromise = null;
 
-try {
-  routeMeta = await import('../../../../vendor/statusline/src/gateway/route-meta.mjs');
-} catch {
-  routeMeta = await import('../../../gateway/route-meta.mjs');
+async function loadRouteMetaModule() {
+  if (routeMeta) return routeMeta;
+  if (!routeMetaPromise) {
+    routeMetaPromise = import('../../../../vendor/statusline/src/gateway/route-meta.mjs').then((mod) => {
+      routeMeta = mod;
+      return mod;
+    });
+  }
+  try {
+    return await routeMetaPromise;
+  } catch (err) {
+    routeMetaPromise = null;
+    routeMeta = null;
+    throw err;
+  }
 }
 
-export const buildGatewayLimits = routeMeta.buildGatewayLimits;
-export const recordGatewayUsageEvent = routeMeta.recordGatewayUsageEvent;
-export const summarizeGatewayUsage = routeMeta.summarizeGatewayUsage;
+/** Await before calling the sync exports when route-meta may not be ready yet. */
+export async function ensureStatuslineRouteMetaLoaded() {
+  return loadRouteMetaModule();
+}
+
+function requireRouteMeta() {
+  if (!routeMeta) {
+    void loadRouteMetaModule().catch(() => {});
+    throw new Error('statusline route-meta not loaded');
+  }
+  return routeMeta;
+}
+
+export function buildGatewayLimits(routeInfo, providerOut = null, usageSnapshot = null) {
+  return requireRouteMeta().buildGatewayLimits(routeInfo, providerOut, usageSnapshot);
+}
+
+export function recordGatewayUsageEvent(summary) {
+  return requireRouteMeta().recordGatewayUsageEvent(summary);
+}
+
+export function summarizeGatewayUsage(routeInfo, providerOut, compact = null, durationMs = null) {
+  return requireRouteMeta().summarizeGatewayUsage(routeInfo, providerOut, compact, durationMs);
+}