@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

package/services/account-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-pool.d.ts","sourceRoot":"","sources":["../../../../../src/services/account-pool.ts"],"names":[],"mappings":"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"}

package/services/account-pool.js

@@ -0,0 +1,693 @@
+/**
+ * Multi-account selection brain.
+ *
+ * Owns the runtime decision "which `LinkedAccountConfig` should serve this
+ * request?" given a strategy (priority / round-robin / least-used /
+ * quota-aware), session affinity, and per-account health state.
+ *
+ * The pool never reads OAuth credentials directly — callers resolve them
+ * via `getAccessToken(providerId, accountId)` from `@elizaos/agent` once
+ * the pool returns an account. Health, priority, and usage live in this
+ * layer; the OAuth blob lives under `~/.eliza/auth/` (see WS1's
+ * `account-storage.ts`).
+ *
+ * Persistence: the pool layers rich metadata (priority, enabled, health,
+ * usage) on top of WS1's credential records. The metadata is written to
+ * `<ELIZA_HOME>/auth/_pool-metadata.json` atomically so it survives
+ * process restarts and is independent of WS3's eventual `eliza.json`
+ * field — when WS3 lands its CRUD API on top of `LinkedAccountsConfig`
+ * we can swap `createDefaultAccountPool()`'s deps without touching the
+ * pool itself.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { ACCOUNT_CREDENTIAL_PROVIDER_IDS, DIRECT_ACCOUNT_PROVIDER_ENV, DIRECT_ACCOUNT_PROVIDER_IDS, getAccessToken as getAccountAccessToken, isSubscriptionProvider, listProviderAccounts, } from "@elizaos/agent";
+import { logger } from "@elizaos/core";
+import { pollAnthropicUsage, pollCodexUsage, recordCall as recordUsageEntry, } from "./account-usage.js";
+const DEFAULT_RATE_LIMIT_BACKOFF_MS = 60_000;
+const QUOTA_AWARE_SKIP_PCT = 85;
+const SESSION_AFFINITY_MAX_ATTEMPTS = 3;
+const DIRECT_PROVIDER_BY_BACKEND = {
+    anthropic: "anthropic-api",
+    openai: "openai-api",
+    deepseek: "deepseek-api",
+    zai: "zai-api",
+    moonshot: "moonshot-api",
+};
+const OPENAI_COMPAT_BASE_BY_DIRECT_PROVIDER = {
+    "moonshot-api": "https://api.moonshot.ai/v1",
+};
+const KEEP_ALIVE_INTERVAL_MS = 5 * 60_000;
+export class AccountPool {
+    deps;
+    affinity = new Map();
+    roundRobinCursor = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    // Selection.
+    async select(input) {
+        const all = this.deps.readAccounts();
+        const eligible = this.filterEligible(all, input);
+        if (eligible.length === 0)
+            return null;
+        if (input.sessionKey) {
+            const cached = this.affinity.get(input.sessionKey);
+            if (cached &&
+                cached.attempts < SESSION_AFFINITY_MAX_ATTEMPTS &&
+                eligible.some((a) => a.id === cached.accountId)) {
+                cached.attempts += 1;
+                const account = eligible.find((a) => a.id === cached.accountId);
+                if (account)
+                    return account;
+            }
+        }
+        const strategy = input.strategy ?? "priority";
+        const picked = this.applyStrategy(strategy, eligible, input.providerId);
+        if (!picked)
+            return null;
+        if (input.sessionKey) {
+            this.affinity.set(input.sessionKey, {
+                accountId: picked.id,
+                attempts: 1,
+            });
+        }
+        return picked;
+    }
+    filterEligible(all, input) {
+        const exclude = new Set(input.exclude ?? []);
+        const explicit = input.accountIds && input.accountIds.length > 0
+            ? new Set(input.accountIds)
+            : null;
+        const now = Date.now();
+        return Object.values(all).filter((account) => {
+            if (account.providerId !== input.providerId)
+                return false;
+            if (!account.enabled)
+                return false;
+            if (exclude.has(account.id))
+                return false;
+            if (explicit && !explicit.has(account.id))
+                return false;
+            if (account.health === "ok")
+                return true;
+            // Allow rate-limited accounts back in once their reset has passed.
+            if (account.health === "rate-limited" &&
+                typeof account.healthDetail?.until === "number" &&
+                account.healthDetail.until < now) {
+                return true;
+            }
+            return false;
+        });
+    }
+    applyStrategy(strategy, eligible, providerId) {
+        if (eligible.length === 0)
+            return null;
+        if (eligible.length === 1)
+            return eligible[0] ?? null;
+        switch (strategy) {
+            case "round-robin": {
+                const sorted = [...eligible].sort(byPriorityThenAge);
+                const cursor = (this.roundRobinCursor.get(providerId) ?? -1) + 1;
+                const index = cursor % sorted.length;
+                this.roundRobinCursor.set(providerId, index);
+                return sorted[index] ?? null;
+            }
+            case "least-used": {
+                return [...eligible].sort(byLeastUsedThenPriority)[0] ?? null;
+            }
+            case "quota-aware": {
+                const underQuota = eligible.filter((a) => (a.usage?.sessionPct ?? 0) < QUOTA_AWARE_SKIP_PCT);
+                const pool = underQuota.length > 0 ? underQuota : eligible;
+                return [...pool].sort(byPriorityThenAge)[0] ?? null;
+            }
+            default:
+                return [...eligible].sort(byPriorityThenAge)[0] ?? null;
+        }
+    }
+    // CRUD — used by accounts-routes.ts as the single source of truth for
+    // LinkedAccountConfig records. Both reads and writes go through here so
+    // changes from the HTTP API and from runtime mutations (markRateLimited,
+    // refreshUsage, recordCall) stay consistent.
+    list(providerId) {
+        const all = Object.values(this.deps.readAccounts());
+        if (!providerId)
+            return all;
+        return all.filter((a) => a.providerId === providerId);
+    }
+    get(accountId, providerId) {
+        return findAccountById(this.deps.readAccounts(), accountId, providerId);
+    }
+    async upsert(account) {
+        await this.deps.writeAccount(account);
+    }
+    async deleteMetadata(providerId, accountId) {
+        if (!this.deps.deleteAccount)
+            return;
+        await this.deps.deleteAccount(providerId, accountId);
+    }
+    // Mutations.
+    async recordCall(accountId, result, opts) {
+        const account = findAccountById(this.deps.readAccounts(), accountId, opts?.providerId);
+        if (!account)
+            return;
+        recordUsageEntry(account.providerId, account.id, result);
+        const next = {
+            ...account,
+            lastUsedAt: Date.now(),
+        };
+        await this.deps.writeAccount(next);
+    }
+    async refreshUsage(accountId, accessToken, opts) {
+        const account = findAccountById(this.deps.readAccounts(), accountId, opts?.providerId);
+        if (!account)
+            return;
+        let usage;
+        if (account.providerId === "anthropic-subscription") {
+            usage = await pollAnthropicUsage(accessToken, opts?.fetch);
+        }
+        else if (account.providerId === "openai-codex") {
+            const codexAccountId = opts?.codexAccountId ?? account.organizationId;
+            if (!codexAccountId) {
+                throw new Error(`[AccountPool] Codex usage probe needs the OpenAI account_id (account ${accountId} has no organizationId).`);
+            }
+            usage = await pollCodexUsage(accessToken, codexAccountId, opts?.fetch);
+        }
+        else {
+            // No probe defined for direct API providers.
+            return;
+        }
+        await this.deps.writeAccount({
+            ...account,
+            health: "ok",
+            usage,
+        });
+    }
+    async markRateLimited(accountId, untilMs, detail, opts) {
+        const account = findAccountById(this.deps.readAccounts(), accountId, opts?.providerId);
+        if (!account)
+            return;
+        const healthDetail = {
+            until: Number.isFinite(untilMs) && untilMs > Date.now()
+                ? untilMs
+                : Date.now() + DEFAULT_RATE_LIMIT_BACKOFF_MS,
+            lastChecked: Date.now(),
+            ...(detail ? { lastError: detail } : {}),
+        };
+        await this.deps.writeAccount({
+            ...account,
+            health: "rate-limited",
+            healthDetail,
+        });
+    }
+    async markNeedsReauth(accountId, detail, opts) {
+        const account = findAccountById(this.deps.readAccounts(), accountId, opts?.providerId);
+        if (!account)
+            return;
+        await this.deps.writeAccount({
+            ...account,
+            health: "needs-reauth",
+            healthDetail: {
+                lastChecked: Date.now(),
+                ...(detail ? { lastError: detail } : {}),
+            },
+        });
+    }
+    async markInvalid(accountId, detail, opts) {
+        const account = findAccountById(this.deps.readAccounts(), accountId, opts?.providerId);
+        if (!account)
+            return;
+        await this.deps.writeAccount({
+            ...account,
+            health: "invalid",
+            healthDetail: {
+                lastChecked: Date.now(),
+                ...(detail ? { lastError: detail } : {}),
+            },
+        });
+    }
+    async markHealthy(accountId, opts) {
+        const account = findAccountById(this.deps.readAccounts(), accountId, opts?.providerId);
+        if (!account)
+            return;
+        if (account.health === "ok")
+            return;
+        await this.deps.writeAccount({
+            ...account,
+            health: "ok",
+            ...(account.healthDetail ? { healthDetail: undefined } : {}),
+        });
+    }
+    /**
+     * Re-probe accounts whose `health` is non-OK and whose `healthDetail.until`
+     * has passed (or is absent). Used by background sweepers to recover
+     * temporarily flagged accounts. We don't load access tokens here — the
+     * caller probes via `refreshUsage` separately.
+     */
+    async reprobeFlagged() {
+        const all = this.deps.readAccounts();
+        const now = Date.now();
+        const ready = [];
+        for (const account of Object.values(all)) {
+            if (account.health === "ok")
+                continue;
+            if (account.health === "rate-limited") {
+                const until = account.healthDetail?.until;
+                if (typeof until === "number" && until > now)
+                    continue;
+            }
+            ready.push(account.id);
+        }
+        return ready;
+    }
+}
+function poolRecordKey(providerId, accountId) {
+    return `${providerId}:${accountId}`;
+}
+function findAccountById(all, accountId, providerId) {
+    if (providerId) {
+        const scoped = all[poolRecordKey(providerId, accountId)];
+        if (scoped)
+            return scoped;
+        return (Object.values(all).find((account) => account.id === accountId && account.providerId === providerId) ?? null);
+    }
+    const direct = all[accountId];
+    if (direct)
+        return direct;
+    return Object.values(all).find((account) => account.id === accountId) ?? null;
+}
+function byPriorityThenAge(a, b) {
+    if (a.priority !== b.priority)
+        return a.priority - b.priority;
+    const aLast = a.lastUsedAt ?? 0;
+    const bLast = b.lastUsedAt ?? 0;
+    return aLast - bLast; // older first
+}
+function byLeastUsedThenPriority(a, b) {
+    const aPct = a.usage?.sessionPct ?? 0;
+    const bPct = b.usage?.sessionPct ?? 0;
+    if (aPct !== bPct)
+        return aPct - bPct;
+    return byPriorityThenAge(a, b);
+}
+function authRoot() {
+    return path.join(process.env.ELIZA_HOME || path.join(os.homedir(), ".eliza"), "auth");
+}
+function metadataFile() {
+    return path.join(authRoot(), "_pool-metadata.json");
+}
+function isPoolProviderId(value) {
+    return (value === "anthropic-subscription" ||
+        value === "openai-codex" ||
+        value === "gemini-cli" ||
+        value === "zai-coding" ||
+        value === "kimi-coding" ||
+        value === "deepseek-coding" ||
+        value === "anthropic-api" ||
+        value === "openai-api" ||
+        value === "deepseek-api" ||
+        value === "zai-api" ||
+        value === "moonshot-api");
+}
+function readMetaStore() {
+    const file = metadataFile();
+    if (!existsSync(file)) {
+        return {};
+    }
+    try {
+        const raw = readFileSync(file, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Corrupt file — fall through to empty store. Next write rewrites it.
+    }
+    return {};
+}
+function writeMetaStore(store) {
+    const file = metadataFile();
+    const dir = path.dirname(file);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    const tmp = `${file}.tmp`;
+    writeFileSync(tmp, JSON.stringify(store, null, 2), {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+    renameSync(tmp, file);
+}
+function recordToLinked(record, meta, providerId, defaultPriority) {
+    return {
+        id: record.id,
+        providerId,
+        label: meta?.label ?? record.label,
+        source: record.source,
+        enabled: meta?.enabled ?? true,
+        priority: meta?.priority ?? defaultPriority,
+        createdAt: record.createdAt,
+        health: meta?.health ?? "ok",
+        ...(record.lastUsedAt !== undefined
+            ? { lastUsedAt: record.lastUsedAt }
+            : {}),
+        ...(meta?.healthDetail ? { healthDetail: meta.healthDetail } : {}),
+        ...(meta?.usage ? { usage: meta.usage } : {}),
+        ...(record.organizationId ? { organizationId: record.organizationId } : {}),
+        ...(record.userId ? { userId: record.userId } : {}),
+        ...(record.email ? { email: record.email } : {}),
+    };
+}
+function loadAllAccounts() {
+    const meta = readMetaStore();
+    const out = {};
+    for (const provider of ACCOUNT_CREDENTIAL_PROVIDER_IDS) {
+        const records = listProviderAccounts(provider);
+        let priorityCounter = 0;
+        const sorted = [...records].sort((a, b) => a.createdAt - b.createdAt);
+        for (const record of sorted) {
+            const providerMeta = meta[provider]?.[record.id];
+            out[poolRecordKey(provider, record.id)] = recordToLinked(record, providerMeta, provider, priorityCounter);
+            priorityCounter += 1;
+        }
+    }
+    return out;
+}
+async function persistAccount(account) {
+    if (!isPoolProviderId(account.providerId))
+        return;
+    const store = readMetaStore();
+    if (!store[account.providerId]) {
+        store[account.providerId] = {};
+    }
+    store[account.providerId][account.id] = {
+        label: account.label,
+        enabled: account.enabled,
+        priority: account.priority,
+        health: account.health,
+        ...(account.healthDetail ? { healthDetail: account.healthDetail } : {}),
+        ...(account.usage ? { usage: account.usage } : {}),
+    };
+    writeMetaStore(store);
+}
+async function deleteAccountMeta(providerId, accountId) {
+    const store = readMetaStore();
+    const bucket = store[providerId];
+    if (!bucket)
+        return;
+    if (!(accountId in bucket))
+        return;
+    delete bucket[accountId];
+    writeMetaStore(store);
+}
+/**
+ * Symbol-keyed bridge contract consumed by plugin-anthropic's
+ * `credential-store.ts`. Kept narrow so the plugin doesn't have to import
+ * the full pool surface (or the rest of `@elizaos/app-core`).
+ */
+const ANTHROPIC_POOL_BRIDGE_SYMBOL = Symbol.for("eliza.account-pool.anthropic.v1");
+/**
+ * Bridge used by `applySubscriptionCredentials` in `@elizaos/agent` to pick
+ * the active Codex account when applying `OPENAI_API_KEY`. Lives behind
+ * a symbol so the agent package doesn't need to depend on app-core.
+ */
+const SUBSCRIPTION_SELECTOR_BRIDGE_SYMBOL = Symbol.for("eliza.account-pool.subscription-selector.v1");
+let cachedDefaultPool = null;
+let defaultSelectionConfig = {};
+function normalizeStrategy(value) {
+    return value === "priority" ||
+        value === "round-robin" ||
+        value === "least-used" ||
+        value === "quota-aware"
+        ? value
+        : undefined;
+}
+function normalizeAccountIdsFromRoute(route) {
+    if (!route)
+        return undefined;
+    const fromList = Array.isArray(route.accountIds)
+        ? route.accountIds
+            .map((id) => (typeof id === "string" ? id.trim() : ""))
+            .filter(Boolean)
+        : [];
+    const single = typeof route.accountId === "string" && route.accountId.trim()
+        ? [route.accountId.trim()]
+        : [];
+    const ids = fromList.length > 0 ? fromList : single;
+    return ids.length > 0 ? ids : undefined;
+}
+function routeTargetsProvider(route, providerId) {
+    if (!route?.backend)
+        return false;
+    const directProvider = DIRECT_PROVIDER_BY_BACKEND[route.backend];
+    if (directProvider === providerId)
+        return true;
+    if (providerId === "anthropic-subscription" &&
+        route.backend === "anthropic") {
+        return true;
+    }
+    return providerId === "openai-codex" && route.backend === "openai";
+}
+function selectionForProvider(providerId) {
+    const route = defaultSelectionConfig.serviceRouting?.llmText;
+    const routeSelection = routeTargetsProvider(route, providerId)
+        ? {
+            strategy: normalizeStrategy(route?.strategy),
+            accountIds: normalizeAccountIdsFromRoute(route),
+        }
+        : {};
+    return {
+        strategy: routeSelection.strategy ??
+            normalizeStrategy(defaultSelectionConfig.accountStrategies?.[providerId]),
+        accountIds: routeSelection.accountIds,
+    };
+}
+export function __getDefaultAccountPoolSelectionForTests(providerId) {
+    return selectionForProvider(providerId);
+}
+export function configureDefaultAccountPoolSelection(config = {}) {
+    defaultSelectionConfig = {
+        accountStrategies: config.accountStrategies ?? {},
+        serviceRouting: config.serviceRouting ?? null,
+    };
+}
+/**
+ * Module-level singleton for the default pool wired against WS1's
+ * `account-storage` and the pool-owned metadata file. Plugins / runtime
+ * resolvers should import `getDefaultAccountPool()` rather than building
+ * a new pool. WS3 may later swap the default deps to read/write the
+ * `LinkedAccountsConfig` field directly out of `eliza.json`; consumers
+ * keep the same accessor.
+ */
+export function getDefaultAccountPool() {
+    if (!cachedDefaultPool) {
+        cachedDefaultPool = new AccountPool({
+            readAccounts: () => loadAllAccounts(),
+            writeAccount: persistAccount,
+            deleteAccount: deleteAccountMeta,
+        });
+        installAnthropicBridge(cachedDefaultPool);
+        installSubscriptionSelectorBridge(cachedDefaultPool);
+    }
+    return cachedDefaultPool;
+}
+export async function applyAccountPoolApiCredentials(opts = {}) {
+    configureDefaultAccountPoolSelection({
+        accountStrategies: opts.accountStrategies,
+        serviceRouting: opts.serviceRouting,
+    });
+    const pool = getDefaultAccountPool();
+    const activeProvider = opts.activeBackend
+        ? DIRECT_PROVIDER_BY_BACKEND[opts.activeBackend]
+        : undefined;
+    let activeProviderToken = null;
+    for (const providerId of DIRECT_ACCOUNT_PROVIDER_IDS) {
+        const accounts = listProviderAccounts(providerId);
+        if (accounts.length === 0)
+            continue;
+        const account = (await pool.select({
+            providerId,
+            sessionKey: `env:${providerId}`,
+            ...selectionForProvider(providerId),
+        })) ?? accounts.slice().sort((a, b) => a.createdAt - b.createdAt)[0];
+        if (!account)
+            continue;
+        const token = await getAccountAccessToken(providerId, account.id);
+        if (!token)
+            continue;
+        const envKey = DIRECT_ACCOUNT_PROVIDER_ENV[providerId];
+        process.env[envKey] = token;
+        if (activeProvider === providerId) {
+            activeProviderToken = token;
+        }
+        if (providerId === "zai-api") {
+            process.env.Z_AI_API_KEY ??= token;
+        }
+        const openAiCompatibleBase = activeProvider === providerId
+            ? OPENAI_COMPAT_BASE_BY_DIRECT_PROVIDER[providerId]
+            : undefined;
+        if (openAiCompatibleBase) {
+            process.env.OPENAI_API_KEY = token;
+            process.env.OPENAI_BASE_URL = openAiCompatibleBase;
+        }
+    }
+    if (activeProvider && !activeProviderToken) {
+        const envKey = DIRECT_ACCOUNT_PROVIDER_ENV[activeProvider];
+        activeProviderToken = process.env[envKey]?.trim() || null;
+        if (!activeProviderToken && activeProvider === "zai-api") {
+            activeProviderToken = process.env.Z_AI_API_KEY?.trim() || null;
+        }
+        if (!activeProviderToken && activeProvider === "moonshot-api") {
+            activeProviderToken = process.env.KIMI_API_KEY?.trim() || null;
+        }
+        const openAiCompatibleBase = activeProviderToken
+            ? OPENAI_COMPAT_BASE_BY_DIRECT_PROVIDER[activeProvider]
+            : undefined;
+        const token = activeProviderToken;
+        if (openAiCompatibleBase && token) {
+            process.env.OPENAI_API_KEY = token;
+            process.env.OPENAI_BASE_URL = openAiCompatibleBase;
+        }
+    }
+}
+export async function sweepAccountPoolKeepAlive() {
+    const pool = getDefaultAccountPool();
+    const result = {
+        checked: 0,
+        refreshed: 0,
+        failed: 0,
+    };
+    for (const providerId of ACCOUNT_CREDENTIAL_PROVIDER_IDS) {
+        for (const record of listProviderAccounts(providerId)) {
+            result.checked += 1;
+            const token = await getAccountAccessToken(providerId, record.id);
+            if (!token) {
+                result.failed += 1;
+                await pool.markNeedsReauth(record.id, "No valid credential available", {
+                    providerId,
+                });
+                continue;
+            }
+            if (!isSubscriptionProvider(providerId)) {
+                continue;
+            }
+            try {
+                await pool.refreshUsage(record.id, token, {
+                    providerId,
+                    ...(record.organizationId
+                        ? { codexAccountId: record.organizationId }
+                        : {}),
+                });
+                result.refreshed += 1;
+            }
+            catch (err) {
+                result.failed += 1;
+                const message = err instanceof Error ? err.message : String(err);
+                if (/401|403|invalid|unauthor/i.test(message)) {
+                    await pool.markNeedsReauth(record.id, message, { providerId });
+                }
+                else if (/429|rate.?limit/i.test(message)) {
+                    await pool.markRateLimited(record.id, Date.now() + DEFAULT_RATE_LIMIT_BACKOFF_MS, message, { providerId });
+                }
+                else {
+                    await pool.markInvalid(record.id, message, { providerId });
+                }
+            }
+        }
+    }
+    return result;
+}
+let keepAliveTimer = null;
+let keepAliveRunning = false;
+export function startAccountPoolKeepAlive(intervalMs = KEEP_ALIVE_INTERVAL_MS) {
+    const disabled = process.env.ELIZA_ACCOUNT_POOL_KEEPALIVE?.trim().toLowerCase();
+    if (disabled === "0" ||
+        disabled === "false" ||
+        disabled === "no" ||
+        disabled === "off") {
+        return;
+    }
+    if (keepAliveTimer)
+        return;
+    const run = () => {
+        if (keepAliveRunning)
+            return;
+        keepAliveRunning = true;
+        void sweepAccountPoolKeepAlive()
+            .catch((err) => {
+            logger.debug(`[AccountPool] keep-alive sweep failed: ${String(err)}`);
+        })
+            .finally(() => {
+            keepAliveRunning = false;
+        });
+    };
+    keepAliveTimer = setInterval(run, Math.max(60_000, intervalMs));
+    keepAliveTimer.unref?.();
+    run();
+}
+export function stopAccountPoolKeepAliveForTests() {
+    if (keepAliveTimer) {
+        clearInterval(keepAliveTimer);
+        keepAliveTimer = null;
+    }
+    keepAliveRunning = false;
+}
+/**
+ * Install the `globalThis`-keyed bridge that plugin-anthropic's
+ * credential-store reads. Idempotent — repeated installs replace the
+ * previous bridge.
+ */
+function installAnthropicBridge(pool) {
+    if (typeof globalThis === "undefined")
+        return;
+    const bridge = {
+        selectAnthropicSubscription: async (opts) => {
+            const account = await pool.select({
+                providerId: "anthropic-subscription",
+                sessionKey: opts?.sessionKey,
+                exclude: opts?.exclude,
+                ...selectionForProvider("anthropic-subscription"),
+            });
+            if (!account)
+                return null;
+            // expiresAt is sourced from the underlying credential blob via
+            // `loadCredentials`; we cache it on the cached account record's
+            // lastUsedAt is independent. The plugin only uses expiresAt as a
+            // hint for cache TTL, so an Infinity fallback is acceptable.
+            return { id: account.id, expiresAt: Number.POSITIVE_INFINITY };
+        },
+        getAccessToken: (providerId, accountId) => getAccountAccessToken(providerId, accountId),
+        markInvalid: (accountId, detail) => pool.markInvalid(accountId, detail, {
+            providerId: "anthropic-subscription",
+        }),
+        markRateLimited: (accountId, untilMs, detail) => pool.markRateLimited(accountId, untilMs, detail, {
+            providerId: "anthropic-subscription",
+        }),
+    };
+    globalThis[ANTHROPIC_POOL_BRIDGE_SYMBOL] =
+        bridge;
+}
+function installSubscriptionSelectorBridge(pool) {
+    if (typeof globalThis === "undefined")
+        return;
+    const bridge = {
+        pickAccountId: async (providerId) => {
+            const account = await pool.select({
+                providerId,
+                ...selectionForProvider(providerId),
+            });
+            return account?.id ?? null;
+        },
+    };
+    globalThis[SUBSCRIPTION_SELECTOR_BRIDGE_SYMBOL] =
+        bridge;
+}
+/**
+ * Resets the cached singleton. Test-only.
+ */
+export function __resetDefaultAccountPoolForTests() {
+    stopAccountPoolKeepAliveForTests();
+    cachedDefaultPool = null;
+}