llm-cli-gateway 2.15.0 → 2.17.0

package/dist/compressor/transforms/json.js

@@ -0,0 +1,156 @@
+const WS = new Set([" ", "\t", "\n", "\r"]);
+function skipWs(c) {
+    while (c.pos < c.text.length && WS.has(c.text[c.pos]))
+        c.pos += 1;
+}
+function fail() {
+    throw new SyntaxError("json-minify: not valid JSON");
+}
+const SIMPLE_ESCAPES = new Set(['"', "\\", "/", "b", "f", "n", "r", "t"]);
+const HEX = /^[0-9a-fA-F]{4}$/;
+function copyString(c) {
+    const start = c.pos;
+    if (c.text[c.pos] !== '"')
+        fail();
+    c.pos += 1;
+    while (c.pos < c.text.length) {
+        const ch = c.text[c.pos];
+        if (ch === "\\") {
+            const esc = c.text[c.pos + 1];
+            if (esc === undefined)
+                fail();
+            if (esc === "u") {
+                if (!HEX.test(c.text.slice(c.pos + 2, c.pos + 6)))
+                    fail();
+                c.pos += 6;
+                continue;
+            }
+            if (!SIMPLE_ESCAPES.has(esc))
+                fail();
+            c.pos += 2;
+            continue;
+        }
+        if (ch === '"') {
+            c.pos += 1;
+            c.out.push(c.text.slice(start, c.pos));
+            return;
+        }
+        if (ch.charCodeAt(0) < 0x20)
+            fail();
+        c.pos += 1;
+    }
+    fail();
+}
+const NUMBER = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/;
+function copyNumber(c) {
+    const match = NUMBER.exec(c.text.slice(c.pos));
+    if (!match || match[0].length === 0)
+        fail();
+    c.out.push(match[0]);
+    c.pos += match[0].length;
+}
+function copyLiteral(c, word) {
+    if (c.text.startsWith(word, c.pos)) {
+        c.out.push(word);
+        c.pos += word.length;
+        return;
+    }
+    fail();
+}
+function copyValue(c) {
+    skipWs(c);
+    const ch = c.text[c.pos];
+    if (ch === undefined)
+        fail();
+    if (ch === "{") {
+        c.out.push("{");
+        c.pos += 1;
+        skipWs(c);
+        if (c.text[c.pos] === "}") {
+            c.out.push("}");
+            c.pos += 1;
+            return;
+        }
+        for (;;) {
+            skipWs(c);
+            copyString(c);
+            skipWs(c);
+            if (c.text[c.pos] !== ":")
+                fail();
+            c.out.push(":");
+            c.pos += 1;
+            copyValue(c);
+            skipWs(c);
+            if (c.text[c.pos] === ",") {
+                c.out.push(",");
+                c.pos += 1;
+                continue;
+            }
+            if (c.text[c.pos] === "}") {
+                c.out.push("}");
+                c.pos += 1;
+                return;
+            }
+            fail();
+        }
+    }
+    if (ch === "[") {
+        c.out.push("[");
+        c.pos += 1;
+        skipWs(c);
+        if (c.text[c.pos] === "]") {
+            c.out.push("]");
+            c.pos += 1;
+            return;
+        }
+        for (;;) {
+            copyValue(c);
+            skipWs(c);
+            if (c.text[c.pos] === ",") {
+                c.out.push(",");
+                c.pos += 1;
+                continue;
+            }
+            if (c.text[c.pos] === "]") {
+                c.out.push("]");
+                c.pos += 1;
+                return;
+            }
+            fail();
+        }
+    }
+    if (ch === '"') {
+        copyString(c);
+        return;
+    }
+    if (ch === "t") {
+        copyLiteral(c, "true");
+        return;
+    }
+    if (ch === "f") {
+        copyLiteral(c, "false");
+        return;
+    }
+    if (ch === "n") {
+        copyLiteral(c, "null");
+        return;
+    }
+    if (ch === "-" || (ch >= "0" && ch <= "9")) {
+        copyNumber(c);
+        return;
+    }
+    fail();
+}
+export function minifyJson(text) {
+    const c = { text, pos: 0, out: [] };
+    try {
+        copyValue(c);
+        skipWs(c);
+        if (c.pos !== text.length)
+            return null;
+        return c.out.join("");
+    }
+    catch {
+        return null;
+    }
+}

