llm-cli-gateway 2.13.2 → 2.14.0-rc.1

package/dist/pricing.d.ts

@@ -1,8 +1,9 @@
+import type { CliType } from "./provider-types.js";
 export interface PricePerMillion {
     inputUsd: number;
     outputUsd: number;
     cacheReadMultiplier: number;
 }
 export declare const PRICING_AS_OF = "2026-06-13";
-export declare function getPricing(cli: "claude" | "codex" | "gemini" | "grok" | "mistral", model: string): PricePerMillion;
-export declare function estimateCacheSavingsUsd(cli: "claude" | "codex" | "gemini" | "grok" | "mistral", model: string, cacheReadTokens: number): number;
+export declare function getPricing(cli: CliType, model: string): PricePerMillion;
+export declare function estimateCacheSavingsUsd(cli: CliType, model: string, cacheReadTokens: number): number;

package/dist/provider-acp-capabilities.d.ts

@@ -0,0 +1,52 @@
+import type { AcpConfig } from "./config.js";
+import type { ParsedAcpInitialize } from "./provider-capability-discovery.js";
+import type { CliType } from "./session-manager.js";
+export interface AcpHostServicePolicy {
+    readonly filesystemRead: "deny-by-default";
+    readonly filesystemWriteAllowed: boolean;
+    readonly terminalAllowed: boolean;
+    readonly mutatingSessionOpsAllowed: boolean;
+    readonly permissionRouting: "approval-manager";
+    readonly unknownToolKind: "deny-by-default";
+}
+export interface ProviderAcpInitializeDetail {
+    readonly source: "discovered" | "static-fallback";
+    readonly degraded: boolean;
+    readonly protocolVersion: number | string | null;
+    readonly agentInfo: {
+        readonly name?: string;
+        readonly version?: string;
+    } | null;
+    readonly authMethods: readonly string[];
+    readonly promptCapabilities: readonly string[];
+    readonly mcpCapabilities: readonly string[];
+    readonly sessionCapabilities: readonly string[];
+    readonly extensionMethods: readonly string[];
+}
+export interface ProviderAcpCapabilityRecord {
+    readonly schemaVersion: "provider-acp-capability.v1";
+    readonly provider: CliType;
+    readonly displayName: string;
+    readonly native: boolean;
+    readonly nativeEntrypoint: string | null;
+    readonly entrypoint: {
+        readonly command: string;
+        readonly args: readonly string[];
+    } | null;
+    readonly probeArgv: readonly (readonly string[])[];
+    readonly agentTypes: readonly {
+        readonly id: string;
+        readonly description: string;
+    }[];
+    readonly evidence: string;
+    readonly initialize: ProviderAcpInitializeDetail | null;
+    readonly supportedSessionMethods: readonly string[];
+    readonly hostServicePolicy: AcpHostServicePolicy;
+}
+export declare function deriveSupportedMethodsFromDiscovered(parsed: ParsedAcpInitialize): readonly string[];
+export interface BuildProviderAcpRecordOptions {
+    readonly discovered?: ParsedAcpInitialize | null;
+    readonly discoveredDegraded?: boolean;
+    readonly acpConfig?: AcpConfig | null;
+}
+export declare function buildProviderAcpCapabilityRecord(provider: CliType, options?: BuildProviderAcpRecordOptions): ProviderAcpCapabilityRecord;

package/dist/provider-acp-capabilities.js

