llm-cli-gateway 2.6.3 → 2.8.0

package/dist/request-context.d.ts

@@ -1,4 +1,5 @@
 export interface GatewayRequestContext {
+    transport?: "stdio" | "http";
     authKind?: "disabled" | "gateway_bearer" | "oauth";
     authScopes: string[];
     authClientId?: string;

package/dist/request-helpers.d.ts

@@ -98,8 +98,8 @@ export declare const CLAUDE_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodEffects<z.ZodObject<
     effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "xhigh", "max"]>>;
     excludeDynamicSystemPromptSections: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    agents?: Record<string, Record<string, unknown>> | undefined;
     agent?: string | undefined;
+    agents?: Record<string, Record<string, unknown>> | undefined;
     forkSession?: boolean | undefined;
     systemPrompt?: string | undefined;
     appendSystemPrompt?: string | undefined;
@@ -108,8 +108,8 @@ export declare const CLAUDE_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodEffects<z.ZodObject<
     effort?: "medium" | "low" | "high" | "xhigh" | "max" | undefined;
     excludeDynamicSystemPromptSections?: boolean | undefined;
 }, {
-    agents?: Record<string, Record<string, unknown>> | undefined;
     agent?: string | undefined;
+    agents?: Record<string, Record<string, unknown>> | undefined;
     forkSession?: boolean | undefined;
     systemPrompt?: string | undefined;
     appendSystemPrompt?: string | undefined;
@@ -118,8 +118,8 @@ export declare const CLAUDE_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodEffects<z.ZodObject<
     effort?: "medium" | "low" | "high" | "xhigh" | "max" | undefined;
     excludeDynamicSystemPromptSections?: boolean | undefined;
 }>, {
-    agents?: Record<string, Record<string, unknown>> | undefined;
     agent?: string | undefined;
+    agents?: Record<string, Record<string, unknown>> | undefined;
     forkSession?: boolean | undefined;
     systemPrompt?: string | undefined;
     appendSystemPrompt?: string | undefined;
@@ -128,8 +128,8 @@ export declare const CLAUDE_HIGH_IMPACT_PARAMS_SCHEMA: z.ZodEffects<z.ZodObject<
     effort?: "medium" | "low" | "high" | "xhigh" | "max" | undefined;
     excludeDynamicSystemPromptSections?: boolean | undefined;
 }, {
-    agents?: Record<string, Record<string, unknown>> | undefined;
     agent?: string | undefined;
+    agents?: Record<string, Record<string, unknown>> | undefined;
     forkSession?: boolean | undefined;
     systemPrompt?: string | undefined;
     appendSystemPrompt?: string | undefined;

package/dist/resources.js

@@ -2,6 +2,7 @@ import { CLI_TYPES, PROVIDER_TYPES } from "./session-manager.js";
 import { getAvailableCliInfo } from "./model-registry.js";
 import { computeGlobalCacheStats, computePrefixCacheStats, computeSessionCacheStats, computeTtlRemaining, } from "./cache-stats.js";
 import { buildProviderSubcommandsCompactCatalog, getCliSubcommandContract, serializeCliSubcommandContract, } from "./upstream-contracts.js";
+import { getOneProviderToolCapabilities, getProviderToolCapabilities, providerCapabilityIds, } from "./provider-tool-capabilities.js";
 export class ResourceProvider {
     sessionManager;
     performanceMetrics;
@@ -176,6 +177,28 @@ export class ResourceProvider {
                     priority: 0.7,
                 },
             },
+            {
+                uri: "provider-tools://catalog",
+                name: "Provider Tool Capabilities Catalog",
+                title: "Provider Tool Capabilities Catalog",
+                description: "Read-only catalog of gateway tool controls and discovered provider skills",
+                mimeType: "application/json",
+                annotations: {
+                    audience: ["user", "assistant"],
+                    priority: 0.8,
+                },
+            },
+            ...providerCapabilityIds().map(cli => ({
+                uri: `provider-tools://${cli}`,
+                name: `${cli} Tool Capabilities`,
+                title: `${cli} Tool Capabilities`,
+                description: `Gateway tool controls and discovered local skills for ${cli}`,
+                mimeType: "application/json",
+                annotations: {
+                    audience: ["user", "assistant"],
+                    priority: 0.8,
+                },
+            })),
         ];
     }
     async readResource(uri) {
@@ -320,6 +343,21 @@ export class ResourceProvider {
                 text: JSON.stringify(buildProviderSubcommandsCompactCatalog()),
             };
         }