package/dist/compressor/transforms/log.d.ts

@@ -0,0 +1,12 @@
+export declare const SENTINEL_PREFIX = "[[gateway-";
+export declare const LIT_MARKER = "[[gateway-lit:v1]] ";
+export declare function repeatMarker(lines: number, count: number): string;
+export declare function crMarker(frames: number): string;
+export declare function noteLine(folded: number, escaped: number): string;
+export interface MarkerCounts {
+    folded: number;
+    escaped: number;
+}
+export declare function escapeSentinelLikeLines(text: string, counts: MarkerCounts): string;
+export declare const MIN_RUN = 3;
+export declare function dedupAdjacentLines(text: string, counts: MarkerCounts): string;

package/dist/compressor/transforms/log.js

@@ -0,0 +1,55 @@
+import { mapUnfenced } from "./whitespace.js";
+export const SENTINEL_PREFIX = "[[gateway-";
+export const LIT_MARKER = "[[gateway-lit:v1]] ";
+export function repeatMarker(lines, count) {
+    return `[[gateway-repeat:v1 lines=${lines} count=${count}]]`;
+}
+export function crMarker(frames) {
+    return `[[gateway-cr:v1 frames=${frames}]]`;
+}
+export function noteLine(folded, escaped) {
+    return (`[[gateway-note:v1 folded=${folded} escaped=${escaped}]] ` +
+        "Gateway compressor markers follow: [[gateway-repeat:v1 ...]] folds byte-identical repeated lines (count included), " +
+        "[[gateway-cr:v1 ...]] keeps the final frame of carriage-return-rewritten lines, " +
+        "and lines opening with [[gateway-lit:v1]] are verbatim input with that prefix added.");
+}
+export function escapeSentinelLikeLines(text, counts) {
+    return mapUnfenced(text, segment => segment
+        .split("\n")
+        .map(line => {
+        if (line.trimStart().startsWith(SENTINEL_PREFIX)) {
+            counts.escaped += 1;
+            return LIT_MARKER + line;
+        }
+        return line;
+    })
+        .join("\n"));
+}
+export const MIN_RUN = 3;
+export function dedupAdjacentLines(text, counts) {
+    return mapUnfenced(text, segment => {
+        const lines = segment.split("\n");
+        const out = [];
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            let runEnd = i + 1;
+            if (line.trim() !== "") {
+                while (runEnd < lines.length && lines[runEnd] === line)
+                    runEnd += 1;
+            }
+            const runLength = runEnd - i;
+            if (runLength >= MIN_RUN) {
+                out.push(line);
+                out.push(repeatMarker(1, runLength));
+                counts.folded += 1;
+            }
+            else {
+                for (let j = i; j < runEnd; j += 1)
+                    out.push(lines[j]);
+            }
+            i = runEnd;
+        }
+        return out.join("\n");
+    });
+}

package/dist/compressor/transforms/whitespace.d.ts

@@ -0,0 +1,8 @@
+export interface FenceSegment {
+    text: string;
+    fenced: boolean;
+}
+export declare function splitFences(text: string): FenceSegment[];
+export declare function joinFences(segments: FenceSegment[]): string;
+export declare function mapUnfenced(text: string, op: (segment: string) => string): string;
+export declare function normalizeWhitespace(text: string): string;

package/dist/compressor/transforms/whitespace.js

