llm-cli-gateway 2.15.0 → 2.17.0

package/dist/doctor.js

@@ -7,7 +7,11 @@ import { createEndpointExposureReport, redactDiagnosticUrl, } from "./endpoint-e
 import { getApiProviderStatus, listProviderRuntimeStatuses, } from "./provider-status.js";
 import { getApiProviderLoginGuidance, } from "./provider-login-guidance.js";
 import { CLAUDE_MCP_SERVER_NAMES } from "./claude-mcp-config.js";
-import { diagnoseRemoteOAuthConfig, enabledApiProviders, loadCacheAwarenessConfig, loadProvidersConfig, } from "./config.js";
+import { defaultLeastCostConfig, diagnoseRemoteOAuthConfig, enabledApiProviders, loadCacheAwarenessConfig, loadLeastCostConfig, loadProvidersConfig, } from "./config.js";
+import { telemetryTierFor } from "./lcr-telemetry.js";
+import { API_CATALOG_AS_OF, PRICING_AS_OF, getModelCost, modelIdToFamily } from "./pricing.js";
+import { computeLcrPriorsFromDb } from "./lcr-priors.js";
+import { getCliInfo } from "./model-registry.js";
 import { loadWorkspaceRegistry, remoteSafeWorkspaceSummary, } from "./workspace-registry.js";
 import { buildRemoteConnectorUrls, resolveConfiguredRemoteOrigin } from "./remote-url.js";
 import { computeGlobalCacheStats } from "./cache-stats.js";
