llm-cli-gateway 2.6.3 → 2.8.0

package/dist/config.js

@@ -348,6 +348,125 @@ export function isXaiProviderEnabled(config, env = process.env) {
         return false;
     return typeof env[keyEnv] === "string" && env[keyEnv].trim().length > 0;
 }
+export const ACP_TRANSPORTS = ["cli", "acp"];
+export const DEFAULT_ACP_PROCESS_IDLE_TIMEOUT_MS = 600000;
+export const DEFAULT_ACP_INITIALIZE_TIMEOUT_MS = 10000;
+export const DEFAULT_ACP_SESSION_NEW_TIMEOUT_MS = 10000;
+export const DEFAULT_ACP_PROMPT_TIMEOUT_MS = 600000;
+const SHELL_METACHARACTERS = /[\s|&;<>(){}$`"'\\*?[\]~#!]/;
+function isSafeExecutable(value) {
+    if (value.length === 0)
+        return false;
+    return !SHELL_METACHARACTERS.test(value);
+}
+const SafeExecutableSchema = z
+    .string()
+    .min(1)
+    .refine(isSafeExecutable, {
+    message: "ACP provider command must be a bare executable name or path with no shell metacharacters " +
+        "(no spaces, quotes, pipes, redirects, globs, or command substitution); pass arguments via 'args'",
+});
+const SafeArgSchema = z.string();
+const AcpProviderSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+    command: SafeExecutableSchema,
+    args: z.array(SafeArgSchema).default([]),
+    runtime_enabled: z.boolean().default(false),
+    isolated_leader_socket: z.boolean().default(false),
+})
+    .strict();
+const AcpConfigSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+    default_transport: z.enum(ACP_TRANSPORTS).default("cli"),
+    smoke_on_startup: z.boolean().default(false),
+    process_idle_timeout_ms: z
+        .number()
+        .int()
+        .positive()
+        .default(DEFAULT_ACP_PROCESS_IDLE_TIMEOUT_MS),
+    initialize_timeout_ms: z.number().int().positive().default(DEFAULT_ACP_INITIALIZE_TIMEOUT_MS),
+    session_new_timeout_ms: z.number().int().positive().default(DEFAULT_ACP_SESSION_NEW_TIMEOUT_MS),
+    prompt_timeout_ms: z.number().int().positive().default(DEFAULT_ACP_PROMPT_TIMEOUT_MS),
+    allow_write_host_services: z.boolean().default(false),
+    allow_terminal_host_services: z.boolean().default(false),
+    fallback_to_cli_when_unhealthy: z.boolean().default(true),
+    providers: z.record(z.string(), AcpProviderSchema).default({}),
+})
+    .strict();
+function defaultAcpConfig(sourcePath) {
+    return {
+        enabled: false,
+        defaultTransport: "cli",
+        smokeOnStartup: false,
+        processIdleTimeoutMs: DEFAULT_ACP_PROCESS_IDLE_TIMEOUT_MS,
+        initializeTimeoutMs: DEFAULT_ACP_INITIALIZE_TIMEOUT_MS,
+        sessionNewTimeoutMs: DEFAULT_ACP_SESSION_NEW_TIMEOUT_MS,
+        promptTimeoutMs: DEFAULT_ACP_PROMPT_TIMEOUT_MS,
+        allowWriteHostServices: false,
+        allowTerminalHostServices: false,
+        fallbackToCliWhenUnhealthy: true,
+        providers: {},
+        sources: { configFile: sourcePath },
+    };
+}
+function readAcpFile(configPath, logger) {
+    if (!existsSync(configPath)) {
+        return { raw: undefined, sourcePath: null };
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const TOML = require("smol-toml");
+        const text = readFileSync(configPath, "utf-8");
+        const parsed = TOML.parse(text);
+        return { raw: parsed?.acp, sourcePath: configPath };
+    }
+    catch (err) {
+        logger.error(`Failed to parse gateway config at ${configPath}; using acp defaults`, err);
+        return { raw: undefined, sourcePath: null };
+    }
+}
+export function loadAcpConfig(logger = noopLogger) {
+    const configPath = defaultGatewayConfigPath();
+    const { raw, sourcePath } = readAcpFile(configPath, logger);
+    if (raw === undefined) {
+        return defaultAcpConfig(sourcePath);
+    }
+    let parsed;
+    try {
+        parsed = AcpConfigSchema.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Invalid [acp] config: ${err instanceof Error ? err.message : String(err)}`, {
+            cause: err,
+        });
+    }
+    const providers = {};
+    for (const [name, p] of Object.entries(parsed.providers)) {
+        providers[name] = {
+            enabled: p.enabled,
+            command: p.command,
+            args: p.args,
+            runtimeEnabled: p.runtime_enabled,
+            isolatedLeaderSocket: p.isolated_leader_socket,
+        };
+    }
+    return {
+        enabled: parsed.enabled,
+        defaultTransport: parsed.default_transport,
+        smokeOnStartup: parsed.smoke_on_startup,
+        processIdleTimeoutMs: parsed.process_idle_timeout_ms,
+        initializeTimeoutMs: parsed.initialize_timeout_ms,
+        sessionNewTimeoutMs: parsed.session_new_timeout_ms,
+        promptTimeoutMs: parsed.prompt_timeout_ms,
+        allowWriteHostServices: parsed.allow_write_host_services,
+        allowTerminalHostServices: parsed.allow_terminal_host_services,
+        fallbackToCliWhenUnhealthy: parsed.fallback_to_cli_when_unhealthy,
+        providers,
+        sources: { configFile: sourcePath },
+    };
+}
 const OAuthRegistrationPolicySchema = z.enum(["static_clients", "shared_secret", "open_dev"]);
 const OAuthClientSchema = z
     .object({

package/dist/doctor.d.ts

@@ -2,6 +2,7 @@ import { type EndpointExposureReport } from "./endpoint-exposure.js";
 import { type ProviderLoginStatus } from "./provider-status.js";
 import type { FlightRecorderQuery } from "./flight-recorder.js";
 import { type CacheAwarenessConfig } from "./config.js";
+import { type ProviderCapabilityId, type ProviderKind } from "./provider-tool-capabilities.js";
 export type CliType = "claude" | "codex" | "gemini" | "grok" | "mistral";
 export interface CacheAwarenessReport {
     enabled_features: Array<"anthropic_cache_control" | "ttl_warnings">;
@@ -17,6 +18,26 @@ export interface CacheAwarenessReport {
         total_cache_read_tokens: number;
     }>>;
 }
+export interface ProviderCapabilitySummaryReport {
+    schema_version: "provider-tool-capabilities.v2";
+    tool: "provider_tool_capabilities";
+    resources: {
+        catalog: "provider-tools://catalog";
+        providers: Record<ProviderCapabilityId, string>;
+    };
+    cache_ttl_ms: number;
+    providers: Record<ProviderCapabilityId, {
+        provider_kind: ProviderKind;
+        cli_available: boolean;
+        gateway_request_tools: string[];
+        supported_features: string[];
+        unsupported_inputs: string[];
+        config_surface_count: number;
+        discovered_skill_count: number;
+        discovered_provider_tool_count: number;
+        warnings: string[];
+    }>;
+}
 export interface VibeSessionLoggingStatus {
     config_path: string;
     config_present: boolean;
@@ -116,6 +137,7 @@ export interface DoctorReport {
         vibe_session_logging: VibeSessionLoggingStatus;
     };
     cache_awareness: CacheAwarenessReport;
+    provider_capabilities: ProviderCapabilitySummaryReport;
     upstream: {
         note: string;
         recommendation: string;

package/dist/doctor.js

@@ -11,6 +11,7 @@ import { loadWorkspaceRegistry } from "./workspace-registry.js";
 import { computeGlobalCacheStats } from "./cache-stats.js";
 import { FlightRecorder, resolveFlightRecorderDbPath } from "./flight-recorder.js";
 import { buildUpstreamContractReport } from "./upstream-contracts.js";
+import { getProviderToolCapabilities, providerCapabilityIds, } from "./provider-tool-capabilities.js";
 export function checkVibeSessionLogging(home = homedir()) {
     const configPath = join(home, ".vibe", "config.toml");
     if (!existsSync(configPath)) {
@@ -226,6 +227,49 @@ function buildCacheAwarenessReport(opts) {
         per_cli: perCli,
     };
 }
+function buildProviderCapabilitySummary(providerStatuses) {
+    const capabilities = getProviderToolCapabilities({
+        includeSkills: true,
+        includeProviderTools: true,
+        includeUnsupported: true,
+        includePaths: false,
+    });
+    const providers = Object.fromEntries(providerCapabilityIds().map(provider => {
+        const capability = capabilities[provider];
+        if (!capability) {
+            throw new Error(`Missing provider capability record for ${provider}`);
+        }
+        const cliAvailable = provider === "grok_api"
+            ? capability.gatewayRequestTools.includes("grok_api_request")
+            : providerStatuses[provider].installed;
+        return [
+            provider,
+            {
+                provider_kind: capability.providerKind,
+                cli_available: cliAvailable,
+                gateway_request_tools: capability.gatewayRequestTools,
+                supported_features: Object.entries(capability.features)
+                    .filter(([, feature]) => feature.supported)
+                    .map(([name]) => name),
+                unsupported_inputs: capability.unsupportedInputs.map(input => input.input),
+                config_surface_count: capability.configSurfaces.length,
+                discovered_skill_count: capability.discoveredSkills.length,
+                discovered_provider_tool_count: capability.discoveredProviderTools.length,
+                warnings: capability.warnings,
+            },
+        ];
+    }));
+    return {
+        schema_version: "provider-tool-capabilities.v2",
+        tool: "provider_tool_capabilities",
+        resources: {
+            catalog: "provider-tools://catalog",
+            providers: Object.fromEntries(providerCapabilityIds().map(provider => [provider, `provider-tools://${provider}`])),
+        },
+        cache_ttl_ms: 60_000,
+        providers,
+    };
+}
 export function createDoctorReport(envOrOptions = process.env) {
     const opts = isCreateDoctorReportOptions(envOrOptions)
         ? envOrOptions
@@ -316,6 +360,7 @@ export function createDoctorReport(envOrOptions = process.env) {
         endpoint_exposure: endpointExposure,
         client_config: clientConfigStatus(),
         cache_awareness: buildCacheAwarenessReport(opts),
+        provider_capabilities: buildProviderCapabilitySummary(providerStatuses),
         upstream,
         next_actions: [],
     };

package/dist/http-transport.js

@@ -155,7 +155,7 @@ export async function startHttpGateway(options) {
                 jsonError(res, 404, "Not found");
                 return;
             }
-            let requestContext = { authScopes: [] };
+            let requestContext = { authScopes: [], transport: "http" };
             if (!noAuthPath) {
                 const auth = authorizeBearerRequest(req, token);
                 if (!auth.ok) {
@@ -163,6 +163,7 @@ export async function startHttpGateway(options) {
                     return;
                 }
                 requestContext = {
+                    transport: "http",
                     authKind: auth.kind,
                     authScopes: auth.scopes ?? [],
                     authClientId: auth.clientId,

package/dist/index.js

@@ -9,7 +9,7 @@ import { fileURLToPath } from "url";
 import { z } from "zod/v3";
 import { executeCli, killAllProcessGroups, providerCommandName } from "./executor.js";
 import { parseStreamJson } from "./stream-json-parser.js";
-import { parseCodexJsonStream } from "./codex-json-parser.js";
+import { parseCodexJsonStream, codexDisplayText, codexFrResponse } from "./codex-json-parser.js";
 import { parseGeminiJson, parseGeminiStreamJson } from "./gemini-json-parser.js";
 import { parseVibeMetaJson } from "./mistral-meta-json-parser.js";
 import { homedir } from "os";
@@ -22,6 +22,7 @@ import { loadConfig, loadPersistenceConfig, loadCacheAwarenessConfig, loadProvid
 import { createXaiResponse, XaiApiError, } from "./xai-api-provider.js";
 import { checkHealth } from "./health.js";
 import { clearModelRegistryCache, getAvailableCliInfo, getCliInfo, resolveModelAlias, } from "./model-registry.js";
+import { getProviderToolCapabilities } from "./provider-tool-capabilities.js";
 import { AsyncJobManager, } from "./async-job-manager.js";
 import { createJobStore } from "./job-store.js";
 import { ApprovalManager } from "./approval-manager.js";
@@ -488,13 +489,10 @@ async function resolveWorkspaceAndWorktreeForRequest(args) {
     else if (isGatewayAppDirCwd()) {
         throw new Error("No workspace selected. Configure [workspaces].default or pass a registered workspace alias.");
     }
-    if (!workspace && getRequestContext()?.authKind === "oauth") {
-        throw new Error("Remote OAuth provider requests require a registered workspace alias or [workspaces].default.");
-    }
-    if (!workspace &&
-        (args.workingDir || (args.addDir?.length ?? 0) > 0) &&
-        !args.runtime.workspaces.allowUnregisteredWorkingDir) {
-        throw new Error("workingDir/addDir require a registered workspace alias unless [workspaces].allow_unregistered_working_dir is explicitly enabled.");
+    const requestContext = getRequestContext();
+    const isRemoteTransport = requestContext?.transport === "http" || requestContext?.authKind === "oauth";
+    if (!workspace && isRemoteTransport) {
+        throw new Error("Remote HTTP provider requests require a registered workspace alias, session workspace, or [workspaces].default.");
     }
     if (workspace) {
         if (args.workingDir) {
@@ -719,7 +717,7 @@ export function extractUsageAndCost(cli, output, outputFormat, ctx) {
             costUsd: parsed.costUsd ?? undefined,
         };
     }
-    if (cli === "codex" && outputFormat === "json") {
+    if (cli === "codex") {
         const parsed = parseCodexJsonStream(output);
         if (!parsed.usage) {
             return {};
@@ -1049,6 +1047,27 @@ function registerBaseResources(server, runtime) {
         const contents = await runtime.resourceProvider.readResource(uri.href);
         return { contents: contents ? [contents] : [] };
     });
+    server.registerResource("provider-tools-catalog", "provider-tools://catalog", {
+        title: "Provider Tool Capabilities Catalog",
+        description: "Read-only catalog of gateway tool controls and discovered provider skills",
+        mimeType: "application/json",
+    }, async (uri) => {
+        runtime.logger.debug("Reading provider-tools://catalog resource");
+        const contents = await runtime.resourceProvider.readResource(uri.href);
+        return { contents: contents ? [contents] : [] };
+    });
+    server.registerResource("provider-tools", new ResourceTemplate("provider-tools://{provider}", { list: undefined }), {
+        title: "Provider Tool Capabilities",
+        description: "Read-only gateway tool controls and discovered local skills for one provider CLI",
+        mimeType: "application/json",
+    }, async (uri, variables) => {
+        const provider = Array.isArray(variables.provider)
+            ? variables.provider[0]
+            : variables.provider;
+        runtime.logger.debug(`Reading provider-tools://${provider}`);
+        const contents = await runtime.resourceProvider.readResource(uri.href);
+        return { contents: contents ? [contents] : [] };
+    });
 }
 function resolvePromptOrPartsForPrep(args) {
     const hasPrompt = typeof args.prompt === "string" && args.prompt.length > 0;
@@ -1398,9 +1417,7 @@ export function prepareCodexRequest(params, runtime = resolveGatewayServerRuntim
     if (params.dangerouslyBypassApprovalsAndSandbox) {
         args.push("--dangerously-bypass-approvals-and-sandbox");
     }
-    if (params.outputFormat === "json") {
-        args.push("--json");
-    }
+    args.push("--json");
     args.push("--skip-git-repo-check");
     let highImpactCleanup;
     if (sessionPlan.mode === "new") {
@@ -1808,6 +1825,9 @@ export function buildMistralRetryPrep(params, recoveryModel) {
 }
 function buildCliResponse(cli, stdout, optimizeResponse, corrId, sessionId, prep, durationMs, resumable, outputFormat, warnings) {
     let finalStdout = stdout;
+    if (cli === "codex" && outputFormat !== "json") {
+        finalStdout = codexDisplayText(stdout);
+    }
     if (optimizeResponse && outputFormat !== "json") {
         const optimized = optimizeResponseText(finalStdout);
         logOptimizationTokens("response", corrId, finalStdout, optimized);
@@ -3597,7 +3617,7 @@ export function createGatewayServer(deps = {}) {
         outputFormat: z
             .enum(["text", "json"])
             .default("text")
-            .describe("Codex output format. `json` emits --json (JSONL events) so token usage and cost are parsed and reported in the flight recorder. `text` is the default."),
+            .describe("Codex caller-facing output format. Token/cache usage is recorded in the flight recorder regardless. `text` (default) returns the plain reply; `json` returns the raw `--json` JSONL event stream."),
         outputSchema: z
             .union([z.string(), z.record(z.string(), z.unknown())])
             .optional()
@@ -3757,7 +3777,7 @@ export function createGatewayServer(deps = {}) {
             logger.info(`[${corrId}] codex_request completed successfully in ${durationMs}ms`);
             const codexUsage = extractUsageAndCost("codex", stdout, outputFormat);
             safeFlightComplete(corrId, {
-                response: stdout,
+                response: codexFrResponse(outputFormat, stdout),
                 durationMs,
                 retryCount: 0,
                 circuitBreakerState: "closed",
@@ -4600,7 +4620,7 @@ export function createGatewayServer(deps = {}) {
             outputFormat: z
                 .enum(["text", "json"])
                 .default("text")
-                .describe("Codex output format. `json` emits --json (JSONL events) for token usage extraction."),
+                .describe("Codex caller-facing output format. Token/cache usage is recorded in the flight recorder regardless. `text` (default) returns the plain reply; `json` returns the raw `--json` JSONL event stream."),
             outputSchema: z
                 .union([z.string(), z.record(z.string(), z.unknown())])
                 .optional()
@@ -5202,6 +5222,11 @@ export function createGatewayServer(deps = {}) {
             if (outputFormat === "stream-json" && result.stdout) {
                 parsed = parseStreamJson(result.stdout);
             }
+            if (asyncJobManager.getJobCli(jobId) === "codex" &&
+                outputFormat !== "json" &&
+                result.stdout) {
+                result.stdout = codexDisplayText(result.stdout);
+            }
             return {
                 content: [
                     {
@@ -5415,6 +5440,44 @@ export function createGatewayServer(deps = {}) {
         const result = cli ? { [cli]: cliInfo[cli] } : cliInfo;
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     });
+    server.tool("provider_tool_capabilities", "Report provider tool/feature capabilities and discovered local skill/tool integrations for claude|codex|gemini|grok|grok_api|mistral.", {
+        cli: z
+            .preprocess(value => (value === "" || value === null ? undefined : value), z.enum(["claude", "codex", "gemini", "grok", "grok_api", "mistral"]).optional())
+            .describe("Provider filter (claude|codex|gemini|grok|grok_api|mistral)"),
+        includeSkills: z
+            .boolean()
+            .default(true)
+            .describe("Include bounded local skill discovery results"),
+        includeProviderTools: z
+            .boolean()
+            .default(true)
+            .describe("Include provider-native tools extracted from local skills"),
+        includeUnsupported: z
+            .boolean()
+            .default(true)
+            .describe("Include explicit unsupported/degraded input records"),
+        includePaths: z
+            .boolean()
+            .default(false)
+            .describe("Include raw local filesystem paths in discovery output"),
+        refresh: z.boolean().default(false).describe("Bypass the short-lived capability cache"),
+    }, {
+        title: "Provider tool capabilities",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    }, async ({ cli, includeSkills, includeProviderTools, includeUnsupported, includePaths, refresh, }) => {
+        const capabilities = getProviderToolCapabilities({
+            cli,
+            includeSkills,
+            includeProviderTools,
+            includeUnsupported,
+            includePaths,
+            refresh,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(capabilities, null, 2) }] };
+    });
     server.tool("cli_versions", "Report installed provider CLI versions, availability, and login status for all five providers or one.", {
         cli: z
             .preprocess(value => (value === "" || value === null ? undefined : value), z.enum(["claude", "codex", "gemini", "grok", "mistral"]).optional())

package/dist/pricing.d.ts

@@ -3,6 +3,6 @@ export interface PricePerMillion {
     outputUsd: number;
     cacheReadMultiplier: number;
 }
-export declare const PRICING_AS_OF = "2026-05-26";
+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;

package/dist/pricing.js

@@ -1,4 +1,4 @@
-export const PRICING_AS_OF = "2026-05-26";
+export const PRICING_AS_OF = "2026-06-13";
 const ANTHROPIC_SONNET = {
     inputUsd: 3,
     outputUsd: 15,
@@ -19,6 +19,41 @@ const OPENAI_GPT5 = {
     outputUsd: 10,
     cacheReadMultiplier: 0.5,
 };
+const GEMINI_25_PRO = {
+    inputUsd: 1.25,
+    outputUsd: 10,
+    cacheReadMultiplier: 0.1,
+};
+const GEMINI_FLASH = {
+    inputUsd: 0.3,
+    outputUsd: 2.5,
+    cacheReadMultiplier: 0.1,
+};
+const GEMINI_3_PRO = {
+    inputUsd: 2,
+    outputUsd: 12,
+    cacheReadMultiplier: 0.1,
+};
+const GROK_4 = {
+    inputUsd: 1.25,
+    outputUsd: 2.5,
+    cacheReadMultiplier: 0.16,
+};
+const GROK_BUILD = {
+    inputUsd: 1,
+    outputUsd: 2,
+    cacheReadMultiplier: 0.2,
+};
+const MISTRAL_MEDIUM = {
+    inputUsd: 1.5,
+    outputUsd: 7.5,
+    cacheReadMultiplier: 0.1,
+};
+const MISTRAL_DEVSTRAL = {
+    inputUsd: 0.1,
+    outputUsd: 0.3,
+    cacheReadMultiplier: 0.1,
+};
 const ZERO = {
     inputUsd: 0,
     outputUsd: 0,
@@ -33,13 +68,43 @@ export function getPricing(cli, model) {
             return ANTHROPIC_OPUS;
         if (lower.includes("haiku"))
             return ANTHROPIC_HAIKU;
-        return ZERO;
+        return ANTHROPIC_SONNET;
     }
     if (cli === "codex") {
         if (lower.includes("gpt-5") || lower.includes("o3"))
             return OPENAI_GPT5;
         return ZERO;
     }
+    if (cli === "gemini") {
+        const specialtyVariant = lower.includes("lite") ||
+            lower.includes("image") ||
+            lower.includes("audio") ||
+            lower.includes("tts");
+        if (!specialtyVariant) {
+            if (lower.includes("2.5-flash"))
+                return GEMINI_FLASH;
+            if (lower.includes("2.5-pro"))
+                return GEMINI_25_PRO;
+            if (lower.includes("gemini-3") && lower.includes("pro"))
+                return GEMINI_3_PRO;
+        }
+        return ZERO;
+    }
+    if (cli === "grok") {
+        if (lower.includes("grok-build") || lower.includes("grok-code"))
+            return GROK_BUILD;
+        if (lower.includes("grok-4") || lower.includes("grok-3") || lower.includes("grok-latest")) {
+            return GROK_4;
+        }
+        return ZERO;
+    }
+    if (cli === "mistral") {
+        if (lower.includes("devstral-small"))
+            return MISTRAL_DEVSTRAL;
+        if (lower.includes("mistral-medium-3.5"))
+            return MISTRAL_MEDIUM;
+        return ZERO;
+    }
     return ZERO;
 }
 export function estimateCacheSavingsUsd(cli, model, cacheReadTokens) {

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

@@ -0,0 +1,135 @@
+import { type CliInfo } from "./model-registry.js";
+import { type CliType } from "./session-manager.js";
+export interface ProviderToolControl {
+    name?: string;
+    supported: boolean;
+    requestField?: string;
+    cliFlag?: string;
+    behavior: string;
+}
+export type ProviderCapabilityId = CliType | "grok_api";
+export type ProviderKind = "cli" | "api";
+export type UnsupportedInputBehavior = "reject" | "ignored" | "not_supported" | "approval_tracking_only" | "deprecated";
+export type ProviderToolConfidence = "high" | "medium" | "low";
+export type ProviderToolExtractionReason = "exact-tool-section" | "known-tool-name" | "backtick-heuristic" | "low-confidence";
+export interface ProviderSkillCapability {
+    name: string;
+    source: "user" | "bundled";
+    path?: string;
+    description?: string;
+    declaredTools: string[];
+    declaredToolReasons?: Partial<Record<string, ProviderToolExtractionReason>>;
+}
+export interface ProviderNativeToolCapability {
+    name: string;
+    source: string;
+    skillName?: string;
+    path?: string;
+    confidence: ProviderToolConfidence;
+    reason: ProviderToolExtractionReason;
+}
+export interface ProviderConfigSurface {
+    name: string;
+    kind: "file" | "directory" | "env" | "gateway" | "provider";
+    present: boolean;
+    path?: string;
+    entries?: string[];
+    details?: string;
+}
+export interface ProviderUnsupportedInput {
+    input: string;
+    behavior: UnsupportedInputBehavior;
+    details: string;
+}
+export interface ProviderFeatureCapability {
+    supported: boolean;
+    details?: string;
+    values?: string[];
+}
+export type ProviderAcpStatus = "native_smoke_passed" | "native_candidate" | "adapter_mediated_deferred" | "absent_watchlist" | "not_applicable";
+export type ProviderAcpMediation = "native" | "adapter_mediated" | "none";
+export type ProviderAcpSmokeStatus = "passed" | "not_run" | "unsupported";
+export interface ProviderAcpCapability {
+    status: ProviderAcpStatus;
+    mediation: ProviderAcpMediation;
+    targetVersion: string;
+    entrypoint: {
+        command: string;
+        args: string[];
+    } | null;
+    runtimeEnabled: boolean;
+    smokeSupported: boolean;
+    smokeStatus: ProviderAcpSmokeStatus;
+    caveats: string[];
+    docs: string;
+}
+export type ProviderFeatureMap = Record<string, ProviderFeatureCapability>;
+export interface ProviderCapabilityControls {
+    allowlist: ProviderToolControl;
+    denylist: ProviderToolControl;
+    mcpServers: ProviderToolControl;
+    nativeSkills: ProviderToolControl;
+    [name: string]: ProviderToolControl;
+}
+export type AcpFrozenClassification = "native_candidate" | "adapter_mediated_deferred" | "absent_watchlist";
+export interface AcpProviderContract {
+    classification: AcpFrozenClassification;
+    summary: string;
+}
+export interface AcpContractMetadata {
+    protocol: "Agent Client Protocol";
+    outOfScope: "Agent Communication Protocol";
+    mcpFrontendRemains: true;
+    acpIsInternalProviderTransport: true;
+    defaultTransport: "cli";
+    hostServicesDenyByDefault: true;
+    noRawAcpJsonRpcTool: true;
+    adapterSupportIsNotNative: true;
+    contractDoc: "docs/acp-contract.md";
+    nonGoals: readonly string[];
+    providers: Readonly<Record<ProviderCapabilityId, AcpProviderContract>>;
+}
+export declare const ACP_CONTRACT: AcpContractMetadata;
+export interface ProviderToolCapabilities {
+    schemaVersion: "provider-tool-capabilities.v2";
+    generatedAt: string;
+    cli: ProviderCapabilityId;
+    providerKind: ProviderKind;
+    gatewayRequestTools: string[];
+    modelInfo: CliInfo | GrokApiModelInfo;
+    summary: string;
+    acpContract: AcpProviderContract;
+    acp: ProviderAcpCapability;
+    controls: ProviderCapabilityControls;
+    features: ProviderFeatureMap;
+    discoveredSkills: ProviderSkillCapability[];
+    discoveredProviderTools: ProviderNativeToolCapability[];
+    configSurfaces: ProviderConfigSurface[];
+    unsupportedInputs: ProviderUnsupportedInput[];
+    warnings: string[];
+    metadata: {
+        deprecatedFields?: Record<string, string>;
+        cacheTtlMs: number;
+    };
+    gatewayRequestTool: string;
+}
+export interface GrokApiModelInfo {
+    description: string;
+    models: Record<string, string>;
+    defaultModel?: string;
+    defaultModelSource?: string;
+    warnings?: string[];
+}
+export interface ProviderCapabilityQuery {
+    cli?: ProviderCapabilityId;
+    includeSkills?: boolean;
+    includeProviderTools?: boolean;
+    includeUnsupported?: boolean;
+    includePaths?: boolean;
+    refresh?: boolean;
+}
+export type ProviderToolCapabilitiesMap = Partial<Record<ProviderCapabilityId, ProviderToolCapabilities>>;
+export declare function getProviderToolCapabilities(queryOrCli?: ProviderCapabilityQuery | ProviderCapabilityId): ProviderToolCapabilitiesMap;
+export declare function getOneProviderToolCapabilities(cli: ProviderCapabilityId, queryOrCli?: ProviderCapabilityQuery | ProviderCapabilityId): ProviderToolCapabilities;
+export declare function clearProviderToolCapabilitiesCache(): void;
+export declare function providerCapabilityIds(): readonly ProviderCapabilityId[];