llm-cli-gateway 2.14.1 → 2.16.0

package/dist/job-store.d.ts

@@ -10,6 +10,7 @@ export interface JobRecord {
     cli: string;
     argsJson: string;
     outputFormat?: string | null;
+    compressResponse?: boolean | null;
     status: JobStoreStatus;
     exitCode: number | null;
     stdout: string;
@@ -52,6 +53,7 @@ export interface JobStore {
         cli: string;
         args: string[];
         outputFormat?: string;
+        compressResponse?: boolean;
         startedAt: string;
         pid: number | null;
         ownerPrincipal?: string | null;
@@ -173,6 +175,7 @@ export declare class SqliteJobStore implements JobStore, ValidationRunStore {
         cli: string;
         args: string[];
         outputFormat?: string;
+        compressResponse?: boolean;
         startedAt: string;
         pid: number | null;
         ownerPrincipal?: string | null;
@@ -236,6 +239,7 @@ export declare class MemoryJobStore implements JobStore {
         cli: string;
         args: string[];
         outputFormat?: string;
+        compressResponse?: boolean;
         startedAt: string;
         pid: number | null;
         ownerPrincipal?: string | null;

package/dist/job-store.js

@@ -51,6 +51,9 @@ function rowToRecord(row) {
         cli: row.cli,
         argsJson: row.args_json,
         outputFormat: row.output_format ?? null,
+        compressResponse: row.compress_response === null || row.compress_response === undefined
+            ? null
+            : Boolean(row.compress_response),
         status: row.status,
         exitCode: row.exit_code,
         stdout: row.stdout ?? "",
@@ -99,6 +102,13 @@ function ensureJobsLeaseColumns(db) {
         db.exec("ALTER TABLE jobs ADD COLUMN lease_deadline INTEGER");
     }
 }
+function ensureJobsCompressResponseColumn(db) {
+    const cols = db.prepare("PRAGMA table_info(jobs)").all();
+    const names = new Set(cols.map(col => col?.name));
+    if (!names.has("compress_response")) {
+        db.exec("ALTER TABLE jobs ADD COLUMN compress_response INTEGER");
+    }
+}
 export function isValidationRunStore(store) {
     return (typeof store === "object" &&
         store !== null &&
@@ -143,6 +153,7 @@ export class SqliteJobStore {
         cli TEXT NOT NULL,
         args_json TEXT NOT NULL,
         output_format TEXT,
+        compress_response INTEGER,
         status TEXT NOT NULL,
         exit_code INTEGER,
         stdout TEXT,
@@ -216,6 +227,7 @@ export class SqliteJobStore {
         ensureJobsTransportColumns(this.db);
         ensureJobsLeaseColumns(this.db);
         this.db.exec("CREATE INDEX IF NOT EXISTS idx_jobs_owner_status ON jobs(owner_instance, status)");
+        ensureJobsCompressResponseColumn(this.db);
         if (process.platform !== "win32") {
             try {
                 chmodSync(dbPath, 0o600);
@@ -228,10 +240,12 @@ export class SqliteJobStore {
         this.leaseTtlMs = options.leaseTtlMs ?? DEFAULT_INSTANCE_LEASE_TTL_MS;
         this.insertStmt = this.db.prepare(`
       INSERT INTO jobs (id, correlation_id, request_key, cli, args_json, output_format,
+                        compress_response,
                         status, exit_code, stdout, stderr, output_truncated, error,
                         started_at, finished_at, pid, expires_at, owner_principal,
                         transport, http_status, payload_json, owner_instance, lease_deadline)
       VALUES (@id, @correlation_id, @request_key, @cli, @args_json, @output_format,
+              @compress_response,
               'queued', @exit_code, @stdout, @stderr, @output_truncated, @error,
               @started_at, @finished_at, @pid, @expires_at, @owner_principal,
               @transport, @http_status, @payload_json, @owner_instance,
@@ -332,6 +346,7 @@ export class SqliteJobStore {
             cli: input.cli,
             args_json: JSON.stringify(input.args),
             output_format: input.outputFormat ?? null,
+            compress_response: input.compressResponse === undefined ? null : input.compressResponse ? 1 : 0,
             exit_code: null,
             stdout: "",
             stderr: "",
@@ -624,6 +639,7 @@ export class MemoryJobStore {
             cli: input.cli,
             argsJson: JSON.stringify(input.args),
             outputFormat: input.outputFormat ?? null,
+            compressResponse: input.compressResponse ?? null,
             status: "queued",
             exitCode: null,
             stdout: "",

package/dist/provider-definitions.d.ts

@@ -119,6 +119,7 @@ export interface ProviderDefinition {
     readonly upstreamContract: ProviderUpstreamLinkage;
     readonly capabilityScope: CapabilityScope;
 }
+export declare const PROVIDER_TARGET_VERSIONS: Record<CliType, string>;
 export declare const PROVIDER_DEFINITIONS_BY_ID: Readonly<Record<CliType, ProviderDefinition>>;
 export declare function getAllProviderDefinitions(): readonly ProviderDefinition[];
 export declare function getProviderDefinition(id: CliType): ProviderDefinition;

package/dist/provider-definitions.js

@@ -4,6 +4,15 @@ export function adminSurfaceKind(family) {
     return family.kind ?? "cli-subcommand";
 }
 export const DEVIN_ACP_AGENT_TYPES = ["summarizer", "review"];
+export const PROVIDER_TARGET_VERSIONS = {
+    claude: "claude 2.1.206",
+    codex: "codex-cli 0.144.1",
+    gemini: "agy 1.1.0",
+    grok: "grok 0.2.93 (f00f96316d)",
+    mistral: "vibe 2.19.1",
+    devin: "devin 3000.1.27 (0d4bf12e)",
+    cursor: "cursor-agent 2026.07.09-c59fd9a",
+};
 const PROVIDER_DEFINITIONS = {
     claude: {
         id: "claude",
@@ -86,7 +95,7 @@ const PROVIDER_DEFINITIONS = {
             nativeEntrypoint: null,
             entrypoint: null,
             probeArgv: [],
-            evidence: "No native Claude Code ACP subcommand or flag in installed help (claude 2.1.198) or the official CLI reference. Coverage is CLI-first; ACP reporting says no native entrypoint is advertised.",
+            evidence: `No native Claude Code ACP subcommand or flag in installed help (${PROVIDER_TARGET_VERSIONS.claude}) or the official CLI reference. Coverage is CLI-first; ACP reporting says no native entrypoint is advertised.`,
         },
         safetyModes: {
             sandbox: false,
@@ -98,7 +107,10 @@ const PROVIDER_DEFINITIONS = {
         outputFormats: ["text", "json", "stream-json"],
         streamingFormats: ["stream-json"],
         resourcePolicy: { exposesModelsResource: true, exposesSessionsResource: true },
-        upstreamContract: { targetVersion: "Claude Code 2.1.198", helpChecksumRef: "claude--help.txt" },
+        upstreamContract: {
+            targetVersion: PROVIDER_TARGET_VERSIONS.claude,
+            helpChecksumRef: "claude--help.txt",
+        },
         capabilityScope: "full",
     },
     codex: {
@@ -215,7 +227,7 @@ const PROVIDER_DEFINITIONS = {
             nativeEntrypoint: null,
             entrypoint: null,
             probeArgv: [],
-            evidence: "codex-cli 0.142.4 advertises mcp-server and app-server transports, not a native ACP agent entrypoint. Third-party adapters exist but are documentation only and are never treated as native gateway ACP.",
+            evidence: `${PROVIDER_TARGET_VERSIONS.codex} advertises mcp-server and app-server transports, not a native ACP agent entrypoint. Third-party adapters exist but are documentation only and are never treated as native gateway ACP.`,
         },
         safetyModes: {
             sandbox: true,
@@ -233,7 +245,7 @@ const PROVIDER_DEFINITIONS = {
         streamingFormats: ["jsonl"],
         resourcePolicy: { exposesModelsResource: true, exposesSessionsResource: true },
         upstreamContract: {
-            targetVersion: "codex-cli 0.142.4",
+            targetVersion: PROVIDER_TARGET_VERSIONS.codex,
             helpChecksumRef: "codex-exec--help.txt",
         },
         capabilityScope: "full",
@@ -319,7 +331,7 @@ const PROVIDER_DEFINITIONS = {
             nativeEntrypoint: null,
             entrypoint: null,
             probeArgv: [],
-            evidence: "agy 1.0.14 has no ACP flag or subcommand in installed help or the Antigravity CLI docs. Legacy Gemini CLI ACP evidence does not transfer. No native entrypoint advertised.",
+            evidence: `${PROVIDER_TARGET_VERSIONS.gemini} has no ACP flag or subcommand in installed help or the Antigravity CLI docs. Legacy Gemini CLI ACP evidence does not transfer. No native entrypoint advertised.`,
         },
         safetyModes: {
             sandbox: true,
@@ -331,7 +343,10 @@ const PROVIDER_DEFINITIONS = {
         outputFormats: ["text"],
         streamingFormats: [],
         resourcePolicy: { exposesModelsResource: true, exposesSessionsResource: true },
-        upstreamContract: { targetVersion: "agy 1.0.14", helpChecksumRef: "agy--help.txt" },
+        upstreamContract: {
+            targetVersion: PROVIDER_TARGET_VERSIONS.gemini,
+            helpChecksumRef: "agy--help.txt",
+        },
         capabilityScope: "full",
     },
     grok: {
@@ -436,7 +451,7 @@ const PROVIDER_DEFINITIONS = {
         streamingFormats: ["json"],
         resourcePolicy: { exposesModelsResource: true, exposesSessionsResource: true },
         upstreamContract: {
-            targetVersion: "grok 0.2.77 (44e77bec3a)",
+            targetVersion: PROVIDER_TARGET_VERSIONS.grok,
             helpChecksumRef: "grok--help.txt",
         },
         capabilityScope: "full",
@@ -551,7 +566,10 @@ const PROVIDER_DEFINITIONS = {
         outputFormats: ["text", "json"],
         streamingFormats: [],
         resourcePolicy: { exposesModelsResource: true, exposesSessionsResource: true },
-        upstreamContract: { targetVersion: "vibe 2.18.3", helpChecksumRef: "vibe--help.txt" },
+        upstreamContract: {
+            targetVersion: PROVIDER_TARGET_VERSIONS.mistral,
+            helpChecksumRef: "vibe--help.txt",
+        },
         capabilityScope: "full",
     },
     devin: {
@@ -660,7 +678,7 @@ const PROVIDER_DEFINITIONS = {
         streamingFormats: [],
         resourcePolicy: { exposesModelsResource: true, exposesSessionsResource: true },
         upstreamContract: {
-            targetVersion: "devin 2026.8.18 (16737566)",
+            targetVersion: PROVIDER_TARGET_VERSIONS.devin,
             helpChecksumRef: "devin--help.txt",
         },
         capabilityScope: "full",
@@ -734,7 +752,7 @@ const PROVIDER_DEFINITIONS = {
         streamingFormats: ["stream-json"],
         resourcePolicy: { exposesModelsResource: true, exposesSessionsResource: true },
         upstreamContract: {
-            targetVersion: "cursor-agent 2026.06.29-2ad2186",
+            targetVersion: PROVIDER_TARGET_VERSIONS.cursor,
             helpChecksumRef: "cursor-agent--help.txt",
         },
         capabilityScope: "maintain-only",

package/dist/provider-tool-capabilities.js

@@ -4,7 +4,7 @@ import path from "path";
 import { parse as parseToml } from "smol-toml";
 import { CLAUDE_MCP_SERVER_NAMES } from "./claude-mcp-config.js";
 import { getAvailableCliInfo } from "./model-registry.js";
-import { CLI_TYPES, getProviderDefinition } from "./provider-definitions.js";
+import { CLI_TYPES, getProviderDefinition, PROVIDER_TARGET_VERSIONS, } from "./provider-definitions.js";
 import { enabledApiProviders, isXaiProviderEnabled, loadProvidersConfig, } from "./config.js";
 import { apiContinuityForKind } from "./api-provider.js";
 const MAX_SKILLS_PER_DIR = 100;
@@ -50,7 +50,7 @@ export const ACP_CONTRACT = {
         },
         gemini: {
             classification: "absent_watchlist",
-            summary: "Google Antigravity agy 1.0.14 has no ACP surface; watchlist item only.",
+            summary: `Google Antigravity ${PROVIDER_TARGET_VERSIONS.gemini} has no ACP surface; watchlist item only.`,
         },
         grok_api: {
             classification: "absent_watchlist",
@@ -110,7 +110,7 @@ const ACP_RESIDUAL = {
         smokeSupported: false,
         smokeStatus: "unsupported",
         caveats: [
-            "Antigravity agy 1.0.14 has no ACP flag or subcommand.",
+            `Antigravity ${PROVIDER_TARGET_VERSIONS.gemini} has no ACP flag or subcommand.`,
             "Legacy Gemini CLI ACP evidence does not transfer to agy; kept on the upstream drift watchlist.",
         ],
     },

package/dist/request-helpers.js

@@ -99,7 +99,7 @@ export const MISTRAL_BUILTIN_AGENT_MODES = [
     "accept-edits",
     "auto-approve",
 ];
-export const MISTRAL_DEFAULT_AGENT_MODE = "auto-approve";
+export const MISTRAL_DEFAULT_AGENT_MODE = "accept-edits";
 export function prepareMistralRequest(input) {
     const args = ["-p", input.prompt];
     const env = {};

package/dist/skill-loader.d.ts

@@ -0,0 +1,24 @@
+import type { Logger } from "./logger.js";
+export interface SkillEntry {
+    name: string;
+    content: string;
+    description: string;
+    source: "bundled" | "external";
+    path: string;
+    pack: {
+        name: string;
+        version: string;
+        manifestPath: string;
+        verified: boolean;
+    } | null;
+}
+export interface LoadGatewaySkillsOptions {
+    bundledSkillsDir: string;
+    configuredPaths?: string[];
+    envSkillsPath?: string | undefined;
+    userSkillsDir?: string;
+    logger?: Logger;
+}
+export declare function defaultUserSkillsDir(): string;
+export declare function parseSkillPathList(raw: string | undefined): string[];
+export declare function loadGatewaySkills(options: LoadGatewaySkillsOptions): SkillEntry[];

package/dist/skill-loader.js

@@ -0,0 +1,201 @@
+import { createHash } from "crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+import { z } from "zod/v3";
+import { logWarn, noopLogger } from "./logger.js";
+const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,62}$/;
+const SkillPackManifestSchema = z
+    .object({
+    name: z.string().regex(SKILL_NAME_PATTERN),
+    version: z.string().min(1),
+    skills: z
+        .array(z
+        .object({
+        name: z.string().regex(SKILL_NAME_PATTERN),
+        sha256: z.string().regex(/^[a-f0-9]{64}$/i),
+    })
+        .strict())
+        .default([]),
+})
+    .strict();
+export function defaultUserSkillsDir() {
+    return path.join(homedir(), ".llm-cli-gateway", "skills");
+}
+export function parseSkillPathList(raw) {
+    if (!raw)
+        return [];
+    return raw
+        .split(path.delimiter)
+        .map(part => part.trim())
+        .filter(Boolean);
+}
+export function loadGatewaySkills(options) {
+    const logger = options.logger ?? noopLogger;
+    const roots = [
+        { path: options.bundledSkillsDir, source: "bundled", label: "bundled" },
+        ...normalizeExternalRoots(options.configuredPaths ?? [], "configured"),
+        ...normalizeExternalRoots(parseSkillPathList(options.envSkillsPath), "LLM_GATEWAY_SKILLS_PATH"),
+    ];
+    const userSkillsDir = options.userSkillsDir ?? defaultUserSkillsDir();
+    if (existsSync(userSkillsDir)) {
+        roots.push({ path: userSkillsDir, source: "external", label: "user" });
+    }
+    const byName = new Map();
+    for (const root of roots) {
+        for (const skill of readSkillRoot(root, logger)) {
+            const prior = byName.get(skill.name);
+            if (prior) {
+                logWarn(logger, `Skill '${skill.name}' from ${skill.path} overrides ${prior.source} skill at ${prior.path}`);
+            }
+            byName.set(skill.name, skill);
+        }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function normalizeExternalRoots(paths, label) {
+    return paths.map(p => ({
+        path: expandHome(p),
+        source: "external",
+        label,
+    }));
+}
+function expandHome(p) {
+    return p === "~" ? homedir() : p.startsWith("~/") ? path.join(homedir(), p.slice(2)) : p;
+}
+function readSkillRoot(root, logger) {
+    if (!existsSync(root.path)) {
+        if (root.source === "external") {
+            logWarn(logger, `Configured skill path does not exist; skipping: ${root.path}`);
+        }
+        return [];
+    }
+    let stat;
+    try {
+        stat = statSync(root.path);
+    }
+    catch (err) {
+        logWarn(logger, `Cannot stat skill path; skipping: ${root.path}`, err);
+        return [];
+    }
+    if (!stat.isDirectory()) {
+        logWarn(logger, `Skill path is not a directory; skipping: ${root.path}`);
+        return [];
+    }
+    const manifest = readManifest(root, logger);
+    if (manifest === "invalid")
+        return [];
+    if (existsSync(path.join(root.path, "SKILL.md"))) {
+        const skill = readSkillDir(root.path, root, manifest, logger);
+        return skill ? [skill] : [];
+    }
+    let entries;
+    try {
+        entries = readdirSync(root.path, { withFileTypes: true });
+    }
+    catch (err) {
+        logWarn(logger, `Cannot read skill path; skipping: ${root.path}`, err);
+        return [];
+    }
+    const skills = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skill = readSkillDir(path.join(root.path, entry.name), root, manifest, logger);
+        if (skill)
+            skills.push(skill);
+    }
+    if (manifest && manifest.skills.length > 0) {
+        const loaded = new Set(skills.map(skill => skill.name));
+        for (const expected of manifest.skills) {
+            if (!loaded.has(expected.name)) {
+                logWarn(logger, `Skill pack '${manifest.name}' declares '${expected.name}', but no verified SKILL.md was loaded`);
+            }
+        }
+    }
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+function readManifest(root, logger) {
+    const manifestPath = path.join(root.path, "skill-pack.json");
+    if (!existsSync(manifestPath))
+        return null;
+    try {
+        const raw = JSON.parse(readFileSync(manifestPath, "utf8"));
+        return SkillPackManifestSchema.parse(raw);
+    }
+    catch (err) {
+        logWarn(logger, `Invalid skill-pack.json at ${manifestPath}; skipping skill pack`, err);
+        return "invalid";
+    }
+}
+function readSkillDir(skillDir, root, manifest, logger) {
+    const skillPath = path.join(skillDir, "SKILL.md");
+    if (!existsSync(skillPath))
+        return null;
+    let content;
+    try {
+        content = readFileSync(skillPath, "utf8");
+    }
+    catch (err) {
+        logWarn(logger, `Cannot read skill file; skipping: ${skillPath}`, err);
+        return null;
+    }
+    const frontmatter = parseSkillFrontmatter(content);
+    const dirName = path.basename(skillDir);
+    const name = frontmatter.name || dirName;
+    if (!SKILL_NAME_PATTERN.test(name)) {
+        logWarn(logger, `Invalid skill name '${name}' in ${skillPath}; skipping`);
+        return null;
+    }
+    if (frontmatter.name && frontmatter.name !== dirName) {
+        logWarn(logger, `Skill frontmatter name '${frontmatter.name}' does not match directory '${dirName}'; skipping ${skillPath}`);
+        return null;
+    }
+    const packInfo = verifyManifestEntry(name, content, skillPath, root, manifest, logger);
+    if (packInfo === "skip")
+        return null;
+    return {
+        name,
+        content,
+        description: frontmatter.description || name,
+        source: root.source,
+        path: skillPath,
+        pack: packInfo,
+    };
+}
+function verifyManifestEntry(name, content, skillPath, root, manifest, logger) {
+    if (!manifest)
+        return null;
+    const expected = manifest.skills.find(skill => skill.name === name);
+    if (!expected) {
+        logWarn(logger, `Skill pack '${manifest.name}' does not list '${name}' in skill-pack.json; skipping ${skillPath}`);
+        return "skip";
+    }
+    const actual = createHash("sha256").update(content, "utf8").digest("hex");
+    if (actual.toLowerCase() !== expected.sha256.toLowerCase()) {
+        logWarn(logger, `Skill pack '${manifest.name}' hash mismatch for '${name}'; skipping ${skillPath}`);
+        return "skip";
+    }
+    return {
+        name: manifest.name,
+        version: manifest.version,
+        manifestPath: path.join(root.path, "skill-pack.json"),
+        verified: true,
+    };
+}
+function parseSkillFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return { name: null, description: null };
+    return {
+        name: scalarFrontmatterValue(match[1], "name"),
+        description: scalarFrontmatterValue(match[1], "description"),
+    };
+}
+function scalarFrontmatterValue(frontmatter, key) {
+    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = frontmatter.match(new RegExp(`^${escapedKey}:\\s*(.+?)\\s*$`, "m"));
+    if (!match)
+        return null;
+    return match[1].replace(/^["']|["']$/g, "").trim();
+}

package/dist/spawn-env-isolation.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from "./logger.js";
+export declare function isRedirectionEnvKey(key: string): boolean;
+export declare function isSpawnEnvIsolationEnabled(env?: NodeJS.ProcessEnv): boolean;
+export interface SpawnEnvSanitizeResult {
+    env: NodeJS.ProcessEnv;
+    stripped: string[];
+}
+export declare function sanitizeSpawnEnv(baseEnv: NodeJS.ProcessEnv): SpawnEnvSanitizeResult;
+export declare function resetSpawnEnvIsolationWarning(): void;
+export declare function applySpawnEnvIsolation(finalEnv: NodeJS.ProcessEnv, logger?: Logger, env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/spawn-env-isolation.js

@@ -0,0 +1,55 @@
+import { logWarn } from "./logger.js";
+const REDIRECTION_SUFFIXES = [
+    /_BASE_URL$/,
+    /_API_URL$/,
+    /_API_BASE$/,
+    /_ENDPOINT$/,
+    /_ENDPOINT_URL$/,
+    /_SERVER_URL$/,
+];
+const REDIRECTION_EXACT = new Set([
+    "ANTHROPIC_UNIX_SOCKET",
+    "GROK_LEADER_SOCKET",
+]);
+export function isRedirectionEnvKey(key) {
+    const upper = key.toUpperCase();
+    if (upper === "NO_PROXY")
+        return false;
+    if (upper.endsWith("_PROXY"))
+        return true;
+    if (REDIRECTION_EXACT.has(upper))
+        return true;
+    return REDIRECTION_SUFFIXES.some(re => re.test(upper));
+}
+export function isSpawnEnvIsolationEnabled(env = process.env) {
+    const raw = (env.LLM_GATEWAY_ISOLATE_SPAWN_ENV ?? "").trim().toLowerCase();
+    return raw === "1" || raw === "true" || raw === "on" || raw === "yes";
+}
+export function sanitizeSpawnEnv(baseEnv) {
+    const env = {};
+    const stripped = [];
+    for (const key of Object.keys(baseEnv)) {
+        if (isRedirectionEnvKey(key)) {
+            stripped.push(key);
+            continue;
+        }
+        env[key] = baseEnv[key];
+    }
+    return { env, stripped };
+}
+let warnedOnce = false;
+export function resetSpawnEnvIsolationWarning() {
+    warnedOnce = false;
+}
+export function applySpawnEnvIsolation(finalEnv, logger, env = process.env) {
+    if (!isSpawnEnvIsolationEnabled(env))
+        return finalEnv;
+    const { env: sanitized, stripped } = sanitizeSpawnEnv(finalEnv);
+    if (stripped.length > 0 && logger && !warnedOnce) {
+        warnedOnce = true;
+        logWarn(logger, `spawn-env isolation: withheld ${stripped.length} endpoint/proxy redirection variable(s) ` +
+            `from provider child processes (${stripped.join(", ")}). ` +
+            `Unset LLM_GATEWAY_ISOLATE_SPAWN_ENV to disable.`);
+    }
+    return sanitized;
+}