@@ -58,7 +62,7 @@ export function checkVibeSessionLogging(home = homedir()) {
 function parseVibeSessionLoggingEnabled(text) {
     const lines = text.split(/\r?\n/);
     let inSection = false;
-    for (let raw of lines) {
+    for (const raw of lines) {
         const line = raw.replace(/#.*$/, "").trim();
         if (!line)
             continue;
@@ -426,6 +430,70 @@ function buildCacheAwarenessReport(opts) {
         per_cli: perCli,
     };
 }
+const MS_PER_DAY = 86_400_000;
+function computePricingStaleDays(runIso) {
+    const run = Date.parse(runIso);
+    const table = Date.parse(PRICING_AS_OF);
+    const catalog = Date.parse(API_CATALOG_AS_OF);
+    const newer = Math.max(table, catalog);
+    if (!Number.isFinite(run) || !Number.isFinite(newer))
+        return 0;
+    const days = Math.floor((run - newer) / MS_PER_DAY);
+    return days > 0 ? days : 0;
+}
+function buildLeastCostReport(cfg, generatedAt, flightRecorder) {
+    const pricing = {
+        tableAsOf: PRICING_AS_OF,
+        apiCatalogAsOf: API_CATALOG_AS_OF,
+        staleDays: computePricingStaleDays(generatedAt),
+    };
+    if (!cfg.enabled) {
+        return { enabled: false, pricing, providers: [], untieredModels: [], calibrationQuality: [] };
+    }
+    const tierMap = new Map(Object.entries(cfg.tiers));
+    const cliInfo = getCliInfo();
+    const providers = [];
+    const untieredModels = [];
+    for (const provider of CLI_TYPES) {
+        const candidates = Object.keys(cliInfo[provider].models).map(model => {
+            const family = modelIdToFamily(model);
+            const cost = getModelCost(provider, model, { preferCatalog: cfg.preferCatalogPrice });
+            const tier = tierMap.get(`${provider}:${family}`) ?? null;
+            if (tier === null) {
+                untieredModels.push(`${provider}:${model}`);
+            }
+            return {
+                model,
+                family,
+                priced: cost.source !== "unknown",
+                priceSource: cost.source,
+                tier,
+            };
+        });
+        providers.push({
+            provider,
+            telemetryTier: telemetryTierFor(provider),
+            candidates,
+        });
+    }
+    const calibrationQuality = [];
+    if (flightRecorder && cfg.priorsScope !== "off") {
+        try {
+            const priors = computeLcrPriorsFromDb(flightRecorder, { priorsScope: cfg.priorsScope });
+            for (const [bucket, entry] of priors.calibration) {
+                calibrationQuality.push({
+                    bucket,
+                    k: entry.k,
+                    samples: entry.samples,
+                    confidence: entry.confidence,
+                });
+            }
+        }
+        catch {
+        }
+    }
+    return { enabled: true, pricing, providers, untieredModels, calibrationQuality };
+}
 function buildProviderCapabilitySummary(providerStatuses) {
     const capabilities = getProviderToolCapabilities({
         includeSkills: true,
@@ -502,10 +570,12 @@ export function createDoctorReport(envOrOptions = process.env) {
     if (probeReport) {
         upstream.probe_report = probeReport;
     }
+    const generatedAt = new Date().toISOString();
+    const leastCostConfig = opts.leastCost ?? defaultLeastCostConfig();
     const report = {
         schema_version: "1.0",
         ok: true,
-        generated_at: new Date().toISOString(),
+        generated_at: generatedAt,
         system: {
             os: platform(),
             arch: arch(),
@@ -564,6 +634,7 @@ export function createDoctorReport(envOrOptions = process.env) {
         client_config: clientConfigStatus(),
         cache_awareness: buildCacheAwarenessReport(opts),
         provider_capabilities: buildProviderCapabilitySummary(providerStatuses),
+        least_cost: buildLeastCostReport(leastCostConfig, generatedAt, opts.flightRecorder),
         upstream,
         next_actions: [],
     };
@@ -613,11 +684,17 @@ export async function printDoctorJson(opts = {}) {
     let cacheAwareness;
     let flightRecorder;
     let providersConfig;
+    let leastCost;
     try {
         cacheAwareness = loadCacheAwarenessConfig();
     }
     catch {
     }
+    try {
+        leastCost = loadLeastCostConfig();
+    }
+    catch {
+    }
     try {
         const dbPath = resolveFlightRecorderDbPath();
         if (dbPath)
@@ -644,6 +721,7 @@ export async function printDoctorJson(opts = {}) {
         probeUpstream: opts.probeUpstream,
         providersConfig,
         apiReachability,
+        leastCost,
     });
     process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
     if (flightRecorder) {
@@ -685,6 +763,10 @@ function isCreateDoctorReportOptions(value) {
         const candidate = value.flightRecorder;
         return candidate === undefined || typeof candidate === "object";
     }
+    if (Object.prototype.hasOwnProperty.call(value, "leastCost")) {
+        const candidate = value.leastCost;
+        return candidate === undefined || typeof candidate === "object";
+    }
     if (Object.prototype.hasOwnProperty.call(value, "env")) {
         const candidate = value.env;
         return candidate === undefined || typeof candidate === "object";

package/dist/executor.d.ts

@@ -1,5 +1,7 @@
 import { ChildProcess, type SpawnOptions } from "child_process";
+import { CircuitBreakerState } from "./retry.js";
 import type { Logger } from "./logger.js";
+import type { CliType } from "./provider-types.js";
 export interface ExecuteOptions {
     timeout?: number;
     idleTimeout?: number;
@@ -14,6 +16,9 @@ export interface ExecuteResult {
     code: number;
 }
 export declare function providerCommandName(command: string): string;
+export declare function cliBreakerState(cli: CliType): CircuitBreakerState;
+export declare function resetCliBreakersForTest(): void;
+export declare function primeCliBreakerStateForTest(command: string, state: CircuitBreakerState): void;
 export declare function buildExtendedPath(env?: NodeJS.ProcessEnv, home?: string, nodePath?: string, platform?: NodeJS.Platform): string;
 export declare function getExtendedPath(): string;
 export declare function envWithExtendedPath(baseEnv?: NodeJS.ProcessEnv, extendedPath?: string, platform?: NodeJS.Platform): NodeJS.ProcessEnv;
@@ -35,5 +40,6 @@ export declare function spawnCliProcess(command: string, args: string[], options
     cwd?: string;
     env: NodeJS.ProcessEnv;
     stdio: SpawnOptions["stdio"];
+    logger?: Logger;
 }): ChildProcess;
 export declare function executeCli(command: string, args: string[], options?: ExecuteOptions): Promise<ExecuteResult>;

package/dist/executor.js

@@ -2,7 +2,8 @@ import { spawn, spawnSync } from "child_process";
 import { homedir } from "os";
 import { delimiter, join, dirname, extname, win32 } from "path";
 import { readdirSync, existsSync } from "fs";
-import { createCircuitBreaker, withRetry } from "./retry.js";
+import { createCircuitBreaker, withRetry, CircuitBreakerState } from "./retry.js";
+import { applySpawnEnvIsolation } from "./spawn-env-isolation.js";
 export function providerCommandName(command) {
     if (command === "gemini")
         return "agy";
@@ -24,6 +25,16 @@ function getCircuitBreaker(command) {
     circuitBreakers.set(command, circuitBreaker);
     return circuitBreaker;
 }
+export function cliBreakerState(cli) {
+    const command = providerCommandName(cli);
+    return circuitBreakers.get(command)?.state ?? CircuitBreakerState.CLOSED;
+}
+export function resetCliBreakersForTest() {
+    circuitBreakers.clear();
+}
+export function primeCliBreakerStateForTest(command, state) {
+    getCircuitBreaker(command).state = state;
+}
 function getNvmPath() {
     if (cachedNvmPath !== undefined) {
         return cachedNvmPath;
@@ -309,9 +320,10 @@ function killWindowsProcessTree(pid) {
     return result.status === 0;
 }
 export function spawnCliProcess(command, args, options) {
+    const env = applySpawnEnvIsolation(options.env, options.logger);
     const detached = shouldDetachProviderProcess();
     const resolved = resolveCommandForSpawn(command, args, {
-        envPath: pathValueFromEnv(options.env, process.platform),
+        envPath: pathValueFromEnv(env, process.platform),
     });
     const proc = spawn(resolved.command, resolved.args, {
         cwd: options.cwd,
@@ -319,7 +331,7 @@ export function spawnCliProcess(command, args, options) {
         windowsHide: true,
         windowsVerbatimArguments: resolved.windowsVerbatimArguments,
         stdio: options.stdio,
-        env: options.env,
+        env,
     });
     if (proc.pid)
         registerProcessGroup(proc.pid);
@@ -337,6 +349,7 @@ export async function executeCli(command, args, options = {}) {
             cwd,
             stdio,
             env: { ...baseEnv, ...(extraEnv ?? {}) },
+            logger: options.logger,
         });
         if (stdin !== undefined && proc.stdin) {
             proc.stdin.write(stdin);

package/dist/flight-recorder.d.ts

@@ -23,6 +23,7 @@ export interface FlightLogResult {
     retryCount: number;
     circuitBreakerState: string;
     costUsd?: number;
+    costBasis?: string;
     approvalDecision?: string;
     optimizationApplied: boolean;
     thinkingBlocks?: string[];
@@ -37,6 +38,20 @@ interface LoggerLike {
     info: (message: string, ...args: any[]) => void;
     error: (message: string, ...args: any[]) => void;
 }
+export interface CompressionTelemetry {
+    route: string;
+    transforms: string[];
+    originalChars: number;
+    compressedChars: number;
+    estimatedTokensSaved: number;
+}
+export interface RoutingRecord {
+    estCostUsd?: number | null;
+    estConfidence?: string | null;
+    reason?: string | null;
+    considered?: number | null;
+    reroutes?: number | null;
+}
 export declare function resolveFlightRecorderDbPath(): string | null;
 export declare class FlightRecorder {
     private db;
@@ -51,6 +66,8 @@ export declare class FlightRecorder {
     });
     logStart(entry: FlightLogStart): void;
     logComplete(correlationId: string, result: FlightLogResult): void;
+    recordCompressionTelemetry(correlationId: string, telemetry: CompressionTelemetry): void;
+    recordRouting(correlationId: string, routing: RoutingRecord): void;
     private redactStart;
     private redactResult;
     queryRequests<T = Record<string, unknown>>(sql: string, ...params: unknown[]): T[];
@@ -60,6 +77,8 @@ export declare class FlightRecorder {
 export declare class NoopFlightRecorder {
     logStart(_entry: FlightLogStart): void;
     logComplete(_correlationId: string, _result: FlightLogResult): void;
+    recordCompressionTelemetry(_correlationId: string, _telemetry: CompressionTelemetry): void;
+    recordRouting(_correlationId: string, _routing: RoutingRecord): void;
     queryRequests<T = Record<string, unknown>>(_sql: string, ..._params: unknown[]): T[];
     flush(): void;
     close(): void;

package/dist/flight-recorder.js

@@ -64,6 +64,54 @@ function ensureMetadataProviderSessionColumns(db) {
         db.exec("ALTER TABLE gateway_metadata ADD COLUMN stop_reason TEXT");
     }
 }
+function ensureCompressionColumns(db) {
+    const rows = db.prepare("PRAGMA table_info(gateway_metadata)").all();
+    const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
+    if (!names.has("compression_route")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_route TEXT");
+    }
+    if (!names.has("compression_transforms")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_transforms TEXT");
+    }
+    if (!names.has("compression_original_chars")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_original_chars INTEGER");
+    }
+    if (!names.has("compression_compressed_chars")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_compressed_chars INTEGER");
+    }
+    if (!names.has("compression_tokens_saved_est")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_tokens_saved_est INTEGER");
+    }
+}
+function ensureRequestsCostBasisColumn(db) {
+    const rows = db.prepare("PRAGMA table_info(requests)").all();
+    const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
+    if (!names.has("cost_basis")) {
+        db.exec("ALTER TABLE requests ADD COLUMN cost_basis TEXT");
+    }
+}
+function ensureMetadataRoutingColumns(db) {
+    const rows = db.prepare("PRAGMA table_info(gateway_metadata)").all();
+    const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
+    if (!names.has("routed")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN routed INTEGER");
+    }
+    if (!names.has("route_est_cost_usd")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_est_cost_usd REAL");
+    }
+    if (!names.has("route_est_confidence")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_est_confidence TEXT");
+    }
+    if (!names.has("route_reason")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_reason TEXT");
+    }
+    if (!names.has("route_considered")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_considered INTEGER");
+    }
+    if (!names.has("route_reroutes")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN route_reroutes INTEGER");
+    }
+}
 export function resolveFlightRecorderDbPath() {
     const configured = process.env.LLM_GATEWAY_LOGS_DB;
     if (configured !== undefined) {
@@ -142,7 +190,8 @@ export class FlightRecorder {
         output_tokens INTEGER,
         cache_read_tokens INTEGER,
         cache_creation_tokens INTEGER,
-        owner_principal TEXT
+        owner_principal TEXT,
+        cost_basis TEXT
       );
 
       CREATE TABLE IF NOT EXISTS gateway_metadata (
@@ -159,6 +208,12 @@ export class FlightRecorder {
         async_job_id TEXT,
         provider_session_id TEXT,
         stop_reason TEXT,
+        routed INTEGER,
+        route_est_cost_usd REAL,
+        route_est_confidence TEXT,
+        route_reason TEXT,
+        route_considered INTEGER,
+        route_reroutes INTEGER,
         status TEXT NOT NULL DEFAULT 'started'
       );
 
@@ -196,6 +251,18 @@ export class FlightRecorder {
         this.db
             .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(7, ?)")
             .run(new Date().toISOString());
+        ensureCompressionColumns(this.db);
+        this.db
+            .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(8, ?)")
+            .run(new Date().toISOString());
+        ensureRequestsCostBasisColumn(this.db);
+        this.db
+            .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(9, ?)")
+            .run(new Date().toISOString());
+        ensureMetadataRoutingColumns(this.db);
+        this.db
+            .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(10, ?)")
+            .run(new Date().toISOString());
         if (process.platform !== "win32") {
             try {
                 chmodSync(dbPath, 0o600);
@@ -242,7 +309,8 @@ export class FlightRecorder {
           input_tokens = @input_tokens,
           output_tokens = @output_tokens,
           cache_read_tokens = @cache_read_tokens,
-          cache_creation_tokens = @cache_creation_tokens
+          cache_creation_tokens = @cache_creation_tokens,
+          cost_basis = @cost_basis
       WHERE id = @id
     `);
         const updateMetadata = this.db.prepare(`
@@ -273,6 +341,7 @@ export class FlightRecorder {
                 output_tokens: result.outputTokens ?? null,
                 cache_read_tokens: result.cacheReadTokens ?? null,
                 cache_creation_tokens: result.cacheCreationTokens ?? null,
+                cost_basis: result.costBasis ?? null,
             });
             updateMetadata.run({
                 id: correlationId,
@@ -297,6 +366,43 @@ export class FlightRecorder {
     logComplete(correlationId, result) {
         this.updateCompleteTxn(correlationId, this.redactEnabled ? this.redactResult(result) : result);
     }
+    recordCompressionTelemetry(correlationId, telemetry) {
+        this.db
+            .prepare(`UPDATE gateway_metadata
+         SET compression_route = @route,
+             compression_transforms = @transforms,
+             compression_original_chars = @original_chars,
+             compression_compressed_chars = @compressed_chars,
+             compression_tokens_saved_est = @tokens_saved_est
+         WHERE request_id = @id AND compression_route IS NULL`)
+            .run({
+            id: correlationId,
+            route: telemetry.route,
+            transforms: telemetry.transforms.join(","),
+            original_chars: telemetry.originalChars,
+            compressed_chars: telemetry.compressedChars,
+            tokens_saved_est: telemetry.estimatedTokensSaved,
+        });
+    }
+    recordRouting(correlationId, routing) {
+        this.db
+            .prepare(`UPDATE gateway_metadata
+         SET routed = 1,
+             route_est_cost_usd = @est_cost_usd,
+             route_est_confidence = @est_confidence,
+             route_reason = @reason,
+             route_considered = @considered,
+             route_reroutes = @reroutes
+         WHERE request_id = @id`)
+            .run({
+            id: correlationId,
+            est_cost_usd: routing.estCostUsd ?? null,
+            est_confidence: routing.estConfidence ?? null,
+            reason: routing.reason ?? null,
+            considered: routing.considered ?? null,
+            reroutes: routing.reroutes ?? null,
+        });
+    }
     redactStart(entry) {
         return {
             ...entry,
@@ -330,6 +436,8 @@ export class FlightRecorder {
 export class NoopFlightRecorder {
     logStart(_entry) { }
     logComplete(_correlationId, _result) { }
+    recordCompressionTelemetry(_correlationId, _telemetry) { }
+    recordRouting(_correlationId, _routing) { }
     queryRequests(_sql, ..._params) {
         return [];
     }

package/dist/http-transport.js

@@ -19,12 +19,7 @@ async function readBody(req) {
     const raw = await readCappedRawBody(req, maxHttpBodyBytes());
     if (!raw)
         return undefined;
-    try {
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        throw error;
-    }
+    return JSON.parse(raw);
 }
 function methodNotAllowed(res) {
     res.writeHead(405, { allow: "GET, POST, DELETE", "content-type": "application/json" });
@@ -34,10 +29,6 @@ function jsonError(res, status, message) {
     res.writeHead(status, { "content-type": "application/json" });
     res.end(JSON.stringify({ error: message }));
 }
-function jsonResponse(res, status, body) {
-    res.writeHead(status, { "content-type": "application/json" });
-    res.end(JSON.stringify(body));
-}
 function parseNoAuthPaths(raw, protectedPath) {
     const paths = new Set();
     for (const value of (raw ?? "").split(/[,;\s]+/)) {
@@ -133,21 +124,21 @@ export async function startHttpGateway(options) {
     }
     async function createSession(releaseInitializeReservation) {
         const gatewayServer = options.createGatewayServer(options.deps);
-        let entry;
+        const onSessionInitialized = (sessionId) => {
+            const initializedAt = Date.now();
+            releaseInitializeReservation();
+            entry.sessionId = sessionId;
+            entry.createdAt = initializedAt;
+            entry.lastActivityAt = initializedAt;
+            entry.inFlight++;
+            sessions.set(sessionId, entry);
+        };
         const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => randomUUID(),
-            onsessioninitialized: sessionId => {
-                const now = Date.now();
-                releaseInitializeReservation();
-                entry.sessionId = sessionId;
-                entry.createdAt = now;
-                entry.lastActivityAt = now;
-                entry.inFlight++;
-                sessions.set(sessionId, entry);
-            },
+            onsessioninitialized: onSessionInitialized,
         });
         const now = Date.now();
-        entry = {
+        const entry = {
             server: gatewayServer,
             transport,
             createdAt: now,
@@ -209,6 +200,9 @@ export async function startHttpGateway(options) {
         if (manager) {
             const limiter = manager.getLimiterSnapshot();
             const limits = manager.getConfiguredLimits();
+            const durableAdmission = manager.getDurableAdmissionHealth();
+            const persistence = options.deps?.persistence;
+            const durablePersistenceConfigured = persistence !== undefined && persistence.backend !== "none" && persistence.asyncJobsEnabled;
             payload.jobs = {
                 running: limiter.running,
                 queued: limiter.queued,
@@ -222,7 +216,11 @@ export async function startHttpGateway(options) {
                 saturated: limiter.saturated,
                 completedJobMemoryTtlMs: limits.completedJobMemoryTtlMs,
                 maxJobOutputBytes: limits.maxJobOutputBytes,
+                durableAdmission,
             };
+            payload.ready = durableAdmission.storeAttached
+                ? durableAdmission.admitting
+                : !durablePersistenceConfigured;
         }
         return payload;
     }

package/dist/index.d.ts

@@ -4,7 +4,9 @@ import { z } from "zod/v3";
 import { ISessionManager, type CliType, type ProviderType } from "./session-manager.js";
 import { ResourceProvider } from "./resources.js";
 import { PerformanceMetrics } from "./metrics.js";
-import { type PersistenceConfig, type CacheAwarenessConfig, type ProvidersConfig, type ApiProviderRuntime, type AcpConfig, type AdminConfig } from "./config.js";
+import { type CompressResult } from "./compressor/index.js";
+import { type PersistenceConfig, type CacheAwarenessConfig, type CompressionConfig, type ProvidersConfig, type ApiProviderRuntime, type AcpConfig, type AdminConfig, type LeastCostConfig } from "./config.js";
+import type { CostBasis } from "./least-cost-types.js";
 import { DatabaseConnection } from "./db.js";
 import { type DevinAcpAgentType } from "./provider-definitions.js";
 import { AsyncJobManager } from "./async-job-manager.js";
@@ -38,6 +40,8 @@ type ExtendedToolResponse = {
     };
     reviewIntegrity?: ReviewIntegrityResult;
     warnings?: WarningEntry[];
+    routing?: RouteResponseBlock;
+    compression?: CompressResult;
 };
 export declare const logger: {
     info: (message: string, ...args: unknown[]) => void;
@@ -76,10 +80,12 @@ export interface GatewayServerDeps {
     logger?: GatewayLogger;
     persistence?: PersistenceConfig;
     cacheAwareness?: CacheAwarenessConfig;
+    compression?: CompressionConfig;
     providers?: ProvidersConfig;
     acpConfig?: AcpConfig;
     adminConfig?: AdminConfig;
     workspaces?: WorkspaceRegistry;
+    leastCost?: LeastCostConfig;
 }
 export interface GatewayServerRuntime {
     sessionManager: ISessionManager;
@@ -92,10 +98,12 @@ export interface GatewayServerRuntime {
     logger: GatewayLogger;
     persistence: PersistenceConfig;
     cacheAwareness: CacheAwarenessConfig;
+    compression: CompressionConfig;
     providers: ProvidersConfig;
     acpConfig: AcpConfig;
     adminConfig: AdminConfig;
     workspaces: WorkspaceRegistry;
+    leastCost: LeastCostConfig;
 }
 export declare function resolveGatewayServerRuntime(deps?: GatewayServerDeps, options?: {
     isolateState?: boolean;
@@ -169,6 +177,11 @@ export declare function extractUsageAndCost(cli: CliType, output: string, output
     cacheCreationTokens?: number;
     costUsd?: number;
 };
+export declare function resolveEffectiveCompression(compression: CompressionConfig, input: {
+    compressResponse?: boolean;
+    outputFormat?: string;
+    outputSchemaDeclared?: boolean;
+}): boolean;
 export declare function registerBaseResources(server: McpServer, runtime: GatewayServerRuntime): void;
 interface CliRequestPrep {
     corrId: string;
@@ -344,6 +357,7 @@ export declare function prepareGrokRequest(params: {
     forkSession?: boolean;
     jsonSchema?: string | Record<string, unknown>;
 }, runtime?: GatewayServerRuntime): CliRequestPrep | ExtendedToolResponse;
+export declare function resolveMistralAgentMode(approvalStrategy: "legacy" | "mcp_managed" | undefined, callerMode: MistralAgentMode | undefined): MistralAgentMode;
 export declare function prepareMistralRequest(params: {
     prompt?: string;
     promptParts?: PromptParts;
@@ -374,7 +388,7 @@ export declare function buildMistralRetryPrep(params: Pick<MistralRequestParams,
     env: Record<string, string>;
     ignoredDisallowedTools: boolean;
 };
-export declare function buildCliResponse(cli: CliType, stdout: string, optimizeResponse: boolean, corrId: string, sessionId: string | undefined, prep: CliRequestPrep, durationMs: number, resumable?: boolean, outputFormat?: string, warnings?: WarningEntry[]): ExtendedToolResponse;
+export declare function buildCliResponse(cli: CliType, stdout: string, optimizeResponse: boolean, corrId: string, sessionId: string | undefined, prep: CliRequestPrep, durationMs: number, resumable?: boolean, outputFormat?: string, warnings?: WarningEntry[], compressResponse?: boolean): ExtendedToolResponse;
 export interface GrokApiRequestParams {
     prompt?: string;
     promptParts?: PromptParts;
@@ -427,6 +441,7 @@ export interface GeminiRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
     outputFormat?: "text" | "json" | "stream-json";
@@ -482,6 +497,7 @@ export interface GrokRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
     maxTurns?: number;
@@ -541,6 +557,7 @@ export interface DevinRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
 }
@@ -580,6 +597,7 @@ export interface CursorRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
 }
@@ -620,6 +638,7 @@ export interface MistralRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
     trust?: boolean;
@@ -653,6 +672,7 @@ export declare function handleCodexRequestAsync(deps: AsyncHandlerDeps, params:
     createNewSession: boolean;
     correlationId?: string;
     optimizePrompt: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
     outputFormat?: "text" | "json";
@@ -680,5 +700,41 @@ export declare function handleCodexRequestAsync(deps: AsyncHandlerDeps, params:
         ref?: string;
     };
 }): Promise<ExtendedToolResponse>;
+export interface RouteResponseBlock {
+    chosen: {
+        provider: string;
+        model: string;
+    } | null;
+    tier?: string;
+    estCostUsd?: number;
+    costBasis?: string;
+    confidence?: string;
+    nearTie?: boolean;
+    estInputTokens?: number;
+    estOutputTokens?: number;
+    priceAsOf?: string;
+    priceSource?: string;
+    consideredCount: number;
+    rejected: {
+        candidate: {
+            provider: string;
+            model: string;
+        };
+        reason: string;
+    }[];
+    reroutes: number;
+    error?: string;
+}
+export declare function isTransientRouteFailure(provider: string, response: ExtendedToolResponse): boolean;
+export declare function deriveCostBasis(provider: string, resolvedModel: string, usage: {
+    inputTokens?: number;
+    outputTokens?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    costUsd?: number;
+}): {
+    costUsd?: number;
+    costBasis?: CostBasis;
+};
 export declare function createGatewayServer(deps?: GatewayServerDeps): McpServer;
 export {};