@@ -0,0 +1,101 @@
+import { redactAcpMessage } from "./acp/errors.js";
+import { BASELINE_ACP_METHODS, deriveAcpMethodAvailability, } from "./acp/types.js";
+import { getProviderDefinition } from "./provider-definitions.js";
+export function deriveSupportedMethodsFromDiscovered(parsed) {
+    const init = {
+        protocolVersion: typeof parsed.protocolVersion === "number" ? parsed.protocolVersion : 0,
+        agentCapabilities: parsed.agentCapabilities ?? undefined,
+        authMethods: parsed.authMethods.map(id => ({ id })),
+    };
+    const methods = new Set(deriveAcpMethodAvailability(init));
+    for (const method of parsed.knownMethods) {
+        methods.add(method);
+    }
+    return [...methods].sort();
+}
+function hostServicePolicy(config) {
+    return {
+        filesystemRead: "deny-by-default",
+        filesystemWriteAllowed: config?.allowWriteHostServices ?? false,
+        terminalAllowed: config?.allowTerminalHostServices ?? false,
+        mutatingSessionOpsAllowed: config?.allowMutatingSessionOps ?? false,
+        permissionRouting: "approval-manager",
+        unknownToolKind: "deny-by-default",
+    };
+}
+export function buildProviderAcpCapabilityRecord(provider, options = {}) {
+    const def = getProviderDefinition(provider);
+    const acp = def.acp;
+    const native = acp.classification === "native";
+    const policy = hostServicePolicy(options.acpConfig);
+    if (!native) {
+        return {
+            schemaVersion: "provider-acp-capability.v1",
+            provider,
+            displayName: def.displayName,
+            native: false,
+            nativeEntrypoint: null,
+            entrypoint: null,
+            probeArgv: [],
+            agentTypes: [],
+            evidence: acp.evidence,
+            initialize: null,
+            supportedSessionMethods: [],
+            hostServicePolicy: policy,
+        };
+    }
+    const discovered = options.discovered ?? null;
+    const initialize = discovered
+        ? {
+            source: "discovered",
+            degraded: options.discoveredDegraded ?? false,
+            protocolVersion: discovered.protocolVersion,
+            agentInfo: discovered.agentInfo
+                ? {
+                    ...(discovered.agentInfo.name !== undefined
+                        ? { name: redactAcpMessage(discovered.agentInfo.name) }
+                        : {}),
+                    ...(discovered.agentInfo.version !== undefined
+                        ? { version: redactAcpMessage(discovered.agentInfo.version) }
+                        : {}),
+                }
+                : null,
+            authMethods: discovered.authMethods,
+            promptCapabilities: discovered.promptCapabilities,
+            mcpCapabilities: discovered.mcpCapabilities,
+            sessionCapabilities: discovered.sessionCapabilities,
+            extensionMethods: discovered.extensionMethods,
+        }
+        : {
+            source: "static-fallback",
+            degraded: false,
+            protocolVersion: null,
+            agentInfo: null,
+            authMethods: [],
+            promptCapabilities: [],
+            mcpCapabilities: [],
+            sessionCapabilities: [],
+            extensionMethods: [],
+        };
+    const supportedSessionMethods = discovered
+        ? deriveSupportedMethodsFromDiscovered(discovered)
+        : [...BASELINE_ACP_METHODS].sort();
+    return {
+        schemaVersion: "provider-acp-capability.v1",
+        provider,
+        displayName: def.displayName,
+        native: true,
+        nativeEntrypoint: acp.nativeEntrypoint,
+        entrypoint: acp.entrypoint
+            ? { command: acp.entrypoint.command, args: [...acp.entrypoint.args] }
+            : null,
+        probeArgv: acp.probeArgv.map(argv => [...argv]),
+        agentTypes: acp.agentTypes
+            ? acp.agentTypes.map(t => ({ id: t.id, description: t.description }))
+            : [],
+        evidence: acp.evidence,
+        initialize,
+        supportedSessionMethods,
+        hostServicePolicy: policy,
+    };
+}

package/dist/provider-admin-tools.d.ts

