@pwrdrvr/agent-acp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PwrDrvr LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,568 @@
+import { Logger, AgentBackend, NormalizedThreadEvent, Unsubscribe, AgentBackendToolCallHandler, AgentBackendApprovalHandler, AgentStartThreadOptions, AgentBackendStartThreadResult, AgentStartTurnOptions, NormalizedToolCall } from '@pwrdrvr/agent-core';
+import { JsonRpcId, JsonRpcObserver, JsonRpcTransport } from '@pwrdrvr/agent-transport';
+
+/** The bidirectional transport shape the ACP client drives. */
+interface AcpJsonRpcTransport {
+    request(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;
+    notify?(method: string, params?: Record<string, unknown>): Promise<void>;
+    close?(): Promise<void>;
+    onNotification(listener: (method: string, params: Record<string, unknown>) => void): () => void;
+    onRequest?(listener: (method: string, params: Record<string, unknown>, id?: JsonRpcId) => Promise<unknown> | unknown): () => void;
+}
+type AcpStdioJsonRpcTransportOptions = {
+    command: string;
+    args: string[];
+    env?: NodeJS.ProcessEnv;
+    requestTimeoutMs?: number;
+    observer?: JsonRpcObserver;
+    logger?: Logger;
+    /** Override the underlying JSON-RPC transport (tests inject a fake). */
+    transport?: JsonRpcTransport;
+};
+declare class AcpStdioJsonRpcTransport implements AcpJsonRpcTransport {
+    private readonly connection;
+    private readonly notificationListeners;
+    private requestHandler;
+    constructor(options: AcpStdioJsonRpcTransportOptions);
+    connect(): Promise<void>;
+    request(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    close(): Promise<void>;
+    onNotification(listener: (method: string, params: Record<string, unknown>) => void): () => void;
+    onRequest(listener: (method: string, params: Record<string, unknown>, id?: JsonRpcId) => Promise<unknown> | unknown): () => void;
+}
+
+type LocalAcpProbeResult = {
+    stdout?: string | Buffer;
+    stderr?: string | Buffer;
+};
+type LocalAcpAgentProbe = (command: string, args: string[]) => Promise<LocalAcpProbeResult>;
+/** How a strategy decides it is installed + ACP-capable on this machine. */
+type AcpDiscoveryProbe = {
+    /** Args that print a version (probed first; failure = not installed). */
+    versionArgs: string[];
+    /** Args that print help/usage text the `helpMatches` regex confirms ACP support against. */
+    helpArgs: string[];
+    /** Regex the help/usage output must match for the agent to count as ACP-capable. */
+    helpMatches: RegExp;
+    /** Bare command name tried first. */
+    command: string;
+    /** Additional candidate command paths (Homebrew prefixes, `~/.<agent>/bin`, …). */
+    fallbackCommands?: string[];
+};
+/** Launch invocation: how to spawn the CLI in ACP stdio server mode. */
+type AcpSpawnSpec = {
+    /** Command to run (resolved against the discovered candidate at spawn time). */
+    command: string;
+    /** Args that put the CLI into ACP stdio server mode (e.g. `["--acp"]`). */
+    args: string[];
+    /** Extra env to set when launching (e.g. Gemini workspace-trust). */
+    env?: Record<string, string>;
+    /** Extra args appended only when missing (e.g. Gemini `--skip-trust`). */
+    ensureArgs?: string[];
+};
+/**
+ * Normalization quirks the normalizer reads. NO agent-id literal ever appears
+ * in the normalizer — it reads these fields off the strategy it was constructed
+ * with. A synthetic strategy with different quirk values flows through the
+ * normalizer with zero normalizer changes (asserted in tests).
+ */
+type AcpAgentQuirks = {
+    /**
+     * Whether agent "thought"/reasoning chunks surface as assistant messages.
+     * Qwen sets this false (its thoughts are noisy scaffolding); others true.
+     */
+    surfaceThoughts: boolean;
+    /**
+     * Where the auto-generated thread title comes from:
+     *   • "topic-update"  — a `tool_call` titled `Update topic to: "…"` (Gemini/Kimi/Qwen);
+     *   • "session-summary" — a vendor `session_summary_generated` update (Grok);
+     *   • "both" — recognize either.
+     */
+    titleFrom: "topic-update" | "session-summary" | "both";
+    /** Vendor notification methods routed through the same session/update path. */
+    vendorNotificationMethods?: string[];
+};
+type AcpAgentStrategy = {
+    /** Strategy id, also the registry id (`gemini`, `grok`, `kimi`, `qwen`, …). */
+    id: string;
+    /** Neutral backend id (`acp:<id>`) used as the thread/session correlation key. */
+    backendId: string;
+    displayName: string;
+    authors: string[];
+    license?: string;
+    repositoryUrl?: string;
+    discoveryProbe: AcpDiscoveryProbe;
+    spawn: AcpSpawnSpec;
+    quirks: AcpAgentQuirks;
+};
+/** Build the neutral backend id for a registry id. */
+declare function buildAcpBackendId(registryId: string): string;
+/** Quirks for an unknown/synthetic strategy default to the common case. */
+declare function defaultQuirks(overrides?: Partial<AcpAgentQuirks>): AcpAgentQuirks;
+
+type AcpRuntimeConfigOptionValue = {
+    value: string;
+    label?: string;
+    description?: string;
+};
+type AcpRuntimeConfigOption = {
+    id: string;
+    label: string;
+    description?: string;
+    type: "select";
+    category?: string;
+    currentValue?: string;
+    values: AcpRuntimeConfigOptionValue[];
+};
+type AcpRuntimeMode = {
+    id: string;
+    label: string;
+    description?: string;
+};
+type AcpRuntimeModel = {
+    id: string;
+    label?: string;
+    description?: string;
+};
+type AcpRuntimeModes = {
+    availableModes: AcpRuntimeMode[];
+    currentModeId?: string;
+};
+type AcpRuntimeModels = {
+    availableModels: AcpRuntimeModel[];
+    currentModelId?: string;
+};
+type AcpRuntimeAgentInfo = {
+    name?: string;
+    title?: string;
+    version?: string;
+};
+type AcpRuntimeAgentCapabilities = {
+    loadSession?: boolean;
+    sessionHistoryReplay?: boolean;
+    session?: {
+        close?: boolean;
+        cancel?: boolean;
+    };
+    raw?: unknown;
+};
+type AcpRuntimeCapabilitiesSource = "initialize" | "session-new" | "session-load";
+type AcpRuntimeCapabilities = {
+    source: AcpRuntimeCapabilitiesSource;
+    discoveredAt: number;
+    checkedAt: number;
+    protocolVersion?: number;
+    agentInfo?: AcpRuntimeAgentInfo;
+    agentCapabilities?: AcpRuntimeAgentCapabilities;
+    configOptions?: AcpRuntimeConfigOption[];
+    modes?: AcpRuntimeModes;
+    models?: AcpRuntimeModels;
+};
+type AcpSessionRuntimeState = {
+    updatedAt?: number;
+    currentModeId?: string;
+    currentModelId?: string;
+    configValues?: Record<string, string>;
+};
+declare function normalizeAcpRuntimeCapabilities(params: {
+    value: unknown;
+    now: number;
+    source: AcpRuntimeCapabilitiesSource;
+    initialize?: AcpRuntimeCapabilities;
+}): AcpRuntimeCapabilities | undefined;
+declare function acpRuntimeSupportsSessionLoad(capabilities: AcpRuntimeCapabilities | undefined): boolean;
+declare function acpSessionRuntimeStateFromCapabilities(capabilities: AcpRuntimeCapabilities | undefined, now: number): AcpSessionRuntimeState | undefined;
+/** Runtime-state change carried inside a session/update (mode/model/config). */
+declare function acpSessionRuntimeStateFromUpdate(update: Record<string, unknown>, now: number): AcpSessionRuntimeState | undefined;
+declare function mergeAcpRuntimeState(existing: AcpSessionRuntimeState | undefined, update: AcpSessionRuntimeState): AcpSessionRuntimeState;
+/** Resolve the human-facing label for a mode id from the capabilities snapshot. */
+declare function modeLabelFor(capabilities: AcpRuntimeCapabilities | undefined, modeId: string): string | undefined;
+
+type AcpPromptContentBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    mimeType: string;
+    data: string;
+};
+type AcpMcpServerConfig = {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+};
+type AcpRuntimeOptionSource = "mode" | "model" | "configOption";
+type AcpAgentClientOptions = {
+    /** The transport (real stdio or a fake). */
+    transport: AcpJsonRpcTransport;
+    /** The agent strategy (carries quirks + display name). */
+    strategy: AcpAgentStrategy;
+    /** Identity sent at `initialize`. Defaults to "agent-kit". */
+    clientName?: string;
+    clientTitle?: string;
+    clientVersion?: string;
+    /** Default cwd for `session/new` when `startThread` omits one. */
+    cwd?: string;
+    /** MCP servers to attach at `session/new` / `session/load`. */
+    mcpServers?: AcpMcpServerConfig[];
+    now?: () => number;
+    logger?: Logger;
+};
+/** ACP-NATIVE thread/start options. **No longer the public `startThread`
+ *  surface** — `AcpAgentClient` implements the non-generic `AgentBackend` and its
+ *  public `startThread` takes neutral `AgentStartThreadOptions`. Retained as the
+ *  internal mapping target and exposed via `startThreadNative` for hosts wanting
+ *  ACP-specific control (e.g. per-thread `mcpServers`). */
+type AcpStartThreadOptions = {
+    /** Working directory for the agent session. */
+    cwd?: string;
+    mcpServers?: AcpMcpServerConfig[];
+};
+/** ACP-NATIVE turn/start options. Internal mapping target; the public `startTurn`
+ *  takes neutral `AgentStartTurnOptions`. */
+type AcpStartTurnOptions = {
+    threadId: string;
+    /** Plain prompt text. */
+    prompt?: string;
+    /** Pre-built ACP content blocks (text/image); overrides `prompt` when set. */
+    promptContent?: AcpPromptContentBlock[];
+};
+/** Fired when the normalizer extracts a thread title from the stream. */
+type AcpTitleHandler = (event: {
+    threadId: string;
+    title: string;
+}) => void;
+/** Fired when runtime capabilities (models/modes/config-options) are observed. */
+type AcpRuntimeCapabilitiesHandler = (event: {
+    threadId?: string;
+    runtimeCapabilities: AcpRuntimeCapabilities;
+    runtimeState?: AcpSessionRuntimeState;
+}) => void;
+declare class AcpAgentClient implements AgentBackend {
+    private readonly transport;
+    private readonly strategy;
+    private readonly now;
+    private readonly logger;
+    private readonly eventListeners;
+    private toolCallHandler;
+    private approvalHandler;
+    private titleHandler;
+    private runtimeCapabilitiesHandler;
+    private readonly sessions;
+    private readonly threadIdByProtocolId;
+    private unsubscribeNotification;
+    private unsubscribeRequest;
+    private initialized;
+    private runtimeCapabilities?;
+    private threadSequence;
+    constructor(options: AcpAgentClientOptions);
+    private readonly clientName;
+    private readonly clientTitle;
+    private readonly clientVersion;
+    private readonly defaultCwd;
+    private readonly defaultMcpServers;
+    onEvent(cb: (event: NormalizedThreadEvent) => void): Unsubscribe;
+    onToolCall(handler: AgentBackendToolCallHandler): Unsubscribe;
+    onApprovalRequest(handler: AgentBackendApprovalHandler): Unsubscribe;
+    /** Subscribe to title extraction (topic-update / session-summary). */
+    onTitle(handler: AcpTitleHandler): Unsubscribe;
+    /** Subscribe to runtime-capabilities (models/modes/config-options) changes. */
+    onRuntimeCapabilities(handler: AcpRuntimeCapabilitiesHandler): Unsubscribe;
+    /**
+     * Public `AgentBackend.startThread`: accepts NEUTRAL `AgentStartThreadOptions`
+     * and maps them onto an ACP `session/new`. ACP supports:
+     *   • `cwd` → `session/new.cwd`.
+     *   • `model` → applied via `session/set_model` after the session opens, when
+     *     the agent advertises model selection (best-effort; debug-logged if not).
+     *   • `instructions` is NOT injected here — ACP `session/new` has no base-
+     *     instructions slot, matching the adapter's existing behavior. A host that
+     *     wants system framing sends it as leading turn text.
+     * Codex-only fields (`approvalPolicy`, `sandbox`, `config`, `environments`,
+     * `tools`, `serviceName`, `modelProvider`, `serviceTier`, `workspaceRoots`) are
+     * IGNORED — logged at debug so it's visible the backend doesn't honor them.
+     */
+    startThread(options?: AgentStartThreadOptions): Promise<AgentBackendStartThreadResult>;
+    /** ACP-native `session/new`. The neutral `startThread` delegates here after
+     *  mapping cwd + dropping Codex-only fields. Exposed for hosts that need
+     *  ACP-specific control (per-thread `mcpServers`). */
+    startThreadNative(options?: AcpStartThreadOptions): Promise<AgentBackendStartThreadResult>;
+    /**
+     * Public `AgentBackend.startTurn`: accepts NEUTRAL `AgentStartTurnOptions` and
+     * maps them onto ACP prompt content blocks — a leading `text` block from
+     * `input.text`, then one `image` block per `input.imagePaths` entry (read from
+     * disk, base64-encoded, mimeType inferred from extension). `reasoning` maps to
+     * an ACP mode/config when the session advertises a matching option, else it is
+     * IGNORED (debug-logged).
+     */
+    startTurn(options: AgentStartTurnOptions): Promise<{
+        turnId: string;
+    }>;
+    /** ACP-native `session/prompt`. Takes a plain prompt or pre-built content
+     *  blocks. The neutral `startTurn` delegates here after building blocks. */
+    startTurnNative(options: AcpStartTurnOptions): Promise<{
+        turnId: string;
+    }>;
+    interruptTurn(threadId: string): Promise<void>;
+    setMode(threadId: string, modeId: string): Promise<void>;
+    setModel(threadId: string, modelId: string): Promise<void>;
+    setConfigOption(threadId: string, optionId: string, value: string): Promise<void>;
+    close(): Promise<void>;
+    private emit;
+    private initialize;
+    private handleNotification;
+    private applySessionUpdate;
+    private handleAcpRequest;
+    private handlePermissionRequest;
+    private setRuntimeOption;
+    private setRuntimeOptionOnTransport;
+    /** Map a neutral `reasoning` token onto an ACP runtime option. We try to match
+     *  it to an available MODE (by id or label, case-insensitively) and switch via
+     *  `session/set_mode`. ACP has no first-class "reasoning effort" concept, so if
+     *  no mode matches we leave it alone — the caller's `.catch` debug-logs. */
+    private applyReasoning;
+    /** Read an image file and build an ACP `image` content block (base64 + inferred
+     *  mimeType). Throws on read failure; the caller catches + skips. */
+    private imageBlockFromPath;
+    private captureRuntimeCapabilities;
+    private notifyRuntimeCapabilities;
+    private emitThreadSettings;
+    private requireSession;
+    /** Whether the agent advertises session/load support (for hosts that resume). */
+    supportsSessionLoad(): boolean;
+}
+
+type AcpNormalizerOptions = {
+    /** The agent's normalization quirks (surface thoughts, where title comes from). */
+    quirks: AcpAgentQuirks;
+};
+type AcpNormalizeResult = {
+    events: NormalizedThreadEvent[];
+    /** A thread title extracted from a topic-update / session-summary, if any. */
+    title?: string;
+};
+type AcpApplyContext = {
+    threadId: string;
+    turnId: string;
+};
+declare class AcpSessionNormalizer {
+    private readonly quirks;
+    private activeAssistantItemId;
+    private assistantText;
+    private assistantSequence;
+    private readonly toolCalls;
+    constructor(options: AcpNormalizerOptions);
+    /** Reset coalescing state at a turn boundary (new prompt / turn finished). */
+    resetTurn(): void;
+    /** Finalize the in-flight assistant bubble into a terminal `agent_message`, if any. */
+    finalizeAssistantMessage(ctx: AcpApplyContext): NormalizedThreadEvent[];
+    /** Normalize one ACP session/update into neutral events (+ optional title). */
+    apply(update: Record<string, unknown>, ctx: AcpApplyContext): AcpNormalizeResult;
+    private applyAgentMessageChunk;
+    private applyThoughtChunk;
+    private applyUserMessageChunk;
+    private applyPlan;
+    private applyToolCall;
+    private assistantItemIdForChunk;
+    /** Strategy-driven title extraction. NO agent-id literal — reads quirks.titleFrom. */
+    private extractTitle;
+}
+/** Read the message parts (text/image) of a prompt, camel/snake tolerant. */
+declare function readPromptText(content: unknown): string | undefined;
+
+/** Read the tool-call correlation id across every spelling agents use. */
+declare function readToolCallId(update: Record<string, unknown>, kind: string, sessionId: string): string;
+/**
+ * Normalize one ACP tool-ish update (tool_call / tool_call_update / file /
+ * terminal) into a NormalizedToolCall. The result is fed to the normalizer's
+ * upsert, which merges deltas with the same id via agent-core's `mergeToolCall`.
+ */
+declare function toolCallFromUpdate(update: Record<string, unknown>, kind: string, sessionId: string): NormalizedToolCall;
+/** Tool output text from a content array, for permission prompts. */
+declare function readToolContentText(value: unknown): string | undefined;
+
+declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+declare function readString(record: Record<string, unknown> | undefined, key: string): string | undefined;
+declare function readNonEmptyString(record: Record<string, unknown> | undefined, key: string): string | undefined;
+declare function readNumber(record: Record<string, unknown> | undefined, key: string): number | undefined;
+declare function readBoolean(record: Record<string, unknown> | undefined, key: string): boolean | undefined;
+/**
+ * Read the first defined string among the given keys, in order. Used for
+ * camel/snake parity (`toolCallId` vs `tool_call_id`).
+ */
+declare function readFirstString(record: Record<string, unknown> | undefined, ...keys: string[]): string | undefined;
+/** The session-update kind, tolerant of all four key spellings. */
+declare function readKind(update: Record<string, unknown>): string;
+/**
+ * Recursively unwrap an ACP content value to plain text. Handles a bare string,
+ * an array of content blocks (joined with newlines), and nested
+ * `{ type:"text", text }` / `{ content }` / `{ text }` / `{ output }` /
+ * `{ result }` shapes.
+ */
+declare function readAcpContentText(value: unknown): string | undefined;
+declare function readContentText(record: Record<string, unknown>, key: string): string | undefined;
+/** Tool output, checked across all the spellings agents use. */
+declare function readToolOutput(record: Record<string, unknown>): string | undefined;
+/** First location path from an ACP `locations: [{ path }]` array. */
+declare function readFirstLocationPath(record: Record<string, unknown>): string | undefined;
+/** The assistant/user text carried by a chunk update (camel/snake tolerant). */
+declare function readUpdateText(update: Record<string, unknown>): string | undefined;
+
+declare const geminiStrategy: AcpAgentStrategy;
+
+declare const grokStrategy: AcpAgentStrategy;
+
+declare const kimiStrategy: AcpAgentStrategy;
+
+declare const qwenStrategy: AcpAgentStrategy;
+
+declare const BUILT_IN_ACP_STRATEGIES: readonly AcpAgentStrategy[];
+/** Index a list of strategies by id (built-ins by default). */
+declare function buildStrategyTable(strategies?: readonly AcpAgentStrategy[]): Map<string, AcpAgentStrategy>;
+/** Look up a strategy by its registry id, falling back to the built-in table. */
+declare function strategyById(id: string, table?: Map<string, AcpAgentStrategy>): AcpAgentStrategy | undefined;
+/** Look up a strategy by its neutral backend id (`acp:<id>`). */
+declare function strategyByBackendId(backendId: string, strategies?: readonly AcpAgentStrategy[]): AcpAgentStrategy | undefined;
+
+type DiscoveredAcpAgent = {
+    strategyId: string;
+    backendId: string;
+    name: string;
+    version?: string;
+    /** Resolved command that passed the probe (may be a fallback path). */
+    command: string;
+    /** Spawn args that put it into ACP stdio mode. */
+    args: string[];
+    /** Extra env to set at launch. */
+    env: Record<string, string>;
+    discoveredAt: number;
+};
+type LocalAcpDiscoveryOptions = {
+    probe?: LocalAcpAgentProbe;
+    now?: () => number;
+    /** Strategy table to probe (built-ins by default). */
+    strategies?: readonly AcpAgentStrategy[];
+    /** Per-strategy command override (tried before the strategy's own candidates). */
+    overrides?: Record<string, string>;
+};
+declare function discoverLocalAcpAgents(options?: LocalAcpDiscoveryOptions): Promise<DiscoveredAcpAgent[]>;
+
+declare const ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+type AcpDistributionKind = "npx" | "uvx" | "binary" | "local";
+type AcpRegistryDistributionEnv = Record<string, string>;
+type AcpPackageDistribution = {
+    kind: "npx" | "uvx";
+    packageName: string;
+    args: string[];
+    env: AcpRegistryDistributionEnv;
+};
+type AcpBinaryPlatformDistribution = {
+    kind: "binary";
+    platform: string;
+    archiveUrl: string;
+    command: string;
+    args: string[];
+    env: AcpRegistryDistributionEnv;
+    checksum?: string;
+    signatureUrl?: string;
+};
+type AcpRegistryDistribution = AcpPackageDistribution | AcpBinaryPlatformDistribution;
+type AcpRegistryAuthMethod = "agent-managed" | "terminal" | "unknown";
+type AcpRegistryAuthDescriptor = {
+    required: boolean;
+    methods: AcpRegistryAuthMethod[];
+    raw?: unknown;
+};
+type AcpRegistryAgent = {
+    id: string;
+    backendId: string;
+    name: string;
+    version?: string;
+    description?: string;
+    authors: string[];
+    license?: string;
+    repositoryUrl?: string;
+    websiteUrl?: string;
+    iconUrl?: string;
+    distributions: AcpRegistryDistribution[];
+    distributionKinds: AcpDistributionKind[];
+    auth: AcpRegistryAuthDescriptor;
+    raw: unknown;
+};
+type AcpVerificationStatus = "verified" | "unverified-allowed" | "unverified-blocked" | "not-applicable";
+type AcpAllowlistDecision = {
+    allowed: true;
+    ruleId: string;
+    unverifiedBinaryAllowed: boolean;
+} | {
+    allowed: false;
+    reason: string;
+};
+type AcpRegistryAgentWithPolicy = AcpRegistryAgent & {
+    allowlist: AcpAllowlistDecision;
+    installable: boolean;
+    unavailableReason?: string;
+    verificationStatus: AcpVerificationStatus;
+};
+type AcpRegistrySnapshot = {
+    fetchedAt: number;
+    agents: AcpRegistryAgent[];
+    raw: unknown;
+};
+
+type AcpAgentAllowlistRule = {
+    id: string;
+    registryId: string;
+    versions?: string[];
+    distributionKinds?: AcpDistributionKind[];
+    allowedPackageNames?: string[];
+    allowedArchiveHosts?: string[];
+    allowUnverifiedBinary?: boolean;
+    allowGplFamilyLicense?: boolean;
+};
+declare const BANNED_ACP_REGISTRY_IDS: Set<string>;
+declare const DEFAULT_ACP_AGENT_ALLOWLIST: AcpAgentAllowlistRule[];
+declare class AcpAgentAllowlist {
+    private readonly rules;
+    constructor(rules: AcpAgentAllowlistRule[]);
+    evaluate(agent: AcpRegistryAgent): AcpAllowlistDecision;
+    evaluateDistribution(agent: AcpRegistryAgent, distribution: AcpRegistryDistribution): AcpAllowlistDecision;
+}
+declare const defaultAcpAgentAllowlist: AcpAgentAllowlist;
+declare function isBannedAcpRegistryId(registryId: string): boolean;
+
+type AcpRegistryFetch = (input: string, init?: {
+    headers?: Record<string, string>;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    statusText: string;
+    json(): Promise<unknown>;
+}>;
+type AcpRegistryServiceOptions = {
+    allowlist?: AcpAgentAllowlist;
+    fetch?: AcpRegistryFetch;
+    now?: () => number;
+    registryUrl?: string;
+};
+type AcpDistributionPolicy = {
+    allowlist: AcpAllowlistDecision;
+    installable: boolean;
+    verificationStatus: AcpVerificationStatus;
+    unavailableReason?: string;
+};
+declare class AcpRegistryService {
+    private readonly allowlist;
+    private readonly fetcher;
+    private readonly now;
+    private readonly registryUrl;
+    constructor(options?: AcpRegistryServiceOptions);
+    fetchRegistry(): Promise<AcpRegistrySnapshot>;
+    applyAllowlist(snapshot: AcpRegistrySnapshot): AcpRegistryAgentWithPolicy[];
+    evaluateDistribution(agent: AcpRegistryAgent, distribution: AcpRegistryDistribution): AcpDistributionPolicy;
+}
+declare function evaluateAcpDistributionPolicy(distribution: AcpRegistryDistribution, allowlist: AcpAllowlistDecision): AcpDistributionPolicy;
+declare function normalizeRegistry(raw: unknown): AcpRegistryAgent[];
+
+export { ACP_REGISTRY_URL, AcpAgentAllowlist, type AcpAgentAllowlistRule, AcpAgentClient, type AcpAgentClientOptions, type AcpAgentQuirks, type AcpAgentStrategy, type AcpAllowlistDecision, type AcpApplyContext, type AcpBinaryPlatformDistribution, type AcpDiscoveryProbe, type AcpDistributionKind, type AcpDistributionPolicy, type AcpJsonRpcTransport, type AcpMcpServerConfig, type AcpNormalizeResult, type AcpNormalizerOptions, type AcpPackageDistribution, type AcpPromptContentBlock, type AcpRegistryAgent, type AcpRegistryAgentWithPolicy, type AcpRegistryAuthDescriptor, type AcpRegistryAuthMethod, type AcpRegistryDistribution, type AcpRegistryFetch, AcpRegistryService, type AcpRegistryServiceOptions, type AcpRegistrySnapshot, type AcpRuntimeAgentCapabilities, type AcpRuntimeAgentInfo, type AcpRuntimeCapabilities, type AcpRuntimeCapabilitiesHandler, type AcpRuntimeCapabilitiesSource, type AcpRuntimeConfigOption, type AcpRuntimeConfigOptionValue, type AcpRuntimeMode, type AcpRuntimeModel, type AcpRuntimeModels, type AcpRuntimeModes, type AcpRuntimeOptionSource, AcpSessionNormalizer, type AcpSessionRuntimeState, type AcpSpawnSpec, type AcpStartThreadOptions, type AcpStartTurnOptions, AcpStdioJsonRpcTransport, type AcpStdioJsonRpcTransportOptions, type AcpTitleHandler, type AcpVerificationStatus, BANNED_ACP_REGISTRY_IDS, BUILT_IN_ACP_STRATEGIES, DEFAULT_ACP_AGENT_ALLOWLIST, type DiscoveredAcpAgent, type LocalAcpAgentProbe, type LocalAcpDiscoveryOptions, type LocalAcpProbeResult, acpRuntimeSupportsSessionLoad, acpSessionRuntimeStateFromCapabilities, acpSessionRuntimeStateFromUpdate, asRecord, buildAcpBackendId, buildStrategyTable, defaultAcpAgentAllowlist, defaultQuirks, discoverLocalAcpAgents, evaluateAcpDistributionPolicy, geminiStrategy, grokStrategy, isBannedAcpRegistryId, kimiStrategy, mergeAcpRuntimeState, modeLabelFor, normalizeAcpRuntimeCapabilities, normalizeRegistry, qwenStrategy, readAcpContentText, readBoolean, readContentText, readFirstLocationPath, readFirstString, readKind, readNonEmptyString, readNumber, readPromptText, readString, readToolCallId, readToolContentText, readToolOutput, readUpdateText, strategyByBackendId, strategyById, toolCallFromUpdate };