@bitkyc08/opencodex 2.79.0 → 2.81.0

package/src/oauth/anthropic-model-quota.ts

@@ -2,6 +2,8 @@
 import { credentialGeneration, getAccountCredential } from "./store";
 import { getCachedProviderAccountQuota } from "../providers/quota/account-cache";
 import type { ProviderQuota, ProviderQuotaWindow } from "../providers/quota-types";
+import type { AnthropicInstanceId } from "../providers/anthropic-instance-id";
+import type { GenerationContext } from "../lib/state-store-sweeper";
 
 export const ANTHROPIC_PASSIVE_FAMILY_MAX_AGE_MS = 30 * 60_000;
 export type AnthropicModelFamily = "Fable" | "Opus" | "Sonnet";
@@ -17,67 +19,137 @@ export function anthropicModelPercents(quota: ProviderQuota | null, model?: stri
     ...(quota?.customWindows ?? []).filter(window => !model || window.scope !== "model" || (family && window.label === family)).map(window => window.percent)]
     .filter((value): value is number => typeof value === "number" && Number.isFinite(value));
 }
-export function anthropicModelExhausted(accountId: string, model?: string): boolean {
-  return anthropicModelPercents(getCachedProviderAccountQuota("anthropic", accountId), model).some(percent => percent >= 100);
-}
-
 interface FamilyObservation { generation: string; seenAt: number; resetAt?: number; busy: boolean; }
-const spentFamilies = new Map<string, FamilyObservation>();
-const familyGenerations = new Map<string, number>();
-let nextFamilyGeneration = 1;
-export function anthropicFamilyQuotaGeneration(id: string): number { return familyGenerations.get(id) ?? 0; }
 const keyFor = (id: string, family: string) => `${id}\0${family}`;