+        if (uri === "provider-tools://catalog" || uri === "provider_tools://catalog") {
+            return {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(getProviderToolCapabilities(), null, 2),
+            };
+        }
+        const providerToolsResource = parseProviderToolsUri(uri);
+        if (providerToolsResource) {
+            return {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(getOneProviderToolCapabilities(providerToolsResource.provider), null, 2),
+            };
+        }
         const subcommandResource = parseProviderSubcommandUri(uri);
         if (subcommandResource) {
             const contract = getCliSubcommandContract(subcommandResource.provider, subcommandResource.commandPath);
@@ -354,3 +392,16 @@ function parseProviderSubcommandUri(uri) {
         commandPath: pathParts.map(part => decodeURIComponent(part)).filter(Boolean),
     };
 }
+function parseProviderToolsUri(uri) {
+    const prefix = uri.startsWith("provider-tools://")
+        ? "provider-tools://"
+        : uri.startsWith("provider_tools://")
+            ? "provider_tools://"
+            : null;
+    if (!prefix || uri === `${prefix}catalog`)
+        return null;
+    const provider = uri.slice(prefix.length);
+    if (!providerCapabilityIds().includes(provider))
+        return null;
+    return { provider: provider };
+}

package/dist/upstream-contracts.d.ts

@@ -107,6 +107,20 @@ export interface ProviderSubcommandCompactCatalog {
     ];
     rows: readonly (readonly string[])[];
 }
+export type AcpEntrypointStatus = "native" | "adapter_mediated_deferred" | "absent_watchlist";
+export interface AcpEntrypointContract {
+    cli: CliType;
+    displayName: string;
+    status: AcpEntrypointStatus;
+    executable: string;
+    entrypointArgs: readonly string[];
+    targetVersion: string;
+    probeArgs: readonly (readonly string[])[];
+    adapterCandidates?: readonly string[];
+    evidence: string;
+    docsRef: string;
+}
+export declare const ACP_ENTRYPOINT_CONTRACTS: Record<CliType, AcpEntrypointContract>;
 export declare const UPSTREAM_CLI_CONTRACTS: Record<CliType, CliContract>;
 export declare function validateUpstreamCliArgs(cli: CliType, args: readonly string[]): ContractValidationResult;
 export declare function assertUpstreamCliArgs(cli: CliType, args: readonly string[]): void;
@@ -167,6 +181,19 @@ export interface InstalledCliContractProbe {
     warnings: string[];
 }
 export declare function probeInstalledCliContract(cli: CliType, timeoutMs?: number): InstalledCliContractProbe;
