@cortexkit/anthropic-auth-core 1.4.1 → 1.6.0

package/dist/accounts.d.ts

@@ -31,6 +31,14 @@ export type AccountQuotaWindow = {
     checkedAt: number;
 };
 export type RoutingMode = 'main-first' | 'fallback-first';
+export type KillswitchThresholds = Partial<Record<QuotaWindowName | '5h' | '1w', number>>;
+export type KillswitchConfig = {
+    enabled?: boolean;
+    /** Thresholds for the main OAuth account (remaining % below which the account is killed). */
+    main?: KillswitchThresholds;
+    /** Per-account overrides keyed by account ID. Accounts without an entry use the `main` thresholds. */
+    accounts?: Record<string, KillswitchThresholds>;
+};
 export type AccountStorage = {
     version: 1;
     main?: {
@@ -53,8 +61,15 @@ export type AccountStorage = {
     quota?: {
         enabled?: boolean;
         checkIntervalMinutes?: number;
+        refreshEveryNRequests?: number;
         minimumRemaining?: Partial<Record<QuotaWindowName | '5h' | '1w', number>>;
         failClosedOnUnknownQuota?: boolean;
+        /** Opt-in OpenCode TUI toast after quota refresh. Default: false. */
+        showToasts?: boolean;
+        mainQuota?: OAuthQuotaSnapshot;
+        mainQuotaCheckedAt?: number;
+        mainQuotaToken?: string;
+        mainLastQuotaApiError?: AccountOperationError;
     };
     claudeCache?: {
         enabled?: boolean;
@@ -78,6 +93,7 @@ export type AccountStorage = {
         fallbackToDirect?: boolean;
         transport?: 'http' | 'websocket';
     };
+    killswitch?: KillswitchConfig;
     accounts: OAuthAccount[];
 };
 export type OAuthQuotaSnapshot = Partial<Record<QuotaWindowName, AccountQuotaWindow>>;
@@ -85,6 +101,8 @@ export type AccountManagerOptions = {
     now?: () => number;
     fetchImpl?: typeof fetch;
     configPath?: string;
+    quotaManager?: import('./quota-manager.ts').QuotaManager;
+    onFallbackStorageChanged?: () => void;
 };
 export type AccountRefreshError = {
     accountId: string;
@@ -124,8 +142,41 @@ export declare function buildRefreshOperationError(input: {
 }): AccountOperationError;
 export declare function refreshBackoffActive(error: AccountOperationError | undefined, refreshToken: string | undefined, now: number): boolean;
 export declare function formatRefreshBackoffMessage(error: AccountOperationError, now: number): string;
+export declare function buildQuotaOperationError(input: {
+    error: unknown;
+    now: number;
+    previous?: AccountOperationError;
+}): AccountOperationError;
+export declare function quotaBackoffActive(error: AccountOperationError | undefined, now: number): boolean;
+export declare function formatQuotaBackoffMessage(error: AccountOperationError, now: number): string;
 export declare function getQuotaCheckIntervalMs(storage: AccountStorage | null): number;
+export declare function getPersistedMainQuota(storage: AccountStorage | null): {
+    quota: OAuthQuotaSnapshot;
+    checkedAt: number;
+    tokenFingerprint?: string;
+} | null;
+/**
+ * How often (in requests) to force a quota refresh, independent of the timer.
+ * Returns 0 when disabled (default).
+ */
+export declare function getQuotaRefreshEveryNRequests(storage: AccountStorage | null): number;
 export declare function quotaSnapshotPassesPolicy(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null): boolean;
+export declare const DEFAULT_KILLSWITCH_THRESHOLDS: Record<QuotaWindowName, number>;
+export declare function isKillswitchEnabled(storage: AccountStorage | null): boolean;
+/**
+ * Returns true if the account's quota is above its killswitch threshold.
+ * When killswitch is disabled, always returns true.
+ */
+export declare function killswitchPassesPolicy(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null, accountId?: string): boolean;
+/**
+ * Find the earliest reset time across all accounts' quota windows.
+ * Returns seconds from `now` until that reset, or 300 as a fallback.
+ */
+export declare function killswitchRetryAfterSeconds(mainQuota: OAuthQuotaSnapshot | undefined, fallbackAccounts: Array<{
+    quota?: OAuthQuotaSnapshot;
+}>, now: number): number;
+export declare function getKillswitchConfig(storage: AccountStorage | null): KillswitchConfig;
+export declare function setKillswitchPersistent(config: KillswitchConfig, path?: string): Promise<AccountStorage>;
 export declare function getQuotaNextRefreshAt(quota: OAuthQuotaSnapshot | undefined, storage: AccountStorage | null, now: number): number;
 export declare function fetchOAuthQuotaSnapshot(input: {
     accessToken: string;
@@ -142,7 +193,14 @@ export declare class FallbackAccountManager {
     private readonly refreshPromises;
     private refreshTimer;
     private quotaTimer;
+    readonly quotaManager: import('./quota-manager.ts').QuotaManager | null;
+    private readonly onFallbackStorageChanged;
     constructor(options?: AccountManagerOptions);
+    /**
+     * Seed QuotaManager from persisted account.quota if no cache entry exists
+     * yet. Prevents unnecessary API calls when the on-disk snapshot is fresh.
+     */
+    private seedFallbackQuota;
     load(): Promise<AccountStorage | null>;
     save(storage: AccountStorage): Promise<void>;
     startBackgroundRefresh(): void;
@@ -150,9 +208,18 @@ export declare class FallbackAccountManager {
     getUsableFallbackAccounts(existingStorage?: AccountStorage | null): Promise<OAuthAccount[]>;
     markUsed(account: OAuthAccount): Promise<void>;
     accountPassesQuotaPolicy(account: OAuthAccount, storage: AccountStorage | null): boolean;
+    /**
+     * Return the account with its quota overlaid from the unified QuotaManager
+     * cache (token-bound) when available, so quota-policy decisions use the same
+     * source of truth as the staleness check. Falls back to the stored
+     * account.quota when no manager is wired or the cache has no entry.
+     */
+    private quotaPolicyAccount;
     refreshDueAccounts(): Promise<void>;
     refreshQuotaForDueAccounts(): Promise<void>;
-    refreshQuotaForAllAccounts(): Promise<{
+    refreshQuotaForAllAccounts(options?: {
+        force?: boolean;
+    }): Promise<{
         storage: AccountStorage | null;
         errors: AccountRefreshError[];
     }>;

package/dist/accounts.js

@@ -16,6 +16,9 @@ const DEFAULT_REFRESH_INTERVAL_MINUTES = 10;
 const MIN_REFRESH_RETRY_DELAY_MS = 5 * 60_000;
 const MAX_REFRESH_RETRY_DELAY_MS = 60 * 60_000;
 const NON_TRANSIENT_REFRESH_RETRY_DELAY_MS = 24 * 60 * 60_000;
+const MIN_QUOTA_RETRY_DELAY_MS = 60_000;
+const MAX_QUOTA_RETRY_DELAY_MS = 15 * 60_000;
+const NON_TRANSIENT_QUOTA_RETRY_DELAY_MS = 5 * 60_000;
 const DEFAULT_QUOTA_CHECK_INTERVAL_MINUTES = 5;
 const DEFAULT_MINIMUM_REMAINING = {
     five_hour: 0,
@@ -127,6 +130,7 @@ function normalizeStorage(value) {
         claudeFast: isRecord(value.claudeFast) ? value.claudeFast : undefined,
         cacheKeep: isRecord(value.cacheKeep) ? value.cacheKeep : undefined,
         relay: isRecord(value.relay) ? value.relay : undefined,
+        killswitch: isRecord(value.killswitch) ? value.killswitch : undefined,
         accounts: value.accounts
             .map(normalizeAccount)
             .filter((account) => account != null),
@@ -452,10 +456,51 @@ export function formatRefreshBackoffMessage(error, now) {
     const seconds = Math.max(1, Math.ceil(((error.nextRetryAt ?? now) - now) / 1000));
     return `Claude OAuth refresh is backed off for ${seconds}s after: ${error.message}`;
 }
+export function buildQuotaOperationError(input) {
+    const previousRetryCount = input.previous?.retryCount ?? 0;
+    const retryCount = previousRetryCount + 1;
+    const delay = isTransientQuotaError(input.error)
+        ? Math.min(MAX_QUOTA_RETRY_DELAY_MS, MIN_QUOTA_RETRY_DELAY_MS * 2 ** Math.min(retryCount - 1, 6))
+        : NON_TRANSIENT_QUOTA_RETRY_DELAY_MS;
+    return {
+        message: formatErrorMessage(input.error),
+        checkedAt: input.now,
+        nextRetryAt: input.now + delay,
+        retryCount,
+    };
+}
+export function quotaBackoffActive(error, now) {
+    if (!error?.nextRetryAt || error.nextRetryAt <= now)
+        return false;
+    return true;
+}
+export function formatQuotaBackoffMessage(error, now) {
+    const seconds = Math.max(1, Math.ceil(((error.nextRetryAt ?? now) - now) / 1000));
+    return `Quota API backed off for ${seconds}s after: ${error.message}`;
+}
 export function getQuotaCheckIntervalMs(storage) {
     const minutes = storage?.quota?.checkIntervalMinutes ?? DEFAULT_QUOTA_CHECK_INTERVAL_MINUTES;
     return Math.max(1, minutes) * 60_000;
 }
+export function getPersistedMainQuota(storage) {
+    if (!storage?.quota?.mainQuota || !storage.quota.mainQuotaCheckedAt)
+        return null;
+    return {
+        quota: storage.quota.mainQuota,
+        checkedAt: storage.quota.mainQuotaCheckedAt,
+        tokenFingerprint: storage.quota.mainQuotaToken,
+    };
+}
+/**
+ * How often (in requests) to force a quota refresh, independent of the timer.
+ * Returns 0 when disabled (default).
+ */
+export function getQuotaRefreshEveryNRequests(storage) {
+    const n = storage?.quota?.refreshEveryNRequests;
+    return typeof n === 'number' && Number.isFinite(n) && n > 0
+        ? Math.floor(n)
+        : 0;
+}
 function failClosedOnUnknownQuota(storage) {
     return (storage?.quota?.failClosedOnUnknownQuota ??
         DEFAULT_FAIL_CLOSED_ON_UNKNOWN_QUOTA);
@@ -473,6 +518,95 @@ export function quotaSnapshotPassesPolicy(quota, storage) {
     }
     return true;
 }
+// ---------------------------------------------------------------------------
+// Killswitch — hard-block requests when remaining quota drops below per-account
+// thresholds, even if the API would still accept them.
+// ---------------------------------------------------------------------------
+export const DEFAULT_KILLSWITCH_THRESHOLDS = {
+    five_hour: 5,
+    seven_day: 10,
+};
+function normalizeKillswitchThresholds(thresholds) {
+    return {
+        five_hour: thresholds?.five_hour ??
+            thresholds?.['5h'] ??
+            DEFAULT_KILLSWITCH_THRESHOLDS.five_hour,
+        seven_day: thresholds?.seven_day ??
+            thresholds?.['1w'] ??
+            DEFAULT_KILLSWITCH_THRESHOLDS.seven_day,
+    };
+}
+export function isKillswitchEnabled(storage) {
+    return storage?.killswitch?.enabled === true;
+}
+function getKillswitchThresholdsForAccount(storage, accountId) {
+    if (!storage?.killswitch)
+        return DEFAULT_KILLSWITCH_THRESHOLDS;
+    if (accountId && storage.killswitch.accounts?.[accountId]) {
+        return normalizeKillswitchThresholds(storage.killswitch.accounts[accountId]);
+    }
+    return normalizeKillswitchThresholds(storage.killswitch.main);
+}
+/**
+ * Returns true if the account's quota is above its killswitch threshold.
+ * When killswitch is disabled, always returns true.
+ */
+export function killswitchPassesPolicy(quota, storage, accountId) {
+    if (!isKillswitchEnabled(storage))
+        return true;
+    const thresholds = getKillswitchThresholdsForAccount(storage, accountId);
+    let sawUnknownWindow = false;
+    for (const key of ['five_hour', 'seven_day']) {
+        const window = quota?.[key];
+        // Defer the unknown-window decision: a quota snapshot can legally carry
+        // only one window, and a present window below its threshold must still
+        // block even if the other window is missing.
+        if (!window) {
+            sawUnknownWindow = true;
+            continue;
+        }
+        if (window.remainingPercent < thresholds[key])
+            return false;
+    }
+    if (sawUnknownWindow)
+        return !failClosedOnUnknownQuota(storage);
+    return true;
+}
+/**
+ * Find the earliest reset time across all accounts' quota windows.
+ * Returns seconds from `now` until that reset, or 300 as a fallback.
+ */
+export function killswitchRetryAfterSeconds(mainQuota, fallbackAccounts, now) {
+    const resetTimes = [];
+    const allQuotas = [mainQuota, ...fallbackAccounts.map((a) => a.quota)];
+    for (const quota of allQuotas) {
+        for (const key of ['five_hour', 'seven_day']) {
+            const resetStr = quota?.[key]?.resetsAt;
+            if (!resetStr)
+                continue;
+            const resetTime = Date.parse(resetStr);
+            if (Number.isFinite(resetTime) && resetTime > now) {
+                resetTimes.push(resetTime);
+            }
+        }
+    }
+    if (!resetTimes.length)
+        return 300;
+    return Math.max(1, Math.ceil((Math.min(...resetTimes) - now) / 1000)) + 60;
+}
+export function getKillswitchConfig(storage) {
+    return storage?.killswitch ?? { enabled: false };
+}
+export async function setKillswitchPersistent(config, path = getAccountStoragePath()) {
+    const storage = (await loadAccounts(path)) ?? {
+        version: 1,
+        main: { type: 'opencode', provider: 'anthropic' },
+        accounts: [],
+    };
+    storage.killswitch = config;
+    await saveAccounts(storage, path);
+    return storage;
+}
 export function getQuotaNextRefreshAt(quota, storage, now) {
     if (!quotaEnabled(storage))
         return now + getQuotaCheckIntervalMs(storage);
@@ -597,10 +731,11 @@ function recordRefreshError(account, error, now) {
     });
 }
 function recordQuotaRefreshError(account, error, now) {
-    account.lastQuotaRefreshError = {
-        message: formatErrorMessage(error),
-        checkedAt: now,
-    };
+    account.lastQuotaRefreshError = buildQuotaOperationError({
+        error,
+        now,
+        previous: account.lastQuotaRefreshError,
+    });
     if (error instanceof ClaudeOAuthRefreshError) {
         recordRefreshError(account, error, now);
     }
@@ -618,10 +753,35 @@ export class FallbackAccountManager {
     refreshPromises = new Map();
     refreshTimer = null;
     quotaTimer = null;
+    quotaManager;
+    onFallbackStorageChanged;
     constructor(options = {}) {
         this.now = options.now ?? Date.now;
         this.fetchImpl = options.fetchImpl ?? fetch;
         this.configPath = options.configPath ?? getAccountStoragePath();
+        this.quotaManager = options.quotaManager ?? null;
+        this.onFallbackStorageChanged = options.onFallbackStorageChanged;
+    }
+    /**
+     * Seed QuotaManager from persisted account.quota if no cache entry exists
+     * yet. Prevents unnecessary API calls when the on-disk snapshot is fresh.
+     */
+    seedFallbackQuota(account, storage) {
+        if (!this.quotaManager)
+            return;
+        if (this.quotaManager.getFallback(account.id, account.access))
+            return;
+        if (!account.quota)
+            return;
+        const checkedAt = Math.max(account.quota.five_hour?.checkedAt ?? 0, account.quota.seven_day?.checkedAt ?? 0);
+        if (checkedAt <= 0)
+            return;
+        const checkInterval = getQuotaCheckIntervalMs(storage);
+        this.quotaManager.setFallback(account.id, {
+            quota: account.quota,
+            refreshAfter: checkedAt + checkInterval,
+            checkedAt,
+        }, account.access);
     }
     async load() {
         return loadAccounts(this.configPath);
@@ -671,11 +831,23 @@ export class FallbackAccountManager {
                     next = await this.refreshAccount(next, storage);
                     changed = true;
                 }
-                if (quotaIsStale(next, storage, this.now())) {
+                this.seedFallbackQuota(next, storage);
+                const stale = this.quotaManager
+                    ? this.quotaManager.isFallbackStale(next.id, next.access)
+                    : quotaIsStale(next, storage, this.now());
+                // Skip the request-time refresh when this account's quota API is
+                // backed off (recent 429/5xx). Hitting it again would extend the
+                // backoff; evaluate policy on the cached/seeded quota instead. Mirrors
+                // the background refreshQuotaForDueAccounts() guard.
+                if (stale &&
+                    !quotaBackoffActive(next.lastQuotaRefreshError, this.now())) {
                     next = await this.refreshAccountQuota(next, storage);
                     changed = true;
                 }
-                if (this.accountPassesQuotaPolicy(next, storage))
+                // Single source of truth: evaluate quota policy from the unified
+                // QuotaManager cache (the same source as the staleness check above) so
+                // an active-route refresh that updated only the cache is not ignored.
+                if (this.accountPassesQuotaPolicy(this.quotaPolicyAccount(next), storage))
                     usable.push(next);
             }
             catch (error) {
@@ -708,6 +880,18 @@ export class FallbackAccountManager {
     accountPassesQuotaPolicy(account, storage) {
         return quotaSnapshotPassesPolicy(account.quota, storage);
     }
+    /**
+     * Return the account with its quota overlaid from the unified QuotaManager
+     * cache (token-bound) when available, so quota-policy decisions use the same
+     * source of truth as the staleness check. Falls back to the stored
+     * account.quota when no manager is wired or the cache has no entry.
+     */
+    quotaPolicyAccount(account) {
+        if (!this.quotaManager)
+            return account;
+        const cached = this.quotaManager.getFallback(account.id, account.access)?.quota;
+        return cached ? { ...account, quota: cached } : account;
+    }
     async refreshDueAccounts() {
         const storage = await this.load();
         if (!storage || !refreshEnabled(storage))
@@ -719,11 +903,11 @@ export class FallbackAccountManager {
             if (!tokenNeedsRefresh(account, storage, this.now()))
                 continue;
             if (refreshBackoffActive(account.lastRefreshError, account.refresh, this.now())) {
-                log('[refresh] fallback oauth skipped backoff', {
-                    accountId: account.id,
-                    nextRetryAt: account.lastRefreshError?.nextRetryAt,
-                    retryCount: account.lastRefreshError?.retryCount,
-                });
+                // Backoff skips are steady-state while a fallback account is waiting for
+                // its next retry. Logging every background tick from every OpenCode
+                // process creates noise without adding new diagnostic signal; the
+                // failure/backoff itself is recorded when the refresh attempt fails and
+                // shown by /claude-quota.
                 continue;
             }
             try {
@@ -767,7 +951,16 @@ export class FallbackAccountManager {
                     next = await this.refreshAccount(next, storage);
                     changed = true;
                 }
-                if (!quotaIsStale(next, storage, this.now()))
+                if (quotaBackoffActive(next.lastQuotaRefreshError, this.now())) {
+                    continue;
+                }
+                this.seedFallbackQuota(next, storage);
+                // Use QuotaManager staleness when available (shared cache);
+                // fall back to per-account on-disk staleness otherwise.
+                const stale = this.quotaManager
+                    ? this.quotaManager.isFallbackStale(next.id, next.access)
+                    : quotaIsStale(next, storage, this.now());
+                if (!stale)
                     continue;
                 await this.refreshAccountQuota(next, storage);
                 changed = true;
@@ -779,14 +972,17 @@ export class FallbackAccountManager {
                 // Quota probes are advisory; failed probes fail closed at selection time.
             }
         }
-        if (changed)
+        if (changed) {
             await this.save(storage);
+            this.onFallbackStorageChanged?.();
+        }
     }
-    async refreshQuotaForAllAccounts() {
+    async refreshQuotaForAllAccounts(options = {}) {
         const storage = await this.load();
         const errors = [];
         if (!storage || !quotaEnabled(storage))
             return { storage, errors };
+        const force = options.force ?? false;
         let changed = false;
         for (const account of storage.accounts) {
             if (account.enabled === false)
@@ -802,7 +998,10 @@ export class FallbackAccountManager {
                     next = await this.refreshAccount(next, storage);
                     changed = true;
                 }
-                if (!quotaIsStale(next, storage, this.now())) {
+                // force (manual /claude-quota) bypasses the staleness skip to fetch
+                // fresh numbers on demand. refreshAccountQuota still respects 429
+                // backoff via QuotaManager.refreshFallback.
+                if (!force && !quotaIsStale(next, storage, this.now())) {
                     if (next.lastQuotaRefreshError) {
                         next.lastQuotaRefreshError = undefined;
                         updateStoredAccount(storage, next);
@@ -948,12 +1147,18 @@ export class FallbackAccountManager {
         if (!target.access) {
             throw new Error(`Fallback account ${account.id} has no access token`);
         }
-        try {
-            target.quota = await fetchOAuthQuotaSnapshot({
-                accessToken: target.access,
+        // Unify on the shared QuotaManager when present: it adds inflight
+        // deduplication and 429 backoff gating around the same quota API. Fall back
+        // to a direct fetch only when no QuotaManager is wired (e.g. in isolation).
+        const fetchSnapshot = (accessToken) => this.quotaManager
+            ? this.quotaManager.refreshFallback(target.id, accessToken)
+            : fetchOAuthQuotaSnapshot({
+                accessToken,
                 fetchImpl: this.fetchImpl,
                 now: this.now,
             });
+        try {
+            target.quota = await fetchSnapshot(target.access);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -964,14 +1169,22 @@ export class FallbackAccountManager {
             });
             if (!target.access)
                 throw error;
-            target.quota = await fetchOAuthQuotaSnapshot({
-                accessToken: target.access,
-                fetchImpl: this.fetchImpl,
-                now: this.now,
-            });
+            // 401 does not arm QuotaManager backoff, so this retry proceeds.
+            target.quota = await fetchSnapshot(target.access);
         }
         target.lastQuotaRefreshError = undefined;
         updateStoredAccount(storage, target);
+        // Sync to shared QuotaManager so all consumers see the same cache. The
+        // refreshFallback path already cached the snapshot; re-set here so
+        // refreshAfter reflects this storage's check interval consistently.
+        if (this.quotaManager && target.quota) {
+            const now = this.now();
+            this.quotaManager.setFallback(target.id, {
+                quota: target.quota,
+                refreshAfter: now + getQuotaCheckIntervalMs(storage),
+                checkedAt: now,
+            }, target.access);
+        }
         return target;
     }
 }

package/dist/cachekeep.d.ts

@@ -73,6 +73,7 @@ export declare class CacheKeepManager {
         trackedSessions: number;
         nextPrewarmAt: number | undefined;
     };
+    trackedCount(): number;
     track(input: {
         sessionId?: string | null;
         url: string;

package/dist/cachekeep.js

@@ -205,6 +205,9 @@ export class CacheKeepManager {
             : undefined;
         return { trackedSessions: targets.length, nextPrewarmAt };
     }
+    trackedCount() {
+        return this.targets.size;
+    }
     track(input) {
         if (!input.sessionId)
             return { tracked: false, reason: 'missing session id' };

package/dist/index.d.ts

@@ -7,8 +7,10 @@ export * from './claude-code.ts';
 export * from './constants.ts';
 export * from './dump.ts';
 export * from './fast.ts';
+export * from './killswitch.ts';
 export * from './logger.ts';
 export * from './pkce.ts';
+export * from './quota-manager.ts';
 export * from './quotas.ts';
 export * from './relay.ts';
 export * from './routing.ts';

package/dist/index.js

@@ -7,8 +7,10 @@ export * from "./claude-code.js";
 export * from "./constants.js";
 export * from "./dump.js";
 export * from "./fast.js";
+export * from "./killswitch.js";
 export * from "./logger.js";
 export * from "./pkce.js";
+export * from "./quota-manager.js";
 export * from "./quotas.js";
 export * from "./relay.js";
 export * from "./routing.js";

package/dist/killswitch.d.ts

@@ -0,0 +1,27 @@
+import type { KillswitchConfig } from './accounts.ts';
+export declare const KILLSWITCH_COMMAND_NAME = "claude-killswitch";
+export type KillswitchCommandAction = {
+    type: 'status';
+} | {
+    type: 'on';
+} | {
+    type: 'off';
+} | {
+    type: 'set';
+    entries: Array<{
+        account: string;
+        fh: number;
+        sd: number;
+    }>;
+} | {
+    type: 'usage';
+};
+export declare function parseKillswitchCommandAction(argumentsText: string): KillswitchCommandAction;
+export declare function executeKillswitchCommand(input: {
+    argumentsText: string;
+    config: KillswitchConfig;
+    accountIds: string[];
+}): {
+    text: string;
+    updatedConfig?: KillswitchConfig;
+};