llm-cli-gateway 2.14.1 → 2.16.0

package/dist/compressor/transforms/json.js

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

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

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

package/dist/compressor/transforms/log.js

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

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

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

package/dist/compressor/transforms/whitespace.js

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

package/dist/config.d.ts

@@ -15,6 +15,13 @@ export interface Config {
     database?: DatabaseConfig;
     sessionTtl: number;
 }
+export interface SkillsConfig {
+    paths: string[];
+    sources: {
+        configFile: string | null;
+        envOverrides: string[];
+    };
+}
 export declare function loadConfig(): Config;
 export declare const PERSISTENCE_BACKENDS: readonly ["sqlite", "postgres", "memory", "none"];
 export type PersistenceBackend = (typeof PERSISTENCE_BACKENDS)[number];
@@ -46,6 +53,7 @@ export interface PersistenceConfigSources {
     envOverrides: string[];
 }
 export declare function defaultGatewayConfigPath(): string;
+export declare function loadSkillsConfig(logger?: Logger): SkillsConfig;
 export declare function loadPersistenceConfig(logger?: Logger): PersistenceConfig;
 export declare const DEFAULT_HTTP_MAX_SESSIONS = 100;
 export declare const DEFAULT_HTTP_SESSION_IDLE_TTL_MS: number;
@@ -103,6 +111,14 @@ export interface CacheAwarenessConfig {
     };
 }
 export declare function loadCacheAwarenessConfig(logger?: Logger): CacheAwarenessConfig;
+export interface CompressionConfig {
+    enabled: boolean;
+    sources: {
+        configFile: string | null;
+    };
+}
+export declare const DEFAULT_COMPRESSION_CONFIG: CompressionConfig;
+export declare function loadCompressionConfig(logger?: Logger): CompressionConfig;
 export declare function minStableTokensForModel(config: CacheAwarenessConfig, modelName: string): number;
 export declare const DEFAULT_XAI_API_KEY_ENV = "XAI_API_KEY";
 export declare const DEFAULT_XAI_BASE_URL = "https://api.x.ai/v1";

package/dist/config.js

@@ -14,6 +14,12 @@ const DatabaseUrlSchema = z
     message: "Database URL must start with postgresql:// or postgres://",
 });
 export const DEFAULT_SESSION_TTL_SECONDS = 2592000;
