llm-relay 0.80.0 → 0.82.0

package/dist/dispatch.js

@@ -1,7 +1,9 @@
-import { expandPoolSpecs, offloadRule, splitSpec, POOL_PREFIX } from "./config.js";
+import { existsSync } from "node:fs";
+import { AUTO_MODEL, expandPoolSpecs, offloadRule, splitSpec, POOL_PREFIX } from "./config.js";
 import { unsupportedArgValues, verifyModel } from "./lane-manifest.js";
-import { allLaneStats, laneStatsFor, medianWallClockMs, p95WallClockMs, quantileWallClockMs } from "./dispatch-lane-stats.js";
+import { allLaneStats, DISPATCH_MODES, laneStatsFor, medianWallClockMs, p95WallClockMs, quantileWallClockMs } from "./dispatch-lane-stats.js";
 import { laneDemotion, lanePin } from "./lane-affinity.js";
+import { relayStatePath } from "./state-paths.js";
 export const DEFAULT_EXHAUSTED_MS = 15 * 60 * 1000;
 export const MAX_EXHAUSTED_MS = 30 * 24 * 60 * 60 * 1000;
 export const OUTCOME_DEFAULT_MS = {
@@ -9,6 +11,9 @@ export const OUTCOME_DEFAULT_MS = {
     quota_exhausted: 60 * 60 * 1000,
 };
 const MAX_ECHOED_ID = 120;
+export const MAX_ATTEMPT_BUDGET_MS = 3_600_000;
+export const LANE_UNRELIABLE_STREAK = 3;
+export const FAILING_LANE_STREAK = 5;
 export function formatLaneStats(stats) {
     const seconds = (ms) => (ms === null ? "n/a" : `${Math.round(ms / 100) / 10}s`);
     return (`stats: ${stats.calls} calls, ${stats.successes} ok, ${stats.failures} failed, ` +
@@ -17,15 +22,19 @@ export function formatLaneStats(stats) {
 export function formatAttemptBudget(budget) {
     const render = (ms) => `${Math.round(ms / 100) / 10}s`;
     const seconds = render(budget.ms);
+    const raised = budget.raisedBy
+        ? `; raised after ${budget.raisedBy} abandoned run${budget.raisedBy === 1 ? "" : "s"}, ` +
+            `×2 each, at most ${render(MAX_ATTEMPT_BUDGET_MS)}`
+        : "";
     switch (budget.basis) {
         case "history":
-            return `budget: ${seconds} (from ${budget.samples} recorded runs)`;
+            return `budget: ${seconds} (from ${budget.samples} recorded runs${raised})`;
         case "clamped":
             return budget.quantileMs === undefined
-                ? `budget: ${seconds} (flat floor — this lane's ${budget.samples} runs are faster)`
-                : `budget: ${seconds} (flat floor — this lane's ${budget.samples} runs put it at ${render(budget.quantileMs)})`;
+                ? `budget: ${seconds} (flat floor — this lane's ${budget.samples} runs are faster${raised})`
+                : `budget: ${seconds} (flat floor — this lane's ${budget.samples} runs put it at ${render(budget.quantileMs)}${raised})`;
         case "floor":
-            return `budget: ${seconds} (flat — too few recorded runs, ${budget.samples})`;
+            return `budget: ${seconds} (flat — too few recorded runs, ${budget.samples}${raised})`;
         default: {
             const _never = budget.basis;
             return _never;
@@ -64,9 +73,7 @@ function clampExhaustedDeadline(untilMs, now) {
     return Math.min(Math.max(now, untilMs), now + MAX_EXHAUSTED_MS);
 }
 export function markExhausted(cfg, id, ttlMs = DEFAULT_EXHAUSTED_MS, tier) {
-    if (typeof id !== "string" || id.length === 0)
-        return false;
-    const rung = selectLadder(cfg, tier).rungs.find((r) => r.id === id);
+    const { rung } = lookupLadderRung(cfg, id, tier);
     if (!rung)
         return false;
     markExhaustedKey(cfg, cooldownKey(rung), Date.now() + normalizeTtl(ttlMs));
@@ -81,12 +88,17 @@ export function clearExhausted(cfg, id, tier) {
         }
         return;
     }
-    if (typeof id !== "string")
-        return;
-    const rung = selectLadder(cfg, tier).rungs.find((r) => r.id === id);
+    const { rung } = lookupLadderRung(cfg, id, tier);
     if (rung)
         clearExhaustedKey(cfg, cooldownKey(rung));
 }
+export function lookupLadderRung(cfg, laneId, tier) {
+    const selected = selectLadder(cfg, tier);
+    const rung = typeof laneId === "string" && laneId.length > 0
+        ? selected.rungs.find((r) => r.id === laneId)
+        : undefined;
+    return { tier: selected.tier, rung, missingTier: selected.missing };
+}
 const exhaustionListeners = new WeakMap();
 export function onExhaustionChanged(cfg, listener) {
     let set = exhaustionListeners.get(cfg);
@@ -192,6 +204,13 @@ function reachableWithoutRelay(spec, cfg) {
             provider.credentialMode !== "contained");
     });
 }
+export function isPassThroughSpec(spec, cfg) {
+    return reachableWithoutRelay(spec, cfg);
+}
+export function mcpPassThroughReason(spec) {
+    return (`the MCP server cannot run "${describeId(spec)}": it forwards the caller's own Anthropic credential, ` +
+        "which only the calling host holds, so the host must reach it with its own subagent");
+}
 function transposeToCli(spec, lane, task, platform, contextWindow) {
     const fillShared = (value) => {
         const withSpec = value.split(SPEC_TOKEN).join(spec);
@@ -223,6 +242,36 @@ function transposeToCli(spec, lane, task, platform, contextWindow) {
 export function normalizeCliCommand(command, platform = process.platform) {
     return platform === "win32" && /^agy$/i.test(command) ? `${command}.exe` : command;
 }
+export function resolveLaneLauncherPath(platform = process.platform, exists) {
+    if (platform !== "win32")
+        return null;
+    if (exists === undefined && process.env["VITEST"])
+        return null;
+    const path = relayStatePath("config", ["bin", "lane-launch.ps1"]);
+    return (exists ?? existsSync)(path) ? path : null;
+}
+function isAlreadyLaneLaunched(command, args) {
+    if (!/^(pwsh|powershell)(\.exe)?$/i.test(command))
+        return false;
+    const fileIdx = args.findIndex((a) => a === "-File" || a === "/File");
+    if (fileIdx === -1)
+        return false;
+    const target = args[fileIdx + 1];
+    if (!target)
+        return false;
+    const basename = target.split(/[\\/]/).pop() ?? "";
+    return /^lane-launch\.ps1$/i.test(basename);
+}
+function wrapForWindowsConsoleSafety(invoke, launcherPath, platform) {
+    if (platform !== "win32" || launcherPath === null)
+        return invoke;
+    if (isAlreadyLaneLaunched(invoke.command, invoke.args))
+        return invoke;
+    return {
+        command: "pwsh",
+        args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", launcherPath, invoke.command, ...invoke.args],
+    };
+}
 function normalizeOptions(opts) {
     const str = (v) => (typeof v === "string" && v.length > 0 ? v : undefined);
     const out = {};
@@ -253,6 +302,14 @@ function normalizeOptions(opts) {
     if (manifest && typeof manifest === "object" && manifest.version === 1 && typeof manifest.lanes === "object" && manifest.lanes !== null) {
         out.manifest = manifest;
     }
+    if (opts.requester === "mcp")
+        out.requester = "mcp";
+    const mode = str(opts.mode);
+    if (mode !== undefined && DISPATCH_MODES.includes(mode))
+        out.mode = mode;
+    const model = str(opts.model);
+    if (model !== undefined && model.length <= 200)
+        out.model = model;
     return out;
 }
 function inferredTier(cfg) {
@@ -294,7 +351,7 @@ function stripControlCharacters(value) {
     }
     return out;
 }
-function describeId(id) {
+export function describeId(id) {
     const clean = stripControlCharacters(id);
     return clean.length > MAX_ECHOED_ID ? `${clean.slice(0, MAX_ECHOED_ID)}\u2026` : clean;
 }
@@ -309,7 +366,7 @@ function unreachableReason(host, who) {
         ? `${who} is not running inside a Claude Code session, so it has no subagent mechanism to reach`
         : `${who} does not route its traffic through this relay, so a subagent cannot reach`;
 }
-function toLane(rung, position, cfg, opts, now, client, platform, host, entrypoint) {
+function toLane(rung, position, cfg, opts, now, client, platform, host, entrypoint, launcherPath) {
     const until = cooldownUntil(cfg, rung, now);
     const state = !rung.enabled ? "disabled" : until !== null ? "exhausted" : "ready";
     const lane = { id: rung.id, kind: rung.kind, position, state };
@@ -339,7 +396,11 @@ function toLane(rung, position, cfg, opts, now, client, platform, host, entrypoi
             delete lane.invoke;
         }
     }
-    if (rung.kind === "relay" && rung.spec) {
+    if (rung.kind === "relay" && rung.spec && opts.requester === "mcp" && reachableWithoutRelay(rung.spec, cfg)) {
+        lane.spec = rung.spec;
+        lane.unreachable = mcpPassThroughReason(rung.spec);
+    }
+    else if (rung.kind === "relay" && rung.spec) {
         lane.spec = rung.spec;
         if (canAddressAsSubagent(host)) {
             lane.requiresDirective = !offloadRule(cfg, client).enabled;
@@ -366,6 +427,10 @@ function toLane(rung, position, cfg, opts, now, client, platform, host, entrypoi
             }
         }
     }
+    if (lane.invoke) {
+        const wrapped = wrapForWindowsConsoleSafety(lane.invoke, launcherPath, platform);
+        lane.invoke = { ...lane.invoke, command: wrapped.command, args: wrapped.args };
+    }
     return lane;
 }
 function rungModel(rung) {
@@ -440,14 +505,102 @@ function stripArgs(args, drop) {
     }
     return out;
 }
-export function buildDispatch(cfg, rawOpts = {}, platform = process.platform) {
+export function buildDispatch(cfg, rawOpts = {}, platform = process.platform, launcherPath = null) {
     const opts = normalizeOptions(rawOpts ?? {});
     const client = opts.client ?? "default";
     const host = opts.host ?? "unknown";
     const now = Date.now();
     const selected = selectLadder(cfg, opts.tier);
-    const rungs = selected.rungs;
-    const ladder = rungs.map((r, i) => toLane(r, i + 1, cfg, opts, now, client, platform, opts.host, opts.entrypoint));
+    const makeLane = (rung, position) => toLane(rung, position, cfg, opts, now, client, platform, opts.host, opts.entrypoint, launcherPath);
+    const ladder = selected.rungs.map((r, i) => makeLane(r, i + 1));
+    annotateLaneStats(cfg, ladder);
+    annotateLaneHistory(cfg, ladder, selected.tier, opts.mode ?? null);
+    annotateAffinity(cfg, ladder, selected.tier, now);
+    const offload = offloadRule(cfg, client).enabled;
+    const base = { tier: selected.tier, offload, client, host, ladder };
+    if (opts.model !== undefined)
+        return modelView(cfg, base, opts.model, opts.lane, makeLane);
+    if (selected.missing) {
+        return {
+            ...base,
+            order: [],
+            next: null,
+            reason: `no dispatch tier "${describeId(selected.missing)}" configured (have: ${Object.keys(cfg.routing.ladders ?? {}).join(", ")})`,
+        };
+    }
+    if (ladder.length === 0) {
+        return {
+            ...base,
+            order: [],
+            next: null,
+            reason: "no routing.ladder configured — dispatch order is the host's to choose",
+        };
+    }
+    if (opts.lane !== undefined)
+        return forcedLaneView(base, opts.lane);
+    return rankedView(base, opts.after);
+}
+function laneWindows(cfg, laneId, tier, mode) {
+    const keys = [];
+    const add = (t, m) => {
+        if (!keys.some(([kt, km]) => kt === t && km === m))
+            keys.push([t, m]);
+    };
+    add(tier, mode);
+    add(tier, null);
+    add(null, mode);
+    add(null, null);
+    const out = [];
+    for (const [t, m] of keys) {
+        const w = laneStatsFor(cfg, laneId, t, m);
+        if (w)
+            out.push(w);
+    }
+    return out;
+}
+function laneHistoryFacts(cfg, laneId, tier, mode) {
+    const windows = laneWindows(cfg, laneId, tier, mode);
+    const walk = cfg.routing.dispatchWalk;
+    const minSamples = walk?.attemptMinSamples ?? 5;
+    const sampled = windows.find((w) => w.wallClockMs.length >= minSamples);
+    const hinted = sampled ?? windows.find((w) => w.wallClockMs.length > 0);
+    const timeToAnswer = hinted === undefined
+        ? undefined
+        : {
+            medianMs: Math.round(medianWallClockMs(hinted.wallClockMs) ?? 0),
+            p80Ms: Math.round(quantileWallClockMs(hinted.wallClockMs, 0.8) ?? 0),
+            samples: hinted.wallClockMs.length,
+            mode: hinted.mode,
+        };
+    const newest = windows[0];
+    const recentFailures = newest?.consecutiveFailures ?? 0;
+    if (!walk || !walk.enabled)
+        return { budget: undefined, timeToAnswer, recentFailures };
+    const floorMs = mode === "agent" ? Math.max(walk.attemptMs, walk.agentAttemptMs) : walk.attemptMs;
+    const base = budgetFromSamples(sampled?.wallClockMs ?? newest?.wallClockMs ?? [], { ...walk, attemptMs: floorMs });
+    const raisedBy = newest?.abandonedSinceSuccess ?? 0;
+    if (base === undefined || raisedBy <= 0)
+        return { budget: base, timeToAnswer, recentFailures };
+    const ms = Math.min(MAX_ATTEMPT_BUDGET_MS, base.ms * 2 ** Math.min(raisedBy, 16));
+    return { budget: { ...base, ms, raisedBy }, timeToAnswer, recentFailures };
+}
+function budgetFromSamples(samples, walk) {
+    if (samples.length < walk.attemptMinSamples) {
+        return { ms: walk.attemptMs, basis: "floor", samples: samples.length };
+    }
+    const quantile = quantileWallClockMs(samples, walk.attemptQuantile);
+    if (quantile === null)
+        return { ms: walk.attemptMs, basis: "floor", samples: samples.length };
+    const own = Math.round(quantile);
+    if (own < walk.attemptMs) {
+        return { ms: walk.attemptMs, basis: "clamped", samples: samples.length, quantileMs: own };
+    }
+    return { ms: own, basis: "history", samples: samples.length };
+}
+function isSelectable(lane) {
+    return lane.state === "ready" && lane.unreachable === undefined && lane.notServable === undefined;
+}
+function annotateLaneStats(cfg, ladder) {
     const statsByLane = new Map();
     for (const row of allLaneStats(cfg)) {
         const agg = statsByLane.get(row.laneId);
@@ -483,108 +636,112 @@ export function buildDispatch(cfg, rawOpts = {}, platform = process.platform) {
             lastAt: row.lastAt,
         };
     }
+}
+function annotateLaneHistory(cfg, ladder, tier, mode) {
+    const walkOn = cfg.routing.dispatchWalk?.enabled === true;
     for (const lane of ladder) {
-        const budget = attemptBudget(cfg, lane.id, selected.tier);
-        if (budget !== undefined)
-            lane.attemptBudget = budget;
-    }
-    annotateAffinity(cfg, ladder, selected.tier, now);
-    const offload = offloadRule(cfg, client).enabled;
-    const base = { tier: selected.tier, offload, client, host, ladder };
-    if (selected.missing) {
-        return {
-            ...base,
-            order: [],
-            next: null,
-            reason: `no dispatch tier "${describeId(selected.missing)}" configured (have: ${Object.keys(cfg.routing.ladders ?? {}).join(", ")})`,
-        };
+        const facts = laneHistoryFacts(cfg, lane.id, tier, mode);
+        if (facts.budget !== undefined)
+            lane.attemptBudget = facts.budget;
+        if (facts.timeToAnswer !== undefined)
+            lane.timeToAnswer = facts.timeToAnswer;
+        if (facts.recentFailures > 0)
+            lane.recentFailures = facts.recentFailures;
+        if (walkOn && facts.recentFailures >= FAILING_LANE_STREAK && isSelectable(lane)) {
+            lane.failing = {
+                streak: facts.recentFailures,
+                reason: `${facts.recentFailures} own failures in a row; ordered behind the other lanes until it answers again`,
+            };
+        }
     }
-    if (ladder.length === 0) {
+}
+function forcedLaneView(base, laneId) {
+    const forced = base.ladder.find((l) => l.id === laneId);
+    if (!forced) {
         return {
             ...base,
             order: [],
             next: null,
-            reason: "no routing.ladder configured — dispatch order is the host's to choose",
-        };
-    }
-    if (opts.lane !== undefined) {
-        const forced = ladder.find((l) => l.id === opts.lane);
-        if (!forced) {
-            return {
-                ...base,
-                order: [],
-                next: null,
-                reason: `no lane "${describeId(opts.lane)}" in the ladder (have: ${ladder.map((l) => l.id).join(", ")})`,
-            };
-        }
-        return {
-            ...base,
-            order: [forced.id],
-            next: forced,
-            reason: forced.unreachable !== undefined
-                ? `lane "${forced.id}" selected by host override (${forced.unreachable})`
-                : forced.state === "ready"
-                    ? `lane "${forced.id}" selected by host override`
-                    : `lane "${forced.id}" selected by host override (currently ${forced.state})`,
+            reason: `no lane "${describeId(laneId)}" in the ladder (have: ${base.ladder.map((l) => l.id).join(", ")})`,
         };
     }
-    let pool = ladder;
-    if (opts.after !== undefined) {
-        const idx = ladder.findIndex((l) => l.id === opts.after);
+    return {
+        ...base,
+        order: [forced.id],
+        next: forced,
+        reason: forced.unreachable !== undefined
+            ? `lane "${forced.id}" selected by host override (${forced.unreachable})`
+            : forced.state === "ready"
+                ? `lane "${forced.id}" selected by host override`
+                : `lane "${forced.id}" selected by host override (currently ${forced.state})`,
+    };
+}
+function rankedView(base, after) {
+    let pool = base.ladder;
+    if (after !== undefined) {
+        const idx = base.ladder.findIndex((l) => l.id === after);
         if (idx < 0) {
             return {
                 ...base,
                 order: [],
                 next: null,
-                reason: `no lane "${describeId(opts.after)}" in the ladder (have: ${ladder.map((l) => l.id).join(", ")})`,
+                reason: `no lane "${describeId(after)}" in the ladder (have: ${base.ladder.map((l) => l.id).join(", ")})`,
             };
         }
-        pool = ladder.slice(idx + 1);
+        pool = base.ladder.slice(idx + 1);
     }
-    const usable = pool.filter((l) => l.state === "ready" && l.unreachable === undefined && l.notServable === undefined);
+    const usable = pool.filter(isSelectable);
     const ranked = rankSelectable(usable);
     const next = ranked[0] ?? null;
     if (!next) {
         const blocked = pool.filter((l) => l.unreachable !== undefined).length;
-        const why = opts.after !== undefined
-            ? `no ready lane after "${describeId(opts.after)}" — the ladder is exhausted`
+        const why = after !== undefined
+            ? `no ready lane after "${describeId(after)}" — the ladder is exhausted`
             : "every lane is exhausted or disabled";
+        return { ...base, order: [], next: null, reason: blocked > 0 ? `${why} (${blocked} unreachable from this host)` : why };
+    }
+    return { ...base, order: ranked.map((l) => l.id), next, reason: selectionReason(next, after, usable) };
+}
+function unknownModelReason(cfg, spec) {
+    if (/\s/.test(spec) || stripControlCharacters(spec) !== spec) {
+        return `model "${describeId(spec)}" is not a routing spec: it holds whitespace or control characters`;
+    }
+    if (spec === AUTO_MODEL)
+        return null;
+    const { provider, model } = splitSpec(spec);
+    if (provider === POOL_PREFIX) {
+        const pools = Object.keys(cfg.routing.pools ?? {});
+        if (model !== undefined && pools.includes(model))
+            return null;
+        return `no pool "${describeId(spec)}" configured (have: ${pools.map((p) => `${POOL_PREFIX}/${p}`).join(", ")})`;
+    }
+    if (Object.keys(cfg.providers).includes(provider))
+        return null;
+    return `model "${describeId(spec)}" names no configured provider or pool (providers: ${Object.keys(cfg.providers).join(", ")})`;
+}
+function modelView(cfg, base, spec, laneOverride, makeLane) {
+    if (laneOverride !== undefined) {
         return {
             ...base,
             order: [],
             next: null,
-            reason: blocked > 0 ? `${why} (${blocked} unreachable from this host)` : why,
+            reason: `pass lane or model, not both: lane "${describeId(laneOverride)}" names a ladder rung and ` +
+                `model "${describeId(spec)}" names a routing spec`,
         };
     }
-    const why = selectionReason(next, opts.after, usable);
-    return { ...base, order: ranked.map((l) => l.id), next, reason: why };
-}
-function attemptBudget(cfg, laneId, tier) {
-    const walk = cfg.routing.dispatchWalk;
-    if (!walk || !walk.enabled)
-        return undefined;
-    const tiered = laneStatsFor(cfg, laneId, tier)?.wallClockMs ?? [];
-    if (tiered.length >= walk.attemptMinSamples) {
-        return budgetFromSamples(tiered, walk);
-    }
-    if (tier === null) {
-        return budgetFromSamples(tiered, walk);
-    }
-    const legacy = laneStatsFor(cfg, laneId, null)?.wallClockMs ?? [];
-    return budgetFromSamples(legacy, walk);
-}
-function budgetFromSamples(samples, walk) {
-    if (samples.length < walk.attemptMinSamples) {
-        return { ms: walk.attemptMs, basis: "floor", samples: samples.length };
-    }
-    const quantile = quantileWallClockMs(samples, walk.attemptQuantile);
-    if (quantile === null)
-        return { ms: walk.attemptMs, basis: "floor", samples: samples.length };
-    const own = Math.round(quantile);
-    if (own < walk.attemptMs) {
-        return { ms: walk.attemptMs, basis: "clamped", samples: samples.length, quantileMs: own };
-    }
-    return { ms: own, basis: "history", samples: samples.length };
+    const unknown = unknownModelReason(cfg, spec);
+    if (unknown !== null)
+        return { ...base, order: [], next: null, reason: unknown };
+    const lane = makeLane({ id: `model:${spec}`, kind: "relay", enabled: true, spec }, base.ladder.length + 1);
+    lane.adHoc = true;
+    const named = `model "${spec}" named by the caller`;
+    return {
+        ...base,
+        ladder: [...base.ladder, lane],
+        order: [lane.id],
+        next: lane,
+        reason: lane.unreachable === undefined ? named : `${named} (${lane.unreachable})`,
+    };
 }
 function annotateAffinity(cfg, ladder, tier, now) {
     const walk = cfg.routing.dispatchWalk;
@@ -606,7 +763,7 @@ function annotateAffinity(cfg, ladder, tier, now) {
     }
 }
 function rankSelectable(usable) {
-    const rank = (lane) => (lane.pinned ? 0 : lane.demoted ? 2 : 1);
+    const rank = (lane) => (lane.pinned ? 0 : lane.demoted || lane.failing ? 2 : 1);
     return [...usable].sort((a, b) => rank(a) - rank(b));
 }
 function selectionReason(next, after, usable) {
@@ -614,17 +771,22 @@ function selectionReason(next, after, usable) {
         return `lane "${next.id}" is pinned (${next.pinned.reason})`;
     if (after !== undefined)
         return `first ready lane after "${describeId(after)}"`;
-    if (next.demoted)
-        return `every ready lane is demoted; "${next.id}" is first among them in the ladder`;
+    if (next.demoted || next.failing) {
+        return `every ready lane is demoted or failing; "${next.id}" is first among them in the ladder`;
+    }
     if (next.position === 1)
         return "first lane in the ladder";
-    const aheadDemoted = usable.filter((l) => l.position < next.position).length;
-    const aheadUnavailable = next.position - 1 - aheadDemoted;
+    const ahead = usable.filter((l) => l.position < next.position);
+    const aheadFailing = ahead.filter((l) => l.failing !== undefined).length;
+    const aheadDemoted = ahead.length - aheadFailing;
+    const aheadUnavailable = next.position - 1 - ahead.length;
     const parts = [];
     if (aheadUnavailable > 0)
         parts.push(`${aheadUnavailable} ahead of it unavailable`);
     if (aheadDemoted > 0)
         parts.push(`${aheadDemoted} ahead of it ready but demoted`);
+    if (aheadFailing > 0)
+        parts.push(`${aheadFailing} ahead of it ready but failing`);
     return parts.length === 0 ? "first lane in the ladder" : `first undemoted lane (${parts.join(", ")})`;
 }
 export const AUTO_TIERS = ["low", "medium", "high", "xhigh"];