llm-cli-gateway 1.17.3 → 1.17.4

package/CHANGELOG.md

@@ -4,6 +4,36 @@ All notable changes to the llm-cli-gateway project.
 
 ## Unreleased
 
+## [1.17.4] - 2026-06-02: upstream contract compatibility
+
+Patch release that realigns the provider CLI contracts with the currently
+installed binaries (codex 0.135.0, grok 0.2.16, gemini 0.44.1, claude 2.1.159,
+vibe 2.12.1).
+
+### Fixed
+
+- Mistral: dropped the unsupported `--effort` / `--reasoning-effort` surface.
+  vibe 2.x argparse rejects both flags, so any `mistral_request` that passed
+  `effort` / `reasoningEffort` failed before reaching the model. Locked out with
+  two `expect:fail` conformance fixtures and a builder guard test.
+
+### Added
+
+- Grok: `--compaction-mode` (summary|transcript|segments) and
+  `--compaction-detail` (none|minimal|balanced|verbose) context controls, wired
+  as enum passthrough flags on `grok_request` / `grok_request_async`.
+- Gemini: a `yolo` boolean that emits `--yolo` (auto-approve all actions). It
+  routes through the mcp_managed approval gate and is never emitted alongside
+  `--approval-mode yolo`.
+- Claude: `--no-session-persistence`, `--setting-sources`, `--settings`, and
+  `--tools` exposed through `prepareClaudeHighImpactFlags`. `--betas` is left
+  out on purpose, since it is API-key only and the gateway runs Claude via OAuth.
+
+### Notes
+
+- Documented `--max-turns` as a known `--probe-installed` false-positive: claude
+  2.x hides it from `--help` but still accepts it.
+
 ## [1.17.3] - 2026-05-31 — Socket scanner prose cleanup
 
 Patch release that removes wording in shipped metadata that Socket classified

package/dist/index.d.ts