+export interface InstalledAcpEntrypointProbe {
+    cli: CliType;
+    status: AcpEntrypointStatus;
+    executable: string;
+    entrypointArgs: readonly string[];
+    targetVersion: string;
+    checkedProbeCommands: readonly (readonly string[])[];
+    available: boolean | null;
+    entrypointDrift: boolean;
+    warnings: string[];
+    probedAt: string;
+}
+export declare function probeInstalledAcpEntrypoint(cli: CliType, timeoutMs?: number): InstalledAcpEntrypointProbe;
 export declare function buildUpstreamContractReport(options?: {
     cli?: CliType;
     probeInstalled?: boolean;

package/dist/upstream-contracts.js

@@ -1,6 +1,65 @@
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { envWithExtendedPath, getExtendedPath, resolveCommandForSpawn } from "./executor.js";
+export const ACP_ENTRYPOINT_CONTRACTS = {
+    mistral: {
+        cli: "mistral",
+        displayName: "Mistral Vibe",
+        status: "native",
+        executable: "vibe-acp",
+        entrypointArgs: [],
+        targetVersion: "vibe 2.14.1",
+        probeArgs: [["--version"], ["--help"]],
+        evidence: "Native ACP executable vibe-acp; manual initialize + session/new smoke passed. First runtime pilot.",
+        docsRef: "docs/plans/first-class-acp-gateway-extension.dag.toml#provider_matrix.mistral",
+    },
+    grok: {
+        cli: "grok",
+        displayName: "xAI Grok CLI",
+        status: "native",
+        executable: "grok",
+        entrypointArgs: ["agent", "stdio"],
+        targetVersion: "grok 0.2.50 (cadf94855)",
+        probeArgs: [["agent", "stdio", "--help"]],
+        evidence: "Native ACP via `grok agent stdio`; initialize + session/new smoke passed with isolated leader socket. Second runtime pilot.",
+        docsRef: "docs/plans/first-class-acp-gateway-extension.dag.toml#provider_matrix.grok",
+    },
+    codex: {
+        cli: "codex",
+        displayName: "OpenAI Codex CLI",
+        status: "adapter_mediated_deferred",
+        executable: "codex",
+        entrypointArgs: [],
+        targetVersion: "codex-cli 0.139.0",
+        probeArgs: [],
+        adapterCandidates: ["zed-industries/codex-acp", "agentclientprotocol/codex-acp"],
+        evidence: "No native ACP entrypoint at codex-cli 0.139.0. Adapter evidence tracked as documentation only; not native gateway ACP support.",
+        docsRef: "docs/plans/first-class-acp-gateway-extension.dag.toml#provider_matrix.codex",
+    },
+    claude: {
+        cli: "claude",
+        displayName: "Anthropic Claude Code",
+        status: "adapter_mediated_deferred",
+        executable: "claude",
+        entrypointArgs: [],
+        targetVersion: "claude 2.1.175",
+        probeArgs: [],
+        adapterCandidates: ["Claude Agent SDK ACP adapter"],
+        evidence: "No native Claude Code CLI ACP entrypoint at claude 2.1.175. Adapter ownership/permission bridging unresolved; deferred.",
+        docsRef: "docs/plans/first-class-acp-gateway-extension.dag.toml#provider_matrix.claude",
+    },
+    gemini: {
+        cli: "gemini",
+        displayName: "Google Antigravity",
+        status: "absent_watchlist",
+        executable: "agy",
+        entrypointArgs: [],
+        targetVersion: "agy 1.0.7",
+        probeArgs: [],
+        evidence: "agy 1.0.7 has no ACP flag or subcommand. Legacy Gemini CLI ACP evidence does not transfer. Watchlist item.",
+        docsRef: "docs/plans/first-class-acp-gateway-extension.dag.toml#provider_matrix.gemini",
+    },
+};
 const PERMISSION_MODES = [
     "default",
     "acceptEdits",
@@ -2084,6 +2143,74 @@ function probeInstalledCliSubcommands(cli, timeoutMs) {
     }
     return probes;
 }
+export function probeInstalledAcpEntrypoint(cli, timeoutMs = 5_000) {
+    const contract = ACP_ENTRYPOINT_CONTRACTS[cli];
+    const warnings = [];
+    const checkedProbeCommands = contract.probeArgs.map(args => [...args]);
+    if (contract.status !== "native" || contract.probeArgs.length === 0) {
+        return {
+            cli,
+            status: contract.status,
+            executable: contract.executable,
+            entrypointArgs: contract.entrypointArgs,
+            targetVersion: contract.targetVersion,
+            checkedProbeCommands,
+            available: null,
+            entrypointDrift: false,
+            warnings,
+            probedAt: new Date().toISOString(),
+        };
+    }
+    let anyProbeSucceeded = false;
+    for (const probeArgs of contract.probeArgs) {
+        const extendedPath = getExtendedPath();
+        const env = envWithExtendedPath(process.env, extendedPath);
+        const resolved = resolveCommandForSpawn(contract.executable, [...probeArgs], {
+            envPath: extendedPath,
+        });
+        const result = spawnSync(resolved.command, resolved.args, {
+            encoding: "utf8",
+            timeout: timeoutMs,
+            maxBuffer: 1024 * 1024,
+            env,
+            windowsHide: true,
+            windowsVerbatimArguments: resolved.windowsVerbatimArguments,
+        });
+        if (result.error) {
+            warnings.push(`${contract.executable} ${probeArgs.join(" ")} unavailable: ${result.error.message}`);
+            continue;
+        }
+        anyProbeSucceeded = true;
+        if (result.status !== 0) {
+            warnings.push(`${contract.executable} ${probeArgs.join(" ")} exited with status ${result.status}`);
+        }
+    }
+    return {
+        cli,
+        status: contract.status,
+        executable: contract.executable,
+        entrypointArgs: contract.entrypointArgs,
+        targetVersion: contract.targetVersion,
+        checkedProbeCommands,
+        available: anyProbeSucceeded,
+        entrypointDrift: !anyProbeSucceeded,
+        warnings,
+        probedAt: new Date().toISOString(),
+    };
+}
+function serializeAcpEntrypointContract(contract) {
+    return {
+        status: contract.status,
+        native: contract.status === "native",
+        executable: contract.executable,
+        entrypointArgs: contract.entrypointArgs,
+        targetVersion: contract.targetVersion,
+        probeArgs: contract.probeArgs.map(args => [...args]),
+        adapterCandidates: contract.adapterCandidates ?? [],
+        evidence: contract.evidence,
+        docsRef: contract.docsRef,
+    };
+}
 export function buildUpstreamContractReport(options = {}) {
     const selected = options.cli ? [options.cli] : Object.keys(UPSTREAM_CLI_CONTRACTS);
     const contracts = Object.fromEntries(selected.map(cli => {
@@ -2130,6 +2257,7 @@ export function buildUpstreamContractReport(options = {}) {
                     description: fixture.description,
                     expect: fixture.expect,
                 })),
+                acpEntrypoint: serializeAcpEntrypointContract(ACP_ENTRYPOINT_CONTRACTS[cli]),
             },
         ];
     }));
