mixdog 1.3.5 → 1.4.0

package/src/runtime/agent/orchestrator/providers/account-pool.mjs

@@ -1,5 +1,6 @@
 import {
   ACCOUNT_PROVIDERS,
+  MAX_ACCOUNTS,
   accountScopedSessionId,
   readProviderAccountPool,
   chooseProviderAccount,
@@ -358,110 +359,182 @@ async function accountQuotaExhausted(providerName, row, model, error, account) {
     evidence = providerAccountExhausted(providerAccountWithBlocks(entry), Date.now(), model, options);
     exhausted = exhausted || evidence || providerAccountExhausted(entry, Date.now(), model, options);
   }
-  return { exhausted, delay, evidence, ...(exhausted ? blockUntil(evidence, evidence ? 'quota' : 'unknown') : {}) };
+  const reason = evidence ? 'quota' : 'unknown';
+  return { exhausted, delay, evidence, ...(exhausted ? blockUntil(evidence, reason) : {}) };
+}
+
+// Record an exhausted verdict on the roster. An account-level block holds
+// every model, so it carries no model or limit scope.
+function blockRefusedAccount(providerName, accountId, model, error, verdict) {
+  const { evidence, until, source, reset, accountBlocked } = verdict;
+  return blockProviderAccount(providerName, accountId, until, accountBlocked ? '' : model, source, {
+    quota: evidence === true,
+    reset: reset === true,
+    limit: accountBlocked ? '' : quotaLimitOf(error),
+  });
+}
+
+/**
+ * A refusal `error` that account `accountId` gave outside the pool's send (a
+ * cache warm, which never rotates): judged and recorded on the roster exactly
+ * as the send would, with `instance` as that account's provider. Resolves
+ * whether the account was blocked.
+ */
+export async function recordAccountRefusal(providerName, accountId, model, error, instance) {
+  const row = readProviderAccountPool(providerName).accounts.find((entry) => entry.id === accountId);
+  if (!row) return false;
+  const verdict = await accountQuotaExhausted(providerName, row, model, error, () => instance);
+  if (!verdict.exhausted) return false;
+  await blockRefusedAccount(providerName, row.id, model, error, verdict);
+  return true;
+}
+
+// Whether every account in `ids` (default: the roster) is exhausted with quota
+// evidence: observed in this send (`evidenced`), or a full window.
+function rosterExhaustion(providerName, model, evidenced, ids) {
+  const pool = readProviderAccountPool(providerName);
+  // Manual policy: the eligible set is the selected account alone.
+  const scope = ids || (providerAccountPolicy(pool) === 'manual' ? [pool.selectedId] : null);
+  const rows = scope ? pool.accounts.filter((entry) => scope.includes(entry.id)) : pool.accounts;
+  const opts = { useCredits: pool.useCredits === true };
+  const now = Date.now();
+  const all =
+    rows.length > 0 &&
+    rows.every((entry) =>
+      providerAccountExhausted(
+        evidenced.has(entry.id) ? entry : providerAccountWithBlocks(entry, (block) => block.blockedQuota === true),
+        now,
+        model,
+        opts
+      )
+    );
+  return { rows, opts, now, all };
+}
+
+// Mark `error` only when every account in `ids` is exhausted with quota
+// evidence (`rosterExhaustion`). Without an error of its own, the send reports
+// quota exhaustion only on that evidence, and a rate-limit cooldown otherwise.
+function exhaustedSendError(providerName, model, evidenced, error, ids) {
+  const { rows, opts, now, all } = rosterExhaustion(providerName, model, evidenced, ids);
+  if (all) {
+    return quotaExhausted(error || accountsExhaustedError(opts.useCredits), providerName, model, rows, opts);
+  }
+  return error || accountsCoolingDownError(rows, now, model);
+}
+
+// The provider's bound on the time one send spends waiting for cooldowns.
+function cooldownWaitBoundMs(providerName, account, ids) {
+  const id = ids?.[0] || readProviderAccountPool(providerName).selectedId || 'default';
+  return finiteMs(cooldownPolicyOf(account(id))?.waitForCooldownMs, 0);
+}
+
+// A cooldown-only eligible set whose earliest cooldown ends inside the
+// remaining wait budget is waited out; otherwise the send fails as before.
+// `ledger` is the send's own record of the roster (see `poolSend`).
+async function waitOutCooldownOrThrow(request, ledger, error, ids) {
+  const { providerName, model, account, options } = request;
+  const { rows, now, all } = rosterExhaustion(providerName, model, ledger.evidenced, ids);
+  const bound = cooldownWaitBoundMs(providerName, account, ids);
+  // Persisting a short cooldown can outlast its deadline. Release only
+  // attempts cooled by this send, and only under an enabled wait policy.
+  const expired = bound > 0 && rows.some((row) => ledger.cooled.has(row.id) && !(coolingUntil(row, model) > now));
+  let wait = null;
+  if (!all) wait = expired ? 0 : earliestCooldownMs(rows, now, model);
+  if (wait == null || ledger.waitedMs + wait > bound) {
+    throw exhaustedSendError(providerName, model, ledger.evidenced, error, ids);
+  }
+  options.onStageChange?.('reconnecting', {
+    message: `Rate limited — every account is cooling down; retrying in ${Math.ceil(wait / 1000)}s`,
+    reason: 'rate_limited',
+    waitMs: wait,
+    retryAt: now + wait,
+  });
+  // A zero-duration sleep does not check cancellation, including on the
+  // final allowed send when no next loop iteration will check it either.
+  options.signal?.throwIfAborted();
+  await sleepWithAbort(wait, options.signal);
+  ledger.waitedMs += wait;
+  const lifted = Date.now();
+  for (const row of readProviderAccountPool(providerName).accounts) {
+    if (ledger.cooled.has(row.id) && !(coolingUntil(row, model) > lifted)) {
+      ledger.cooled.delete(row.id);
+      ledger.attempted.delete(row.id);
+    }
+  }
+}
+
+// No roster: with credit use off, a stored reading showing the plan's window
+// spent refuses before the implicit account sends.
+function throwIfPlanQuotaSpent(providerName, pool, model) {
+  if (pool.useCredits !== true) {
+    const stored = readCachedOAuthUsageSnapshot({ provider: providerName, model: '' });
+    // A snapshot cached before per-model gating is stale evidence.
+    if (stored?.quotaWindows?.length && !staleQuotaWindows(providerName, stored.quotaWindows)) {
+      const row = { usage: { windows: stored.quotaWindows, checkedAt: stored.cachedAt } };
+      if (providerAccountExhausted(row, Date.now(), model)) {
+        throw quotaExhausted(accountsExhaustedError(false), providerName, model, [row]);
+      }
+    }
+  }
+}
+
+// Headroom policy: a session's first pick, or its move off its account on a
+// limit, becomes the selection; continuing on its account does not, so
+// concurrent sessions never flip the selection back and forth. A move forced
+// by a model-scoped limit serves this request only (`scoped`). Stamps the
+// serving account on `result` and resolves whether the selection may commit.
+function bindServedAccount(providerName, result, rowId, model, binding) {
+  const { policy, boundId, sessionKey, switched, refusalScoped } = binding;
+  const leftBound = Boolean(boundId) && rowId !== boundId;
+  const scoped = switched
+    ? refusalScoped
+    : policy === 'headroom' && leftBound && accountExhaustedForModelOnly(providerName, boundId, model);
+  recordServingAccount(providerName, result, rowId, scoped && boundId ? boundId : rowId);
+  if (sessionKey && policy === 'headroom' && !scoped) rememberSessionAccount(sessionKey, rowId);
+  return { scoped, commit: policy !== 'headroom' || !boundId || leftBound };
+}
+
+// A failed attempt is never re-issued once output reached the caller or the
+// attempt was unsafe to retry (`unsafe`, judged by the caller and read only
+// when nothing was emitted).
+function attemptUnretryable(bound, error, unsafe) {
+  return Boolean(bound.emitted() || unsafe() || error.liveTextEmitted || error.emittedToolCall);
+}
+
+function rotationReason(evidence, accountBlocked) {
+  if (evidence) return 'Quota exhausted';
+  if (accountBlocked) return 'Account blocked';
+  return 'Rate limited (cooldown)';
 }
 
 // The pool's send: walks the eligible accounts until one answers, blocking
 // the ones whose quota window is exhausted along the way.
 function poolSend(providerName, account) {
   return async function send(messages, model, tools, options = {}) {
-    const attempted = new Set();
+    const request = { providerName, model, account, options };
+    // This send's record of the roster: the accounts it tried, those it found
+    // exhausted with quota evidence, those it blocked on a rate-limit
+    // cooldown, and the time it spent waiting for cooldowns.
+    const ledger = { attempted: new Set(), evidenced: new Set(), cooled: new Set(), waitedMs: 0 };
     let lastError;
     let probed = false;
-    const evidenced = new Set();
+    let sends = 0;
     const sessionKey = options.sessionId ? `${providerName}:${options.sessionId}` : null;
     const boundId = sessionAccountId(providerName, sessionKey, messages, options);
     // Whether this send already left an account, and whether the latest quota
     // refusal held only for this model's family.
     let switched = false;
     let refusalScoped = false;
-    // Mark `error` only when every account in `ids` (default: the roster) is
-    // exhausted with quota evidence: observed in this send, or a full window.
-    // Without an error of its own, the send reports quota exhaustion only on
-    // that evidence, and a rate-limit cooldown otherwise.
-    const exhaustion = (ids) => {
-      const pool = readProviderAccountPool(providerName);
-      // Manual policy: the eligible set is the selected account alone.
-      const scope = ids || (providerAccountPolicy(pool) === 'manual' ? [pool.selectedId] : null);
-      const rows = scope ? pool.accounts.filter((entry) => scope.includes(entry.id)) : pool.accounts;
-      const opts = { useCredits: pool.useCredits === true };
-      const now = Date.now();
-      const all =
-        rows.length > 0 &&
-        rows.every((entry) =>
-          providerAccountExhausted(
-            evidenced.has(entry.id) ? entry : providerAccountWithBlocks(entry, (block) => block.blockedQuota === true),
-            now,
-            model,
-            opts
-          )
-        );
-      return { rows, opts, now, all };
-    };
-    const markExhausted = (error, ids) => {
-      const { rows, opts, now, all } = exhaustion(ids);
-      if (all) {
-        return quotaExhausted(error || accountsExhaustedError(opts.useCredits), providerName, model, rows, opts);
-      }
-      return error || accountsCoolingDownError(rows, now, model);
-    };
-    // Accounts this send blocked on a rate-limit cooldown, the time it spent
-    // waiting for cooldowns, and the provider's wait bound.
-    const cooled = new Set();
-    let waitedMs = 0;
-    let sends = 0;
-    const waitBoundMs = (ids) => {
-      const id = ids?.[0] || readProviderAccountPool(providerName).selectedId || 'default';
-      return finiteMs(cooldownPolicyOf(account(id))?.waitForCooldownMs, 0);
-    };
-    // A cooldown-only eligible set whose earliest cooldown ends inside the
-    // remaining wait budget is waited out; otherwise the send fails as before.
-    const waitOrThrow = async (error, ids) => {
-      const { rows, now, all } = exhaustion(ids);
-      const bound = waitBoundMs(ids);
-      // Persisting a short cooldown can outlast its deadline. Release only
-      // attempts cooled by this send, and only under an enabled wait policy.
-      const expired = bound > 0 && rows.some((row) => cooled.has(row.id) && !(coolingUntil(row, model) > now));
-      let wait = null;
-      if (!all) wait = expired ? 0 : earliestCooldownMs(rows, now, model);
-      if (wait == null || waitedMs + wait > bound) throw markExhausted(error, ids);
-      options.onStageChange?.('reconnecting', {
-        message: `Rate limited — every account is cooling down; retrying in ${Math.ceil(wait / 1000)}s`,
-        reason: 'rate_limited',
-        waitMs: wait,
-        retryAt: now + wait,
-      });
-      // A zero-duration sleep does not check cancellation, including on the
-      // final allowed send when no next loop iteration will check it either.
-      options.signal?.throwIfAborted();
-      await sleepWithAbort(wait, options.signal);
-      waitedMs += wait;
-      const lifted = Date.now();
-      for (const row of readProviderAccountPool(providerName).accounts) {
-        if (cooled.has(row.id) && !(coolingUntil(row, model) > lifted)) {
-          cooled.delete(row.id);
-          attempted.delete(row.id);
-        }
-      }
-    };
-    while (attempted.size < 20 && sends < 20) {
+    // One try per connectable account at most (provider-accounts.mjs MAX_ACCOUNTS).
+    while (ledger.attempted.size < MAX_ACCOUNTS && sends < MAX_ACCOUNTS) {
       options.signal?.throwIfAborted();
       const pool = readProviderAccountPool(providerName);
       if (!pool.accounts.length) {
-        if (pool.useCredits !== true) {
-          const stored = readCachedOAuthUsageSnapshot({ provider: providerName, model: '' });
-          // A snapshot cached before per-model gating is stale evidence.
-          if (stored?.quotaWindows?.length && !staleQuotaWindows(providerName, stored.quotaWindows)) {
-            const row = { usage: { windows: stored.quotaWindows, checkedAt: stored.cachedAt } };
-            if (providerAccountExhausted(row, Date.now(), model)) {
-              throw quotaExhausted(accountsExhaustedError(false), providerName, model, [row]);
-            }
-          }
-        }
+        throwIfPlanQuotaSpent(providerName, pool, model);
         return account('default').send(messages, model, tools, options);
       }
       const policy = providerAccountPolicy(pool);
-      const row = chooseProviderAccount(pool, attempted, Date.now(), model, { sessionAccountId: boundId });
+      const row = chooseProviderAccount(pool, ledger.attempted, Date.now(), model, { sessionAccountId: boundId });
       if (!row) {
         // Once per send: a refusal built on a stale meter must not outlive the
         // meter. Re-measuring can only widen the roster, so it is tried before
@@ -470,26 +543,22 @@ function poolSend(providerName, account) {
           probed = true;
           if (await probeRefusedAccounts(providerName, pool, model, account)) continue;
         }
-        await waitOrThrow(lastError);
+        await waitOutCooldownOrThrow(request, ledger, lastError);
         continue;
       }
-      attempted.add(row.id);
+      ledger.attempted.add(row.id);
       sends += 1;
       const bound = boundAccountSend(providerName, row, messages, options);
       try {
         const result = await account(row.id).send(bound.history, model, tools, bound.opts);
         quotaStrikes.delete(`${providerName}:${row.id}`);
-        // Headroom policy: a session's first pick, or its move off its account
-        // on a limit, becomes the selection; continuing on its account does
-        // not, so concurrent sessions never flip the selection back and forth.
-        // A move forced by a model-scoped limit serves this request only.
-        const leftBound = Boolean(boundId) && row.id !== boundId;
-        const scoped = switched
-          ? refusalScoped
-          : policy === 'headroom' && leftBound && accountExhaustedForModelOnly(providerName, boundId, model);
-        recordServingAccount(providerName, result, row.id, scoped && boundId ? boundId : row.id);
-        if (sessionKey && policy === 'headroom' && !scoped) rememberSessionAccount(sessionKey, row.id);
-        const commit = policy !== 'headroom' || !boundId || leftBound;
+        const { scoped, commit } = bindServedAccount(providerName, result, row.id, model, {
+          policy,
+          boundId,
+          sessionKey,
+          switched,
+          refusalScoped,
+        });
         if (commit && (await commitFallbackAccount(providerName, pool, row, model, scoped, policy))) {
           // Publish only a committed selection, never a speculative retry or
           // one superseded by a manual switch. The existing progress channel
@@ -508,62 +577,41 @@ function poolSend(providerName, account) {
       } catch (error) {
         if (options.signal?.aborted) throw error;
         if (error?.reauthRequired === true) {
-          if (
-            policy === 'manual' ||
-            bound.emitted() ||
-            error.unsafeToRetry ||
-            error.liveTextEmitted ||
-            error.emittedToolCall
-          )
-            throw error;
+          if (policy === 'manual' || attemptUnretryable(bound, error, () => error.unsafeToRetry)) throw error;
           lastError = error;
           switched = true;
           refusalScoped = false;
           options.onStageChange?.('reconnecting', { message: 'Sign-in expired — switching to the next account' });
           continue;
         }
-        const { exhausted, evidence, until, source, reset, accountBlocked } = await accountQuotaExhausted(
-          providerName,
-          row,
-          model,
-          error,
-          account
-        );
+        const verdict = await accountQuotaExhausted(providerName, row, model, error, account);
+        const { exhausted, evidence, accountBlocked } = verdict;
         if (options.signal?.aborted || !exhausted) throw error;
-        if (evidence) evidenced.add(row.id);
-        else cooled.add(row.id);
-        // An account-level block holds every model, so it carries no model or
-        // limit scope.
-        await blockProviderAccount(providerName, row.id, until, accountBlocked ? '' : model, source, {
-          quota: evidence === true,
-          reset: reset === true,
-          limit: accountBlocked ? '' : quotaLimitOf(error),
-        });
+        if (evidence) ledger.evidenced.add(row.id);
+        else ledger.cooled.add(row.id);
+        await blockRefusedAccount(providerName, row.id, model, error, verdict);
         // An account block is unsafe to re-issue on THAT account only; with no
         // output emitted, the next account may serve the same request.
-        if (
-          bound.emitted() ||
-          (error.unsafeToRetry && accountBlocked !== true) ||
-          error.liveTextEmitted ||
-          error.emittedToolCall
-        )
-          throw error;
+        if (attemptUnretryable(bound, error, () => error.unsafeToRetry && accountBlocked !== true)) throw error;
         // Manual policy: the eligible set is the selected account alone.
         if (policy === 'manual') {
-          await waitOrThrow(error, [row.id]);
+          await waitOutCooldownOrThrow(request, ledger, error, [row.id]);
           lastError = error;
           continue;
         }
         lastError = error;
         switched = true;
         refusalScoped = accountExhaustedForModelOnly(providerName, row.id, model);
-        let reason = 'Rate limited (cooldown)';
-        if (evidence) reason = 'Quota exhausted';
-        else if (accountBlocked) reason = 'Account blocked';
+        const reason = rotationReason(evidence, accountBlocked);
         options.onStageChange?.('reconnecting', { message: `${reason} — switching to the next account` });
       }
     }
-    throw markExhausted(lastError || new Error('Provider account attempts exhausted.'));
+    throw exhaustedSendError(
+      providerName,
+      model,
+      ledger.evidenced,
+      lastError || new Error('Provider account attempts exhausted.')
+    );
   };
 }
 

package/src/runtime/agent/orchestrator/providers/admission-scheduler.mjs

@@ -264,7 +264,9 @@ export class ProviderAdmissionScheduler {
         running.parentAbort = () => {
           try {
             controller.abort(item.signal.reason);
-          } catch {}
+          } catch {
+            // the controller may already be aborted
+          }
         };
         item.signal.addEventListener('abort', running.parentAbort, { once: true });
       }
@@ -301,7 +303,9 @@ export class ProviderAdmissionScheduler {
           if (running.parentAbort && running.parentSignal) {
             try {
               running.parentSignal.removeEventListener('abort', running.parentAbort);
-            } catch {}
+            } catch {
+              // the abort listener may already be gone
+            }
           }
           this.running.delete(running);
           lane.active -= 1;
@@ -312,6 +316,32 @@ export class ProviderAdmissionScheduler {
     if (this._canDeleteLane(lane)) this._deleteLane(key, lane);
   }
 
+  /**
+   * Why a request that must not wait (a cache warm) cannot start on lane
+   * `key` now, or null: the lane's rate-limit cooldown, or a lane throttled
+   * after a 429 that would queue it.
+   */
+  immediateBlock(key) {
+    if (this.closedReason) return 'provider scheduler closed';
+    const lane = this.lanes.get(String(key || ''));
+    if (!lane) return null;
+    if (lane.adaptive && lane.cooldownUntil > this.now()) return 'rate-limit cooldown';
+    if (lane.queue.length > 0 || lane.active >= lane.limit) return 'account throttled';
+    return null;
+  }
+
+  /** Record a rate limit a request outside `run` (a cache warm) received on
+   *  lane `key`, into the same cooldown state (and broadcast) as a send's. */
+  recordRateLimit(key, error) {
+    const laneKey = String(key || '');
+    if (!laneKey || this.closedReason) return false;
+    const lane = this.lanes.get(laneKey) || createAdmissionLane(laneKey, this.concurrency);
+    this.lanes.set(laneKey, lane);
+    const recorded = this._recordFailure(laneKey, lane, error);
+    if (this._canDeleteLane(lane)) this._deleteLane(laneKey, lane);
+    return recorded;
+  }
+
   snapshot() {
     const now = this.now();
     return {
@@ -428,7 +458,9 @@ export class ProviderAdmissionScheduler {
     if (item.onAbort && item.signal) {
       try {
         item.signal.removeEventListener('abort', item.onAbort);
-      } catch {}
+      } catch {
+        // the abort listener may already be gone
+      }
       item.onAbort = null;
     }
   }
@@ -453,7 +485,9 @@ export class ProviderAdmissionScheduler {
     for (const running of this.running) {
       try {
         running.controller.abort(this.closedReason);
-      } catch {}
+      } catch {
+        // the controller may already be aborted
+      }
     }
   }
 }
@@ -476,7 +510,7 @@ function digest(value) {
     .digest('hex');
 }
 
-function providerAdmissionKey(providerName, provider) {
+export function providerAdmissionKey(providerName, provider) {
   const name = String(providerName || provider?.name || 'provider');
   const stableAnthropicOAuthPath =
     name.toLowerCase() === 'anthropic-oauth'
@@ -556,7 +590,9 @@ export function wrapProviderAdmission(provider, providerName, scheduler = provid
             // time. Provider-local retry remains the sole retry owner.
             try {
               opts.onStageChange?.('requesting');
-            } catch {}
+            } catch {
+              // the stage observer is advisory
+            }
             const admittedOpts = {
               ...opts,
               signal: admissionSignal,

package/src/runtime/agent/orchestrator/providers/anthropic-cache-warm.mjs

@@ -0,0 +1,165 @@
+// anthropic-cache-warm.mjs — the cache-warm mode both Anthropic providers
+// expose as `sendCacheWarm` (session/cache-warm.mjs): one POST of the
+// request the provider's own builder produces, no retry, fallback, re-send,
+// wait or account rotation, and the stream cut at the first content block
+// once the usage (cache read / write) has been reported. Right before the
+// POST the account gate (cache-warm-admission.mjs) may skip it; a refusal is
+// fed into the shared rate-limit and roster state. The request is bounded by
+// the providers' own watchdogs: the first-byte timeout until the usage
+// arrives, then the SSE idle timeout between events. Usage is handed to
+// `onUsage` as it arrives, so a warm that fails or is aborted after the
+// provider accepted it is still accounted. Every exit cancels the stream and
+// aborts the transport.
+import { PROVIDER_FIRST_BYTE_TIMEOUT_MS, PROVIDER_SSE_IDLE_TIMEOUT_MS } from '../stall-policy.mjs';
+import { updateTurnUsage } from './anthropic-sse-turn/turn-state.mjs';
+import { _anthropicSseError } from './anthropic-sse.mjs';
+import { anthropicQuotaError } from './anthropic-oauth-request/initial-status.mjs';
+import { cacheWarmAccountBlock, cacheWarmBlockedError, recordCacheWarmRefusal } from './cache-warm-admission.mjs';
+import { scrubOAuthSecrets } from './lib/oauth-token-utils.mjs';
+
+const SSE_LABELS = Object.freeze({ display: 'Anthropic cache warm' });
+
+function usageSnapshot(usage) {
+  const { raw: _raw, ...rest } = usage;
+  return { ...rest };
+}
+
+// An abort deadline: `arm(ms)` (re)starts it; it fires `controller.abort`.
+function watchdog(controller) {
+  let timer = null;
+  return {
+    arm(ms, what) {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => controller.abort(new Error(`cache warm ${what} timed out after ${ms}ms`)), ms);
+      timer.unref?.();
+    },
+    clear() {
+      if (timer) clearTimeout(timer);
+      timer = null;
+    },
+  };
+}
+
+/**
+ * Read a warm's SSE stream until usage is known and the first content block
+ * starts, or the message ends. Resolves the usage; a stream error rejects
+ * with `error.usage` set to what was reported before it. `onChunk` hears
+ * every chunk (the idle watchdog). The stream is cancelled on every exit.
+ */
+export async function readCacheWarmStream(response, { onUsage = () => {}, onChunk = () => {} } = {}) {
+  const usage = { inputTokens: 0, outputTokens: 0, cachedTokens: 0, cacheWriteTokens: 0, raw: null };
+  let reported = false;
+  const report = (raw) => {
+    if (!raw || typeof raw !== 'object') return;
+    updateTurnUsage(usage, raw);
+    reported = true;
+    onUsage(usageSnapshot(usage));
+  };
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  try {
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let cut = buffer.indexOf('\n\n');
+      while (cut >= 0) {
+        const frame = buffer.slice(0, cut);
+        buffer = buffer.slice(cut + 2);
+        cut = buffer.indexOf('\n\n');
+        const data = frame
+          .split('\n')
+          .filter((line) => line.startsWith('data:'))
+          .map((line) => line.slice(5).trimStart())
+          .join('\n');
+        if (!data) continue;
+        let event;
+        try {
+          event = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        if (event?.type === 'error' || event?.error) throw _anthropicSseError(event, SSE_LABELS);
+        if (event.type === 'message_start') report(event.message?.usage);
+        else if (event.type === 'message_delta') report(event.usage);
+        else if (event.type === 'content_block_start' && reported) {
+          // The prefix was read (and the cache refreshed) before any content:
+          // nothing generated after this point is needed.
+          return usageSnapshot(usage);
+        } else if (event.type === 'message_stop') return usageSnapshot(usage);
+      }
+      onChunk(reported);
+    }
+  } catch (error) {
+    if (error && typeof error === 'object' && error.usage === undefined) {
+      error.usage = reported ? usageSnapshot(usage) : null;
+    }
+    throw error;
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+  return usageSnapshot(usage);
+}
+
+/**
+ * One warm on account instance `instance` (roster account `accountId`, empty
+ * for a provider without a roster) of `providerName`: the account gate, then
+ * `post(signal)` (the provider's single POST of its built body), then the
+ * stream. A refusal reaches the shared rate-limit and roster state; the
+ * transport is aborted on every exit.
+ */
+export async function sendAnthropicCacheWarm({
+  providerName,
+  instance,
+  accountId = '',
+  model,
+  opts = {},
+  post,
+  onUsage,
+}) {
+  const blocked = cacheWarmAccountBlock(providerName, instance, {
+    accountId,
+    model,
+    sessionId: opts.session?.id || opts.sessionId || '',
+  });
+  if (blocked) throw cacheWarmBlockedError(blocked);
+  const controller = new AbortController();
+  const callerSignal = opts.signal;
+  const onCallerAbort = () => controller.abort(callerSignal.reason);
+  if (callerSignal?.aborted) controller.abort(callerSignal.reason);
+  else callerSignal?.addEventListener?.('abort', onCallerAbort, { once: true });
+  const deadline = watchdog(controller);
+  deadline.arm(PROVIDER_FIRST_BYTE_TIMEOUT_MS, 'first byte');
+  try {
+    const response = await post(controller.signal);
+    if (!response.ok) {
+      const bodyText = await response.text().catch(() => '');
+      throw anthropicQuotaError(response.status, response.headers, bodyText);
+    }
+    return await readCacheWarmStream(response, {
+      onUsage,
+      onChunk: (reported) => {
+        if (reported) deadline.arm(PROVIDER_SSE_IDLE_TIMEOUT_MS, 'stream');
+      },
+    });
+  } catch (error) {
+    // The warm's own error is what the caller needs; a failure to persist the
+    // refusal (quota / roster state) is reported, scrubbed, like the other
+    // credential and account-state write failures of the Anthropic providers.
+    await recordCacheWarmRefusal(providerName, instance, error, {
+      accountId,
+      model,
+      aborted: Boolean(callerSignal?.aborted),
+    }).catch((recordError) => {
+      process.stderr.write(
+        `[anthropic-cache-warm] refusal record failed: ${scrubOAuthSecrets(recordError?.message || String(recordError))}\n`
+      );
+    });
+    throw error;
+  } finally {
+    callerSignal?.removeEventListener?.('abort', onCallerAbort);
+    deadline.clear();
+    controller.abort(new Error('cache warm finished'));
+  }
+}

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-client-version.mjs

@@ -10,7 +10,7 @@ import { createNpmVersionSource, maxSemver } from './npm-cli-version.mjs';
 // source release just to advance the user-agent version.
 // Claude Opus 5.5 requires 2.1.280 or newer. The release workflow raises this
 // to the published CLI version (scripts/sync-client-version-floors.mjs).
-export const DEFAULT_CLI_VERSION = '2.1.310';
+export const DEFAULT_CLI_VERSION = '2.1.311';
 export const CLAUDE_CLI_NPM_PACKAGE = '@anthropic-ai/claude-code';
 
 const CACHE_SCHEMA_VERSION = 1;

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-credentials.mjs

@@ -15,6 +15,7 @@ import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs
 import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { modelProxyClientMode, serverModelCredentialsDisabledError } from '../../../shared/model-proxy-mode.mjs';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
+import { TIMEOUT_PHASE } from '../../../shared/provider-timeout-phase.mjs';
 import { claudeCliUserAgent, resolveCliVersion } from './anthropic-oauth-client-version.mjs';
 import {
   accountIdentityFields,
@@ -375,7 +376,9 @@ async function _refreshOAuthCredentialsUnlocked(creds) {
     return refreshed;
   } catch (err) {
     if (err?.name === 'AbortError') {
-      throw new Error('Anthropic OAuth token refresh timed out after 30000ms');
+      throw Object.assign(new Error('Anthropic OAuth token refresh timed out after 30000ms'), {
+        timeoutPhase: TIMEOUT_PHASE.AUTH,
+      });
     }
     throw err;
   } finally {