muonroi-cli 1.8.4 → 1.9.0

package/dist/src/utils/loop-profiler.js

@@ -0,0 +1,202 @@
+/**
+ * src/utils/loop-profiler.ts
+ *
+ * Rolling V8 CPU profiler — the instrument that names the culprit when the
+ * event loop blocks (see `event-loop-monitor.ts` for the incident this exists
+ * for).
+ *
+ * Why a CPU profile and not a stack dump: while the JS thread is blocked, NO
+ * JS can run — you cannot ask the process what it is doing, because asking is
+ * itself JS. V8's sampling profiler runs on its OWN thread and samples the JS
+ * thread regardless of whether that thread is stuck, so the profile taken
+ * across a block contains the blocking frames. Verified under Bun 1.3.13: a
+ * deliberate 400ms synchronous block yielded 54 samples.
+ *
+ * Rolling segments keep the retained profile small without losing the block:
+ * rotation is loop-driven, so it CANNOT run during a block — whichever segment
+ * is in flight when the loop freezes stays in flight for the whole freeze, and
+ * is still open when the monitor detects the block right after. So `capture()`
+ * always writes a profile containing the entire block, however long it ran.
+ *
+ * Off by default (`MUONROI_LOOP_PROFILE=1` to arm) — continuous profiling has a
+ * real, if small, cost and this is a diagnostic, not a feature.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { logger } from "./logger.js";
+/** Frames V8 synthesises; naming one as the culprit tells nobody anything. */
+const SYNTHETIC_FRAMES = new Set(["(root)", "(program)", "(idle)", "(garbage collector)", "(anonymous)", ""]);
+/**
+ * Reduce a CPU profile to the single hottest stack, leaf-first.
+ *
+ * Why not just the top frame: samples land on the LEAF, which for a blocking
+ * loop is whatever primitive it calls (`Date.now`, a regex step, a syscall) —
+ * true but useless. Verified on a synthetic 3s block: the leaf was `now` with
+ * 188 samples while the actual culprit `theGuiltyFunction` had 4. The CALLERS
+ * are the answer, so we walk up from the hottest leaf and return the chain.
+ *
+ * This is what makes the profile readable from debug.log alone, without
+ * requiring anyone to open Chrome DevTools.
+ *
+ * Pure — unit-testable with a hand-built profile.
+ *
+ * @param maxFrames how many frames of the chain to return, leaf-first
+ * @returns frames like `theGuiltyFunction (file.ts:12)`, or [] if unusable
+ */
+export function summarizeHotStack(profile, maxFrames = 8) {
+    const samples = profile?.samples;
+    const nodes = profile?.nodes;
+    if (!Array.isArray(samples) || !Array.isArray(nodes) || samples.length === 0)
+        return [];
+    const byId = new Map();
+    const parentOf = new Map();
+    for (const n of nodes) {
+        byId.set(n.id, n);
+        for (const c of n.children ?? [])
+            parentOf.set(c, n.id);
+    }
+    const selfCounts = new Map();
+    for (const s of samples)
+        selfCounts.set(s, (selfCounts.get(s) ?? 0) + 1);
+    let hottest = -1;
+    let best = -1;
+    for (const [id, count] of selfCounts) {
+        if (count > best) {
+            best = count;
+            hottest = id;
+        }
+    }
+    if (hottest < 0)
+        return [];
+    const frames = [];
+    const seen = new Set();
+    let cur = hottest;
+    while (cur !== undefined && !seen.has(cur) && frames.length < maxFrames) {
+        seen.add(cur);
+        const node = byId.get(cur);
+        if (!node)
+            break;
+        const name = node.callFrame?.functionName ?? "";
+        if (!SYNTHETIC_FRAMES.has(name)) {
+            const url = node.callFrame?.url ?? "";
+            const short = url ? `${url.split(/[\\/]/).pop()}:${(node.callFrame?.lineNumber ?? 0) + 1}` : "native";
+            frames.push(`${name} (${short})`);
+        }
+        cur = parentOf.get(cur);
+    }
+    return frames;
+}
+/**
+ * Create and arm a rolling CPU profiler.
+ *
+ * Returns null when the inspector is unavailable (some runtimes/builds) — the
+ * caller keeps the block detector, just without stacks. Never throws.
+ */
+export async function createLoopProfiler(opts = {}) {
+    const samplingIntervalUs = opts.samplingIntervalUs ?? 10_000;
+    const dir = opts.dir ?? path.join(os.homedir(), ".muonroi-cli", "profiles");
+    let session;
+    try {
+        const inspector = await import("node:inspector");
+        session = new inspector.Session();
+        session.connect();
+    }
+    catch (err) {
+        logger.warn("cli", `[loop-profiler] inspector unavailable — block reports will have no stacks: ${err?.message}`, { error: err });
+        return null;
+    }
+    /** Promise-free post: the profiler is driven from timer callbacks. */
+    const post = (method, params) => {
+        try {
+            session.post(method, params, (err) => {
+                if (err) {
+                    logger.warn("cli", `[loop-profiler] ${method} failed: ${err.message}`, { error: err });
+                }
+            });
+        }
+        catch (err) {
+            logger.warn("cli", `[loop-profiler] ${method} threw: ${err?.message}`, { error: err });
+        }
+    };
+    let disposed = false;
+    const start = () => {
+        post("Profiler.setSamplingInterval", { interval: samplingIntervalUs });
+        post("Profiler.start");
+    };
+    try {
+        post("Profiler.enable");
+        start();
+    }
+    catch (err) {
+        logger.warn("cli", `[loop-profiler] failed to arm: ${err?.message}`, { error: err });
+        return null;
+    }
+    /**
+     * Stop the current segment and resolve with its profile (null on failure).
+     * Restarts a fresh segment unless disposing.
+     */
+    const stopSegment = (restart) => new Promise((resolve) => {
+        try {
+            session.post("Profiler.stop", (err, res) => {
+                if (err) {
+                    logger.warn("cli", `[loop-profiler] Profiler.stop failed: ${err.message}`, { error: err });
+                    resolve(null);
+                }
+                else {
+                    resolve(res?.profile ?? null);
+                }
+                if (restart && !disposed)
+                    start();
+            });
+        }
+        catch (err) {
+            logger.warn("cli", `[loop-profiler] Profiler.stop threw: ${err?.message}`, { error: err });
+            resolve(null);
+        }
+    });
+    return {
+        rotate() {
+            if (disposed)
+                return;
+            // Drop the segment on the floor — it contained no block worth keeping.
+            void stopSegment(true);
+        },
+        async capture(reason) {
+            if (disposed)
+                return null;
+            const profile = await stopSegment(true);
+            if (!profile)
+                return null;
+            try {
+                fs.mkdirSync(dir, { recursive: true });
+                const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+                const safeReason = reason.replace(/[^a-z0-9_-]/gi, "_").slice(0, 40);
+                const file = path.join(dir, `loop-block-${stamp}-${safeReason}.cpuprofile`);
+                fs.writeFileSync(file, JSON.stringify(profile), "utf8");
+                return { file, hotStack: summarizeHotStack(profile) };
+            }
+            catch (err) {
+                logger.error("cli", `[loop-profiler] failed to write profile: ${err?.message}`, {
+                    error: err,
+                    dir,
+                });
+                return null;
+            }
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            void stopSegment(false);
+            try {
+                post("Profiler.disable");
+                session.disconnect();
+            }
+            catch (err) {
+                logger.warn("cli", `[loop-profiler] disconnect failed: ${err?.message}`, { error: err });
+            }
+        },
+    };
+}
+//# sourceMappingURL=loop-profiler.js.map

