opencode-multi-account-core 0.2.7 → 0.2.9

package/dist/index.d.ts

@@ -1,20 +1,551 @@
-export * from "./account-manager";
-export * from "./account-store";
-export * from "./claims";
-export * from "./config";
-export * from "./constants";
-export * from "./executor";
-export * from "./proactive-refresh";
-export * from "./rate-limit";
-export * from "./storage";
-export * from "./types";
-export * from "./utils";
-export * from "./auth-migration";
-export * from "./ui/ansi";
-export * from "./ui/confirm";
-export * from "./ui/select";
-export * from "./adapters";
-export * from "./pool-types";
-export * from "./pool-config-store";
-export * from "./pool-manager";
-export * from "./cascade-state";
+import * as v from 'valibot';
+
+declare const OAuthCredentialsSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"oauth", undefined>;
+    readonly refresh: v.StringSchema<undefined>;
+    readonly access: v.StringSchema<undefined>;
+    readonly expires: v.NumberSchema<undefined>;
+}, undefined>;
+declare const UsageLimitEntrySchema: v.ObjectSchema<{
+    readonly utilization: v.NumberSchema<undefined>;
+    readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+declare const UsageLimitsSchema: v.ObjectSchema<{
+    readonly five_hour: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+        readonly utilization: v.NumberSchema<undefined>;
+        readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, null>;
+    readonly seven_day: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+        readonly utilization: v.NumberSchema<undefined>;
+        readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, null>;
+    readonly seven_day_sonnet: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+        readonly utilization: v.NumberSchema<undefined>;
+        readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, null>;
+}, undefined>;
+declare const CredentialRefreshPatchSchema: v.ObjectSchema<{
+    readonly accessToken: v.StringSchema<undefined>;
+    readonly expiresAt: v.NumberSchema<undefined>;
+    readonly refreshToken: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly uuid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly accountId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly email: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+declare const StoredAccountSchema: v.ObjectSchema<{
+    readonly uuid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly accountId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly email: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly planTier: v.OptionalSchema<v.StringSchema<undefined>, "">;
+    readonly refreshToken: v.StringSchema<undefined>;
+    readonly accessToken: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly expiresAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly addedAt: v.NumberSchema<undefined>;
+    readonly lastUsed: v.NumberSchema<undefined>;
+    readonly enabled: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
+    readonly rateLimitResetAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly cachedUsage: v.OptionalSchema<v.ObjectSchema<{
+        readonly five_hour: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+            readonly utilization: v.NumberSchema<undefined>;
+            readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, null>;
+        readonly seven_day: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+            readonly utilization: v.NumberSchema<undefined>;
+            readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, null>;
+        readonly seven_day_sonnet: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+            readonly utilization: v.NumberSchema<undefined>;
+            readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, null>;
+    }, undefined>, undefined>;
+    readonly cachedUsageAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly consecutiveAuthFailures: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+    readonly isAuthDisabled: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+    readonly authDisabledReason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+declare const AccountStorageSchema: v.ObjectSchema<{
+    readonly version: v.LiteralSchema<1, undefined>;
+    readonly accounts: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+        readonly uuid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly accountId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly label: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly email: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly planTier: v.OptionalSchema<v.StringSchema<undefined>, "">;
+        readonly refreshToken: v.StringSchema<undefined>;
+        readonly accessToken: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly expiresAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly addedAt: v.NumberSchema<undefined>;
+        readonly lastUsed: v.NumberSchema<undefined>;
+        readonly enabled: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
+        readonly rateLimitResetAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly cachedUsage: v.OptionalSchema<v.ObjectSchema<{
+            readonly five_hour: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+                readonly utilization: v.NumberSchema<undefined>;
+                readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>, null>;
+            readonly seven_day: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+                readonly utilization: v.NumberSchema<undefined>;
+                readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>, null>;
+            readonly seven_day_sonnet: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
+                readonly utilization: v.NumberSchema<undefined>;
+                readonly resets_at: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>, null>;
+        }, undefined>, undefined>;
+        readonly cachedUsageAt: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+        readonly consecutiveAuthFailures: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+        readonly isAuthDisabled: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+        readonly authDisabledReason: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>, readonly []>;
+    readonly activeAccountUuid: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+declare const AccountSelectionStrategySchema: v.PicklistSchema<["sticky", "round-robin", "hybrid"], undefined>;
+declare const PluginConfigSchema: v.ObjectSchema<{
+    readonly account_selection_strategy: v.OptionalSchema<v.PicklistSchema<["sticky", "round-robin", "hybrid"], undefined>, "sticky">;
+    readonly cross_process_claims: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
+    readonly soft_quota_threshold_percent: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 100, undefined>]>, 100>;
+    readonly rate_limit_min_backoff_ms: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>, 30000>;
+    readonly default_retry_after_ms: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>, 60000>;
+    readonly max_consecutive_auth_failures: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>]>, 3>;
+    readonly token_failure_backoff_ms: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>]>, 30000>;
+    readonly proactive_refresh: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
+    readonly proactive_refresh_buffer_seconds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 60, undefined>]>, 1800>;
+    readonly proactive_refresh_interval_seconds: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 30, undefined>]>, 300>;
+    readonly quiet_mode: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+    readonly debug: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
+}, undefined>;
+type OAuthCredentials = v.InferOutput<typeof OAuthCredentialsSchema>;
+type UsageLimitEntry = v.InferOutput<typeof UsageLimitEntrySchema>;
+type UsageLimits = v.InferOutput<typeof UsageLimitsSchema>;
+type CredentialRefreshPatch = v.InferOutput<typeof CredentialRefreshPatchSchema>;
+type StoredAccount = v.InferOutput<typeof StoredAccountSchema>;
+type AccountStorage = v.InferOutput<typeof AccountStorageSchema>;
+type AccountSelectionStrategy = v.InferOutput<typeof AccountSelectionStrategySchema>;
+type PluginConfig = v.InferOutput<typeof PluginConfigSchema>;
+type TokenRefreshResult = {
+    ok: true;
+    patch: CredentialRefreshPatch;
+} | {
+    ok: false;
+    permanent: boolean;
+    status?: number;
+};
+declare class TokenRefreshError extends Error {
+    readonly status?: number;
+    readonly permanent: boolean;
+    constructor(permanent: boolean, status?: number);
+}
+declare function isTokenRefreshError(error: unknown): error is TokenRefreshError;
+interface ManagedAccount {
+    index: number;
+    uuid?: string;
+    accountId?: string;
+    label?: string;
+    email?: string;
+    planTier?: string;
+    refreshToken: string;
+    accessToken?: string;
+    expiresAt?: number;
+    addedAt: number;
+    lastUsed: number;
+    enabled: boolean;
+    rateLimitResetAt?: number;
+    last429At?: number;
+    cachedUsage?: UsageLimits;
+    cachedUsageAt?: number;
+    consecutiveAuthFailures: number;
+    isAuthDisabled: boolean;
+    authDisabledReason?: string;
+}
+interface PluginClient {
+    auth: {
+        set: (params: {
+            path: {
+                id: string;
+            };
+            body: {
+                type: string;
+                refresh: string;
+                access: string;
+                expires: number;
+            };
+        }) => Promise<void>;
+    };
+    tui: {
+        showToast: (params: {
+            body: {
+                title?: string;
+                message: string;
+                variant: "info" | "warning" | "success" | "error";
+            };
+        }) => Promise<void>;
+    };
+    app: {
+        log: (params: {
+            body: {
+                service: string;
+                level: "debug" | "info" | "warn" | "error";
+                message: string;
+                extra?: Record<string, unknown>;
+            };
+        }) => Promise<void>;
+    };
+}
+
+interface DiskCredentials {
+    refreshToken: string;
+    accessToken?: string;
+    expiresAt?: number;
+    accountId?: string;
+}
+declare class AccountStore {
+    load(): Promise<AccountStorage>;
+    readCredentials(uuid: string): Promise<DiskCredentials | null>;
+    mutateAccount(uuid: string, fn: (account: StoredAccount) => void): Promise<StoredAccount | null>;
+    mutateStorage(fn: (storage: AccountStorage) => void): Promise<void>;
+    addAccount(account: StoredAccount): Promise<void>;
+    removeAccount(uuid: string): Promise<boolean>;
+    setActiveUuid(uuid: string | undefined): Promise<void>;
+    clear(): Promise<void>;
+}
+
+interface ProfileData {
+    email?: string;
+    planTier: string;
+}
+interface RuntimeFactoryLike {
+    invalidate(uuid: string): void;
+}
+interface AccountManagerDependencies {
+    providerAuthId: string;
+    isTokenExpired: (account: Pick<ManagedAccount, "accessToken" | "expiresAt">) => boolean;
+    refreshToken: (currentRefreshToken: string, accountId: string, client: PluginClient) => Promise<TokenRefreshResult>;
+}
+interface AccountManagerInstance {
+    initialize(currentAuth: OAuthCredentials, client?: PluginClient): Promise<void>;
+    refresh(): Promise<void>;
+    getAccountCount(): number;
+    getAccounts(): ManagedAccount[];
+    getActiveAccount(): ManagedAccount | null;
+    setClient(client: PluginClient): void;
+    setRuntimeFactory(factory: RuntimeFactoryLike): void;
+    hasAnyUsableAccount(): boolean;
+    isRateLimited(account: ManagedAccount): boolean;
+    clearExpiredRateLimits(): void;
+    getMinWaitTime(): number;
+    selectAccount(): Promise<ManagedAccount | null>;
+    markRateLimited(uuid: string, backoffMs?: number): Promise<void>;
+    markRevoked(uuid: string): Promise<void>;
+    markSuccess(uuid: string): Promise<void>;
+    markAuthFailure(uuid: string, result: TokenRefreshResult): Promise<void>;
+    applyUsageCache(uuid: string, usage: UsageLimits): Promise<void>;
+    applyProfileCache(uuid: string, profile: ProfileData): Promise<void>;
+    ensureValidToken(uuid: string, client: PluginClient): Promise<TokenRefreshResult>;
+    validateNonActiveTokens(client: PluginClient): Promise<void>;
+    removeAccount(index: number): Promise<boolean>;
+    clearAllAccounts(): Promise<void>;
+    addAccount(auth: OAuthCredentials, email?: string): Promise<void>;
+    toggleEnabled(uuid: string): Promise<void>;
+    replaceAccountCredentials(uuid: string, auth: OAuthCredentials): Promise<void>;
+    retryAuth(uuid: string, client: PluginClient): Promise<TokenRefreshResult>;
+}
+interface AccountManagerClass {
+    new (store: AccountStore): AccountManagerInstance;
+    create(store: AccountStore, currentAuth: OAuthCredentials, client?: PluginClient): Promise<AccountManagerInstance>;
+}
+declare function createAccountManagerForProvider(dependencies: AccountManagerDependencies): AccountManagerClass;
+
+type ClaimsMap = Record<string, {
+    pid: number;
+    at: number;
+}>;
+declare function readClaims(): Promise<ClaimsMap>;
+declare function writeClaim(accountId: string): Promise<void>;
+declare function releaseClaim(accountId: string): Promise<void>;
+declare function isClaimedByOther(claims: ClaimsMap, accountId: string | undefined): boolean;
+
+type CoreConfig = Pick<PluginConfig, "quiet_mode" | "debug">;
+declare function initCoreConfig(filename: string): void;
+declare function loadConfig(): Promise<PluginConfig>;
+declare function getConfig(): PluginConfig;
+declare function resetConfigCache(): void;
+declare function setConfigGetter(getter: () => PluginConfig): void;
+declare function updateConfigField<K extends keyof PluginConfig>(key: K, value: PluginConfig[K]): Promise<void>;
+
+declare let ACCOUNTS_FILENAME: string;
+declare function setAccountsFilename(filename: string): void;
+
+interface ExecutorAccountManager {
+    getAccountCount(): number;
+    refresh(): Promise<void>;
+    selectAccount(): Promise<ManagedAccount | null>;
+    markSuccess(uuid: string): Promise<void>;
+    markAuthFailure(uuid: string, result: TokenRefreshResult): Promise<void>;
+    markRevoked(uuid: string): Promise<void>;
+    hasAnyUsableAccount(): boolean;
+    getMinWaitTime(): number;
+}
+interface ExecutorRuntimeFactory {
+    getRuntime(uuid: string): Promise<{
+        fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    }>;
+    invalidate(uuid: string): void;
+}
+interface ExecutorDependencies {
+    handleRateLimitResponse: (manager: unknown, client: PluginClient, account: ManagedAccount, response: Response) => Promise<void>;
+    formatWaitTime: (ms: number) => string;
+    sleep: (ms: number) => Promise<void>;
+    showToast: (client: PluginClient, message: string, variant: "info" | "warning" | "success" | "error") => Promise<void>;
+    getAccountLabel: (account: ManagedAccount) => string;
+}
+declare function createExecutorForProvider(providerName: string, dependencies: ExecutorDependencies): {
+    executeWithAccountRotation: (manager: ExecutorAccountManager, runtimeFactory: ExecutorRuntimeFactory, client: PluginClient, input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+};
+
+interface ProactiveRefreshDependencies {
+    providerAuthId: string;
+    getConfig: () => PluginConfig;
+    refreshToken: (currentRefreshToken: string, accountId: string, client: PluginClient) => Promise<TokenRefreshResult>;
+    isTokenExpired: (account: Pick<StoredAccount, "accessToken" | "expiresAt">) => boolean;
+    debugLog: (client: PluginClient, message: string, extra?: Record<string, unknown>) => void;
+}
+interface ProactiveRefreshQueueInstance {
+    start(): void;
+    stop(): Promise<void>;
+}
+interface ProactiveRefreshQueueClass {
+    new (client: PluginClient, store: AccountStore, onInvalidate?: (uuid: string) => void): ProactiveRefreshQueueInstance;
+}
+declare function createProactiveRefreshQueueForProvider(dependencies: ProactiveRefreshDependencies): ProactiveRefreshQueueClass;
+
+interface RateLimitDependencies {
+    fetchUsage: (accessToken: string, accountId?: string) => Promise<{
+        ok: true;
+        data: UsageLimits;
+    } | {
+        ok: false;
+        reason: string;
+    }>;
+    getConfig: () => Pick<PluginConfig, "default_retry_after_ms">;
+    formatWaitTime: (ms: number) => string;
+    getAccountLabel: (account: ManagedAccount) => string;
+    showToast: (client: PluginClient, message: string, variant: "info" | "warning" | "success" | "error") => Promise<void>;
+}
+interface RateLimitAccountManager {
+    markRateLimited(uuid: string, backoffMs?: number): Promise<void>;
+    applyUsageCache(uuid: string, usage: UsageLimits): Promise<void>;
+    getAccountCount(): number;
+}
+declare function createRateLimitHandlers(dependencies: RateLimitDependencies): {
+    retryAfterMsFromResponse: (response: Response) => number;
+    getResetMsFromUsage: (account: ManagedAccount) => number | null;
+    fetchUsageLimits: (accessToken: string, accountId?: string) => Promise<UsageLimits | null>;
+    handleRateLimitResponse: (manager: RateLimitAccountManager, client: PluginClient, account: ManagedAccount, response: Response) => Promise<void>;
+};
+
+declare function readStorageFromDisk(targetPath: string, backupOnCorrupt: boolean): Promise<AccountStorage | null>;
+declare function deduplicateAccounts(accounts: StoredAccount[]): StoredAccount[];
+declare function loadAccounts(): Promise<AccountStorage | null>;
+
+declare function getConfigDir(): string;
+declare function getErrorCode(error: unknown): string | undefined;
+declare function formatWaitTime(ms: number): string;
+declare function getAccountLabel(account: ManagedAccount): string;
+declare function sleep(ms: number): Promise<void>;
+declare function showToast(client: PluginClient, message: string, variant: "info" | "warning" | "success" | "error"): Promise<void>;
+declare function debugLog(client: PluginClient, message: string, extra?: Record<string, unknown>): void;
+declare function createMinimalClient(): PluginClient;
+declare function getClearedOAuthBody(): {
+    type: "oauth";
+    refresh: string;
+    access: string;
+    expires: number;
+};
+
+/**
+ * Imports an existing OAuth credential from OpenCode's auth.json
+ * into the multi-account storage on first use.
+ *
+ * Only runs when storage has zero accounts. Does not modify auth.json.
+ *
+ * @param providerKey - The key in auth.json ("anthropic" or "openai")
+ * @param store - The AccountStore instance to import into
+ * @returns true if a credential was imported, false otherwise
+ */
+declare function migrateFromAuthJson(providerKey: string, store: AccountStore): Promise<boolean>;
+
+declare const ANSI: {
+    readonly hide: "\u001B[?25l";
+    readonly show: "\u001B[?25h";
+    readonly up: (n?: number) => string;
+    readonly down: (n?: number) => string;
+    readonly clearLine: "\u001B[2K";
+    readonly cyan: "\u001B[36m";
+    readonly green: "\u001B[32m";
+    readonly red: "\u001B[31m";
+    readonly yellow: "\u001B[33m";
+    readonly dim: "\u001B[2m";
+    readonly bold: "\u001B[1m";
+    readonly reset: "\u001B[0m";
+};
+type KeyAction = "up" | "down" | "enter" | "escape" | "escape-start" | null;
+declare function parseKey(data: Buffer): KeyAction;
+declare function isTTY(): boolean;
+
+declare function confirm(message: string, defaultYes?: boolean): Promise<boolean>;
+
+interface MenuItem<T = string> {
+    label: string;
+    value: T;
+    hint?: string;
+    disabled?: boolean;
+    separator?: boolean;
+    color?: "red" | "green" | "yellow" | "cyan";
+}
+interface SelectOptions {
+    message: string;
+    subtitle?: string;
+}
+declare function select<T>(items: MenuItem<T>[], options: SelectOptions): Promise<T | null>;
+
+interface OAuthAdapterTransformConfig {
+    rewriteOpenCodeBranding: boolean;
+    addToolPrefix: boolean;
+    stripToolPrefixInResponse: boolean;
+    enableMessagesBetaQuery: boolean;
+}
+type OAuthAdapterPlanLabels = Record<string, string>;
+interface OAuthAdapter {
+    id: string;
+    authProviderId: string;
+    modelDisplayName: string;
+    statusToolName: string;
+    authMethodLabel: string;
+    serviceLogName: string;
+    oauthClientId: string;
+    tokenEndpoint: string;
+    usageEndpoint: string;
+    profileEndpoint: string;
+    oauthBetaHeader: string;
+    requestBetaHeader: string;
+    cliUserAgent: string;
+    cliVersion: string;
+    billingSalt: string;
+    toolPrefix: string;
+    accountStorageFilename: string;
+    transform: OAuthAdapterTransformConfig;
+    planLabels: OAuthAdapterPlanLabels;
+    supported: boolean;
+    unsupportedReason?: string;
+}
+
+declare const anthropicOAuthAdapter: OAuthAdapter;
+
+declare const openAIOAuthAdapter: OAuthAdapter;
+
+declare const PoolConfigSchema: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly baseProvider: v.StringSchema<undefined>;
+    readonly members: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+    readonly enabled: v.BooleanSchema<undefined>;
+}, undefined>;
+declare const ChainEntryConfigSchema: v.ObjectSchema<{
+    readonly pool: v.StringSchema<undefined>;
+    readonly model: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    readonly enabled: v.BooleanSchema<undefined>;
+}, undefined>;
+declare const ChainConfigSchema: v.ObjectSchema<{
+    readonly name: v.StringSchema<undefined>;
+    readonly entries: v.ArraySchema<v.ObjectSchema<{
+        readonly pool: v.StringSchema<undefined>;
+        readonly model: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+        readonly enabled: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+    readonly enabled: v.BooleanSchema<undefined>;
+}, undefined>;
+declare const PoolChainConfigSchema: v.ObjectSchema<{
+    readonly pools: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly baseProvider: v.StringSchema<undefined>;
+        readonly members: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        readonly enabled: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>, readonly []>;
+    readonly chains: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.StringSchema<undefined>;
+        readonly entries: v.ArraySchema<v.ObjectSchema<{
+            readonly pool: v.StringSchema<undefined>;
+            readonly model: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly enabled: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>;
+        readonly enabled: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>, readonly []>;
+}, undefined>;
+type PoolConfig = v.InferOutput<typeof PoolConfigSchema>;
+type ChainEntryConfig = v.InferOutput<typeof ChainEntryConfigSchema>;
+type ChainConfig = v.InferOutput<typeof ChainConfigSchema>;
+type PoolChainConfig = v.InferOutput<typeof PoolChainConfigSchema>;
+interface CascadeState {
+    prompt: string;
+    attemptedAccounts: Set<string>;
+    visitedChainIndexes: Set<number>;
+}
+interface FailoverCandidate {
+    poolName: string;
+    accountUuid: string;
+    source: "pool" | "chain";
+    chainIndex?: number;
+}
+interface FailoverSkip {
+    type: "pool_exhausted" | "chain_disabled" | "account_attempted" | "account_unavailable";
+    poolName: string;
+    reason: string;
+    detail?: string;
+}
+
+declare function loadPoolChainConfig(): Promise<PoolChainConfig>;
+declare function savePoolChainConfig(config: PoolChainConfig): Promise<void>;
+
+interface PoolAwareAccountManager {
+    getAccounts(): ManagedAccount[];
+    isRateLimited(account: ManagedAccount): boolean;
+    selectAccount(): Promise<ManagedAccount | null>;
+}
+interface BuildFailoverPlanOptions {
+    attemptedAccounts?: Set<string>;
+    visitedChainIndexes?: Set<number>;
+}
+interface FailoverPlan {
+    candidates: FailoverCandidate[];
+    skips: FailoverSkip[];
+}
+declare class PoolManager {
+    private poolsByName;
+    private exhaustedUntilByAccount;
+    private exhaustedCooldownMs;
+    constructor(options?: {
+        exhaustedCooldownMs?: number;
+    });
+    loadPools(configs: PoolConfig[]): void;
+    getPoolForAccount(accountUuid: string): PoolConfig | null;
+    getAvailableMembers(pool: PoolConfig, accountManager: PoolAwareAccountManager): string[];
+    markExhausted(accountUuid: string): void;
+    getNextMember(pool: PoolConfig, currentUuid: string | undefined, accountManager: PoolAwareAccountManager): Promise<string | null>;
+    buildFailoverPlan(currentAccount: Pick<ManagedAccount, "uuid" | "accountId"> | null, config: PoolChainConfig, accountManager: PoolAwareAccountManager, options?: BuildFailoverPlanOptions): Promise<FailoverPlan>;
+    private isExhausted;
+    private clearExpiredExhausted;
+    private selectPreferredMember;
+}
+
+declare class CascadeStateManager {
+    suppressNextStartTurn: boolean;
+    private cascadeState;
+    startTurn(prompt: string, currentAccountUuid?: string): CascadeState;
+    ensureCascadeState(prompt: string, currentAccountUuid?: string): CascadeState;
+    markAttempted(accountUuid: string): void;
+    markVisitedChainIndex(index: number): void;
+    clearCascadeState(): void;
+    getSnapshot(): CascadeState | null;
+}
+
+export { ACCOUNTS_FILENAME, ANSI, type AccountManagerClass, type AccountManagerDependencies, type AccountManagerInstance, type AccountSelectionStrategy, AccountSelectionStrategySchema, type AccountStorage, AccountStorageSchema, AccountStore, type BuildFailoverPlanOptions, type CascadeState, CascadeStateManager, type ChainConfig, ChainConfigSchema, type ChainEntryConfig, ChainEntryConfigSchema, type ClaimsMap, type CoreConfig, type CredentialRefreshPatch, CredentialRefreshPatchSchema, type DiskCredentials, type ExecutorAccountManager, type ExecutorDependencies, type ExecutorRuntimeFactory, type FailoverCandidate, type FailoverPlan, type FailoverSkip, type KeyAction, type ManagedAccount, type MenuItem, type OAuthAdapter, type OAuthAdapterPlanLabels, type OAuthAdapterTransformConfig, type OAuthCredentials, OAuthCredentialsSchema, type PluginClient, type PluginConfig, PluginConfigSchema, type PoolChainConfig, PoolChainConfigSchema, type PoolConfig, PoolConfigSchema, PoolManager, type ProactiveRefreshDependencies, type ProactiveRefreshQueueClass, type ProactiveRefreshQueueInstance, type ProfileData, type RateLimitAccountManager, type RateLimitDependencies, type RuntimeFactoryLike, type SelectOptions, type StoredAccount, StoredAccountSchema, TokenRefreshError, type TokenRefreshResult, type UsageLimitEntry, UsageLimitEntrySchema, type UsageLimits, UsageLimitsSchema, anthropicOAuthAdapter, confirm, createAccountManagerForProvider, createExecutorForProvider, createMinimalClient, createProactiveRefreshQueueForProvider, createRateLimitHandlers, debugLog, deduplicateAccounts, formatWaitTime, getAccountLabel, getClearedOAuthBody, getConfig, getConfigDir, getErrorCode, initCoreConfig, isClaimedByOther, isTTY, isTokenRefreshError, loadAccounts, loadConfig, loadPoolChainConfig, migrateFromAuthJson, openAIOAuthAdapter, parseKey, readClaims, readStorageFromDisk, releaseClaim, resetConfigCache, savePoolChainConfig, select, setAccountsFilename, setConfigGetter, showToast, sleep, updateConfigField, writeClaim };

package/dist/index.js

@@ -1,20 +1,20 @@
 // src/account-manager.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID } from "crypto";
 
 // src/claims.ts
-import { promises as fs2 } from "node:fs";
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { promises as fs2 } from "fs";
+import { randomBytes as randomBytes2 } from "crypto";
+import { dirname as dirname2, join as join3 } from "path";
 
 // src/utils.ts
-import { join as join2 } from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/config.ts
-import { promises as fs } from "node:fs";
-import { randomBytes } from "node:crypto";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
+import { promises as fs } from "fs";
+import { randomBytes } from "crypto";
+import { dirname, join } from "path";
+import { homedir } from "os";
 import * as v2 from "valibot";
 
 // src/types.ts
@@ -380,6 +380,7 @@ function createAccountManagerForProvider(dependencies) {
     constructor(store) {
       this.store = store;
     }
+    store;
     cached = [];
     activeAccountUuid;
     client = null;
@@ -928,15 +929,15 @@ function createAccountManagerForProvider(dependencies) {
 }
 
 // src/account-store.ts
-import { promises as fs4 } from "node:fs";
-import { randomBytes as randomBytes3 } from "node:crypto";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { promises as fs4 } from "fs";
+import { randomBytes as randomBytes3 } from "crypto";
+import { dirname as dirname4, join as join5 } from "path";
 import lockfile from "proper-lockfile";
 import * as v4 from "valibot";
 
 // src/storage.ts
-import { promises as fs3 } from "node:fs";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { promises as fs3 } from "fs";
+import { dirname as dirname3, join as join4 } from "path";
 import * as v3 from "valibot";
 
 // src/constants.ts
@@ -1380,6 +1381,9 @@ function createProactiveRefreshQueueForProvider(dependencies) {
       this.store = store;
       this.onInvalidate = onInvalidate;
     }
+    client;
+    store;
+    onInvalidate;
     timeoutHandle = null;
     runToken = 0;
     inFlight = null;
@@ -1578,8 +1582,8 @@ function createRateLimitHandlers(dependencies) {
 }
 
 // src/auth-migration.ts
-import { promises as fs5 } from "node:fs";
-import { join as join6 } from "node:path";
+import { promises as fs5 } from "fs";
+import { join as join6 } from "path";
 var AUTH_JSON_FILENAME = "auth.json";
 function isValidOAuthCredential(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -1925,9 +1929,9 @@ var PoolChainConfigSchema = v5.object({
 });
 
 // src/pool-config-store.ts
-import { promises as fs6 } from "node:fs";
-import { randomBytes as randomBytes4 } from "node:crypto";
-import { dirname as dirname5, join as join7 } from "node:path";
+import { promises as fs6 } from "fs";
+import { randomBytes as randomBytes4 } from "crypto";
+import { dirname as dirname5, join as join7 } from "path";
 import lockfile2 from "proper-lockfile";
 import * as v6 from "valibot";
 var POOL_CONFIG_FILENAME = "multiauth-pools.json";
@@ -2348,3 +2352,4 @@ export {
   updateConfigField,
   writeClaim
 };
+//# sourceMappingURL=index.js.map