@@ -0,0 +1,79 @@
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+export function splitFences(text) {
+    const segments = [];
+    const lines = text.split("\n");
+    let current = [];
+    let fenced = false;
+    let fenceMarker = "";
+    const flush = (nextFenced) => {
+        if (current.length > 0) {
+            segments.push({ text: current.join("\n"), fenced });
+            current = [];
+        }
+        fenced = nextFenced;
+    };
+    for (const line of lines) {
+        if (!fenced) {
+            const open = FENCE_OPEN.exec(line);
+            if (open) {
+                flush(true);
+                fenceMarker = open[1];
+                current.push(line);
+                continue;
+            }
+            current.push(line);
+        }
+        else {
+            current.push(line);
+            const marker = FENCE_OPEN.exec(line);
+            if (marker &&
+                marker[1][0] === fenceMarker[0] &&
+                marker[1].length >= fenceMarker.length &&
+                line.trim() === marker[1]) {
+                flush(false);
+            }
+        }
+    }
+    flush(false);
+    return segments;
+}
+export function joinFences(segments) {
+    return segments.map(s => s.text).join("\n");
+}
+export function mapUnfenced(text, op) {
+    const segments = splitFences(text);
+    return joinFences(segments.map(s => (s.fenced ? s : { ...s, text: op(s.text) })));
+}
+export function normalizeWhitespace(text) {
+    return mapUnfenced(text, segment => {
+        const lines = segment.split("\n").map(line => {
+            if (line.includes("`"))
+                return line;
+            const crlf = line.endsWith("\r");
+            const body = crlf ? line.slice(0, -1) : line;
+            const stripped = body.replace(/[ \t]+$/, "");
+            return crlf ? `${stripped}\r` : stripped;
+        });
+        const out = [];
+        let blankRun = 0;
+        const collapse = () => {
+            if (blankRun < 3)
+                return;
+            const keep = out[out.length - blankRun];
+            out.splice(out.length - blankRun, blankRun, keep);
+        };
+        for (const line of lines) {
+            const isBlank = line === "" || line === "\r";
+            if (isBlank) {
+                blankRun += 1;
+                out.push(line);
+                continue;
+            }
+            collapse();
+            blankRun = 0;
+            out.push(line);
+        }
+        collapse();
+        return out.join("\n");
+    });
+}

package/dist/config.d.ts

@@ -1,6 +1,7 @@
 import type { Logger } from "./logger.js";
 import type { RemoteOAuthConfig } from "./auth.js";
 import type { ApiProviderKind } from "./api-provider.js";