package/dist/src/utils/permission-mode.js

@@ -3,7 +3,8 @@
  *
  * safe      - Every tool call prompts the user for approval.
  * auto-edit - File operation tools (read/write/edit/grep/list) auto-approve;
- *             shell execution and computer tools still require confirmation.
+ *             shell execution auto-approves for non-dangerous commands;
+ *             computer tools still require confirmation.
  * yolo      - All tool calls auto-approve without any prompting.
  */
 import { appendDecisionLog } from "../usage/decision-log.js";
@@ -217,8 +218,9 @@ export function toolNeedsApproval(toolName, mode, context) {
         return false;
     }
     if (mode === "auto-edit") {
-        if (toolName === "bash" && dangerous(context?.command))
-            return true;
+        // bash auto-approves when non-dangerous; only dangerous bash needs approval
+        if (toolName === "bash")
+            return dangerous(context?.command);
         return !AUTO_EDIT_ALLOWED.has(toolName);
     }
     // "safe" — always confirm; dangerous patterns explicitly require (no bypass)

package/dist/src/utils/redactor.js

@@ -34,7 +34,7 @@ const STATIC_PATTERNS = [
     },
     // Environment variable assignments for common API keys
     {
-        pattern: /(ANTHROPIC_API_KEY|OPENAI_API_KEY|GOOGLE_API_KEY|DEEPSEEK_API_KEY)\s*=\s*\S+/g,
+        pattern: /(ANTHROPIC_API_KEY|OPENAI_API_KEY|DEEPSEEK_API_KEY)\s*=\s*\S+/g,
         replacement: "$1=***REDACTED***",
     },
     // Authorization Bearer header

