llm-cli-gateway 2.13.2 → 2.14.0

package/dist/model-registry.js

@@ -139,6 +139,7 @@ function cloneInfo(source) {
         aliases: source.aliases ? { ...source.aliases } : undefined,
         modelMetadata: source.modelMetadata ? { ...source.modelMetadata } : {},
         warnings: source.warnings ? [...source.warnings] : [],
+        defaultAgent: source.defaultAgent,
     };
     Object.keys(cloned.models).forEach(model => {
         cloned.modelMetadata[model] = cloned.modelMetadata[model] ?? {
@@ -373,6 +374,7 @@ function applyGeminiOverrides(info) {
 }
 function applyGrokOverrides(info) {
     const envDefault = process.env.GROK_DEFAULT_MODEL;
+    applyGrokConfig(info);
     addEnvModels(info, "GROK_MODELS");
     addEnvAliases(info, "grok", "GROK_MODEL_ALIASES");
     addGlobalEnvAliases(info, "grok");
@@ -381,8 +383,48 @@ function applyGrokOverrides(info) {
     }
     info.modelOrder = buildOrder(info, info.defaultModel);
 }
+function applyGrokConfig(info) {
+    const configPath = process.env.GROK_CONFIG_PATH || path.join(homedir(), ".grok", "config.toml");
+    if (!existsSync(configPath)) {
+        return;
+    }
+    try {
+        const parsed = parseToml(readFileSync(configPath, "utf-8"));
+        const models = readRecordProperty(parsed, "models");
+        Object.entries(models).forEach(([key, value]) => {
+            if (typeof value !== "string") {
+                return;
+            }
+            if (key === "default") {
+                setDefaultModel(info, value, `${configPath} [models].default`, "config");
+                return;
+            }
+            addModel(info, value, `Custom Grok model from config.toml [models].${key}`, {
+                source: "config",
+                sourceDetail: `${configPath} [models].${key}`,
+                confidence: "medium",
+            });
+        });
+        const ui = readRecordProperty(parsed, "ui");
+        const forkModel = readStringProperty(ui, "fork_secondary_model");
+        if (forkModel) {
+            addModel(info, forkModel, "Configured Grok fork/secondary model", {
+                source: "config",
+                sourceDetail: `${configPath} [ui].fork_secondary_model`,
+                confidence: "medium",
+            });
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        addWarning(info, `Could not parse Grok config ${configPath}: ${message}`);
+    }
+}
 function applyMistralOverrides(info) {
     const vibeConfig = readVibeConfig(info);
+    if (vibeConfig.defaultAgent) {
+        info.defaultAgent = vibeConfig.defaultAgent;
+    }
     addVibeModelEntries(info, parseVibeModels(process.env.VIBE_MODELS, "VIBE_MODELS"), "env");
     addVibeModelEntries(info, vibeConfig.models, "config");
     addEnvModels(info, "MISTRAL_MODELS");
@@ -426,6 +468,10 @@ function readVibeConfig(info) {
         if (activeModel) {
             result.activeModel = activeModel.trim();
         }
+        const defaultAgent = readStringProperty(parsed, "default_agent");
+        if (defaultAgent) {
+            result.defaultAgent = defaultAgent.trim();
+        }
         result.models = parseVibeModelArray(readRecordOrArrayProperty(parsed, "models"), configPath);
     }
     catch (error) {

package/dist/oauth.js

@@ -273,7 +273,7 @@ export class OAuthServer {
         return {
             resource: joinBaseAndPath(baseUrl, this.opts.protectedPath),
             authorization_servers: [baseUrl],
-            scopes_supported: ["mcp", "workspace:admin"],
+            scopes_supported: ["mcp", "workspace:admin", "cli:admin"],
             bearer_methods_supported: ["header"],
         };
     }
@@ -291,7 +291,7 @@ export class OAuthServer {
             code_challenge_methods_supported: this.opts.config.allowPlainPkce
                 ? ["S256", "plain"]
                 : ["S256"],
-            scopes_supported: ["mcp", "workspace:admin"],
+            scopes_supported: ["mcp", "workspace:admin", "cli:admin"],
         };
     }
     registrationAllowedByPolicy(req, params) {

package/dist/postgres-job-store-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/postgres-job-store-worker.js

@@ -0,0 +1,444 @@
+import { writeFileSync } from "node:fs";
+import { parentPort, workerData } from "node:worker_threads";
+let pool = null;
+const PG_NOW_MS = "(EXTRACT(EPOCH FROM now()) * 1000)::bigint";
+function signal(shared, status) {
+    const view = new Int32Array(shared);
+    Atomics.store(view, 0, status);
+    Atomics.notify(view, 0, 1);
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function fail(error) {
+    return {
+        ok: false,
+        error: {
+            message: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        },
+    };
+}
+function getPool() {
+    if (!pool)
+        throw new Error("PostgresJobStore worker pool is not initialized");
+    return pool;
+}
+async function withClient(fn) {
+    const client = await getPool().connect();
+    try {
+        return await fn(client);
+    }
+    finally {
+        client.release();
+    }
+}
+async function init() {
+    let pg;
+    try {
+        pg = await import("pg");
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") {
+            throw new Error("Postgres persistence requires optional peer dependency 'pg'. Install it alongside llm-cli-gateway to use backend = 'postgres'.", { cause: error });
+        }
+        throw error;
+    }
+    pool = new pg.Pool({
+        connectionString: workerData.dsn,
+        connectionTimeoutMillis: workerData.connectionTimeoutMillis,
+    });
+    await getPool().query("SELECT 1");
+    await getPool().query(`
+    CREATE TABLE IF NOT EXISTS jobs (
+      id TEXT PRIMARY KEY,
+      correlation_id TEXT NOT NULL,
+      request_key TEXT NOT NULL,
+      cli TEXT NOT NULL,
+      args_json TEXT NOT NULL,
+      output_format TEXT,
+      status TEXT NOT NULL,
+      exit_code INTEGER,
+      stdout TEXT,
+      stderr TEXT,
+      output_truncated BOOLEAN NOT NULL DEFAULT FALSE,
+      error TEXT,
+      started_at TEXT NOT NULL,
+      finished_at TEXT,
+      pid INTEGER,
+      expires_at TEXT NOT NULL,
+      owner_principal TEXT,
+      transport TEXT NOT NULL DEFAULT 'process',
+      http_status INTEGER,
+      payload_json TEXT,
+      owner_instance TEXT,
+      lease_deadline BIGINT
+    );
+    CREATE INDEX IF NOT EXISTS idx_jobs_request_key ON jobs(request_key);
+    CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+    CREATE INDEX IF NOT EXISTS idx_jobs_expires_at ON jobs(expires_at);
+    CREATE INDEX IF NOT EXISTS idx_jobs_request_key_finished ON jobs(request_key, finished_at);
+
+    CREATE TABLE IF NOT EXISTS gateway_instances (
+      instance_id TEXT PRIMARY KEY,
+      role TEXT,
+      hostname TEXT,
+      pid INTEGER,
+      started_at BIGINT NOT NULL,
+      last_heartbeat BIGINT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_gateway_instances_heartbeat
+      ON gateway_instances(last_heartbeat);
+
+    CREATE TABLE IF NOT EXISTS validation_runs (
+      validation_id TEXT PRIMARY KEY,
+      owner_principal TEXT NOT NULL,
+      intent TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      request_json TEXT NOT NULL,
+      provider_links TEXT NOT NULL,
+      judge_link TEXT,
+      status TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_validation_runs_owner ON validation_runs(owner_principal);
+
+    CREATE TABLE IF NOT EXISTS validation_run_jobs (
+      job_id TEXT PRIMARY KEY,
+      validation_id TEXT NOT NULL,
+      role TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_validation_run_jobs_run ON validation_run_jobs(validation_id);
+
+    CREATE TABLE IF NOT EXISTS validation_receipts (
+      validation_id TEXT PRIMARY KEY,
+      owner_principal TEXT NOT NULL,
+      minted_at TEXT NOT NULL,
+      schema_version TEXT NOT NULL,
+      report_json TEXT NOT NULL,
+      canonical_sha256 TEXT NOT NULL,
+      prev_sha256 TEXT,
+      seq INTEGER,
+      signature TEXT,
+      models TEXT NOT NULL,
+      has_material_disagreement BOOLEAN NOT NULL,
+      confidence TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_validation_receipts_owner ON validation_receipts(owner_principal);
+  `);
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS owner_principal TEXT");
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS transport TEXT NOT NULL DEFAULT 'process'");
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS http_status INTEGER");
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS payload_json TEXT");
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS owner_instance TEXT");
+    await getPool().query("ALTER TABLE jobs ADD COLUMN IF NOT EXISTS lease_deadline BIGINT");
+    await getPool().query("CREATE INDEX IF NOT EXISTS idx_jobs_owner_status ON jobs(owner_instance, status)");
+}
+async function op(method, args) {
+    switch (method) {
+        case "init":
+            await init();
+            return null;
+        case "recordStart": {
+            const input = args[0];
+            await getPool().query(`INSERT INTO jobs (id, correlation_id, request_key, cli, args_json, output_format,
+                           status, exit_code, stdout, stderr, output_truncated, error,
+                           started_at, finished_at, pid, expires_at, owner_principal,
+                           transport, http_status, payload_json, owner_instance, lease_deadline)
+         VALUES ($1, $2, $3, $4, $5, $6, 'queued', NULL, '', '', FALSE, NULL,
+                 $7, NULL, $8, $9, $10, $11, NULL, $12, $13, ${PG_NOW_MS} + $14)`, [
+                input.id,
+                input.correlationId,
+                input.requestKey,
+                input.cli,
+                JSON.stringify(input.args),
+                input.outputFormat ?? null,
+                input.startedAt,
+                input.pid,
+                workerData.farFutureIso,
+                input.ownerPrincipal ?? null,
+                input.transport ?? "process",
+                input.payloadJson ?? null,
+                input.ownerInstance ?? null,
+                workerData.leaseTtlMs,
+            ]);
+            return null;
+        }
+        case "markRunning": {
+            const [id, opts] = args;
+            const result = await getPool().query(`UPDATE jobs
+         SET status = 'running', pid = $2, lease_deadline = ${PG_NOW_MS} + $3::bigint
+         WHERE id = $1 AND status = 'queued'`, [id, opts?.pid ?? null, workerData.leaseTtlMs]);
+            return (result.rowCount ?? 0) > 0;
+        }
+        case "registerInstance": {
+            const meta = args[0];
+            await getPool().query(`INSERT INTO gateway_instances (instance_id, role, hostname, pid, started_at, last_heartbeat)
+         VALUES ($1, $2, $3, $4, ${PG_NOW_MS}, ${PG_NOW_MS})
+         ON CONFLICT (instance_id) DO UPDATE SET
+           role = EXCLUDED.role, hostname = EXCLUDED.hostname, pid = EXCLUDED.pid,
+           last_heartbeat = EXCLUDED.last_heartbeat`, [meta.instanceId, meta.role ?? null, meta.hostname ?? null, meta.pid ?? null]);
+            return null;
+        }
+        case "heartbeat": {
+            const instanceId = args[0];
+            await withClient(async (client) => {
+                await client.query("BEGIN");
+                try {
+                    await client.query(`UPDATE gateway_instances SET last_heartbeat = ${PG_NOW_MS} WHERE instance_id = $1`, [instanceId]);
+                    await client.query(`UPDATE jobs SET lease_deadline = ${PG_NOW_MS} + $2
+             WHERE owner_instance = $1 AND status IN ('queued', 'running')`, [instanceId, workerData.leaseTtlMs]);
+                    await client.query("COMMIT");
+                }
+                catch (error) {
+                    await client.query("ROLLBACK");
+                    throw error;
+                }
+            });
+            return null;
+        }
+        case "deregisterInstance": {
+            await getPool().query("DELETE FROM gateway_instances WHERE instance_id = $1", [args[0]]);
+            return null;
+        }
+        case "selectStaleProcessCandidates": {
+            const result = await getPool().query(`SELECT j.id AS id, j.pid AS pid, j.transport AS transport,
+                j.owner_instance AS owner_instance, gi.hostname AS hostname
+         FROM jobs j
+         LEFT JOIN gateway_instances gi ON gi.instance_id = j.owner_instance
+         WHERE j.status IN ('queued', 'running')
+           AND j.transport = 'process'
+           AND j.pid IS NOT NULL
+           AND (j.lease_deadline IS NULL OR j.lease_deadline < ${PG_NOW_MS})`);
+            return result.rows.map(r => ({
+                id: r.id,
+                pid: r.pid,
+                transport: r.transport ?? "process",
+                ownerInstance: r.owner_instance ?? null,
+                hostname: r.hostname ?? null,
+            }));
+        }
+        case "recoverStaleJobs": {
+            const [leaseTtlMs, httpJobGraceMs, liveConfirmedIds] = args;
+            const excludeIds = liveConfirmedIds ?? [];
+            const httpGraceCutoffMs = "(" + PG_NOW_MS + " - $1::bigint)";
+            return await withClient(async (client) => {
+                await client.query("BEGIN");
+                try {
+                    if (excludeIds.length > 0) {
+                        await client.query(`UPDATE jobs SET lease_deadline = ${PG_NOW_MS} + $1::bigint, pid = NULL
+               WHERE status IN ('queued', 'running') AND id = ANY($2::text[])`, [leaseTtlMs, excludeIds]);
+                    }
+                    const orphan = await client.query(`UPDATE jobs
+             SET status = 'orphaned',
+                 error = COALESCE(error, 'owning gateway instance is no longer alive'),
+                 finished_at = COALESCE(finished_at, $2),
+                 expires_at = $3,
+                 lease_deadline = NULL
+             WHERE status IN ('queued', 'running')
+               AND (lease_deadline IS NULL OR lease_deadline < ${PG_NOW_MS})
+               AND (transport <> 'http'
+                    OR (EXTRACT(EPOCH FROM started_at::timestamptz) * 1000)::bigint < ${httpGraceCutoffMs})
+               AND NOT (id = ANY($4::text[]))
+             RETURNING id, correlation_id, started_at, stdout, stderr, exit_code, transport, http_status`, [
+                        httpJobGraceMs,
+                        new Date().toISOString(),
+                        new Date(Date.now() + workerData.retentionMs).toISOString(),
+                        excludeIds,
+                    ]);
+                    await client.query("COMMIT");
+                    return { orphaned: orphan.rows };
+                }
+                catch (error) {
+                    await client.query("ROLLBACK");
+                    throw error;
+                }
+            });
+        }
+        case "gcInstances": {
+            const result = await getPool().query(`DELETE FROM gateway_instances WHERE last_heartbeat < ${PG_NOW_MS} - $1::bigint`, [args[0]]);
+            return result.rowCount ?? 0;
+        }
+        case "recordOutput":
+            await getPool().query("UPDATE jobs SET stdout = $2, stderr = $3, output_truncated = $4 WHERE id = $1", args);
+            return null;
+        case "recordComplete": {
+            const input = args[0];
+            const expiresAt = new Date(Date.parse(input.finishedAt) + workerData.retentionMs).toISOString();
+            await getPool().query(`UPDATE jobs
+         SET status = $2, exit_code = $3, stdout = $4, stderr = $5,
+             output_truncated = $6, error = $7, finished_at = $8,
+             expires_at = $9, http_status = $10, lease_deadline = NULL
+         WHERE id = $1 AND status IN ('queued', 'running', 'orphaned')`, [
+                input.id,
+                input.status,
+                input.exitCode,
+                input.stdout,
+                input.stderr,
+                input.outputTruncated,
+                input.error,
+                input.finishedAt,
+                expiresAt,
+                input.httpStatus ?? null,
+            ]);
+            return null;
+        }
+        case "getById": {
+            const result = await getPool().query("SELECT * FROM jobs WHERE id = $1", [args[0]]);
+            return result.rows[0] ?? null;
+        }
+        case "findByRequestKey": {
+            const cutoff = new Date(Date.now() - workerData.dedupWindowMs).toISOString();
+            const result = await getPool().query(`SELECT * FROM jobs
+         WHERE request_key = $1
+           AND started_at >= $2
+           AND (
+             status IN ('running', 'completed')
+             OR (status = 'queued' AND lease_deadline IS NOT NULL AND lease_deadline >= ${PG_NOW_MS})
+           )
+         ORDER BY started_at DESC
+         LIMIT 1`, [args[0], cutoff]);
+            return result.rows[0] ?? null;
+        }
+        case "markOrphanedOnStartup":
+            return await withClient(async (client) => {
+                const now = new Date().toISOString();
+                const expiresAt = new Date(Date.now() + workerData.retentionMs).toISOString();
+                await client.query("BEGIN");
+                try {
+                    const rows = await client.query("SELECT id, correlation_id, started_at, stdout, stderr, exit_code, transport, http_status FROM jobs WHERE status = 'running'");
+                    const update = await client.query(`UPDATE jobs
+             SET status = 'orphaned',
+                 error = COALESCE(error, 'Gateway restarted while job was running'),
+                 finished_at = COALESCE(finished_at, $1),
+                 expires_at = $2
+             WHERE status = 'running'`, [now, expiresAt]);
+                    await client.query("COMMIT");
+                    return { count: update.rowCount ?? 0, orphaned: rows.rows };
+                }
+                catch (error) {
+                    await client.query("ROLLBACK");
+                    throw error;
+                }
+            });
+        case "evictExpired": {
+            const result = await getPool().query("DELETE FROM jobs WHERE expires_at < $1", [
+                new Date().toISOString(),
+            ]);
+            return result.rowCount ?? 0;
+        }
+        case "recordValidationRun": {
+            const run = args[0];
+            await withClient(async (client) => {
+                await client.query("BEGIN");
+                try {
+                    await client.query(`INSERT INTO validation_runs
+               (validation_id, owner_principal, intent, created_at, request_json,
+                provider_links, judge_link, status)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+             ON CONFLICT (validation_id) DO NOTHING`, [
+                        run.validationId,
+                        run.ownerPrincipal,
+                        run.intent,
+                        run.createdAt,
+                        run.requestJson,
+                        JSON.stringify(run.providerLinks),
+                        run.judgeLink ? JSON.stringify(run.judgeLink) : null,
+                        run.status,
+                    ]);
+                    for (const link of run.providerLinks) {
+                        await client.query(`INSERT INTO validation_run_jobs (job_id, validation_id, role)
+               VALUES ($1, $2, 'provider')
+               ON CONFLICT (job_id) DO NOTHING`, [link.jobId, run.validationId]);
+                    }
+                    await client.query("COMMIT");
+                }
+                catch (error) {
+                    await client.query("ROLLBACK");
+                    throw error;
+                }
+            });
+            return null;
+        }
+        case "getValidationRun": {
+            const result = await getPool().query("SELECT * FROM validation_runs WHERE validation_id = $1", [args[0]]);
+            return result.rows[0] ?? null;
+        }
+        case "setValidationJudgeLink": {
+            const [validationId, judgeLink] = args;
+            await withClient(async (client) => {
+                await client.query("BEGIN");
+                try {
+                    await client.query("UPDATE validation_runs SET judge_link = $2 WHERE validation_id = $1", [validationId, JSON.stringify(judgeLink)]);
+                    await client.query(`INSERT INTO validation_run_jobs (job_id, validation_id, role)
+             VALUES ($1, $2, 'judge')
+             ON CONFLICT (job_id) DO NOTHING`, [judgeLink.jobId, validationId]);
+                    await client.query("COMMIT");
+                }
+                catch (error) {
+                    await client.query("ROLLBACK");
+                    throw error;
+                }
+            });
+            return null;
+        }
+        case "setValidationRunStatus":
+            await getPool().query("UPDATE validation_runs SET status = $2 WHERE validation_id = $1", args);
+            return null;
+        case "getValidationRunIdByJobId": {
+            const result = await getPool().query("SELECT validation_id FROM validation_run_jobs WHERE job_id = $1", [args[0]]);
+            return result.rows[0] ? result.rows[0].validation_id : null;
+        }
+        case "recordValidationReceipt": {
+            const receipt = args[0];
+            await getPool().query(`INSERT INTO validation_receipts
+           (validation_id, owner_principal, minted_at, schema_version, report_json,
+            canonical_sha256, prev_sha256, seq, signature, models,
+            has_material_disagreement, confidence)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+         ON CONFLICT (validation_id) DO NOTHING`, [
+                receipt.validationId,
+                receipt.ownerPrincipal,
+                receipt.mintedAt,
+                receipt.schemaVersion,
+                receipt.reportJson,
+                receipt.canonicalSha256,
+                receipt.prevSha256,
+                receipt.seq,
+                receipt.signature,
+                JSON.stringify(receipt.models),
+                receipt.hasMaterialDisagreement,
+                receipt.confidence,
+            ]);
+            return null;
+        }
+        case "getValidationReceipt": {
+            const result = await getPool().query("SELECT * FROM validation_receipts WHERE validation_id = $1", [args[0]]);
+            return result.rows[0] ?? null;
+        }
+        case "close":
+            if (pool)
+                await pool.end();
+            pool = null;
+            return null;
+        default:
+            throw new Error(`Unknown PostgresJobStore worker method: ${method}`);
+    }
+}
+parentPort?.on("message", async (message) => {
+    const { method, args, resultPath, shared } = message;
+    let payload;
+    try {
+        payload = ok(await op(method, args));
+    }
+    catch (error) {
+        payload = fail(error);
+    }
+    try {
+        writeFileSync(resultPath, JSON.stringify(payload));
+        signal(shared, 1);
+    }
+    catch {
+        signal(shared, 2);
+    }
+});

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;