llm-cli-gateway 2.5.0 → 2.6.3

package/dist/prompt-parts.js

@@ -60,14 +60,17 @@ export function assembleClaudeCacheBlocks(parts) {
     for (const [name, value] of stableEntries) {
         if (value === undefined || value.length === 0)
             continue;
-        const block = { type: "text", text: value };
+        const block = {
+            type: "text",
+            text: blocks.length > 0 ? `${SEPARATOR}${value}` : value,
+        };
         if (cc[name]) {
             block.cache_control = { type: "ephemeral", ttl: "1h" };
             markedBlockCount += 1;
         }
         blocks.push(block);
     }
-    blocks.push({ type: "text", text: parts.task });
+    blocks.push({ type: "text", text: blocks.length > 0 ? `${SEPARATOR}${parts.task}` : parts.task });
     return {
         payload: {
             type: "user",

package/dist/provider-codegen.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod/v3";
+import type { CliContract } from "./upstream-contracts.js";
+export type FlagEmitRule = "value_if_present" | "value_if_defined" | "flag_if_true" | "csv_if_nonempty" | "repeat_if_nonempty";
+export interface FlagGenerationMeta {
+    flag: string;
+    requestParameter: string;
+    emit: FlagEmitRule;
+    inputType: "string" | "number" | "boolean" | "string[]";
+    describe?: string;
+    minLength?: number;
+    numeric?: {
+        int?: boolean;
+        positive?: boolean;
+        safe?: boolean;
+        max?: number;
+        min?: number;
+    };
+}
+export declare function buildArgvFromGeneration(contract: CliContract, generation: readonly FlagGenerationMeta[], params: Record<string, unknown>): string[];
+export declare function deriveZodShapeFromGeneration(contract: CliContract, generation: readonly FlagGenerationMeta[]): Record<string, z.ZodTypeAny>;
+export declare const GROK_GEN_OUTPUT_FORMAT: readonly FlagGenerationMeta[];
+export declare const GROK_GEN_MAIN: readonly FlagGenerationMeta[];
+export declare const GROK_GEN_PROMPT_FILE: readonly FlagGenerationMeta[];
+export declare const GROK_GEN_SINGLE: readonly FlagGenerationMeta[];
+export declare const GROK_GEN_TAIL: readonly FlagGenerationMeta[];
+export declare const GROK_FLAG_GENERATION: readonly FlagGenerationMeta[];
+export declare const UNGENERATED_GROK_FLAGS: readonly string[];

package/dist/provider-codegen.js

@@ -0,0 +1,335 @@
+import { z } from "zod/v3";
+export function buildArgvFromGeneration(contract, generation, params) {
+    const args = [];
+    for (const gen of generation) {
+        if (!contract.flags[gen.flag]) {
+            throw new Error(`provider-codegen: generation references flag '${gen.flag}' absent from ${contract.cli} contract.flags`);
+        }
+        const value = params[gen.requestParameter];
+        switch (gen.emit) {
+            case "value_if_present":
+                if (value)
+                    args.push(gen.flag, String(value));
+                break;
+            case "value_if_defined":
+                if (value !== undefined && value !== null)
+                    args.push(gen.flag, String(value));
+                break;
+            case "flag_if_true":
+                if (value)
+                    args.push(gen.flag);
+                break;
+            case "csv_if_nonempty":
+                if (Array.isArray(value) && value.length > 0) {
+                    args.push(gen.flag, value.map(String).join(","));
+                }
+                break;
+            case "repeat_if_nonempty":
+                if (Array.isArray(value) && value.length > 0) {
+                    for (const item of value)
+                        args.push(gen.flag, String(item));
+                }
+                break;
+        }
+    }
+    return args;
+}
+export function deriveZodShapeFromGeneration(contract, generation) {
+    const shape = {};
+    for (const gen of generation) {
+        const flagContract = contract.flags[gen.flag];
+        if (!flagContract) {
+            throw new Error(`provider-codegen: generation references flag '${gen.flag}' absent from ${contract.cli} contract.flags`);
+        }
+        let field;
+        switch (gen.inputType) {
+            case "string": {
+                if (flagContract.values && flagContract.values.length > 0) {
+                    field = z.enum(flagContract.values);
+                }
+                else {
+                    let s = z.string();
+                    if (gen.minLength !== undefined)
+                        s = s.min(gen.minLength);
+                    field = s;
+                }
+                break;
+            }
+            case "number": {
+                let n = z.number();
+                if (gen.numeric?.int)
+                    n = n.int();
+                if (gen.numeric?.positive)
+                    n = n.positive();
+                if (gen.numeric?.safe)
+                    n = n.safe();
+                if (gen.numeric?.min !== undefined)
+                    n = n.min(gen.numeric.min);
+                if (gen.numeric?.max !== undefined)
+                    n = n.max(gen.numeric.max);
+                field = n;
+                break;
+            }
+            case "boolean":
+                field = z.boolean();
+                break;
+            case "string[]":
+                field = z.array(z.string());
+                break;
+        }
+        let optional = field.optional();
+        if (gen.describe !== undefined)
+            optional = optional.describe(gen.describe);
+        shape[gen.requestParameter] = optional;
+    }
+    return shape;
+}
+export const GROK_GEN_OUTPUT_FORMAT = [
+    {
+        flag: "--output-format",
+        requestParameter: "outputFormat",
+        emit: "value_if_present",
+        inputType: "string",
+        describe: "Output format (plain|json|streaming-json). Grok default is plain.",
+    },
+];
+const MAX_TURNS_NUMERIC = { int: true, positive: true, safe: true, max: 10_000 };
+export const GROK_GEN_MAIN = [
+    {
+        flag: "--effort",
+        requestParameter: "effort",
+        emit: "value_if_present",
+        inputType: "string",
+        describe: "Grok effort level",
+    },
+    {
+        flag: "--reasoning-effort",
+        requestParameter: "reasoningEffort",
+        emit: "value_if_present",
+        inputType: "string",
+        describe: "Reasoning effort for reasoning models",
+    },
+    {
+        flag: "--tools",
+        requestParameter: "allowedTools",
+        emit: "csv_if_nonempty",
+        inputType: "string[]",
+        describe: "Allowed built-in tools (passed as --tools comma list)",
+    },
+    {
+        flag: "--disallowed-tools",
+        requestParameter: "disallowedTools",
+        emit: "csv_if_nonempty",
+        inputType: "string[]",
+        describe: "Disallowed built-in tools (passed as --disallowed-tools comma list)",
+    },
+    {
+        flag: "--max-turns",
+        requestParameter: "maxTurns",
+        emit: "value_if_defined",
+        inputType: "number",
+        numeric: MAX_TURNS_NUMERIC,
+        describe: "Grok `--max-turns N`: cap on agent-loop iterations for cost / latency control (Phase 4 slice δ). Bounded to safe integers ≤ 10000.",
+    },
+    {
+        flag: "--cwd",
+        requestParameter: "workingDir",
+        emit: "value_if_present",
+        inputType: "string",
+        minLength: 1,
+        describe: "Grok --cwd <DIR>: working directory for this invocation. Lets headless callers run Grok against a directory other than the gateway process's cwd.",
+    },
+    {
+        flag: "--sandbox",
+        requestParameter: "sandbox",
+        emit: "value_if_present",
+        inputType: "string",
+        minLength: 1,
+        describe: "Grok --sandbox <PROFILE>: sandbox profile for filesystem and network access. Freeform per `grok --help` (no enum constraint on Grok 0.1.210); also settable via GROK_SANDBOX env var. Caller responsibility to pass a valid profile name.",
+    },
+    {
+        flag: "--rules",
+        requestParameter: "rules",
+        emit: "value_if_present",
+        inputType: "string",
+        minLength: 1,
+        describe: "Grok --rules <RULES>: extra rules to append to the system prompt. Supports `@file` prefix per `grok --help` to load from a file; gateway passes the value verbatim and lets Grok parse the prefix.",
+    },
+    {
+        flag: "--system-prompt-override",
+        requestParameter: "systemPromptOverride",
+        emit: "value_if_present",
+        inputType: "string",
+        minLength: 1,
+        describe: "Grok --system-prompt-override <PROMPT>: replace the agent's system prompt entirely. Distinct from Claude's --system-prompt / --append-system-prompt (Grok has only one override flag, not a pair).",
+    },
+    {
+        flag: "--allow",
+        requestParameter: "allow",
+        emit: "repeat_if_nonempty",
+        inputType: "string[]",
+        describe: 'Grok --allow <RULE>: permission allow rules. Each entry is emitted as its own --allow instance (per `grok --help`: "Repeat to add multiple rules").',
+    },
+    {
+        flag: "--deny",
+        requestParameter: "deny",
+        emit: "repeat_if_nonempty",
+        inputType: "string[]",
+        describe: 'Grok --deny <RULE>: permission deny rules. Each entry is emitted as its own --deny instance (per `grok --help`: "Repeat to add multiple rules").',
+    },
+    {
+        flag: "--compaction-mode",
+        requestParameter: "compactionMode",
+        emit: "value_if_present",
+        inputType: "string",
+        describe: "Grok --compaction-mode: summary (default; no pointer) | transcript (points at the raw transcript) | segments (persists per-segment markdown to grep). Sets GROK_COMPACTION_MODE.",
+    },
+    {
+        flag: "--compaction-detail",
+        requestParameter: "compactionDetail",
+        emit: "value_if_present",
+        inputType: "string",
+        describe: "Grok --compaction-detail: verbatim segment detail (none|minimal|balanced|verbose, default verbose). Only affects `--compaction-mode segments`. Sets GROK_COMPACTION_DETAIL.",
+    },
+    {
+        flag: "--agent",
+        requestParameter: "agent",
+        emit: "value_if_present",
+        inputType: "string",
+        minLength: 1,
+        describe: "Grok --agent <NAME>: agent name or definition file path.",
+    },
+    {
+        flag: "--best-of-n",
+        requestParameter: "bestOfN",
+        emit: "value_if_defined",
+        inputType: "number",
+        numeric: MAX_TURNS_NUMERIC,
+        describe: "Grok --best-of-n <N>: run the task N ways in parallel and pick the best (headless only).",
+    },
+    {
+        flag: "--check",
+        requestParameter: "check",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --check: append a self-verification loop to the prompt (headless only).",
+    },
+    {
+        flag: "--disable-web-search",
+        requestParameter: "disableWebSearch",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --disable-web-search: disable web search and remote retrieval tools.",
+    },
+    {
+        flag: "--todo-gate",
+        requestParameter: "todoGate",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --todo-gate: enable runtime turn-end TodoGate for this session (session-scoped, not persisted).",
+    },
+    {
+        flag: "--verbatim",
+        requestParameter: "verbatim",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --verbatim: send the prompt exactly as given. Also skips gateway optimizePrompt when true.",
+    },
+];
+export const GROK_GEN_PROMPT_FILE = [
+    {
+        flag: "--prompt-file",
+        requestParameter: "promptFile",
+        emit: "value_if_present",
+        inputType: "string",
+        minLength: 1,
+        describe: "Grok --prompt-file <PATH>: single-turn prompt loaded from a file.",
+    },
+];
+export const GROK_GEN_SINGLE = [
+    {
+        flag: "--single",
+        requestParameter: "single",
+        emit: "value_if_present",
+        inputType: "string",
+        minLength: 1,
+        describe: "Grok --single <PROMPT>: single-turn prompt (in addition to gateway -p).",
+    },
+];
+export const GROK_GEN_TAIL = [
+    {
+        flag: "--experimental-memory",
+        requestParameter: "experimentalMemory",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --experimental-memory: enable cross-session memory.",
+    },
+    {
+        flag: "--no-alt-screen",
+        requestParameter: "noAltScreen",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --no-alt-screen: run inline without alt screen.",
+    },
+    {
+        flag: "--no-memory",
+        requestParameter: "noMemory",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --no-memory: disable cross-session memory.",
+    },
+    {
+        flag: "--no-plan",
+        requestParameter: "noPlan",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --no-plan: disable plan mode.",
+    },
+    {
+        flag: "--no-subagents",
+        requestParameter: "noSubagents",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --no-subagents: disable subagent spawning.",
+    },
+    {
+        flag: "--oauth",
+        requestParameter: "oauth",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --oauth: use OAuth during authentication.",
+    },
+    {
+        flag: "--restore-code",
+        requestParameter: "restoreCode",
+        emit: "flag_if_true",
+        inputType: "boolean",
+        describe: "Grok --restore-code: check out the original session commit when resuming.",
+    },
+    {
+        flag: "--leader-socket",
+        requestParameter: "leaderSocket",
+        emit: "value_if_present",
+        inputType: "string",
+        minLength: 1,
+        describe: "Grok 0.2.32+ --leader-socket <PATH>: custom leader socket path (default ~/.grok/leader.sock). Targets an isolated leader process, e.g. a local/branch Grok build; name it ~/.grok/leader-*.sock to keep `grok leader list/kill` discovery working.",
+    },
+];
+export const GROK_FLAG_GENERATION = [
+    ...GROK_GEN_OUTPUT_FORMAT,
+    ...GROK_GEN_MAIN,
+    ...GROK_GEN_PROMPT_FILE,
+    ...GROK_GEN_SINGLE,
+    ...GROK_GEN_TAIL,
+];
+export const UNGENERATED_GROK_FLAGS = [
+    "--model",
+    "--always-approve",
+    "--permission-mode",
+    "--agents",
+    "--prompt-json",
+    "--worktree",
+    "-p",
+    "--resume",
+    "--continue",
+];

package/dist/provider-login-guidance.js

@@ -37,20 +37,20 @@ const GUIDANCE = {
     },
     gemini: {
         provider: "gemini",
-        displayName: "Gemini CLI",
+        displayName: "Google Antigravity CLI",
         install: {
-            summary: "Install Gemini CLI using Google's npm package or current official installer.",
-            commands: ["npm install -g @google/gemini-cli"],
-            documentationUrl: "https://github.com/google-gemini/gemini-cli",
+            summary: "Install Google Antigravity CLI using Google's current official installer.",
+            commands: ["curl -fsSL https://antigravity.google/cli/install.sh | bash"],
+            documentationUrl: "https://antigravity.google/docs/cli-overview",
         },
         login: {
-            summary: "Run Gemini CLI and complete Google's official sign-in flow when prompted.",
-            commands: ["gemini"],
-            credentialHandling: "Let Gemini CLI store credentials in its own local store. Do not paste OAuth files or API keys into chat.",
+            summary: "Run Antigravity CLI and complete Google's official sign-in flow when prompted.",
+            commands: ["agy"],
+            credentialHandling: "Let Antigravity store credentials in its own local store. Do not paste OAuth files or API keys into chat.",
         },
         verification: {
-            command: "gemini --version",
-            expected: "CLI is installed; doctor checks the local Gemini credential store for login evidence",
+            command: "agy --version",
+            expected: "CLI is installed; doctor checks local Gemini-compatible credential stores for login evidence",
         },
     },
     grok: {

package/dist/provider-status.js

@@ -3,7 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { getProviderLoginGuidance } from "./provider-login-guidance.js";
-import { envWithExtendedPath, getExtendedPath, resolveCommandForSpawn } from "./executor.js";
+import { envWithExtendedPath, getExtendedPath, providerCommandName, resolveCommandForSpawn, } from "./executor.js";
 const PROVIDERS = ["claude", "codex", "gemini", "grok", "mistral"];
 const VERSION_ARGS = {
     claude: ["--version"],
@@ -15,9 +15,9 @@ const VERSION_ARGS = {
 export const PROVIDER_COMMANDS = {
     claude: "claude",
     codex: "codex",
-    gemini: "gemini",
+    gemini: providerCommandName("gemini"),
     grok: "grok",
-    mistral: "vibe",
+    mistral: providerCommandName("mistral"),
 };
 const LOGIN_CHECKS = {
     claude: ["auth", "status", "--json"],
@@ -68,8 +68,8 @@ export function getProviderRuntimeStatus(provider) {
                 command: null,
                 credentialStore: store,
                 detail: store === "present"
-                    ? `Gemini auth detected via: ${matchedMethods.join(", ")}; contents were not inspected.`
-                    : "Gemini CLI is installed, but no credential store or auth env vars were found (oauth_creds.json, GEMINI_API_KEY, GOOGLE_API_KEY, or GOOGLE_CLOUD_PROJECT+GOOGLE_GENAI_USE_VERTEXAI).",
+                    ? `Antigravity auth detected via Gemini-compatible stores: ${matchedMethods.join(", ")}; contents were not inspected.`
+                    : "Antigravity CLI is installed, but no Gemini-compatible credential store or auth env vars were found (oauth_creds.json, GEMINI_API_KEY, GOOGLE_API_KEY, or GOOGLE_CLOUD_PROJECT+GOOGLE_GENAI_USE_VERTEXAI).",
             },
         };
     }

package/dist/request-helpers.js

@@ -514,12 +514,12 @@ export function resolveGeminiSessionPlan(opts) {
     if (opts.sessionId && !opts.createNewSession) {
         validateSessionId(opts.sessionId);
         return {
-            args: ["--resume", opts.sessionId],
+            args: ["--conversation", opts.sessionId],
             resumed: true,
         };
     }
     if (opts.resumeLatest && !opts.createNewSession) {
-        return { args: ["--resume", "latest"], resumed: false };
+        return { args: ["--continue"], resumed: false };
     }
     return { args: [], resumed: false };
 }