+import type { QualityTier } from "./least-cost-types.js";
 export interface DatabaseConfig {
     connectionString: string;
     pool: {
@@ -111,6 +112,44 @@ export interface CacheAwarenessConfig {
     };
 }
 export declare function loadCacheAwarenessConfig(logger?: Logger): CacheAwarenessConfig;
+export interface CompressionConfig {
+    enabled: boolean;
+    sources: {
+        configFile: string | null;
+    };
+}
+export declare const DEFAULT_COMPRESSION_CONFIG: CompressionConfig;
+export declare function loadCompressionConfig(logger?: Logger): CompressionConfig;
+export declare const LEAST_COST_PRIORS_SCOPES: readonly ["global", "principal", "off"];
+export type LeastCostPriorsScope = (typeof LEAST_COST_PRIORS_SCOPES)[number];
+export declare const DEFAULT_LEAST_COST_MAX_COST_USD = 0.5;
+export declare const DEFAULT_LEAST_COST_EXPECTED_OUTPUT_TOKENS = 800;
+export declare const DEFAULT_LEAST_COST_BUDGET_SAFETY_FACTOR = 1.5;
+export declare const DEFAULT_LEAST_COST_MAX_REROUTES = 2;
+export declare const DEFAULT_LEAST_COST_TIERS: Readonly<Record<string, QualityTier>>;
+export interface LeastCostConfig {
+    enabled: boolean;
+    minTier: QualityTier;
+    maxCostUsd: number;
+    defaultExpectedOutputTokens: number;
+    budgetOutputSafetyFactor: number;
+    priorsScope: LeastCostPriorsScope;
+    allowUnpriced: boolean;
+    maxReroutes: number;
+    preferCatalogPrice: boolean;
+    preferenceOrder: string[];
+    tiers: Record<string, QualityTier>;
+    candidates: {
+        allow: string[];
+        deny: string[];
+    };
+    sources: {
+        configFile: string | null;
+        envOverrides: string[];
+    };
+}
+export declare function defaultLeastCostConfig(sourcePath?: string | null): LeastCostConfig;
+export declare function loadLeastCostConfig(logger?: Logger): LeastCostConfig;
 export declare function minStableTokensForModel(config: CacheAwarenessConfig, modelName: string): number;
 export declare const DEFAULT_XAI_API_KEY_ENV = "XAI_API_KEY";
 export declare const DEFAULT_XAI_BASE_URL = "https://api.x.ai/v1";

package/dist/config.js

@@ -33,7 +33,7 @@ export function loadConfig() {
         DatabaseUrlSchema.parse(databaseUrl);
     }
     catch (error) {
-        throw new Error(`Invalid database URL: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Invalid database URL: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
     return {
         database: {
@@ -87,6 +87,13 @@ const PersistenceSchema = z
             message: `httpJobGraceMs (${cfg.httpJobGraceMs}) must be >= instanceLeaseTtlMs (${cfg.instanceLeaseTtlMs})`,
         });
     }
+    if (cfg.instanceGcMs < cfg.instanceLeaseTtlMs) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["instanceGcMs"],
+            message: `instanceGcMs (${cfg.instanceGcMs}) must be >= instanceLeaseTtlMs (${cfg.instanceLeaseTtlMs})`,
+        });
+    }
 });
 const DEFAULT_SQLITE_PATH = path.join(os.homedir(), ".llm-cli-gateway", "logs.db");
 function defaultPersistenceConfigPath() {
@@ -108,7 +115,9 @@ export function loadSkillsConfig(logger = noopLogger) {
         skillsParsed = SkillsSchema.parse(rawSkills);
     }
     catch (err) {
-        throw new Error(`Invalid [skills] config: ${err instanceof Error ? err.message : String(err)}`);
+        throw new Error(`Invalid [skills] config: ${err instanceof Error ? err.message : String(err)}`, {
+            cause: err,
+        });
     }
     const paths = [...skillsParsed.paths];
     const envPaths = process.env.LLM_GATEWAY_SKILLS_PATH;
@@ -220,7 +229,7 @@ export function loadPersistenceConfig(logger = noopLogger) {
         parsed = PersistenceSchema.parse(merged);
     }
     catch (err) {
-        throw new Error(`Invalid [persistence] config: ${err instanceof Error ? err.message : String(err)}`);
+        throw new Error(`Invalid [persistence] config: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
     const backend = parsed.backend;
     const resolvedPath = backend === "sqlite" ? expandHome(parsed.path ?? DEFAULT_SQLITE_PATH) : null;
@@ -315,14 +324,16 @@ export function loadLimitsConfig(logger = noopLogger) {
         httpParsed = HttpSessionLimitsSchema.parse(rawHttp);
     }
     catch (err) {
-        throw new Error(`Invalid [http] session-limit config: ${err instanceof Error ? err.message : String(err)}`);
+        throw new Error(`Invalid [http] session-limit config: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
     let limitsParsed;
     try {
         limitsParsed = JobLimitsSchema.parse(rawLimits);
     }
     catch (err) {
-        throw new Error(`Invalid [limits] config: ${err instanceof Error ? err.message : String(err)}`);
+        throw new Error(`Invalid [limits] config: ${err instanceof Error ? err.message : String(err)}`, {
+            cause: err,
+        });
     }
     return {
         http: {
@@ -398,7 +409,7 @@ export function loadCacheAwarenessConfig(logger = noopLogger) {
         parsed = CacheAwarenessSchema.parse(raw ?? {});
     }
     catch (err) {
-        throw new Error(`Invalid [cache_awareness] config: ${err instanceof Error ? err.message : String(err)}`);
+        throw new Error(`Invalid [cache_awareness] config: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
     }
     return {
         emitAnthropicCacheControl: parsed.emit_anthropic_cache_control,
@@ -413,6 +424,155 @@ export function loadCacheAwarenessConfig(logger = noopLogger) {
         sources: { configFile: sourcePath },
     };
 }
+const CompressionSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+})
+    .strict();
+export const DEFAULT_COMPRESSION_CONFIG = {
+    enabled: false,
+    sources: { configFile: null },
+};
+export function loadCompressionConfig(logger = noopLogger) {
+    const configPath = defaultGatewayConfigPath();
+    const { parsed, sourcePath } = readGatewayTomlFile(configPath, logger, "compression");
+    const raw = parsed?.compression ?? {};
+    let parsedCompression;
+    try {
+        parsedCompression = CompressionSchema.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Invalid [compression] config: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+    return {
+        enabled: parsedCompression.enabled,
+        sources: { configFile: sourcePath },
+    };
+}
+export const LEAST_COST_PRIORS_SCOPES = ["global", "principal", "off"];
+export const DEFAULT_LEAST_COST_MAX_COST_USD = 0.5;
+export const DEFAULT_LEAST_COST_EXPECTED_OUTPUT_TOKENS = 800;
+export const DEFAULT_LEAST_COST_BUDGET_SAFETY_FACTOR = 1.5;
+export const DEFAULT_LEAST_COST_MAX_REROUTES = 2;
+export const DEFAULT_LEAST_COST_TIERS = {
+    "claude:claude-haiku": "economy",
+    "claude:claude-sonnet": "standard",
+    "claude:claude-opus": "frontier",
+    "codex:openai-gpt5": "standard",
+    "gemini:gemini-2.5-flash": "economy",
+    "gemini:gemini-2.5-pro": "standard",
+    "gemini:gemini-3-pro": "frontier",
+    "grok:grok-build": "economy",
+    "grok:grok-4": "standard",
+    "mistral:mistral-devstral": "economy",
+    "mistral:mistral-medium": "standard",
+};
+const QualityTierSchema = z.enum(["economy", "standard", "frontier"]);
+const LeastCostCandidatesSchema = z
+    .object({
+    allow: z.array(z.string().min(1)).default([]),
+    deny: z.array(z.string().min(1)).default([]),
+})
+    .strict()
+    .default({ allow: [], deny: [] });
+const LeastCostSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+    min_tier: QualityTierSchema.default("standard"),
+    max_cost_usd: z.number().positive().default(DEFAULT_LEAST_COST_MAX_COST_USD),
+    default_expected_output_tokens: z
+        .number()
+        .int()
+        .positive()
+        .default(DEFAULT_LEAST_COST_EXPECTED_OUTPUT_TOKENS),
+    budget_output_safety_factor: z
+        .number()
+        .positive()
+        .default(DEFAULT_LEAST_COST_BUDGET_SAFETY_FACTOR),
+    priors_scope: z.enum(LEAST_COST_PRIORS_SCOPES).default("global"),
+    allow_unpriced: z.boolean().default(false),
+    max_reroutes: z.number().int().nonnegative().default(DEFAULT_LEAST_COST_MAX_REROUTES),
+    prefer_catalog_price: z.boolean().default(true),
+    preference_order: z.array(z.string().min(1)).default([]),
+    tiers: z.record(z.string(), QualityTierSchema).default({}),
+    candidates: LeastCostCandidatesSchema,
+})
+    .strict();
+export function defaultLeastCostConfig(sourcePath = null) {
+    return {
+        enabled: false,
+        minTier: "standard",
+        maxCostUsd: DEFAULT_LEAST_COST_MAX_COST_USD,
+        defaultExpectedOutputTokens: DEFAULT_LEAST_COST_EXPECTED_OUTPUT_TOKENS,
+        budgetOutputSafetyFactor: DEFAULT_LEAST_COST_BUDGET_SAFETY_FACTOR,
+        priorsScope: "global",
+        allowUnpriced: false,
+        maxReroutes: DEFAULT_LEAST_COST_MAX_REROUTES,
+        preferCatalogPrice: true,
+        preferenceOrder: [],
+        tiers: { ...DEFAULT_LEAST_COST_TIERS },
+        candidates: { allow: [], deny: [] },
+        sources: { configFile: sourcePath, envOverrides: [] },
+    };
+}
+function readLeastCostFile(configPath, logger) {
+    if (!existsSync(configPath)) {
+        return { raw: undefined, sourcePath: null };
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const TOML = require("smol-toml");
+        const text = readFileSync(configPath, "utf-8");
+        const parsed = TOML.parse(text);
+        return { raw: parsed?.least_cost, sourcePath: configPath };
+    }
+    catch (err) {
+        logger.error(`Failed to parse gateway config at ${configPath}; using least_cost defaults`, err);
+        return { raw: undefined, sourcePath: null };
+    }
+}
+export function loadLeastCostConfig(logger = noopLogger) {
+    const configPath = defaultGatewayConfigPath();
+    const { raw, sourcePath } = readLeastCostFile(configPath, logger);
+    const envOverrides = [];
+    const envSentinel = process.env.LLM_GATEWAY_LEAST_COST;
+    if (envSentinel !== undefined && envSentinel.length > 0) {
+        envOverrides.push("LLM_GATEWAY_LEAST_COST");
+        logWarn(logger, "LLM_GATEWAY_LEAST_COST is not supported and is ignored; configure [least_cost] in " +
+            "~/.llm-cli-gateway/config.toml (routing cannot be enabled via an environment variable).");
+    }
+    if (raw === undefined) {
+        const cfg = defaultLeastCostConfig(sourcePath);
+        cfg.sources.envOverrides = envOverrides;
+        return cfg;
+    }
+    let parsed;
+    try {
+        parsed = LeastCostSchema.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Invalid [least_cost] config: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    }
+    const tiers = { ...DEFAULT_LEAST_COST_TIERS, ...parsed.tiers };
+    return {
+        enabled: parsed.enabled,
+        minTier: parsed.min_tier,
+        maxCostUsd: parsed.max_cost_usd,
+        defaultExpectedOutputTokens: parsed.default_expected_output_tokens,
+        budgetOutputSafetyFactor: parsed.budget_output_safety_factor,
+        priorsScope: parsed.priors_scope,
+        allowUnpriced: parsed.allow_unpriced,
+        maxReroutes: parsed.max_reroutes,
+        preferCatalogPrice: parsed.prefer_catalog_price,
+        preferenceOrder: [...parsed.preference_order],
+        tiers,
+        candidates: {
+            allow: [...parsed.candidates.allow],
+            deny: [...parsed.candidates.deny],
+        },
+        sources: { configFile: sourcePath, envOverrides },
+    };
+}
 export function minStableTokensForModel(config, modelName) {
     const lower = modelName.toLowerCase();
     const table = config.minStableTokensForCacheControl;

package/dist/db.js

@@ -28,7 +28,7 @@ export class DatabaseConnection {
         }
         catch (error) {
             this.logger.error("Failed to connect to PostgreSQL", { error });
-            throw new Error(`Failed to connect to PostgreSQL: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Failed to connect to PostgreSQL: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
         }
     }
     async disconnect() {
@@ -40,7 +40,7 @@ export class DatabaseConnection {
                 this.pool = null;
             }
             catch (error) {
-                errors.push(new Error(`PostgreSQL disconnect error: ${error instanceof Error ? error.message : String(error)}`));
+                errors.push(new Error(`PostgreSQL disconnect error: ${error instanceof Error ? error.message : String(error)}`, { cause: error }));
             }
         }
         if (errors.length > 0) {
@@ -60,7 +60,7 @@ export class DatabaseConnection {
                 result.postgres.connected = true;
                 result.postgres.latency = Date.now() - pgStart;
             }
-            catch (error) {
+            catch {
                 result.postgres.connected = false;
             }
             finally {
@@ -87,7 +87,7 @@ async function importOptionalPg() {
     }
     catch (error) {
         if (error?.code === "ERR_MODULE_NOT_FOUND" || error?.code === "MODULE_NOT_FOUND") {
-            throw new Error("PostgreSQL sessions require optional peer dependency 'pg'. Install it alongside llm-cli-gateway to use DATABASE_URL-backed sessions.");
+            throw new Error("PostgreSQL sessions require optional peer dependency 'pg'. Install it alongside llm-cli-gateway to use DATABASE_URL-backed sessions.", { cause: error });
         }
         throw error;
     }

package/dist/doctor.d.ts

@@ -2,7 +2,9 @@ import { type EndpointExposureReport } from "./endpoint-exposure.js";
 import { type ProviderLoginStatus } from "./provider-status.js";
 import { type ApiProviderLoginGuidance } from "./provider-login-guidance.js";
 import type { FlightRecorderQuery } from "./flight-recorder.js";
-import { type CacheAwarenessConfig, type ProvidersConfig, type RemoteOAuthConfigDiagnostics } from "./config.js";
+import { type CacheAwarenessConfig, type LeastCostConfig, type ProvidersConfig, type RemoteOAuthConfigDiagnostics } from "./config.js";
+import { type TelemetryTier } from "./lcr-telemetry.js";
+import type { Confidence, PriceSource, QualityTier } from "./least-cost-types.js";
 import type { AuthConfig } from "./auth.js";
 import { type RemoteSafeWorkspaceSummary } from "./workspace-registry.js";
 import { type ProviderCapabilityId, type ProviderKind } from "./provider-tool-capabilities.js";
@@ -79,6 +81,35 @@ export interface GeminiConfigStatus {
 }
 export declare function checkVibeSessionLogging(home?: string): VibeSessionLoggingStatus;
 export declare function checkGeminiConfig(cwd?: string, home?: string, whitelist?: readonly string[]): GeminiConfigStatus;
+export interface LeastCostCandidateReport {
+    model: string;
+    family: string;
+    priced: boolean;
+    priceSource: PriceSource;
+    tier: QualityTier | null;
+}
+export interface LeastCostProviderReport {
+    provider: CliType;
+    telemetryTier: TelemetryTier;
+    candidates: LeastCostCandidateReport[];
+}
+export interface LeastCostCalibrationBucketReport {
+    bucket: string;
+    k: number;
+    samples: number;
+    confidence: Confidence;
+}
+export interface LeastCostReport {
+    enabled: boolean;
+    pricing: {
+        tableAsOf: string;
+        apiCatalogAsOf: string;
+        staleDays: number;
+    };
+    providers: LeastCostProviderReport[];
+    untieredModels: string[];
+    calibrationQuality: LeastCostCalibrationBucketReport[];
+}
 export interface DoctorReport {
     schema_version: "1.0";
     ok: boolean;
@@ -158,6 +189,7 @@ export interface DoctorReport {
     };
     cache_awareness: CacheAwarenessReport;
     provider_capabilities: ProviderCapabilitySummaryReport;
+    least_cost: LeastCostReport;
     api_providers?: ApiProviderHealthReport;
     upstream: {
         note: string;
@@ -215,6 +247,7 @@ export interface CreateDoctorReportOptions {
         reachable: boolean;
         error?: string;
     }>;
+    leastCost?: LeastCostConfig;
 }
 export declare function createDoctorReport(envOrOptions?: NodeJS.ProcessEnv | CreateDoctorReportOptions): DoctorReport;
 export declare function printDoctorJson(opts?: {