+const SkillsSchema = z
+    .object({
+    paths: z.array(z.string().min(1)).default([]),
+})
+    .strict()
+    .default({ paths: [] });
 export function loadConfig() {
     const databaseUrl = process.env.DATABASE_URL;
     const rawSessionTtl = parseInt(process.env.SESSION_TTL || String(DEFAULT_SESSION_TTL_SECONDS), 10);
@@ -89,6 +95,32 @@ function defaultPersistenceConfigPath() {
 export function defaultGatewayConfigPath() {
     return defaultPersistenceConfigPath();
 }
+export function loadSkillsConfig(logger = noopLogger) {
+    const configPath = defaultGatewayConfigPath();
+    const { parsed, sourcePath } = readGatewayTomlFile(configPath, logger, "skills");
+    const rawSkills = parsed?.skills ?? {};
+    const sources = {
+        configFile: sourcePath,
+        envOverrides: [],
+    };
+    let skillsParsed;
+    try {
+        skillsParsed = SkillsSchema.parse(rawSkills);
+    }
+    catch (err) {
+        throw new Error(`Invalid [skills] config: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const paths = [...skillsParsed.paths];
+    const envPaths = process.env.LLM_GATEWAY_SKILLS_PATH;
+    if (envPaths !== undefined && envPaths.trim().length > 0) {
+        paths.push(...envPaths
+            .split(path.delimiter)
+            .map(part => part.trim())
+            .filter(Boolean));
+        sources.envOverrides.push("LLM_GATEWAY_SKILLS_PATH");
+    }
+    return { paths, sources };
+}
 function readPersistenceFile(configPath, logger) {
     if (!existsSync(configPath)) {
         return { raw: undefined, sourcePath: null };
@@ -381,6 +413,31 @@ export function loadCacheAwarenessConfig(logger = noopLogger) {
         sources: { configFile: sourcePath },
     };
 }
+const CompressionSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+})
+    .strict();
+export const DEFAULT_COMPRESSION_CONFIG = {
+    enabled: false,
+    sources: { configFile: null },
+};
+export function loadCompressionConfig(logger = noopLogger) {
+    const configPath = defaultGatewayConfigPath();
+    const { parsed, sourcePath } = readGatewayTomlFile(configPath, logger, "compression");
+    const raw = parsed?.compression ?? {};
+    let parsedCompression;
+    try {
+        parsedCompression = CompressionSchema.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Invalid [compression] config: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {
+        enabled: parsedCompression.enabled,
+        sources: { configFile: sourcePath },
+    };
+}
 export function minStableTokensForModel(config, modelName) {
     const lower = modelName.toLowerCase();
     const table = config.minStableTokensForCacheControl;

package/dist/executor.d.ts

@@ -35,5 +35,6 @@ export declare function spawnCliProcess(command: string, args: string[], options
     cwd?: string;
     env: NodeJS.ProcessEnv;
     stdio: SpawnOptions["stdio"];
+    logger?: Logger;
 }): ChildProcess;
 export declare function executeCli(command: string, args: string[], options?: ExecuteOptions): Promise<ExecuteResult>;

package/dist/executor.js

@@ -3,6 +3,7 @@ import { homedir } from "os";
 import { delimiter, join, dirname, extname, win32 } from "path";
 import { readdirSync, existsSync } from "fs";
 import { createCircuitBreaker, withRetry } from "./retry.js";
+import { applySpawnEnvIsolation } from "./spawn-env-isolation.js";
 export function providerCommandName(command) {
     if (command === "gemini")
         return "agy";
@@ -309,9 +310,10 @@ function killWindowsProcessTree(pid) {
     return result.status === 0;
 }
 export function spawnCliProcess(command, args, options) {
+    const env = applySpawnEnvIsolation(options.env, options.logger);
     const detached = shouldDetachProviderProcess();
     const resolved = resolveCommandForSpawn(command, args, {
-        envPath: pathValueFromEnv(options.env, process.platform),
+        envPath: pathValueFromEnv(env, process.platform),
     });
     const proc = spawn(resolved.command, resolved.args, {
         cwd: options.cwd,
@@ -319,7 +321,7 @@ export function spawnCliProcess(command, args, options) {
         windowsHide: true,
         windowsVerbatimArguments: resolved.windowsVerbatimArguments,
         stdio: options.stdio,
-        env: options.env,
+        env,
     });
     if (proc.pid)
         registerProcessGroup(proc.pid);
@@ -337,6 +339,7 @@ export async function executeCli(command, args, options = {}) {
             cwd,
             stdio,
             env: { ...baseEnv, ...(extraEnv ?? {}) },
+            logger: options.logger,
         });
         if (stdin !== undefined && proc.stdin) {
             proc.stdin.write(stdin);

package/dist/flight-recorder.d.ts

@@ -37,6 +37,13 @@ interface LoggerLike {
     info: (message: string, ...args: any[]) => void;
     error: (message: string, ...args: any[]) => void;
 }
+export interface CompressionTelemetry {
+    route: string;
+    transforms: string[];
+    originalChars: number;
+    compressedChars: number;
+    estimatedTokensSaved: number;
+}
 export declare function resolveFlightRecorderDbPath(): string | null;
 export declare class FlightRecorder {
     private db;
@@ -51,6 +58,7 @@ export declare class FlightRecorder {
     });
     logStart(entry: FlightLogStart): void;
     logComplete(correlationId: string, result: FlightLogResult): void;
+    recordCompressionTelemetry(correlationId: string, telemetry: CompressionTelemetry): void;
     private redactStart;
     private redactResult;
     queryRequests<T = Record<string, unknown>>(sql: string, ...params: unknown[]): T[];
@@ -60,6 +68,7 @@ export declare class FlightRecorder {
 export declare class NoopFlightRecorder {
     logStart(_entry: FlightLogStart): void;
     logComplete(_correlationId: string, _result: FlightLogResult): void;
+    recordCompressionTelemetry(_correlationId: string, _telemetry: CompressionTelemetry): void;
     queryRequests<T = Record<string, unknown>>(_sql: string, ..._params: unknown[]): T[];
     flush(): void;
     close(): void;

package/dist/flight-recorder.js

@@ -64,6 +64,25 @@ function ensureMetadataProviderSessionColumns(db) {
         db.exec("ALTER TABLE gateway_metadata ADD COLUMN stop_reason TEXT");
     }
 }
+function ensureCompressionColumns(db) {
+    const rows = db.prepare("PRAGMA table_info(gateway_metadata)").all();
+    const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
+    if (!names.has("compression_route")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_route TEXT");
+    }
+    if (!names.has("compression_transforms")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_transforms TEXT");
+    }
+    if (!names.has("compression_original_chars")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_original_chars INTEGER");
+    }
+    if (!names.has("compression_compressed_chars")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_compressed_chars INTEGER");
+    }
+    if (!names.has("compression_tokens_saved_est")) {
+        db.exec("ALTER TABLE gateway_metadata ADD COLUMN compression_tokens_saved_est INTEGER");
+    }
+}
 export function resolveFlightRecorderDbPath() {
     const configured = process.env.LLM_GATEWAY_LOGS_DB;
     if (configured !== undefined) {
@@ -196,6 +215,10 @@ export class FlightRecorder {
         this.db
             .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(7, ?)")
             .run(new Date().toISOString());
+        ensureCompressionColumns(this.db);
+        this.db
+            .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(8, ?)")
+            .run(new Date().toISOString());
         if (process.platform !== "win32") {
             try {
                 chmodSync(dbPath, 0o600);
@@ -297,6 +320,24 @@ export class FlightRecorder {
     logComplete(correlationId, result) {
         this.updateCompleteTxn(correlationId, this.redactEnabled ? this.redactResult(result) : result);
     }
+    recordCompressionTelemetry(correlationId, telemetry) {
+        this.db
+            .prepare(`UPDATE gateway_metadata
+         SET compression_route = @route,
+             compression_transforms = @transforms,
+             compression_original_chars = @original_chars,
+             compression_compressed_chars = @compressed_chars,
+             compression_tokens_saved_est = @tokens_saved_est
+         WHERE request_id = @id AND compression_route IS NULL`)
+            .run({
+            id: correlationId,
+            route: telemetry.route,
+            transforms: telemetry.transforms.join(","),
+            original_chars: telemetry.originalChars,
+            compressed_chars: telemetry.compressedChars,
+            tokens_saved_est: telemetry.estimatedTokensSaved,
+        });
+    }
     redactStart(entry) {
         return {
             ...entry,
@@ -330,6 +371,7 @@ export class FlightRecorder {
 export class NoopFlightRecorder {
     logStart(_entry) { }
     logComplete(_correlationId, _result) { }
+    recordCompressionTelemetry(_correlationId, _telemetry) { }
     queryRequests(_sql, ..._params) {
         return [];
     }

package/dist/index.d.ts

@@ -4,7 +4,8 @@ import { z } from "zod/v3";
 import { ISessionManager, type CliType, type ProviderType } from "./session-manager.js";
 import { ResourceProvider } from "./resources.js";
 import { PerformanceMetrics } from "./metrics.js";
-import { type PersistenceConfig, type CacheAwarenessConfig, type ProvidersConfig, type ApiProviderRuntime, type AcpConfig, type AdminConfig } from "./config.js";
+import { type CompressResult } from "./compressor/index.js";
+import { type PersistenceConfig, type CacheAwarenessConfig, type CompressionConfig, type ProvidersConfig, type ApiProviderRuntime, type AcpConfig, type AdminConfig } from "./config.js";
 import { DatabaseConnection } from "./db.js";
 import { type DevinAcpAgentType } from "./provider-definitions.js";
 import { AsyncJobManager } from "./async-job-manager.js";
@@ -38,6 +39,7 @@ type ExtendedToolResponse = {
     };
     reviewIntegrity?: ReviewIntegrityResult;
     warnings?: WarningEntry[];
+    compression?: CompressResult;
 };
 export declare const logger: {
     info: (message: string, ...args: unknown[]) => void;
@@ -76,6 +78,7 @@ export interface GatewayServerDeps {
     logger?: GatewayLogger;
     persistence?: PersistenceConfig;
     cacheAwareness?: CacheAwarenessConfig;
+    compression?: CompressionConfig;
     providers?: ProvidersConfig;
     acpConfig?: AcpConfig;
     adminConfig?: AdminConfig;
@@ -92,6 +95,7 @@ export interface GatewayServerRuntime {
     logger: GatewayLogger;
     persistence: PersistenceConfig;
     cacheAwareness: CacheAwarenessConfig;
+    compression: CompressionConfig;
     providers: ProvidersConfig;
     acpConfig: AcpConfig;
     adminConfig: AdminConfig;
@@ -169,6 +173,11 @@ export declare function extractUsageAndCost(cli: CliType, output: string, output
     cacheCreationTokens?: number;
     costUsd?: number;
 };
+export declare function resolveEffectiveCompression(compression: CompressionConfig, input: {
+    compressResponse?: boolean;
+    outputFormat?: string;
+    outputSchemaDeclared?: boolean;
+}): boolean;
 export declare function registerBaseResources(server: McpServer, runtime: GatewayServerRuntime): void;
 interface CliRequestPrep {
     corrId: string;
@@ -344,6 +353,7 @@ export declare function prepareGrokRequest(params: {
     forkSession?: boolean;
     jsonSchema?: string | Record<string, unknown>;
 }, runtime?: GatewayServerRuntime): CliRequestPrep | ExtendedToolResponse;
+export declare function resolveMistralAgentMode(approvalStrategy: "legacy" | "mcp_managed" | undefined, callerMode: MistralAgentMode | undefined): MistralAgentMode;
 export declare function prepareMistralRequest(params: {
     prompt?: string;
     promptParts?: PromptParts;
@@ -374,7 +384,7 @@ export declare function buildMistralRetryPrep(params: Pick<MistralRequestParams,
     env: Record<string, string>;
     ignoredDisallowedTools: boolean;
 };
-export declare function buildCliResponse(cli: CliType, stdout: string, optimizeResponse: boolean, corrId: string, sessionId: string | undefined, prep: CliRequestPrep, durationMs: number, resumable?: boolean, outputFormat?: string, warnings?: WarningEntry[]): ExtendedToolResponse;
+export declare function buildCliResponse(cli: CliType, stdout: string, optimizeResponse: boolean, corrId: string, sessionId: string | undefined, prep: CliRequestPrep, durationMs: number, resumable?: boolean, outputFormat?: string, warnings?: WarningEntry[], compressResponse?: boolean): ExtendedToolResponse;
 export interface GrokApiRequestParams {
     prompt?: string;
     promptParts?: PromptParts;
@@ -427,6 +437,7 @@ export interface GeminiRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
     outputFormat?: "text" | "json" | "stream-json";
@@ -482,6 +493,7 @@ export interface GrokRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
     maxTurns?: number;
@@ -541,6 +553,7 @@ export interface DevinRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
 }
@@ -580,6 +593,7 @@ export interface CursorRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
 }
@@ -620,6 +634,7 @@ export interface MistralRequestParams {
     correlationId?: string;
     optimizePrompt: boolean;
     optimizeResponse?: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
     trust?: boolean;
@@ -653,6 +668,7 @@ export declare function handleCodexRequestAsync(deps: AsyncHandlerDeps, params:
     createNewSession: boolean;
     correlationId?: string;
     optimizePrompt: boolean;
+    compressResponse?: boolean;
     idleTimeoutMs?: number;
     forceRefresh?: boolean;
     outputFormat?: "text" | "json";