llm-relay 0.77.0 → 0.78.0

package/dist/config/routing-parser.js

@@ -1,4 +1,4 @@
-import { EFFORT_LEVELS, } from "../config-types.js";
+import { DEFAULT_MCP_MAX_WAIT_MS, EFFORT_LEVELS, } from "../config-types.js";
 import { AUTO_MODEL, POOL_PREFIX, splitSpec } from "../spec.js";
 const EFFORT_LEVEL_SET = new Set(EFFORT_LEVELS);
 function parseQuotaEnforcement(raw) {
@@ -92,122 +92,91 @@ function parseHedge(raw) {
     }
     return out;
 }
-export function parseRouting(raw, providers, overrideDefault, warnings = [], disabledProviders = new Set()) {
-    const r = (typeof raw === "object" && raw !== null ? raw : {});
-    if (providers[POOL_PREFIX]) {
-        throw new Error(`config.providers."${POOL_PREFIX}" is reserved — it would shadow "pool/<name>" routing`);
-    }
-    if (providers[AUTO_MODEL]) {
-        throw new Error(`config.providers."${AUTO_MODEL}" is reserved — it would shadow "${AUTO_MODEL}" routing`);
+function parseProbation(raw) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (typeof raw === "boolean")
+        return { enabled: raw };
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("config.routing.probation must be an object or a boolean");
     }
-    const dfltRaw = overrideDefault !== undefined ? overrideDefault : r.default;
-    let dflt;
-    if (Array.isArray(dfltRaw)) {
-        dflt = dfltRaw.filter((s) => typeof s === "string" && s.length > 0);
-        if (dflt.length === 0) {
-            throw new Error(`config.routing.default array must contain at least one valid spec string`);
+    const value = raw;
+    const known = new Set(["enabled", "minSamples"]);
+    for (const key of Object.keys(value)) {
+        if (!known.has(key)) {
+            throw new Error(`config.routing.probation has an unknown key "${key}"`);
         }
     }
-    else if (typeof dfltRaw === "string" && dfltRaw.length > 0) {
-        dflt = dfltRaw;
-    }
-    else {
-        throw new Error(`config.routing.default ("provider/model") is required`);
+    const out = {};
+    if (value.enabled !== undefined) {
+        if (typeof value.enabled !== "boolean")
+            throw new Error("config.routing.probation.enabled must be a boolean");
+        out.enabled = value.enabled;
     }
-    const tiers = {};
-    if (typeof r.tiers === "object" && r.tiers !== null) {
-        for (const [k, v] of Object.entries(r.tiers)) {
-            if (Array.isArray(v)) {
-                const arr = v.filter((s) => typeof s === "string" && s.length > 0);
-                if (arr.length > 0)
-                    tiers[k] = arr;
-            }
-            else if (typeof v === "string" && v.length > 0) {
-                tiers[k] = v;
-            }
+    if (value.minSamples !== undefined) {
+        const n = value.minSamples;
+        if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
+            throw new Error("config.routing.probation.minSamples must be a positive integer");
         }
+        out.minSamples = n;
     }
-    const pools = {};
-    const poolPolicies = {};
-    if (typeof r.pools === "object" && r.pools !== null) {
-        for (const [k, v] of Object.entries(r.pools)) {
-            let declared;
-            if (Array.isArray(v)) {
-                declared = v.filter((s) => typeof s === "string" && s.length > 0);
-            }
-            else if (typeof v === "object" && v !== null) {
-                const policy = v;
-                if (!Array.isArray(policy.preferred) || policy.preferred.some((s) => typeof s !== "string" || s.length === 0)) {
-                    throw new Error(`config.routing.pools.${k}.preferred must be an array of non-empty "provider/model" specs`);
-                }
-                if (policy.include !== "free") {
-                    throw new Error(`config.routing.pools.${k}.include must be "free"`);
-                }
-                if (policy.exclude !== undefined &&
-                    (!Array.isArray(policy.exclude) ||
-                        policy.exclude.some((s) => typeof s !== "string" ||
-                            !/^\S+\/\S+$/.test(s) ||
-                            s.startsWith(`${POOL_PREFIX}/`)))) {
-                    throw new Error(`config.routing.pools.${k}.exclude must be an array of "provider/model" specs`);
-                }
-                if (policy.effort !== undefined && !EFFORT_LEVEL_SET.has(policy.effort)) {
-                    throw new Error(`config.routing.pools.${k}.effort must be low, medium, high, or xhigh`);
-                }
-                const exclude = [...(policy.exclude ?? [])];
-                const excluded = new Set(exclude);
-                declared = policy.preferred.filter((spec) => !excluded.has(spec));
-                poolPolicies[k] = {
-                    preferred: declared,
-                    include: "free",
-                    ...(exclude.length > 0 ? { exclude } : {}),
-                    ...(policy.effort ? { effort: policy.effort } : {}),
-                };
-            }
-            else {
-                throw new Error(`config.routing.pools.${k} must be an array of specs or {"preferred":[...],"include":"free"}`);
-            }
-            const arr = declared.filter((s) => {
-                const { provider } = splitSpec(s);
-                if (!disabledProviders.has(provider))
-                    return true;
-                warnings.push(`routing.pools.${k}: dropped "${s}" — provider "${provider}" is disabled`);
-                return false;
-            });
-            if (arr.length === 0 && !poolPolicies[k]) {
-                throw new Error(`config.routing.pools.${k} must contain at least one valid spec string`);
-            }
-            const nested = arr.find((s) => s.startsWith(`${POOL_PREFIX}/`));
-            if (nested) {
-                throw new Error(`config.routing.pools.${k} member "${nested}" — a pool cannot reference another pool`);
-            }
-            pools[k] = arr;
-            if (poolPolicies[k])
-                poolPolicies[k] = { ...poolPolicies[k], preferred: arr, include: "free" };
+    return out;
+}
+function parseCrawl(raw) {
+    if (raw === undefined || raw === null)
+        return {};
+    if (typeof raw === "boolean")
+        return { enabled: raw };
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("config.routing.crawl must be an object or a boolean");
+    }
+    const value = raw;
+    const known = new Set(["enabled", "msPerToken", "windowMs", "minTokens"]);
+    for (const key of Object.keys(value)) {
+        if (!known.has(key)) {
+            throw new Error(`config.routing.crawl has an unknown key "${key}"`);
         }
     }
-    const subagents = {};
-    if (typeof r.subagents === "object" && r.subagents !== null) {
-        for (const [k, v] of Object.entries(r.subagents)) {
-            if (typeof v === "string" && v.length > 0)
-                subagents[k] = v;
+    const out = {};
+    if (value.enabled !== undefined) {
+        if (typeof value.enabled !== "boolean")
+            throw new Error("config.routing.crawl.enabled must be a boolean");
+        out.enabled = value.enabled;
+    }
+    for (const key of ["msPerToken", "windowMs", "minTokens"]) {
+        const n = value[key];
+        if (n === undefined)
+            continue;
+        if (typeof n !== "number" || !Number.isFinite(n) || n <= 0) {
+            throw new Error(`config.routing.crawl.${key} must be a positive finite number`);
         }
+        out[key] = n;
     }
+    return out;
+}
+export function parseRouting(raw, providers, overrideDefault, warnings = [], disabledProviders = new Set()) {
+    const r = (typeof raw === "object" && raw !== null ? raw : {});
+    assertNoReservedProviderNames(providers);
+    const dflt = parseDefault(r.default, overrideDefault);
+    const tiers = parseTiers(r.tiers);
+    const { pools, poolPolicies } = parsePools(r.pools, disabledProviders, warnings);
+    const subagents = parseSubagents(r.subagents);
     const benchmarkSort = typeof r.benchmarkSort === "boolean" ? r.benchmarkSort : true;
     const offload = parseOffload(r.offload);
     const routing = { default: dflt, tiers, benchmarkSort, offload };
-    const sticky = parseSticky(r.sticky);
-    if (sticky)
-        routing.sticky = sticky;
-    const quota = parseQuotaEnforcement(r.quota);
-    if (quota)
-        routing.quota = quota;
-    routing.latency = parseLatencyDemotion(r.latency);
-    routing.hedge = parseHedge(r.hedge);
-    routing.laneProbe = parseLaneProbe(r.laneProbe);
-    routing.dispatchWalk = parseDispatchWalk(r.dispatchWalk);
-    const mcpSettings = parseMcpSettings(r.mcp);
-    if (mcpSettings)
-        routing.mcp = mcpSettings;
+    const optionalBlocks = parseOptionalBlocks(r);
+    if (optionalBlocks.sticky)
+        routing.sticky = optionalBlocks.sticky;
+    if (optionalBlocks.quota)
+        routing.quota = optionalBlocks.quota;
+    routing.latency = optionalBlocks.latency;
+    routing.hedge = optionalBlocks.hedge;
+    routing.probation = optionalBlocks.probation;
+    routing.crawl = optionalBlocks.crawl;
+    routing.laneProbe = optionalBlocks.laneProbe;
+    routing.dispatchWalk = optionalBlocks.dispatchWalk;
+    if (optionalBlocks.mcp)
+        routing.mcp = optionalBlocks.mcp;
     if (Object.keys(pools).length > 0)
         routing.pools = pools;
     if (Object.keys(poolPolicies).length > 0)
@@ -217,82 +186,14 @@ export function parseRouting(raw, providers, overrideDefault, warnings = [], dis
     const ladder = parseLadder(r.ladder, "config.routing.ladder");
     if (ladder.length > 0)
         routing.ladder = ladder;
-    if (r.ladders !== undefined && (typeof r.ladders !== "object" || r.ladders === null || Array.isArray(r.ladders))) {
-        throw new Error(`config.routing.ladders must be an object of named ladder arrays`);
-    }
-    const ladders = {};
-    for (const [tier, rawLadder] of Object.entries((r.ladders ?? {}))) {
-        const parsed = parseLadder(rawLadder, `config.routing.ladders.${tier}`);
-        if (parsed.length === 0)
-            throw new Error(`config.routing.ladders.${tier} must contain at least one rung`);
-        ladders[tier] = parsed;
-    }
+    const ladders = parseLadders(r.ladders);
     if (Object.keys(ladders).length > 0)
         routing.ladders = ladders;
     const cliLane = parseCliLane(r.cliLane, "config.routing.cliLane");
     if (cliLane)
         routing.cliLane = cliLane;
-    for (const [tier, spec] of Object.entries(tiers)) {
-        const kept = dropDisabledSpecs(spec, disabledProviders, warnings, `routing.tiers.${tier}`);
-        if (kept === null)
-            delete tiers[tier];
-        else
-            tiers[tier] = kept;
-    }
-    for (const [tier, spec] of Object.entries(subagents)) {
-        const kept = dropDisabledSpecs(spec, disabledProviders, warnings, `routing.subagents.${tier}`);
-        if (kept === null)
-            delete subagents[tier];
-        else
-            subagents[tier] = kept;
-    }
-    if (Array.isArray(routing.default)) {
-        const kept = dropDisabledSpecs(routing.default, disabledProviders, warnings, "routing.default");
-        if (kept !== null)
-            routing.default = kept;
-    }
-    routing.ladder = ladder.filter((rung) => {
-        if (rung.kind !== "relay" || !rung.spec)
-            return true;
-        return dropDisabledSpecs(rung.spec, disabledProviders, warnings, `routing.ladder[${rung.id}].spec`) !== null;
-    });
-    if (routing.ladder.length === 0)
-        delete routing.ladder;
-    for (const [tier, tierLadder] of Object.entries(routing.ladders ?? {})) {
-        const kept = tierLadder.filter((rung) => {
-            if (rung.kind !== "relay" || !rung.spec)
-                return true;
-            return dropDisabledSpecs(rung.spec, disabledProviders, warnings, `routing.ladders.${tier}[${rung.id}].spec`) !== null;
-        });
-        if (kept.length === 0)
-            delete routing.ladders[tier];
-        else
-            routing.ladders[tier] = kept;
-    }
-    if (routing.ladders && Object.keys(routing.ladders).length === 0)
-        delete routing.ladders;
-    assertSpecResolvable(routing.default, providers, pools, "routing.default", disabledProviders);
-    for (const [tier, spec] of Object.entries(tiers)) {
-        assertSpecResolvable(spec, providers, pools, `routing.tiers.${tier}`);
-    }
-    for (const [pool, specs] of Object.entries(pools)) {
-        assertSpecResolvable(specs, providers, {}, `routing.pools.${pool}`);
-    }
-    for (const [tier, spec] of Object.entries(subagents)) {
-        assertSpecResolvable(spec, providers, pools, `routing.subagents.${tier}`);
-    }
-    for (const rung of routing.ladder ?? []) {
-        if (rung.kind === "relay" && rung.spec) {
-            assertSpecResolvable(rung.spec, providers, pools, `routing.ladder[${rung.id}].spec`);
-        }
-    }
-    for (const [tier, tierLadder] of Object.entries(routing.ladders ?? {})) {
-        for (const rung of tierLadder) {
-            if (rung.kind === "relay" && rung.spec) {
-                assertSpecResolvable(rung.spec, providers, pools, `routing.ladders.${tier}[${rung.id}].spec`);
-            }
-        }
-    }
+    degradeDisabledRouting(routing, tiers, subagents, ladder, disabledProviders, warnings);
+    assertRoutingResolvable(routing, tiers, pools, subagents, providers, disabledProviders);
     return routing;
 }
 function parseMcpSettings(raw) {
@@ -303,16 +204,27 @@ function parseMcpSettings(raw) {
     }
     const o = raw;
     for (const key of Object.keys(o)) {
-        if (key !== "allowedRoots") {
-            throw new Error(`config.routing.mcp.${key} is not a recognized key (allowedRoots)`);
+        if (key !== "allowedRoots" && key !== "maxWaitMs") {
+            throw new Error(`config.routing.mcp.${key} is not a recognized key (allowedRoots, maxWaitMs)`);
         }
     }
-    if (o.allowedRoots === undefined)
-        return {};
-    if (!Array.isArray(o.allowedRoots) || o.allowedRoots.some((r) => typeof r !== "string" || r.length === 0)) {
-        throw new Error(`config.routing.mcp.allowedRoots must be an array of non-empty strings`);
+    const out = {};
+    if (o.allowedRoots !== undefined) {
+        if (!Array.isArray(o.allowedRoots) || o.allowedRoots.some((r) => typeof r !== "string" || r.length === 0)) {
+            throw new Error(`config.routing.mcp.allowedRoots must be an array of non-empty strings`);
+        }
+        out.allowedRoots = [...o.allowedRoots];
+    }
+    if (o.maxWaitMs === undefined) {
+        out.maxWaitMs = DEFAULT_MCP_MAX_WAIT_MS;
+    }
+    else if (typeof o.maxWaitMs !== "number" || !Number.isInteger(o.maxWaitMs) || o.maxWaitMs <= 0) {
+        throw new Error(`config.routing.mcp.maxWaitMs must be a positive integer (milliseconds)`);
+    }
+    else {
+        out.maxWaitMs = o.maxWaitMs;
     }
-    return { allowedRoots: [...o.allowedRoots] };
+    return out;
 }
 export const DEFAULT_LANE_PROBE = {
     enabled: true,
@@ -350,6 +262,11 @@ function parseLaneProbe(raw) {
         catalogIntervalMs: interval("catalogIntervalMs", o.catalogIntervalMs, DEFAULT_LANE_PROBE.catalogIntervalMs),
     };
 }
+export const DEFAULT_DISPATCH_WALK_OUTLIER = {
+    recentCount: 5,
+    historyQuantile: 0.8,
+    outlierFactor: 7.6,
+};
 export const DEFAULT_DISPATCH_WALK = {
     enabled: true,
     attemptMs: 90_000,
@@ -358,6 +275,7 @@ export const DEFAULT_DISPATCH_WALK = {
     maxLanes: 4,
     pinMs: 15 * 60 * 1000,
     demoteMs: 15 * 60 * 1000,
+    outlier: { ...DEFAULT_DISPATCH_WALK_OUTLIER },
 };
 function parseDispatchWalk(raw) {
     if (raw === undefined || raw === null)
@@ -368,7 +286,7 @@ function parseDispatchWalk(raw) {
         throw new Error(`config.routing.dispatchWalk must be a boolean or an object`);
     }
     const o = raw;
-    const keys = ["enabled", "attemptMs", "attemptQuantile", "attemptMinSamples", "maxLanes", "pinMs", "demoteMs"];
+    const keys = ["enabled", "attemptMs", "attemptQuantile", "attemptMinSamples", "maxLanes", "pinMs", "demoteMs", "outlier"];
     for (const key of Object.keys(o)) {
         if (!keys.includes(key)) {
             throw new Error(`config.routing.dispatchWalk.${key} is not a recognized key (${keys.join(", ")})`);
@@ -401,7 +319,45 @@ function parseDispatchWalk(raw) {
         maxLanes: bounded("maxLanes", o.maxLanes, DEFAULT_DISPATCH_WALK.maxLanes, 1, 20),
         pinMs: bounded("pinMs", o.pinMs, DEFAULT_DISPATCH_WALK.pinMs, 0, 6 * 60 * 60 * 1000),
         demoteMs: bounded("demoteMs", o.demoteMs, DEFAULT_DISPATCH_WALK.demoteMs, 0, 6 * 60 * 60 * 1000),
+        outlier: parseDispatchWalkOutlier(o.outlier),
+    };
+}
+function parseDispatchWalkOutlier(raw) {
+    const parsed = raw === false ? false : parseDispatchWalkOutlierObject(raw);
+    return parsed;
+}
+function parseDispatchWalkOutlierObject(raw) {
+    if (raw === undefined)
+        return { ...DEFAULT_DISPATCH_WALK_OUTLIER };
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error(`config.routing.dispatchWalk.outlier must be false or an object`);
+    }
+    const o = raw;
+    const keys = ["recentCount", "historyQuantile", "outlierFactor"];
+    for (const key of Object.keys(o)) {
+        if (!keys.includes(key)) {
+            throw new Error(`config.routing.dispatchWalk.outlier.${key} is not a recognized key (${keys.join(", ")})`);
+        }
+    }
+    const d = DEFAULT_DISPATCH_WALK_OUTLIER;
+    const recentCount = o.recentCount;
+    if (recentCount !== undefined && (typeof recentCount !== "number" || !Number.isInteger(recentCount) || recentCount < 1 || recentCount > 100)) {
+        throw new Error(`config.routing.dispatchWalk.outlier.recentCount must be an integer between 1 and 100`);
+    }
+    const historyQuantile = o.historyQuantile;
+    if (historyQuantile !== undefined && (typeof historyQuantile !== "number" || !Number.isFinite(historyQuantile) || historyQuantile <= 0 || historyQuantile >= 1)) {
+        throw new Error(`config.routing.dispatchWalk.outlier.historyQuantile must be a number greater than 0 and less than 1`);
+    }
+    const outlierFactor = o.outlierFactor;
+    if (outlierFactor !== undefined && (typeof outlierFactor !== "number" || !Number.isFinite(outlierFactor) || outlierFactor <= 1 || outlierFactor > 100)) {
+        throw new Error(`config.routing.dispatchWalk.outlier.outlierFactor must be a number greater than 1 and at most 100`);
+    }
+    const parsed = {
+        recentCount: recentCount ?? d.recentCount,
+        historyQuantile: historyQuantile ?? d.historyQuantile,
+        outlierFactor: outlierFactor ?? d.outlierFactor,
     };
+    return parsed;
 }
 function parseSticky(raw) {
     if (raw === undefined || raw === null)
@@ -438,6 +394,154 @@ function parseSticky(raw) {
     }
     return { enabled: sticky.enabled, ttlMs, maxSessions };
 }
+function assertNoReservedProviderNames(providers) {
+    if (providers[POOL_PREFIX]) {
+        throw new Error(`config.providers."${POOL_PREFIX}" is reserved — it would shadow "pool/<name>" routing`);
+    }
+    if (providers[AUTO_MODEL]) {
+        throw new Error(`config.providers."${AUTO_MODEL}" is reserved — it would shadow "${AUTO_MODEL}" routing`);
+    }
+}
+function parseDefault(dfltRaw, overrideDefault) {
+    const raw = overrideDefault !== undefined ? overrideDefault : dfltRaw;
+    let result;
+    if (Array.isArray(raw)) {
+        const filtered = raw.filter((s) => typeof s === "string" && s.length > 0);
+        if (filtered.length === 0) {
+            throw new Error(`config.routing.default array must contain at least one valid spec string`);
+        }
+        result = filtered;
+    }
+    else if (typeof raw === "string" && raw.length > 0) {
+        result = raw;
+    }
+    else {
+        throw new Error(`config.routing.default ("provider/model") is required`);
+    }
+    return result;
+}
+function parseTiers(raw) {
+    const tiers = {};
+    if (typeof raw === "object" && raw !== null) {
+        for (const [k, v] of Object.entries(raw)) {
+            if (Array.isArray(v)) {
+                const arr = v.filter((s) => typeof s === "string" && s.length > 0);
+                if (arr.length > 0)
+                    tiers[k] = arr;
+            }
+            else if (typeof v === "string" && v.length > 0) {
+                tiers[k] = v;
+            }
+        }
+    }
+    return tiers;
+}
+function parsePoolPolicy(k, policy) {
+    if (!Array.isArray(policy.preferred) || policy.preferred.some((s) => typeof s !== "string" || s.length === 0)) {
+        throw new Error(`config.routing.pools.${k}.preferred must be an array of non-empty "provider/model" specs`);
+    }
+    if (policy.include !== "free") {
+        throw new Error(`config.routing.pools.${k}.include must be "free"`);
+    }
+    if (policy.exclude !== undefined &&
+        (!Array.isArray(policy.exclude) ||
+            policy.exclude.some((s) => typeof s !== "string" ||
+                !/^\S+\/\S+$/.test(s) ||
+                s.startsWith(`${POOL_PREFIX}/`)))) {
+        throw new Error(`config.routing.pools.${k}.exclude must be an array of "provider/model" specs`);
+    }
+    if (policy.effort !== undefined && !EFFORT_LEVEL_SET.has(policy.effort)) {
+        throw new Error(`config.routing.pools.${k}.effort must be low, medium, high, or xhigh`);
+    }
+    const exclude = [...(policy.exclude ?? [])];
+    const excluded = new Set(exclude);
+    const declared = policy.preferred.filter((spec) => !excluded.has(spec));
+    const poolPolicy = {
+        preferred: declared,
+        include: "free",
+        ...(exclude.length > 0 ? { exclude } : {}),
+        ...(policy.effort ? { effort: policy.effort } : {}),
+    };
+    return { declared, poolPolicy };
+}
+function parsePoolEntry(k, v, disabledProviders, warnings) {
+    let declared;
+    let poolPolicy;
+    if (Array.isArray(v)) {
+        declared = v.filter((s) => typeof s === "string" && s.length > 0);
+    }
+    else if (typeof v === "object" && v !== null) {
+        const parsed = parsePoolPolicy(k, v);
+        declared = parsed.declared;
+        poolPolicy = parsed.poolPolicy;
+    }
+    else {
+        throw new Error(`config.routing.pools.${k} must be an array of specs or {"preferred":[...],"include":"free"}`);
+    }
+    const arr = declared.filter((s) => {
+        const { provider } = splitSpec(s);
+        if (!disabledProviders.has(provider))
+            return true;
+        warnings.push(`routing.pools.${k}: dropped "${s}" — provider "${provider}" is disabled`);
+        return false;
+    });
+    if (arr.length === 0 && !poolPolicy) {
+        throw new Error(`config.routing.pools.${k} must contain at least one valid spec string`);
+    }
+    const nested = arr.find((s) => s.startsWith(`${POOL_PREFIX}/`));
+    if (nested) {
+        throw new Error(`config.routing.pools.${k} member "${nested}" — a pool cannot reference another pool`);
+    }
+    if (poolPolicy) {
+        poolPolicy = { ...poolPolicy, preferred: arr, include: "free" };
+    }
+    return { members: arr, poolPolicy };
+}
+function parsePools(raw, disabledProviders, warnings) {
+    const pools = {};
+    const poolPolicies = {};
+    if (typeof raw === "object" && raw !== null) {
+        for (const [k, v] of Object.entries(raw)) {
+            const { members, poolPolicy } = parsePoolEntry(k, v, disabledProviders, warnings);
+            pools[k] = members;
+            if (poolPolicy)
+                poolPolicies[k] = poolPolicy;
+        }
+    }
+    return { pools, poolPolicies };
+}
+function parseOptionalBlocks(r) {
+    const sticky = parseSticky(r.sticky);
+    const quota = parseQuotaEnforcement(r.quota);
+    const latency = parseLatencyDemotion(r.latency);
+    const hedge = parseHedge(r.hedge);
+    const probation = parseProbation(r.probation);
+    const crawl = parseCrawl(r.crawl);
+    const laneProbe = parseLaneProbe(r.laneProbe);
+    const dispatchWalk = parseDispatchWalk(r.dispatchWalk);
+    const mcp = parseMcpSettings(r.mcp);
+    return {
+        ...(sticky ? { sticky } : {}),
+        ...(quota ? { quota } : {}),
+        latency,
+        hedge,
+        probation,
+        crawl,
+        laneProbe,
+        dispatchWalk,
+        ...(mcp ? { mcp } : {}),
+    };
+}
+function parseSubagents(raw) {
+    const subagents = {};
+    if (typeof raw === "object" && raw !== null) {
+        for (const [k, v] of Object.entries(raw)) {
+            if (typeof v === "string" && v.length > 0)
+                subagents[k] = v;
+        }
+    }
+    return subagents;
+}
 export function parseOffload(raw) {
     let out = false;
     if (typeof raw === "boolean") {
@@ -554,6 +658,14 @@ function parseCliLane(raw, root) {
     }
     return lane;
 }
+function applyCliMaxConcurrent(rung, raw, where, id) {
+    if (raw === undefined)
+        return;
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw <= 0) {
+        throw new Error(`${where}.maxConcurrent must be a positive integer (rung "${id}")`);
+    }
+    rung.maxConcurrent = raw;
+}
 function parseLadder(raw, root) {
     if (raw === undefined || raw === null)
         return [];
@@ -596,6 +708,7 @@ function parseLadder(raw, root) {
             const env = parseSpawnEnv(e.env, where);
             if (env)
                 rung.env = env;
+            applyCliMaxConcurrent(rung, e.maxConcurrent, where, id);
         }
         else {
             if (typeof e.spec !== "string" || e.spec.length === 0) {
@@ -607,6 +720,56 @@ function parseLadder(raw, root) {
     }
     return out;
 }
+function parseLadders(raw) {
+    if (raw !== undefined && (typeof raw !== "object" || raw === null || Array.isArray(raw))) {
+        throw new Error(`config.routing.ladders must be an object of named ladder arrays`);
+    }
+    const ladders = {};
+    for (const [tier, rawLadder] of Object.entries((raw ?? {}))) {
+        const parsed = parseLadder(rawLadder, `config.routing.ladders.${tier}`);
+        if (parsed.length === 0)
+            throw new Error(`config.routing.ladders.${tier} must contain at least one rung`);
+        ladders[tier] = parsed;
+    }
+    return ladders;
+}
+function dropDisabledRungs(rungs, disabledProviders, warnings, prefix) {
+    return rungs.filter((rung) => {
+        if (rung.kind !== "relay" || !rung.spec)
+            return true;
+        return dropDisabledSpecs(rung.spec, disabledProviders, warnings, `${prefix}[${rung.id}].spec`) !== null;
+    });
+}
+function pruneDisabledSpecEntries(map, disabledProviders, warnings, prefix) {
+    for (const [tier, spec] of Object.entries(map)) {
+        const kept = dropDisabledSpecs(spec, disabledProviders, warnings, `${prefix}.${tier}`);
+        if (kept === null)
+            delete map[tier];
+        else
+            map[tier] = kept;
+    }
+}
+function degradeDisabledRouting(routing, tiers, subagents, ladder, disabledProviders, warnings) {
+    pruneDisabledSpecEntries(tiers, disabledProviders, warnings, "routing.tiers");
+    pruneDisabledSpecEntries(subagents, disabledProviders, warnings, "routing.subagents");
+    if (Array.isArray(routing.default)) {
+        const kept = dropDisabledSpecs(routing.default, disabledProviders, warnings, "routing.default");
+        if (kept !== null)
+            routing.default = kept;
+    }
+    routing.ladder = dropDisabledRungs(ladder, disabledProviders, warnings, "routing.ladder");
+    if (routing.ladder.length === 0)
+        delete routing.ladder;
+    for (const [tier, tierLadder] of Object.entries(routing.ladders ?? {})) {
+        const kept = dropDisabledRungs(tierLadder, disabledProviders, warnings, `routing.ladders.${tier}`);
+        if (kept.length === 0)
+            delete routing.ladders[tier];
+        else
+            routing.ladders[tier] = kept;
+    }
+    if (routing.ladders && Object.keys(routing.ladders).length === 0)
+        delete routing.ladders;
+}
 function assertSpecResolvable(spec, providers, pools, where, disabled = new Set()) {
     const specs = Array.isArray(spec) ? spec : [spec];
     for (const s of specs) {
@@ -629,4 +792,27 @@ function assertSpecResolvable(spec, providers, pools, where, disabled = new Set(
             throw new Error(`config.${where} "${s}" needs a model id for openai provider "${provider}"`);
     }
 }
+function assertRungsResolvable(rungs, providers, pools, prefix) {
+    for (const rung of rungs) {
+        if (rung.kind === "relay" && rung.spec) {
+            assertSpecResolvable(rung.spec, providers, pools, `${prefix}[${rung.id}].spec`);
+        }
+    }
+}
+function assertRoutingResolvable(routing, tiers, pools, subagents, providers, disabledProviders) {
+    assertSpecResolvable(routing.default, providers, pools, "routing.default", disabledProviders);
+    for (const [tier, spec] of Object.entries(tiers)) {
+        assertSpecResolvable(spec, providers, pools, `routing.tiers.${tier}`);
+    }
+    for (const [pool, specs] of Object.entries(pools)) {
+        assertSpecResolvable(specs, providers, {}, `routing.pools.${pool}`);
+    }
+    for (const [tier, spec] of Object.entries(subagents)) {
+        assertSpecResolvable(spec, providers, pools, `routing.subagents.${tier}`);
+    }
+    assertRungsResolvable(routing.ladder ?? [], providers, pools, "routing.ladder");
+    for (const [tier, tierLadder] of Object.entries(routing.ladders ?? {})) {
+        assertRungsResolvable(tierLadder, providers, pools, `routing.ladders.${tier}`);
+    }
+}
 //# sourceMappingURL=routing-parser.js.map