@@ -264,6 +264,10 @@ export declare function prepareClaudeRequest(params: {
     fallbackModel?: string;
     jsonSchema?: string | Record<string, unknown>;
     addDir?: string[];
+    noSessionPersistence?: boolean;
+    settingSources?: string;
+    settings?: string;
+    tools?: string[];
 }, runtime?: GatewayServerRuntime): CliRequestPrep | ExtendedToolResponse;
 export interface CodexRequestPrep extends CliRequestPrep {
     /**
@@ -340,6 +344,14 @@ export declare function prepareGeminiRequest(params: {
      * is undefined (preserves current prompt behaviour for legacy callers).
      */
     skipTrust?: boolean;
+    /**
+     * Emit `--yolo` (auto-approve all actions). Equivalent in effect to
+     * `approvalMode: "yolo"`; provided for CLI ergonomic parity. Routed
+     * through the same approval gate (sets `bypassRequested`), and never
+     * emitted alongside `--approval-mode yolo` so there is a single
+     * auto-approve path. Default undefined.
+     */
+    yolo?: boolean;
 }, runtime?: GatewayServerRuntime): CliRequestPrep | ExtendedToolResponse;
 export declare function prepareGrokRequest(params: {
     prompt?: string;
@@ -388,6 +400,16 @@ export declare function prepareGrokRequest(params: {
     systemPromptOverride?: string;
     allow?: string[];
     deny?: string[];
+    /**
+     * Grok 0.2.x context/compaction controls (both enum passthrough flags):
+     * - `compactionMode` → `--compaction-mode <summary|transcript|segments>`
+     *   (default summary; sets GROK_COMPACTION_MODE).
+     * - `compactionDetail` → `--compaction-detail <none|minimal|balanced|verbose>`
+     *   (default verbose; only affects `--compaction-mode segments`; sets
+     *   GROK_COMPACTION_DETAIL).
+     */
+    compactionMode?: string;
+    compactionDetail?: string;
 }, runtime?: GatewayServerRuntime): CliRequestPrep | ExtendedToolResponse;
 export declare function prepareMistralRequest(params: {
     prompt?: string;
@@ -395,8 +417,6 @@ export declare function prepareMistralRequest(params: {
     model?: string;
     outputFormat?: string;
     permissionMode?: MistralAgentMode;
-    effort?: string;
-    reasoningEffort?: string;
     allowedTools?: string[];
     disallowedTools?: string[];
     approvalStrategy: "legacy" | "mcp_managed";
@@ -432,7 +452,7 @@ export declare function prepareMistralRequest(params: {
  * through here, or a fresh-workspace / budgeted run can degrade on
  * the second attempt.
  */
-export declare function buildMistralRetryPrep(params: Pick<MistralRequestParams, "outputFormat" | "permissionMode" | "effort" | "reasoningEffort" | "allowedTools" | "disallowedTools" | "approvalStrategy" | "trust" | "maxTurns" | "maxPrice" | "maxTokens" | "workingDir" | "addDir"> & {
+export declare function buildMistralRetryPrep(params: Pick<MistralRequestParams, "outputFormat" | "permissionMode" | "allowedTools" | "disallowedTools" | "approvalStrategy" | "trust" | "maxTurns" | "maxPrice" | "maxTokens" | "workingDir" | "addDir"> & {
     effectivePrompt: string;
 }, recoveryModel: string): {
     args: string[];
@@ -468,6 +488,8 @@ export interface GeminiRequestParams {
     attachments?: string[];
     /** Phase 4 slice γ: emit `--skip-trust` for fresh-workspace headless runs. */
     skipTrust?: boolean;
+    /** Emit `--yolo` (auto-approve all). Equivalent to approvalMode "yolo"; gated identically. */
+    yolo?: boolean;
     /** Slice λ: run this request inside a gateway-owned git worktree. */
     worktree?: boolean | {
         name?: string;
@@ -525,6 +547,10 @@ export interface GrokRequestParams {
     allow?: string[];
     /** Phase 4 slice θ: Grok `--deny <RULE>` (repeatable; one entry per --deny instance). */
     deny?: string[];
+    /** Grok 0.2.x: `--compaction-mode <summary|transcript|segments>` context control. */
+    compactionMode?: string;
+    /** Grok 0.2.x: `--compaction-detail <none|minimal|balanced|verbose>`; only affects segments mode. */
+    compactionDetail?: string;
     /** Slice λ: run this request inside a gateway-owned git worktree. */
     worktree?: boolean | {
         name?: string;
@@ -542,8 +568,6 @@ export interface MistralRequestParams {
     resumeLatest: boolean;
     createNewSession: boolean;
     permissionMode?: MistralAgentMode;
-    effort?: string;
-    reasoningEffort?: string;
     approvalStrategy: "legacy" | "mcp_managed";
     approvalPolicy?: string;
     mcpServers?: ClaudeMcpServerName[];

package/dist/index.js

@@ -1273,6 +1273,10 @@ export function prepareClaudeRequest(params, runtime = resolveGatewayServerRunti
         fallbackModel: params.fallbackModel,
         jsonSchema: params.jsonSchema,
         addDir: params.addDir,
+        noSessionPersistence: params.noSessionPersistence,
+        settingSources: params.settingSources,
+        settings: params.settings,
+        tools: params.tools,
     }));
     return {
         corrId,
@@ -1506,7 +1510,7 @@ export function prepareGeminiRequest(params, runtime = resolveGatewayServerRunti
             cli: "gemini",
             operation: params.operation,
             prompt: assembledPrompt, // Use raw assembled prompt for review-context detection, not optimized
-            bypassRequested: params.approvalMode === "yolo",
+            bypassRequested: params.approvalMode === "yolo" || params.yolo === true,
             fullAuto: false,
             requestedMcpServers,
             allowedTools: params.allowedTools,
@@ -1546,6 +1550,13 @@ export function prepareGeminiRequest(params, runtime = resolveGatewayServerRunti
         args.push("--model", resolvedModel);
     if (effectiveApprovalMode)
         args.push("--approval-mode", effectiveApprovalMode);
+    // `--yolo` is functionally identical to `--approval-mode yolo`; emit it only
+    // when the caller asked for yolo AND we are not already emitting
+    // `--approval-mode yolo` (under mcp_managed the gate forces that mode), so
+    // there is never a redundant double auto-approve flag.
+    if (params.yolo && effectiveApprovalMode !== "yolo") {
+        args.push("--yolo");
+    }
     if (params.allowedTools && params.allowedTools.length > 0) {
         sanitizeCliArgValues(params.allowedTools, "allowedTools");
         params.allowedTools.forEach(tool => args.push("--allowed-tools", tool));
@@ -1694,6 +1705,12 @@ export function prepareGrokRequest(params, runtime = resolveGatewayServerRuntime
             args.push("--deny", rule);
         }
     }
+    if (params.compactionMode) {
+        args.push("--compaction-mode", params.compactionMode);
+    }
+    if (params.compactionDetail) {
+        args.push("--compaction-detail", params.compactionDetail);
+    }
     return {
         corrId,
         effectivePrompt,
@@ -1773,8 +1790,6 @@ export function prepareMistralRequest(params, runtime = resolveGatewayServerRunt
         resolvedModel,
         outputFormat: params.outputFormat,
         permissionMode: effectivePermissionMode,
-        effort: params.effort,
-        reasoningEffort: params.reasoningEffort,
         allowedTools: params.allowedTools,
         disallowedTools: params.disallowedTools,
         trust: params.trust,
@@ -1830,8 +1845,6 @@ export function buildMistralRetryPrep(params, recoveryModel) {
         permissionMode: params.approvalStrategy === "mcp_managed"
             ? "auto-approve"
             : (params.permissionMode ?? "auto-approve"),
-        effort: params.effort,
-        reasoningEffort: params.reasoningEffort,
         allowedTools: params.allowedTools,
         disallowedTools: params.disallowedTools,
         trust: params.trust,
@@ -1969,6 +1982,7 @@ export async function handleGeminiRequest(deps, params) {
         adminPolicyFiles: params.adminPolicyFiles,
         attachments: params.attachments,
         skipTrust: params.skipTrust,
+        yolo: params.yolo,
     }, runtime);
     if (!("args" in prep))
         return prep;
@@ -2111,6 +2125,7 @@ export async function handleGeminiRequestAsync(deps, params) {
         adminPolicyFiles: params.adminPolicyFiles,
         attachments: params.attachments,
         skipTrust: params.skipTrust,
+        yolo: params.yolo,
     }, runtime);
     if (!("args" in prep))
         return prep;
@@ -2210,6 +2225,8 @@ export async function handleGrokRequest(deps, params) {
         systemPromptOverride: params.systemPromptOverride,
         allow: params.allow,
         deny: params.deny,
+        compactionMode: params.compactionMode,
+        compactionDetail: params.compactionDetail,
     }, runtime);
     if (!("args" in prep))
         return prep;
@@ -2350,6 +2367,8 @@ export async function handleGrokRequestAsync(deps, params) {
         systemPromptOverride: params.systemPromptOverride,
         allow: params.allow,
         deny: params.deny,
+        compactionMode: params.compactionMode,
+        compactionDetail: params.compactionDetail,
     }, runtime);
     if (!("args" in prep))
         return prep;
@@ -2431,8 +2450,6 @@ export async function handleMistralRequest(deps, params) {
         model: params.model,
         outputFormat: params.outputFormat,
         permissionMode: params.permissionMode,
-        effort: params.effort,
-        reasoningEffort: params.reasoningEffort,
         allowedTools: params.allowedTools,
         disallowedTools: params.disallowedTools,
         approvalStrategy: params.approvalStrategy,
@@ -2582,8 +2599,6 @@ export async function handleMistralRequestAsync(deps, params) {
         model: params.model,
         outputFormat: params.outputFormat,
         permissionMode: params.permissionMode,
-        effort: params.effort,
-        reasoningEffort: params.reasoningEffort,
         allowedTools: params.allowedTools,
         disallowedTools: params.disallowedTools,
         approvalStrategy: params.approvalStrategy,
@@ -2920,6 +2935,25 @@ export function createGatewayServer(deps = {}) {
             .array(z.string())
             .optional()
             .describe("Claude --add-dir: additional directories the CLI is allowed to read/write beyond the process cwd. Each entry is emitted as its own --add-dir instance."),
+        // Claude session / settings / tools surface (2.x)
+        noSessionPersistence: z
+            .boolean()
+            .optional()
+            .describe("Claude --no-session-persistence: do not write this session to disk (ephemeral one-shot runs; mirrors codex --ephemeral)."),
+        settingSources: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Claude --setting-sources: comma-separated setting sources to load (user|project|local) for reproducible/isolated headless runs."),
+        settings: z
+            .string()
+            .min(1)
+            .optional()
+            .describe("Claude --settings: path to a settings JSON file or a JSON literal of additional settings. Powerful: settings can define hooks/permissions/model; passed verbatim."),
+        tools: z
+            .array(z.string())
+            .optional()
+            .describe('Claude --tools: restrict the available built-in tool set (distinct from allowedTools permission gating). Pass [""] to disable all tools.'),
         worktree: WORKTREE_SCHEMA.optional(),
         approvalStrategy: z
             .enum(["legacy", "mcp_managed"])
@@ -2951,7 +2985,7 @@ export function createGatewayServer(deps = {}) {
             .boolean()
             .default(false)
             .describe("Bypass dedup and force a fresh CLI run even if a recent identical request exists"),
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, 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, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, optimizeResponse, 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)."));
@@ -2984,6 +3018,10 @@ export function createGatewayServer(deps = {}) {
             fallbackModel,
             jsonSchema,
             addDir,
+            noSessionPersistence,
+            settingSources,
+            settings,
+            tools,
         }, runtime);
         if (!("args" in prep))
             return prep;
@@ -3600,8 +3638,12 @@ export function createGatewayServer(deps = {}) {
             .boolean()
             .default(false)
             .describe("Emit `--skip-trust` so Gemini trusts the workspace for this session and skips the interactive trust prompt (Phase 4 slice γ). Required for headless runs in fresh workspaces."),
+        yolo: z
+            .boolean()
+            .optional()
+            .describe("Emit `--yolo` to auto-approve all actions. Equivalent to approvalMode 'yolo'; routed through the same approval gate. Under mcp_managed the gate still decides."),
         worktree: WORKTREE_SCHEMA.optional(),
-    }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, worktree, }) => {
+    }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, worktree, }) => {
         return handleGeminiRequest({ sessionManager, logger, runtime }, {
             prompt,
             promptParts,
@@ -3626,6 +3668,7 @@ export function createGatewayServer(deps = {}) {
             adminPolicyFiles,
             attachments,
             skipTrust,
+            yolo,
             worktree,
         });
     });
@@ -3732,8 +3775,16 @@ export function createGatewayServer(deps = {}) {
             .array(z.string())
             .optional()
             .describe('Grok --deny <RULE>: permission deny rules. Each entry is emitted as its own --deny instance (per `grok --help`: "Repeat to add multiple rules").'),
+        compactionMode: z
+            .enum(["summary", "transcript", "segments"])
+            .optional()
+            .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."),
+        compactionDetail: z
+            .enum(["none", "minimal", "balanced", "verbose"])
+            .optional()
+            .describe("Grok --compaction-detail: verbatim segment detail (none|minimal|balanced|verbose, default verbose). Only affects `--compaction-mode segments`. Sets GROK_COMPACTION_DETAIL."),
         worktree: WORKTREE_SCHEMA.optional(),
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, worktree, }) => {
+    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, worktree, }) => {
         return handleGrokRequest({ sessionManager, logger, runtime }, {
             prompt,
             promptParts,
@@ -3763,6 +3814,8 @@ export function createGatewayServer(deps = {}) {
             systemPromptOverride,
             allow,
             deny,
+            compactionMode,
+            compactionDetail,
             worktree,
         });
     });
@@ -3798,11 +3851,6 @@ export function createGatewayServer(deps = {}) {
             .enum(MISTRAL_AGENT_MODES)
             .optional()
             .describe("Vibe agent mode (default|plan|accept-edits|auto-approve|chat|explore|lean). Defaults to auto-approve for programmatic use."),
-        effort: z
-            .enum(["low", "medium", "high", "xhigh", "max"])
-            .optional()
-            .describe("Vibe effort level"),
-        reasoningEffort: z.string().optional().describe("Reasoning effort for reasoning models"),
         approvalStrategy: z
             .enum(["legacy", "mcp_managed"])
             .default("legacy")
@@ -3855,7 +3903,7 @@ export function createGatewayServer(deps = {}) {
             .optional()
             .describe("Vibe --add-dir <DIR>: additional writable workspace directories. Each entry is emitted as its own --add-dir instance (Vibe states this flag may be specified multiple times)."),
         worktree: WORKTREE_SCHEMA.optional(),
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, worktree, }) => {
+    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, worktree, }) => {
         return handleMistralRequest({ sessionManager, logger, runtime }, {
             prompt,
             promptParts,
@@ -3865,8 +3913,6 @@ export function createGatewayServer(deps = {}) {
             resumeLatest,
             createNewSession,
             permissionMode,
-            effort,
-            reasoningEffort,
             approvalStrategy,
             approvalPolicy,
             mcpServers,
@@ -3984,6 +4030,25 @@ export function createGatewayServer(deps = {}) {
                 .array(z.string())
                 .optional()
                 .describe("Claude --add-dir: additional directories the CLI is allowed to read/write beyond the process cwd. Each entry is emitted as its own --add-dir instance."),
+            // Claude session / settings / tools surface (2.x)
+            noSessionPersistence: z
+                .boolean()
+                .optional()
+                .describe("Claude --no-session-persistence: do not write this session to disk (ephemeral one-shot runs; mirrors codex --ephemeral)."),
+            settingSources: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Claude --setting-sources: comma-separated setting sources to load (user|project|local) for reproducible/isolated headless runs."),
+            settings: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Claude --settings: path to a settings JSON file or a JSON literal of additional settings. Powerful: settings can define hooks/permissions/model; passed verbatim."),
+            tools: z
+                .array(z.string())
+                .optional()
+                .describe('Claude --tools: restrict the available built-in tool set (distinct from allowedTools permission gating). Pass [""] to disable all tools.'),
             worktree: WORKTREE_SCHEMA.optional(),
             approvalStrategy: z
                 .enum(["legacy", "mcp_managed"])
@@ -4014,7 +4079,7 @@ export function createGatewayServer(deps = {}) {
                 .boolean()
                 .default(false)
                 .describe("Bypass dedup and force a fresh CLI run even if a recent identical request exists"),
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, 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, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, 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)."));
             }
@@ -4046,6 +4111,10 @@ export function createGatewayServer(deps = {}) {
                 fallbackModel,
                 jsonSchema,
                 addDir,
+                noSessionPersistence,
+                settingSources,
+                settings,
+                tools,
             }, runtime);
             if (!("args" in prep))
                 return prep;
@@ -4335,8 +4404,12 @@ export function createGatewayServer(deps = {}) {
                 .boolean()
                 .default(false)
                 .describe("Emit `--skip-trust` so Gemini trusts the workspace for this session and skips the interactive trust prompt (Phase 4 slice γ). Required for headless runs in fresh workspaces."),
+            yolo: z
+                .boolean()
+                .optional()
+                .describe("Emit `--yolo` to auto-approve all actions. Equivalent to approvalMode 'yolo'; routed through the same approval gate. Under mcp_managed the gate still decides."),
             worktree: WORKTREE_SCHEMA.optional(),
-        }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, worktree, }) => {
+        }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, worktree, }) => {
             return handleGeminiRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4360,6 +4433,7 @@ export function createGatewayServer(deps = {}) {
                 adminPolicyFiles,
                 attachments,
                 skipTrust,
+                yolo,
                 worktree,
             });
         });
@@ -4462,8 +4536,16 @@ export function createGatewayServer(deps = {}) {
                 .array(z.string())
                 .optional()
                 .describe("Grok --deny <RULE>: permission deny rules. Each entry → its own --deny instance."),
+            compactionMode: z
+                .enum(["summary", "transcript", "segments"])
+                .optional()
+                .describe("Grok --compaction-mode: summary (default) | transcript | segments. Sets GROK_COMPACTION_MODE."),
+            compactionDetail: z
+                .enum(["none", "minimal", "balanced", "verbose"])
+                .optional()
+                .describe("Grok --compaction-detail: segment verbatim detail (none|minimal|balanced|verbose, default verbose). Only affects segments mode. Sets GROK_COMPACTION_DETAIL."),
             worktree: WORKTREE_SCHEMA.optional(),
-        }, 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, worktree, }) => {
+        }, 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, worktree, }) => {
             return handleGrokRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4492,6 +4574,8 @@ export function createGatewayServer(deps = {}) {
                 systemPromptOverride,
                 allow,
                 deny,
+                compactionMode,
+                compactionDetail,
                 worktree,
             });
         });
@@ -4524,11 +4608,6 @@ export function createGatewayServer(deps = {}) {
                 .enum(MISTRAL_AGENT_MODES)
                 .optional()
                 .describe("Vibe agent mode (default|plan|accept-edits|auto-approve|chat|explore|lean). Defaults to auto-approve for programmatic use."),
-            effort: z
-                .enum(["low", "medium", "high", "xhigh", "max"])
-                .optional()
-                .describe("Vibe effort level"),
-            reasoningEffort: z.string().optional().describe("Reasoning effort for reasoning models"),
             approvalStrategy: z
                 .enum(["legacy", "mcp_managed"])
                 .default("legacy")
@@ -4580,7 +4659,7 @@ export function createGatewayServer(deps = {}) {
                 .optional()
                 .describe("Vibe --add-dir <DIR>: additional writable workspace directories. Each entry is emitted as its own --add-dir instance."),
             worktree: WORKTREE_SCHEMA.optional(),
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, worktree, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, worktree, }) => {
             return handleMistralRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4590,8 +4669,6 @@ export function createGatewayServer(deps = {}) {
                 resumeLatest,
                 createNewSession,
                 permissionMode,
-                effort,
-                reasoningEffort,
                 approvalStrategy,
                 approvalPolicy,
                 mcpServers,

package/dist/prompt-parts.d.ts

@@ -35,32 +35,32 @@ export declare const PromptPartsSchema: z.ZodObject<{
         tools: z.ZodOptional<z.ZodBoolean>;
         context: z.ZodOptional<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
-        system?: boolean | undefined;
         tools?: boolean | undefined;
+        system?: boolean | undefined;
         context?: boolean | undefined;
     }, {
-        system?: boolean | undefined;
         tools?: boolean | undefined;
+        system?: boolean | undefined;
         context?: boolean | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     task: string;
-    system?: string | undefined;
     tools?: string | undefined;
+    system?: string | undefined;
     context?: string | undefined;
     cacheControl?: {
-        system?: boolean | undefined;
         tools?: boolean | undefined;
+        system?: boolean | undefined;
         context?: boolean | undefined;
     } | undefined;
 }, {
     task: string;
-    system?: string | undefined;
     tools?: string | undefined;
+    system?: string | undefined;
     context?: string | undefined;
     cacheControl?: {
-        system?: boolean | undefined;
         tools?: boolean | undefined;
+        system?: boolean | undefined;
         context?: boolean | undefined;
     } | undefined;
 }>;

package/dist/request-helpers.d.ts

@@ -98,8 +98,6 @@ export interface PrepareMistralRequestInput {
     resolvedModel?: string;
     outputFormat?: string;
     permissionMode?: MistralAgentMode;
-    effort?: string;
-    reasoningEffort?: string;
     allowedTools?: string[];
     /**
      * Vibe has no flag to deny tools; this is accepted in the schema for caller
@@ -391,6 +389,30 @@ export interface ClaudeHighImpactFlagsInput {
      * changing the call site).
      */
     addDir?: string[];
+    /**
+     * Claude `--no-session-persistence`: do not write this session to disk
+     * (one-shot / ephemeral runs; mirrors Codex `--ephemeral`).
+     */
+    noSessionPersistence?: boolean;
+    /**
+     * Claude `--setting-sources <user,project,local>`: comma-separated list of
+     * setting sources to load, for reproducible / isolated headless runs.
+     * Passed through verbatim.
+     */
+    settingSources?: string;
+    /**
+     * Claude `--settings <file-or-json>`: load additional settings from a JSON
+     * file path or a JSON literal. Powerful: settings can define hooks,
+     * permissions, and model; the value is passed through verbatim.
+     */
+    settings?: string;
+    /**
+     * Claude `--tools <tools...>`: restrict the available built-in tool set
+     * (distinct from `--allowed-tools` permission gating). Emitted as a single
+     * variadic flag mirroring `--allowed-tools`; pass `[""]` to disable all
+     * tools per `claude --help`. An empty array emits nothing.
+     */
+    tools?: string[];
 }
 /**
  * Emit Claude high-impact feature flags (U25) as a flat argv segment.

package/dist/request-helpers.js

@@ -166,12 +166,8 @@ export function prepareMistralRequest(input) {
     }
     const mode = input.permissionMode ?? MISTRAL_DEFAULT_AGENT_MODE;
     args.push("--agent", mode);
-    if (input.effort) {
-        args.push("--effort", input.effort);
-    }
-    if (input.reasoningEffort) {
-        args.push("--reasoning-effort", input.reasoningEffort);
-    }
+    // No reasoning-effort surface on vibe: --effort / --reasoning-effort are not
+    // emitted (the CLI rejects them; see upstream-contracts.ts mistral block).
     if (input.allowedTools && input.allowedTools.length > 0) {
         sanitizeCliArgValues(input.allowedTools, "allowedTools");
         for (const tool of input.allowedTools) {
@@ -471,6 +467,20 @@ export function prepareClaudeHighImpactFlags(input) {
             args.push("--add-dir", dir);
         }
     }
+    if (input.noSessionPersistence) {
+        args.push("--no-session-persistence");
+    }
+    if (input.settingSources !== undefined) {
+        args.push("--setting-sources", input.settingSources);
+    }
+    if (input.settings !== undefined) {
+        args.push("--settings", input.settings);
+    }
+    if (input.tools && input.tools.length > 0) {
+        // Single variadic flag (mirrors --allowed-tools emission). `[""]` → `--tools ""`
+        // which disables all built-in tools per `claude --help`.
+        args.push("--tools", ...input.tools);
+    }
     return args;
 }
 //──────────────────────────────────────────────────────────────────────────────

package/dist/upstream-contracts.js

@@ -49,6 +49,11 @@ export const UPSTREAM_CLI_CONTRACTS = {
             "jsonSchema",
             // Phase 4 slice ζ
             "addDir",
+            // Claude 2.x session / settings / tools surface
+            "noSessionPersistence",
+            "settingSources",
+            "settings",
+            "tools",
             "approvalStrategy",
             "mcpServers",
             "strictMcpConfig",
@@ -96,6 +101,12 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 pattern: /^[0-9]+(?:\.[0-9]+)?$/,
                 description: "Budget cap in USD",
             },
+            // NOTE: `--probe-installed` reports --max-turns as "missing from binary"
+            // because claude 2.x hides it from the `--help` body. It is nonetheless a
+            // real, accepted flag (verified: `claude --max-turns N --help` parses
+            // without an "unknown option" error, while a genuinely unknown flag errors
+            // loudly). Keep it in the contract; the probe drift here is a known
+            // help-text false-positive, not a removed flag.
             "--max-turns": { arity: "one", pattern: /^[1-9][0-9]*$/, description: "Turn cap" },
             "--effort": { arity: "one", values: EFFORT_LEVELS, description: "Reasoning effort" },
             "--exclude-dynamic-system-prompt-sections": {
@@ -116,6 +127,23 @@ export const UPSTREAM_CLI_CONTRACTS = {
             },
             "--continue": { arity: "none", description: "Continue active session" },
             "--session-id": { arity: "one", description: "Session id" },
+            // Claude 2.x session / settings / tools surface
+            "--no-session-persistence": {
+                arity: "none",
+                description: "Do not persist the session to disk (ephemeral; mirrors Codex --ephemeral)",
+            },
+            "--setting-sources": {
+                arity: "one",
+                description: "Comma-separated setting sources to load (user|project|local)",
+            },
+            "--settings": {
+                arity: "one",
+                description: "Settings JSON file path or literal (can define hooks/permissions/model)",
+            },
+            "--tools": {
+                arity: "variadic",
+                description: 'Restrict the available built-in tool set ("" disables all)',
+            },
         },
         env: {},
         conformanceFixtures: [
@@ -162,6 +190,23 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 args: ["-p", "hello", "--add-dir", "/tmp/a", "--add-dir", "/tmp/b"],
                 expect: "pass",
             },
+            {
+                id: "claude-session-settings-tools",
+                description: "Claude 2.x: --no-session-persistence, --setting-sources, --settings, and --tools (variadic) are accepted",
+                args: [
+                    "-p",
+                    "hello",
+                    "--no-session-persistence",
+                    "--setting-sources",
+                    "project,local",
+                    "--settings",
+                    "{}",
+                    "--tools",
+                    "Read",
+                    "Edit",
+                ],
+                expect: "pass",
+            },
             {
                 // Claude CLI 2.x: stream-json requires --verbose alongside --print.
                 // The gateway emits all three together; this fixture pins the combo
@@ -478,6 +523,8 @@ export const UPSTREAM_CLI_CONTRACTS = {
             "attachments",
             // Phase 4 slice γ
             "skipTrust",
+            // Auto-approve-all ergonomic alias (equivalent to approvalMode "yolo")
+            "yolo",
         ],
         flags: {
             "-p": { arity: "one", description: "Prompt text" },
@@ -503,6 +550,10 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 arity: "none",
                 description: "Trust workspace for this session (Phase 4 slice γ)",
             },
+            "--yolo": {
+                arity: "none",
+                description: "Auto-approve all actions (gemini -y/--yolo). Functionally equivalent to --approval-mode yolo; the gateway emits at most one of the two.",
+            },
         },
         env: {},
         conformanceFixtures: [
@@ -524,6 +575,12 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 args: ["-p", "hello", "--skip-trust"],
                 expect: "pass",
             },
+            {
+                id: "gemini-yolo",
+                description: "--yolo (auto-approve all) is accepted",
+                args: ["-p", "hello", "--yolo"],
+                expect: "pass",
+            },
             {
                 id: "gemini-stream-json",
                 description: "Phase 4 slice ε: -o stream-json is accepted",
@@ -576,6 +633,9 @@ export const UPSTREAM_CLI_CONTRACTS = {
             "systemPromptOverride",
             "allow",
             "deny",
+            // Grok 0.2.x context/compaction controls
+            "compactionMode",
+            "compactionDetail",
         ],
         flags: {
             "-p": { arity: "one", description: "Prompt text" },
@@ -665,6 +725,17 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 arity: "optional",
                 description: "Start the session in a new git worktree, optionally named",
             },
+            // Grok 0.2.x context/compaction controls (both enum, env-backed):
+            "--compaction-mode": {
+                arity: "one",
+                values: ["summary", "transcript", "segments"],
+                description: "Compaction mode (default summary; sets GROK_COMPACTION_MODE). `segments` persists per-segment markdown.",
+            },
+            "--compaction-detail": {
+                arity: "one",
+                values: ["none", "minimal", "balanced", "verbose"],
+                description: "Segment verbatim detail (default verbose; sets GROK_COMPACTION_DETAIL). Only affects `--compaction-mode segments`.",
+            },
         },
         env: {},
         conformanceFixtures: [
@@ -762,6 +833,18 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 ],
                 expect: "pass",
             },
+            {
+                id: "grok-compaction",
+                description: "Grok 0.2.x: --compaction-mode and --compaction-detail accepted with valid enum values",
+                args: ["-p", "hello", "--compaction-mode", "segments", "--compaction-detail", "balanced"],
+                expect: "pass",
+            },
+            {
+                id: "grok-compaction-mode-invalid",
+                description: "Grok --compaction-mode rejects a value outside the contract enum",
+                args: ["-p", "hello", "--compaction-mode", "aggressive"],
+                expect: "fail",
+            },
         ],
     },
     mistral: {
@@ -787,8 +870,6 @@ export const UPSTREAM_CLI_CONTRACTS = {
             "resumeLatest",
             "createNewSession",
             "permissionMode",
-            "effort",
-            "reasoningEffort",
             "approvalStrategy",
             "mcpServers",
             "allowedTools",
@@ -815,8 +896,12 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 values: ["default", "plan", "accept-edits", "auto-approve", "chat", "explore", "lean"],
                 description: "Agent/permission mode",
             },
-            "--effort": { arity: "one", description: "Reasoning effort" },
-            "--reasoning-effort": { arity: "one", description: "Reasoning effort override" },
+            // NOTE: vibe has no reasoning-effort surface. `--effort` / `--reasoning-effort`
+            // were declared speculatively (mirroring Grok) in the provider-modernisation
+            // commit but were never accepted by the CLI: vibe 2.x argparse hard-rejects them
+            // ("error: unrecognized arguments: --effort"), failing the whole request before
+            // any model call. Removed from the contract, builder, and request schema; the
+            // mistral-effort-rejected / mistral-reasoning-effort-rejected fixtures lock it in.
             "--enabled-tools": { arity: "one", description: "Enabled tool" },
             "--resume": { arity: "one", description: "Resume session" },
             "--continue": { arity: "none", description: "Continue latest session" },
@@ -932,6 +1017,20 @@ export const UPSTREAM_CLI_CONTRACTS = {
                 env: { VIBE_ACTIVE_MODEL: "mistral-medium-3.5" },
                 expect: "pass",
             },
+            {
+                id: "mistral-effort-rejected",
+                description: "vibe 2.x advertises no reasoning-effort surface: a raw --effort arg is rejected by the contract (mirrors the CLI's own 'unrecognized arguments' failure)",
+                args: ["-p", "hello", "--agent", "auto-approve", "--effort", "high"],
+                env: { VIBE_ACTIVE_MODEL: "mistral-medium-3.5" },
+                expect: "fail",
+            },
+            {
+                id: "mistral-reasoning-effort-rejected",
+                description: "vibe 2.x: a raw --reasoning-effort arg is rejected by the contract",
+                args: ["-p", "hello", "--agent", "auto-approve", "--reasoning-effort", "medium"],
+                env: { VIBE_ACTIVE_MODEL: "mistral-medium-3.5" },
+                expect: "fail",
+            },
         ],
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-cli-gateway",
-  "version": "1.17.3",
+  "version": "1.17.4",
   "mcpName": "io.github.verivus-oss/llm-cli-gateway",
   "description": "MCP server providing unified access to Claude Code, Codex, Gemini, Grok, and Mistral Vibe CLIs with session management, retry logic, async job orchestration, durable job results, and cross-LLM validation.",
   "license": "MIT",