@juspay/neurolink 9.62.0 → 9.63.0

package/dist/cli/commands/auth.d.ts

@@ -73,6 +73,25 @@ export declare function handleCleanup(argv: AuthCommandArgs): Promise<void>;
  * Re-enables a previously disabled account so it can be used by the proxy pool again.
  */
 export declare function handleEnable(argv: AuthCommandArgs): Promise<void>;
+/**
+ * Handle the set-primary subcommand
+ * `neurolink auth set-primary <email> [--config <path>]`
+ *
+ * Writes routing.primary-account to the proxy config YAML so the proxy
+ * tries this account first under fill-first/round-robin home semantics.
+ * Does not touch the token store.
+ */
+export declare function handleSetPrimary(argv: AuthCommandArgs): Promise<void>;
+/**
+ * Handle the get-primary subcommand
+ * `neurolink auth get-primary [--config <path>]`
+ */
+export declare function handleGetPrimary(argv: AuthCommandArgs): Promise<void>;
+/**
+ * Handle the clear-primary subcommand
+ * `neurolink auth clear-primary [--config <path>]`
+ */
+export declare function handleClearPrimary(argv: AuthCommandArgs): Promise<void>;
 /**
  * Legacy main auth command handler
  * @deprecated Use subcommand handlers instead

package/dist/cli/commands/auth.js

@@ -739,6 +739,272 @@ export async function handleEnable(argv) {
     }
 }
 // =============================================================================
+// PRIMARY ACCOUNT (proxy routing.primaryAccount in YAML)
+// =============================================================================
+const DEFAULT_PROXY_CONFIG_PATH = path.join(NEUROLINK_CONFIG_DIR, "proxy-config.yaml");
+/** Lazy-load js-yaml. Returns undefined if unavailable; callers that need YAML
+ *  output (rather than JSON fallback) should error with install guidance. */
+async function tryLoadJsYaml() {
+    try {
+        return (await import(/* @vite-ignore */ "js-yaml"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function isYamlPath(p) {
+    const lower = p.toLowerCase();
+    return lower.endsWith(".yaml") || lower.endsWith(".yml");
+}
+/** Read and parse a proxy config file. Returns an empty object when the file
+ *  doesn't exist (caller can mutate and write). Detects YAML vs JSON by
+ *  extension; falls back to JSON parsing if js-yaml is unavailable for a YAML
+ *  file (errors loudly if neither parser can read it). */
+async function readProxyConfigFile(filePath) {
+    const yamlExpected = isYamlPath(filePath);
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, "utf-8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            return {
+                data: {},
+                format: yamlExpected ? "yaml" : "json",
+                hadComments: false,
+            };
+        }
+        throw err;
+    }
+    const hadComments = /^\s*#/m.test(raw);
+    if (yamlExpected) {
+        const yaml = await tryLoadJsYaml();
+        if (yaml) {
+            const parsed = yaml.default?.load?.(raw) ?? yaml.load(raw);
+            return {
+                data: parsed && typeof parsed === "object"
+                    ? parsed
+                    : {},
+                format: "yaml",
+                hadComments,
+            };
+        }
+        // YAML expected but js-yaml absent — try JSON
+        try {
+            return { data: JSON.parse(raw), format: "json", hadComments };
+        }
+        catch {
+            throw new Error(`Cannot edit ${filePath}: js-yaml is not installed and the file is ` +
+                `not valid JSON. Install js-yaml (pnpm add -D js-yaml) or convert ` +
+                `the file to JSON.`);
+        }
+    }
+    return { data: JSON.parse(raw), format: "json", hadComments };
+}
+/** Serialize and write a proxy config file. */
+async function writeProxyConfigFile(filePath, doc) {
+    let serialized;
+    if (doc.format === "yaml") {
+        const yaml = await tryLoadJsYaml();
+        if (!yaml) {
+            throw new Error(`Cannot write ${filePath} as YAML: js-yaml is not installed. ` +
+                `Install it (pnpm add -D js-yaml) or use a .json config path.`);
+        }
+        const dump = yaml.default?.dump ?? yaml.dump;
+        if (!dump) {
+            throw new Error(`Cannot write ${filePath} as YAML: js-yaml module does not expose ` +
+                `a dump function (unexpected version).`);
+        }
+        serialized = dump(doc.data, {
+            lineWidth: 100,
+            noRefs: true,
+        });
+    }
+    else {
+        serialized = `${JSON.stringify(doc.data, null, 2)}\n`;
+    }
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, serialized, "utf-8");
+}
+function getRoutingObject(data) {
+    const routing = data.routing;
+    if (routing && typeof routing === "object" && !Array.isArray(routing)) {
+        return routing;
+    }
+    const fresh = {};
+    data.routing = fresh;
+    return fresh;
+}
+function readPrimaryFromRouting(routing) {
+    if (!routing) {
+        return undefined;
+    }
+    const kebab = routing["primary-account"];
+    if (typeof kebab === "string" && kebab.trim() !== "") {
+        return kebab.trim();
+    }
+    const camel = routing.primaryAccount;
+    if (typeof camel === "string" && camel.trim() !== "") {
+        return camel.trim();
+    }
+    return undefined;
+}
+/** Best-effort detection of a running proxy. Mirrors `proxy status` semantics
+ *  without importing the proxy module. */
+function detectRunningProxyPid() {
+    try {
+        const stateFile = path.join(NEUROLINK_CONFIG_DIR, "proxy-state.json");
+        if (!fs.existsSync(stateFile)) {
+            return undefined;
+        }
+        const parsed = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
+        if (!parsed.pid || typeof parsed.pid !== "number") {
+            return undefined;
+        }
+        process.kill(parsed.pid, 0);
+        return parsed.pid;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Handle the set-primary subcommand
+ * `neurolink auth set-primary <email> [--config <path>]`
+ *
+ * Writes routing.primary-account to the proxy config YAML so the proxy
+ * tries this account first under fill-first/round-robin home semantics.
+ * Does not touch the token store.
+ */
+export async function handleSetPrimary(argv) {
+    const email = argv.email ?? (argv._ && argv._[2] ? String(argv._[2]) : undefined);
+    if (!email || email.trim() === "") {
+        logger.error(chalk.red("Missing required argument: <email>"));
+        logger.always(chalk.blue("\nUsage: neurolink auth set-primary <email> [--config <path>]\n" +
+            "Run 'neurolink auth list' to see authenticated accounts.\n"));
+        process.exit(1);
+    }
+    const trimmed = email.trim();
+    const filePath = argv.config ?? DEFAULT_PROXY_CONFIG_PATH;
+    try {
+        const doc = await readProxyConfigFile(filePath);
+        if (doc.hadComments) {
+            logger.always(chalk.yellow(`⚠ Note: existing YAML comments in ${filePath} will not be preserved.`));
+        }
+        const routing = getRoutingObject(doc.data);
+        delete routing.primaryAccount;
+        routing["primary-account"] = trimmed;
+        await writeProxyConfigFile(filePath, doc);
+        logger.always(chalk.green(`✓ Set primary account → ${trimmed}`));
+        logger.always(chalk.green(`✓ Saved to ${filePath}`));
+        // Token-store presence check (non-fatal)
+        const compoundKey = `anthropic:${trimmed}`;
+        const known = await defaultTokenStore.listByPrefix("anthropic:");
+        if (!known.includes(compoundKey)) {
+            logger.always("");
+            logger.always(chalk.yellow("⚠ This account is not currently authenticated. Run\n" +
+                "  `neurolink auth login --add` to add it. The proxy will fall\n" +
+                "  back to the first enabled account until then."));
+        }
+        // Restart hint
+        const pid = detectRunningProxyPid();
+        if (pid) {
+            logger.always("");
+            logger.always(chalk.yellow(`⚠ A proxy is currently running (PID ${pid}). Restart it to pick\n` +
+                "  up the change: `neurolink proxy stop && neurolink proxy start`."));
+        }
+    }
+    catch (err) {
+        logger.error(chalk.red("Failed to set primary account:"));
+        logger.error(chalk.red(err instanceof Error ? err.message : "Unknown error"));
+        process.exit(1);
+    }
+}
+/**
+ * Handle the get-primary subcommand
+ * `neurolink auth get-primary [--config <path>]`
+ */
+export async function handleGetPrimary(argv) {
+    const filePath = argv.config ?? DEFAULT_PROXY_CONFIG_PATH;
+    try {
+        if (!fs.existsSync(filePath)) {
+            logger.always(chalk.blue(`No proxy config file found at ${filePath}.`));
+            logger.always("Falling back to insertion-order index 0 (no primary configured).");
+            return;
+        }
+        const doc = await readProxyConfigFile(filePath);
+        const routing = typeof doc.data.routing === "object" && doc.data.routing
+            ? doc.data.routing
+            : undefined;
+        const primary = readPrimaryFromRouting(routing);
+        if (!primary) {
+            logger.always(chalk.blue(`No primary account configured. Falling back to insertion-order ` +
+                `index 0.`));
+            logger.always(`Source: ${filePath} (no \`routing.primaryAccount\` field)`);
+            return;
+        }
+        const compoundKey = `anthropic:${primary}`;
+        const known = await defaultTokenStore.listByPrefix("anthropic:");
+        const present = known.includes(compoundKey);
+        logger.always(chalk.bold(`Configured primary: ${primary}`));
+        logger.always(`Status: ${present
+            ? chalk.green(`authenticated (${compoundKey} present in token store)`)
+            : chalk.yellow(`not authenticated (token store has no ${compoundKey})`)}`);
+        logger.always(`Source: ${filePath}`);
+    }
+    catch (err) {
+        logger.error(chalk.red("Failed to read primary account:"));
+        logger.error(chalk.red(err instanceof Error ? err.message : "Unknown error"));
+        process.exit(1);
+    }
+}
+/**
+ * Handle the clear-primary subcommand
+ * `neurolink auth clear-primary [--config <path>]`
+ */
+export async function handleClearPrimary(argv) {
+    const filePath = argv.config ?? DEFAULT_PROXY_CONFIG_PATH;
+    try {
+        if (!fs.existsSync(filePath)) {
+            logger.always(chalk.blue(`No proxy config file found at ${filePath}.`));
+            logger.always("Nothing to clear.");
+            return;
+        }
+        const doc = await readProxyConfigFile(filePath);
+        const routing = typeof doc.data.routing === "object" && doc.data.routing
+            ? doc.data.routing
+            : undefined;
+        const before = readPrimaryFromRouting(routing);
+        if (!before || !routing) {
+            logger.always(chalk.blue("No primary account was configured."));
+            return;
+        }
+        if (doc.hadComments) {
+            logger.always(chalk.yellow(`⚠ Note: existing YAML comments in ${filePath} will not be preserved.`));
+        }
+        delete routing.primaryAccount;
+        delete routing["primary-account"];
+        await writeProxyConfigFile(filePath, doc);
+        logger.always(chalk.green(`✓ Cleared primary account (was: ${before})`));
+        logger.always(chalk.green(`✓ Saved to ${filePath}`));
+        const pid = detectRunningProxyPid();
+        if (pid) {
+            logger.always("");
+            logger.always(chalk.yellow(`⚠ A proxy is currently running (PID ${pid}). Restart it to pick\n` +
+                "  up the change: `neurolink proxy stop && neurolink proxy start`."));
+        }
+    }
+    catch (err) {
+        logger.error(chalk.red("Failed to clear primary account:"));
+        logger.error(chalk.red(err instanceof Error ? err.message : "Unknown error"));
+        process.exit(1);
+    }
+}
+// =============================================================================
 // LEGACY HANDLER (for backward compatibility)
 // =============================================================================
 /**

package/dist/cli/commands/proxy.js

@@ -66,6 +66,50 @@ function getProcessStatus(pid) {
         return "not_running";
     }
 }
+/** Resolve the primary-account info shown in /status. Reads the operator's
+ *  configured email from proxy config and cross-checks it against the token
+ *  store; falls back to the first enabled anthropic account when not set or
+ *  when the configured account isn't currently usable. */
+async function resolveStatusPrimaryAccount(proxyConfig) {
+    const configured = proxyConfig?.routing?.primaryAccount?.trim() || null;
+    let enabledAnthropicKeys = [];
+    try {
+        const { tokenStore } = await import("../../lib/auth/tokenStore.js");
+        const all = await tokenStore.listByPrefix("anthropic:");
+        const filtered = [];
+        for (const key of all) {
+            const disabled = await tokenStore.isDisabled(key);
+            if (!disabled) {
+                filtered.push(key);
+            }
+        }
+        enabledAnthropicKeys = filtered;
+    }
+    catch (err) {
+        logger.debug(`[proxy] /status: failed to enumerate anthropic accounts: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (configured) {
+        const configuredKey = `anthropic:${configured}`;
+        if (enabledAnthropicKeys.includes(configuredKey)) {
+            return {
+                configured,
+                key: configuredKey,
+                label: configured,
+                source: "configured",
+            };
+        }
+    }
+    const fallbackKey = enabledAnthropicKeys[0] ?? null;
+    const fallbackLabel = fallbackKey
+        ? (fallbackKey.split(":")[1] ?? null)
+        : null;
+    return {
+        configured,
+        key: fallbackKey,
+        label: fallbackLabel,
+        source: "fallback",
+    };
+}
 /**
  * Check if the launchd service is loaded and actively managing the proxy.
  * Returns true if launchctl reports the service as running.
@@ -605,14 +649,42 @@ async function loadProxyStartConfiguration(argv, spinner) {
             passthroughModels: proxyConfig.routing.passthroughModels,
         });
     }
+    const primaryAccountKey = await resolveBootPrimaryAccountKey(proxyConfig?.routing?.primaryAccount);
     return {
         configPath,
         proxyConfig,
         strategy,
         modelRouter,
         passthrough: argv.passthrough ?? false,
+        primaryAccountKey,
     };
 }
+/** Resolve the operator's configured primary email to a stable token-store
+ *  key (anthropic:<email>). Cross-checks the token store and emits a one-time
+ *  startup warning if the configured account isn't authenticated — but still
+ *  returns the key so it activates automatically once the user runs
+ *  `auth login --add`. */
+async function resolveBootPrimaryAccountKey(primaryEmail) {
+    const trimmed = primaryEmail?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const key = `anthropic:${trimmed}`;
+    try {
+        const { tokenStore } = await import("../../lib/auth/tokenStore.js");
+        const known = await tokenStore.listByPrefix("anthropic:");
+        if (!known.includes(key)) {
+            logger.warn(`[proxy] WARN: configured routing.primaryAccount=${trimmed} not ` +
+                `found in token store; falling back to first enabled account. ` +
+                `Run \`neurolink auth login --add\` to authenticate it, or ` +
+                `\`neurolink auth clear-primary\` to remove the setting.`);
+        }
+    }
+    catch (err) {
+        logger.debug(`[proxy] could not validate primary account against token store: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return key;
+}
 async function createProxyStartApp(params) {
     const { createClaudeProxyRoutes } = await import("../../lib/server/routes/claudeProxyRoutes.js");
     const { Hono } = await import("hono");
@@ -632,7 +704,7 @@ async function createProxyStartApp(params) {
             },
         }, 502);
     });
-    const routeGroup = createClaudeProxyRoutes(params.modelRouter, "", params.strategy, params.passthrough);
+    const routeGroup = createClaudeProxyRoutes(params.modelRouter, "", params.strategy, params.passthrough, params.primaryAccountKey);
     for (const route of routeGroup.routes) {
         const method = route.method.toLowerCase();
         app[method](route.path, async (c) => {
@@ -761,6 +833,7 @@ async function createProxyStartApp(params) {
             passthrough: params.passthrough,
             version: PROXY_VERSION,
         });
+        const primaryAccount = await resolveStatusPrimaryAccount(params.proxyConfig);
         return c.json({
             status: "running",
             ready: health.ready,
@@ -789,6 +862,7 @@ async function createProxyStartApp(params) {
                     rateLimits: account.rateLimitCount,
                     cooling: false, // No persistent cooldown — always active
                 })),
+                primaryAccount,
             },
             config: params.proxyConfig
                 ? { hasRouting: !!params.proxyConfig.routing }
@@ -1057,7 +1131,7 @@ async function startProxyCommandHandler(argv) {
         }
         const loadedEnvFile = await loadProxyStartEnv(argv, spinner);
         const { neurolink, cleanupLogs } = await createProxyNeurolinkRuntime(devPaths?.logsDir);
-        const { proxyConfig, strategy, modelRouter, passthrough } = await loadProxyStartConfiguration(argv, spinner);
+        const { proxyConfig, strategy, modelRouter, passthrough, primaryAccountKey, } = await loadProxyStartConfiguration(argv, spinner);
         if (spinner) {
             spinner.text = "Configuring server...";
         }
@@ -1071,6 +1145,7 @@ async function startProxyCommandHandler(argv) {
             port,
             host,
             proxyConfig,
+            primaryAccountKey,
         });
         await initializeProxyOpenTelemetry();
         if (spinner) {

package/dist/cli/factories/authCommandFactory.d.ts

@@ -56,6 +56,14 @@ export declare class AuthCommandFactory {
      * Build options for enable subcommand
      */
     private static buildEnableOptions;
+    /**
+     * Build options for set-primary subcommand
+     */
+    private static buildSetPrimaryOptions;
+    /**
+     * Build options for get-primary / clear-primary subcommands.
+     */
+    private static buildPrimaryConfigOption;
     /**
      * Auth provider choices for multi-provider commands
      */

package/dist/cli/factories/authCommandFactory.js

@@ -63,6 +63,18 @@ export class AuthCommandFactory {
                     .command("enable <account>", "Re-enable a previously disabled account", (yargs) => this.buildEnableOptions(yargs), async (argv) => {
                     const { handleEnable } = await import("../commands/auth.js");
                     await handleEnable(argv);
+                })
+                    .command("set-primary <email>", "Set the proxy's primary (home) Anthropic account", (yargs) => this.buildSetPrimaryOptions(yargs), async (argv) => {
+                    const { handleSetPrimary } = await import("../commands/auth.js");
+                    await handleSetPrimary(argv);
+                })
+                    .command("get-primary", "Show the proxy's currently configured primary account", (yargs) => this.buildPrimaryConfigOption(yargs), async (argv) => {
+                    const { handleGetPrimary } = await import("../commands/auth.js");
+                    await handleGetPrimary(argv);
+                })
+                    .command("clear-primary", "Clear the proxy's configured primary account", (yargs) => this.buildPrimaryConfigOption(yargs), async (argv) => {
+                    const { handleClearPrimary } = await import("../commands/auth.js");
+                    await handleClearPrimary(argv);
                 })
                     .command("providers", "List available authentication providers", (yargs) => yargs.option("format", {
                     type: "string",
@@ -110,6 +122,9 @@ export class AuthCommandFactory {
                     .example("$0 auth cleanup", "Remove expired and disabled accounts")
                     .example("$0 auth cleanup --force", "Remove stale accounts without confirmation")
                     .example("$0 auth enable anthropic:1-VjRIq", "Re-enable a disabled account")
+                    .example("$0 auth set-primary alice@example.com", "Make alice@example.com the proxy's primary (home) account")
+                    .example("$0 auth get-primary", "Show the proxy's currently configured primary account")
+                    .example("$0 auth clear-primary", "Remove the configured primary account (use insertion-order fallback)")
                     .help();
             },
             handler: () => {
@@ -257,6 +272,32 @@ export class AuthCommandFactory {
         })
             .example("$0 auth enable anthropic:1-VjRIq", "Re-enable a disabled account");
     }
+    /**
+     * Build options for set-primary subcommand
+     */
+    static buildSetPrimaryOptions(yargs) {
+        return yargs
+            .positional("email", {
+            type: "string",
+            description: "Email/label of the Anthropic account to make primary (home)",
+            demandOption: true,
+        })
+            .option("config", {
+            type: "string",
+            description: "Path to the proxy config YAML (default: ~/.neurolink/proxy-config.yaml)",
+        })
+            .example("$0 auth set-primary alice@example.com", "Write routing.primary-account to the default proxy config")
+            .example("$0 auth set-primary alice@example.com --config ./proxy.yaml", "Use a non-default config path");
+    }
+    /**
+     * Build options for get-primary / clear-primary subcommands.
+     */
+    static buildPrimaryConfigOption(yargs) {
+        return yargs.option("config", {
+            type: "string",
+            description: "Path to the proxy config YAML (default: ~/.neurolink/proxy-config.yaml)",
+        });
+    }
     /**
      * Auth provider choices for multi-provider commands
      */

package/dist/lib/proxy/proxyConfig.js

@@ -336,6 +336,20 @@ function parseRoutingConfig(raw) {
     if (Array.isArray(rawPassthrough)) {
         result.passthroughModels = rawPassthrough.map(String);
     }
+    // Primary account (accept kebab-case or camelCase). Email or label of the
+    // Anthropic account that should be tried first ("home"). Resolved to a
+    // stable key (anthropic:<email>) at proxy boot; absence preserves the
+    // pre-existing insertion-order behavior.
+    const rawPrimary = (raw["primary-account"] ?? raw.primaryAccount);
+    if (rawPrimary !== undefined) {
+        if (typeof rawPrimary === "string" && rawPrimary.trim() !== "") {
+            result.primaryAccount = rawPrimary.trim();
+        }
+        else {
+            logger.warn(`[proxy-config] Ignoring routing.primaryAccount: expected non-empty ` +
+                `string, got ${typeof rawPrimary}`);
+        }
+    }
     return result;
 }
 // ---------------------------------------------------------------------------

package/dist/lib/server/routes/claudeProxyRoutes.d.ts

@@ -10,7 +10,18 @@
  * Without a router, models are passed through to the Anthropic provider.
  */
 import type { ModelRouter } from "../../proxy/modelRouter.js";
-import type { ParsedClaudeError, ParsedClaudeRequest, RouteGroup } from "../../types/index.js";
+import type { ParsedClaudeError, ParsedClaudeRequest, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState } from "../../types/index.js";
+/** Resolve the configured primary's stable key to its current index in the
+ *  request's enabledAccounts list. Returns 0 (insertion-order fallback) when
+ *  no key is configured or the key cannot be matched (account disabled/
+ *  removed). The resolution is per-request because enabledAccounts membership
+ *  can shift between requests. */
+declare function resolveHomeIndex(enabledAccounts: ProxyPassthroughAccount[]): number;
+/** If the configured home primary is no longer cooling, reset
+ *  primaryAccountIndex back to its index so traffic returns to the preferred
+ *  account once its rate limit window expires. Called at the start of each
+ *  request. Home is resolved fresh per call via resolveHomeIndex. */
+declare function maybeResetPrimaryToHome(enabledAccounts: ProxyPassthroughAccount[]): void;
 /**
  * Create Claude-compatible proxy routes.
  *
@@ -21,7 +32,7 @@ import type { ParsedClaudeError, ParsedClaudeRequest, RouteGroup } from "../../t
  * @param basePath    - Base path prefix (default: "" since Claude API uses /v1/...).
  * @returns RouteGroup with Claude-compatible endpoints.
  */
-export declare function createClaudeProxyRoutes(modelRouter?: ModelRouter, basePath?: string, accountStrategy?: "round-robin" | "fill-first", passthroughMode?: boolean): RouteGroup;
+export declare function createClaudeProxyRoutes(modelRouter?: ModelRouter, basePath?: string, accountStrategy?: "round-robin" | "fill-first", passthroughMode?: boolean, primaryAccountKey?: string): RouteGroup;
 export declare function getTransientSameAccountRetryDelayMs(retryNumber: number): number;
 /**
  * Parse a Claude error payload when available.
@@ -42,3 +53,14 @@ export declare function buildProxyFallbackOptions(parsed: ParsedClaudeRequest, o
  * carry transient HTML responses (e.g. 520 pages) inside `error.message`.
  */
 export declare function isTransientHttpFailure(status: number, errBody: string): boolean;
+export declare const __testHooks: {
+    resolveHomeIndex: typeof resolveHomeIndex;
+    maybeResetPrimaryToHome: typeof maybeResetPrimaryToHome;
+    setConfiguredPrimaryAccountKey: (key: string | undefined) => void;
+    getConfiguredPrimaryAccountKey: () => string | undefined;
+    setPrimaryAccountIndex: (index: number) => void;
+    getPrimaryAccountIndex: () => number;
+    setAccountRuntimeState: (key: string, state: Partial<RuntimeAccountState>) => void;
+    resetAllRuntimeState: () => void;
+};
+export {};