@@ -2140,5 +2268,8 @@ export function buildUpstreamContractReport(options = {}) {
         installedProbe: options.probeInstalled
             ? Object.fromEntries(selected.map(cli => [cli, probeInstalledCliContract(cli)]))
             : null,
+        acpInstalledProbe: options.probeInstalled
+            ? Object.fromEntries(selected.map(cli => [cli, probeInstalledAcpEntrypoint(cli)]))
+            : null,
     };
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "llm-cli-gateway",
-  "version": "2.6.3",
+  "version": "2.8.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "llm-cli-gateway",
-      "version": "2.6.3",
+      "version": "2.8.0",
       "license": "MIT",
       "dependencies": {
         "@modelcontextprotocol/sdk": "^1.29.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-cli-gateway",
-  "version": "2.6.3",
+  "version": "2.8.0",
   "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",

package/setup/status.schema.json

@@ -16,6 +16,7 @@
     "endpoint_exposure",
     "client_config",
     "cache_awareness",
+    "provider_capabilities",
     "upstream",
     "next_actions"
   ],
@@ -289,12 +290,7 @@
         },
         "vibe_session_logging": {
           "type": "object",
-          "required": [
-            "config_path",
-            "config_present",
-            "session_logging_enabled",
-            "note"
-          ],
+          "required": ["config_path", "config_present", "session_logging_enabled", "note"],
           "properties": {
             "config_path": { "type": "string" },
             "config_present": { "type": "boolean" },
@@ -344,6 +340,71 @@
       },
       "additionalProperties": false
     },