package/dist/src/utils/settings.d.ts

@@ -4,6 +4,17 @@ import type { ProviderId } from "../providers/types.js";
 import type { AgentMode, ReasoningEffort } from "../types/index.js";
 import { type ShellSettings } from "./shell.js";
 export type ModelRole = "leader" | "implement" | "verify" | "research";
+export type PeakHourMode = "downgrade" | "switch";
+export interface PeakHourPolicy {
+    /** Default true — peak-hour routing active. */
+    enabled?: boolean;
+    /**
+     * downgrade: same-provider only (per catalog provider_policies.peak_hour).
+     * switch: try catalog switch_fallback_providers first.
+     * Default: switch.
+     */
+    mode?: PeakHourMode;
+}
 export declare function getCatalogDefaultModel(): string;
 export type TelegramStreamingMode = "off" | "partial";
 export type CouncilExperienceMode = "off" | "advisory" | "enforcing";
@@ -67,6 +78,12 @@ export interface ProviderKeyConfig {
 }
 export interface UserSettings {
     apiKey?: string;
+    /**
+     * One-time guard: true once legacy keychain/settings API keys have been
+     * migrated into the env-store (`~/.muonroi-cli/.env`). See
+     * `migrateLegacyKeysToEnv` in src/providers/keychain.ts.
+     */
+    keysMigratedToEnv?: boolean;
     defaultModel?: string;
     /**
      * Preferred provider. When set, the splash/config UI hides the model
@@ -101,6 +118,9 @@ export interface UserSettings {
     autoCompactAfterTurn?: boolean;
     /** Minimum % of context window to trigger post-turn auto-compact (default 0.25 = 25%, range 0.05-0.50). */
     autoCompactThresholdPct?: number;
+    /** Minimum new tokens accumulated since the last compaction before another
+     *  post-turn compaction may fire. Prevents cache-reset thrash. Default 20000. */
+    autoCompactMinNewTokens?: number;
     roleModels?: Partial<Record<ModelRole, string>>;
     councilRounds?: number;
     autoCouncil?: boolean;
@@ -118,6 +138,26 @@ export interface UserSettings {
      * preserving legacy behavior).
      */
     autoCouncilMinRoles?: number;
+    /**
+     * Whether an auto-triggered council/debate runs the pre-debate clarification
+     * interview (model-designed askcards) before debating, instead of jumping
+     * straight into the debate on the bare prompt. Default true — a broad request
+     * like "dùng debate mode thảo luận lên plan" is exactly the kind of ambiguous
+     * scope the interview is meant to chốt first (prevents the debate drifting /
+     * "lan man"). The clarifier is ROI-gated and returns 0 cards on already-detailed
+     * topics, so enabling it is safe. Set false (or env MUONROI_AUTOCOUNCIL_CLARIFY=0)
+     * to restore the old skip-clarification behaviour.
+     */
+    autoCouncilClarify?: boolean;
+    /**
+     * When true (default), auto-council is skipped if the current session model is
+     * a reasoning model (catalog `reasoning: true`). Reasoning models already
+     * perform an internal self-debate via extended thinking, so running an
+     * explicit multi-role council on the same prompt is usually low-ROI and
+     * expensive. Set false (or env MUONROI_AUTOCOUNCIL_SKIP_REASONING=0) to force
+     * council even for reasoning models.
+     */
+    autoCouncilSkipReasoning?: boolean;
     councilPreferMultiProvider?: boolean;
     /** EE involvement level in council debates. Default: advisory. CQ-19. */
     councilExperienceMode?: CouncilExperienceMode;
@@ -132,6 +172,20 @@ export interface UserSettings {
      * decide structure and quality, not throughput.
      */
     councilCostAware?: boolean;
+    /**
+     * Language the council debate is conducted in (Feature B). The chosen language
+     * IS the debate language — no separate translate-back pass, so no extra LLM
+     * rounds. Values:
+     *   - "auto" (default) — debate + conclusion follow the language of the user's
+     *     prompt/brief (they type Vietnamese → the debate runs in Vietnamese).
+     *   - "english" — force the historical English-only debate (citation tags,
+     *     JSON, cross-turn citations stay maximally machine-stable).
+     *   - any other free-text locale label (e.g. "vietnamese", "日本語") — pin the
+     *     debate to that language regardless of the prompt's language.
+     * Citation tags, JSON keys, the `type` field, code identifiers, and STACK LOCK
+     * technology names always stay verbatim English regardless of this setting.
+     */
+    councilLanguage?: string;
     /** Set true after the user has been prompted (or skipped) the web-research onboarding. */
     webResearchPrompted?: boolean;
     /** Set true after the user has been prompted (or skipped) the first-run Experience Engine setup. */
@@ -151,13 +205,13 @@ export interface UserSettings {
     providers?: {
         anthropic?: ProviderKeyConfig;
         openai?: ProviderKeyConfig;
-        google?: ProviderKeyConfig;
         deepseek?: ProviderKeyConfig;
-        siliconflow?: ProviderKeyConfig;
         xai?: ProviderKeyConfig;
         ollama?: {
             baseURL?: string;
         };
+        zai?: ProviderKeyConfig;
+        "opencode-go"?: ProviderKeyConfig;
     };
     /** Providers the user has explicitly disabled in the model picker (still configured but hidden). */
     disabledProviders?: ProviderId[];
@@ -187,6 +241,11 @@ export interface UserSettings {
         /** Switch back to premium for final synthesis. Default: false. */
         premiumSynthesis?: boolean;
     };
+    /**
+     * Peak-hour routing for Z.ai (14:00–18:00 UTC+8 per docs) and DeepSeek
+     * (pro→flash downgrade in the same window to ease concurrency pressure).
+     */
+    peakHourPolicy?: PeakHourPolicy;
     /**
      * Reporter auto-fire settings (B2).
      * Controls whether the reporter posts to Discord automatically on sprint
@@ -216,6 +275,27 @@ export interface UserSettings {
      * Default 400_000 (~100k tokens).
      */
     topLevelToolBudgetChars?: number;
+    /**
+     * Router tier-promotion cap. The session's default model is treated as the
+     * user's cost ceiling: the EE router may DOWNGRADE per turn (cheaper model)
+     * but may not promote to a HIGHER tier than this setting allows without an
+     * explicit opt-in.
+     *
+     * - `"off"`: never promote beyond the default model's own tier.
+     * - `"balanced"` (default): allow promotion up to balanced, never premium.
+     *   Routine tasks the EE brain over-classifies as premium get clamped to
+     *   balanced (or to the default model when the provider has no balanced
+     *   option — e.g. DeepSeek native only has fast + premium).
+     * - `"any"`: restore legacy behavior (router may promote to any tier).
+     *
+     * Evidence: session 89b34ce9a4e8 — default deepseek-v4-flash (fast tier),
+     * stored session.model=flash, but EE warm path returned premium for a
+     * routine "check và commit files" task → 47/47 turns silently ran on
+     * deepseek-v4-pro ($0.353) instead of flash (~$0.06). The per-turn routing
+     * override never flowed through setModel so the sessions row stayed flash
+     * ("session.model lie"). Default cap="balanced" prevents that silent leak.
+     */
+    routingPromoteMax?: "off" | "balanced" | "any";
 }
 export interface ProjectSettings {
     model?: string;
@@ -279,6 +359,7 @@ export declare function loadPaymentSettings(): Required<PaymentSettings>;
 export declare function savePaymentSettings(partial: PaymentSettings): void;
 export declare function isAutoCompactAfterTurnEnabled(): boolean;
 export declare function getAutoCompactThresholdPct(): number;
+export declare function getAutoCompactMinNewTokens(): number;
 /**
  * Per-invocation cap on cumulative tool-output chars inside a `task`
  * sub-agent. See orchestrator/sub-agent-cap.ts for the tiered compression
@@ -294,6 +375,42 @@ export declare function getSubAgentBudgetChars(): number;
  * Default 120_000 (2 min). Env override: MUONROI_PROVIDER_STALL_TIMEOUT_MS.
  */
 export declare function getProviderStallTimeoutMs(): number;
+/**
+ * No-forward-progress watchdog timeout (ms) for streaming model calls. Distinct
+ * from the stall watchdog: the stall watchdog re-arms on ANY stream chunk —
+ * including a reasoning model's `reasoning-delta` chunks — so a model stuck in an
+ * endless chain-of-thought keeps petting it and it NEVER fires (observed live
+ * 2026-07-10: a deepseek-v4-flash sub-agent churned reasoning for 30+ min, 1.4M
+ * input tokens, ZERO text/tool output, and the 2-min stall watchdog never tripped
+ * because reasoning chunks kept arriving). This second watchdog is petted ONLY on
+ * REAL forward progress (a text-delta or a tool-call), so a runaway-reasoning /
+ * no-output loop is aborted while a legitimately long reasoning burst that DOES
+ * eventually emit text/tools survives. Set generously above a normal reasoning
+ * burst. Range 30_000–1_800_000; 0 disables. Default 300_000 (5 min). Env
+ * override: MUONROI_PROVIDER_PROGRESS_TIMEOUT_MS.
+ */
+export declare function getProviderProgressTimeoutMs(): number;
+/**
+ * Event-loop block reporting threshold (ms). The monitor
+ * (`src/utils/event-loop-monitor.ts`) reports a block when its own tick runs at
+ * least this late — evidence that the JS thread was stuck and NO timer could
+ * fire, which is why the provider stall watchdogs above cannot see this class
+ * of freeze (measured live 2026-07-16: a 304.5s TUI freeze that the 120s stall
+ * watchdog only rescued 6.7s AFTER the loop recovered).
+ *
+ * 2s is well clear of ordinary GC pauses and heavy renders while still catching
+ * anything a user would call a freeze. Range 250–60_000; 0 disables.
+ * Default 2_000. Env override: MUONROI_LOOP_BLOCK_THRESHOLD_MS.
+ */
+export declare function getLoopBlockThresholdMs(): number;
+/**
+ * Whether to run the rolling CPU profiler (`src/utils/loop-profiler.ts`) so a
+ * reported event-loop block comes with the culprit's stack rather than just a
+ * duration. OFF by default: continuous V8 sampling costs a little on every
+ * session, and this is a diagnostic for a sporadic bug, not a feature. Arm it
+ * when hunting a freeze. Env: MUONROI_LOOP_PROFILE=1 (0/unset disables).
+ */
+export declare function isLoopProfileEnabled(): boolean;
 /**
  * Number of times to AUTOMATICALLY re-issue a streaming model call after the
  * stall watchdog fires WITHOUT any chunk having arrived (a time-to-first-byte
@@ -337,21 +454,48 @@ export declare function getSubAgentCompactKeepLast(): number;
  * top-level loops typically carry more useful early context.
  * Env override: MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS.
  */
-export declare function getTopLevelCompactThresholdChars(): number;
+export declare function getTopLevelCompactThresholdChars(contextWindowTokens?: number): number;
+/**
+ * Compaction hysteresis factor for the top-level loop. Once B4 compaction has
+ * fired within a turn, the compacted prefix is FROZEN and only new messages are
+ * appended (keeping the provider prompt-cache prefix byte-stable) until the
+ * cumulative size grows past `lastTriggerChars * factor` — then it re-compacts.
+ *
+ * Why: measured on session 1afb2728e67a — a 24-step turn re-ran compaction every
+ * step, and each step's sliding keepLast boundary flipped one more tool result
+ * verbatim→stub, breaking the cache prefix at that position. 63% of that
+ * session's FRESH input came from 5 such compaction-induced cache breaks.
+ * Holding the boundary between compactions trades a higher peak input for far
+ * fewer cache-break re-bills.
+ *
+ * Range 1.0–3.0. Default 1.15 (re-compact at +15% growth). `1.0` or env `0`
+ * disables hysteresis → legacy per-step compaction.
+ * Env override: MUONROI_COMPACT_HYSTERESIS.
+ */
+export declare function getTopLevelCompactHysteresis(): number;
 /**
  * Phase B4 — number of trailing tool turns kept verbatim during top-level
  * compaction. Higher than sub-agent default because top-level agents make
  * decisions across longer horizons.
  * Env override: MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST.
  */
-export declare function getTopLevelCompactKeepLast(): number;
+export declare function getTopLevelCompactKeepLast(contextWindowTokens?: number): number;
+/**
+ * O2 — byte budget for the verbatim tail (last keepLast turns) in top-level B4
+ * compaction. The keepLast shrink is otherwise fill-ratio based, so on a
+ * large-context model a read-heavy tail stays verbatim at ~50% fill, pinning
+ * each tool round at 60-80K input (measured on July-8 sessions). This caps the
+ * tail's actual chars, shrinking keepLast further (floor 2) when the kept tool
+ * results are large. 0 disables. Env: MUONROI_TOP_LEVEL_COMPACT_TAIL_BUDGET_CHARS.
+ */
+export declare function getTopLevelCompactTailBudgetChars(contextWindowTokens?: number): number;
 /**
  * Per-turn cap on cumulative tool-output chars inside the top-level
  * orchestrator agentic loop. Same tiered compression as the sub-agent cap,
  * higher default so single-tool turns are unaffected. Env override:
  * MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS.
  */
-export declare function getTopLevelToolBudgetChars(maxRounds?: number): number;
+export declare function getTopLevelToolBudgetChars(maxRounds?: number, contextWindowTokens?: number): number;
 export declare function getRoleModel(role: ModelRole): string | undefined;
 export declare function getRoleModels(): Partial<Record<ModelRole, string>>;
 export declare function getCouncilRounds(): number;
@@ -361,10 +505,41 @@ export declare function normalizeAutoCouncilConfidence(val: unknown): number;
 /** Pure validator extracted for testability; clamps user input to a sane range. */
 export declare function normalizeAutoCouncilMinRoles(val: unknown): number;
 export declare function getAutoCouncilConfidence(): number;
+/**
+ * Whether the auto-council path runs the pre-debate clarification interview
+ * (model-designed askcards) before debating. Default true so a broadly-scoped
+ * "debate mode" request is clarified first. Env override wins over the user
+ * setting for quick dev toggling; env "0"/"false" disables, "1"/"true" enables.
+ */
+export declare function isAutoCouncilClarifyEnabled(): boolean;
+/**
+ * Whether auto-council should be skipped when the session model is a reasoning
+ * model. Default true. Env override wins over the user setting for quick dev
+ * toggling; env "0"/"false" disables the skip (forces council), "1"/"true"
+ * enables the skip.
+ */
+export declare function isAutoCouncilSkipReasoning(): boolean;
 export declare function getAutoCouncilMinRoles(): number;
 export declare function isCouncilMultiProviderPreferred(): boolean;
 export declare function getCouncilExperienceMode(): CouncilExperienceMode;
+export declare function normalizePeakHourPolicy(raw: unknown): PeakHourPolicy;
+export declare function getPeakHourPolicy(): PeakHourPolicy;
 export declare function isCouncilCostAware(): boolean;
+/**
+ * Normalize a raw councilLanguage value (Feature B). Trims + lowercases the two
+ * reserved modes ("auto", "english"); any other non-empty string is preserved
+ * as-is (trimmed) so locale labels keep the user's exact casing (e.g. "日本語").
+ * Empty / non-string → "auto".
+ */
+export declare function normalizeCouncilLanguage(raw: unknown): string;
+export declare function getCouncilLanguage(): string;
+/**
+ * Router tier-promotion ceiling. See UserSettings.routingPromoteMax.
+ * Default "balanced" — router may promote up to balanced but never silently
+ * to premium. Validated to the three allowed values; any unknown value
+ * falls back to the default.
+ */
+export declare function getRoutingPromoteMax(): "off" | "balanced" | "any";
 export declare function getDisabledProviders(): ProviderId[];
 export declare function isProviderDisabled(provider: ProviderId): boolean;
 export declare function setProviderDisabled(provider: ProviderId, disabled: boolean): ProviderId[];