opencode-auth-load-balancer 0.8.1 → 0.9.1

package/dist/index.js

@@ -12680,6 +12680,15 @@ var init_tool = __esm(() => {
   tool.schema = exports_external;
 });
 
+// src/login-rev.ts
+function bumpLoginRev(row, now = Date.now()) {
+  row.loginRev = (row.loginRev ?? 1) + 1;
+  row.loginAt = now;
+}
+function loginVersion(row) {
+  return { rev: row.loginRev ?? 1, at: row.loginAt ?? 0 };
+}
+
 // src/types.ts
 function emptyUsage() {
   return { hourly: null, weekly: null, capturedAt: 0 };
@@ -13110,6 +13119,10 @@ function normalizeAccounts(rows) {
       delete row.orgId;
     if (!isFiniteNumber(row.refreshExpires) || row.refreshExpires <= 0)
       delete row.refreshExpires;
+    if (typeof row.loginRev !== "number" || !Number.isSafeInteger(row.loginRev) || row.loginRev < 1)
+      delete row.loginRev;
+    if (!isFiniteNumber(row.loginAt) || row.loginAt < 0)
+      delete row.loginAt;
     if (row.inferenceToken === undefined || !isFiniteNumber(row.inferenceExpires) || row.inferenceExpires <= 0)
       delete row.inferenceExpires;
     if (row.lostLogins !== undefined) {
@@ -13372,6 +13385,14 @@ var init_score_core = __esm(() => {
 });
 
 // src/usage-merge.ts
+function reconcileQuotaCooldown(account, cfg, now) {
+  if (account.cooldownKind === "auth" || account.cooldownKind === "transient")
+    return;
+  if (account.cooldownUntil > now + MAX_TRANSIENT_COOLDOWN_MS && !isExhausted(account, cfg, now)) {
+    account.cooldownUntil = 0;
+    delete account.cooldownKind;
+  }
+}
 function rollWeeklyAnchorForward(anchor, now) {
   if (!Number.isFinite(anchor) || anchor <= 0)
     return 0;
@@ -13388,8 +13409,10 @@ function preserveWeeklyAnchor(incoming, stored, now) {
     return incoming;
   return { utilization: incoming.utilization, resetAt: anchor };
 }
+var MAX_TRANSIENT_COOLDOWN_MS;
 var init_usage_merge = __esm(() => {
   init_score_core();
+  MAX_TRANSIENT_COOLDOWN_MS = 5 * 60 * 1000;
 });
 
 // src/accounts.ts
@@ -13417,6 +13440,10 @@ function makeAccount(providerID, label, tokens) {
     account.orgId = tokens.orgId;
   if (tokens.refreshExpires)
     account.refreshExpires = tokens.refreshExpires;
+  if (tokens.refresh && !tokens.inferenceOnly) {
+    account.loginRev = 1;
+    account.loginAt = Date.now();
+  }
   return account;
 }
 function recordLostLogin(row, login, reason) {
@@ -13437,10 +13464,14 @@ function mergeLoginUsage(row, usage) {
     weekly: usage.weekly ? preserveWeeklyAnchor(usage.weekly, row.usage.weekly, usage.capturedAt) : row.usage.weekly,
     capturedAt: usage.weekly ? usage.capturedAt : row.usage.capturedAt
   };
+  if (usage.weekly)
+    reconcileQuotaCooldown(row, loadScoreConfig(), usage.capturedAt);
 }
 function applyTokens(row, tokens) {
-  if (tokens.refresh)
+  if (tokens.refresh) {
     row.refresh = tokens.refresh;
+    bumpLoginRev(row);
+  }
   row.access = tokens.access;
   row.expires = tokens.expires;
   row.disabledReason = null;
@@ -13528,6 +13559,7 @@ async function bootstrapFromOpencodeAuth(providerID, getAuth, tokensFromApiKey)
 var init_accounts = __esm(() => {
   init_pairing();
   init_store();
+  init_score_core();
   init_types();
   init_usage_merge();
 });
@@ -13650,6 +13682,15 @@ function mergeHeaders(input, init) {
   return headers;
 }
 
+// src/refresh-hooks.ts
+function setRefreshHooks(hooks) {
+  current = hooks;
+}
+function getRefreshHooks() {
+  return current;
+}
+var current = null;
+
 // src/refresh.ts
 function needsRefresh(account, now) {
   return !account.access || account.expires - REFRESH_SKEW_MS <= now;
@@ -13708,6 +13749,7 @@ async function commitRefresh(accountId, attempt, next) {
     if (!sameGeneration(stored, attempt))
       return tokensOf(stored);
     applyTokensTo(stored, next);
+    bumpLoginRev(stored);
     stored.tokenGen = attempt.gen + 1;
     if (stored.disabledReason !== MANUAL_DISABLED_REASON)
       stored.disabledReason = null;
@@ -13734,11 +13776,31 @@ async function resolveInvalidGrant(adapter, accountId, attempt, reason) {
     return null;
   });
 }
+async function pullNewer(account, recovery) {
+  try {
+    const adopted = await getRefreshHooks()?.pull?.(account, recovery);
+    return adopted ? await readPoolAccount(account.id) : undefined;
+  } catch {
+    return;
+  }
+}
+function announceRefresh() {
+  try {
+    getRefreshHooks()?.afterRefresh?.();
+  } catch {
+    ignore();
+  }
+}
 async function runRefresh(adapter, account, now, rejectedAccess) {
   return withLock(refreshLockDir(adapter.id, account.id), REFRESH_LOCK, async () => {
-    const latest = await readPoolAccount(account.id) ?? account;
-    if (latest.access !== rejectedAccess && !needsRefresh(latest, Math.max(now, Date.now())))
-      return tokensOf(latest);
+    const read = await readPoolAccount(account.id) ?? account;
+    const usable = (row) => row.access !== rejectedAccess && !needsRefresh(row, Math.max(now, Date.now()));
+    if (usable(read))
+      return tokensOf(read);
+    const pulled = await pullNewer(read, false);
+    if (pulled && usable(pulled))
+      return tokensOf(pulled);
+    const latest = pulled ?? read;
     const attempt = {
       refresh: latest.refresh,
       gen: genOf(latest)
@@ -13749,6 +13811,9 @@ async function runRefresh(adapter, account, now, rejectedAccess) {
     } catch (error) {
       if (!(error instanceof Error) || !isInvalidGrant(error))
         throw error;
+      const recovered = await pullNewer(latest, true);
+      if (recovered)
+        return tokensOf(recovered);
       const adopted = await resolveInvalidGrant(adapter, account.id, attempt, refusalReason(error));
       if (adopted)
         return adopted;
@@ -13776,7 +13841,9 @@ async function ensureAccessToken(adapter, account, now, rejectedAccess) {
   const job = runRefresh(adapter, account, now, rejectedAccess);
   inflight.set(account.id, job);
   try {
-    return await settleRefresh(adapter, account, job);
+    const access = await settleRefresh(adapter, account, job);
+    announceRefresh();
+    return access;
   } finally {
     inflight.delete(account.id);
   }
@@ -13975,7 +14042,7 @@ var init_session = __esm(() => {
 // src/token-mint.ts
 function autoTokenEnabled(env = process.env) {
   const raw = env.OPENCODE_AUTH_LB_ANTHROPIC_AUTO_TOKEN?.trim().toLowerCase();
-  return raw !== "0" && raw !== "false" && raw !== "no" && raw !== "off";
+  return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
 }
 function tokenDue(account, now) {
   if (!account.refresh || account.disabledReason)
@@ -14004,6 +14071,7 @@ async function mintToken(adapter, accountId) {
       if (minted.refresh !== row.refresh) {
         row.refresh = minted.refresh;
         row.tokenGen = attempt.gen + 1;
+        bumpLoginRev(row);
       }
       if (minted.refreshExpires)
         row.refreshExpires = minted.refreshExpires;
@@ -14433,24 +14501,46 @@ var init_usage_headers = __esm(() => {
 });
 
 // src/providers/usage-http.ts
-async function fetchJson(url, headers, timeoutMs) {
-  let response;
+async function request(url, headers, timeoutMs) {
   try {
-    response = await fetch(url, {
+    return await fetch(url, {
       headers,
       signal: AbortSignal.timeout(timeoutMs)
     });
   } catch {
     return null;
   }
+}
+async function readJson(response) {
+  if (!response)
+    return null;
   if (!response.ok) {
     await response.body?.cancel().catch(ignore);
     return null;
   }
   return await response.json().catch(() => null);
 }
+async function fetchJson(url, headers, timeoutMs) {
+  return readJson(await request(url, headers, timeoutMs));
+}
+async function fetchUsageJson(url, headers, timeoutMs) {
+  const response = await request(url, headers, timeoutMs);
+  if (response?.status === 401) {
+    await response.body?.cancel().catch(ignore);
+    throw new UsageAuthenticationError;
+  }
+  return readJson(response);
+}
+var UsageAuthenticationError;
 var init_usage_http = __esm(() => {
   init_util2();
+  UsageAuthenticationError = class UsageAuthenticationError extends Error {
+    status = 401;
+    constructor() {
+      super("Usage endpoint rejected the access token (401)");
+      this.name = "UsageAuthenticationError";
+    }
+  };
 });
 
 // src/providers/anthropic/version.ts
@@ -14469,16 +14559,16 @@ function adopt(candidate) {
   const trimmed = candidate.trim();
   if (!VERSION_RE.test(trimmed))
     return;
-  if (compareVersions2(trimmed, current) <= 0)
+  if (compareVersions2(trimmed, current2) <= 0)
     return;
-  current = trimmed;
+  current2 = trimmed;
 }
 function envOverride() {
   const raw = process.env[CLAUDE_CODE_VERSION_ENV]?.trim();
   return raw && VERSION_RE.test(raw) ? raw : undefined;
 }
 function claudeCodeVersion() {
-  return envOverride() ?? current;
+  return envOverride() ?? current2;
 }
 function userAgent() {
   return `claude-cli/${claudeCodeVersion()} (external, cli)`;
@@ -14513,7 +14603,7 @@ async function refreshClaudeCodeVersion(now) {
   await persist(now);
 }
 async function persist(now) {
-  await writeJsonAtomic(versionCacheFilePath(), JSON.stringify({ version: current, fetchedAt: now })).catch(ignore);
+  await writeJsonAtomic(versionCacheFilePath(), JSON.stringify({ version: current2, fetchedAt: now })).catch(ignore);
 }
 async function recoverClaudeCodeVersion(res, now) {
   if (envOverride())
@@ -14526,12 +14616,12 @@ async function recoverClaudeCodeVersion(res, now) {
   }
   if (!text.includes(CLAUDE_CODE_VERSION_GATE_CODE))
     return false;
-  const before = current;
+  const before = current2;
   const required = CLAUDE_CODE_REQUIRED_VERSION_RE.exec(text)?.[1];
   if (required !== undefined)
     adopt(required);
   await refreshClaudeCodeVersion(now).catch(ignore);
-  if (current === before)
+  if (current2 === before)
     return false;
   await persist(now);
   return true;
@@ -14547,7 +14637,7 @@ async function primeClaudeCodeVersion(now) {
   }
   refreshClaudeCodeVersion(now).catch(ignore);
 }
-var VERSION_RE, current;
+var VERSION_RE, current2;
 var init_version = __esm(() => {
   init_paths();
   init_store();
@@ -14555,7 +14645,7 @@ var init_version = __esm(() => {
   init_usage_http();
   init_constants();
   VERSION_RE = /^\d+\.\d+\.\d+$/;
-  current = FALLBACK_CLAUDE_CODE_VERSION;
+  current2 = FALLBACK_CLAUDE_CODE_VERSION;
 });
 
 // src/providers/anthropic/cch.ts
@@ -14890,7 +14980,7 @@ async function probeUsage(access, now) {
 async function fetchUsage(account, now) {
   if (!account.refresh)
     return probeUsage(account.access, now);
-  const json = await fetchJson(USAGE_URL, {
+  const json = await fetchUsageJson(USAGE_URL, {
     authorization: `Bearer ${account.access}`,
     "anthropic-beta": "oauth-2025-04-20",
     "user-agent": usageUserAgent(),
@@ -15222,7 +15312,7 @@ function parseUsages(json, now) {
   return hourly || weekly ? { hourly, weekly, capturedAt: now } : null;
 }
 function getUsages(baseUrl, key) {
-  return fetchJson(`${baseUrl}/usages`, { authorization: `Bearer ${key}`, accept: "application/json" }, USAGE_HTTP_TIMEOUT_MS);
+  return fetchUsageJson(`${baseUrl}/usages`, { authorization: `Bearer ${key}`, accept: "application/json" }, USAGE_HTTP_TIMEOUT_MS);
 }
 function usageFetcher(baseUrl) {
   return async (account, now) => parseUsages(await getUsages(baseUrl, account.access), now);
@@ -15496,7 +15586,7 @@ async function fetchUsage2(account, now) {
   const accountId = resolveAccountId(account);
   if (accountId)
     headers["chatgpt-account-id"] = accountId;
-  const json = await fetchJson(USAGE_URL2, headers, USAGE_HTTP_TIMEOUT_MS);
+  const json = await fetchUsageJson(USAGE_URL2, headers, USAGE_HTTP_TIMEOUT_MS);
   const rateLimit = json?.rate_limit;
   if (!isPlainObject2(rateLimit))
     return null;
@@ -15585,7 +15675,7 @@ async function refreshUsage(adapters, now, poolSnapshot) {
     aliveIds?.add(account.id);
     if (account.disabledReason && account.disabledReason !== MANUAL_DISABLED_REASON)
       continue;
-    if (account.usage.capturedAt !== 0 && now - account.usage.capturedAt <= USAGE_REFRESH_TTL_MS)
+    if (account.usage.capturedAt !== 0 && now - account.usage.capturedAt < USAGE_REFRESH_TTL_MS)
       continue;
     const adapter = adapterFor(adapters, account.providerID);
     if (!adapter)
@@ -15607,7 +15697,16 @@ async function refreshUsage(adapters, now, poolSnapshot) {
   await Promise.all(stale.map(async ({ adapter, account }) => {
     try {
       await ensureAccessToken(adapter, account, now);
-      const snapshot = await adapter.fetchUsage(account, now);
+      const rejectedAccess = account.access;
+      let snapshot;
+      try {
+        snapshot = await adapter.fetchUsage(account, now);
+      } catch (error) {
+        if (!(error instanceof UsageAuthenticationError) || !account.refresh)
+          throw error;
+        await ensureAccessToken(adapter, account, now, rejectedAccess);
+        snapshot = await adapter.fetchUsage(account, now);
+      }
       if (snapshot) {
         await mutatePool((p) => {
           const stored = findAccount(p, account.id);
@@ -15617,10 +15716,8 @@ async function refreshUsage(adapters, now, poolSnapshot) {
               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;
-              delete stored.cooldownKind;
-            }
+            if (snapshot.weekly !== null && stored.cooldownUntil === account.cooldownUntil && stored.cooldownKind === account.cooldownKind)
+              reconcileQuotaCooldown(stored, scoreCfg, now);
           }
         });
       }
@@ -15633,16 +15730,17 @@ function refreshUsageInBackground(adapter, now, poolSnapshot) {
 function refreshAllUsageInBackground(now, poolSnapshot) {
   return refreshUsage(ADAPTERS, now, poolSnapshot);
 }
-var USAGE_REFRESH_TTL_MS, MAX_TRANSIENT_COOLDOWN_MS, lastPoll;
+var USAGE_REFRESH_TTL_MS, lastPoll;
 var init_usage_refresh = __esm(() => {
   init_store();
   init_registry();
+  init_usage_http();
   init_refresh();
   init_score_core();
   init_types();
   init_usage_merge();
+  init_usage_merge();
   USAGE_REFRESH_TTL_MS = 5 * 60 * 1000;
-  MAX_TRANSIENT_COOLDOWN_MS = 5 * 60 * 1000;
   lastPoll = new Map;
 });
 
@@ -16867,6 +16965,12 @@ var init_prime = __esm(() => {
   init_select();
 });
 
+// src/sync/enabled.ts
+function syncEnabled(env = process.env) {
+  const raw = env.OPENCODE_AUTH_LB_SYNC?.trim().toLowerCase();
+  return raw !== "0" && raw !== "false" && raw !== "no" && raw !== "off";
+}
+
 // src/sync/errors.ts
 function describeSyncError(error) {
   return error instanceof SyncError ? error.message : "Sync failed.";
@@ -16974,10 +17078,7 @@ var init_crypto = __esm(() => {
   B64URL_RE = /^[\w-]+$/;
 });
 
-// src/sync/payload.ts
-function entryKey(entry) {
-  return `${entry.origin}/${entry.id}`;
-}
+// src/sync/text.ts
 function isControl(code) {
   return code < 32 || code >= 127 && code <= 159 || code === 1564 || code >= 8203 && code <= 8207 || code >= 8232 && code <= 8238 || code >= 8288 && code <= 8297 || code === 65279;
 }
@@ -16987,6 +17088,106 @@ function printable(text) {
 function boundedString(value, max) {
   return typeof value === "string" && value.length > 0 && value.length <= max ? value : undefined;
 }
+var MAX_LABEL = 80;
+
+// src/sync/login-payload.ts
+function loginKey(providerID, accountId) {
+  return `${providerID}:${accountId}`;
+}
+function word(value, max) {
+  const text = boundedString(value, max);
+  return text !== undefined && NO_SPACE_RE.test(text) ? text : undefined;
+}
+function positive(value) {
+  return isFiniteNumber(value) && value > 0 ? value : undefined;
+}
+function parseLogin(raw) {
+  if (!isPlainObject2(raw))
+    return null;
+  const providerID = word(raw.providerID, MAX_ID);
+  const accountId = word(raw.accountId, MAX_ID);
+  const label = printable(boundedString(raw.label, MAX_LABEL) ?? "");
+  const [access, refresh] = [
+    word(raw.access, MAX_TOKEN),
+    word(raw.refresh, MAX_TOKEN)
+  ];
+  const { rev, at } = raw;
+  if (!providerID || !LOGIN_PROVIDERS.has(providerID) || !accountId)
+    return null;
+  if (raw.key !== loginKey(providerID, accountId))
+    return null;
+  const expires = positive(raw.expires);
+  if (!label || !access || !refresh || !expires)
+    return null;
+  if (typeof rev !== "number" || !Number.isSafeInteger(rev) || rev < 1)
+    return null;
+  if (!isFiniteNumber(at) || at < 0)
+    return null;
+  const orgId = word(raw.orgId, MAX_ID);
+  const refreshExpires = positive(raw.refreshExpires);
+  return {
+    key: loginKey(providerID, accountId),
+    providerID,
+    label,
+    access,
+    refresh,
+    expires,
+    accountId,
+    ...orgId ? { orgId } : {},
+    ...refreshExpires ? { refreshExpires } : {},
+    rev,
+    at
+  };
+}
+function sortLogins(logins) {
+  return [...logins].sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+}
+function loginsDigest(logins) {
+  return fingerprint(JSON.stringify(sortLogins(logins)));
+}
+function compareLogins(a, b) {
+  if (a.rev !== b.rev)
+    return a.rev < b.rev ? -1 : 1;
+  if (a.at !== b.at)
+    return a.at < b.at ? -1 : 1;
+  const [x, y] = [fingerprint(a.refresh), fingerprint(b.refresh)];
+  return x < y ? -1 : x > y ? 1 : 0;
+}
+function parseLoginList(rawList) {
+  const parsed = {
+    logins: [],
+    loginsListed: new Set,
+    loginsUnreadable: 0
+  };
+  for (const raw of rawList) {
+    const key = isPlainObject2(raw) ? boundedString(raw.key, MAX_KEY) : undefined;
+    if (key)
+      parsed.loginsListed.add(key);
+    const login = parseLogin(raw);
+    if (!login)
+      parsed.loginsUnreadable += 1;
+    else if (!parsed.logins.some((l) => l.key === login.key))
+      parsed.logins.push(login);
+  }
+  return parsed;
+}
+var MAX_LOGINS = 64, MAX_TOKEN = 8192, MAX_ID = 128, MAX_KEY = 300, NO_SPACE_RE, LOGIN_PROVIDERS;
+var init_login_payload = __esm(() => {
+  init_util2();
+  init_crypto();
+  NO_SPACE_RE = /^\S+$/;
+  LOGIN_PROVIDERS = new Set([
+    "anthropic",
+    "openai",
+    "kimi-code-plan-cn",
+    "kimi-code-plan-global"
+  ]);
+});
+
+// src/sync/payload.ts
+function entryKey(entry) {
+  return `${entry.origin}/${entry.id}`;
+}
 function keyOf(raw) {
   if (!isPlainObject2(raw))
     return null;
@@ -17027,11 +17228,12 @@ function sortEntries(entries) {
 function entriesDigest(entries) {
   return fingerprint(JSON.stringify(sortEntries(entries)));
 }
-function buildPayload(entries, at) {
+function buildPayload(entries, at, logins = []) {
   return JSON.stringify({
     v: PAYLOAD_VERSION,
     at,
-    entries: sortEntries(entries)
+    entries: sortEntries(entries),
+    logins: sortLogins(logins)
   });
 }
 function parsePayload(text) {
@@ -17043,11 +17245,12 @@ function parsePayload(text) {
   }
   if (!isPlainObject2(json) || !Array.isArray(json.entries))
     throw new SyncError("bad-blob");
-  if (json.v !== PAYLOAD_VERSION)
+  if (json.v !== PAYLOAD_VERSION && json.v !== ENTRIES_ONLY_VERSION)
     throw new SyncError("bad-version");
-  if (!isFiniteNumber(json.at))
+  const rawLogins = json.v === PAYLOAD_VERSION ? json.logins ?? [] : [];
+  if (!isFiniteNumber(json.at) || !Array.isArray(rawLogins))
     throw new SyncError("bad-blob");
-  if (json.entries.length > MAX_ENTRIES)
+  if (json.entries.length > MAX_ENTRIES || rawLogins.length > MAX_LOGINS)
     throw new SyncError("too-large");
   const listed = new Set;
   const entries = [];
@@ -17066,13 +17269,20 @@ function parsePayload(text) {
     else
       unreadable += 1;
   }
-  return { at: json.at, entries, listed, unreadable };
+  return {
+    at: json.at,
+    entries,
+    listed,
+    unreadable,
+    ...parseLoginList(rawLogins)
+  };
 }
-var PAYLOAD_VERSION = 2, MAX_ENTRIES = 64, MAX_LABEL = 80, MAX_SECRET = 512, MAX_FIELD = 128, ID_RE, ORIGIN_RE, CLAUDE_TOKEN_RE, API_KEY_RE, SECRET_SHAPES;
+var PAYLOAD_VERSION = 3, ENTRIES_ONLY_VERSION = 2, MAX_ENTRIES = 64, MAX_SECRET = 512, MAX_FIELD = 128, ID_RE, ORIGIN_RE, CLAUDE_TOKEN_RE, API_KEY_RE, SECRET_SHAPES;
 var init_payload = __esm(() => {
   init_util2();
   init_crypto();
   init_errors3();
+  init_login_payload();
   ID_RE = /^[\w-]{1,64}$/;
   ORIGIN_RE = /^[\da-f]{32}$/;
   CLAUDE_TOKEN_RE = /^sk-ant-oat\d+-[\w-]+$/;
@@ -17162,7 +17372,7 @@ function backoffFrom(res, now) {
 function isRateLimited(res) {
   return res.status === 429 || res.status === 403 && (res.headers.get("x-ratelimit-remaining") === "0" || res.headers.has("retry-after"));
 }
-async function request(url, init, now) {
+async function request2(url, init, now) {
   let res;
   try {
     res = await globalThis.fetch(url, {
@@ -17214,7 +17424,7 @@ async function boundedText(res) {
   }
   return Buffer.concat(chunks).toString("utf8");
 }
-async function readJson(res) {
+async function readJson2(res) {
   if (!res.ok)
     throw new SyncError("http");
   const text = await boundedText(res);
@@ -17229,7 +17439,7 @@ async function readJson(res) {
   return json;
 }
 async function createGist(token, content, now = Date.now()) {
-  const res = await request(API, {
+  const res = await request2(API, {
     method: "POST",
     headers: { ...headers(token), "content-type": "application/json" },
     body: JSON.stringify({
@@ -17238,7 +17448,7 @@ async function createGist(token, content, now = Date.now()) {
       files: { [GIST_FILE]: { content } }
     })
   }, now);
-  const json = await readJson(res);
+  const json = await readJson2(res);
   const owner = isPlainObject2(json.owner) ? json.owner.login : undefined;
   if (typeof json.id !== "string" || !GIST_ID_RE.test(json.id))
     throw new SyncError("http");
@@ -17250,7 +17460,7 @@ async function createGist(token, content, now = Date.now()) {
 async function updateGist(token, id, content, now = Date.now()) {
   let res;
   try {
-    res = await request(`${API}/${id}`, {
+    res = await request2(`${API}/${id}`, {
       method: "PATCH",
       headers: { ...headers(token), "content-type": "application/json" },
       body: JSON.stringify({ files: { [GIST_FILE]: { content } } })
@@ -17262,10 +17472,10 @@ async function updateGist(token, id, content, now = Date.now()) {
   }
   if (res.status === 401 || res.status === 403)
     throw new SyncError("write-denied");
-  await readJson(res);
+  await readJson2(res);
 }
 async function readGist(id, etag, now = Date.now(), token) {
-  const ask = (auth) => request(`${API}/${id}`, {
+  const ask = (auth) => request2(`${API}/${id}`, {
     headers: {
       ...headers(auth),
       ...etag ? { "if-none-match": etag } : {}
@@ -17276,7 +17486,7 @@ async function readGist(id, etag, now = Date.now(), token) {
     res = await ask();
   if (res.status === 304)
     return { changed: false };
-  const json = await readJson(res);
+  const json = await readJson2(res);
   const file = isPlainObject2(json.files) ? json.files[GIST_FILE] : undefined;
   if (!isPlainObject2(file) || typeof file.content !== "string")
     throw new SyncError("bad-blob");
@@ -17318,6 +17528,12 @@ function isRef(value) {
 function isSkip(value) {
   return isPlainObject2(value) && typeof value.fingerprint === "string" && typeof value.blocker === "string" && typeof value.holds === "string";
 }
+function isMark(value) {
+  return value === true;
+}
+function marks(from) {
+  return from && Object.keys(from).length > 0 ? newMap(from) : undefined;
+}
 function readMap(raw, accept) {
   const map = newMap();
   if (isPlainObject2(raw)) {
@@ -17341,6 +17557,8 @@ function parseState(text) {
     return null;
   const { owner, etag, syncedAt, uploadedDigest, write } = json;
   const { uploadedAt, appliedAt, retryAt, pollAt, writeCheckAt } = json;
+  const loginKnown = marks(readMap(json.loginKnown, isMark));
+  const loginSuppressed = marks(readMap(json.loginSuppressed, isMark));
   return {
     v: 1,
     gistId: json.gistId,
@@ -17348,6 +17566,8 @@ function parseState(text) {
     creator: json.creator === true,
     imported: readMap(json.imported, isRef),
     skipped: readMap(json.skipped, isSkip),
+    ...loginKnown ? { loginKnown } : {},
+    ...loginSuppressed ? { loginSuppressed } : {},
     ...typeof owner === "string" ? { owner } : {},
     ...isWrite(write) ? { write } : {},
     ...typeof etag === "string" ? { etag } : {},
@@ -17577,6 +17797,179 @@ async function discoverGithubToken(run = ghAuthToken, env = process.env) {
 var GH_TIMEOUT_MS = 5000;
 var init_github_auth = () => {};
 
+// src/sync/logins.ts
+function loginsSyncEnabled(env = process.env) {
+  const raw = env.OPENCODE_AUTH_LB_SYNC_LOGINS?.trim().toLowerCase();
+  return raw !== "0" && raw !== "false" && raw !== "no" && raw !== "off";
+}
+function rowKey(row) {
+  const live = row.refresh !== "" || row.inferenceToken !== undefined && row.lostLogins?.oauth !== undefined;
+  return LOGIN_PROVIDERS.has(row.providerID) && row.accountId && live ? loginKey(row.providerID, row.accountId) : null;
+}
+function heldMarks(accounts) {
+  const held = newMap();
+  for (const row of accounts) {
+    const key = rowKey(row);
+    if (key)
+      held[key] = true;
+  }
+  return held;
+}
+function ownLogins(pool) {
+  const best = new Map;
+  for (const row of pool.accounts) {
+    if (!row.refresh || !row.accountId)
+      continue;
+    if (row.disabledReason || row.lostLogins?.oauth)
+      continue;
+    const login = parseLogin({
+      key: loginKey(row.providerID, row.accountId),
+      providerID: row.providerID,
+      label: printable(row.label).slice(0, MAX_LABEL).trim() || row.providerID,
+      access: row.access,
+      refresh: row.refresh,
+      expires: row.expires,
+      accountId: row.accountId,
+      orgId: row.orgId,
+      refreshExpires: row.refreshExpires,
+      ...loginVersion(row)
+    });
+    const prior = login ? best.get(login.key) : undefined;
+    if (login && (!prior || compareLogins(login, prior) > 0))
+      best.set(login.key, login);
+  }
+  return sortLogins([...best.values()]).slice(0, MAX_LOGINS);
+}
+function mergeLogins(gist, own) {
+  const merged = new Map(gist.map((login) => [login.key, login]));
+  for (const login of own) {
+    const prior = merged.get(login.key);
+    if (prior ? compareLogins(login, prior) > 0 : merged.size < MAX_LOGINS)
+      merged.set(login.key, login);
+  }
+  return sortLogins([...merged.values()]);
+}
+function ownCopies(next, own) {
+  return own.filter((login) => next.some((n) => n.key === login.key && n.refresh === login.refresh)).length;
+}
+function publishDigest(entries, logins) {
+  return logins.length === 0 ? entriesDigest(entries) : fingerprint(`${entriesDigest(entries)}/${loginsDigest(logins)}`);
+}
+function sameLogin(row, login) {
+  return rowKey(row) === login.key && (row.orgId === undefined || login.orgId === undefined || row.orgId === login.orgId);
+}
+function versionOf(row) {
+  return { ...loginVersion(row), refresh: row.refresh };
+}
+function overwriteLocked(row, login) {
+  const attempt = { refresh: row.refresh, gen: genOf(row) };
+  return mutatePool((pool) => {
+    const cur = findAccount(pool, row.id);
+    if (!cur || !sameGeneration(cur, attempt))
+      return false;
+    cur.access = login.access;
+    cur.refresh = login.refresh;
+    cur.expires = login.expires;
+    if (login.refreshExpires)
+      cur.refreshExpires = login.refreshExpires;
+    else
+      delete cur.refreshExpires;
+    if (login.orgId)
+      cur.orgId = login.orgId;
+    cur.loginRev = login.rev;
+    cur.loginAt = login.at;
+    cur.tokenGen = genOf(cur) + 1;
+    clearLostLogin(cur, "oauth");
+    if (cur.disabledReason?.startsWith(AUTO_DISABLED_PREFIX))
+      cur.disabledReason = null;
+    return true;
+  });
+}
+function overwrite(row, login) {
+  return withRefreshLock(row.providerID, row.id, () => overwriteLocked(row, login));
+}
+async function create(login) {
+  const tokens = {
+    access: login.access,
+    refresh: login.refresh,
+    expires: login.expires,
+    accountId: login.accountId,
+    ...login.orgId ? { orgId: login.orgId } : {},
+    ...login.refreshExpires ? { refreshExpires: login.refreshExpires } : {}
+  };
+  return mutatePool((pool) => {
+    if (pool.accounts.some((row) => sameLogin(row, login)))
+      return false;
+    const manual = new Set(pool.accounts.filter((row) => row.disabledReason === MANUAL_DISABLED_REASON).map((row) => row.id));
+    const row = placeTokens(pool, login.providerID, tokens, uniqueLabel(pool, login.label), undefined);
+    row.loginRev = login.rev;
+    row.loginAt = login.at;
+    row.tokenGen = genOf(row) + 1;
+    if (manual.has(row.id))
+      row.disabledReason = MANUAL_DISABLED_REASON;
+    return true;
+  });
+}
+async function adopt2(login) {
+  const row = (await readPool()).accounts.find((a) => sameLogin(a, login));
+  if (!row)
+    return create(login);
+  return compareLogins(login, versionOf(row)) > 0 ? overwrite(row, login) : false;
+}
+async function outrank(login, now) {
+  const row = (await readPool()).accounts.find((a) => sameLogin(a, login));
+  if (!row || compareLogins(versionOf(row), login) > 0)
+    return;
+  const attempt = { refresh: row.refresh, gen: genOf(row) };
+  await mutatePool((pool) => {
+    const cur = findAccount(pool, row.id);
+    if (!cur || !sameGeneration(cur, attempt))
+      return;
+    cur.loginRev = login.rev + 1;
+    cur.loginAt = now;
+  });
+}
+async function applyLogins(gist, marks, now) {
+  const known = newMap(marks.known);
+  const suppressed = newMap(marks.suppressed);
+  const held = heldMarks((await readPool()).accounts);
+  for (const key of Object.keys(known)) {
+    if (held[key])
+      continue;
+    suppressed[key] = true;
+    delete known[key];
+  }
+  for (const key of Object.keys(suppressed)) {
+    if (!held[key])
+      continue;
+    delete suppressed[key];
+    const login = gist.find((l) => l.key === key);
+    if (login)
+      await outrank(login, now);
+  }
+  let adopted = 0;
+  for (const login of gist)
+    if (!suppressed[login.key] && await adopt2(login))
+      adopted += 1;
+  return {
+    adopted,
+    known: heldMarks((await readPool()).accounts),
+    suppressed
+  };
+}
+var AUTO_DISABLED_PREFIX = "invalid_grant: re-login required";
+var init_logins = __esm(() => {
+  init_accounts();
+  init_store();
+  init_refresh();
+  init_types();
+  init_apply();
+  init_crypto();
+  init_login_payload();
+  init_payload();
+  init_state();
+});
+
 // src/sync/origin.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { readFile as readFile6 } from "node:fs/promises";
@@ -17677,6 +18070,10 @@ var init_timing = __esm(() => {
 function count(n, one, many) {
   return `${n} ${n === 1 ? one : many}`;
 }
+function uploadedMessage(entries, logins) {
+  const credentials = count(entries, "credential", "credentials");
+  return logins === 0 ? `Uploaded ${credentials}.` : `Uploaded ${credentials} and ${count(logins, "login", "logins")}.`;
+}
 function recordApplied(gistId, at, applied, syncedAt) {
   return updateSyncState((cur) => cur?.gistId === gistId ? {
     ...cur,
@@ -17700,7 +18097,8 @@ async function runCycle(deps, force, report) {
   const pool = await readPool();
   const backedOff = state.write === "denied" && !force && now() < (state.writeCheckAt ?? 0);
   const mayWrite = token !== null && !backedOff;
-  const before = entriesDigest(ownEntries(pool, origin, state.imported));
+  const sharing = loginsSyncEnabled();
+  const before = publishDigest(ownEntries(pool, origin, state.imported), sharing ? ownLogins(pool) : []);
   const dirty = mayWrite && before !== state.uploadedDigest;
   report.retryMs = dirty ? PUBLISH_RETRY_MS : POLL_MS;
   const reread = force || dirty || hasFreedSkips(pool.accounts, state.skipped);
@@ -17722,8 +18120,17 @@ async function runCycle(deps, force, report) {
     ...deps.adapters ? { adapters: deps.adapters } : {},
     afterPass: (soFar) => recordApplied(state.gistId, snapshot.at, soFar, now())
   });
-  const own = ownEntries(await readPool(), origin, applied?.imported ?? state.imported);
-  const unreadable = snapshot.unreadable > 0;
+  const adoptedLogins = stale || !sharing ? null : await applyLogins(snapshot.logins, { known: state.loginKnown, suppressed: state.loginSuppressed }, now());
+  if (adoptedLogins)
+    await updateSyncState((cur) => cur?.gistId === state.gistId ? {
+      ...cur,
+      loginKnown: marks(adoptedLogins.known),
+      loginSuppressed: marks(adoptedLogins.suppressed)
+    } : cur);
+  const settled = await readPool();
+  const own = ownEntries(settled, origin, applied?.imported ?? state.imported);
+  const ownShared = sharing ? ownLogins(settled) : [];
+  const unreadable = snapshot.unreadable > 0 || snapshot.loginsUnreadable > 0;
   let write = standing;
   let wrote = null;
   let stamped = 0;
@@ -17733,12 +18140,16 @@ async function runCycle(deps, force, report) {
   if (mayWrite && !unreadable) {
     const others = snapshot.entries.filter((e) => e.origin !== origin);
     const next = sortEntries([...others, ...listable(own, others, origin)]);
-    const same = JSON.stringify(next) === JSON.stringify(sortEntries(snapshot.entries));
+    const nextLogins = sharing ? mergeLogins(snapshot.logins, ownShared) : snapshot.logins;
+    const same = JSON.stringify(next) === JSON.stringify(sortEntries(snapshot.entries)) && loginsDigest(nextLogins) === loginsDigest(snapshot.logins);
     if (!same || stale) {
       stamped = Math.max(now(), snapshot.at + 1, (state.uploadedAt ?? 0) + 1, (state.appliedAt ?? 0) + 1);
       try {
-        await updateGist(token, state.gistId, seal(buildPayload(next, stamped), key), now());
-        wrote = next.filter((e) => e.origin === origin);
+        await updateGist(token, state.gistId, seal(buildPayload(next, stamped, nextLogins), key), now());
+        wrote = {
+          entries: next.filter((e) => e.origin === origin).length,
+          logins: ownCopies(nextLogins, ownShared)
+        };
       } catch (error) {
         if (!(error instanceof SyncError) || error.code !== "write-denied")
           throw error;
@@ -17754,18 +18165,22 @@ async function runCycle(deps, force, report) {
     etag: wrote || stale || deferred > 0 || denied ? undefined : read.etag,
     write,
     writeCheckAt: denied ? now() + WRITE_BACKOFF_MS : backedOff ? cur.writeCheckAt : undefined,
-    uploadedDigest: mayWrite && !unreadable && !denied ? entriesDigest(own) : cur.uploadedDigest,
+    uploadedDigest: mayWrite && !unreadable && !denied ? publishDigest(own, ownShared) : cur.uploadedDigest,
     ...wrote ? { uploadedAt: stamped } : {}
   } : cur);
   const parts = [];
   const moved = applied ? applied.added + applied.updated + applied.removed + deferred : 0;
+  const adopted = adoptedLogins?.adopted ?? 0;
   if (applied && moved > 0) {
     const tail = deferred > 0 ? `; ${count(deferred, "entry", "entries")} could not be verified yet` : "";
-    parts.push(`Synced: ${applied.added} added, ${applied.updated} updated, ${applied.removed} removed${tail}.`);
-  } else if (!wrote)
+    const login = adopted > 0 ? `; ${count(adopted, "login", "logins")} adopted` : "";
+    parts.push(`Synced: ${applied.added} added, ${applied.updated} updated, ${applied.removed} removed${tail}${login}.`);
+  } else if (adopted > 0)
+    parts.push(`Synced: ${count(adopted, "login", "logins")} adopted.`);
+  else if (!wrote)
     parts.push("Up to date.");
   if (wrote)
-    parts.push(`Uploaded ${count(wrote.length, "credential", "credentials")}.`);
+    parts.push(uploadedMessage(wrote.entries, wrote.logins));
   if (denied)
     parts.push(new SyncError("write-denied").message);
   if (mayWrite && unreadable && state.write !== "unreadable")
@@ -17780,6 +18195,8 @@ var init_cycle = __esm(() => {
   init_errors3();
   init_gist();
   init_github_auth();
+  init_login_payload();
+  init_logins();
   init_merge();
   init_origin();
   init_own();
@@ -17789,9 +18206,6 @@ var init_cycle = __esm(() => {
 });
 
 // src/sync/engine.ts
-function count2(n, one, many) {
-  return `${n} ${n === 1 ? one : many}`;
-}
 function createEngine(deps) {
   const { now } = deps;
   async function settle(work, reqAt, scheduled) {
@@ -17824,10 +18238,14 @@ function createEngine(deps) {
     if (!token)
       throw new SyncError("no-auth");
     const origin = await machineOrigin();
-    const own = ownEntries(await readPool(), origin, newRefs());
+    const pool = await readPool();
+    const own = ownEntries(pool, origin, newRefs());
+    const sharing = loginsSyncEnabled();
+    const shared = sharing ? ownLogins(pool) : [];
     const key = generateKey();
     const at = now();
-    const gist = await createGist(token, seal(buildPayload(own, at), key), now());
+    const gist = await createGist(token, seal(buildPayload(own, at, shared), key), now());
+    const loginKnown = sharing ? marks(heldMarks(pool.accounts)) : undefined;
     await updateSyncState(() => ({
       v: 1,
       gistId: gist.id,
@@ -17836,21 +18254,23 @@ function createEngine(deps) {
       ...gist.owner ? { owner: gist.owner } : {},
       write: "ok",
       syncedAt: now(),
-      uploadedDigest: entriesDigest(own),
+      uploadedDigest: publishDigest(own, shared),
       uploadedAt: at,
       appliedAt: at,
       pollAt: now() + POLL_MS,
       imported: newRefs(),
-      skipped: newMap()
+      skipped: newMap(),
+      ...loginKnown ? { loginKnown } : {}
     }));
-    return `Uploaded ${count2(own.length, "credential", "credentials")}.`;
+    const message = uploadedMessage(own.length, shared.length);
+    return own.length + shared.length === 0 ? `${message} ${NOTHING_TO_SHARE}` : message;
   }
   async function unpublishedDigest() {
     const state = await readSyncState();
     if (!state || state.write === "no-token" || state.write === "unreadable" || state.write === "denied" && now() < (state.writeCheckAt ?? 0))
       return null;
-    const own = ownEntries(await readPool(), await machineOrigin(), state.imported);
-    const digest = entriesDigest(own);
+    const pool = await readPool();
+    const digest = publishDigest(ownEntries(pool, await machineOrigin(), state.imported), loginsSyncEnabled() ? ownLogins(pool) : []);
     return digest === state.uploadedDigest ? null : digest;
   }
   const engine = {
@@ -17872,7 +18292,9 @@ function createEngine(deps) {
           creator: prior?.creator ?? false,
           ...prior?.owner ? { owner: prior.owner } : {},
           imported: prior?.imported ?? newRefs(),
-          skipped: prior?.skipped ?? newMap()
+          skipped: prior?.skipped ?? newMap(),
+          ...prior?.loginKnown ? { loginKnown: prior.loginKnown } : {},
+          ...prior?.loginSuppressed ? { loginSuppressed: prior.loginSuppressed } : {}
         };
       });
       return settle(cycle(false), reqAt, true);
@@ -17899,6 +18321,7 @@ function createEngine(deps) {
   };
   return engine;
 }
+var NOTHING_TO_SHARE = "No static credential or shareable OAuth login on this machine.";
 var init_engine = __esm(() => {
   init_store();
   init_crypto();
@@ -17906,6 +18329,7 @@ var init_engine = __esm(() => {
   init_errors3();
   init_gist();
   init_github_auth();
+  init_logins();
   init_origin();
   init_own();
   init_payload();
@@ -17913,6 +18337,47 @@ var init_engine = __esm(() => {
   init_timing();
 });
 
+// src/sync/login-hooks.ts
+function createPullLogin(runGh) {
+  return async function pullLogin(account, _recovery) {
+    const { providerID, accountId } = account;
+    if (!syncEnabled() || !loginsSyncEnabled())
+      return false;
+    if (!LOGIN_PROVIDERS.has(providerID) || !accountId || !account.refresh)
+      return false;
+    try {
+      const state = await readSyncState();
+      if (!state)
+        return false;
+      const token = await discoverGithubToken(runGh) ?? undefined;
+      const read = await readGist(state.gistId, undefined, Date.now(), token);
+      if (!read.changed)
+        return false;
+      const key = decodeKey(state.key) ?? Buffer.alloc(32);
+      const wanted = loginKey(providerID, accountId);
+      const login = parsePayload(open(read.content, key)).logins.find((l) => l.key === wanted);
+      if (!login || !sameLogin(account, login))
+        return false;
+      if (compareLogins(login, versionOf(account)) <= 0)
+        return false;
+      return await overwriteLocked(account, login);
+    } catch {
+      return false;
+    }
+  };
+}
+var pullLogin;
+var init_login_hooks = __esm(() => {
+  init_crypto();
+  init_gist();
+  init_github_auth();
+  init_login_payload();
+  init_logins();
+  init_payload();
+  init_state();
+  pullLogin = createPullLogin();
+});
+
 // src/sync/intent.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { access, readFile as readFile7, rename as rename2, rm as rm3 } from "node:fs/promises";
@@ -18114,10 +18579,6 @@ var init_loop = __esm(() => {
 });
 
 // src/sync/start.ts
-function syncEnabled(env = process.env) {
-  const raw = env.OPENCODE_AUTH_LB_SYNC?.trim().toLowerCase();
-  return raw !== "0" && raw !== "false" && raw !== "no" && raw !== "off";
-}
 function startSync() {
   if (!syncEnabled())
     return null;
@@ -18126,11 +18587,110 @@ function startSync() {
     now: Date.now
   });
   loop.start();
-  return loop;
+  if (!loginsSyncEnabled())
+    return loop;
+  setRefreshHooks({
+    pull: pullLogin,
+    afterRefresh: () => void publishAfterLogin().catch(ignore)
+  });
+  return {
+    ...loop,
+    dispose() {
+      setRefreshHooks(null);
+      return loop.dispose();
+    }
+  };
+}
+async function publishAfterLogin(options = {}) {
+  const { engine = createEngine({ now: Date.now }) } = options;
+  const { timeoutMs = LOGIN_PUBLISH_MS } = options;
+  let timer;
+  const publish = async () => {
+    if (!syncEnabled() || !loginsSyncEnabled() || !await readSyncState())
+      return;
+    await withCycleLock(() => engine.sync(), timeoutMs);
+  };
+  await Promise.race([
+    publish().catch(ignore),
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, timeoutMs);
+    })
+  ]);
+  clearTimeout(timer);
 }
+var LOGIN_PUBLISH_MS = 20000;
 var init_start = __esm(() => {
+  init_util2();
   init_engine();
+  init_login_hooks();
+  init_logins();
+  init_loop();
+  init_state();
+});
+
+// src/usage-poll.ts
+import { readFile as readFile8 } from "node:fs/promises";
+async function nextPollAt(path) {
+  try {
+    const value = JSON.parse(await readFile8(path, "utf8"));
+    return isPlainObject2(value) && isFiniteNumber(value.nextPollAt) ? value.nextPollAt : 0;
+  } catch (error) {
+    if (error instanceof SyntaxError || error instanceof Error && "code" in error && error.code === "ENOENT")
+      return 0;
+    throw error;
+  }
+}
+function startUsagePoll(deps = {}) {
+  const now = deps.now ?? Date.now;
+  const refresh = deps.refresh ?? refreshAllUsageInBackground;
+  const timers = deps.timers ?? realTimers;
+  let disposed = false;
+  let inflight;
+  async function poll() {
+    const path = `${poolFilePath()}.usage-poll.json`;
+    try {
+      await withLock(`${path}.lock`, {
+        staleMs: 120000,
+        timeoutMs: 0,
+        retryMs: 25,
+        heartbeatMs: 5000
+      }, async () => {
+        const at = now();
+        if (at < await nextPollAt(path))
+          return;
+        await writeJsonAtomic(path, JSON.stringify({ nextPollAt: at + USAGE_REFRESH_TTL_MS }));
+        await refresh(at);
+      });
+    } catch (error) {
+      if (!(error instanceof LockTimeoutError))
+        throw error;
+    }
+  }
+  function tick() {
+    if (disposed)
+      return Promise.resolve();
+    inflight ??= poll().finally(() => {
+      inflight = undefined;
+    });
+    return inflight;
+  }
+  const timer = timers.set(() => void tick().catch(ignore), USAGE_REFRESH_TTL_MS);
+  return {
+    tick,
+    async dispose() {
+      disposed = true;
+      timers.clear(timer);
+      await inflight;
+    }
+  };
+}
+var init_usage_poll = __esm(() => {
+  init_lock();
+  init_paths();
+  init_store();
   init_loop();
+  init_usage_refresh();
+  init_util2();
 });
 
 // src/legacy.ts
@@ -18158,6 +18718,8 @@ function buildAuthHook(adapter, client, pending) {
     if (minted || account.inferenceToken !== undefined && account.refresh)
       notifyPaired(client, adapter.id, account);
     await refreshUsageInBackground(adapter, Date.now()).catch(ignore);
+    if (tokens.refresh && !tokens.inferenceOnly)
+      await publishAfterLogin();
   };
   const oauthSuccess = (tokens) => ({
     type: "success",
@@ -18285,8 +18847,12 @@ function createProviderPlugin(adapter) {
 }
 var PROVIDER_LABELS, AnthropicLoadBalancerPlugin, OpenAILoadBalancerPlugin, KimiCodeLoadBalancerPlugin, KimiCodeGlobalLoadBalancerPlugin, lbResult = (output) => ({ title: "Auth Load Balancer", output }), AuthLoadBalancerStatusPlugin = async (input) => {
   const sync = startSync();
+  const usage = startUsagePoll();
   return {
-    dispose: async () => sync?.dispose(),
+    dispose: async () => {
+      await usage.dispose();
+      await sync?.dispose();
+    },
     tool: {
       auth_lb_status: tool({
         description: "Show the auth load-balancer pool: the in-use account per provider, each account's weekly and 5h usage, cooldowns, and the ranked next-candidate accounts. Refreshes stale usage from the provider usage endpoints (throttled) before rendering.",
@@ -18375,6 +18941,7 @@ var init_legacy = __esm(() => {
   init_start();
   init_token_mint();
   init_types();
+  init_usage_poll();
   init_usage_refresh();
   init_util2();
   PROVIDER_LABELS = {