llm-cli-gateway 2.15.0 → 2.17.0

package/dist/index.js

@@ -7,7 +7,8 @@ import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileS
 import { basename, dirname, isAbsolute, join, relative } from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod/v3";
-import { executeCli, killAllProcessGroups, providerCommandName } from "./executor.js";
+import { executeCli, killAllProcessGroups, providerCommandName, cliBreakerState, } from "./executor.js";
+import { isDefaultTransient } from "./retry.js";
 import { parseStreamJson } from "./stream-json-parser.js";
 import { parseCodexJsonStream, codexDisplayText, codexFrResponse } from "./codex-json-parser.js";
 import { grokDisplayText } from "./grok-json-parser.js";
@@ -21,7 +22,12 @@ import { ResourceProvider } from "./resources.js";
 import { generateResourceDescriptors, generateProviderAcpDescriptors, } from "./provider-surface-generator.js";
 import { PerformanceMetrics } from "./metrics.js";
 import { estimateTokens, optimizePrompt as optimizePromptText, optimizeResponse as optimizeResponseText, } from "./optimizer.js";
-import { loadConfig, loadPersistenceConfig, loadCacheAwarenessConfig, loadProvidersConfig, loadAcpConfig, loadAdminConfig, loadLimitsConfig, loadSkillsConfig, defaultGatewayConfigPath, isXaiProviderEnabled, enabledApiProviders, minStableTokensForModel, } from "./config.js";
+import { compressDisplayText } from "./compressor/index.js";
+import { loadConfig, loadPersistenceConfig, loadCacheAwarenessConfig, loadProvidersConfig, loadAcpConfig, loadAdminConfig, loadLimitsConfig, loadCompressionConfig, loadLeastCostConfig, loadSkillsConfig, defaultGatewayConfigPath, isXaiProviderEnabled, enabledApiProviders, minStableTokensForModel, } from "./config.js";
+import { buildRouterEnv, toRouterConfig } from "./lcr-router-env.js";
+import { getModelCost, composeCost, modelIdToFamily } from "./pricing.js";
+import { telemetryTierFor } from "./lcr-telemetry.js";
+import { selectCandidate, } from "./least-cost-router.js";
 import { loadGatewaySkills } from "./skill-loader.js";
 import { runAcpRequest } from "./acp/runtime.js";
 import { isAcpError } from "./acp/errors.js";
@@ -228,6 +234,8 @@ let resourceProvider;
 let flightRecorder = null;
 let persistenceConfig = null;
 let cacheAwarenessConfig = null;
+let compressionConfig = null;
+let leastCostConfig = null;
 let providersConfig = null;
 let acpConfig = null;
 let adminConfig = null;
@@ -260,6 +268,14 @@ function getCacheAwarenessConfig(runtimeLogger = logger) {
     cacheAwarenessConfig ??= loadCacheAwarenessConfig(runtimeLogger);
     return cacheAwarenessConfig;
 }
