llm-cli-gateway 2.7.0 → 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/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";
@@ -489,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) {
@@ -720,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 {};
@@ -1420,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") {
@@ -1830,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);
@@ -3619,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()
@@ -3779,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",
@@ -4622,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()
@@ -5224,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: [
                     {

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

@@ -46,6 +46,23 @@ export interface ProviderFeatureCapability {
     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;
@@ -54,6 +71,25 @@ export interface ProviderCapabilityControls {
     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;
@@ -62,6 +98,8 @@ export interface ProviderToolCapabilities {
     gatewayRequestTools: string[];
     modelInfo: CliInfo | GrokApiModelInfo;
     summary: string;
+    acpContract: AcpProviderContract;
+    acp: ProviderAcpCapability;
     controls: ProviderCapabilityControls;
     features: ProviderFeatureMap;
     discoveredSkills: ProviderSkillCapability[];

package/dist/provider-tool-capabilities.js

@@ -11,6 +11,146 @@ const MAX_SKILL_BYTES = 64 * 1024;
 const MAX_CONFIG_BYTES = 128 * 1024;
 const MAX_PROVIDER_TOOLS_PER_SKILL = 50;
 const CAPABILITY_CACHE_TTL_MS = 60 * 1000;
+export const ACP_CONTRACT = {
+    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: [
+        "Replace the MCP server.",
+        "Ship an outbound ACP server or frontend in this slice.",
+        "Wrap every provider immediately.",
+        "Run adapter-mediated providers by default.",
+        "Grant write or terminal HostServices by default.",
+        "Expose raw ACP JSON-RPC to agents.",
+        "Implement any agent-to-agent Agent Communication Protocol layer.",
+    ],
+    providers: {
+        mistral: {
+            classification: "native_candidate",
+            summary: "Mistral Vibe exposes native ACP via vibe-acp; first runtime pilot candidate.",
+        },
+        grok: {
+            classification: "native_candidate",
+            summary: "xAI Grok CLI exposes native ACP via grok agent stdio; second runtime pilot candidate.",
+        },
+        codex: {
+            classification: "adapter_mediated_deferred",
+            summary: "OpenAI Codex CLI has no native ACP entrypoint at the target version; adapter-mediated and deferred.",
+        },
+        claude: {
+            classification: "adapter_mediated_deferred",
+            summary: "Anthropic Claude Code has no native ACP entrypoint at the target version; adapter-mediated and deferred.",
+        },
+        gemini: {
+            classification: "absent_watchlist",
+            summary: "Google Antigravity agy 1.0.7 has no ACP surface; watchlist item only.",
+        },
+        grok_api: {
+            classification: "absent_watchlist",
+            summary: "Grok API is an HTTP provider with no ACP process transport; watchlist item only.",
+        },
+    },
+};
+const ACP_DOCS_REFERENCE = "docs/plans/first-class-acp-gateway-extension.dag.toml";
+const ACP_CAPABILITIES = {
+    mistral: {
+        status: "native_smoke_passed",
+        mediation: "native",
+        targetVersion: "vibe 2.14.1",
+        entrypoint: { command: "vibe-acp", args: [] },
+        runtimeEnabled: false,
+        smokeSupported: true,
+        smokeStatus: "passed",
+        caveats: [
+            "Native ACP via the provider-scoped vibe-acp executable; first runtime pilot.",
+            "Runtime routing stays disabled until ACP is enabled in gateway config.",
+        ],
+        docs: ACP_DOCS_REFERENCE,
+    },
+    grok: {
+        status: "native_smoke_passed",
+        mediation: "native",
+        targetVersion: "grok 0.2.50 (cadf94855)",
+        entrypoint: { command: "grok", args: ["agent", "stdio"] },
+        runtimeEnabled: false,
+        smokeSupported: true,
+        smokeStatus: "passed",
+        caveats: [
+            "Native ACP via grok agent stdio; second runtime pilot.",
+            "Credential lookup is owned by the installed CLI; empty-env smoke is not expected to pass.",
+            "Runtime routing stays disabled until ACP is enabled in gateway config.",
+        ],
+        docs: ACP_DOCS_REFERENCE,
+    },
+    codex: {
+        status: "adapter_mediated_deferred",
+        mediation: "adapter_mediated",
+        targetVersion: "codex-cli 0.139.0",
+        entrypoint: null,
+        runtimeEnabled: false,
+        smokeSupported: false,
+        smokeStatus: "unsupported",
+        caveats: [
+            "No native ACP entrypoint at the target version; ACP would be adapter-mediated.",
+            "Adapter support requires a separate threat model and is never labelled native gateway ACP support.",
+        ],
+        docs: ACP_DOCS_REFERENCE,
+    },
+    claude: {
+        status: "adapter_mediated_deferred",
+        mediation: "adapter_mediated",
+        targetVersion: "claude 2.1.175",
+        entrypoint: null,
+        runtimeEnabled: false,
+        smokeSupported: false,
+        smokeStatus: "unsupported",
+        caveats: [
+            "No native Claude Code CLI ACP entrypoint at the target version; ACP would be adapter-mediated.",
+            "Adapter ownership, permission bridging, and install story must be specified before runtime support.",
+        ],
+        docs: ACP_DOCS_REFERENCE,
+    },
+    gemini: {
+        status: "absent_watchlist",
+        mediation: "none",
+        targetVersion: "agy 1.0.7",
+        entrypoint: null,
+        runtimeEnabled: false,
+        smokeSupported: false,
+        smokeStatus: "unsupported",
+        caveats: [
+            "Antigravity agy 1.0.7 has no ACP flag or subcommand.",
+            "Legacy Gemini CLI ACP evidence does not transfer to agy; kept on the upstream drift watchlist.",
+        ],
+        docs: ACP_DOCS_REFERENCE,
+    },
+    grok_api: {
+        status: "not_applicable",
+        mediation: "none",
+        targetVersion: "xAI Responses API",
+        entrypoint: null,
+        runtimeEnabled: false,
+        smokeSupported: false,
+        smokeStatus: "unsupported",
+        caveats: ["ACP is a CLI-stdio transport; the HTTP API provider has no ACP surface."],
+        docs: ACP_DOCS_REFERENCE,
+    },
+};
+function cloneAcpCapability(acp) {
+    return {
+        ...acp,
+        entrypoint: acp.entrypoint
+            ? { command: acp.entrypoint.command, args: [...acp.entrypoint.args] }
+            : null,
+        caveats: [...acp.caveats],
+    };
+}
 const PROVIDER_CAPABILITY_IDS = [...CLI_TYPES, "grok_api"];
 const KNOWN_PROVIDER_TOOLS = {
     grok: [
@@ -640,6 +780,8 @@ function buildOneProviderToolCapabilities(cli, query) {
         gatewayRequestTool: gatewayRequestTools[0] ?? definition.gatewayRequestTools[0],
         modelInfo: getModelInfo(cli, query.refresh),
         summary: definition.summary,
+        acpContract: { ...ACP_CONTRACT.providers[cli] },
+        acp: cloneAcpCapability(ACP_CAPABILITIES[cli]),
         controls: cloneControls(definition.controls),
         features,
         discoveredSkills,

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/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;