+    "provider_capabilities": {
+      "type": "object",
+      "required": ["schema_version", "tool", "resources", "cache_ttl_ms", "providers"],
+      "properties": {
+        "schema_version": { "const": "provider-tool-capabilities.v2" },
+        "tool": { "const": "provider_tool_capabilities" },
+        "resources": {
+          "type": "object",
+          "required": ["catalog", "providers"],
+          "properties": {
+            "catalog": { "const": "provider-tools://catalog" },
+            "providers": {
+              "type": "object",
+              "required": ["claude", "codex", "gemini", "grok", "grok_api", "mistral"],
+              "additionalProperties": { "type": "string" }
+            }
+          },
+          "additionalProperties": false
+        },
+        "cache_ttl_ms": { "type": "integer", "minimum": 0 },
+        "providers": {
+          "type": "object",
+          "required": ["claude", "codex", "gemini", "grok", "grok_api", "mistral"],
+          "additionalProperties": {
+            "type": "object",
+            "required": [
+              "provider_kind",
+              "cli_available",
+              "gateway_request_tools",
+              "supported_features",
+              "unsupported_inputs",
+              "config_surface_count",
+              "discovered_skill_count",
+              "discovered_provider_tool_count",
+              "warnings"
+            ],
+            "properties": {
+              "provider_kind": { "enum": ["cli", "api"] },
+              "cli_available": { "type": "boolean" },
+              "gateway_request_tools": {
+                "type": "array",
+                "items": { "type": "string" }
+              },
+              "supported_features": {
+                "type": "array",
+                "items": { "type": "string" }
+              },
+              "unsupported_inputs": {
+                "type": "array",
+                "items": { "type": "string" }
+              },
+              "config_surface_count": { "type": "integer", "minimum": 0 },
+              "discovered_skill_count": { "type": "integer", "minimum": 0 },
+              "discovered_provider_tool_count": { "type": "integer", "minimum": 0 },
+              "warnings": {
+                "type": "array",
+                "items": { "type": "string" }
+              }
+            },
+            "additionalProperties": false
+          }
+        }
+      },
+      "additionalProperties": false
+    },
     "upstream": {
       "type": "object",
       "required": [

package/socket.yml

@@ -35,6 +35,28 @@ version: 2
 #     release security audit now hard-fails if any of those packages re-enter
 #     the prod graph (and still blocks the flagged tar-stream 2.x versions).
 #
+#   shrinkwrap
+#     The published npm package intentionally includes npm-shrinkwrap.json. It
+#     is not an install-script bypass or a hidden dependency surface; it is a
+#     prod-only projection generated from package-lock.json by
+#     scripts/make-prod-shrinkwrap.mjs so registry consumers resolve the same
+#     audited tree we release. scripts/release-security-audit.sh regenerates
+#     that projection and hard-fails on mismatch, and
+#     scripts/verify-registry-install.sh publishes to a temporary registry and
+#     verifies a fresh consumer install has no better-sqlite3, prebuild-install,
+#     tar-fs, or tar-stream production chain.
+#
+#     This is the npm-documented narrow use case for shrinkwrap: applications,
+#     daemons, and command-line tools published through the registry for global
+#     installs or devDependency use. llm-cli-gateway is a CLI/MCP appliance, not
+#     a library whose users need unpinned transitive dependency control.
+#
+#     Historical note: releases that previously reported healthy public Socket
+#     scores, including 2.3.0, 2.4.0, and 2.5.0, also shipped
+#     npm-shrinkwrap.json. The same socket.yml shellAccess policy was present
+#     there too. A public package-page alert on 2.6.x therefore reflects Socket
+#     scoring/rescan behavior, not a newly introduced shrinkwrap or shell path.
+#
 #   shellAccess
 #     This alert fires on every module that imports node:child_process, and
 #     because spawning provider CLIs and git is the entire purpose of the package
@@ -93,8 +115,9 @@ issueRules:
   didYouMean: true
   installScripts: true
   telemetry: true
-  hasNativeCode: true            # devDependency-only as of 2.0.0 (better-sqlite3); prod artifact has no native code
-  shellAccess: false             # reviewed gateway capability; see rationale above
+  hasNativeCode: true # devDependency-only as of 2.0.0 (better-sqlite3); prod artifact has no native code
+  shrinkwrap: false # reviewed published CLI lockfile; see rationale above
+  shellAccess: false # reviewed gateway capability; see rationale above
   shellScriptOverride: true
   gitDependency: true
   httpDependency: true