@cortexkit/anthropic-auth-core 1.16.0 → 1.17.0

package/dist/accounts.js

@@ -5,6 +5,7 @@ import { dirname, join } from 'node:path';
 import { parseRetryAfterHeader, refreshClaudeOAuthToken } from "./auth.js";
 import { CACHE_1H_MODES, CLAUDE_CODE_VERSION, DEFAULT_CACHE_1H_MODE, } from "./constants.js";
 import { log, logger } from "./logger.js";
+import { tokenFingerprint } from "./token-fingerprint.js";
 const setRefreshLockRenewalTimeout = globalThis.setTimeout.bind(globalThis);
 const clearRefreshLockRenewalTimeout = globalThis.clearTimeout.bind(globalThis);
 export const ACCOUNT_FILE_NAME = 'anthropic-auth.json';
@@ -124,6 +125,28 @@ function normalizeAccount(value) {
         lastRefreshError: normalizeOperationError(value.lastRefreshError),
         lastQuotaRefreshError: normalizeOperationError(value.lastQuotaRefreshError),
         quota: normalizeQuota(value.quota),
+        profile: normalizeOAuthAccountProfile(value.profile),
+    };
+}
+function normalizeOAuthAccountProfile(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.tier !== 'string' ||
+        !value.tier.trim() ||
+        typeof value.orgType !== 'string' ||
+        !value.orgType.trim() ||
+        typeof value.checkedAt !== 'number' ||
+        !Number.isFinite(value.checkedAt)) {
+        return undefined;
+    }
+    return {
+        tier: value.tier.trim(),
+        orgType: value.orgType.trim(),
+        checkedAt: value.checkedAt,
+        ...(typeof value.tokenFingerprint === 'string' &&
+            value.tokenFingerprint.trim() && {
+            tokenFingerprint: value.tokenFingerprint.trim(),
+        }),
     };
 }
 function normalizeOperationError(value) {
@@ -220,8 +243,56 @@ function normalizeQuota(value) {
         // — only inputs that already carried an array reach this line.
         quota.scoped = scoped;
     }
+    if (isRecord(value.extraUsage)) {
+        const used = normalizeQuotaMoney(value.extraUsage.used);
+        const limit = normalizeQuotaMoney(value.extraUsage.limit);
+        if (used && limit && typeof value.extraUsage.exhausted === 'boolean') {
+            quota.extraUsage = {
+                used,
+                limit,
+                ...(typeof value.extraUsage.utilizationPercent === 'number' &&
+                    Number.isFinite(value.extraUsage.utilizationPercent) && {
+                    utilizationPercent: value.extraUsage.utilizationPercent,
+                }),
+                ...(typeof value.extraUsage.severity === 'string' && {
+                    severity: value.extraUsage.severity,
+                }),
+                exhausted: value.extraUsage.exhausted,
+            };
+        }
+    }
+    if (typeof value.bindingWindow === 'string' && value.bindingWindow.trim()) {
+        quota.bindingWindow = value.bindingWindow.trim();
+    }
+    if (value.bindingWindowSource === 'poll' ||
+        value.bindingWindowSource === 'headers') {
+        quota.bindingWindowSource = value.bindingWindowSource;
+    }
+    if (typeof value.fallbackAdvised === 'boolean') {
+        quota.fallbackAdvised = value.fallbackAdvised;
+    }
+    if (value.source === 'poll' || value.source === 'headers') {
+        quota.source = value.source;
+    }
     return Object.keys(quota).length ? quota : undefined;
 }