@@ -0,0 +1,100 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type ExecuteResult } from "./executor.js";
+import { type Logger } from "./logger.js";
+import { type CliType, type ProviderAdminFamily, type ProviderDefinition } from "./provider-definitions.js";
+import type { DiscoveredCapabilitySet } from "./provider-capability-discovery.js";
+import { type CliSubcommandExposure, type CliSubcommandRisk } from "./upstream-contracts.js";
+import type { ApprovalManager } from "./approval-manager.js";
+import { type GatewayRequestContext } from "./request-context.js";
+export declare function adminRiskToExposure(risk: CliSubcommandRisk): CliSubcommandExposure;
+export declare function classifyOperationRisk(operationName: string, familyRisk: CliSubcommandRisk, opts?: {
+    isSubcommand?: boolean;
+}): CliSubcommandRisk;
+export declare function familyBaseRisk(provider: CliType, fam: ProviderAdminFamily): CliSubcommandRisk;
+export type AdminDiscoverySource = "subcommand-help" | "root-help" | "not-advertised" | "no-discovery";
+export interface AdminOperation {
+    readonly provider: CliType;
+    readonly family: string;
+    readonly operationId: string;
+    readonly argv: readonly string[];
+    readonly risk: CliSubcommandRisk;
+    readonly exposure: CliSubcommandExposure;
+    readonly mutating: boolean;
+    readonly available: boolean;
+    readonly discoverySource: AdminDiscoverySource;
+    readonly summary: string;
+}
+export declare function projectProviderAdminOperations(def: ProviderDefinition, discovered: DiscoveredCapabilitySet | null): AdminOperation[];
+export interface AdminCatalogRow {
+    readonly provider: CliType;
+    readonly operationId: string;
+    readonly family: string;
+    readonly argv: readonly string[];
+    readonly risk: CliSubcommandRisk;
+    readonly exposure: CliSubcommandExposure;
+    readonly mutating: boolean;
+    readonly available: boolean;
+    readonly discoverySource: AdminDiscoverySource;
+    readonly summary: string;
+}
+export declare function buildProviderAdminCatalog(options?: {
+    provider?: CliType;
+    lookup?: (id: CliType) => DiscoveredCapabilitySet | null;
+    includeUnavailable?: boolean;
+}): AdminCatalogRow[];
+export declare function redactAdminOutput(text: string): string;
+export type AdminCommandRunner = (executable: string, argv: readonly string[], options: {
+    timeoutMs?: number;
+}) => Promise<ExecuteResult>;
+export declare function isSafeAdminToken(token: string): boolean;
+export interface AdminRunResult {
+    readonly ok: boolean;
+    readonly provider: CliType;
+    readonly operationId: string;
+    readonly argv: readonly string[];
+    readonly exitCode: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly redacted: true;
+    readonly error?: string;
+}
+export declare function runReadOnlyAdminOperation(op: AdminOperation, deps?: {
+    runner?: AdminCommandRunner;
+    timeoutMs?: number;
+    logger?: Logger;
+}): Promise<AdminRunResult>;
+export interface AdminAuditRecord {
+    readonly ts: string;
+    readonly provider: CliType;
+    readonly operationId: string;
+    readonly argv: readonly string[];
+    readonly outcome: "gate_closed" | "denied" | "approved" | "executed";
+    readonly approvalId?: string;
+    readonly exitCode?: number | null;
+    readonly principal?: string;
+}
+export declare function defaultAdminAuditPath(): string;
+export type AdminAuditSink = (record: AdminAuditRecord) => void;
+export declare function defaultAdminAuditSink(auditPath?: string): AdminAuditSink;
+export declare function appendAdminAudit(record: AdminAuditRecord, auditPath?: string): void;
+export interface AdminMutateContext {
+    readonly allowMutating: boolean;
+    readonly remoteCaller?: boolean;
+    readonly remoteAdminAllowed?: boolean;
+    readonly approvalManager: ApprovalManager;
+    readonly runner?: AdminCommandRunner;
+    readonly timeoutMs?: number;
+    readonly logger?: Logger;
+    readonly principal?: string;
+    readonly auditPath?: string;
+    readonly auditSink?: AdminAuditSink;
+}
+export declare function runMutatingAdminOperation(op: AdminOperation, ctx: AdminMutateContext): Promise<AdminRunResult>;
+export declare function isRemoteAdminCaller(ctx: GatewayRequestContext | undefined): boolean;
+export declare function remoteCliAdminEnabled(ctx: GatewayRequestContext | undefined): boolean;
+export interface ProviderAdminToolRuntime {
+    readonly approvalManager: ApprovalManager;
+    readonly logger: Logger;
+    readonly allowMutatingCliAdminOps: boolean;
+}
+export declare function registerProviderAdminTools(server: McpServer, runtime: ProviderAdminToolRuntime): void;