-function ownedObservation(id: string, family: string): FamilyObservation | undefined {
-  const key = keyFor(id, family);
-  const entry = spentFamilies.get(key);
-  if (!entry) return undefined;
-  const credential = getAccountCredential("anthropic", id);
-  if (!credential || credentialGeneration(credential) !== entry.generation) { spentFamilies.delete(key); return undefined; }
-  return entry;
+function createAnthropicModelQuota(instance: AnthropicInstanceId) {
+  let spentFamilies: Map<string, FamilyObservation> | undefined;
+  let familyGenerations: Map<string, number> | undefined;
+  let nextFamilyGeneration = 1;
+  let emptyGeneration = 0;
+  function bump(id: string): void { (familyGenerations ??= new Map()).set(id, nextFamilyGeneration++); }
+  function anthropicFamilyQuotaGeneration(id: string): number { return familyGenerations?.get(id) ?? emptyGeneration; }
+  /** Reserving an asynchronous probe is a write; ordinary generation reads stay allocation-free. */
+  function captureAnthropicFamilyQuotaGeneration(id: string): number {
+    if (!familyGenerations?.has(id)) bump(id);
+    return anthropicFamilyQuotaGeneration(id);
+  }
+  function anthropicModelExhausted(accountId: string, model?: string): boolean {
+    return anthropicModelPercents(getCachedProviderAccountQuota(instance, accountId), model).some(percent => percent >= 100);
+  }
+  function ownedObservation(id: string, family: string): FamilyObservation | undefined {
+    const key = keyFor(id, family);
+    const entry = spentFamilies?.get(key);
+    if (!entry) return undefined;
+    const credential = getAccountCredential(instance, id);
+    if (!credential || credentialGeneration(credential) !== entry.generation) { spentFamilies!.delete(key); bump(id); return undefined; }
+    return entry;
+  }
+  function observeAnthropicFamilyQuota(id: string, windows: ProviderQuotaWindow[], now: number, authoritative = false): void {
+    const credential = getAccountCredential(instance, id);
+    if (!credential) return;
+    if (!authoritative && !windows.some(window => window.scope === "model")) return;
+    bump(id);
+    const observations = spentFamilies ??= new Map();
+    if (authoritative) for (const key of observations.keys()) if (key.startsWith(`${id}\0`)) observations.delete(key);
+    for (const window of windows) {
+      if (window.scope !== "model") continue;
+      const key = keyFor(id, window.label);
+      if (!window.rejected) { observations.delete(key); continue; }
+      observations.set(key, { generation: credentialGeneration(credential), seenAt: now, resetAt: window.resetAt, busy: false });
+    }
+  }
+  function anthropicFamilyRejected(id: string, model?: string, now = Date.now()): boolean {
+    const family = anthropicModelFamily(model);
+    const entry = family && ownedObservation(id, family);
+    if (!entry) return false;
+    if (entry.resetAt !== undefined && entry.resetAt <= now) return entry.busy;
+    return entry.busy || now - entry.seenAt < ANTHROPIC_PASSIVE_FAMILY_MAX_AGE_MS;
+  }
+  /** Only stale passive family exclusions require a request-driven single-flight physical send. */
+  function claimAnthropicFamilyRevalidation(id: string, model?: string, now = Date.now()): (() => void) | null {
+    const family = anthropicModelFamily(model);
+    const entry = family && ownedObservation(id, family);
+    if (!entry) return () => {};
+    if (anthropicFamilyRejected(id, model, now)) return null;
+    entry.busy = true;
+    return () => { if (spentFamilies?.get(keyFor(id, family!)) === entry) entry.busy = false; };
+  }
+  /** An owned successful send proves admission for its requested family even without headers. */
+  function clearAnthropicRequestedFamilyQuota(id: string, model?: string): void {
+    const family = anthropicModelFamily(model);
+    if (family && spentFamilies?.delete(keyFor(id, family))) bump(id);
+  }
+  function clearAnthropicFamilyQuota(): void {
+    // A prior zero-generation claim must stay stale even after an identical account is re-added.
+    emptyGeneration = nextFamilyGeneration++;
+    spentFamilies = undefined;
+    familyGenerations = undefined;
+  }
+  function reconcileAnthropicFamilyQuota(context: GenerationContext): number {
+    let removed = 0;
+    const retired = new Set<string>();
+    for (const [key] of spentFamilies ?? []) {
+      const id = key.slice(0, key.indexOf("\0"));
+      if (context.oauthAccountKeys.has(`${instance}\0${id}`)) continue;
+      spentFamilies!.delete(key); retired.add(id); removed++;
+    }
+    for (const id of familyGenerations?.keys() ?? []) {
+      if (!context.oauthAccountKeys.has(`${instance}\0${id}`)) retired.add(id);
+    }
+    for (const id of retired) bump(id);
+    return removed;
+  }
+  function anthropicFamilyRetryAt(id: string, model?: string, now = Date.now()): number | undefined {
+    const family = anthropicModelFamily(model);
+    const entry = family && ownedObservation(id, family);
+    if (!entry || !anthropicFamilyRejected(id, model, now)) return undefined;
+    return entry.busy ? now + 1000 : Math.min(entry.resetAt ?? Infinity, entry.seenAt + ANTHROPIC_PASSIVE_FAMILY_MAX_AGE_MS);
+  }
+  return Object.freeze({ instance, anthropicModelExhausted, anthropicFamilyQuotaGeneration,
+    captureAnthropicFamilyQuotaGeneration,
+    observeAnthropicFamilyQuota, anthropicFamilyRejected, claimAnthropicFamilyRevalidation,
+    clearAnthropicRequestedFamilyQuota, clearAnthropicFamilyQuota, anthropicFamilyRetryAt, reconcileAnthropicFamilyQuota });
+}
+
+export type AnthropicModelQuota = ReturnType<typeof createAnthropicModelQuota>;
+const instances = new Map<AnthropicInstanceId, AnthropicModelQuota>();
+export function anthropicModelQuotaFor(instance: AnthropicInstanceId): AnthropicModelQuota {
+  let facade = instances.get(instance);
+  if (!facade) { facade = createAnthropicModelQuota(instance); instances.set(instance, facade); }
+  return facade;
+}
+export function reconcileAllAnthropicFamilyQuota(context: GenerationContext): number {
+  let removed = 0;
+  for (const facade of instances.values()) removed += facade.reconcileAnthropicFamilyQuota(context);
+  return removed;
+}
+export function clearAllAnthropicFamilyQuota(): void {
+  for (const facade of instances.values()) facade.clearAnthropicFamilyQuota();
+}
+export function anthropicModelExhausted(accountId: string, model?: string): boolean {
+  return anthropicModelQuotaFor("anthropic").anthropicModelExhausted(accountId, model);
+}
+export function anthropicFamilyQuotaGeneration(id: string): number {
+  return anthropicModelQuotaFor("anthropic").anthropicFamilyQuotaGeneration(id);
 }
 export function observeAnthropicFamilyQuota(id: string, windows: ProviderQuotaWindow[], now: number, authoritative = false): void {
-  const credential = getAccountCredential("anthropic", id);
-  if (!credential) return;
-  if (authoritative || windows.some(window => window.scope === "model")) familyGenerations.set(id, nextFamilyGeneration++);
-  if (authoritative) for (const key of spentFamilies.keys()) if (key.startsWith(`${id}\0`)) spentFamilies.delete(key);
-  for (const window of windows) {
-    if (window.scope !== "model") continue;
-    const key = keyFor(id, window.label);
-    if (!window.rejected) { spentFamilies.delete(key); continue; }
-    spentFamilies.set(key, { generation: credentialGeneration(credential), seenAt: now, resetAt: window.resetAt, busy: false });
-  }
+  anthropicModelQuotaFor("anthropic").observeAnthropicFamilyQuota(id, windows, now, authoritative);
 }
 export function anthropicFamilyRejected(id: string, model?: string, now = Date.now()): boolean {
-  const family = anthropicModelFamily(model);
-  const entry = family && ownedObservation(id, family);
-  if (!entry) return false;
-  if (entry.resetAt !== undefined && entry.resetAt <= now) return entry.busy;
-  return entry.busy || now - entry.seenAt < ANTHROPIC_PASSIVE_FAMILY_MAX_AGE_MS;
+  return anthropicModelQuotaFor("anthropic").anthropicFamilyRejected(id, model, now);
 }
-/** Only stale passive family exclusions require a request-driven single-flight physical send. */
 export function claimAnthropicFamilyRevalidation(id: string, model?: string, now = Date.now()): (() => void) | null {
-  const family = anthropicModelFamily(model);
-  const entry = family && ownedObservation(id, family);
-  if (!entry) return () => {};
-  if (anthropicFamilyRejected(id, model, now)) return null;
-  entry.busy = true;
-  return () => { entry.busy = false; };
+  return anthropicModelQuotaFor("anthropic").claimAnthropicFamilyRevalidation(id, model, now);
 }
-/** An owned successful send proves admission for its requested family even without headers. */
 export function clearAnthropicRequestedFamilyQuota(id: string, model?: string): void {
-  const family = anthropicModelFamily(model);
-  if (family && spentFamilies.delete(keyFor(id, family))) familyGenerations.set(id, nextFamilyGeneration++);
+  anthropicModelQuotaFor("anthropic").clearAnthropicRequestedFamilyQuota(id, model);
+}
+export function clearAnthropicFamilyQuota(): void { anthropicModelQuotaFor("anthropic").clearAnthropicFamilyQuota(); }
+export function anthropicFamilyRetryAt(id: string, model?: string, now = Date.now()): number | undefined {
+  return anthropicModelQuotaFor("anthropic").anthropicFamilyRetryAt(id, model, now);
 }
-export function clearAnthropicFamilyQuota(): void { spentFamilies.clear(); familyGenerations.clear(); }
 
 export function anthropicModelWeeklyPercent(quota: ProviderQuota | null, model?: string): number | undefined {
   const family = anthropicModelFamily(model);
   return family ? quota?.customWindows?.find(window => window.scope === "model" && window.label === family)?.percent : undefined;
 }
-
-export function anthropicFamilyRetryAt(id: string, model?: string, now = Date.now()): number | undefined {
-  const family = anthropicModelFamily(model);
-  const entry = family && ownedObservation(id, family);
-  if (!entry || !anthropicFamilyRejected(id, model, now)) return undefined;
-  return entry.busy ? now + 1000 : Math.min(entry.resetAt ?? Infinity, entry.seenAt + ANTHROPIC_PASSIVE_FAMILY_MAX_AGE_MS);
-}

package/src/oauth/anthropic-model-routes.ts

@@ -1,3 +1,5 @@
+import type { AnthropicInstanceId } from "../providers/anthropic-instance-id";
+import { resolveAnthropicAccountPoolConfig } from "./anthropic-pool-config";
 import type { AnthropicModelRoute, OcxConfig } from "../types/config";
 
 export interface AnthropicRouteDecision {
@@ -79,12 +81,14 @@ function matches(pattern: string, modelId: string): boolean {
   return p === pattern.length;
 }
 
-export function resolveAnthropicModelRoute(
+export function resolveAnthropicModelRouteForInstance(
+  instance: AnthropicInstanceId,
   config: OcxConfig,
   modelId: string,
 ): { decision: AnthropicRouteDecision | null; error?: string } {
-  if (config.anthropicAccountPool?.enabled !== true) return { decision: null };
-  const raw = (config.anthropicAccountPool as { routes?: unknown } | undefined)?.routes;
+  const pool = resolveAnthropicAccountPoolConfig(config, instance);
+  if (pool.enabled !== true) return { decision: null };
+  const raw = pool.routes;
   if (raw === undefined) return { decision: null };
   const parsed = parseAnthropicModelRoutes(raw);
   if (!parsed.ok) return { decision: null, error: parsed.error };
@@ -103,3 +107,7 @@ export function routeCandidates(eligible: readonly string[], decision: Anthropic
   const routed = decision.accounts.filter(id => available.has(id));
   return routed.length > 0 || !decision.fallback ? routed : [...eligible];
 }
+
+export function resolveAnthropicModelRoute(config: OcxConfig, modelId: string): { decision: AnthropicRouteDecision | null; error?: string } {
+  return resolveAnthropicModelRouteForInstance("anthropic", config, modelId);
+}

package/src/oauth/anthropic-oauth-definitions.ts

@@ -0,0 +1,98 @@
+import { ConfigMutationLockError } from "../config";
+import { deriveOAuthDefaultModel, deriveOAuthProviderConfig } from "../providers/derive";
+import type { AnthropicInstanceId } from "../providers/anthropic-instance-id";
+import { loginAnthropic, refreshAnthropicToken } from "./anthropic";
+import type { OAuthProviderDef } from "./index";
+import {
+  clearOAuthRefreshIntent, clearOAuthRefreshIntentIfMatch, markOAuthRefreshIntentCleanupPending,
+  OAuthRefreshIntentIOError, type OAuthRefreshIntent, type OAuthRefreshIntentCleanupPending,
+} from "./store";
+
+/** Both pools use the same flow; only A may import the local Claude credential. */
+export function anthropicOAuthDefinition(instance: AnthropicInstanceId): OAuthProviderDef {
+  const providerConfig = deriveOAuthProviderConfig(instance);
+  const defaultModel = deriveOAuthDefaultModel(instance);
+  if (!providerConfig || !defaultModel) throw new Error(`OAuth provider missing from registry: ${instance}`);
+  return {
+    login: (ctrl, opts) => loginAnthropic(ctrl, {
+      instance, importLocal: instance === "anthropic2" || opts?.forceLogin ? "off" : "fallback",
+    }),
+    refresh: refreshAnthropicToken,
+    providerConfig,
+    defaultModel,
+    // Subscription OAuth must never generate unattended traffic by default.
+    defaultRefreshPolicy: "disabled",
+  };
+}
+
+export { AnthropicInstanceCollisionError, assertAnthropicInstanceLoginConfig } from "./store-anthropic-instance";
+
+/** Cleanup is secondary once a rotated credential has become durable. */
+export function clearAnthropicRefreshIntentBestEffort(provider: string, accountId: string, expected: OAuthRefreshIntent): boolean {
+  try {
+    return expected.attemptId
+      ? clearOAuthRefreshIntentIfMatch(provider, accountId, expected)
+      : clearOAuthRefreshIntent(provider, accountId, expected.generation);
+  } catch {
+    console.warn("[opencodex] Anthropic refresh intent cleanup failed; preserving the durable replay guard.");
+    return false;
+  }
+}
+
+const ANTHROPIC_INTENT_MARK_RETRY_DELAYS_MS = [10, 25, 50] as const;
+function isConfigMutationLockContention(error: unknown): boolean {
+  if (!(error instanceof ConfigMutationLockError)) return false;
+  const cause = error.cause;
+  const code = cause && typeof cause === "object" && "code" in cause
+    ? String((cause as { code?: unknown }).code) : "";
+  return code === "SQLITE_BUSY" || code === "SQLITE_LOCKED";
+}
+
+export async function clearAnthropicRefreshIntentForKnownFailure(
+  provider: string, accountId: string, expected: OAuthRefreshIntent,
+  cleanupPending: OAuthRefreshIntentCleanupPending, refreshError: unknown,
+): Promise<boolean> {
+  let marked: OAuthRefreshIntent | undefined;
+  for (let attempt = 0; attempt <= ANTHROPIC_INTENT_MARK_RETRY_DELAYS_MS.length; attempt += 1) {
+    try {
+      marked = markOAuthRefreshIntentCleanupPending(provider, accountId, expected, cleanupPending);
+      break;
+    } catch (cause) {
+      const retryDelay = ANTHROPIC_INTENT_MARK_RETRY_DELAYS_MS[attempt];
+      if (!isConfigMutationLockContention(cause) || retryDelay === undefined) {
+        throw new OAuthRefreshIntentIOError("mark-cleanup-pending", cause, refreshError);
+      }
+      // Settlement retains the account lock after a definitive provider answer.
+      await Bun.sleep(retryDelay);
+    }
+  }
+  if (!marked) throw new OAuthRefreshIntentIOError("mark-cleanup-pending",
+    new Error("Anthropic refresh intent changed before safe cleanup"), refreshError);
+  let cleared: boolean;
+  try {
+    cleared = clearOAuthRefreshIntentIfMatch(provider, accountId, marked);
+  } catch {
+    console.warn("[opencodex] Anthropic refresh intent cleanup failed; retry-safe cleanup remains pending.");
+    return false;
+  }
+  if (!cleared) throw new OAuthRefreshIntentIOError("clear-cleanup-pending",
+    new Error("Anthropic refresh intent changed during safe cleanup"), refreshError);
+  return true;
+}
+
+export function resumeAnthropicRefreshIntentCleanup(provider: string, accountId: string, pendingIntent: OAuthRefreshIntent): void {
+  let cleared: boolean;
+  try {
+    cleared = clearOAuthRefreshIntentIfMatch(provider, accountId, pendingIntent);
+  } catch (cause) {
+    throw new OAuthRefreshIntentIOError("resume-cleanup", cause);
+  }
+  if (!cleared) throw new OAuthRefreshIntentIOError("resume-cleanup",
+    new Error("Pending Anthropic refresh intent changed before cleanup"));
+}
+
+export function clearObservedAnthropicRefreshIntent(provider: string, accountId: string, pendingIntent: OAuthRefreshIntent): boolean {
+  return pendingIntent.attemptId
+    ? clearOAuthRefreshIntentIfMatch(provider, accountId, pendingIntent)
+    : clearOAuthRefreshIntent(provider, accountId, pendingIntent.generation);
+}

package/src/oauth/anthropic-pool-config.ts

@@ -0,0 +1,30 @@
+/**
+ * Per-instance Anthropic pool settings. A reads only `config.anthropicAccountPool`; B reads only
+ * `config.providers.anthropic2.anthropicAccountPool`. A missing B block means product defaults, never
+ * A's settings. Pure: no store, network or state access.
+ */
+import type { OcxConfig } from "../types";
+import type { AnthropicAccountPoolConfig } from "../types/anthropic-account-pool";
+import type { AnthropicInstanceId } from "../providers/anthropic-instance-id";
+
+/** The raw value at the instance's own location, preserving absent/invalid distinctions for callers that need them. */
+export function rawAnthropicAccountPool(config: Pick<OcxConfig, "anthropicAccountPool" | "providers">, instance: AnthropicInstanceId): unknown {
+  if (instance === "anthropic") return config.anthropicAccountPool;
+  const row: unknown = config.providers?.[instance];
+  return row && typeof row === "object" ? (row as { anthropicAccountPool?: unknown }).anthropicAccountPool : undefined;
+}
+
+export function resolveAnthropicAccountPoolConfig(
+  config: Pick<OcxConfig, "anthropicAccountPool" | "providers">,
+  instance: AnthropicInstanceId,
+): AnthropicAccountPoolConfig {
+  const raw = rawAnthropicAccountPool(config, instance);
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw as AnthropicAccountPoolConfig : {};
+}
+
+export function isAnthropicPoolEnabledFor(
+  config: Pick<OcxConfig, "anthropicAccountPool" | "providers">,
+  instance: AnthropicInstanceId,
+): boolean {
+  return resolveAnthropicAccountPoolConfig(config, instance).enabled === true;
+}

package/src/oauth/anthropic-rate-limit-policy.ts

@@ -1,4 +1,7 @@
 /** Response-header policy for managed Anthropic sends; no account or request payload data. */
+import type { AnthropicInstanceId } from "../providers/anthropic-instance-id";
+import type { GenerationContext } from "../lib/state-store-sweeper";
+import { credentialGeneration, getAccountCredential } from "./store";
 export type AnthropicRateLimitKind = "shared-quota" | "family-quota" | "transient-rate" | "request-scoped-unknown";
 export type RateLimitHeaders = Pick<Headers, "get">;
 export const ANTHROPIC_SHORT_RETRY_MS = 100;
@@ -22,16 +25,68 @@ export function classifyAnthropic429(headers: RateLimitHeaders, now = Date.now()
   return "request-scoped-unknown";
 }
 
-const pauses = new Map<string, number>();
+function createAnthropicRatePolicy(instance: AnthropicInstanceId) {
+  let pauses: Map<string, { until: number; generation: string }> | undefined;
+  function pauseAnthropicRateAdmission(accountId: string, until: number): void {
+    const credential = getAccountCredential(instance, accountId);
+    if (!credential) return;
+    const now = Date.now();
+    const generation = credentialGeneration(credential);
+    const rows = pauses ??= new Map();
+    for (const [id, pause] of rows) if (pause.until <= now) rows.delete(id);
+    const previous = rows.get(accountId);
+    rows.set(accountId, { until: Math.max(previous?.generation === generation ? previous.until : 0, until), generation });
+  }
+  function anthropicRatePauseUntil(accountId: string, now = Date.now()): number | undefined {
+    const pause = pauses?.get(accountId);
+    if (!pause) return undefined;
+    const credential = getAccountCredential(instance, accountId);
+    if (pause.until <= now || !credential || credentialGeneration(credential) !== pause.generation) {
+      pauses!.delete(accountId); return undefined;
+    }
+    return pause.until;
+  }
+  function clearAnthropicRatePauses(): void { pauses = undefined; }
+  function reconcileAnthropicRatePauses(context: GenerationContext): number {
+    let removed = 0;
+    for (const id of pauses?.keys() ?? []) {
+      if (context.oauthAccountKeys.has(`${instance}\0${id}`)) continue;
+      pauses!.delete(id); removed++;
+    }
+    return removed;
+  }
+  function sweepExpiredAnthropicRatePauses(now = Date.now()): number {
+    let removed = 0;
+    for (const [id, pause] of pauses ?? []) if (pause.until <= now) { pauses!.delete(id); removed++; }
+    return removed;
+  }
+  return Object.freeze({ instance, pauseAnthropicRateAdmission, anthropicRatePauseUntil,
+    clearAnthropicRatePauses, reconcileAnthropicRatePauses, sweepExpiredAnthropicRatePauses });
+}
+export type AnthropicRatePolicy = ReturnType<typeof createAnthropicRatePolicy>;
+const instances = new Map<AnthropicInstanceId, AnthropicRatePolicy>();
+export function anthropicRatePolicyFor(instance: AnthropicInstanceId): AnthropicRatePolicy {
+  let facade = instances.get(instance);
+  if (!facade) { facade = createAnthropicRatePolicy(instance); instances.set(instance, facade); }
+  return facade;
+}
+export function reconcileAllAnthropicRatePauses(context: GenerationContext): number {
+  let removed = 0;
+  for (const facade of instances.values()) removed += facade.reconcileAnthropicRatePauses(context);
+  return removed;
+}
+export function sweepExpiredAllAnthropicRatePauses(now = Date.now()): number {
+  let removed = 0;
+  for (const facade of instances.values()) removed += facade.sweepExpiredAnthropicRatePauses(now);
+  return removed;
+}
+export function clearAllAnthropicRatePauses(): void {
+  for (const facade of instances.values()) facade.clearAnthropicRatePauses();
+}
 export function pauseAnthropicRateAdmission(accountId: string, until: number): void {
-  const now = Date.now();
-  for (const [id, deadline] of pauses) if (deadline <= now) pauses.delete(id);
-  pauses.set(accountId, Math.max(pauses.get(accountId) ?? 0, until));
+  anthropicRatePolicyFor("anthropic").pauseAnthropicRateAdmission(accountId, until);
 }
 export function anthropicRatePauseUntil(accountId: string, now = Date.now()): number | undefined {
-  const until = pauses.get(accountId);
-  if (until === undefined) return undefined;
-  if (until <= now) { pauses.delete(accountId); return undefined; }
-  return until;
+  return anthropicRatePolicyFor("anthropic").anthropicRatePauseUntil(accountId, now);
 }
-export function clearAnthropicRatePauses(): void { pauses.clear(); }
+export function clearAnthropicRatePauses(): void { anthropicRatePolicyFor("anthropic").clearAnthropicRatePauses(); }