+function normalizeQuotaMoney(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.amountMinor !== 'number' ||
+        !Number.isFinite(value.amountMinor) ||
+        typeof value.currency !== 'string' ||
+        !value.currency.trim() ||
+        typeof value.exponent !== 'number' ||
+        !Number.isFinite(value.exponent)) {
+        return undefined;
+    }
+    return {
+        amountMinor: value.amountMinor,
+        currency: value.currency.trim(),
+        exponent: value.exponent,
+    };
+}
 // Fresh empty storage shell — main OpenCode OAuth account, no fallback
 // accounts. Returns a new object each call so mutating callers don't alias.
 export function createEmptyStorage() {
@@ -236,7 +307,11 @@ function normalizeStorage(value) {
         return null;
     return {
         version: 1,
-        main: { type: 'opencode', provider: 'anthropic' },
+        main: {
+            type: 'opencode',
+            provider: 'anthropic',
+            profile: normalizeOAuthAccountProfile(isRecord(value.main) ? value.main.profile : undefined),
+        },
         routing: isRecord(value.routing) ? value.routing : undefined,
         fallbackOn: Array.isArray(value.fallbackOn)
             ? value.fallbackOn.filter((status) => Number.isInteger(status))
@@ -330,6 +405,11 @@ function mergeConfigAndState(configValue, stateValue) {
         : [];
     return {
         ...configValue,
+        main: {
+            type: 'opencode',
+            provider: 'anthropic',
+            profile: normalizeOAuthAccountProfile(mainState?.profile),
+        },
         refresh: objectWithDefinedEntries({
             ...refreshConfig,
             mainLastRefreshError: mainRefreshSource.lastRefreshError,
@@ -392,52 +472,127 @@ function accountRuntimeState(account) {
         lastRefreshError: account.lastRefreshError,
         lastQuotaRefreshError: account.lastQuotaRefreshError,
         quota: account.quota,
+        profile: account.profile,
     });
 }
 function quotaSnapshotCheckedAt(quota) {
     return Math.max(quota?.five_hour?.checkedAt ?? 0, quota?.seven_day?.checkedAt ?? 0, ...(quota?.scoped?.map((window) => window.checkedAt) ?? []), quota?.checkedAt ?? 0);
 }
+function quotaSourcePrecedence(quota) {
+    if (quota?.source === 'poll')
+        return 2;
+    if (quota?.source === 'headers')
+        return 1;
+    return 0;
+}
+function mergeHeaderScopedQuota(existing, incoming) {
+    if (!('scoped' in existing))
+        return incoming.scoped;
+    if (!Array.isArray(existing.scoped) || existing.scoped.length === 0) {
+        return existing.scoped;
+    }
+    if (!Array.isArray(incoming.scoped) || incoming.scoped.length === 0) {
+        return existing.scoped;
+    }
+    const merged = new Map(incoming.scoped.map((window) => [window.id, window]));
+    for (const window of existing.scoped) {
+        const candidate = merged.get(window.id);
+        if (!candidate || window.checkedAt >= candidate.checkedAt) {
+            merged.set(window.id, window);
+        }
+    }
+    return [...merged.values()];
+}
+function mergeHeaderOwnedWindow(existingSnapshot, incomingSnapshot, key) {
+    const existing = existingSnapshot[key];
+    const incoming = incomingSnapshot[key];
+    if (!incoming)
+        return existing;
+    if (!existing)
+        return incoming;
+    if (incoming.checkedAt > existing.checkedAt)
+        return incoming;
+    if (incoming.checkedAt < existing.checkedAt)
+        return existing;
+    return quotaSourcePrecedence(existingSnapshot) >
+        quotaSourcePrecedence(incomingSnapshot)
+        ? existing
+        : incoming;
+}
+function mergeHeaderQuotaForPersistence(existing, incoming) {
+    if (!existing || incoming.source !== 'headers')
+        return incoming;
+    const preservePollBinding = existing.bindingWindowSource === 'poll';
+    return {
+        ...existing,
+        ...incoming,
+        five_hour: mergeHeaderOwnedWindow(existing, incoming, 'five_hour'),
+        seven_day: mergeHeaderOwnedWindow(existing, incoming, 'seven_day'),
+        scoped: mergeHeaderScopedQuota(existing, incoming),
+        extraUsage: existing.extraUsage ?? incoming.extraUsage,
+        bindingWindow: preservePollBinding
+            ? existing.bindingWindow
+            : (incoming.bindingWindow ?? existing.bindingWindow),
+        bindingWindowSource: preservePollBinding
+            ? 'poll'
+            : (incoming.bindingWindowSource ?? existing.bindingWindowSource),
+    };
+}
 function mergeAccountRuntimeState(existing, incoming) {
     if (!isRecord(existing))
         return incoming;
     const existingEntry = existing;
-    const existingQuotaCheckedAt = quotaSnapshotCheckedAt(existingEntry.quota);
-    const incomingQuotaCheckedAt = quotaSnapshotCheckedAt(incoming.quota);
     const tokenChanged = Boolean((existingEntry.access &&
         incoming.access &&
         existingEntry.access !== incoming.access) ||
         (existingEntry.refresh &&
             incoming.refresh &&
             existingEntry.refresh !== incoming.refresh));
-    if (existingQuotaCheckedAt > incomingQuotaCheckedAt) {
+    const mergesHeaderQuota = Boolean(!tokenChanged && incoming.quota?.source === 'headers');
+    const effectiveIncoming = mergesHeaderQuota && incoming.quota
+        ? {
+            ...incoming,
+            quota: mergeHeaderQuotaForPersistence(existingEntry.quota, incoming.quota),
+        }
+        : incoming;
+    const existingQuotaCheckedAt = quotaSnapshotCheckedAt(existingEntry.quota);
+    const incomingQuotaCheckedAt = quotaSnapshotCheckedAt(effectiveIncoming.quota);
+    const existingQuotaWinsEqualTimestamp = Boolean(existingQuotaCheckedAt === incomingQuotaCheckedAt &&
+        quotaSourcePrecedence(existingEntry.quota) >
+            quotaSourcePrecedence(effectiveIncoming.quota));
+    if (!mergesHeaderQuota &&
+        (existingQuotaCheckedAt > incomingQuotaCheckedAt ||
+            existingQuotaWinsEqualTimestamp)) {
         const existingRefreshAt = existingEntry.lastRefreshedAt ?? 0;
-        const incomingRefreshAt = incoming.lastRefreshedAt ?? 0;
+        const incomingRefreshAt = effectiveIncoming.lastRefreshedAt ?? 0;
         if (tokenChanged && incomingRefreshAt <= existingRefreshAt) {
             const merged = { ...existingEntry };
-            if (typeof incoming.lastUsed === 'number' &&
+            if (typeof effectiveIncoming.lastUsed === 'number' &&
                 (!(typeof existingEntry.lastUsed === 'number') ||
-                    incoming.lastUsed > existingEntry.lastUsed)) {
-                merged.lastUsed = incoming.lastUsed;
+                    effectiveIncoming.lastUsed > existingEntry.lastUsed)) {
+                merged.lastUsed = effectiveIncoming.lastUsed;
             }
             return merged;
         }
-        const merged = { ...existingEntry, ...incoming };
+        const merged = {
+            ...existingEntry,
+            ...effectiveIncoming,
+        };
         if (tokenChanged) {
-            if ('quota' in incoming) {
-                merged.quota = existingEntry.quota;
-                if ('lastQuotaRefreshError' in existingEntry) {
-                    merged.lastQuotaRefreshError = existingEntry.lastQuotaRefreshError;
-                }
-                else {
-                    delete merged.lastQuotaRefreshError;
-                }
+            if (!('profile' in effectiveIncoming))
+                delete merged.profile;
+            if (effectiveIncoming.quota?.source) {
+                merged.quota = effectiveIncoming.quota;
             }
             else {
                 delete merged.quota;
+            }
+            if (!('lastQuotaRefreshError' in effectiveIncoming)) {
                 delete merged.lastQuotaRefreshError;
             }
-            if (!('lastRefreshError' in incoming))
+            if (!('lastRefreshError' in effectiveIncoming)) {
                 delete merged.lastRefreshError;
+            }
             return merged;
         }
         return {
@@ -446,11 +601,20 @@ function mergeAccountRuntimeState(existing, incoming) {
             lastQuotaRefreshError: existingEntry.lastQuotaRefreshError,
         };
     }
-    const merged = { ...existingEntry, ...incoming };
-    if (!('lastQuotaRefreshError' in incoming)) {
+    const merged = {
+        ...existingEntry,
+        ...effectiveIncoming,
+    };
+    if (tokenChanged) {
+        if (!('profile' in effectiveIncoming))
+            delete merged.profile;
+        if (!effectiveIncoming.quota?.source)
+            delete merged.quota;
+    }
+    if (!('lastQuotaRefreshError' in effectiveIncoming)) {
         delete merged.lastQuotaRefreshError;
     }
-    if (!('lastRefreshError' in incoming)) {
+    if (!('lastRefreshError' in effectiveIncoming)) {
         delete merged.lastRefreshError;
     }
     return merged;
@@ -475,7 +639,7 @@ function configFromStorage(storage) {
         : undefined;
     return omitUndefinedTopLevel({
         version: 1,
-        main: storage.main,
+        main: { type: 'opencode', provider: 'anthropic' },
         routing: storage.routing,
         fallbackOn: storage.fallbackOn,
         refresh,
@@ -550,24 +714,45 @@ function mergeAccountsForSave(existing, incoming, options) {
 }
 const ACCOUNT_CONFIG_LOCK_TTL_MS = 10_000;
 const ACCOUNT_CONFIG_LOCK_WAIT_MS = 12_000;
-async function acquireAccountConfigWriteLock(path) {
+const ACCOUNT_STATE_LOCK_TTL_MS = 10_000;
+const ACCOUNT_STATE_LOCK_WAIT_MS = 12_000;
+async function acquireAccountWriteLock(input) {
+    const { path, name, ttlMs, waitMs, description } = input;
     await mkdir(dirname(path), { recursive: true });
-    const deadline = Date.now() + ACCOUNT_CONFIG_LOCK_WAIT_MS;
+    const deadline = Date.now() + waitMs;
     while (true) {
         const lock = await acquireRefreshFileLock({
-            name: 'config-write',
-            ttlMs: ACCOUNT_CONFIG_LOCK_TTL_MS,
+            name,
+            ttlMs,
             path,
             renew: true,
         });
         if (lock)
             return lock;
         if (Date.now() >= deadline) {
-            throw new Error('Timed out waiting for the account configuration write lock');
+            throw new Error(`Timed out waiting for the account ${description} lock`);
         }
         await new Promise((resolve) => setTimeout(resolve, 25));
     }
 }
+function acquireAccountConfigWriteLock(path) {
+    return acquireAccountWriteLock({
+        path,
+        name: 'config-write',
+        ttlMs: ACCOUNT_CONFIG_LOCK_TTL_MS,
+        waitMs: ACCOUNT_CONFIG_LOCK_WAIT_MS,
+        description: 'configuration write',
+    });
+}
+function acquireAccountStateWriteLock(path) {
+    return acquireAccountWriteLock({
+        path,
+        name: 'state-write',
+        ttlMs: ACCOUNT_STATE_LOCK_TTL_MS,
+        waitMs: ACCOUNT_STATE_LOCK_WAIT_MS,
+        description: 'state write',
+    });
+}
 export function saveAccounts(storage, path = getAccountStoragePath(), options = {}) {
     const resolvedPath = path;
     return enqueueSave(() => saveAccountsLocked(storage, resolvedPath, options));
@@ -583,28 +768,55 @@ async function saveAccountsLocked(storage, path, options) {
         const existing = await loadExistingTopLevelFields(path);
         const nextConfig = { ...existing, ...configFromStorage(nextStorage) };
         await writeJsonAtomic(path, nextConfig);
-        await saveAccountStateUnlocked(nextStorage, path, {
-            mainQuota: true,
-            mainRefresh: true,
-            accounts: true,
-        });
+        // Config precedes state everywhere both locks are needed; reversing this
+        // order can deadlock profile mutations against full account saves.
+        const stateLock = await acquireAccountStateWriteLock(path);
+        try {
+            await saveAccountStateUnlocked(nextStorage, path, {
+                mainQuota: true,
+                mainRefresh: true,
+                accounts: true,
+            });
+        }
+        finally {
+            await stateLock.release();
+        }
     }
     finally {
         await lock.release();
     }
 }
+function applyMainProfileStatePatch(state, storage) {
+    state.main = state.main ?? {};
+    state.main.profile = storage.main?.profile;
+}
 function applyMainQuotaStatePatch(state, storage) {
     state.main = state.main ?? {};
+    const incomingQuota = storage.quota?.mainQuota;
+    const sameToken = Boolean(state.main.quotaToken &&
+        storage.quota?.mainQuotaToken &&
+        state.main.quotaToken === storage.quota.mainQuotaToken);
+    const effectiveIncomingQuota = sameToken && incomingQuota?.source === 'headers'
+        ? mergeHeaderQuotaForPersistence(state.main.quota, incomingQuota)
+        : incomingQuota;
+    const mergesHeaderQuota = Boolean(sameToken && incomingQuota?.source === 'headers');
     const existingCheckedAt = typeof state.main.quotaCheckedAt === 'number'
         ? state.main.quotaCheckedAt
         : quotaSnapshotCheckedAt(state.main.quota);
     const incomingCheckedAt = typeof storage.quota?.mainQuotaCheckedAt === 'number'
         ? storage.quota.mainQuotaCheckedAt
-        : quotaSnapshotCheckedAt(storage.quota?.mainQuota);
-    if (existingCheckedAt > incomingCheckedAt)
+        : quotaSnapshotCheckedAt(effectiveIncomingQuota);
+    if (!mergesHeaderQuota &&
+        (existingCheckedAt > incomingCheckedAt ||
+            (existingCheckedAt === incomingCheckedAt &&
+                quotaSourcePrecedence(state.main.quota) >
+                    quotaSourcePrecedence(effectiveIncomingQuota)))) {
         return;
-    state.main.quota = storage.quota?.mainQuota;
-    state.main.quotaCheckedAt = storage.quota?.mainQuotaCheckedAt;
+    }
+    state.main.quota = effectiveIncomingQuota;
+    state.main.quotaCheckedAt = mergesHeaderQuota
+        ? Math.max(existingCheckedAt, incomingCheckedAt)
+        : storage.quota?.mainQuotaCheckedAt;
     state.main.quotaToken = storage.quota?.mainQuotaToken;
     state.main.lastQuotaApiError = storage.quota?.mainLastQuotaApiError;
 }
@@ -625,12 +837,97 @@ function pruneUndefined(value) {
         .map(([key, entry]) => [key, pruneUndefined(entry)]));
 }
 export function saveAccountState(storage, path = getAccountStoragePath(), scope = {
+    mainProfile: true,
     mainQuota: true,
     mainRefresh: true,
     accounts: true,
 }) {
     const resolvedPath = path;
-    return enqueueSave(() => saveAccountStateUnlocked(storage, resolvedPath, scope));
+    return enqueueSave(async () => {
+        const lock = await acquireAccountStateWriteLock(resolvedPath);
+        try {
+            await saveAccountStateUnlocked(storage, resolvedPath, scope);
+        }
+        finally {
+            await lock.release();
+        }
+    });
+}
+export function saveOAuthProfileState(input, path = getAccountStoragePath()) {
+    const resolvedPath = path;
+    return enqueueSave(async () => {
+        const configLock = await acquireAccountConfigWriteLock(resolvedPath);
+        try {
+            const stateLock = await acquireAccountStateWriteLock(resolvedPath);
+            try {
+                const current = await loadAccounts(resolvedPath);
+                const statePath = getAccountStatePath(resolvedPath);
+                const existing = (await readJsonIfPresent(statePath)).value;
+                const next = isRecord(existing)
+                    ? { ...existing, version: 1 }
+                    : { version: 1 };
+                const { accountId, expectedTokenFingerprint, profile } = input;
+                if (profile?.tokenFingerprint &&
+                    profile.tokenFingerprint !== expectedTokenFingerprint) {
+                    return false;
+                }
+                if (accountId === 'main') {
+                    next.main = { ...(next.main ?? {}) };
+                    const existingProfile = normalizeOAuthAccountProfile(next.main.profile);
+                    const persistedToken = next.main.profileToken ?? existingProfile?.tokenFingerprint;
+                    if (!profile &&
+                        existingProfile &&
+                        persistedToken === expectedTokenFingerprint) {
+                        return false;
+                    }
+                    if (profile) {
+                        if (persistedToken && persistedToken !== expectedTokenFingerprint) {
+                            return false;
+                        }
+                        if (existingProfile &&
+                            existingProfile.checkedAt > profile.checkedAt) {
+                            return false;
+                        }
+                    }
+                    next.main.profile = profile;
+                    next.main.profileToken = expectedTokenFingerprint;
+                }
+                else {
+                    const account = current?.accounts.find((candidate) => candidate.id === accountId && isOAuthAccount(candidate));
+                    if (!account?.access ||
+                        tokenFingerprint(account.access) !== expectedTokenFingerprint) {
+                        return false;
+                    }
+                    next.accounts = {
+                        ...(isRecord(next.accounts) ? next.accounts : {}),
+                    };
+                    const existingEntry = isRecord(next.accounts[accountId])
+                        ? { ...next.accounts[accountId] }
+                        : {};
+                    const existingProfile = normalizeOAuthAccountProfile(existingEntry.profile);
+                    if (!profile &&
+                        existingProfile?.tokenFingerprint === expectedTokenFingerprint) {
+                        return false;
+                    }
+                    if (profile &&
+                        existingProfile &&
+                        existingProfile.checkedAt > profile.checkedAt) {
+                        return false;
+                    }
+                    existingEntry.profile = profile;
+                    next.accounts[accountId] = existingEntry;
+                }
+                await writeJsonAtomic(statePath, pruneUndefined(next));
+                return true;
+            }
+            finally {
+                await stateLock.release();
+            }
+        }
+        finally {
+            await configLock.release();
+        }
+    });
 }
 async function saveAccountStateUnlocked(storage, path, scope) {
     const statePath = getAccountStatePath(path);
@@ -638,6 +935,8 @@ async function saveAccountStateUnlocked(storage, path, scope) {
     const next = isRecord(existing)
         ? { ...existing, version: 1 }
         : { version: 1 };
+    if (scope.mainProfile)
+        applyMainProfileStatePatch(next, storage);
     if (scope.mainQuota)
         applyMainQuotaStatePatch(next, storage);
     if (scope.mainRefresh)
@@ -1396,25 +1695,35 @@ export async function addAccountPersistent(account, path = getAccountStoragePath
     await saveAccounts(storage, path);
 }
 export function getQuotaNextRefreshAt(quota, storage, now) {
+    const intervalMs = getQuotaCheckIntervalMs(storage);
     if (!quotaEnabled(storage))
-        return now + getQuotaCheckIntervalMs(storage);
+        return now + intervalMs;
+    const windowFreshnessDeadline = Math.min(...[
+        ...['five_hour', 'seven_day'].map((key) => quota?.[key]?.checkedAt),
+        ...(quota?.scoped ?? []).map((window) => window.checkedAt),
+    ]
+        .filter((checkedAt) => Number.isFinite(checkedAt))
+        .map((checkedAt) => checkedAt + intervalMs));
+    const capAtOldestWindow = (candidate) => Number.isFinite(windowFreshnessDeadline)
+        ? Math.min(candidate, windowFreshnessDeadline)
+        : candidate;
     const thresholds = getQuotaMinimumRemainingThresholds(storage);
     const blockedResetTimes = [];
     for (const key of ['five_hour', 'seven_day']) {
         const window = quota?.[key];
         if (!window)
-            return now + getQuotaCheckIntervalMs(storage);
+            return capAtOldestWindow(now + intervalMs);
         if (window.remainingPercent >= thresholds[key])
             continue;
         const resetTime = window.resetsAt ? Date.parse(window.resetsAt) : Number.NaN;
         if (!Number.isFinite(resetTime) || resetTime <= now) {
-            return now + getQuotaCheckIntervalMs(storage);
+            return capAtOldestWindow(now + intervalMs);
         }
         blockedResetTimes.push(resetTime);
     }
     if (!blockedResetTimes.length)
-        return now + getQuotaCheckIntervalMs(storage);
-    return Math.min(...blockedResetTimes) + 60_000;
+        return capAtOldestWindow(now + intervalMs);
+    return capAtOldestWindow(Math.min(...blockedResetTimes) + 60_000);
 }
 function tokenNeedsRefresh(account, storage, now) {
     return (!account.access ||
@@ -1530,6 +1839,61 @@ function mapScopedWeeklyLimits(limits, checkedAt) {
     }
     return scoped;
 }
+function mapExtraUsage(usage) {
+    if (usage.extra_usage?.is_enabled !== true)
+        return undefined;
+    const usedAmount = usage.extra_usage.used_credits;
+    const limitAmount = usage.extra_usage.monthly_limit;
+    if (typeof usedAmount !== 'number' ||
+        !Number.isFinite(usedAmount) ||
+        typeof limitAmount !== 'number' ||
+        !Number.isFinite(limitAmount)) {
+        return undefined;
+    }
+    const rawCurrency = usage.spend?.limit?.currency;
+    const currency = rawCurrency == null ? 'USD' : nonEmptyString(rawCurrency);
+    const rawExponent = usage.spend?.limit?.exponent;
+    const moneyExponent = rawExponent == null ? 2 : rawExponent;
+    if (!currency ||
+        !/^[A-Za-z]{3}$/.test(currency) ||
+        !Number.isInteger(moneyExponent) ||
+        moneyExponent < 0 ||
+        moneyExponent > 20) {
+        return undefined;
+    }
+    return {
+        used: { amountMinor: usedAmount, currency, exponent: moneyExponent },
+        limit: { amountMinor: limitAmount, currency, exponent: moneyExponent },
+        ...(typeof usage.extra_usage.utilization === 'number' &&
+            Number.isFinite(usage.extra_usage.utilization) && {
+            utilizationPercent: usage.extra_usage.utilization,
+        }),
+        ...(nonEmptyString(usage.spend?.severity) && {
+            severity: nonEmptyString(usage.spend?.severity),
+        }),
+        exhausted: usedAmount >= limitAmount,
+    };
+}
+function mapBindingWindow(limits) {
+    if (!Array.isArray(limits))
+        return undefined;
+    const active = limits.find((limit) => limit?.is_active === true);
+    if (!active)
+        return undefined;
+    if (active.kind === 'session')
+        return 'five_hour';
+    if (active.kind === 'weekly_all')
+        return 'seven_day';
+    if (active.kind !== 'weekly_scoped' || active.group !== 'weekly') {
+        return undefined;
+    }
+    const modelName = nonEmptyString(active.scope?.model?.display_name);
+    if (!modelName)
+        return undefined;
+    const identity = nonEmptyString(active.scope?.model?.id) ?? modelName;
+    const slug = slugForQuotaIdentity(identity);
+    return slug ? `claude-weekly-scoped-${slug}` : undefined;
+}
 function mapUsageWindow(window, checkedAt) {
     if (typeof window?.utilization !== 'number')
         return undefined;
@@ -1565,10 +1929,17 @@ export async function fetchOAuthQuotaSnapshot(input) {
     }
     const checkedAt = input.now?.() ?? Date.now();
     const usage = (await response.json());
+    const bindingWindow = mapBindingWindow(usage.limits);
     return {
         five_hour: mapUsageWindow(usage.five_hour, checkedAt),
         seven_day: mapUsageWindow(usage.seven_day, checkedAt),
         scoped: mapScopedWeeklyLimits(usage.limits, checkedAt),
+        extraUsage: mapExtraUsage(usage),
+        ...(bindingWindow && {
+            bindingWindow,
+            bindingWindowSource: 'poll',
+        }),
+        source: 'poll',
         checkedAt,
     };
 }
@@ -1587,6 +1958,7 @@ export function upsertAccount(storage, account) {
             addedAt: storage.accounts[index]?.addedAt ?? account.addedAt,
             ...(account.type === 'oauth' && {
                 quota: account.quota,
+                profile: account.profile,
                 lastRefreshedAt: account.lastRefreshedAt,
                 lastRefreshError: account.lastRefreshError,
                 lastQuotaRefreshError: account.lastQuotaRefreshError,

package/dist/commands/account.d.ts

@@ -39,6 +39,7 @@ export interface AccountListItem {
     role: 'main' | 'fallback';
     enabled: boolean;
     quotaPercent: number | null;
+    tierLabel?: string;
 }
 export declare function buildAccountList(storage: AccountStorage): AccountListItem[];
 export declare function executeAccountCommand(input: {

package/dist/commands/account.js

@@ -1,3 +1,4 @@
+import { formatOAuthAccountTier } from "../oauth-profile.js";
 export const CLAUDE_ACCOUNT_COMMAND_NAME = 'claude-account';
 export function parseAccountCommandAction(argumentsText) {
     const parts = argumentsText.trim().split(/\s+/).filter(Boolean);
@@ -89,6 +90,7 @@ export function buildAccountList(storage) {
         role: 'main',
         enabled: true,
         quotaPercent: fiveHour?.usedPercent ?? null,
+        tierLabel: formatOAuthAccountTier(storage.main?.profile),
     });
     for (const account of storage.accounts) {
         const fiveHourQuota = account.quota?.five_hour;
@@ -98,6 +100,9 @@ export function buildAccountList(storage) {
             role: 'fallback',
             enabled: account.enabled !== false,
             quotaPercent: fiveHourQuota?.usedPercent ?? null,
+            tierLabel: account.type === 'oauth'
+                ? formatOAuthAccountTier(account.profile)
+                : undefined,
         });
     }
     return list;
@@ -124,7 +129,8 @@ export function executeAccountCommand(input) {
         for (const a of list) {
             const pct = a.quotaPercent != null ? ` ${Math.round(a.quotaPercent)}%` : '';
             const status = !a.enabled ? ' (disabled)' : '';
-            lines.push(`- **${a.label}** [${a.role}]${status}${pct}`);
+            const tier = a.tierLabel ? ` · ${a.tierLabel}` : '';
+            lines.push(`- **${a.label}** [${a.role}]${tier}${status}${pct}`);
         }
         lines.push('', USAGE_TEXT);
         return { text: lines.join('\n') };