+function getCompressionConfig(runtimeLogger = logger) {
+    compressionConfig ??= loadCompressionConfig(runtimeLogger);
+    return compressionConfig;
+}
+function getLeastCostConfig(runtimeLogger = logger) {
+    leastCostConfig ??= loadLeastCostConfig(runtimeLogger);
+    return leastCostConfig;
+}
 function getProvidersConfig(runtimeLogger = logger) {
     providersConfig ??= loadProvidersConfig(runtimeLogger);
     return providersConfig;
@@ -272,7 +288,7 @@ function getJobStore(runtimeLogger = logger) {
         jobStore = createJobStore(getPersistenceConfig(runtimeLogger), runtimeLogger);
     }
     catch (err) {
-        runtimeLogger.error("Failed to open durable job store; async tools will be unavailable", err);
+        runtimeLogger.error("Failed to open configured durable job store", err);
         jobStore = null;
     }
     return jobStore;
@@ -458,7 +474,7 @@ export function resolveGatewayServerRuntime(deps = {}, options = {}) {
         sessionManager: runtimeSessionManager,
         resourceProvider: deps.resourceProvider ??
             (options.isolateState
-                ? new ResourceProvider(runtimeSessionManager, runtimePerformanceMetrics, runtimeFlightRecorder, deps.cacheAwareness ?? getCacheAwarenessConfig(runtimeLogger), deps.providers ?? getProvidersConfig(runtimeLogger), undefined, deps.acpConfig ?? getAcpConfig(runtimeLogger))
+                ? new ResourceProvider(runtimeSessionManager, runtimePerformanceMetrics, runtimeFlightRecorder, deps.cacheAwareness ?? getCacheAwarenessConfig(runtimeLogger), deps.providers ?? getProvidersConfig(runtimeLogger), undefined, deps.acpConfig ?? getAcpConfig(runtimeLogger), deps.leastCost ?? getLeastCostConfig(runtimeLogger))
                 : resourceProvider),
         db: "db" in deps ? (deps.db ?? null) : db,
         performanceMetrics: runtimePerformanceMetrics,
@@ -468,10 +484,12 @@ export function resolveGatewayServerRuntime(deps = {}, options = {}) {
         logger: runtimeLogger,
         persistence: deps.persistence ?? getPersistenceConfig(runtimeLogger),
         cacheAwareness: deps.cacheAwareness ?? getCacheAwarenessConfig(runtimeLogger),
+        compression: deps.compression ?? getCompressionConfig(runtimeLogger),
         providers: deps.providers ?? getProvidersConfig(runtimeLogger),
         acpConfig: deps.acpConfig ?? getAcpConfig(runtimeLogger),
         adminConfig: deps.adminConfig ?? getAdminConfig(runtimeLogger),
         workspaces: deps.workspaces ?? loadWorkspaceRegistry(runtimeLogger),
+        leastCost: deps.leastCost ?? getLeastCostConfig(runtimeLogger),
     };
 }
 export function shouldRegisterGrokApiTools(providers) {
@@ -545,7 +563,7 @@ export async function runAcpTransport(deps, params) {
     }
 }
 const SYNC_POLL_INTERVAL_MS = 1_000;
-async function awaitJobOrDefer(cli, args, corrId, idleTimeoutMs, outputFormat, forceRefresh, runtime = resolveGatewayServerRuntime(), env, onComplete, flightRecorderEntry, extractUsage, stdin, cwd) {
+async function awaitJobOrDefer(cli, args, corrId, idleTimeoutMs, outputFormat, forceRefresh, runtime = resolveGatewayServerRuntime(), env, onComplete, flightRecorderEntry, extractUsage, stdin, cwd, compressResponse) {
     let onCompleteOwnedByCaller = onComplete !== undefined;
     const consumeOnComplete = () => {
         if (!onCompleteOwnedByCaller || !onComplete)
@@ -605,6 +623,7 @@ async function awaitJobOrDefer(cli, args, corrId, idleTimeoutMs, outputFormat, f
             onComplete,
             flightRecorderEntry,
             extractUsage,
+            compressResponse,
         });
         onCompleteOwnedByCaller = false;
     }
@@ -1166,22 +1185,28 @@ export function extractUsageAndCost(cli, output, outputFormat, ctx) {
     }
     return {};
 }
-function buildAsyncFlightRecorderHandoff(cliName, prep, sessionId, outputFormat) {
+function buildAsyncFlightRecorderHandoff(cliName, prep, sessionId, outputFormat, optimizationApplied = false) {
     const cli = cliName;
     const fmt = outputFormat;
     const sid = sessionId;
     const home = homedir();
+    const model = prep.resolvedModel || "default";
     return {
         flightRecorderEntry: {
-            model: prep.resolvedModel || "default",
+            model,
             prompt: prep.effectivePrompt,
             sessionId,
+            optimizationApplied,
             stablePrefixHash: prep.stablePrefixHash ?? undefined,
             stablePrefixTokens: prep.stablePrefixTokens ?? undefined,
             cacheControlBlocks: prep.cacheControlBlocks,
             cacheControlTtlSeconds: prep.cacheControlTtlSeconds,
         },
-        extractUsage: (stdout) => extractUsageAndCost(cli, stdout, fmt, { sessionId: sid, home }),
+        extractUsage: (stdout) => {
+            const usage = extractUsageAndCost(cli, stdout, fmt, { sessionId: sid, home });
+            const { costUsd, costBasis } = deriveCostBasis(cli, model, usage);
+            return { ...usage, costUsd, costBasis };
+        },
     };
 }
 function safeFlightStart(entry, runtime = resolveGatewayServerRuntime()) {
@@ -1200,6 +1225,40 @@ function safeFlightComplete(correlationId, result, runtime = resolveGatewayServe
         runtime.logger.error("Flight recorder logComplete failed", error);
     }
 }
+export function resolveEffectiveCompression(compression, input) {
+    const requested = input.compressResponse ?? compression.enabled;
+    if (!requested)
+        return false;
+    if (input.outputFormat === "json")
+        return false;
+    if (input.outputSchemaDeclared)
+        return false;
+    return true;
+}
+function safeRecordCompression(correlationId, compression, runtime) {
+    if (!compression)
+        return;
+    try {
+        runtime.flightRecorder.recordCompressionTelemetry(correlationId, {
+            route: compression.route,
+            transforms: compression.transforms,
+            originalChars: compression.originalChars,
+            compressedChars: compression.compressedChars,
+            estimatedTokensSaved: compression.estimatedTokensSaved,
+        });
+    }
+    catch (error) {
+        runtime.logger.error("Flight recorder recordCompressionTelemetry failed", error);
+    }
+}
+function safeRecordRouting(correlationId, routing, runtime) {
+    try {
+        runtime.flightRecorder.recordRouting(correlationId, routing);
+    }
+    catch (error) {
+        runtime.logger.error("Flight recorder recordRouting failed", error);
+    }
+}
 function createApprovalDeniedResponse(operation, decision) {
     return {
         content: [
@@ -2142,7 +2201,7 @@ export function prepareGrokRequest(params, runtime = resolveGatewayServerRuntime
             args.push("--permission-mode", "acceptEdits");
         }
     }
-    else if (Boolean(params.alwaysApprove)) {
+    else if (params.alwaysApprove) {
         args.push("--always-approve");
     }
     else if (params.permissionMode) {
@@ -2210,6 +2269,14 @@ export function prepareGrokRequest(params, runtime = resolveGatewayServerRuntime
         stablePrefixTokens,
     };
 }
+export function resolveMistralAgentMode(approvalStrategy, callerMode) {
+    if (approvalStrategy === "mcp_managed") {
+        return bypassAllowedByOperator() ? "auto-approve" : "accept-edits";
+    }
+    if (callerMode !== undefined)
+        return callerMode;
+    return bypassAllowedByOperator() ? "auto-approve" : "accept-edits";
+}
 export function prepareMistralRequest(params, runtime = resolveGatewayServerRuntime()) {
     const corrId = params.correlationId || randomUUID();
     const cliInfo = getCliInfo();
@@ -2266,11 +2333,7 @@ export function prepareMistralRequest(params, runtime = resolveGatewayServerRunt
             return createApprovalDeniedResponse(params.operation, approvalDecision);
         }
     }
-    const effectivePermissionMode = params.approvalStrategy === "mcp_managed"
-        ? bypassAllowedByOperator()
-            ? "auto-approve"
-            : "accept-edits"
-        : (params.permissionMode ?? "auto-approve");
+    const effectivePermissionMode = resolveMistralAgentMode(params.approvalStrategy, params.permissionMode);
     const prep = buildMistralCliInvocation({
         prompt: effectivePrompt,
         resolvedModel,
@@ -2319,11 +2382,7 @@ export function buildMistralRetryPrep(params, recoveryModel) {
         prompt: params.effectivePrompt,
         resolvedModel: recoveryModel,
         outputFormat: params.outputFormat,
-        permissionMode: params.approvalStrategy === "mcp_managed"
-            ? bypassAllowedByOperator()
-                ? "auto-approve"
-                : "accept-edits"
-            : (params.permissionMode ?? "auto-approve"),
+        permissionMode: resolveMistralAgentMode(params.approvalStrategy, params.permissionMode),
         allowedTools: params.allowedTools,
         disallowedTools: params.disallowedTools,
         trust: params.trust,
@@ -2334,7 +2393,7 @@ export function buildMistralRetryPrep(params, recoveryModel) {
         addDir: params.addDir,
     });
 }
-export function buildCliResponse(cli, stdout, optimizeResponse, corrId, sessionId, prep, durationMs, resumable, outputFormat, warnings) {
+export function buildCliResponse(cli, stdout, optimizeResponse, corrId, sessionId, prep, durationMs, resumable, outputFormat, warnings, compressResponse = false) {
     let finalStdout = stdout;
     if (cli === "codex" && outputFormat !== "json") {
         finalStdout = codexDisplayText(stdout);
@@ -2347,6 +2406,20 @@ export function buildCliResponse(cli, stdout, optimizeResponse, corrId, sessionI
         logOptimizationTokens("response", corrId, finalStdout, optimized);
         finalStdout = optimized;
     }
+    let compression;
+    if (compressResponse && outputFormat !== "json") {
+        const compressed = compressDisplayText(finalStdout, {
+            provider: cli,
+            direction: "outbound",
+            outputFormat,
+            outputSchemaDeclared: false,
+            lossless: true,
+        });
+        if (compressed.text !== finalStdout) {
+            compression = compressed;
+            finalStdout = compressed.text;
+        }
+    }
     if (prep.reviewIntegrity &&
         prep.reviewIntegrity.violations.length > 0 &&
         outputFormat !== "json") {
@@ -2422,6 +2495,7 @@ export function buildCliResponse(cli, stdout, optimizeResponse, corrId, sessionI
                 missing: prep.mcpConfig.missing,
             }
             : { requested: prep.requestedMcpServers },
+        ...(compression ? { compression } : {}),
     };
     if (sessionId) {
         response.sessionId = sessionId;
@@ -2931,6 +3005,7 @@ export async function handleApiProviderRequest(runtimeArg, providerRuntime, para
             inputTokens: result.usage?.inputTokens,
             outputTokens: result.usage?.outputTokens,
             cacheReadTokens: result.usage?.cacheReadTokens,
+            cacheCreationTokens: result.usage?.cacheCreationTokens,
             costUsd: result.usage?.costUsd,
         }, runtimeArg);
         return buildApiSuccessResponse(text, corrId, providerRuntime.name, {
@@ -3175,8 +3250,13 @@ export async function handleGeminiRequest(deps, params) {
         catch (err) {
             return createErrorResponse("gemini_request", 1, "", corrId, err);
         }
-        const geminiFrHandoff = buildAsyncFlightRecorderHandoff("gemini", prep, params.sessionId, params.outputFormat);
-        const result = await awaitJobOrDefer("gemini", args, corrId, resolveIdleTimeout("gemini", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, geminiFrHandoff.flightRecorderEntry, geminiFrHandoff.extractUsage, undefined, worktreeResolution.cwd);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: params.outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const geminiFrHandoff = buildAsyncFlightRecorderHandoff("gemini", prep, params.sessionId, params.outputFormat, params.optimizePrompt);
+        const result = await awaitJobOrDefer("gemini", args, corrId, resolveIdleTimeout("gemini", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, geminiFrHandoff.flightRecorderEntry, geminiFrHandoff.extractUsage, undefined, worktreeResolution.cwd, effectiveCompress);
         if (isDeferredResponse(result)) {
             return buildDeferredToolResponse(result, effectiveSessionIdHint);
         }
@@ -3197,7 +3277,7 @@ export async function handleGeminiRequest(deps, params) {
             return createErrorResponse("gemini", code, stderr, corrId);
         }
         wasSuccessful = true;
-        let effectiveSessionId = effectiveSessionIdHint;
+        const effectiveSessionId = effectiveSessionIdHint;
         if (effectiveSessionId) {
             const existing = await deps.sessionManager.getSession(effectiveSessionId);
             if (!existing) {
@@ -3213,7 +3293,8 @@ export async function handleGeminiRequest(deps, params) {
             await deps.sessionManager.updateSessionUsage(effectiveSessionId);
         }
         deps.logger.info(`[${corrId}] gemini_request completed successfully in ${durationMs}ms`);
-        const response = buildCliResponse("gemini", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, userProvidedSession, params.outputFormat);
+        const response = buildCliResponse("gemini", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, userProvidedSession, params.outputFormat, undefined, effectiveCompress);
+        safeRecordCompression(corrId, response.compression, runtime);
         if (worktreeResolution.worktreePath) {
             const first = response.content[0];
             if (first && first.type === "text") {
@@ -3221,6 +3302,7 @@ export async function handleGeminiRequest(deps, params) {
             }
         }
         const geminiUsage = extractUsageAndCost("gemini", stdout, params.outputFormat);
+        const { costUsd: geminiCostUsd, costBasis: geminiCostBasis } = deriveCostBasis("gemini", prep.resolvedModel || "default", geminiUsage);
         const geminiMeta = extractProviderOutputMetadata("gemini", stdout, params.outputFormat);
         safeFlightComplete(corrId, {
             response: stdout,
@@ -3235,7 +3317,8 @@ export async function handleGeminiRequest(deps, params) {
             outputTokens: geminiUsage.outputTokens,
             cacheReadTokens: geminiUsage.cacheReadTokens,
             cacheCreationTokens: geminiUsage.cacheCreationTokens,
-            costUsd: geminiUsage.costUsd,
+            costUsd: geminiCostUsd,
+            costBasis: geminiCostBasis,
             providerSessionId: geminiMeta.sessionId,
             stopReason: geminiMeta.stopReason,
         }, runtime);
@@ -3296,7 +3379,7 @@ export async function handleGeminiRequestAsync(deps, params) {
             resumeLatest: params.resumeLatest,
             createNewSession: params.createNewSession,
         });
-        let effectiveSessionId = sessionPlan.resumed ? params.sessionId : undefined;
+        const effectiveSessionId = sessionPlan.resumed ? params.sessionId : undefined;
         const existingSession = await getExistingSessionForProvider(deps.sessionManager, effectiveSessionId, "gemini");
         args.push(...sessionPlan.args);
         if (effectiveSessionId) {
@@ -3328,8 +3411,13 @@ export async function handleGeminiRequestAsync(deps, params) {
         }
         assertUpstreamCliArgs("gemini", args);
         assertUpstreamCliEnv("gemini", undefined);
-        const geminiAsyncFrHandoff = buildAsyncFlightRecorderHandoff("gemini", prep, effectiveSessionId, params.outputFormat);
-        const job = deps.asyncJobManager.startJob("gemini", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("gemini", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, undefined, undefined, geminiAsyncFrHandoff.flightRecorderEntry, geminiAsyncFrHandoff.extractUsage, true);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: params.outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const geminiAsyncFrHandoff = buildAsyncFlightRecorderHandoff("gemini", prep, effectiveSessionId, params.outputFormat, params.optimizePrompt);
+        const job = deps.asyncJobManager.startJob("gemini", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("gemini", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, undefined, undefined, geminiAsyncFrHandoff.flightRecorderEntry, geminiAsyncFrHandoff.extractUsage, true, undefined, effectiveCompress);
         deps.logger.info(`[${corrId}] gemini_request_async started job ${job.id}`);
         const asyncResponse = {
             success: true,
@@ -3458,8 +3546,13 @@ export async function handleGrokRequest(deps, params) {
         catch (err) {
             return createErrorResponse("grok_request", 1, "", corrId, err);
         }
-        const grokFrHandoff = buildAsyncFlightRecorderHandoff("grok", prep, params.sessionId, params.outputFormat);
-        const result = await awaitJobOrDefer("grok", args, corrId, resolveIdleTimeout("grok", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, grokFrHandoff.flightRecorderEntry, grokFrHandoff.extractUsage, undefined, worktreeResolution.cwd);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: params.outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const grokFrHandoff = buildAsyncFlightRecorderHandoff("grok", prep, params.sessionId, params.outputFormat, params.optimizePrompt);
+        const result = await awaitJobOrDefer("grok", args, corrId, resolveIdleTimeout("grok", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, grokFrHandoff.flightRecorderEntry, grokFrHandoff.extractUsage, undefined, worktreeResolution.cwd, effectiveCompress);
         if (isDeferredResponse(result)) {
             return buildDeferredToolResponse(result, sessionResult.effectiveSessionId);
         }
@@ -3500,7 +3593,8 @@ export async function handleGrokRequest(deps, params) {
             effectiveSessionId = newSession.id;
         }
         deps.logger.info(`[${corrId}] grok_request completed successfully in ${durationMs}ms`);
-        const response = buildCliResponse("grok", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, sessionResult.userProvidedSession, params.outputFormat);
+        const response = buildCliResponse("grok", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, sessionResult.userProvidedSession, params.outputFormat, undefined, effectiveCompress);
+        safeRecordCompression(corrId, response.compression, runtime);
         if (worktreeResolution.worktreePath) {
             const first = response.content[0];
             if (first && first.type === "text") {
@@ -3641,8 +3735,13 @@ export async function handleGrokRequestAsync(deps, params) {
         }
         assertUpstreamCliArgs("grok", args);
         assertUpstreamCliEnv("grok", undefined);
-        const grokAsyncFrHandoff = buildAsyncFlightRecorderHandoff("grok", prep, effectiveSessionId, params.outputFormat);
-        const job = deps.asyncJobManager.startJob("grok", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("grok", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, undefined, undefined, grokAsyncFrHandoff.flightRecorderEntry, grokAsyncFrHandoff.extractUsage, true);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: params.outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const grokAsyncFrHandoff = buildAsyncFlightRecorderHandoff("grok", prep, effectiveSessionId, params.outputFormat, params.optimizePrompt);
+        const job = deps.asyncJobManager.startJob("grok", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("grok", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, undefined, undefined, grokAsyncFrHandoff.flightRecorderEntry, grokAsyncFrHandoff.extractUsage, true, undefined, effectiveCompress);
         deps.logger.info(`[${corrId}] grok_request_async started job ${job.id}`);
         const asyncResponse = {
             success: true,
@@ -3770,8 +3869,13 @@ export async function handleDevinRequest(deps, params) {
             await getExistingSessionForProvider(deps.sessionManager, sessionResult.effectiveSessionId, "devin");
         }
         args.push(...sessionResult.resumeArgs);
-        const devinFrHandoff = buildAsyncFlightRecorderHandoff("devin", prep, params.sessionId, undefined);
-        const result = await awaitJobOrDefer("devin", args, corrId, resolveIdleTimeout("devin", params.idleTimeoutMs), undefined, params.forceRefresh, runtime, undefined, undefined, devinFrHandoff.flightRecorderEntry, devinFrHandoff.extractUsage);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: undefined,
+            outputSchemaDeclared: false,
+        });
+        const devinFrHandoff = buildAsyncFlightRecorderHandoff("devin", prep, params.sessionId, undefined, params.optimizePrompt);
+        const result = await awaitJobOrDefer("devin", args, corrId, resolveIdleTimeout("devin", params.idleTimeoutMs), undefined, params.forceRefresh, runtime, undefined, undefined, devinFrHandoff.flightRecorderEntry, devinFrHandoff.extractUsage, undefined, undefined, effectiveCompress);
         if (isDeferredResponse(result)) {
             return buildDeferredToolResponse(result, sessionResult.effectiveSessionId);
         }
@@ -3810,7 +3914,8 @@ export async function handleDevinRequest(deps, params) {
             const newSession = await deps.sessionManager.createSession("devin", "Devin Session", `${GATEWAY_SESSION_PREFIX}${randomUUID()}`);
             effectiveSessionId = newSession.id;
         }
-        const response = buildCliResponse("devin", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, sessionResult.userProvidedSession);
+        const response = buildCliResponse("devin", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, sessionResult.userProvidedSession, undefined, undefined, effectiveCompress);
+        safeRecordCompression(corrId, response.compression, runtime);
         safeFlightComplete(corrId, {
             response: stdout,
             durationMs,
@@ -3890,8 +3995,13 @@ export async function handleDevinRequestAsync(deps, params) {
         }
         assertUpstreamCliArgs("devin", args);
         assertUpstreamCliEnv("devin", undefined);
-        const devinAsyncFrHandoff = buildAsyncFlightRecorderHandoff("devin", prep, effectiveSessionId, undefined);
-        const job = deps.asyncJobManager.startJob("devin", args, corrId, undefined, resolveIdleTimeout("devin", params.idleTimeoutMs), undefined, params.forceRefresh, undefined, undefined, devinAsyncFrHandoff.flightRecorderEntry, devinAsyncFrHandoff.extractUsage, true);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: undefined,
+            outputSchemaDeclared: false,
+        });
+        const devinAsyncFrHandoff = buildAsyncFlightRecorderHandoff("devin", prep, effectiveSessionId, undefined, params.optimizePrompt);
+        const job = deps.asyncJobManager.startJob("devin", args, corrId, undefined, resolveIdleTimeout("devin", params.idleTimeoutMs), undefined, params.forceRefresh, undefined, undefined, devinAsyncFrHandoff.flightRecorderEntry, devinAsyncFrHandoff.extractUsage, true, undefined, effectiveCompress);
         deps.logger.info(`[${corrId}] devin_request_async started job ${job.id}`);
         return {
             content: [
@@ -4089,8 +4199,13 @@ export async function handleCursorRequest(deps, params) {
                 args[workspaceFlagIndex + 1] = worktreeResolution.workspace.cwd;
             }
         }
-        const cursorFrHandoff = buildAsyncFlightRecorderHandoff("cursor", prep, params.sessionId, params.outputFormat);
-        const result = await awaitJobOrDefer("cursor", args, corrId, resolveIdleTimeout("cursor", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, cursorFrHandoff.flightRecorderEntry, cursorFrHandoff.extractUsage, undefined, worktreeResolution.cwd);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: params.outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const cursorFrHandoff = buildAsyncFlightRecorderHandoff("cursor", prep, params.sessionId, params.outputFormat, params.optimizePrompt);
+        const result = await awaitJobOrDefer("cursor", args, corrId, resolveIdleTimeout("cursor", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, cursorFrHandoff.flightRecorderEntry, cursorFrHandoff.extractUsage, undefined, worktreeResolution.cwd, effectiveCompress);
         if (isDeferredResponse(result)) {
             return buildDeferredToolResponse(result, sessionResult.effectiveSessionId);
         }
@@ -4129,7 +4244,8 @@ export async function handleCursorRequest(deps, params) {
             const newSession = await deps.sessionManager.createSession("cursor", "Cursor Session", `${GATEWAY_SESSION_PREFIX}${randomUUID()}`);
             effectiveSessionId = newSession.id;
         }
-        const response = buildCliResponse("cursor", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, sessionResult.userProvidedSession, params.outputFormat);
+        const response = buildCliResponse("cursor", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, sessionResult.userProvidedSession, params.outputFormat, undefined, effectiveCompress);
+        safeRecordCompression(corrId, response.compression, runtime);
         safeFlightComplete(corrId, {
             response: stdout,
             durationMs,
@@ -4231,8 +4347,13 @@ export async function handleCursorRequestAsync(deps, params) {
         }
         assertUpstreamCliArgs("cursor", args);
         assertUpstreamCliEnv("cursor", undefined);
-        const cursorAsyncFrHandoff = buildAsyncFlightRecorderHandoff("cursor", prep, effectiveSessionId, params.outputFormat);
-        const job = deps.asyncJobManager.startJob("cursor", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("cursor", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, undefined, undefined, cursorAsyncFrHandoff.flightRecorderEntry, cursorAsyncFrHandoff.extractUsage, true);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: params.outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const cursorAsyncFrHandoff = buildAsyncFlightRecorderHandoff("cursor", prep, effectiveSessionId, params.outputFormat, params.optimizePrompt);
+        const job = deps.asyncJobManager.startJob("cursor", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("cursor", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, undefined, undefined, cursorAsyncFrHandoff.flightRecorderEntry, cursorAsyncFrHandoff.extractUsage, true, undefined, effectiveCompress);
         deps.logger.info(`[${corrId}] cursor_request_async started job ${job.id}`);
         return {
             content: [
@@ -4299,7 +4420,7 @@ export async function handleMistralRequest(deps, params) {
         stablePrefixHash: prep.stablePrefixHash ?? undefined,
         stablePrefixTokens: prep.stablePrefixTokens ?? undefined,
     }, runtime);
-    deps.logger.info(`[${corrId}] mistral_request invoked with model=${prep.resolvedModel || "default"}, permissionMode=${params.permissionMode || "auto-approve"}, prompt length=${prep.effectivePrompt.length}`);
+    deps.logger.info(`[${corrId}] mistral_request invoked with model=${prep.resolvedModel || "default"}, permissionMode=${resolveMistralAgentMode(params.approvalStrategy, params.permissionMode)}, prompt length=${prep.effectivePrompt.length}`);
     try {
         const sessionResult = resolveMistralSessionArgs({
             sessionId: params.sessionId,
@@ -4325,8 +4446,13 @@ export async function handleMistralRequest(deps, params) {
         catch (err) {
             return createErrorResponse("mistral_request", 1, "", corrId, err);
         }
-        const mistralFrHandoff = buildAsyncFlightRecorderHandoff("mistral", prep, params.sessionId, params.outputFormat);
-        let result = await awaitJobOrDefer("mistral", args, corrId, resolveIdleTimeout("mistral", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, mistralEnv, undefined, mistralFrHandoff.flightRecorderEntry, mistralFrHandoff.extractUsage, undefined, worktreeResolution.cwd);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: params.outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const mistralFrHandoff = buildAsyncFlightRecorderHandoff("mistral", prep, params.sessionId, params.outputFormat, params.optimizePrompt);
+        let result = await awaitJobOrDefer("mistral", args, corrId, resolveIdleTimeout("mistral", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, mistralEnv, undefined, mistralFrHandoff.flightRecorderEntry, mistralFrHandoff.extractUsage, undefined, worktreeResolution.cwd, effectiveCompress);
         if (isDeferredResponse(result)) {
             return buildDeferredToolResponse(result, sessionResult.effectiveSessionId);
         }
@@ -4336,7 +4462,7 @@ export async function handleMistralRequest(deps, params) {
                 deps.logger.info(`[${corrId}] mistral_request detected stale Vibe model selection; retrying once with ${recoveryModel}`);
                 const retryPrep = buildMistralRetryPrep({ ...params, effectivePrompt: prep.effectivePrompt }, recoveryModel);
                 const retryArgs = [...retryPrep.args, ...sessionResult.resumeArgs];
-                result = await awaitJobOrDefer("mistral", retryArgs, corrId, resolveIdleTimeout("mistral", params.idleTimeoutMs), params.outputFormat, true, runtime, retryPrep.env, undefined, mistralFrHandoff.flightRecorderEntry, mistralFrHandoff.extractUsage, undefined, worktreeResolution.cwd);
+                result = await awaitJobOrDefer("mistral", retryArgs, corrId, resolveIdleTimeout("mistral", params.idleTimeoutMs), params.outputFormat, true, runtime, retryPrep.env, undefined, mistralFrHandoff.flightRecorderEntry, mistralFrHandoff.extractUsage, undefined, worktreeResolution.cwd, effectiveCompress);
                 if (isDeferredResponse(result)) {
                     return buildDeferredToolResponse(result, sessionResult.effectiveSessionId);
                 }
@@ -4381,7 +4507,8 @@ export async function handleMistralRequest(deps, params) {
             effectiveSessionId = newSession.id;
         }
         deps.logger.info(`[${corrId}] mistral_request completed successfully in ${durationMs}ms`);
-        const response = buildCliResponse("mistral", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, sessionResult.userProvidedSession, params.outputFormat);
+        const response = buildCliResponse("mistral", stdout, params.optimizeResponse ?? false, corrId, effectiveSessionId, prep, durationMs, sessionResult.userProvidedSession, params.outputFormat, undefined, effectiveCompress);
+        safeRecordCompression(corrId, response.compression, runtime);
         if (worktreeResolution.worktreePath) {
             const first = response.content[0];
             if (first && first.type === "text") {
@@ -4489,8 +4616,13 @@ export async function handleMistralRequestAsync(deps, params) {
         }
         assertUpstreamCliArgs("mistral", args);
         assertUpstreamCliEnv("mistral", mistralEnv);
-        const mistralAsyncFrHandoff = buildAsyncFlightRecorderHandoff("mistral", prep, effectiveSessionId, params.outputFormat);
-        const job = deps.asyncJobManager.startJob("mistral", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("mistral", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, mistralEnv, undefined, mistralAsyncFrHandoff.flightRecorderEntry, mistralAsyncFrHandoff.extractUsage, true);
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: params.outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const mistralAsyncFrHandoff = buildAsyncFlightRecorderHandoff("mistral", prep, effectiveSessionId, params.outputFormat, params.optimizePrompt);
+        const job = deps.asyncJobManager.startJob("mistral", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("mistral", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, mistralEnv, undefined, mistralAsyncFrHandoff.flightRecorderEntry, mistralAsyncFrHandoff.extractUsage, true, undefined, effectiveCompress);
         deps.logger.info(`[${corrId}] mistral_request_async started job ${job.id}`);
         const asyncResponse = {
             success: true,
@@ -4619,15 +4751,14 @@ export async function handleCodexRequestAsync(deps, params) {
         }
         assertUpstreamCliArgs("codex", args);
         assertUpstreamCliEnv("codex", undefined);
-        const codexAsyncFrHandoff = buildAsyncFlightRecorderHandoff("codex", prep, effectiveSessionId, params.outputFormat);
-        let job;
-        try {
-            job = deps.asyncJobManager.startJob("codex", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("codex", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, undefined, prepCleanup, codexAsyncFrHandoff.flightRecorderEntry, codexAsyncFrHandoff.extractUsage, true);
-            prepCleanupOwnedHere = false;
-        }
-        catch (startErr) {
-            throw startErr;
-        }
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat: params.outputFormat,
+            outputSchemaDeclared: params.outputSchema !== undefined,
+        });
+        const codexAsyncFrHandoff = buildAsyncFlightRecorderHandoff("codex", prep, effectiveSessionId, params.outputFormat, params.optimizePrompt);
+        const job = deps.asyncJobManager.startJob("codex", args, corrId, worktreeResolution.cwd, resolveIdleTimeout("codex", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, undefined, prepCleanup, codexAsyncFrHandoff.flightRecorderEntry, codexAsyncFrHandoff.extractUsage, true, undefined, effectiveCompress);
+        prepCleanupOwnedHere = false;
         deps.logger.info(`[${corrId}] codex_request_async started job ${job.id}`);
         const asyncResponse = {
             success: true,
@@ -4656,6 +4787,439 @@ export async function handleCodexRequestAsync(deps, params) {
         return createErrorResponse("codex_request_async", 1, "", corrId, error);
     }
 }
+function routedOutputFormat(provider) {
+    return provider === "claude" || provider === "gemini" ? "stream-json" : "text";
+}
+function prepareRoutedCli(runtime, cli, params, outputFormat) {
+    const base = {
+        prompt: params.prompt,
+        promptParts: params.promptParts,
+        model: params.model,
+        correlationId: params.correlationId,
+        optimizePrompt: params.optimizePrompt,
+        operation: "route_request",
+        outputFormat,
+    };
+    switch (cli) {
+        case "claude": {
+            const p = {
+                ...base,
+                dangerouslySkipPermissions: false,
+                approvalStrategy: "legacy",
+                strictMcpConfig: false,
+            };
+            return prepareClaudeRequest(p, runtime);
+        }
+        case "codex": {
+            const p = {
+                ...base,
+                outputFormat: outputFormat,
+                fullAuto: false,
+                dangerouslyBypassApprovalsAndSandbox: false,
+                approvalStrategy: "legacy",
+            };
+            return prepareCodexRequest(p, runtime);
+        }
+        case "gemini": {
+            const p = { ...base, approvalStrategy: "legacy" };
+            return prepareGeminiRequest(p, runtime);
+        }
+        case "grok": {
+            const p = { ...base, approvalStrategy: "legacy" };
+            return prepareGrokRequest(p, runtime);
+        }
+        case "mistral": {
+            const p = { ...base, approvalStrategy: "legacy" };
+            return prepareMistralRequest(p, runtime);
+        }
+        case "devin": {
+            const p = { ...base };
+            return prepareDevinRequest(p, runtime);
+        }
+        case "cursor": {
+            const p = { ...base };
+            return prepareCursorRequest(p, runtime);
+        }
+        default: {
+            const exhaustive = cli;
+            return exhaustive;
+        }
+    }
+}
+async function dispatchRoutedCli(runtime, cli, params) {
+    const startTime = Date.now();
+    let durationMs = 0;
+    let wasSuccessful = false;
+    const outputFormat = routedOutputFormat(cli);
+    const prep = prepareRoutedCli(runtime, cli, params, outputFormat);
+    if (!("args" in prep))
+        return prep;
+    const { corrId, args } = prep;
+    const prepCleanup = "cleanup" in prep && typeof prep.cleanup === "function"
+        ? prep.cleanup
+        : undefined;
+    safeFlightStart({
+        correlationId: corrId,
+        cli,
+        model: prep.resolvedModel || "default",
+        prompt: prep.effectivePrompt,
+        stablePrefixHash: prep.stablePrefixHash ?? undefined,
+        stablePrefixTokens: prep.stablePrefixTokens ?? undefined,
+    }, runtime);
+    try {
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const frHandoff = buildAsyncFlightRecorderHandoff(cli, prep, undefined, outputFormat, params.optimizePrompt);
+        const result = await awaitJobOrDefer(cli, args, corrId, resolveIdleTimeout(cli, undefined), outputFormat, params.forceRefresh, runtime, undefined, prepCleanup, frHandoff.flightRecorderEntry, frHandoff.extractUsage, prep.stdinPayload, undefined, effectiveCompress);
+        if (isDeferredResponse(result)) {
+            return buildDeferredToolResponse(result, undefined);
+        }
+        const { stdout, stderr, code } = result;
+        durationMs = Math.max(0, Date.now() - startTime);
+        if (code !== 0) {
+            safeFlightComplete(corrId, {
+                response: stderr || "",
+                durationMs,
+                retryCount: 0,
+                circuitBreakerState: "closed",
+                optimizationApplied: params.optimizePrompt || params.optimizeResponse,
+                exitCode: code,
+                errorMessage: stderr || `Exit code ${code}`,
+                status: "failed",
+            }, runtime);
+            return createErrorResponse(cli, code, stderr, corrId);
+        }
+        wasSuccessful = true;
+        const claudeStream = cli === "claude" && outputFormat === "stream-json";
+        const parsedClaude = claudeStream ? parseStreamJson(stdout) : null;
+        const responseText = parsedClaude ? parsedClaude.text : stdout;
+        const usage = parsedClaude
+            ? {
+                inputTokens: parsedClaude.usage?.inputTokens,
+                outputTokens: parsedClaude.usage?.outputTokens,
+                cacheReadTokens: parsedClaude.usage?.cacheReadInputTokens || undefined,
+                cacheCreationTokens: parsedClaude.usage?.cacheCreationInputTokens || undefined,
+                costUsd: parsedClaude.costUsd ?? undefined,
+            }
+            : extractUsageAndCost(cli, stdout, outputFormat);
+        const meta = extractProviderOutputMetadata(cli, stdout, outputFormat);
+        const { costUsd: recordedCostUsd, costBasis } = deriveCostBasis(cli, prep.resolvedModel || "default", usage);
+        safeFlightComplete(corrId, {
+            response: cli === "codex" ? codexFrResponse(outputFormat, stdout) : responseText,
+            durationMs,
+            retryCount: 0,
+            circuitBreakerState: "closed",
+            optimizationApplied: params.optimizePrompt || params.optimizeResponse,
+            exitCode: 0,
+            status: "completed",
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cacheReadTokens: usage.cacheReadTokens,
+            cacheCreationTokens: usage.cacheCreationTokens,
+            costUsd: recordedCostUsd,
+            costBasis,
+            providerSessionId: parsedClaude ? (parsedClaude.sessionId ?? undefined) : meta.sessionId,
+            stopReason: parsedClaude ? (parsedClaude.stopReason ?? undefined) : meta.stopReason,
+        }, runtime);
+        const response = buildCliResponse(cli, responseText, params.optimizeResponse, corrId, undefined, prep, durationMs, undefined, outputFormat, undefined, effectiveCompress);
+        safeRecordCompression(corrId, response.compression, runtime);
+        return response;
+    }
+    catch (error) {
+        const elapsedMs = Math.max(0, Date.now() - startTime);
+        safeFlightComplete(corrId, {
+            response: "",
+            durationMs: elapsedMs,
+            retryCount: 0,
+            circuitBreakerState: "closed",
+            optimizationApplied: params.optimizePrompt || params.optimizeResponse,
+            exitCode: 1,
+            errorMessage: error.message,
+            status: "failed",
+        }, runtime);
+        return createErrorResponse(cli, 1, "", corrId, error);
+    }
+    finally {
+        const finalizedDurationMs = Math.max(0, durationMs || Date.now() - startTime);
+        runtime.performanceMetrics.recordRequest(cli, finalizedDurationMs, wasSuccessful);
+    }
+}
+async function dispatchRoutedRequest(runtime, chosen, params) {
+    if (isCliTypeValue(chosen.provider)) {
+        return dispatchRoutedCli(runtime, chosen.provider, params);
+    }
+    const api = enabledApiProviders(runtime.providers).find(p => p.name === chosen.provider);
+    if (!api) {
+        return createErrorResponse("route_request", 1, `Routed provider '${chosen.provider}' is not an enabled API provider`, params.correlationId);
+    }
+    const apiParams = {
+        prompt: params.prompt,
+        promptParts: params.promptParts,
+        model: chosen.model,
+        correlationId: params.correlationId,
+        optimizePrompt: params.optimizePrompt,
+        optimizeResponse: params.optimizeResponse,
+        compressResponse: params.compressResponse,
+    };
+    return handleApiProviderRequest(runtime, api, apiParams);
+}
+function isCliTypeValue(provider) {
+    return CLI_TYPES.includes(provider);
+}
+function routeCandidateKey(c) {
+    return `${c.provider}:${c.model}`;
+}
+export function isTransientRouteFailure(provider, response) {
+    const breakerOpen = isCliTypeValue(provider)
+        ? cliBreakerState(provider) !== "CLOSED"
+        : apiProviderBreakerState(provider) !== "CLOSED";
+    if (breakerOpen)
+        return true;
+    const sc = response.structuredContent;
+    if (isDefaultTransient({ code: sc?.exitCode }))
+        return true;
+    const haystack = `${response.content.map(c => c.text).join(" ")} ${sc?.errorCategory ?? ""}`;
+    return /\b(ETIMEDOUT|ECONNRESET|ECONNREFUSED|EPIPE)\b/i.test(haystack);
+}
+function attachRouting(response, block) {
+    response.routing = block;
+    response.structuredContent = { ...(response.structuredContent ?? {}), routing: block };
+    const chosen = block.chosen ? `${block.chosen.provider}/${block.chosen.model}` : "none";
+    const cost = block.estCostUsd !== undefined ? `~$${block.estCostUsd.toFixed(6)}` : "unpriced";
+    const basis = block.costBasis ? ` (${block.costBasis}, ${block.confidence})` : "";
+    const banner = `[routing] chosen=${chosen} est=${cost}${basis} considered=${block.consideredCount} reroutes=${block.reroutes}`;
+    const first = response.content[0];
+    if (first && first.type === "text") {
+        first.text = `${banner}\n${first.text}`;
+    }
+    else {
+        response.content.unshift({ type: "text", text: banner });
+    }
+    return response;
+}
+function buildRoutingBlock(decision, reroutes) {
+    return {
+        chosen: decision.chosen ? { ...decision.chosen } : null,
+        tier: decision.tier,
+        estCostUsd: decision.estCostUsd,
+        costBasis: decision.costBasis,
+        confidence: decision.confidence,
+        nearTie: decision.nearTie,
+        estInputTokens: decision.estInputTokens,
+        estOutputTokens: decision.estOutputTokens,
+        priceAsOf: decision.priceAsOf,
+        priceSource: decision.priceSource,
+        consideredCount: decision.consideredCount,
+        rejected: decision.rejected.map(r => ({ candidate: { ...r.candidate }, reason: r.reason })),
+        reroutes,
+        error: decision.error,
+    };
+}
+export function deriveCostBasis(provider, resolvedModel, usage) {
+    if (usage.costUsd != null) {
+        return { costUsd: usage.costUsd, costBasis: "provider-reported" };
+    }
+    const hasCounts = usage.inputTokens != null || usage.outputTokens != null;
+    if (hasCounts) {
+        const modelCost = getModelCost(provider, resolvedModel);
+        if (modelCost.source !== "unknown") {
+            const counts = {
+                inputTokens: usage.inputTokens ?? 0,
+                outputTokens: usage.outputTokens ?? 0,
+                cacheReadTokens: usage.cacheReadTokens,
+                cacheCreationTokens: usage.cacheCreationTokens,
+            };
+            const composed = composeCost(counts, { estInputTokens: 0, estOutputTokens: 0 }, modelCost);
+            return { costUsd: composed.costUsd, costBasis: composed.cost_basis };
+        }
+    }
+    return {};
+}
+function recordRoutingDecision(runtime, correlationId, decision, reroutes) {
+    const reason = decision.chosen
+        ? `cheapest${decision.nearTie ? ":near-tie" : ""}`
+        : (decision.error ?? "no-eligible");
+    safeRecordRouting(correlationId, {
+        estCostUsd: decision.estCostUsd ?? null,
+        estConfidence: decision.confidence ?? null,
+        reason,
+        considered: decision.consideredCount,
+        reroutes,
+    }, runtime);
+}
+function withDispatchRejections(decision, dispatchRejections) {
+    if (dispatchRejections.length === 0)
+        return decision;
+    const seen = new Set(decision.rejected.map(r => routeCandidateKey(r.candidate)));
+    const extra = dispatchRejections.filter(r => !seen.has(routeCandidateKey(r.candidate)));
+    return { ...decision, rejected: [...decision.rejected, ...extra] };
+}
+function routeErrorResponse(decision, reroutes, corrId, lastFailure) {
+    const reasons = decision.rejected
+        .map(r => `${routeCandidateKey(r.candidate)} (${r.reason})`)
+        .join(", ");
+    const kind = decision.error ?? "NoEligibleCandidate";
+    const base = kind === "BudgetExceeded"
+        ? `route_request: no candidate fits the budget. Rejected: ${reasons || "none eligible"}.`
+        : `route_request: no eligible candidate. Rejected: ${reasons || "empty pool"}.`;
+    const diag = lastFailure?.content?.[0]?.text
+        ? `\nLast dispatch failure: ${lastFailure.content[0].text}`
+        : "";
+    const resp = createErrorResponse("route_request", 1, `${base}${diag}`, corrId);
+    return attachRouting(resp, buildRoutingBlock({ ...decision, error: kind }, reroutes));
+}
+async function runRouteRequest(runtime, params) {
+    const corrId = params.correlationId ?? randomUUID();
+    const cfg = runtime.leastCost;
+    const { env, routerConfig, req } = buildRouteContext(runtime, params);
+    const excluded = new Set();
+    const dispatchRejections = [];
+    let reroutes = 0;
+    let transientReroutes = 0;
+    let lastFailure = null;
+    let lastDecision = null;
+    const maxIterations = env.providers().length * 8 + cfg.maxReroutes + 2;
+    for (let i = 0; i < maxIterations; i++) {
+        const decision = selectCandidate(req, env, routerConfig, excluded);
+        lastDecision = decision;
+        if (!decision.chosen) {
+            return routeErrorResponse(withDispatchRejections(decision, dispatchRejections), reroutes, corrId, lastFailure);
+        }
+        const chosen = decision.chosen;
+        const attemptCorrId = i === 0 ? corrId : randomUUID();
+        const dispatchParams = {
+            prompt: params.prompt,
+            promptParts: params.promptParts,
+            model: chosen.model,
+            correlationId: attemptCorrId,
+            optimizePrompt: params.optimizePrompt ?? false,
+            optimizeResponse: params.optimizeResponse ?? false,
+            compressResponse: params.compressResponse,
+            forceRefresh: params.forceRefresh,
+        };
+        const result = await dispatchRoutedRequest(runtime, chosen, dispatchParams);
+        if (!result.isError) {
+            recordRoutingDecision(runtime, attemptCorrId, decision, reroutes);
+            return attachRouting(result, buildRoutingBlock(decision, reroutes));
+        }
+        lastFailure = result;
+        const transient = isTransientRouteFailure(chosen.provider, result);
+        excluded.add(routeCandidateKey(chosen));
+        dispatchRejections.push({
+            candidate: chosen,
+            reason: transient ? "dispatch-failed:transient" : "dispatch-failed:non-transient",
+        });
+        reroutes++;
+        if (transient) {
+            transientReroutes++;
+            if (transientReroutes > cfg.maxReroutes) {
+                return attachRouting(result, buildRoutingBlock(decision, reroutes));
+            }
+        }
+    }
+    if (lastDecision) {
+        return routeErrorResponse(withDispatchRejections(lastDecision, dispatchRejections), reroutes, corrId, lastFailure);
+    }
+    return createErrorResponse("route_request", 1, "route_request: routing did not converge", corrId);
+}
+function buildRouteContext(runtime, params) {
+    return {
+        env: buildRouterEnv({
+            performanceMetrics: runtime.performanceMetrics,
+            limiterSnapshot: runtime.asyncJobManager.getLimiterSnapshot(),
+            apiProviders: enabledApiProviders(runtime.providers),
+            preferCatalogPrice: runtime.leastCost.preferCatalogPrice,
+            flightRecorder: runtime.flightRecorder,
+            priorsScope: runtime.leastCost.priorsScope,
+            ownerPrincipal: resolveOwnerPrincipal(getRequestContext()),
+        }),
+        routerConfig: toRouterConfig(runtime.leastCost),
+        req: {
+            prompt: params.prompt ?? "",
+            candidates: params.candidates,
+            minTier: params.minTier,
+            maxCostUsd: params.maxCostUsd,
+            expectedOutputTokens: params.expectedOutputTokens,
+            maxOutputTokens: params.maxOutputTokens,
+            requiredCapabilities: params.requiredCapabilities,
+            allowUnpriced: params.allowUnpriced,
+            budgetWaiver: params.budgetWaiver,
+            fallback: params.fallback,
+        },
+    };
+}
+async function dispatchRoutedCliAsync(runtime, cli, params) {
+    const outputFormat = routedOutputFormat(cli);
+    const prep = prepareRoutedCli(runtime, cli, params, outputFormat);
+    if (!("args" in prep))
+        return prep;
+    const { corrId, args } = prep;
+    const prepCleanup = "cleanup" in prep && typeof prep.cleanup === "function"
+        ? prep.cleanup
+        : undefined;
+    try {
+        const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+            compressResponse: params.compressResponse,
+            outputFormat,
+            outputSchemaDeclared: false,
+        });
+        const frHandoff = buildAsyncFlightRecorderHandoff(cli, prep, undefined, outputFormat, params.optimizePrompt);
+        const job = runtime.asyncJobManager.startJob(cli, args, corrId, undefined, resolveIdleTimeout(cli, undefined), outputFormat, params.forceRefresh, undefined, prepCleanup, frHandoff.flightRecorderEntry, frHandoff.extractUsage, true, prep.stdinPayload, effectiveCompress);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ success: true, job, sessionId: null }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return createErrorResponse("route_request_async", 1, "", corrId, error);
+    }
+}
+async function runRouteRequestAsync(runtime, params) {
+    const corrId = params.correlationId ?? randomUUID();
+    const { env, routerConfig, req } = buildRouteContext(runtime, params);
+    const decision = selectCandidate(req, env, routerConfig);
+    if (!decision.chosen) {
+        return routeErrorResponse(decision, 0, corrId);
+    }
+    const chosen = decision.chosen;
+    const dispatchParams = {
+        prompt: params.prompt,
+        promptParts: params.promptParts,
+        model: chosen.model,
+        correlationId: corrId,
+        optimizePrompt: params.optimizePrompt ?? false,
+        optimizeResponse: params.optimizeResponse ?? false,
+        compressResponse: params.compressResponse,
+        forceRefresh: params.forceRefresh,
+    };
+    let result;
+    if (isCliTypeValue(chosen.provider)) {
+        result = await dispatchRoutedCliAsync(runtime, chosen.provider, dispatchParams);
+    }
+    else {
+        const api = enabledApiProviders(runtime.providers).find(p => p.name === chosen.provider);
+        if (!api) {
+            return createErrorResponse("route_request_async", 1, `Routed provider '${chosen.provider}' is not an enabled API provider`, corrId);
+        }
+        result = await handleApiProviderRequestAsync(runtime, api, {
+            prompt: params.prompt,
+            promptParts: params.promptParts,
+            model: chosen.model,
+            correlationId: corrId,
+            optimizePrompt: params.optimizePrompt ?? false,
+            optimizeResponse: params.optimizeResponse ?? false,
+        });
+    }
+    recordRoutingDecision(runtime, corrId, decision, 0);
+    return attachRouting(result, buildRoutingBlock(decision, 0));
+}
 export function createGatewayServer(deps = {}) {
     const runtime = resolveGatewayServerRuntime(deps, { isolateState: true });
     const { sessionManager, asyncJobManager, approvalManager, performanceMetrics, logger, persistence, flightRecorder, cacheAwareness, providers, } = runtime;
@@ -4669,6 +5233,9 @@ export function createGatewayServer(deps = {}) {
         asyncJobManager,
         apiProviders: enabledApiProviders(providers),
         validationRunStore: asyncJobManager.getValidationRunStore(),
+        leastCost: runtime.leastCost,
+        performanceMetrics: runtime.performanceMetrics,
+        flightRecorder: runtime.flightRecorder,
     });
     registerWorkspaceTools(server, runtime);
     registerProviderAdminTools(server, {
@@ -4680,6 +5247,93 @@ export function createGatewayServer(deps = {}) {
     if (apiProviderTools.length > 0) {
         runtime.logger.info(`Registered API provider tools: ${apiProviderTools.join(", ")}`);
     }
+    if (runtime.leastCost.enabled) {
+        const RouteCandidateShape = z.object({
+            provider: z.string().min(1).describe("A CLI_TYPES member or an enabled API-provider name."),
+            model: z.string().min(1).describe("A concrete model id/alias that provider can serve."),
+        });
+        const RouteRequiredCapabilitiesShape = z
+            .object({
+            images: z.boolean().optional(),
+            attachments: z.boolean().optional(),
+            toolCalling: z.boolean().optional(),
+            jsonSchema: z.boolean().optional(),
+            outputFormat: z.string().optional(),
+            effort: z.string().optional(),
+        })
+            .describe("Hard capability constraints; a candidate missing any required capability is excluded.");
+        const routeInputShape = {
+            prompt: z
+                .string()
+                .min(1)
+                .max(100000)
+                .optional()
+                .describe("Prompt text to route (mutually exclusive with promptParts)."),
+            promptParts: PromptPartsSchema.optional().describe("Cache-aware structured prompt (mutually exclusive with prompt)."),
+            candidates: z
+                .array(RouteCandidateShape)
+                .optional()
+                .describe("Explicit (provider, model) pool to restrict routing to; also whitelists untiered / maintain-only candidates. Empty/omitted = all eligible."),
+            minTier: z
+                .enum(["economy", "standard", "frontier"])
+                .optional()
+                .describe("Minimum quality tier floor (default from config, usually 'standard'). No silent downgrade below it."),
+            maxCostUsd: z
+                .number()
+                .positive()
+                .optional()
+                .describe("Per-request budget cap (USD). Over-budget fails closed unless waived via an explicit fallback + budgetWaiver."),
+            maxOutputTokens: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe("Caller output cap; bounds the conservative budget estimate."),
+            expectedOutputTokens: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe("Expected output tokens for the ranking estimate (default from config)."),
+            requiredCapabilities: RouteRequiredCapabilitiesShape.optional(),
+            allowUnpriced: z
+                .boolean()
+                .optional()
+                .describe("Admit unpriced (source 'unknown') candidates. They still rank strictly last and cannot pass the budget gate without budgetWaiver."),
+            budgetWaiver: z
+                .boolean()
+                .optional()
+                .describe("Explicit acknowledgment to admit an unpriced or over-budget fallback candidate (with allowUnpriced / fallback)."),
+            fallback: RouteCandidateShape.optional().describe("A pinned (provider, model) used only when the eligible pool is empty; bypasses cost ranking but still passes eligibility + budget (unless budgetWaiver)."),
+            optimizePrompt: z
+                .boolean()
+                .optional()
+                .describe("Apply prompt token optimization before dispatch."),
+            optimizeResponse: z.boolean().optional().describe("Apply response token optimization."),
+            compressResponse: z
+                .boolean()
+                .optional()
+                .describe("Apply the native display-text compressor to the response."),
+            correlationId: z.string().optional().describe("Caller-supplied correlation id for tracing."),
+            forceRefresh: z
+                .boolean()
+                .optional()
+                .describe("Bypass the async dedup window for this request."),
+        };
+        const routeAnnotations = {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true,
+        };
+        server.tool("route_request", "Least-cost routing: pick the cheapest eligible (provider, model) candidate that meets the caller's quality tier, capability, and budget constraints, then dispatch it through the normal provider path. Returns the provider response plus a `routing` block (chosen candidate, cost estimate + basis/confidence, rejections, reroutes). Registered only when [least_cost].enabled is true.", routeInputShape, { title: "Least-cost route (sync)", ...routeAnnotations }, async (params) => runRouteRequest(runtime, params));
+        let registeredRouteTools = "route_request";
+        if (asyncJobsEnabled) {
+            server.tool("route_request_async", "Async least-cost routing: select the cheapest eligible (provider, model) candidate synchronously, enqueue it for background execution, and return a pollable job handle plus the `routing` block. Poll with llm_job_status, collect with llm_job_result. Registered only when [least_cost].enabled is true and async jobs are enabled.", routeInputShape, { title: "Least-cost route (async)", ...routeAnnotations }, async (params) => runRouteRequestAsync(runtime, params));
+            registeredRouteTools += ", route_request_async";
+        }
+        runtime.logger.info(`Registered least-cost routing tools: ${registeredRouteTools}`);
+    }
     if (grokApiToolsEnabled) {
         server.tool("grok_api_request", "Run an xAI Grok API request synchronously through the Responses API. Requires exactly one of prompt or promptParts. Registered only when [providers.xai] is configured and its API-key env var is present.", {
             prompt: z
@@ -4883,6 +5537,10 @@ export function createGatewayServer(deps = {}) {
         correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
         optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
         optimizeResponse: z.boolean().default(false).describe("Optimize response output"),
+        compressResponse: z
+            .boolean()
+            .optional()
+            .describe("Compress the response display text via the native compressor (default: [compression].enabled in config.toml, off unless opted in). Skipped for structured output."),
         idleTimeoutMs: z
             .number()
             .int()
@@ -4900,7 +5558,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, includeHookEvents, replayUserMessages, systemPromptFile, appendSystemPromptFile, name, pluginDir, pluginUrl, safeMode, bare, debug, debugFile, workspace, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, }) => {
+    }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, includeHookEvents, replayUserMessages, systemPromptFile, appendSystemPromptFile, name, pluginDir, pluginUrl, safeMode, bare, debug, debugFile, workspace, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, optimizeResponse, compressResponse, idleTimeoutMs, forceRefresh, }) => {
         const startTime = Date.now();
         if (systemPrompt !== undefined && appendSystemPrompt !== undefined) {
             return createErrorResponse("claude", 1, "", correlationId, new Error("systemPrompt and appendSystemPrompt are mutually exclusive; use one or the other (not both)."));
@@ -5020,8 +5678,13 @@ export function createGatewayServer(deps = {}) {
                 return createErrorResponse("claude_request", 1, "", corrId, err);
             }
             const effectiveIdleTimeout = outputFormat === "stream-json" ? resolveIdleTimeout("claude", idleTimeoutMs) : undefined;
-            const claudeSyncFrHandoff = buildAsyncFlightRecorderHandoff("claude", prep, effectiveSessionId, outputFormat);
-            const result = await awaitJobOrDefer("claude", args, corrId, effectiveIdleTimeout, outputFormat, forceRefresh, runtime, undefined, undefined, claudeSyncFrHandoff.flightRecorderEntry, claudeSyncFrHandoff.extractUsage, prep.stdinPayload, worktreeResolution.cwd);
+            const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+                compressResponse,
+                outputFormat,
+                outputSchemaDeclared: false,
+            });
+            const claudeSyncFrHandoff = buildAsyncFlightRecorderHandoff("claude", prep, effectiveSessionId, outputFormat, optimizePrompt);
+            const result = await awaitJobOrDefer("claude", args, corrId, effectiveIdleTimeout, outputFormat, forceRefresh, runtime, undefined, undefined, claudeSyncFrHandoff.flightRecorderEntry, claudeSyncFrHandoff.extractUsage, prep.stdinPayload, worktreeResolution.cwd, effectiveCompress);
             if (isDeferredResponse(result)) {
                 const deferred = buildDeferredToolResponse(result, effectiveSessionId);
                 if (warnings.length > 0) {
@@ -5062,6 +5725,13 @@ export function createGatewayServer(deps = {}) {
                 if (parsed.costUsd !== null) {
                     logger.debug(`[${corrId}] stream-json cost=$${parsed.costUsd}, model=${parsed.model}, turns=${parsed.numTurns}`);
                 }
+                const { costUsd: claudeCostUsd, costBasis: claudeCostBasis } = deriveCostBasis("claude", prep.resolvedModel || "default", {
+                    inputTokens: parsed.usage?.inputTokens,
+                    outputTokens: parsed.usage?.outputTokens,
+                    cacheReadTokens: parsed.usage?.cacheReadInputTokens || undefined,
+                    cacheCreationTokens: parsed.usage?.cacheCreationInputTokens || undefined,
+                    costUsd: parsed.costUsd ?? undefined,
+                });
                 safeFlightComplete(corrId, {
                     response: parsed.text,
                     inputTokens: parsed.usage?.inputTokens,
@@ -5071,14 +5741,16 @@ export function createGatewayServer(deps = {}) {
                     durationMs,
                     retryCount: 0,
                     circuitBreakerState: "closed",
-                    costUsd: parsed.costUsd ?? undefined,
+                    costUsd: claudeCostUsd,
+                    costBasis: claudeCostBasis,
                     optimizationApplied: optimizePrompt || optimizeResponse,
                     exitCode: 0,
                     status: "completed",
                     providerSessionId: parsed.sessionId ?? undefined,
                     stopReason: parsed.stopReason ?? undefined,
                 }, runtime);
-                const streamResponse = buildCliResponse("claude", parsed.text, optimizeResponse, corrId, effectiveSessionId, prep, durationMs, undefined, outputFormat, warnings);
+                const streamResponse = buildCliResponse("claude", parsed.text, optimizeResponse, corrId, effectiveSessionId, prep, durationMs, undefined, outputFormat, warnings, effectiveCompress);
+                safeRecordCompression(corrId, streamResponse.compression, runtime);
                 if (worktreeResolution.worktreePath) {
                     const first = streamResponse.content[0];
                     if (first && first.type === "text") {
@@ -5099,7 +5771,8 @@ export function createGatewayServer(deps = {}) {
                 providerSessionId: claudeMeta.sessionId,
                 stopReason: claudeMeta.stopReason,
             }, runtime);
-            const nonStreamResponse = buildCliResponse("claude", stdout, optimizeResponse, corrId, effectiveSessionId, prep, durationMs, undefined, outputFormat, warnings);
+            const nonStreamResponse = buildCliResponse("claude", stdout, optimizeResponse, corrId, effectiveSessionId, prep, durationMs, undefined, outputFormat, warnings, effectiveCompress);
+            safeRecordCompression(corrId, nonStreamResponse.compression, runtime);
             if (worktreeResolution.worktreePath) {
                 const first = nonStreamResponse.content[0];
                 if (first && first.type === "text") {
@@ -5181,6 +5854,10 @@ export function createGatewayServer(deps = {}) {
         correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
         optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
         optimizeResponse: z.boolean().default(false).describe("Optimize response output"),
+        compressResponse: z
+            .boolean()
+            .optional()
+            .describe("Compress the response display text via the native compressor (default: [compression].enabled in config.toml, off unless opted in). Skipped for structured output."),
         idleTimeoutMs: z
             .number()
             .int()
@@ -5245,7 +5922,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, enable, disable, strictConfig, oss, localProvider, color, outputLastMessage, dangerouslyBypassHookTrust, workspace, worktree, }) => {
+    }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, optimizeResponse, compressResponse, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, enable, disable, strictConfig, oss, localProvider, color, outputLastMessage, dangerouslyBypassHookTrust, workspace, worktree, }) => {
         const startTime = Date.now();
         const prep = prepareCodexRequest({
             prompt,
@@ -5307,7 +5984,7 @@ export function createGatewayServer(deps = {}) {
         }, runtime);
         logger.info(`[${corrId}] codex_request invoked with model=${prep.resolvedModel || "default"}, fullAuto=${fullAuto}, prompt length=${prep.effectivePrompt.length}`);
         const prepCleanup = "cleanup" in prep && typeof prep.cleanup === "function" ? prep.cleanup : undefined;
-        let worktreeResolution = {};
+        let worktreeResolution;
         try {
             worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
                 provider: "codex",
@@ -5323,8 +6000,13 @@ export function createGatewayServer(deps = {}) {
             return createErrorResponse("codex_request", 1, "", corrId, err);
         }
         try {
-            const codexSyncFrHandoff = buildAsyncFlightRecorderHandoff("codex", prep, sessionId, outputFormat);
-            const result = await awaitJobOrDefer("codex", args, corrId, resolveIdleTimeout("codex", idleTimeoutMs), outputFormat, forceRefresh, runtime, undefined, prepCleanup, codexSyncFrHandoff.flightRecorderEntry, codexSyncFrHandoff.extractUsage, undefined, worktreeResolution.cwd);
+            const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+                compressResponse,
+                outputFormat,
+                outputSchemaDeclared: outputSchema !== undefined,
+            });
+            const codexSyncFrHandoff = buildAsyncFlightRecorderHandoff("codex", prep, sessionId, outputFormat, optimizePrompt);
+            const result = await awaitJobOrDefer("codex", args, corrId, resolveIdleTimeout("codex", idleTimeoutMs), outputFormat, forceRefresh, runtime, undefined, prepCleanup, codexSyncFrHandoff.flightRecorderEntry, codexSyncFrHandoff.extractUsage, undefined, worktreeResolution.cwd, effectiveCompress);
             if (isDeferredResponse(result)) {
                 return buildDeferredToolResponse(result, sessionId);
             }
@@ -5375,6 +6057,7 @@ export function createGatewayServer(deps = {}) {
             }
             logger.info(`[${corrId}] codex_request completed successfully in ${durationMs}ms`);
             const codexUsage = extractUsageAndCost("codex", stdout, outputFormat);
+            const { costUsd: codexCostUsd, costBasis: codexCostBasis } = deriveCostBasis("codex", prep.resolvedModel || "default", codexUsage);
             const codexMeta = extractProviderOutputMetadata("codex", stdout, outputFormat);
             safeFlightComplete(corrId, {
                 response: codexFrResponse(outputFormat, stdout),
@@ -5388,11 +6071,13 @@ export function createGatewayServer(deps = {}) {
                 outputTokens: codexUsage.outputTokens,
                 cacheReadTokens: codexUsage.cacheReadTokens,
                 cacheCreationTokens: codexUsage.cacheCreationTokens,
-                costUsd: codexUsage.costUsd,
+                costUsd: codexCostUsd,
+                costBasis: codexCostBasis,
                 providerSessionId: codexMeta.sessionId,
                 stopReason: codexMeta.stopReason,
             }, runtime);
-            const codexResponse = buildCliResponse("codex", stdout, optimizeResponse, corrId, effectiveSessionId, prep, durationMs, undefined, outputFormat);
+            const codexResponse = buildCliResponse("codex", stdout, optimizeResponse, corrId, effectiveSessionId, prep, durationMs, undefined, outputFormat, undefined, effectiveCompress);
+            safeRecordCompression(corrId, codexResponse.compression, runtime);
             if (worktreeResolution.worktreePath) {
                 const first = codexResponse.content[0];
                 if (first && first.type === "text") {
@@ -5585,6 +6270,10 @@ export function createGatewayServer(deps = {}) {
         correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
         optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
         optimizeResponse: z.boolean().default(false).describe("Optimize response output"),
+        compressResponse: z
+            .boolean()
+            .optional()
+            .describe("Compress the response display text via the native compressor (default: [compression].enabled in config.toml, off unless opted in). Skipped for structured output."),
         idleTimeoutMs: z
             .number()
             .int()
@@ -5713,6 +6402,10 @@ export function createGatewayServer(deps = {}) {
         correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
         optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
         optimizeResponse: z.boolean().default(false).describe("Optimize response output"),
+        compressResponse: z
+            .boolean()
+            .optional()
+            .describe("Compress the response display text via the native compressor (default: [compression].enabled in config.toml, off unless opted in). Skipped for structured output."),
         idleTimeoutMs: z
             .number()
             .int()
@@ -5869,6 +6562,10 @@ export function createGatewayServer(deps = {}) {
         correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
         optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
         optimizeResponse: z.boolean().default(false).describe("Optimize response output"),
+        compressResponse: z
+            .boolean()
+            .optional()
+            .describe("Compress the response display text via the native compressor (default: [compression].enabled in config.toml, off unless opted in). Skipped for structured output."),
         idleTimeoutMs: z
             .number()
             .int()
@@ -5969,6 +6666,10 @@ export function createGatewayServer(deps = {}) {
         correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
         optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
         optimizeResponse: z.boolean().default(false).describe("Optimize response output"),
+        compressResponse: z
+            .boolean()
+            .optional()
+            .describe("Compress the response display text via the native compressor (default: [compression].enabled in config.toml, off unless opted in). Skipped for structured output."),
         idleTimeoutMs: z
             .number()
             .int()
@@ -6011,7 +6712,7 @@ export function createGatewayServer(deps = {}) {
             forceRefresh,
         });
     });
-    server.tool("mistral_request", "Run a Mistral Vibe CLI request synchronously (when async jobs are enabled, auto-defers to a pollable job past the sync deadline; otherwise runs to completion). Requires exactly one of prompt or promptParts. Defaults to --agent auto-approve (unattended tool execution); pass permissionMode plan or accept-edits for safer runs.", {
+    server.tool("mistral_request", "Run a Mistral Vibe CLI request synchronously (when async jobs are enabled, auto-defers to a pollable job past the sync deadline; otherwise runs to completion). Requires exactly one of prompt or promptParts. Defaults to --agent accept-edits (auto-accepts file edits; dangerous ops such as shell stay gated); pass permissionMode auto-approve (or set LLM_GATEWAY_APPROVAL_ALLOW_BYPASS) for unattended tool execution.", {
         prompt: z
             .string()
             .min(1, "Prompt cannot be empty")
@@ -6043,7 +6744,7 @@ export function createGatewayServer(deps = {}) {
         permissionMode: z
             .string()
             .optional()
-            .describe("Vibe --agent name. Builtins: default|plan|accept-edits|auto-approve; Vibe also accepts install-gated builtins (e.g. lean) and custom agents from ~/.vibe/agents, so any name is passed through. Defaults to auto-approve for programmatic use."),
+            .describe("Vibe --agent name. Builtins: default|plan|accept-edits|auto-approve; Vibe also accepts install-gated builtins (e.g. lean) and custom agents from ~/.vibe/agents, so any name is passed through. Defaults to accept-edits; pass auto-approve (or set LLM_GATEWAY_APPROVAL_ALLOW_BYPASS) for unattended tool execution."),
         approvalStrategy: z
             .enum(["legacy", "mcp_managed"])
             .default("legacy")
@@ -6067,6 +6768,10 @@ export function createGatewayServer(deps = {}) {
         correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
         optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
         optimizeResponse: z.boolean().default(false).describe("Optimize response output"),
+        compressResponse: z
+            .boolean()
+            .optional()
+            .describe("Compress the response display text via the native compressor (default: [compression].enabled in config.toml, off unless opted in). Skipped for structured output."),
         idleTimeoutMs: z
             .number()
             .int()
@@ -6263,6 +6968,10 @@ export function createGatewayServer(deps = {}) {
                 .describe("Restrict Claude to provided MCP config only"),
             correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
             optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
+            compressResponse: z
+                .boolean()
+                .optional()
+                .describe("Compress the response display text when collected via llm_job_result (native compressor; default: [compression].enabled)."),
             idleTimeoutMs: z
                 .number()
                 .int()
@@ -6280,7 +6989,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, includeHookEvents, replayUserMessages, systemPromptFile, appendSystemPromptFile, name, pluginDir, pluginUrl, safeMode, bare, debug, debugFile, workspace, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, includeHookEvents, replayUserMessages, systemPromptFile, appendSystemPromptFile, name, pluginDir, pluginUrl, safeMode, bare, debug, debugFile, workspace, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, compressResponse, idleTimeoutMs, forceRefresh, }) => {
             if (systemPrompt !== undefined && appendSystemPrompt !== undefined) {
                 return createErrorResponse("claude", 1, "", correlationId, new Error("systemPrompt and appendSystemPrompt are mutually exclusive; use one or the other (not both)."));
             }
@@ -6379,8 +7088,13 @@ export function createGatewayServer(deps = {}) {
                     : undefined;
                 assertUpstreamCliArgs("claude", args);
                 assertUpstreamCliEnv("claude", undefined);
-                const claudeAsyncFrHandoff = buildAsyncFlightRecorderHandoff("claude", prep, effectiveSessionId, outputFormat);
-                const job = asyncJobManager.startJob("claude", args, corrId, worktreeResolution.cwd, effectiveIdleTimeout, outputFormat, forceRefresh, undefined, undefined, claudeAsyncFrHandoff.flightRecorderEntry, claudeAsyncFrHandoff.extractUsage, true, prep.stdinPayload);
+                const effectiveCompress = resolveEffectiveCompression(runtime.compression, {
+                    compressResponse,
+                    outputFormat,
+                    outputSchemaDeclared: false,
+                });
+                const claudeAsyncFrHandoff = buildAsyncFlightRecorderHandoff("claude", prep, effectiveSessionId, outputFormat, optimizePrompt);
+                const job = asyncJobManager.startJob("claude", args, corrId, worktreeResolution.cwd, effectiveIdleTimeout, outputFormat, forceRefresh, undefined, undefined, claudeAsyncFrHandoff.flightRecorderEntry, claudeAsyncFrHandoff.extractUsage, true, prep.stdinPayload, effectiveCompress);
                 logger.info(`[${corrId}] claude_request_async started job ${job.id}, outputFormat=${outputFormat}`);
                 const asyncResponse = {
                     success: true,
@@ -6474,6 +7188,10 @@ export function createGatewayServer(deps = {}) {
             createNewSession: z.boolean().default(false).describe("Force a fresh session (no resume)"),
             correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
             optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
+            compressResponse: z
+                .boolean()
+                .optional()
+                .describe("Compress the response display text when collected via llm_job_result (native compressor; default: [compression].enabled)."),
             idleTimeoutMs: z
                 .number()
                 .int()
@@ -6523,7 +7241,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, enable, disable, strictConfig, oss, localProvider, color, outputLastMessage, dangerouslyBypassHookTrust, workspace, worktree, }) => {
+        }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, compressResponse, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, enable, disable, strictConfig, oss, localProvider, color, outputLastMessage, dangerouslyBypassHookTrust, workspace, worktree, }) => {
             return handleCodexRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -6541,6 +7259,7 @@ export function createGatewayServer(deps = {}) {
                 createNewSession,
                 correlationId,
                 optimizePrompt,
+                compressResponse,
                 idleTimeoutMs,
                 forceRefresh,
                 outputFormat,
@@ -6614,6 +7333,10 @@ export function createGatewayServer(deps = {}) {
                 LOCAL_INCLUDE_DIRS_FIELD_SUFFIX),
             correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
             optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
+            compressResponse: z
+                .boolean()
+                .optional()
+                .describe("Compress the response display text when collected via llm_job_result (native compressor; default: [compression].enabled)."),
             idleTimeoutMs: z
                 .number()
                 .int()
@@ -6663,7 +7386,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, project, newProject, printTimeout, workspace, worktree, }) => {
+        }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, compressResponse, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, project, newProject, printTimeout, workspace, worktree, }) => {
             return handleGeminiRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -6679,6 +7402,7 @@ export function createGatewayServer(deps = {}) {
                 includeDirs,
                 correlationId,
                 optimizePrompt,
+                compressResponse,
                 idleTimeoutMs,
                 forceRefresh,
                 outputFormat,
@@ -6752,6 +7476,10 @@ export function createGatewayServer(deps = {}) {
                 .describe("Disallowed built-in tools (passed as --disallowed-tools comma list)"),
             correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
             optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
+            compressResponse: z
+                .boolean()
+                .optional()
+                .describe("Compress the response display text when collected via llm_job_result (native compressor; default: [compression].enabled)."),
             idleTimeoutMs: z
                 .number()
                 .int()
@@ -6893,7 +7621,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, worktreeRef, forkSession, jsonSchema, workspace, worktree, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, compressResponse, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, worktreeRef, forkSession, jsonSchema, workspace, worktree, }) => {
             return handleGrokRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -6913,6 +7641,7 @@ export function createGatewayServer(deps = {}) {
                 disallowedTools,
                 correlationId,
                 optimizePrompt,
+                compressResponse,
                 idleTimeoutMs,
                 forceRefresh,
                 maxTurns,
@@ -6994,6 +7723,10 @@ export function createGatewayServer(deps = {}) {
             createNewSession: z.boolean().default(false).describe("Force a new session"),
             correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
             optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
+            compressResponse: z
+                .boolean()
+                .optional()
+                .describe("Compress the response display text when collected via llm_job_result (native compressor; default: [compression].enabled)."),
             idleTimeoutMs: z
                 .number()
                 .int()
@@ -7011,7 +7744,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, model, permissionMode, promptFile, config, sandbox, exportSession, respectWorkspaceTrust, agentConfig, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, }) => {
+        }, async ({ prompt, model, permissionMode, promptFile, config, sandbox, exportSession, respectWorkspaceTrust, agentConfig, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, compressResponse, idleTimeoutMs, forceRefresh, }) => {
             return handleDevinRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 model,
@@ -7027,6 +7760,7 @@ export function createGatewayServer(deps = {}) {
                 createNewSession,
                 correlationId,
                 optimizePrompt,
+                compressResponse,
                 idleTimeoutMs,
                 forceRefresh,
             });
@@ -7086,6 +7820,10 @@ export function createGatewayServer(deps = {}) {
                 .describe("Approval policy when approvalStrategy is mcp_managed: strict|balanced|permissive (default balanced). Ignored under legacy strategy."),
             correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
             optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
+            compressResponse: z
+                .boolean()
+                .optional()
+                .describe("Compress the response display text when collected via llm_job_result (native compressor; default: [compression].enabled)."),
             idleTimeoutMs: z
                 .number()
                 .int()
@@ -7103,7 +7841,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, model, mode, outputFormat, force, autoReview, sandbox, trust, workspace, addDir, sessionId, resumeLatest, createNewSession, approvalStrategy, approvalPolicy, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, }) => {
+        }, async ({ prompt, model, mode, outputFormat, force, autoReview, sandbox, trust, workspace, addDir, sessionId, resumeLatest, createNewSession, approvalStrategy, approvalPolicy, correlationId, optimizePrompt, compressResponse, idleTimeoutMs, forceRefresh, }) => {
             return handleCursorRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 model,
@@ -7122,6 +7860,7 @@ export function createGatewayServer(deps = {}) {
                 approvalPolicy,
                 correlationId,
                 optimizePrompt,
+                compressResponse,
                 idleTimeoutMs,
                 forceRefresh,
             });
@@ -7154,7 +7893,7 @@ export function createGatewayServer(deps = {}) {
             permissionMode: z
                 .string()
                 .optional()
-                .describe("Vibe --agent name. Builtins: default|plan|accept-edits|auto-approve; Vibe also accepts install-gated builtins (e.g. lean) and custom agents from ~/.vibe/agents, so any name is passed through. Defaults to auto-approve for programmatic use."),
+                .describe("Vibe --agent name. Builtins: default|plan|accept-edits|auto-approve; Vibe also accepts install-gated builtins (e.g. lean) and custom agents from ~/.vibe/agents, so any name is passed through. Defaults to accept-edits; pass auto-approve (or set LLM_GATEWAY_APPROVAL_ALLOW_BYPASS) for unattended tool execution."),
             approvalStrategy: z
                 .enum(["legacy", "mcp_managed"])
                 .default("legacy")
@@ -7177,6 +7916,10 @@ export function createGatewayServer(deps = {}) {
                 .describe("Accepted for caller parity; Vibe has no deny-list flag, so values are ignored (a warning is logged)."),
             correlationId: z.string().optional().describe("Request trace ID (auto if omitted)"),
             optimizePrompt: z.boolean().default(false).describe("Optimize prompt before execution"),
+            compressResponse: z
+                .boolean()
+                .optional()
+                .describe("Compress the response display text when collected via llm_job_result (native compressor; default: [compression].enabled)."),
             idleTimeoutMs: z
                 .number()
                 .int()
@@ -7214,7 +7957,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, workspace, worktree, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, compressResponse, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, workspace, worktree, }) => {
             return handleMistralRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -7231,6 +7974,7 @@ export function createGatewayServer(deps = {}) {
                 disallowedTools,
                 correlationId,
                 optimizePrompt,
+                compressResponse,
                 idleTimeoutMs,
                 forceRefresh,
                 trust,
@@ -7324,6 +8068,23 @@ export function createGatewayServer(deps = {}) {
                 result.stdout) {
                 result.stdout = codexDisplayText(result.stdout);
             }
+            const compressJob = asyncJobManager.getJobCompressResponse(jobId) && outputFormat !== "json";
+            if (compressJob && result.stdout) {
+                if (outputFormat === "stream-json" && parsed) {
+                    result.stdout = parsed.text;
+                }
+                const compressed = compressDisplayText(result.stdout, {
+                    provider: asyncJobManager.getJobCli(jobId) ?? "unknown",
+                    direction: "outbound",
+                    outputFormat,
+                    outputSchemaDeclared: false,
+                    lossless: true,
+                });
+                if (compressed.text !== result.stdout) {
+                    result.stdout = compressed.text;
+                    safeRecordCompression(result.correlationId, compressed, runtime);
+                }
+            }
             if (callerIsRemote()) {
                 const leakedId = result.providerSessionId;
                 delete result.providerSessionId;
@@ -7346,7 +8107,7 @@ export function createGatewayServer(deps = {}) {
                             ...(parsed
                                 ? {
                                     parsed: {
-                                        text: parsed.text,
+                                        ...(compressJob ? {} : { text: parsed.text }),
                                         costUsd: parsed.costUsd,
                                         usage: parsed.usage,
                                         model: parsed.model,
@@ -7354,7 +8115,7 @@ export function createGatewayServer(deps = {}) {
                                     },
                                 }
                                 : {}),
-                        }, null, 2),
+                        }, null, compressJob ? 0 : 2),
                     },
                 ],
             };
@@ -7476,21 +8237,28 @@ export function createGatewayServer(deps = {}) {
     }, async () => {
         const health = asyncJobManager.getJobHealth();
         const storeAttached = asyncJobManager.hasStore();
-        const asyncJobsEffective = persistence.backend !== "none" && persistence.asyncJobsEnabled && storeAttached;
+        const durableAdmission = asyncJobManager.getDurableAdmissionHealth();
+        const asyncJobsConfigured = persistence.backend !== "none" && persistence.asyncJobsEnabled;
+        const asyncJobsEffective = asyncJobsConfigured && storeAttached && durableAdmission.admitting;
         const persistenceBlock = {
             backend: persistence.backend,
             dbPath: persistence.path,
             dsn: persistence.dsn ? "[redacted]" : null,
             retentionDays: persistence.retentionDays,
             dedupWindowMs: persistence.dedupWindowMs,
+            asyncJobsConfigured,
+            storeAttached,
             asyncJobsEnabled: asyncJobsEffective,
+            durableAdmission,
             acknowledgeEphemeral: persistence.acknowledgeEphemeral,
             sources: persistence.sources,
             warning: asyncJobsEffective
                 ? null
                 : persistence.backend === "none"
                     ? "Async job persistence is disabled (backend = 'none'). *_request_async tools are NOT registered on this gateway. Set [persistence].backend = 'sqlite' (or 'memory' + acknowledgeEphemeral = true) to enable them."
-                    : `Async job persistence is configured (backend = '${persistence.backend}') but the durable job store failed to open, so *_request_async tools are NOT registered on this gateway. Check gateway startup logs for the store-open error.`,
+                    : !storeAttached
+                        ? `Async job persistence is configured (backend = '${persistence.backend}') but the durable job store failed to open, so *_request_async / llm_job_* tools are NOT registered on this gateway. Check gateway startup logs for the store-open error.`
+                        : "Async job persistence is attached but durable admission is temporarily disabled while its heartbeat lease recovers. Existing async tools fail closed until admission is restored.",
         };
         const outboundProviders = {
             xai: providers.xai
@@ -7556,6 +8324,46 @@ export function createGatewayServer(deps = {}) {
                 external: mem.external,
             },
         };
+        const leastCostBlock = (() => {
+            const lc = runtime.leastCost;
+            if (!lc.enabled)
+                return { enabled: false };
+            const env = buildRouterEnv({
+                performanceMetrics: runtime.performanceMetrics,
+                limiterSnapshot: runtime.asyncJobManager.getLimiterSnapshot(),
+                apiProviders: enabledApiProviders(runtime.providers),
+                preferCatalogPrice: lc.preferCatalogPrice,
+            });
+            const providerHealth = env.providers().map(provider => ({
+                provider,
+                telemetryTier: telemetryTierFor(provider),
+                authed: env.isAuthed(provider),
+                breakerState: env.breakerState(provider),
+                atCapacity: env.atCapacity(provider),
+                candidates: env.models(provider).map(model => {
+                    const mc = env.modelCost(provider, model);
+                    const family = modelIdToFamily(model);
+                    const tier = lc.tiers[`${provider}:${family}`];
+                    return {
+                        model,
+                        family: mc.family,
+                        priced: mc.source !== "unknown",
+                        priceSource: mc.source,
+                        tier: tier ?? null,
+                    };
+                }),
+            }));
+            return {
+                enabled: true,
+                minTier: lc.minTier,
+                maxCostUsd: lc.maxCostUsd,
+                priorsScope: lc.priorsScope,
+                preferCatalogPrice: lc.preferCatalogPrice,
+                allowUnpriced: lc.allowUnpriced,
+                maxReroutes: lc.maxReroutes,
+                providers: providerHealth,
+            };
+        })();
         return {
             content: [
                 {
@@ -7566,6 +8374,7 @@ export function createGatewayServer(deps = {}) {
                         backpressure,
                         persistence: persistenceBlock,
                         outboundProviders,
+                        leastCost: leastCostBlock,
                     }, null, 2),
                 },
             ],
@@ -8234,7 +9043,7 @@ async function initializeSessionManager() {
         });
         logger.info("File-based session manager initialized");
     }
-    resourceProvider = new ResourceProvider(sessionManager, performanceMetrics, getFlightRecorder(logger), getCacheAwarenessConfig(logger), getProvidersConfig(logger), undefined, getAcpConfig(logger));
+    resourceProvider = new ResourceProvider(sessionManager, performanceMetrics, getFlightRecorder(logger), getCacheAwarenessConfig(logger), getProvidersConfig(logger), undefined, getAcpConfig(logger), getLeastCostConfig(logger));
 }
 function registerHealthResource(server) {
     if (db) {
@@ -8261,20 +9070,26 @@ function registerHealthResource(server) {
         description: "Async job health (CPU, memory, zombie detection)",
         mimeType: "application/json",
     }, async (uri) => {
-        const health = getAsyncJobManager().getJobHealth();
+        const manager = getAsyncJobManager();
+        const health = manager.getJobHealth();
         return {
             contents: [
                 {
                     uri: uri.href,
                     mimeType: "application/json",
-                    text: JSON.stringify(health, null, 2),
+                    text: JSON.stringify({ ...health, durableAdmission: manager.getDurableAdmissionHealth() }, null, 2),
                 },
             ],
         };
     });
     logger.info("Process health resource registered");
 }
-async function shutdown(signal) {
+let shutdownPromise = null;
+function shutdown(signal, exitCode = 0) {
+    shutdownPromise ??= performShutdown(signal, exitCode);
+    return shutdownPromise;
+}
+async function performShutdown(signal, exitCode) {
     logger.info(`Received ${signal}, shutting down gracefully...`);
     try {
         if (asyncJobManager) {
@@ -8298,6 +9113,12 @@ async function shutdown(signal) {
             logger.info("MCP server closed");
             activeServer = null;
         }
+        if (jobStore) {
+            jobStore.close();
+            logger.info("Durable job store closed");
+            jobStore = null;
+            jobStoreInitialized = false;
+        }
         if (db) {
             await db.disconnect();
             logger.info("Database connections closed");
@@ -8306,7 +9127,7 @@ async function shutdown(signal) {
             flightRecorder.close();
             logger.info("Flight recorder closed");
         }
-        process.exit(0);
+        process.exit(exitCode);
     }
     catch (error) {
         logger.error("Error during shutdown:", error);
@@ -8700,15 +9521,23 @@ async function main() {
     logger.info(`Starting llm-cli-gateway MCP server with ${transportMode} transport`);
     await initializeSessionManager();
     void warmProviderCapabilities({ logger }).catch(() => undefined);
+    const persistence = getPersistenceConfig(logger);
+    const runtimeAsyncJobManager = getAsyncJobManager(logger);
+    if (persistence.backend !== "none" &&
+        persistence.asyncJobsEnabled &&
+        !runtimeAsyncJobManager.hasStore()) {
+        throw new Error(`Configured ${persistence.backend} job store could not be opened; refusing to start without durable async persistence`);
+    }
     const serverDeps = {
         sessionManager,
         resourceProvider,
         db,
         performanceMetrics,
-        asyncJobManager: getAsyncJobManager(logger),
+        asyncJobManager: runtimeAsyncJobManager,
         approvalManager: getApprovalManager(logger),
         flightRecorder: getFlightRecorder(logger),
         logger,
+        persistence,
     };
     if (transportMode === "http") {
         activeHttpGateway = await startHttpGateway({
@@ -8725,6 +9554,12 @@ async function main() {
     activeServer = createGatewayServer({
         ...serverDeps,
     });
+    activeServer.server.onclose = () => {
+        void shutdown("stdio MCP connection closed");
+    };
+    process.stdin.once("end", () => {
+        void shutdown("stdio stdin EOF");
+    });
     registerHealthResource(activeServer);
     const transport = new StdioServerTransport();
     await activeServer.connect(transport);
@@ -8734,6 +9569,6 @@ const __entryUrl = entrypointFileURL(process.argv[1]);
 if (__entryUrl === import.meta.url) {
     main().catch(error => {
         logger.error("Fatal server error:", error);
-        process.exit(1);
+        void shutdown("fatal startup error", 1);
     });
 }