opencode-auth-load-balancer 0.2.1 → 0.3.0

package/dist/index.js

@@ -12341,6 +12341,7 @@ import { dirname as dirname2 } from "node:path";
 function emptyUsage() {
   return { hourly: null, weekly: null, capturedAt: 0 };
 }
+var MANUAL_DISABLED_REASON = "manually disabled";
 
 // src/providers/http-timeouts.ts
 var OAUTH_HTTP_TIMEOUT_MS = 30000;
@@ -12699,6 +12700,14 @@ function normalizeLastSelected(rows) {
   }
   return rows;
 }
+function normalizeRelogin(value, now) {
+  if (!isPlainObject2(value))
+    return;
+  const intent = value;
+  if (typeof intent.accountId !== "string" || typeof intent.providerID !== "string" || !Number.isFinite(intent.expiresAt) || intent.expiresAt <= now)
+    return;
+  return intent;
+}
 async function readRaw() {
   let text;
   try {
@@ -12716,6 +12725,7 @@ async function readRaw() {
     return {
       version: 1,
       accounts: normalizeAccounts(parsed.accounts),
+      relogin: normalizeRelogin(parsed.relogin, Date.now()),
       lastSelected: isPlainObject2(parsed.lastSelected) ? normalizeLastSelected(parsed.lastSelected) : {},
       sessions: isPlainObject2(parsed.sessions) ? normalizeSessions(parsed.sessions) : {}
     };
@@ -12788,19 +12798,27 @@ function makeAccount(providerID, label, tokens) {
     disabledReason: null
   };
 }
+function applyTokens(row, tokens) {
+  if (tokens.refresh)
+    row.refresh = tokens.refresh;
+  row.access = tokens.access;
+  row.expires = tokens.expires;
+  row.disabledReason = null;
+  if (tokens.accountId)
+    row.accountId = tokens.accountId;
+  return row;
+}
 async function addAccount(providerID, tokens, label) {
   return mutatePool((pool) => {
+    const intent = pool.relogin?.providerID === providerID ? pool.relogin : undefined;
+    if (intent)
+      delete pool.relogin;
     const existing = pool.accounts.find((a) => a.providerID === providerID && (tokens.refresh && a.refresh === tokens.refresh || tokens.accountId && a.accountId === tokens.accountId));
-    if (existing) {
-      if (tokens.refresh)
-        existing.refresh = tokens.refresh;
-      existing.access = tokens.access;
-      existing.expires = tokens.expires;
-      existing.disabledReason = null;
-      if (tokens.accountId)
-        existing.accountId = tokens.accountId;
-      return existing;
-    }
+    if (existing)
+      return applyTokens(existing, tokens);
+    const target = intent ? pool.accounts.find((account2) => account2.id === intent.accountId) : undefined;
+    if (target)
+      return applyTokens(target, tokens);
     const used = new Set(pool.accounts.map((a) => a.label));
     let n = 1;
     while (used.has(`${providerID}-${n}`))
@@ -13153,26 +13171,31 @@ function loadConfig(env = process.env) {
 // src/scheduler/select.ts
 var IMMINENT_EXHAUSTION_BAND = 0.01;
 var PROACTIVE_MIGRATE_MIN_DELTA = 0.02;
+var INCUMBENT_HYSTERESIS = 0.2;
 function weeklyUtil(account) {
   return account.usage.weekly?.utilization ?? 0;
 }
 var NO_EXCLUSIONS = new Set;
-function selectAccount(accounts, providerID, now, cfg = DEFAULT_CONFIG, exclude = NO_EXCLUSIONS) {
-  let sawAvailable = false;
+function selectAccount(accounts, providerID, now, cfg = DEFAULT_CONFIG, exclude = NO_EXCLUSIONS, incumbentId = null) {
   let bestAvail = null;
   let bestAvailScore = Number.NEGATIVE_INFINITY;
   let bestFallback = null;
   let lowestWeeklyUtil = Number.POSITIVE_INFINITY;
+  let incumbentAccount = null;
+  let incumbentScore = Number.NEGATIVE_INFINITY;
   for (const account of accounts) {
     if (account.providerID !== providerID || account.disabledReason || exclude.has(account.id))
       continue;
     if (isAvailable(account, cfg, now)) {
-      sawAvailable = true;
       const score = scoreAccount(account, cfg, now);
       if (score > bestAvailScore) {
         bestAvailScore = score;
         bestAvail = account;
       }
+      if (account.id === incumbentId) {
+        incumbentAccount = account;
+        incumbentScore = score;
+      }
     } else {
       const util = weeklyUtil(account);
       if (util < lowestWeeklyUtil) {
@@ -13181,8 +13204,11 @@ function selectAccount(accounts, providerID, now, cfg = DEFAULT_CONFIG, exclude
       }
     }
   }
-  if (sawAvailable)
-    return bestAvail ? { account: bestAvail, degraded: false, sticky: false } : null;
+  if (bestAvail) {
+    if (incumbentAccount && incumbentScore >= bestAvailScore * (1 - INCUMBENT_HYSTERESIS))
+      return { account: incumbentAccount, degraded: false, sticky: false };
+    return { account: bestAvail, degraded: false, sticky: false };
+  }
   return bestFallback ? { account: bestFallback, degraded: true, sticky: false } : null;
 }
 function findPinned(pool, providerID, sessionKey, exclude) {
@@ -13206,9 +13232,9 @@ function isCheapMoment(requestBytes, cfg) {
 function selectForSession(pool, providerID, sessionKey, now, cfg = DEFAULT_CONFIG, exclude = NO_EXCLUSIONS, requestBytes = 0) {
   const pinned = sessionKey ? findPinned(pool, providerID, sessionKey, exclude) : null;
   if (!pinned)
-    return selectAccount(pool.accounts, providerID, now, cfg, exclude);
+    return selectAccount(pool.accounts, providerID, now, cfg, exclude, pool.lastSelected[providerID] ?? null);
   if (!isAvailable(pinned, cfg, now))
-    return selectAccount(pool.accounts, providerID, now, cfg, exclude);
+    return selectAccount(pool.accounts, providerID, now, cfg, exclude, pool.lastSelected[providerID] ?? null);
   const weeklyUtilPinned = utilOf(pinned.usage.weekly, now);
   const hourlyUtilPinned = utilOf(pinned.usage.hourly, now);
   const pinnedOverSoft = weeklyUtilPinned >= cfg.weeklyDrainTarget || hourlyUtilPinned >= cfg.migrateAt;
@@ -13217,11 +13243,11 @@ function selectForSession(pool, providerID, sessionKey, now, cfg = DEFAULT_CONFI
     const pinnedImminent = pinnedOverSoft && pinnedUtil >= cfg.exhaustedAt - IMMINENT_EXHAUSTION_BAND;
     const cheap = (!pinnedImminent || cfg.drainMigrate) && isCheapMoment(typeof requestBytes === "function" ? requestBytes() : requestBytes, cfg);
     if (pinnedOverSoft && (pinnedImminent || cheap) || cfg.drainMigrate && cheap) {
-      const alt = selectAccount(pool.accounts, providerID, now, cfg, withExcluded(exclude, pinned.id));
+      const alt = selectAccount(pool.accounts, providerID, now, cfg, withExcluded(exclude, pinned.id), null);
       if (alt && !alt.degraded) {
         if (pinnedOverSoft) {
           const altUtil = maxUtil(alt.account, now);
-          const proactiveBetter = pinnedImminent ? altUtil < pinnedUtil : pinnedUtil - altUtil >= PROACTIVE_MIGRATE_MIN_DELTA;
+          const proactiveBetter = pinnedImminent ? altUtil < pinnedUtil : pinnedUtil - altUtil >= PROACTIVE_MIGRATE_MIN_DELTA && weeklyUrgency(alt.account, cfg, now) >= weeklyUrgency(pinned, cfg, now);
           if (proactiveBetter) {
             return { account: alt.account, degraded: false, sticky: false };
           }
@@ -13295,804 +13321,306 @@ function preserveWeeklyAnchor(incoming, stored, now) {
   return { utilization: incoming.utilization, resetAt: anchor };
 }
 
-// src/usage-refresh.ts
-var SEED_TTL_MS = 5 * 60 * 1000;
-var lastPoll = new Map;
-async function refreshUsageInBackground(adapter, now, poolSnapshot) {
-  const pool = poolSnapshot ?? await readPool();
-  const aliveIds = lastPoll.size > 0 ? new Set : undefined;
-  let stale;
-  for (const account of pool.accounts) {
-    aliveIds?.add(account.id);
-    if (account.providerID !== adapter.id || account.disabledReason)
-      continue;
-    if (account.usage.capturedAt !== 0 && now - account.usage.capturedAt <= SEED_TTL_MS)
-      continue;
-    if ((lastPoll.get(account.id) ?? 0) > now - SEED_TTL_MS)
-      continue;
-    lastPoll.set(account.id, now);
-    stale ??= [];
-    stale.push(account);
-  }
-  if (aliveIds) {
-    for (const id of lastPoll.keys())
-      if (!aliveIds.has(id))
-        lastPoll.delete(id);
+// src/providers/types.ts
+function classifyHttpStatus(status) {
+  if (status === 429 || status === 402)
+    return "account";
+  if (status === 401 || status === 403)
+    return "auth";
+  if (status >= 500)
+    return "service";
+  return "ok";
+}
+function urlFromInput(input) {
+  try {
+    return new URL(input instanceof Request ? input.url : input);
+  } catch {
+    return null;
   }
-  if (!stale)
-    return;
-  await Promise.all(stale.map(async (account) => {
-    try {
-      await ensureAccessToken(adapter, account, now);
-      const snapshot = await adapter.fetchUsage(account, now);
-      if (snapshot) {
-        await mutatePool((p) => {
-          const stored = findAccount(p, account.id);
-          if (stored)
-            stored.usage = {
-              hourly: snapshot.hourly ?? stored.usage.hourly,
-              weekly: snapshot.weekly === null ? stored.usage.weekly : preserveWeeklyAnchor(snapshot.weekly, stored.usage.weekly, now),
-              capturedAt: snapshot.weekly === null ? stored.usage.capturedAt : now
-            };
-        });
-      }
-    } catch {}
-  }));
 }
 
-// src/fetch.ts
-var ACCOUNT_COOLDOWN_MS = 5 * 60 * 1000;
-var AUTH_COOLDOWN_MS = 2 * 60 * 1000;
-var DEBUG = process.env.OPENCODE_AUTH_LB_DEBUG === "1" || process.env.OPENCODE_AUTH_LB_DEBUG === "true";
-function log(message) {
-  if (DEBUG)
-    console.error(`[auth-lb] ${message}`);
+// src/providers/anthropic/fallback.ts
+var TIER_RESET_FALLBACK_MS = 60 * 60 * 1000;
+var TIER_RESET_MAX_MS = MAX_QUOTA_RESET_BOUND_MS;
+var ALPHA_SEGMENT_RE = /^[a-z]+$/;
+var DIGIT_SEGMENT_RE = /^\d+$/;
+var DATE_SEGMENT_RE = /^\d{8}$/;
+function modelFamily(model) {
+  const lower = model.toLowerCase();
+  if (!lower.startsWith("claude"))
+    return null;
+  for (const segment of lower.split("-")) {
+    if (segment !== "claude" && ALPHA_SEGMENT_RE.test(segment))
+      return segment;
+  }
+  return null;
 }
-async function bestEffort(what, op) {
+function requestModelTier(body) {
+  let parsed;
   try {
-    await op();
-  } catch (error45) {
-    if (error45 instanceof LockTimeoutError || error45 instanceof PoolReadError || error45 instanceof PoolWriteError) {
-      log(`bookkeeping skipped (${what}): ${error45.message}`);
-      return;
-    }
-    throw error45;
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
   }
+  const model = parsed.model;
+  return typeof model === "string" ? modelFamily(model) : null;
 }
-function applyUsagePartial(account, partial2, now) {
-  if (partial2.hourly !== undefined)
-    account.usage.hourly = partial2.hourly;
-  if (partial2.weekly !== undefined) {
-    account.usage.weekly = preserveWeeklyAnchor(partial2.weekly, account.usage.weekly, now);
-    account.usage.capturedAt = now;
+function versionVector(model) {
+  const version2 = [];
+  let date5 = -1;
+  for (const segment of model.split("-")) {
+    if (DATE_SEGMENT_RE.test(segment))
+      date5 = Number(segment);
+    else if (DIGIT_SEGMENT_RE.test(segment))
+      version2.push(Number(segment));
   }
+  return { version: version2, date: date5 };
 }
-var RETRY_AFTER_MAX_MS = MAX_QUOTA_RESET_BOUND_MS;
-function cooldownUntilFrom(res, fallbackMs, now) {
-  let until = now + fallbackMs;
-  const retryAfter = res?.headers.get("retry-after");
-  if (retryAfter) {
-    const secs = Number(retryAfter);
-    if (Number.isFinite(secs) && secs > 0) {
-      const delta = secs * 1000;
-      if (Number.isFinite(delta) && delta <= RETRY_AFTER_MAX_MS)
-        until = now + delta;
-    } else {
-      const httpDate = Date.parse(retryAfter);
-      if (Number.isFinite(httpDate) && httpDate > now && httpDate - now <= RETRY_AFTER_MAX_MS)
-        until = httpDate;
-    }
+function compareVersions(a, b) {
+  const len = Math.max(a.version.length, b.version.length);
+  for (let i = 0;i < len; i++) {
+    const d = (a.version[i] ?? -1) - (b.version[i] ?? -1);
+    if (d !== 0)
+      return d;
   }
-  return until;
-}
-async function applyCooldown(accountId, fallbackMs) {
-  const until = cooldownUntilFrom(null, fallbackMs, Date.now());
-  await bestEffort("cooldown", () => mutatePool((pool) => {
-    const account = findAccount(pool, accountId);
-    if (account)
-      account.cooldownUntil = Math.max(account.cooldownUntil, until);
-  }));
-}
-async function recordRotation(adapter, accountId, res, fallbackMs, now) {
-  const partial2 = adapter.parseUsageHeaders(res.headers);
-  const until = cooldownUntilFrom(res, fallbackMs, now);
-  await bestEffort("rotation", () => mutatePool((pool) => {
-    const account = findAccount(pool, accountId);
-    if (!account)
-      return;
-    if (partial2)
-      applyUsagePartial(account, partial2, now);
-    account.cooldownUntil = Math.max(account.cooldownUntil, until);
-  }));
-}
-async function recordModelCooldown(accountId, tier, until, partial2, now) {
-  await bestEffort("model-cooldown", () => mutatePool((pool) => {
-    const account = findAccount(pool, accountId);
-    if (!account)
-      return;
-    if (partial2)
-      applyUsagePartial(account, partial2, now);
-    const map2 = account.modelCooldownsUntil ??= {};
-    map2[tier] = Math.max(map2[tier] ?? 0, until);
-  }));
+  return a.date - b.date;
 }
-async function recordSuccess(adapter, accountId, partial2, sessionKey, now, ttlMs) {
-  await bestEffort("record-success", () => mutatePool((pool) => {
-    const account = findAccount(pool, accountId);
-    if (account) {
-      if (partial2)
-        applyUsagePartial(account, partial2, now);
-      pool.lastSelected[adapter.id] = accountId;
-    }
-    if (sessionKey) {
-      pool.sessions[sessionKey] = { accountId, updatedAt: now };
-      for (const k of Object.keys(pool.sessions)) {
-        const pin = pool.sessions[k];
-        if (pin && now - pin.updatedAt > ttlMs)
-          delete pool.sessions[k];
-      }
+function bestOfFamily(models, family) {
+  let best = null;
+  let bestVersion = {
+    version: [],
+    date: -1
+  };
+  for (const model of models) {
+    if (modelFamily(model) !== family)
+      continue;
+    const version2 = versionVector(model);
+    if (best === null || compareVersions(version2, bestVersion) > 0) {
+      best = model;
+      bestVersion = version2;
     }
-  }));
+  }
+  return best;
 }
-function noUsableAccountResponse(providerID) {
-  const message = `No usable ${providerID} account in the auth-load-balancer pool. Run "opencode auth login" to add or re-login an account.`;
-  const error45 = { type: "authentication_error", message };
-  const body = providerID === PROVIDER_ID ? { type: "error", error: error45 } : { error: error45 };
-  return new Response(JSON.stringify(body), {
-    status: 401,
-    headers: { "content-type": "application/json" }
-  });
+var computeFamilyOrder = memoOne((raw) => {
+  const parsed = (raw ?? "").split(",").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
+  return parsed.length > 0 ? parsed : DEFAULT_FAMILY_ORDER;
+});
+function resolveFamilyOrder() {
+  return computeFamilyOrder(process.env.OPENCODE_AUTH_LB_ANTHROPIC_FAMILY_ORDER);
 }
-function soonestCooldownUntil(accounts, now, accountIds) {
-  if (accountIds.size === 0)
-    return null;
-  let soonest = Number.POSITIVE_INFINITY;
-  for (const account of accounts) {
-    if (account.disabledReason)
-      continue;
-    if (!accountIds.has(account.id))
+var computeFallbackSetting = memoOne((raw) => {
+  const trimmed = raw?.trim();
+  return raw === undefined ? { kind: "ladder" } : trimmed ? { kind: "pinned", model: trimmed } : { kind: "disabled" };
+});
+function resolveFallbackSetting() {
+  return computeFallbackSetting(process.env.OPENCODE_AUTH_LB_ANTHROPIC_OPUS_FALLBACK_MODEL);
+}
+function ladderTargetForFamily(fromFamily, models) {
+  const order = resolveFamilyOrder();
+  const start = order.indexOf(fromFamily) + 1;
+  for (let i = start;i < order.length; i++) {
+    const family = order[i];
+    if (family === undefined)
       continue;
-    const until = account.cooldownUntil > now ? account.cooldownUntil : now;
-    if (until < soonest)
-      soonest = until;
+    const best = bestOfFamily(models, family);
+    if (best !== null)
+      return best;
   }
-  return Number.isFinite(soonest) ? soonest : null;
+  return null;
 }
-function createLoadBalancedFetch(adapter, hooks = {}, models = []) {
-  const cfg = loadConfig();
-  return async (input, init) => {
-    const bodyStr = typeof init?.body === "string" ? init.body : undefined;
-    const baseHeaders = mergeHeaders(input, init);
-    const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
-    const baseKey = deriveSessionKey(baseHeaders, bodyStr);
-    const sessionKey = baseKey ? `${adapter.id}:${baseKey}` : null;
-    baseHeaders.delete(SESSION_HEADER);
-    const tried = new Set;
-    let waitableCooldownIds = null;
-    let lastError = null;
-    let cachedRequestBytes = -1;
-    const requestBytes = cfg.cheapSwitchMaxBytes > 0 && sessionKey !== null && bodyStr ? () => {
-      if (cachedRequestBytes < 0)
-        cachedRequestBytes = Buffer.byteLength(bodyStr, "utf8");
-      return cachedRequestBytes;
-    } : 0;
-    const transformedBody = bodyStr !== undefined ? adapter.transformBody(bodyStr) : init?.body;
-    const transformedUrl = adapter.transformUrl(input);
-    let currentBody = transformedBody;
-    let currentTier = typeof bodyStr === "string" ? adapter.requestModelTier?.(bodyStr) ?? null : null;
-    let fallbackPlan = null;
-    let fallbackPlanFor = null;
-    const planDowngrade = () => {
-      if (typeof currentBody === "string" && fallbackPlanFor !== currentBody) {
-        fallbackPlanFor = currentBody;
-        fallbackPlan = adapter.planModelFallback?.(currentBody, models) ?? null;
-      }
-      return fallbackPlan;
-    };
-    let fallbackInfo = null;
-    let pendingTierFallback = null;
-    let tierSkipped = null;
-    let usageSeeded = false;
-    const waitDeadline = Date.now() + cfg.maxWaitMs;
-    for (;; ) {
-      const pool = await readPool();
-      const now = Date.now();
-      if (!usageSeeded) {
-        usageSeeded = true;
-        refreshUsageInBackground(adapter, now, pool).catch(ignore);
-      }
-      const selection = selectForSession(pool, adapter.id, sessionKey, now, cfg, tried, requestBytes);
-      if (!selection) {
-        if (tried.size === 0)
-          return noUsableAccountResponse(adapter.id);
-        if (pendingTierFallback !== null) {
-          const adopted = pendingTierFallback;
-          pendingTierFallback = null;
-          currentBody = adopted.body;
-          currentTier = adapter.requestModelTier?.(adopted.body) ?? null;
-          fallbackInfo = fallbackInfo === null ? adopted : { ...adopted, fromModel: fallbackInfo.fromModel };
-          if (tierSkipped !== null)
-            for (const id of tierSkipped)
-              tried.delete(id);
-          tierSkipped = null;
-          if (DEBUG)
-            log(`~~ every ${adapter.id} account is tier-limited for ${adopted.fromModel} -> downgraded to ${adopted.toModel}`);
-          continue;
-        }
-        if (cfg.maxWaitMs > 0 && waitableCooldownIds) {
-          const resumeAt = soonestCooldownUntil(pool.accounts, now, waitableCooldownIds);
-          if (resumeAt !== null && resumeAt <= waitDeadline) {
-            let remaining = resumeAt - Date.now();
-            while (remaining > 0) {
-              await sleepAbortable(remaining, signal);
-              remaining = resumeAt - Date.now();
-            }
-            tried.clear();
-            waitableCooldownIds.clear();
-            continue;
-          }
-        }
-        break;
-      }
-      const { account, degraded, sticky } = selection;
-      tried.add(account.id);
-      if (currentTier !== null && (account.modelCooldownsUntil?.[currentTier] ?? 0) > now) {
-        const plan = planDowngrade();
-        if (plan !== null) {
-          pendingTierFallback = plan;
-          tierSkipped ??= new Set;
-          tierSkipped.add(account.id);
-          if (DEBUG)
-            log(`~~ ${account.label} ${currentTier} tier exhausted -> skipped for ${currentTier}`);
-          continue;
-        }
-      }
-      try {
-        await ensureAccessToken(adapter, account, now);
-        const headers = new Headers(baseHeaders);
-        adapter.applyAuth(headers, account);
-        if (DEBUG)
-          log(`-> ${adapter.id} via ${account.label}${sticky ? " (sticky)" : ""}${degraded ? " (degraded)" : ""}`);
-        const res = await fetch(transformedUrl, {
-          ...init,
-          body: currentBody,
-          headers
-        });
-        const cls = adapter.classifyError(res.status);
-        if (cls === "account" || cls === "auth") {
-          await res.body?.cancel().catch(ignore);
-          if (cls === "account" && typeof currentBody === "string") {
-            const reactiveNow = Date.now();
-            const plan = adapter.planReactiveFallback?.(res, currentBody, reactiveNow, models);
-            if (plan) {
-              await recordModelCooldown(account.id, plan.tier, plan.resetAt, adapter.parseUsageHeaders(res.headers), reactiveNow);
-              const local = account.modelCooldownsUntil ??= {};
-              local[plan.tier] = Math.max(local[plan.tier] ?? 0, plan.resetAt);
-              pendingTierFallback = plan.fallback;
-              tierSkipped ??= new Set;
-              tierSkipped.add(account.id);
-              lastError = new Error(`${adapter.id} account "${account.label}" hit its "${plan.tier}" model-tier cap`);
-              if (DEBUG)
-                log(`~~ ${account.label} ${plan.tier} tier limited -> rotating (fallback ${plan.fallback.toModel} pending)`);
-              continue;
-            }
-          }
-          const ms = cls === "auth" ? AUTH_COOLDOWN_MS : ACCOUNT_COOLDOWN_MS;
-          await recordRotation(adapter, account.id, res, ms, Date.now());
-          if (cls === "account") {
-            waitableCooldownIds ??= new Set;
-            waitableCooldownIds.add(account.id);
-          }
-          lastError = new Error(`${adapter.id} account "${account.label}" returned ${res.status}`);
-          if (DEBUG)
-            log(`!! ${account.label} ${res.status} (${cls}) -> rotating`);
-          continue;
-        }
-        const successNow = Date.now();
-        const partial2 = adapter.parseUsageHeaders(res.headers);
-        if (partial2)
-          applyUsagePartial(account, partial2, successNow);
-        if (fallbackInfo)
-          hooks.onModelFallback?.(adapter.id, account, fallbackInfo.fromModel, fallbackInfo.toModel, fallbackInfo.fromTier);
-        hooks.onUse?.(adapter.id, account);
-        await recordSuccess(adapter, account.id, partial2, sessionKey, successNow, cfg.sessionTtlMs);
-        return adapter.transformResponse(res);
-      } catch (error45) {
-        lastError = error45;
-        const aborted2 = signal?.aborted === true || error45 instanceof Error && error45.name === "AbortError";
-        if (aborted2)
-          throw error45;
-        if (!account.disabledReason)
-          await applyCooldown(account.id, AUTH_COOLDOWN_MS);
-        if (DEBUG)
-          log(`!! ${account.label} threw: ${error45 instanceof Error ? error45.message : String(error45)}`);
-        continue;
-      }
-    }
-    throw lastError ?? new Error(`${adapter.id}: no usable account in the load-balancer pool`);
+function downgradeModel(body, models) {
+  const setting = resolveFallbackSetting();
+  if (setting.kind === "disabled")
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  const from = parsed.model;
+  if (typeof from !== "string")
+    return null;
+  const fromFamily = modelFamily(from);
+  if (fromFamily === null)
+    return null;
+  const target = setting.kind === "pinned" ? setting.model : ladderTargetForFamily(fromFamily, models) ?? DEFAULT_OPUS_FALLBACK_MODEL;
+  if (modelFamily(target) === fromFamily)
+    return null;
+  parsed.model = target;
+  return {
+    body: JSON.stringify(parsed),
+    fromModel: from,
+    toModel: target,
+    fromTier: fromFamily
   };
 }
-
-// src/status.ts
-var PROVIDER_NAMES = {
-  anthropic: "Claude",
-  openai: "Codex"
-};
-function compareAscii(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-function byProviderId(a, b) {
-  return compareAscii(a[0], b[0]);
+function parseTierReset(res, now) {
+  const ms = secondsToMs(Number(res.headers.get(UNIFIED_RESET_HEADER)));
+  if (ms > now && ms - now <= TIER_RESET_MAX_MS)
+    return ms;
+  return now + TIER_RESET_FALLBACK_MS;
 }
-function isExpired(window, now) {
-  return !!window && window.resetAt > 0 && window.resetAt <= now;
+function planReactiveFallback(res, body, now, models) {
+  const claim = res.headers.get(REPRESENTATIVE_CLAIM_HEADER);
+  if (!claim || !MODEL_TIER_CLAIM_RE.test(claim))
+    return null;
+  const fallback = downgradeModel(body, models);
+  if (!fallback)
+    return null;
+  return {
+    tier: fallback.fromTier,
+    resetAt: parseTierReset(res, now),
+    fallback
+  };
 }
-function toStatus(account, now, current, available, rank) {
-  const weekly = account.usage.weekly;
-  const weeklyExpired = isExpired(weekly, now);
+
+// src/providers/oauth-callback.ts
+function toTokenSet(json2, previousRefresh) {
   return {
-    id: account.id,
-    label: account.label,
-    weeklyUtil: displayUtil(weekly, now),
-    hourlyUtil: displayUtil(account.usage.hourly, now),
-    weeklyResetAt: weekly && !weeklyExpired ? weekly.resetAt : 0,
-    available,
-    cooldownUntil: account.cooldownUntil,
-    modelCooldownsUntil: account.modelCooldownsUntil ?? {},
-    disabledReason: account.disabledReason,
-    current,
-    rank
+    access: json2.access_token,
+    refresh: json2.refresh_token || previousRefresh,
+    expires: Date.now() + json2.expires_in * 1000
   };
 }
-function buildStatus(pool, now, cfg = DEFAULT_CONFIG) {
-  const byProvider = new Map;
-  for (const a of pool.accounts) {
-    const list = byProvider.get(a.providerID);
-    if (list)
-      list.push(a);
-    else
-      byProvider.set(a.providerID, [a]);
+async function readTokenResponse(res) {
+  const json2 = await res.json().catch(() => null);
+  if (!json2 || typeof json2.access_token !== "string" || json2.access_token === "" || !Number.isFinite(json2.expires_in) || json2.expires_in <= 0 || !Number.isFinite(json2.expires_in * 1000) || json2.refresh_token !== undefined && json2.refresh_token !== null && typeof json2.refresh_token !== "string")
+    return null;
+  return json2;
+}
+async function readExchangeResponse(res) {
+  if (!res.ok) {
+    await res.body?.cancel().catch(ignore);
+    return null;
   }
-  const sorted = [...byProvider.entries()].sort(byProviderId);
-  return sorted.map(([providerID, providerAccounts]) => {
-    const currentAccountId = pool.lastSelected[providerID] ?? null;
-    const ranked = providerAccounts.map((a) => {
-      const available = isAvailable(a, cfg, now);
-      return {
-        a,
-        available,
-        score: available ? scoreAccount(a, cfg, now) : Number.NEGATIVE_INFINITY,
-        weeklyUtil: a.usage.weekly?.utilization ?? 0
-      };
-    }).sort(compareRanked);
-    const accounts = ranked.map(({ a, available }, i) => toStatus(a, now, a.id === currentAccountId, available, i + 1));
-    return { providerID, accounts };
-  });
+  return readTokenResponse(res);
 }
-async function readStatus(now = Date.now(), cfg = loadConfig()) {
-  return buildStatus(await readPool(), now, cfg);
+async function readRefreshResponse(res) {
+  if (!res.ok)
+    throw new Error(`Token refresh failed: ${res.status} — ${await res.text()}`);
+  const json2 = await readTokenResponse(res);
+  if (!json2)
+    throw new Error(`Token refresh failed: ${res.status} — malformed token response body`);
+  return json2;
 }
-function pct(u) {
-  return typeof u === "number" ? `${Math.round(u * 100)}%` : "-";
+function generateState() {
+  return crypto.randomUUID().replaceAll("-", "");
 }
-function displayWidth(s) {
-  let width = 0;
-  for (const ch of s) {
-    const cp = ch.codePointAt(0) ?? 0;
-    const wide = cp >= 4352 && cp <= 4447 || cp >= 11904 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65280 && cp <= 65376 || cp >= 65504 && cp <= 65510 || cp >= 131072 && cp <= 262141;
-    width += wide ? 2 : 1;
-  }
-  return width;
-}
-function padDisplayEnd(s, width) {
-  const pad = width - displayWidth(s);
-  return pad > 0 ? s + " ".repeat(pad) : s;
-}
-function relTime(at, now) {
-  if (at <= now)
-    return "-";
-  const mins = Math.max(1, Math.round((at - now) / 60000));
-  if (mins < 60)
-    return `${mins}m`;
-  const hrs = Math.floor(mins / 60);
-  if (hrs < 24)
-    return `${hrs}h${mins % 60}m`;
-  return `${Math.floor(hrs / 24)}d${hrs % 24}h`;
-}
-function stateOf(a, now) {
-  if (a.disabledReason)
-    return "re-login";
-  if (a.cooldownUntil > now)
-    return `cooldown ${relTime(a.cooldownUntil, now)}`;
-  if (!a.available)
-    return "exhausted";
-  const base = a.current ? "in use" : "ready";
-  const tiers = Object.entries(a.modelCooldownsUntil).filter(([, until]) => until > now).sort(([x], [y]) => compareAscii(x, y)).map(([tier, until]) => `${tier} ${relTime(until, now)}`);
-  if (tiers.length > 0)
-    return `${base} · ${tiers.join(" · ")}`;
-  return base;
-}
-function providerName(providerID) {
-  return PROVIDER_NAMES[providerID] ?? providerID;
-}
-function renderStatus(providers, now = Date.now()) {
-  if (providers.length === 0)
-    return "auth-load-balancer: no accounts registered.";
-  const lines = [];
-  for (const p of providers) {
-    const current = p.accounts.find((a) => a.current);
-    lines.push(`${providerName(p.providerID)} — in use: ${current ? current.label : "(none yet)"}`);
-    const width = p.accounts.reduce((w, a) => Math.max(w, displayWidth(a.label)), 16);
-    lines.push(`  #  ${"account".padEnd(width + 3)}weekly   5h   resets   state`);
-    for (const a of p.accounts) {
-      const mark = a.current ? "▶" : " ";
-      lines.push(`  ${String(a.rank).padEnd(2)} ${mark} ${padDisplayEnd(a.label, width)} ${pct(a.weeklyUtil).padStart(5)} ${pct(a.hourlyUtil).padStart(5)} ${relTime(a.weeklyResetAt, now).padStart(7)}  ${stateOf(a, now)}`);
+function parseCallbackInput(input, options = {}) {
+  const trimmed = input.trim();
+  let isUrl = false;
+  try {
+    const url2 = new URL(trimmed);
+    isUrl = true;
+    const code2 = url2.searchParams.get("code");
+    const state2 = url2.searchParams.get("state");
+    if (code2 && state2)
+      return { code: code2, state: state2 };
+  } catch {}
+  if (options.allowHashFormat && !isUrl) {
+    const hashSplits = trimmed.split("#");
+    if (hashSplits.length === 2 && hashSplits[0] && hashSplits[1]) {
+      return { code: hashSplits[0], state: hashSplits[1] };
     }
-    lines.push("");
   }
-  return lines.join(`
-`).trimEnd();
+  const params = new URLSearchParams(trimmed);
+  const code = params.get("code");
+  const state = params.get("state");
+  if (code && state)
+    return { code, state };
+  return null;
 }
 
-// src/notify.ts
-async function postToast(client, body) {
-  await client.tui.showToast({ body }).catch(ignore);
-}
-var lastToasted = new Map;
-async function notifyOnSwitch(client, providerID, account) {
-  if (lastToasted.get(providerID) === account.id)
-    return;
-  lastToasted.set(providerID, account.id);
-  const now = Date.now();
-  const message = `▶ ${account.label}  ·  weekly ${pct(displayUtil(account.usage.weekly, now))}  ·  5h ${pct(displayUtil(account.usage.hourly, now))}`;
-  await postToast(client, {
-    title: `${providerName(providerID)} account`,
-    message,
-    variant: "info",
-    duration: 4000
-  });
+// src/providers/pkce.ts
+function base64UrlEncode(bytes) {
+  return Buffer.from(bytes).toString("base64url");
 }
-var lastFallbackToasted = new Map;
-var LAST_FALLBACK_TOASTED_MAX = 256;
-async function notifyModelFallback(client, providerID, account, fromModel, toModel, fromTier) {
-  const key = `${providerID}:${account.id}`;
-  const now = Date.now();
-  const tiers = account.modelCooldownsUntil;
-  let latestWindow = 0;
-  const triggeringWindow = fromTier ? tiers?.[fromTier] : undefined;
-  if (triggeringWindow !== undefined && triggeringWindow > now) {
-    latestWindow = triggeringWindow;
-  } else if (tiers) {
-    for (const until of Object.values(tiers)) {
-      if (until > now && until > latestWindow)
-        latestWindow = until;
-    }
-  }
-  const window = `${fromModel}@${latestWindow}`;
-  if (lastFallbackToasted.get(key) === window)
-    return;
-  setBounded(lastFallbackToasted, key, window, LAST_FALLBACK_TOASTED_MAX);
-  await postToast(client, {
-    title: `${providerName(providerID)} model fallback`,
-    message: `▶ ${account.label}  ·  ${fromModel} → ${toModel} (model-tier weekly limit)`,
-    variant: "warning",
-    duration: 6000
-  });
+async function generatePKCE() {
+  const buf = new Uint8Array(64);
+  crypto.getRandomValues(buf);
+  const verifier = base64UrlEncode(buf);
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return {
+    verifier,
+    challenge: base64UrlEncode(new Uint8Array(digest))
+  };
 }
 
-// src/prime.ts
-async function primeInUse(providerID, now) {
-  const snapshot = await readPool();
-  if (!snapshot.accounts.some((a) => a.providerID === providerID))
-    return;
-  const cfg = loadConfig();
-  const preview = selectAccount(snapshot.accounts, providerID, now, cfg);
-  if (!preview || snapshot.lastSelected[providerID] === preview.account.id)
-    return;
-  await mutatePool((pool) => {
-    const selection = selectAccount(pool.accounts, providerID, now, cfg);
-    if (selection)
-      pool.lastSelected[providerID] = selection.account.id;
+// src/providers/anthropic/oauth.ts
+async function postToken(body) {
+  return fetch(TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/plain, */*",
+      "User-Agent": "axios/1.13.6"
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(OAUTH_HTTP_TIMEOUT_MS)
   });
 }
-
-// src/providers/types.ts
-function classifyHttpStatus(status) {
-  if (status === 429 || status === 402)
-    return "account";
-  if (status === 401 || status === 403)
-    return "auth";
-  if (status >= 500)
-    return "service";
-  return "ok";
+async function authorize() {
+  const pkce = await generatePKCE();
+  const state = generateState();
+  const url2 = new URL(AUTHORIZE_URL);
+  url2.searchParams.set("code", "true");
+  url2.searchParams.set("client_id", CLIENT_ID);
+  url2.searchParams.set("response_type", "code");
+  url2.searchParams.set("redirect_uri", CODE_CALLBACK_URL);
+  url2.searchParams.set("scope", OAUTH_SCOPES.join(" "));
+  url2.searchParams.set("code_challenge", pkce.challenge);
+  url2.searchParams.set("code_challenge_method", "S256");
+  url2.searchParams.set("state", state);
+  return {
+    url: url2.toString(),
+    redirectUri: CODE_CALLBACK_URL,
+    state,
+    verifier: pkce.verifier
+  };
 }
-function urlFromInput(input) {
-  try {
-    return new URL(input instanceof Request ? input.url : input);
-  } catch {
+async function exchange(input, verifier, redirectUri, expectedState) {
+  const callback = parseCallbackInput(input, { allowHashFormat: true });
+  if (!callback)
     return null;
-  }
-}
-
-// src/providers/anthropic/fallback.ts
-var TIER_RESET_FALLBACK_MS = 60 * 60 * 1000;
-var TIER_RESET_MAX_MS = MAX_QUOTA_RESET_BOUND_MS;
-var ALPHA_SEGMENT_RE = /^[a-z]+$/;
-var DIGIT_SEGMENT_RE = /^\d+$/;
-var DATE_SEGMENT_RE = /^\d{8}$/;
-function modelFamily(model) {
-  const lower = model.toLowerCase();
-  if (!lower.startsWith("claude"))
+  if (expectedState && callback.state !== expectedState)
     return null;
-  for (const segment of lower.split("-")) {
-    if (segment !== "claude" && ALPHA_SEGMENT_RE.test(segment))
-      return segment;
-  }
-  return null;
-}
-function requestModelTier(body) {
-  let parsed;
-  try {
-    parsed = JSON.parse(body);
-  } catch {
+  const result = await postToken({
+    code: callback.code,
+    state: callback.state,
+    grant_type: "authorization_code",
+    client_id: CLIENT_ID,
+    redirect_uri: redirectUri,
+    code_verifier: verifier
+  });
+  const json2 = await readExchangeResponse(result);
+  if (!json2)
     return null;
-  }
-  const model = parsed.model;
-  return typeof model === "string" ? modelFamily(model) : null;
+  return toTokenSet(json2, "");
 }
-function versionVector(model) {
-  const version2 = [];
-  let date5 = -1;
-  for (const segment of model.split("-")) {
-    if (DATE_SEGMENT_RE.test(segment))
-      date5 = Number(segment);
-    else if (DIGIT_SEGMENT_RE.test(segment))
-      version2.push(Number(segment));
-  }
-  return { version: version2, date: date5 };
+async function refresh(refreshToken) {
+  const response = await postToken({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: CLIENT_ID
+  });
+  const json2 = await readRefreshResponse(response);
+  return toTokenSet(json2, refreshToken);
 }
-function compareVersions(a, b) {
-  const len = Math.max(a.version.length, b.version.length);
-  for (let i = 0;i < len; i++) {
-    const d = (a.version[i] ?? -1) - (b.version[i] ?? -1);
-    if (d !== 0)
-      return d;
+
+// src/providers/anthropic/cch.ts
+import { createHash as createHash2 } from "node:crypto";
+function messageText({ content }) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block?.type === "text")
+        return typeof block.text === "string" ? block.text : "";
+    }
   }
-  return a.date - b.date;
-}
-function bestOfFamily(models, family) {
-  let best = null;
-  let bestVersion = {
-    version: [],
-    date: -1
-  };
-  for (const model of models) {
-    if (modelFamily(model) !== family)
-      continue;
-    const version2 = versionVector(model);
-    if (best === null || compareVersions(version2, bestVersion) > 0) {
-      best = model;
-      bestVersion = version2;
-    }
-  }
-  return best;
-}
-var computeFamilyOrder = memoOne((raw) => {
-  const parsed = (raw ?? "").split(",").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
-  return parsed.length > 0 ? parsed : DEFAULT_FAMILY_ORDER;
-});
-function resolveFamilyOrder() {
-  return computeFamilyOrder(process.env.OPENCODE_AUTH_LB_ANTHROPIC_FAMILY_ORDER);
-}
-var computeFallbackSetting = memoOne((raw) => {
-  const trimmed = raw?.trim();
-  return raw === undefined ? { kind: "ladder" } : trimmed ? { kind: "pinned", model: trimmed } : { kind: "disabled" };
-});
-function resolveFallbackSetting() {
-  return computeFallbackSetting(process.env.OPENCODE_AUTH_LB_ANTHROPIC_OPUS_FALLBACK_MODEL);
-}
-function ladderTargetForFamily(fromFamily, models) {
-  const order = resolveFamilyOrder();
-  const start = order.indexOf(fromFamily) + 1;
-  for (let i = start;i < order.length; i++) {
-    const family = order[i];
-    if (family === undefined)
-      continue;
-    const best = bestOfFamily(models, family);
-    if (best !== null)
-      return best;
-  }
-  return null;
-}
-function downgradeModel(body, models) {
-  const setting = resolveFallbackSetting();
-  if (setting.kind === "disabled")
-    return null;
-  let parsed;
-  try {
-    parsed = JSON.parse(body);
-  } catch {
-    return null;
-  }
-  const from = parsed.model;
-  if (typeof from !== "string")
-    return null;
-  const fromFamily = modelFamily(from);
-  if (fromFamily === null)
-    return null;
-  const target = setting.kind === "pinned" ? setting.model : ladderTargetForFamily(fromFamily, models) ?? DEFAULT_OPUS_FALLBACK_MODEL;
-  if (modelFamily(target) === fromFamily)
-    return null;
-  parsed.model = target;
-  return {
-    body: JSON.stringify(parsed),
-    fromModel: from,
-    toModel: target,
-    fromTier: fromFamily
-  };
-}
-function parseTierReset(res, now) {
-  const ms = secondsToMs(Number(res.headers.get(UNIFIED_RESET_HEADER)));
-  if (ms > now && ms - now <= TIER_RESET_MAX_MS)
-    return ms;
-  return now + TIER_RESET_FALLBACK_MS;
-}
-function planReactiveFallback(res, body, now, models) {
-  const claim = res.headers.get(REPRESENTATIVE_CLAIM_HEADER);
-  const tier = claim ? MODEL_TIER_CLAIM_RE.exec(claim)?.[1] : undefined;
-  if (!tier)
-    return null;
-  const fallback = downgradeModel(body, models);
-  if (!fallback)
-    return null;
-  return { tier, resetAt: parseTierReset(res, now), fallback };
-}
-
-// src/providers/oauth-callback.ts
-function toTokenSet(json2, previousRefresh) {
-  return {
-    access: json2.access_token,
-    refresh: json2.refresh_token || previousRefresh,
-    expires: Date.now() + json2.expires_in * 1000
-  };
-}
-async function readTokenResponse(res) {
-  const json2 = await res.json().catch(() => null);
-  if (!json2 || typeof json2.access_token !== "string" || json2.access_token === "" || !Number.isFinite(json2.expires_in) || json2.expires_in <= 0 || !Number.isFinite(json2.expires_in * 1000) || json2.refresh_token !== undefined && json2.refresh_token !== null && typeof json2.refresh_token !== "string")
-    return null;
-  return json2;
-}
-async function readExchangeResponse(res) {
-  if (!res.ok) {
-    await res.body?.cancel().catch(ignore);
-    return null;
-  }
-  return readTokenResponse(res);
-}
-async function readRefreshResponse(res) {
-  if (!res.ok)
-    throw new Error(`Token refresh failed: ${res.status} — ${await res.text()}`);
-  const json2 = await readTokenResponse(res);
-  if (!json2)
-    throw new Error(`Token refresh failed: ${res.status} — malformed token response body`);
-  return json2;
-}
-function generateState() {
-  return crypto.randomUUID().replaceAll("-", "");
-}
-function parseCallbackInput(input, options = {}) {
-  const trimmed = input.trim();
-  let isUrl = false;
-  try {
-    const url2 = new URL(trimmed);
-    isUrl = true;
-    const code2 = url2.searchParams.get("code");
-    const state2 = url2.searchParams.get("state");
-    if (code2 && state2)
-      return { code: code2, state: state2 };
-  } catch {}
-  if (options.allowHashFormat && !isUrl) {
-    const hashSplits = trimmed.split("#");
-    if (hashSplits.length === 2 && hashSplits[0] && hashSplits[1]) {
-      return { code: hashSplits[0], state: hashSplits[1] };
-    }
-  }
-  const params = new URLSearchParams(trimmed);
-  const code = params.get("code");
-  const state = params.get("state");
-  if (code && state)
-    return { code, state };
-  return null;
-}
-
-// src/providers/pkce.ts
-function base64UrlEncode(bytes) {
-  return Buffer.from(bytes).toString("base64url");
-}
-async function generatePKCE() {
-  const buf = new Uint8Array(64);
-  crypto.getRandomValues(buf);
-  const verifier = base64UrlEncode(buf);
-  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
-  return {
-    verifier,
-    challenge: base64UrlEncode(new Uint8Array(digest))
-  };
-}
-
-// src/providers/anthropic/oauth.ts
-async function postToken(body) {
-  return fetch(TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "application/json, text/plain, */*",
-      "User-Agent": "axios/1.13.6"
-    },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(OAUTH_HTTP_TIMEOUT_MS)
-  });
-}
-async function authorize() {
-  const pkce = await generatePKCE();
-  const state = generateState();
-  const url2 = new URL(AUTHORIZE_URL);
-  url2.searchParams.set("code", "true");
-  url2.searchParams.set("client_id", CLIENT_ID);
-  url2.searchParams.set("response_type", "code");
-  url2.searchParams.set("redirect_uri", CODE_CALLBACK_URL);
-  url2.searchParams.set("scope", OAUTH_SCOPES.join(" "));
-  url2.searchParams.set("code_challenge", pkce.challenge);
-  url2.searchParams.set("code_challenge_method", "S256");
-  url2.searchParams.set("state", state);
-  return {
-    url: url2.toString(),
-    redirectUri: CODE_CALLBACK_URL,
-    state,
-    verifier: pkce.verifier
-  };
-}
-async function exchange(input, verifier, redirectUri, expectedState) {
-  const callback = parseCallbackInput(input, { allowHashFormat: true });
-  if (!callback)
-    return null;
-  if (expectedState && callback.state !== expectedState)
-    return null;
-  const result = await postToken({
-    code: callback.code,
-    state: callback.state,
-    grant_type: "authorization_code",
-    client_id: CLIENT_ID,
-    redirect_uri: redirectUri,
-    code_verifier: verifier
-  });
-  const json2 = await readExchangeResponse(result);
-  if (!json2)
-    return null;
-  return toTokenSet(json2, "");
-}
-async function refresh(refreshToken) {
-  const response = await postToken({
-    grant_type: "refresh_token",
-    refresh_token: refreshToken,
-    client_id: CLIENT_ID
-  });
-  const json2 = await readRefreshResponse(response);
-  return toTokenSet(json2, refreshToken);
-}
-
-// src/providers/anthropic/cch.ts
-import { createHash as createHash2 } from "node:crypto";
-function messageText({ content }) {
-  if (typeof content === "string")
-    return content;
-  if (Array.isArray(content)) {
-    for (const block of content) {
-      if (block?.type === "text")
-        return typeof block.text === "string" ? block.text : "";
-    }
-  }
-  return "";
+  return "";
 }
 function computeCCH(messageText2) {
   return createHash2("sha256").update(messageText2).digest("hex").slice(0, 5);
@@ -14572,131 +14100,681 @@ async function exchange2(input, verifier, redirectUri, expectedState) {
     return null;
   return toTokenSet2(json2, "");
 }
-async function refresh2(refreshToken) {
-  const body = new URLSearchParams({
-    grant_type: "refresh_token",
-    refresh_token: refreshToken,
-    client_id: CLIENT_ID2
+async function refresh2(refreshToken) {
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: refreshToken,
+    client_id: CLIENT_ID2
+  });
+  const json2 = await readRefreshResponse(await postToken2(body));
+  return toTokenSet2(json2, refreshToken);
+}
+
+// src/providers/openai/transform.ts
+function applyAuth(headers, account) {
+  headers.delete("x-api-key");
+  headers.set("authorization", `Bearer ${account.access}`);
+  const accountId = resolveAccountId(account);
+  if (accountId)
+    headers.set("chatgpt-account-id", accountId);
+  headers.set("openai-beta", OPENAI_BETA);
+  headers.set("originator", ORIGINATOR);
+  headers.set("user-agent", USER_AGENT2);
+  headers.set("session-id", SESSION_ID);
+}
+function rewriteUrl2(input) {
+  const url2 = urlFromInput(input);
+  if (!url2)
+    return input;
+  if (!url2.pathname.includes("/responses"))
+    return input;
+  if (url2.href === CODEX_RESPONSES_URL)
+    return input;
+  return input instanceof Request ? new Request(CODEX_RESPONSES_URL, input) : CODEX_RESPONSES_URL;
+}
+function applyInstructions(obj) {
+  let instructions = typeof obj.instructions === "string" ? obj.instructions : "";
+  if (Array.isArray(obj.input)) {
+    const input = obj.input;
+    const systemTexts = [];
+    let remaining = null;
+    let i = 0;
+    for (const raw of input) {
+      if (raw && raw.type === "message" && raw.role === "system") {
+        if (remaining === null)
+          remaining = input.slice(0, i);
+        const text = joinBlockTexts(raw.content, `
+`);
+        if (text)
+          systemTexts.push(text);
+      } else if (remaining !== null) {
+        remaining.push(raw);
+      }
+      i++;
+    }
+    if (systemTexts.length > 0) {
+      instructions = [instructions, ...systemTexts].filter(Boolean).join(`
+
+`);
+    }
+    if (remaining !== null)
+      obj.input = remaining;
+  }
+  obj.instructions = instructions.trim() || "You are a helpful assistant.";
+}
+function rewriteRequestBody2(body) {
+  try {
+    const obj = JSON.parse(body);
+    obj.store = false;
+    const include = Array.isArray(obj.include) ? obj.include : [];
+    obj.include = include.includes("reasoning.encrypted_content") && new Set(include).size === include.length ? include : [...new Set([...include, "reasoning.encrypted_content"])];
+    applyInstructions(obj);
+    delete obj.max_output_tokens;
+    return JSON.stringify(obj);
+  } catch {
+    return body;
+  }
+}
+
+// src/providers/openai/usage.ts
+var WEEK_MINUTES = 7 * 24 * 60;
+function isWeeklyMinutes(minutes) {
+  return minutes >= WEEK_MINUTES * 0.95 && minutes <= WEEK_MINUTES * 1.05;
+}
+var PRIMARY_WINDOW_MINUTES_HEADER = "x-codex-primary-window-minutes";
+var HEADER_SPEC2 = {
+  hourlyUtil: "x-codex-primary-used-percent",
+  hourlyReset: "x-codex-primary-reset-at",
+  weeklyUtil: "x-codex-secondary-used-percent",
+  weeklyReset: "x-codex-secondary-reset-at",
+  divisor: 100
+};
+var WEEKLY_PRIMARY_HEADER_SPEC = {
+  hourlyUtil: HEADER_SPEC2.weeklyUtil,
+  hourlyReset: HEADER_SPEC2.weeklyReset,
+  weeklyUtil: HEADER_SPEC2.hourlyUtil,
+  weeklyReset: HEADER_SPEC2.hourlyReset,
+  divisor: HEADER_SPEC2.divisor
+};
+function parseUsageHeaders2(headers) {
+  const primaryWindowMinutes = Number(headers.get(PRIMARY_WINDOW_MINUTES_HEADER));
+  const spec = isWeeklyMinutes(primaryWindowMinutes) ? WEEKLY_PRIMARY_HEADER_SPEC : HEADER_SPEC2;
+  return parseWindowPairHeaders(headers, spec);
+}
+function endpointWindow2(w) {
+  return endpointWindowFrom(w, (win) => win.used_percent, 100, (win) => secondsToMs(Number(win.reset_at ?? 0)));
+}
+async function fetchUsage2(account, now) {
+  const headers = {
+    authorization: `Bearer ${account.access}`,
+    "user-agent": USAGE_USER_AGENT2,
+    accept: "application/json"
+  };
+  const accountId = resolveAccountId(account);
+  if (accountId)
+    headers["chatgpt-account-id"] = accountId;
+  const json2 = await fetchUsageJson(USAGE_URL2, headers, USAGE_HTTP_TIMEOUT_MS);
+  const rateLimit = json2?.rate_limit;
+  if (!isPlainObject2(rateLimit))
+    return null;
+  const { primary_window: primary, secondary_window: secondary } = rateLimit;
+  const primaryIsWeekly = isWeeklyMinutes(Math.ceil(Number(primary?.limit_window_seconds) / 60));
+  return {
+    hourly: endpointWindow2(primaryIsWeekly ? secondary : primary),
+    weekly: endpointWindow2(primaryIsWeekly ? primary : secondary),
+    capturedAt: now
+  };
+}
+
+// src/providers/openai/adapter.ts
+var openaiAdapter = {
+  id: PROVIDER_ID2,
+  authorize: authorize2,
+  exchange: exchange2,
+  refresh: refresh2,
+  applyAuth,
+  transformUrl: rewriteUrl2,
+  transformBody: rewriteRequestBody2,
+  transformResponse(response) {
+    return response;
+  },
+  parseUsageHeaders: parseUsageHeaders2,
+  fetchUsage: fetchUsage2,
+  classifyError: classifyHttpStatus
+};
+
+// src/providers/registry.ts
+var ADAPTERS = [
+  anthropicAdapter,
+  openaiAdapter
+];
+function adapterFor(adapters, providerID) {
+  for (const adapter of adapters)
+    if (adapter.id === providerID)
+      return adapter;
+  return;
+}
+
+// src/usage-refresh.ts
+var SEED_TTL_MS = 5 * 60 * 1000;
+var MAX_TRANSIENT_COOLDOWN_MS = 5 * 60 * 1000;
+var lastPoll = new Map;
+async function refreshUsage(adapters, now, poolSnapshot) {
+  const pool = poolSnapshot ?? await readPool();
+  const aliveIds = lastPoll.size > 0 ? new Set : undefined;
+  let stale;
+  for (const account of pool.accounts) {
+    aliveIds?.add(account.id);
+    if (account.disabledReason)
+      continue;
+    if (account.usage.capturedAt !== 0 && now - account.usage.capturedAt <= SEED_TTL_MS)
+      continue;
+    const adapter = adapterFor(adapters, account.providerID);
+    if (!adapter)
+      continue;
+    if ((lastPoll.get(account.id) ?? 0) > now - SEED_TTL_MS)
+      continue;
+    lastPoll.set(account.id, now);
+    stale ??= [];
+    stale.push({ adapter, account });
+  }
+  if (aliveIds) {
+    for (const id of lastPoll.keys())
+      if (!aliveIds.has(id))
+        lastPoll.delete(id);
+  }
+  if (!stale)
+    return;
+  const scoreCfg = loadScoreConfig();
+  await Promise.all(stale.map(async ({ adapter, account }) => {
+    try {
+      await ensureAccessToken(adapter, account, now);
+      const snapshot = await adapter.fetchUsage(account, now);
+      if (snapshot) {
+        await mutatePool((p) => {
+          const stored = findAccount(p, account.id);
+          if (stored) {
+            stored.usage = {
+              hourly: snapshot.hourly ?? stored.usage.hourly,
+              weekly: snapshot.weekly === null ? stored.usage.weekly : preserveWeeklyAnchor(snapshot.weekly, stored.usage.weekly, now),
+              capturedAt: snapshot.weekly === null ? stored.usage.capturedAt : now
+            };
+            if (snapshot.weekly !== null && stored.cooldownUntil > now + MAX_TRANSIENT_COOLDOWN_MS && !isExhausted(stored, scoreCfg, now))
+              stored.cooldownUntil = 0;
+          }
+        });
+      }
+    } catch {}
+  }));
+}
+function refreshUsageInBackground(adapter, now, poolSnapshot) {
+  return refreshUsage([adapter], now, poolSnapshot);
+}
+function refreshAllUsageInBackground(now, poolSnapshot) {
+  return refreshUsage(ADAPTERS, now, poolSnapshot);
+}
+
+// src/fetch.ts
+var ACCOUNT_COOLDOWN_MS = 5 * 60 * 1000;
+var AUTH_COOLDOWN_MS = 2 * 60 * 1000;
+var DEBUG = process.env.OPENCODE_AUTH_LB_DEBUG === "1" || process.env.OPENCODE_AUTH_LB_DEBUG === "true";
+function log(message) {
+  if (DEBUG)
+    console.error(`[auth-lb] ${message}`);
+}
+async function bestEffort(what, op) {
+  try {
+    await op();
+  } catch (error45) {
+    if (error45 instanceof LockTimeoutError || error45 instanceof PoolReadError || error45 instanceof PoolWriteError) {
+      log(`bookkeeping skipped (${what}): ${error45.message}`);
+      return;
+    }
+    throw error45;
+  }
+}
+function applyUsagePartial(account, partial2, now) {
+  if (partial2.hourly !== undefined)
+    account.usage.hourly = partial2.hourly;
+  if (partial2.weekly !== undefined) {
+    account.usage.weekly = preserveWeeklyAnchor(partial2.weekly, account.usage.weekly, now);
+    account.usage.capturedAt = now;
+  }
+}
+var RETRY_AFTER_MAX_MS = MAX_QUOTA_RESET_BOUND_MS;
+function cooldownUntilFrom(res, fallbackMs, now) {
+  let until = now + fallbackMs;
+  const retryAfter = res?.headers.get("retry-after");
+  if (retryAfter) {
+    const secs = Number(retryAfter);
+    if (Number.isFinite(secs) && secs > 0) {
+      const delta = secs * 1000;
+      if (Number.isFinite(delta) && delta <= RETRY_AFTER_MAX_MS)
+        until = now + delta;
+    } else {
+      const httpDate = Date.parse(retryAfter);
+      if (Number.isFinite(httpDate) && httpDate > now && httpDate - now <= RETRY_AFTER_MAX_MS)
+        until = httpDate;
+    }
+  }
+  return until;
+}
+async function applyCooldown(accountId, fallbackMs) {
+  const until = cooldownUntilFrom(null, fallbackMs, Date.now());
+  await bestEffort("cooldown", () => mutatePool((pool) => {
+    const account = findAccount(pool, accountId);
+    if (account)
+      account.cooldownUntil = Math.max(account.cooldownUntil, until);
+  }));
+}
+async function recordRotation(adapter, accountId, res, fallbackMs, now) {
+  const partial2 = adapter.parseUsageHeaders(res.headers);
+  const until = cooldownUntilFrom(res, fallbackMs, now);
+  await bestEffort("rotation", () => mutatePool((pool) => {
+    const account = findAccount(pool, accountId);
+    if (!account)
+      return;
+    if (partial2)
+      applyUsagePartial(account, partial2, now);
+    account.cooldownUntil = Math.max(account.cooldownUntil, until);
+  }));
+}
+async function recordModelCooldown(accountId, tier, until, partial2, now) {
+  await bestEffort("model-cooldown", () => mutatePool((pool) => {
+    const account = findAccount(pool, accountId);
+    if (!account)
+      return;
+    if (partial2)
+      applyUsagePartial(account, partial2, now);
+    const map2 = account.modelCooldownsUntil ??= {};
+    map2[tier] = Math.max(map2[tier] ?? 0, until);
+  }));
+}
+async function recordSuccess(adapter, accountId, partial2, sessionKey, now, cfg, fallback) {
+  await bestEffort("record-success", () => mutatePool((pool) => {
+    const account = findAccount(pool, accountId);
+    if (account) {
+      if (partial2)
+        applyUsagePartial(account, partial2, now);
+      if (partial2 && account.cooldownUntil > now + ACCOUNT_COOLDOWN_MS && !isExhausted(account, cfg, now))
+        account.cooldownUntil = 0;
+      pool.lastSelected[adapter.id] = accountId;
+    }
+    if (sessionKey) {
+      pool.sessions[sessionKey] = fallback ? {
+        accountId,
+        updatedAt: now,
+        fallback: { from: fallback.fromModel, to: fallback.toModel }
+      } : { accountId, updatedAt: now };
+      for (const k of Object.keys(pool.sessions)) {
+        const pin = pool.sessions[k];
+        if (pin && now - pin.updatedAt > cfg.sessionTtlMs)
+          delete pool.sessions[k];
+      }
+    }
+  }));
+}
+function noUsableAccountResponse(providerID) {
+  const message = `No usable ${providerID} account in the auth-load-balancer pool. Run "opencode auth login" to add or re-login an account.`;
+  const error45 = { type: "authentication_error", message };
+  const body = providerID === PROVIDER_ID ? { type: "error", error: error45 } : { error: error45 };
+  return new Response(JSON.stringify(body), {
+    status: 401,
+    headers: { "content-type": "application/json" }
+  });
+}
+function soonestCooldownUntil(accounts, now, accountIds) {
+  if (accountIds.size === 0)
+    return null;
+  let soonest = Number.POSITIVE_INFINITY;
+  for (const account of accounts) {
+    if (account.disabledReason)
+      continue;
+    if (!accountIds.has(account.id))
+      continue;
+    const until = account.cooldownUntil > now ? account.cooldownUntil : now;
+    if (until < soonest)
+      soonest = until;
+  }
+  return Number.isFinite(soonest) ? soonest : null;
+}
+function createLoadBalancedFetch(adapter, hooks = {}, models = []) {
+  const cfg = loadConfig();
+  return async (input, init) => {
+    const bodyStr = typeof init?.body === "string" ? init.body : undefined;
+    const baseHeaders = mergeHeaders(input, init);
+    const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+    const baseKey = deriveSessionKey(baseHeaders, bodyStr);
+    const sessionKey = baseKey ? `${adapter.id}:${baseKey}` : null;
+    baseHeaders.delete(SESSION_HEADER);
+    const tried = new Set;
+    let waitableCooldownIds = null;
+    let lastError = null;
+    let cachedRequestBytes = -1;
+    const requestBytes = cfg.cheapSwitchMaxBytes > 0 && sessionKey !== null && bodyStr ? () => {
+      if (cachedRequestBytes < 0)
+        cachedRequestBytes = Buffer.byteLength(bodyStr, "utf8");
+      return cachedRequestBytes;
+    } : 0;
+    const transformedBody = bodyStr !== undefined ? adapter.transformBody(bodyStr) : init?.body;
+    const transformedUrl = adapter.transformUrl(input);
+    let currentBody = transformedBody;
+    let currentTier = typeof bodyStr === "string" ? adapter.requestModelTier?.(bodyStr) ?? null : null;
+    let fallbackPlan = null;
+    let fallbackPlanFor = null;
+    const planDowngrade = () => {
+      if (typeof currentBody === "string" && fallbackPlanFor !== currentBody) {
+        fallbackPlanFor = currentBody;
+        fallbackPlan = adapter.planModelFallback?.(currentBody, models) ?? null;
+      }
+      return fallbackPlan;
+    };
+    let fallbackInfo = null;
+    let pendingTierFallback = null;
+    let tierSkipped = null;
+    let usageSeeded = false;
+    const waitDeadline = Date.now() + cfg.maxWaitMs;
+    for (;; ) {
+      const pool = await readPool();
+      const now = Date.now();
+      if (!usageSeeded) {
+        usageSeeded = true;
+        refreshAllUsageInBackground(now, pool).catch(ignore);
+      }
+      const selection = selectForSession(pool, adapter.id, sessionKey, now, cfg, tried, requestBytes);
+      if (!selection) {
+        if (tried.size === 0)
+          return noUsableAccountResponse(adapter.id);
+        if (pendingTierFallback !== null) {
+          const adopted = pendingTierFallback;
+          pendingTierFallback = null;
+          currentBody = adopted.body;
+          currentTier = adapter.requestModelTier?.(adopted.body) ?? null;
+          fallbackInfo = fallbackInfo === null ? adopted : { ...adopted, fromModel: fallbackInfo.fromModel };
+          if (tierSkipped !== null)
+            for (const id of tierSkipped)
+              tried.delete(id);
+          tierSkipped = null;
+          if (DEBUG)
+            log(`~~ every ${adapter.id} account is tier-limited for ${adopted.fromModel} -> downgraded to ${adopted.toModel}`);
+          continue;
+        }
+        if (cfg.maxWaitMs > 0 && waitableCooldownIds) {
+          const resumeAt = soonestCooldownUntil(pool.accounts, now, waitableCooldownIds);
+          if (resumeAt !== null && resumeAt <= waitDeadline) {
+            let remaining = resumeAt - Date.now();
+            while (remaining > 0) {
+              await sleepAbortable(remaining, signal);
+              remaining = resumeAt - Date.now();
+            }
+            tried.clear();
+            waitableCooldownIds.clear();
+            continue;
+          }
+        }
+        break;
+      }
+      const { account, degraded, sticky } = selection;
+      tried.add(account.id);
+      if (currentTier !== null && (account.modelCooldownsUntil?.[currentTier] ?? 0) > now) {
+        const plan = planDowngrade();
+        if (plan !== null) {
+          pendingTierFallback = plan;
+          tierSkipped ??= new Set;
+          tierSkipped.add(account.id);
+          if (DEBUG)
+            log(`~~ ${account.label} ${currentTier} tier exhausted -> skipped for ${currentTier}`);
+          continue;
+        }
+      }
+      try {
+        await ensureAccessToken(adapter, account, now);
+        const headers = new Headers(baseHeaders);
+        adapter.applyAuth(headers, account);
+        if (DEBUG)
+          log(`-> ${adapter.id} via ${account.label}${sticky ? " (sticky)" : ""}${degraded ? " (degraded)" : ""}`);
+        const res = await fetch(transformedUrl, {
+          ...init,
+          body: currentBody,
+          headers
+        });
+        const cls = adapter.classifyError(res.status);
+        if (cls === "account" || cls === "auth") {
+          await res.body?.cancel().catch(ignore);
+          if (cls === "account" && typeof currentBody === "string") {
+            const reactiveNow = Date.now();
+            const plan = adapter.planReactiveFallback?.(res, currentBody, reactiveNow, models);
+            if (plan) {
+              await recordModelCooldown(account.id, plan.tier, plan.resetAt, adapter.parseUsageHeaders(res.headers), reactiveNow);
+              const local = account.modelCooldownsUntil ??= {};
+              local[plan.tier] = Math.max(local[plan.tier] ?? 0, plan.resetAt);
+              pendingTierFallback = plan.fallback;
+              tierSkipped ??= new Set;
+              tierSkipped.add(account.id);
+              lastError = new Error(`${adapter.id} account "${account.label}" hit its "${plan.tier}" model-tier cap`);
+              if (DEBUG)
+                log(`~~ ${account.label} ${plan.tier} tier limited -> rotating (fallback ${plan.fallback.toModel} pending)`);
+              continue;
+            }
+          }
+          const ms = cls === "auth" ? AUTH_COOLDOWN_MS : ACCOUNT_COOLDOWN_MS;
+          await recordRotation(adapter, account.id, res, ms, Date.now());
+          if (cls === "account") {
+            waitableCooldownIds ??= new Set;
+            waitableCooldownIds.add(account.id);
+          }
+          lastError = new Error(`${adapter.id} account "${account.label}" returned ${res.status}`);
+          if (DEBUG)
+            log(`!! ${account.label} ${res.status} (${cls}) -> rotating`);
+          continue;
+        }
+        const successNow = Date.now();
+        const partial2 = adapter.parseUsageHeaders(res.headers);
+        if (partial2)
+          applyUsagePartial(account, partial2, successNow);
+        if (fallbackInfo)
+          hooks.onModelFallback?.(adapter.id, account, fallbackInfo.fromModel, fallbackInfo.toModel, fallbackInfo.fromTier);
+        hooks.onUse?.(adapter.id, account);
+        await recordSuccess(adapter, account.id, partial2, sessionKey, successNow, cfg, fallbackInfo);
+        return adapter.transformResponse(res);
+      } catch (error45) {
+        lastError = error45;
+        const aborted2 = signal?.aborted === true || error45 instanceof Error && error45.name === "AbortError";
+        if (aborted2)
+          throw error45;
+        if (!account.disabledReason)
+          await applyCooldown(account.id, AUTH_COOLDOWN_MS);
+        if (DEBUG)
+          log(`!! ${account.label} threw: ${error45 instanceof Error ? error45.message : String(error45)}`);
+        continue;
+      }
+    }
+    throw lastError ?? new Error(`${adapter.id}: no usable account in the load-balancer pool`);
+  };
+}
+
+// src/status.ts
+var PROVIDER_NAMES = {
+  anthropic: "Claude",
+  openai: "Codex"
+};
+function compareAscii(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function byProviderId(a, b) {
+  return compareAscii(a[0], b[0]);
+}
+function isExpired(window, now) {
+  return !!window && window.resetAt > 0 && window.resetAt <= now;
+}
+function toStatus(account, now, current, available, rank) {
+  const weekly = account.usage.weekly;
+  const weeklyExpired = isExpired(weekly, now);
+  return {
+    id: account.id,
+    label: account.label,
+    weeklyUtil: displayUtil(weekly, now),
+    hourlyUtil: displayUtil(account.usage.hourly, now),
+    weeklyResetAt: weekly && !weeklyExpired ? weekly.resetAt : 0,
+    available,
+    cooldownUntil: account.cooldownUntil,
+    modelCooldownsUntil: account.modelCooldownsUntil ?? {},
+    disabledReason: account.disabledReason,
+    current,
+    rank
+  };
+}
+function buildStatus(pool, now, cfg = DEFAULT_CONFIG) {
+  const byProvider = new Map;
+  for (const a of pool.accounts) {
+    const list = byProvider.get(a.providerID);
+    if (list)
+      list.push(a);
+    else
+      byProvider.set(a.providerID, [a]);
+  }
+  const sorted = [...byProvider.entries()].sort(byProviderId);
+  return sorted.map(([providerID, providerAccounts]) => {
+    const currentAccountId = pool.lastSelected[providerID] ?? null;
+    const ranked = providerAccounts.map((a) => {
+      const available = isAvailable(a, cfg, now);
+      return {
+        a,
+        available,
+        score: available ? scoreAccount(a, cfg, now) : Number.NEGATIVE_INFINITY,
+        weeklyUtil: a.usage.weekly?.utilization ?? 0
+      };
+    }).sort(compareRanked);
+    const accounts = ranked.map(({ a, available }, i) => toStatus(a, now, a.id === currentAccountId, available, i + 1));
+    return { providerID, accounts };
   });
-  const json2 = await readRefreshResponse(await postToken2(body));
-  return toTokenSet2(json2, refreshToken);
 }
-
-// src/providers/openai/transform.ts
-function applyAuth(headers, account) {
-  headers.delete("x-api-key");
-  headers.set("authorization", `Bearer ${account.access}`);
-  const accountId = resolveAccountId(account);
-  if (accountId)
-    headers.set("chatgpt-account-id", accountId);
-  headers.set("openai-beta", OPENAI_BETA);
-  headers.set("originator", ORIGINATOR);
-  headers.set("user-agent", USER_AGENT2);
-  headers.set("session-id", SESSION_ID);
+async function readStatus(now = Date.now(), cfg = loadConfig()) {
+  return buildStatus(await readPool(), now, cfg);
 }
-function rewriteUrl2(input) {
-  const url2 = urlFromInput(input);
-  if (!url2)
-    return input;
-  if (!url2.pathname.includes("/responses"))
-    return input;
-  if (url2.href === CODEX_RESPONSES_URL)
-    return input;
-  return input instanceof Request ? new Request(CODEX_RESPONSES_URL, input) : CODEX_RESPONSES_URL;
+function pct(u) {
+  return typeof u === "number" ? `${Math.round(u * 100)}%` : "-";
 }
-function applyInstructions(obj) {
-  let instructions = typeof obj.instructions === "string" ? obj.instructions : "";
-  if (Array.isArray(obj.input)) {
-    const input = obj.input;
-    const systemTexts = [];
-    let remaining = null;
-    let i = 0;
-    for (const raw of input) {
-      if (raw && raw.type === "message" && raw.role === "system") {
-        if (remaining === null)
-          remaining = input.slice(0, i);
-        const text = joinBlockTexts(raw.content, `
-`);
-        if (text)
-          systemTexts.push(text);
-      } else if (remaining !== null) {
-        remaining.push(raw);
-      }
-      i++;
-    }
-    if (systemTexts.length > 0) {
-      instructions = [instructions, ...systemTexts].filter(Boolean).join(`
-
-`);
-    }
-    if (remaining !== null)
-      obj.input = remaining;
+function displayWidth(s) {
+  let width = 0;
+  for (const ch of s) {
+    const cp = ch.codePointAt(0) ?? 0;
+    const wide = cp >= 4352 && cp <= 4447 || cp >= 11904 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65280 && cp <= 65376 || cp >= 65504 && cp <= 65510 || cp >= 131072 && cp <= 262141;
+    width += wide ? 2 : 1;
   }
-  obj.instructions = instructions.trim() || "You are a helpful assistant.";
+  return width;
 }
-function rewriteRequestBody2(body) {
-  try {
-    const obj = JSON.parse(body);
-    obj.store = false;
-    const include = Array.isArray(obj.include) ? obj.include : [];
-    obj.include = include.includes("reasoning.encrypted_content") && new Set(include).size === include.length ? include : [...new Set([...include, "reasoning.encrypted_content"])];
-    applyInstructions(obj);
-    delete obj.max_output_tokens;
-    return JSON.stringify(obj);
-  } catch {
-    return body;
+function padDisplayEnd(s, width) {
+  const pad = width - displayWidth(s);
+  return pad > 0 ? s + " ".repeat(pad) : s;
+}
+function relTime(at, now) {
+  if (at <= now)
+    return "-";
+  const mins = Math.max(1, Math.round((at - now) / 60000));
+  if (mins <= 120)
+    return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  if (mins <= 48 * 60)
+    return `${hrs}h${mins % 60}m`;
+  return `${Math.floor(hrs / 24)}d${hrs % 24}h`;
+}
+function stateOf(a, now) {
+  if (a.disabledReason)
+    return a.disabledReason === MANUAL_DISABLED_REASON ? "disabled" : "re-login";
+  if (a.cooldownUntil > now)
+    return `cooldown ${relTime(a.cooldownUntil, now)}`;
+  if (!a.available)
+    return "exhausted";
+  const base = a.current ? "in use" : "ready";
+  const tiers = Object.entries(a.modelCooldownsUntil).filter(([, until]) => until > now).sort(([x], [y]) => compareAscii(x, y)).map(([tier, until]) => `${tier} ${relTime(until, now)}`);
+  if (tiers.length > 0)
+    return `${base} · ${tiers.join(" · ")}`;
+  return base;
+}
+function providerName(providerID) {
+  return PROVIDER_NAMES[providerID] ?? providerID;
+}
+function renderStatus(providers, now = Date.now()) {
+  if (providers.length === 0)
+    return "auth-load-balancer: no accounts registered.";
+  const lines = [];
+  for (const p of providers) {
+    const current = p.accounts.find((a) => a.current);
+    lines.push(`${providerName(p.providerID)} — in use: ${current ? current.label : "(none yet)"}`);
+    const width = p.accounts.reduce((w, a) => Math.max(w, displayWidth(a.label)), 16);
+    lines.push(`  #  ${"account".padEnd(width + 3)}weekly   5h   resets   state`);
+    for (const a of p.accounts) {
+      const mark = a.current ? "▶" : " ";
+      lines.push(`  ${String(a.rank).padEnd(2)} ${mark} ${padDisplayEnd(a.label, width)} ${pct(a.weeklyUtil).padStart(5)} ${pct(a.hourlyUtil).padStart(5)} ${relTime(a.weeklyResetAt, now).padStart(7)}  ${stateOf(a, now)}`);
+    }
+    lines.push("");
   }
+  return lines.join(`
+`).trimEnd();
 }
 
-// src/providers/openai/usage.ts
-var HEADER_SPEC2 = {
-  hourlyUtil: "x-codex-primary-used-percent",
-  hourlyReset: "x-codex-primary-reset-at",
-  weeklyUtil: "x-codex-secondary-used-percent",
-  weeklyReset: "x-codex-secondary-reset-at",
-  divisor: 100
-};
-function parseUsageHeaders2(headers) {
-  return parseWindowPairHeaders(headers, HEADER_SPEC2);
+// src/notify.ts
+async function postToast(client, body) {
+  await client.tui.showToast({ body }).catch(ignore);
 }
-function endpointWindow2(w) {
-  return endpointWindowFrom(w, (win) => win.used_percent, 100, (win) => secondsToMs(Number(win.reset_at ?? 0)));
+var lastToasted = new Map;
+async function notifyOnSwitch(client, providerID, account) {
+  if (lastToasted.get(providerID) === account.id)
+    return;
+  lastToasted.set(providerID, account.id);
+  const now = Date.now();
+  const message = `▶ ${account.label}  ·  weekly ${pct(displayUtil(account.usage.weekly, now))}  ·  5h ${pct(displayUtil(account.usage.hourly, now))}`;
+  await postToast(client, {
+    title: `${providerName(providerID)} account`,
+    message,
+    variant: "info",
+    duration: 4000
+  });
 }
-async function fetchUsage2(account, now) {
-  const headers = {
-    authorization: `Bearer ${account.access}`,
-    "user-agent": USAGE_USER_AGENT2,
-    accept: "application/json"
-  };
-  const accountId = resolveAccountId(account);
-  if (accountId)
-    headers["chatgpt-account-id"] = accountId;
-  const json2 = await fetchUsageJson(USAGE_URL2, headers, USAGE_HTTP_TIMEOUT_MS);
-  if (!json2?.rate_limit)
-    return null;
-  return {
-    hourly: endpointWindow2(json2.rate_limit.primary_window),
-    weekly: endpointWindow2(json2.rate_limit.secondary_window),
-    capturedAt: now
-  };
+var lastFallbackToasted = new Map;
+var LAST_FALLBACK_TOASTED_MAX = 256;
+async function notifyModelFallback(client, providerID, account, fromModel, toModel, fromTier) {
+  const key = `${providerID}:${account.id}`;
+  const now = Date.now();
+  const tiers = account.modelCooldownsUntil;
+  let latestWindow = 0;
+  const triggeringWindow = fromTier ? tiers?.[fromTier] : undefined;
+  if (triggeringWindow !== undefined && triggeringWindow > now) {
+    latestWindow = triggeringWindow;
+  } else if (tiers) {
+    for (const until of Object.values(tiers)) {
+      if (until > now && until > latestWindow)
+        latestWindow = until;
+    }
+  }
+  const window = `${fromModel}@${latestWindow}`;
+  if (lastFallbackToasted.get(key) === window)
+    return;
+  setBounded(lastFallbackToasted, key, window, LAST_FALLBACK_TOASTED_MAX);
+  await postToast(client, {
+    title: `${providerName(providerID)} model fallback`,
+    message: `▶ ${account.label}  ·  ${fromModel} → ${toModel} (model-tier weekly limit)`,
+    variant: "warning",
+    duration: 6000
+  });
 }
 
-// src/providers/openai/adapter.ts
-var openaiAdapter = {
-  id: PROVIDER_ID2,
-  authorize: authorize2,
-  exchange: exchange2,
-  refresh: refresh2,
-  applyAuth,
-  transformUrl: rewriteUrl2,
-  transformBody: rewriteRequestBody2,
-  transformResponse(response) {
-    return response;
-  },
-  parseUsageHeaders: parseUsageHeaders2,
-  fetchUsage: fetchUsage2,
-  classifyError: classifyHttpStatus
-};
+// src/prime.ts
+async function primeInUse(providerID, now) {
+  const snapshot = await readPool();
+  if (!snapshot.accounts.some((a) => a.providerID === providerID))
+    return;
+  const cfg = loadConfig();
+  const preview = selectAccount(snapshot.accounts, providerID, now, cfg);
+  if (!preview || snapshot.lastSelected[providerID] === preview.account.id)
+    return;
+  await mutatePool((pool) => {
+    const selection = selectAccount(pool.accounts, providerID, now, cfg);
+    if (selection)
+      pool.lastSelected[providerID] = selection.account.id;
+  });
+}
 
 // src/index.ts
 var PROVIDER_LABELS = {
@@ -14786,7 +14864,7 @@ var AuthLoadBalancerStatusPlugin = async () => ({
       execute: async () => {
         const now = Date.now();
         const pool = await readPool();
-        await Promise.all([anthropicAdapter, openaiAdapter].map((adapter) => refreshUsageInBackground(adapter, now, pool).catch(ignore)));
+        await refreshAllUsageInBackground(now, pool).catch(ignore);
         const renderedAt = Date.now();
         return lbResult(renderStatus(await readStatus(renderedAt), renderedAt));
       }
@@ -14819,6 +14897,28 @@ var AuthLoadBalancerStatusPlugin = async () => ({
           return lbResult(result.reason === "taken" ? `Label "${trimmed}" is already used by another account.` : `No account matching "${account}". Available: ${result.labels.join(", ") || "(none)"}`);
         return lbResult(`Renamed "${result.previous}" → "${trimmed}".`);
       }
+    }),
+    auth_lb_disable: tool({
+      description: "Disable a pooled account so the load balancer stops selecting it (match by current label or id), or re-enable a previously disabled one with `enable: true`. A disabled account is skipped by scheduling and shows as `disabled` in the auth_lb_status dashboard — separate from an account that needs re-login.",
+      args: {
+        account: tool.schema.string().describe("Current label or id of the account to disable/enable"),
+        enable: tool.schema.boolean().optional().describe("Set true to re-enable a previously disabled account; omit or false to disable it")
+      },
+      execute: async ({ account, enable }) => {
+        const result = await mutatePool((pool) => {
+          const target = pool.accounts.find((a) => a.id === account || a.label === account);
+          if (!target)
+            return {
+              ok: false,
+              labels: pool.accounts.map((a) => `${a.label} (${a.providerID})`)
+            };
+          target.disabledReason = enable ? null : MANUAL_DISABLED_REASON;
+          return { ok: true, label: target.label, enabled: !!enable };
+        });
+        if (!result.ok)
+          return lbResult(`No account matching "${account}". Available: ${result.labels.join(", ") || "(none)"}`);
+        return lbResult(result.enabled ? `Enabled "${result.label}" — back in the load-balancer rotation.` : `Disabled "${result.label}" — the load balancer will skip it until you re-enable it.`);
+      }
     })
   }
 });