llm-cli-gateway 2.16.0 → 2.17.0

package/dist/job-store.d.ts

@@ -280,15 +280,23 @@ export declare class MemoryJobStore implements JobStore {
 export declare class PostgresJobStore implements JobStore, ValidationRunStore {
     private logger;
     private worker;
-    private tmpDir;
-    private nextRequestId;
+    private retiringWorker;
+    private readonly intentionallyRetiredWorkers;
+    private workerTerminationPending;
     private closed;
+    private readonly workerData;
     constructor(dsn: string, logger?: Logger, options?: {
         retentionMs?: number;
         dedupWindowMs?: number;
         leaseTtlMs?: number;
     });
+    private createWorker;
     private syncCall;
+    private ensureWorker;
+    private callWorker;
+    private retireAfterBridgeFailure;
+    private retireWorker;
+    private markWorkerRetired;
     recordStart(input: {
         id: string;
         correlationId: string;

package/dist/job-store.js

@@ -1,8 +1,8 @@
-import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { chmodSync, existsSync } from "fs";
 import os from "os";
 import path from "path";
 import { createHash } from "crypto";
-import { Worker } from "worker_threads";
+import { MessageChannel, receiveMessageOnPort, Worker } from "worker_threads";
 import { fileURLToPath } from "url";
 import { openDatabase } from "./sqlite-driver.js";
 import { noopLogger } from "./logger.js";
@@ -30,6 +30,8 @@ export function resolveJobRetentionMs() {
     return days * 24 * 60 * 60 * 1000;
 }
 const DEFAULT_DEDUP_WINDOW_MS = 60 * 60 * 1000;
+const POSTGRES_WORKER_OPERATION_TIMEOUT_MS = 35_000;
+const POSTGRES_WORKER_INITIALIZATION_TIMEOUT_MS = 45_000;
 export function resolveDedupWindowMs() {
     const raw = process.env.LLM_GATEWAY_DEDUP_WINDOW_MS;
     if (raw === undefined)
@@ -757,66 +759,153 @@ export class MemoryJobStore {
 }
 export class PostgresJobStore {
     logger;
-    worker;
-    tmpDir;
-    nextRequestId = 0;
+    worker = null;
+    retiringWorker = null;
+    intentionallyRetiredWorkers = new WeakSet();
+    workerTerminationPending = false;
     closed = false;
+    workerData;
     constructor(dsn, logger = noopLogger, options = {}) {
         this.logger = logger;
         if (!dsn) {
             throw new Error("PostgresJobStore requires a non-empty DSN");
         }
-        this.tmpDir = mkdtempSync(path.join(os.tmpdir(), "llm-gateway-pg-job-store-"));
-        this.worker = new Worker(resolvePostgresWorkerUrl(), {
-            execArgv: [],
-            workerData: {
-                dsn,
-                retentionMs: options.retentionMs ?? resolveJobRetentionMs(),
-                dedupWindowMs: options.dedupWindowMs ?? resolveDedupWindowMs(),
-                leaseTtlMs: options.leaseTtlMs ?? DEFAULT_INSTANCE_LEASE_TTL_MS,
-                farFutureIso: FAR_FUTURE_ISO,
-                connectionTimeoutMillis: 5000,
-            },
-        });
+        this.workerData = {
+            dsn,
+            retentionMs: options.retentionMs ?? resolveJobRetentionMs(),
+            dedupWindowMs: options.dedupWindowMs ?? resolveDedupWindowMs(),
+            leaseTtlMs: options.leaseTtlMs ?? DEFAULT_INSTANCE_LEASE_TTL_MS,
+            farFutureIso: FAR_FUTURE_ISO,
+            connectionTimeoutMillis: 5000,
+        };
         try {
-            this.syncCall("init");
+            this.ensureWorker();
         }
         catch (err) {
             this.closed = true;
-            void this.worker.terminate();
-            rmSync(this.tmpDir, { recursive: true, force: true });
+            this.retireWorker(this.worker);
             throw err;
         }
     }
+    createWorker() {
+        const worker = new Worker(resolvePostgresWorkerUrl(), {
+            execArgv: [],
+            workerData: this.workerData,
+        });
+        worker.on("message", message => {
+            if (!isPostgresWorkerDiagnostic(message))
+                return;
+            const error = new Error(message.message);
+            if (message.stack)
+                error.stack = message.stack;
+            this.logger.error(`PostgresJobStore worker ${message.kind}`, error);
+        });
+        worker.on("error", error => {
+            this.logger.error("PostgresJobStore worker crashed", error);
+            if (!this.closed && this.worker === worker)
+                this.retireWorker(worker);
+        });
+        worker.on("exit", code => {
+            const wasRetiring = this.retiringWorker === worker || this.intentionallyRetiredWorkers.has(worker);
+            if (this.worker === worker)
+                this.worker = null;
+            if (wasRetiring)
+                this.markWorkerRetired(worker);
+            if (this.closed || wasRetiring || code === 0)
+                return;
+            this.logger.error("PostgresJobStore worker exited unexpectedly", new Error(`PostgresJobStore worker exited with code ${code}`));
+        });
+        return worker;
+    }
     syncCall(method, ...args) {
-        if (this.closed && method !== "close") {
+        if (this.closed) {
             throw new Error("PostgresJobStore is closed");
         }
-        const shared = new SharedArrayBuffer(4);
-        const state = new Int32Array(shared);
-        const resultPath = path.join(this.tmpDir, `result-${process.pid}-${++this.nextRequestId}.json`);
-        this.worker.postMessage({ method, args, resultPath, shared });
-        const wait = Atomics.wait(state, 0, 0, method === "init" ? 10_000 : 30_000);
-        if (wait !== "ok" && wait !== "not-equal") {
-            throw new Error(`PostgresJobStore ${method} wait failed: ${wait}`);
+        const worker = this.ensureWorker();
+        return this.callWorker(worker, method, args);
+    }
+    ensureWorker() {
+        if (this.closed)
+            throw new Error("PostgresJobStore is closed");
+        if (this.worker)
+            return this.worker;
+        if (this.workerTerminationPending) {
+            throw new Error("PostgresJobStore is waiting for a failed worker to terminate before it can recover");
         }
-        if (Atomics.load(state, 0) === 2) {
-            throw new Error(`PostgresJobStore ${method} worker could not write its result`);
+        const worker = this.createWorker();
+        this.worker = worker;
+        try {
+            this.callWorker(worker, "init", []);
+            return worker;
         }
-        let payload;
+        catch (err) {
+            this.retireWorker(worker);
+            throw err;
+        }
+    }
+    callWorker(worker, method, args) {
+        const shared = new SharedArrayBuffer(4);
+        const state = new Int32Array(shared);
+        const { port1: workerPort, port2: responsePort } = new MessageChannel();
         try {
-            payload = JSON.parse(readFileSync(resultPath, "utf8"));
+            try {
+                worker.postMessage({ method, args, shared, responsePort: workerPort }, [workerPort]);
+            }
+            catch (err) {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} could not dispatch work to its worker`, err);
+            }
+            const timeoutMs = method === "init"
+                ? POSTGRES_WORKER_INITIALIZATION_TIMEOUT_MS
+                : POSTGRES_WORKER_OPERATION_TIMEOUT_MS;
+            const wait = Atomics.wait(state, 0, 0, timeoutMs);
+            if (wait === "timed-out") {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} timed out after ${timeoutMs}ms; the operation outcome is unknown`);
+            }
+            if (wait !== "ok" && wait !== "not-equal") {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} wait failed: ${wait}`);
+            }
+            if (Atomics.load(state, 0) !== 1) {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} worker response transport failed`);
+            }
+            const received = receiveMessageOnPort(responsePort);
+            if (!received || !isPostgresWorkerPayload(received.message)) {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} worker signalled without a valid response`);
+            }
+            const payload = received.message;
+            if (!payload.ok) {
+                const err = new Error(payload.error.message);
+                if (payload.error.stack)
+                    err.stack = payload.error.stack;
+                throw err;
+            }
+            return payload.value;
         }
         finally {
-            rmSync(resultPath, { force: true });
+            responsePort.close();
         }
-        if (!payload.ok) {
-            const err = new Error(payload.error.message);
-            if (payload.error.stack)
-                err.stack = payload.error.stack;
-            throw err;
-        }
-        return payload.value;
+    }
+    retireAfterBridgeFailure(worker, message, cause) {
+        this.retireWorker(worker);
+        return cause === undefined ? new Error(message) : new Error(message, { cause });
+    }
+    retireWorker(worker) {
+        if (!worker || this.retiringWorker === worker)
+            return;
+        if (this.worker === worker)
+            this.worker = null;
+        this.retiringWorker = worker;
+        this.intentionallyRetiredWorkers.add(worker);
+        this.workerTerminationPending = true;
+        void worker.terminate().then(() => this.markWorkerRetired(worker), error => {
+            this.logger.error("PostgresJobStore worker termination failed", error);
+            this.markWorkerRetired(worker);
+        });
+    }
+    markWorkerRetired(worker) {
+        if (this.retiringWorker !== worker)
+            return;
+        this.retiringWorker = null;
+        this.workerTerminationPending = false;
     }
     recordStart(input) {
         this.syncCall("recordStart", input);
@@ -899,19 +988,41 @@ export class PostgresJobStore {
     close() {
         if (this.closed)
             return;
+        const worker = this.worker;
         try {
-            this.syncCall("close");
+            if (worker)
+                this.callWorker(worker, "close", []);
         }
         catch (err) {
             this.logger.error("PostgresJobStore close failed", err);
         }
         finally {
             this.closed = true;
-            void this.worker.terminate();
-            rmSync(this.tmpDir, { recursive: true, force: true });
+            this.retireWorker(worker);
         }
     }
 }
+function isPostgresWorkerPayload(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    if (candidate.ok === true)
+        return "value" in candidate;
+    if (!candidate.error || typeof candidate.error !== "object" || candidate.ok !== false)
+        return false;
+    const error = candidate.error;
+    return (typeof error.message === "string" &&
+        (error.stack === undefined || typeof error.stack === "string"));
+}
+function isPostgresWorkerDiagnostic(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (candidate.type === "postgres-job-store-diagnostic" &&
+        typeof candidate.kind === "string" &&
+        typeof candidate.message === "string" &&
+        (candidate.stack === undefined || typeof candidate.stack === "string"));
+}
 function resolvePostgresWorkerUrl() {
     const sibling = new URL("./postgres-job-store-worker.js", import.meta.url);
     if (existsSync(fileURLToPath(sibling)))

package/dist/lcr-priors.d.ts

@@ -0,0 +1,60 @@
+import type { FlightRecorderQuery } from "./flight-recorder.js";
+import type { Confidence } from "./least-cost-types.js";
+import type { ContentType } from "./token-estimator.js";
+export type PriorsScope = "global" | "principal" | "off";
+export declare const CALIBRATION_K_MIN_SAMPLES = 5;
+export declare const CONFIDENCE_HIGH_MIN_SAMPLES = 30;
+export declare const CONFIDENCE_HIGH_MAX_SPREAD = 1.5;
+export declare const CONFIDENCE_MEDIUM_MIN_SAMPLES = 10;
+export declare const CONFIDENCE_MEDIUM_MAX_SPREAD = 3;
+export interface LcrPriorRow {
+    provider: string;
+    model: string;
+    prompt: string;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheCreationTokens: number | null;
+    costUsd: number | null;
+    costBasis: string | null;
+    routeEstCostUsd: number | null;
+    ownerPrincipal: string | null;
+    sessionContinued: boolean;
+}
+export interface OutputPrior {
+    median: number;
+    p90: number;
+    samples: number;
+}
+export interface CalibrationBucket {
+    k: number;
+    samples: number;
+    p10: number;
+    p50: number;
+    p90: number;
+    confidence: Confidence;
+}
+export interface AccuracyBucket {
+    provider: string;
+    model: string;
+    costBasis: string;
+    medianAccuracy: number;
+    samples: number;
+    p10: number;
+    p50: number;
+    p90: number;
+}
+export interface LcrPriors {
+    outputPriors: Map<string, OutputPrior>;
+    calibration: Map<string, CalibrationBucket>;
+    accuracyByBasis: Map<string, AccuracyBucket>;
+}
+export interface ComputeLcrPriorsOptions {
+    priorsScope: PriorsScope;
+    ownerPrincipal?: string;
+}
+export declare function confidenceFromQuality(samples: number, p10: number, p90: number): Confidence;
+export declare function lookupCalibrationK(priors: LcrPriors, contentType: ContentType, family: string): number;
+export declare function computeLcrPriors(rows: LcrPriorRow[], opts: ComputeLcrPriorsOptions): LcrPriors;
+export declare function loadLcrPriorRows(db: FlightRecorderQuery): LcrPriorRow[];
+export declare function computeLcrPriorsFromDb(db: FlightRecorderQuery, opts: ComputeLcrPriorsOptions): LcrPriors;

package/dist/lcr-priors.js

@@ -0,0 +1,190 @@
+import { estimateInputTokens, classifyContent } from "./token-estimator.js";
+import { modelIdToFamily } from "./pricing.js";
+export const CALIBRATION_K_MIN_SAMPLES = 5;
+export const CONFIDENCE_HIGH_MIN_SAMPLES = 30;
+export const CONFIDENCE_HIGH_MAX_SPREAD = 1.5;
+export const CONFIDENCE_MEDIUM_MIN_SAMPLES = 10;
+export const CONFIDENCE_MEDIUM_MAX_SPREAD = 3.0;
+function isFiniteNumber(n) {
+    return typeof n === "number" && Number.isFinite(n);
+}
+function num(n) {
+    return isFiniteNumber(n) ? n : 0;
+}
+function percentile(sortedAsc, q) {
+    const n = sortedAsc.length;
+    if (n === 0)
+        return 0;
+    if (n === 1)
+        return sortedAsc[0];
+    const idx = (n - 1) * q;
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    const loVal = sortedAsc.at(lo) ?? 0;
+    const hiVal = sortedAsc.at(hi) ?? 0;
+    if (lo === hi)
+        return loVal;
+    return loVal + (hiVal - loVal) * (idx - lo);
+}
+const outputKey = (provider, model) => `${provider}:${model}`;
+const calibrationKey = (contentType, family) => `${contentType}:${family}`;
+const accuracyKey = (provider, model, costBasis) => `${provider}:${model}::${costBasis}`;
+function reconstructActualInput(row, family) {
+    const input = num(row.inputTokens);
+    if (family.startsWith("claude-")) {
+        return input + num(row.cacheReadTokens) + num(row.cacheCreationTokens);
+    }
+    return input;
+}
+export function confidenceFromQuality(samples, p10, p90) {
+    if (p10 <= 0)
+        return "low";
+    const spread = p90 / p10;
+    if (samples >= CONFIDENCE_HIGH_MIN_SAMPLES && spread <= CONFIDENCE_HIGH_MAX_SPREAD) {
+        return "high";
+    }
+    if (samples >= CONFIDENCE_MEDIUM_MIN_SAMPLES && spread <= CONFIDENCE_MEDIUM_MAX_SPREAD) {
+        return "medium";
+    }
+    return "low";
+}
+export function lookupCalibrationK(priors, contentType, family) {
+    const bucket = priors.calibration.get(calibrationKey(contentType, family));
+    if (!bucket)
+        return 1;
+    if (bucket.samples < CALIBRATION_K_MIN_SAMPLES)
+        return 1;
+    return bucket.k;
+}
+export function computeLcrPriors(rows, opts) {
+    const empty = {
+        outputPriors: new Map(),
+        calibration: new Map(),
+        accuracyByBasis: new Map(),
+    };
+    if (opts.priorsScope === "off")
+        return empty;
+    let scoped = rows;
+    if (opts.priorsScope === "principal") {
+        const owner = opts.ownerPrincipal;
+        if (owner === undefined)
+            return empty;
+        scoped = rows.filter(r => r.ownerPrincipal === owner);
+    }
+    const outputSamples = new Map();
+    const calibrationRatios = new Map();
+    const accuracyRatios = new Map();
+    for (const row of scoped) {
+        if (isFiniteNumber(row.outputTokens) && row.outputTokens >= 0) {
+            const key = outputKey(row.provider, row.model);
+            const arr = outputSamples.get(key) ?? [];
+            arr.push(row.outputTokens);
+            outputSamples.set(key, arr);
+        }
+        const family = modelIdToFamily(row.model);
+        if (family !== "unknown" && !row.sessionContinued && isFiniteNumber(row.inputTokens)) {
+            const base = estimateInputTokens(row.prompt, { family });
+            if (base > 0) {
+                const actual = reconstructActualInput(row, family);
+                const contentType = classifyContent(row.prompt);
+                const key = calibrationKey(contentType, family);
+                const arr = calibrationRatios.get(key) ?? [];
+                arr.push(actual / base);
+                calibrationRatios.set(key, arr);
+            }
+        }
+        if (isFiniteNumber(row.routeEstCostUsd) &&
+            isFiniteNumber(row.costUsd) &&
+            row.costUsd > 0 &&
+            row.costBasis) {
+            const key = accuracyKey(row.provider, row.model, row.costBasis);
+            const arr = accuracyRatios.get(key) ?? [];
+            arr.push(row.routeEstCostUsd / row.costUsd);
+            accuracyRatios.set(key, arr);
+        }
+    }
+    const outputPriors = new Map();
+    for (const [key, values] of outputSamples) {
+        values.sort((a, b) => a - b);
+        outputPriors.set(key, {
+            median: percentile(values, 0.5),
+            p90: percentile(values, 0.9),
+            samples: values.length,
+        });
+    }
+    const calibration = new Map();
+    for (const [key, values] of calibrationRatios) {
+        values.sort((a, b) => a - b);
+        const p10 = percentile(values, 0.1);
+        const p50 = percentile(values, 0.5);
+        const p90 = percentile(values, 0.9);
+        calibration.set(key, {
+            k: p50,
+            samples: values.length,
+            p10,
+            p50,
+            p90,
+            confidence: confidenceFromQuality(values.length, p10, p90),
+        });
+    }
+    const accuracyByBasis = new Map();
+    for (const [key, values] of accuracyRatios) {
+        values.sort((a, b) => a - b);
+        const sep = key.lastIndexOf("::");
+        const pm = key.slice(0, sep);
+        const costBasis = key.slice(sep + 2);
+        const colon = pm.indexOf(":");
+        const provider = pm.slice(0, colon);
+        const model = pm.slice(colon + 1);
+        accuracyByBasis.set(key, {
+            provider,
+            model,
+            costBasis,
+            medianAccuracy: percentile(values, 0.5),
+            samples: values.length,
+            p10: percentile(values, 0.1),
+            p50: percentile(values, 0.5),
+            p90: percentile(values, 0.9),
+        });
+    }
+    return { outputPriors, calibration, accuracyByBasis };
+}
+export function loadLcrPriorRows(db) {
+    const raw = db.queryRequests(`SELECT r.cli, r.model, r.prompt,
+            r.input_tokens, r.output_tokens,
+            r.cache_read_tokens, r.cache_creation_tokens,
+            r.cost_basis, r.owner_principal, r.session_id, r.datetime_utc,
+            m.cost_usd, m.route_est_cost_usd
+     FROM requests r
+     LEFT JOIN gateway_metadata m ON m.request_id = r.id
+     ORDER BY r.datetime_utc ASC`);
+    const seenMistralSessions = new Set();
+    return raw.map(row => {
+        let sessionContinued = false;
+        if (row.cli === "mistral" && row.session_id) {
+            if (seenMistralSessions.has(row.session_id)) {
+                sessionContinued = true;
+            }
+            else {
+                seenMistralSessions.add(row.session_id);
+            }
+        }
+        return {
+            provider: row.cli,
+            model: row.model,
+            prompt: row.prompt ?? "",
+            inputTokens: row.input_tokens,
+            outputTokens: row.output_tokens,
+            cacheReadTokens: row.cache_read_tokens,
+            cacheCreationTokens: row.cache_creation_tokens,
+            costUsd: row.cost_usd,
+            costBasis: row.cost_basis,
+            routeEstCostUsd: row.route_est_cost_usd,
+            ownerPrincipal: row.owner_principal,
+            sessionContinued,
+        };
+    });
+}
+export function computeLcrPriorsFromDb(db, opts) {
+    return computeLcrPriors(loadLcrPriorRows(db), opts);
+}

package/dist/lcr-router-env.d.ts

@@ -0,0 +1,20 @@
+import { type JobLimiterSnapshot } from "./async-job-manager.js";
+import { type LcrPriors, type PriorsScope } from "./lcr-priors.js";
+import type { FlightRecorderQuery } from "./flight-recorder.js";
+import type { PerformanceMetrics } from "./metrics.js";
+import type { ApiProviderRuntime, LeastCostConfig } from "./config.js";
+import type { RouterEnv, RouterConfig } from "./least-cost-router.js";
+export interface RouterEnvDeps {
+    performanceMetrics: PerformanceMetrics;
+    limiterSnapshot: JobLimiterSnapshot;
+    apiProviders: readonly ApiProviderRuntime[];
+    isAuthed?: (provider: string) => boolean;
+    preferCatalogPrice?: boolean;
+    flightRecorder?: FlightRecorderQuery;
+    priorsScope?: PriorsScope;
+    ownerPrincipal?: string;
+    priors?: LcrPriors;
+}
+export declare function resetLcrPriorsCacheForTest(): void;
+export declare function buildRouterEnv(deps: RouterEnvDeps): RouterEnv;
+export declare function toRouterConfig(cfg: LeastCostConfig): RouterConfig;

package/dist/lcr-router-env.js

@@ -0,0 +1,133 @@
+import { CLI_TYPES } from "./provider-types.js";
+import { getCliInfo } from "./model-registry.js";
+import { getProviderDefinition } from "./provider-definitions.js";
+import { cliBreakerState } from "./executor.js";
+import { apiProviderBreakerState } from "./api-provider.js";
+import { providerAtCapacity } from "./async-job-manager.js";
+import { getModelCost } from "./pricing.js";
+import { classifyContent } from "./token-estimator.js";
+import { computeLcrPriorsFromDb, lookupCalibrationK, } from "./lcr-priors.js";
+const CLI_TYPE_SET = new Set(CLI_TYPES);
+function isCliType(provider) {
+    return CLI_TYPE_SET.has(provider);
+}
+const API_PROVIDER_CAPABILITIES = {
+    acceptsImages: false,
+    acceptsAttachments: false,
+    toolCalling: true,
+    jsonSchema: true,
+    outputFormats: ["text", "json"],
+    capabilityScope: "full",
+    effortLevels: [],
+};
+const EMPTY_PRIORS = {
+    outputPriors: new Map(),
+    calibration: new Map(),
+    accuracyByBasis: new Map(),
+};
+const PRIORS_TTL_MS = 60_000;
+let priorsCacheEntry = null;
+function resolvePriors(deps) {
+    if (deps.priors)
+        return deps.priors;
+    const scope = deps.priorsScope ?? "global";
+    if (scope === "off" || !deps.flightRecorder)
+        return EMPTY_PRIORS;
+    const key = `${scope}:${deps.ownerPrincipal ?? ""}`;
+    const now = Date.now();
+    if (priorsCacheEntry &&
+        priorsCacheEntry.key === key &&
+        now - priorsCacheEntry.at < PRIORS_TTL_MS) {
+        return priorsCacheEntry.priors;
+    }
+    const priors = computeLcrPriorsFromDb(deps.flightRecorder, {
+        priorsScope: scope,
+        ownerPrincipal: deps.ownerPrincipal,
+    });
+    priorsCacheEntry = { at: now, key, priors };
+    return priors;
+}
+export function resetLcrPriorsCacheForTest() {
+    priorsCacheEntry = null;
+}
+function candidateCapabilities(provider) {
+    if (isCliType(provider)) {
+        const def = getProviderDefinition(provider);
+        return {
+            acceptsImages: def.requestSurface.acceptsImages,
+            acceptsAttachments: def.requestSurface.acceptsAttachments,
+            toolCalling: def.requestSurface.toolCalling,
+            jsonSchema: def.requestSurface.jsonSchema,
+            outputFormats: def.outputFormats,
+            capabilityScope: def.capabilityScope,
+            effortLevels: def.discovery.modelDiscovery.facts.effortLevels,
+        };
+    }
+    return API_PROVIDER_CAPABILITIES;
+}
+export function buildRouterEnv(deps) {
+    const apiProviderByName = new Map(deps.apiProviders.map(p => [p.name, p]));
+    const providerNames = [...CLI_TYPES, ...deps.apiProviders.map(p => p.name)];
+    const metricsByTool = deps.performanceMetrics.snapshot().byTool;
+    const priors = resolvePriors(deps);
+    const isAuthed = deps.isAuthed ??
+        ((provider) => {
+            return isCliType(provider) || apiProviderByName.has(provider);
+        });
+    return {
+        providers() {
+            return providerNames;
+        },
+        models(provider) {
+            if (isCliType(provider)) {
+                return Object.keys(getCliInfo()[provider].models);
+            }
+            const api = apiProviderByName.get(provider);
+            if (!api)
+                return [];
+            return api.models && api.models.length > 0 ? api.models : [api.defaultModel];
+        },
+        isAuthed,
+        breakerState(provider) {
+            return isCliType(provider) ? cliBreakerState(provider) : apiProviderBreakerState(provider);
+        },
+        atCapacity(provider) {
+            return providerAtCapacity(deps.limiterSnapshot, provider);
+        },
+        capabilities(provider) {
+            return candidateCapabilities(provider);
+        },
+        modelCost(provider, model) {
+            return getModelCost(provider, model, { preferCatalog: deps.preferCatalogPrice });
+        },
+        successRate(provider) {
+            return metricsByTool[provider]?.successRate ?? 0;
+        },
+        meanLatencyMs(provider) {
+            return metricsByTool[provider]?.averageResponseTimeMs ?? 0;
+        },
+        calibrationK(prompt, family) {
+            return lookupCalibrationK(priors, classifyContent(prompt), family);
+        },
+        outputPrior(provider, model) {
+            const p = priors.outputPriors.get(`${provider}:${model}`);
+            return p ? { median: p.median, p90: p.p90 } : null;
+        },
+        confidenceBand(prompt, family) {
+            const bucket = priors.calibration.get(`${classifyContent(prompt)}:${family}`);
+            return bucket?.confidence ?? "low";
+        },
+    };
+}
+export function toRouterConfig(cfg) {
+    return {
+        minTier: cfg.minTier,
+        maxCostUsd: cfg.maxCostUsd,
+        defaultExpectedOutputTokens: cfg.defaultExpectedOutputTokens,
+        budgetOutputSafetyFactor: cfg.budgetOutputSafetyFactor,
+        allowUnpriced: cfg.allowUnpriced,
+        tiers: cfg.tiers,
+        candidates: cfg.candidates,
+        preferenceOrder: cfg.preferenceOrder.length > 0 ? cfg.preferenceOrder : undefined,
+    };
+}