@multi-agent-protocol/sdk 0.0.4 → 0.0.6

package/dist/{index-Z76qC_Us.d.cts → index-BQXp4_rd.d.cts}

@@ -1,3 +1,5 @@
+import { EventEmitter } from 'events';
+
 /**
  * Multi-Agent Protocol (MAP) Type Definitions - v2
  *
@@ -94,6 +96,29 @@ interface ParticipantCapabilities {
     };
     /** Streaming/backpressure capabilities */
     streaming?: StreamingCapabilities;
+    /**
+     * Protocols supported by this participant.
+     * Used for protocol capability discovery.
+     *
+     * @example ['acp', 'mcp']
+     */
+    protocols?: string[];
+    /**
+     * ACP (Agent Client Protocol) capability details.
+     * Only present if 'acp' is in the protocols array.
+     */
+    acp?: ACPCapability;
+    _meta?: Meta;
+}
+/**
+ * ACP capability advertisement.
+ * Describes what ACP features an agent supports.
+ */
+interface ACPCapability {
+    /** ACP protocol version supported (e.g., '2024-10-07') */
+    version: string;
+    /** ACP features supported by this agent */
+    features?: string[];
     _meta?: Meta;
 }
 /** A participant in the MAP protocol */
@@ -408,6 +433,11 @@ interface MessageMeta {
     priority?: MessagePriority;
     delivery?: DeliverySemantics;
     ttlMs?: number;
+    /**
+     * Protocol identifier for tunneled protocols (e.g., 'acp').
+     * Used to identify the protocol of the payload.
+     */
+    protocol?: string;
     _meta?: Meta;
 }
 /** A message in the multi-agent system */
@@ -532,7 +562,6 @@ declare function createEvent(input: EventInput): Event;
  * | Field | Within-field | Cross-field | Description |
  * |-------|--------------|-------------|-------------|
  * | `eventTypes` | OR | AND | Event type is one of the listed types |
- * | `agents` | OR | AND | Event relates to one of the listed agents (legacy) |
  * | `fromAgents` | OR | AND | Event source is one of the listed agents |
  * | `fromRoles` | OR | AND | Event source agent has one of the listed roles |
  * | `roles` | OR | AND | Event relates to agents with one of the listed roles |
@@ -542,11 +571,6 @@ declare function createEvent(input: EventInput): Event;
  * | `metadataMatch` | AND | AND | Event metadata contains ALL specified key-value pairs |
  */
 interface SubscriptionFilter {
-    /**
-     * Filter by agents the event relates to.
-     * @deprecated Use `fromAgents` for clearer semantics
-     */
-    agents?: AgentId[];
     /**
      * Filter by roles the event relates to.
      * Matches events where the related agent has one of these roles.
@@ -714,11 +738,77 @@ interface SessionInfo {
     lastActiveAt?: Timestamp;
     closedAt?: Timestamp;
 }
-type AuthMethod = 'bearer' | 'api-key' | 'mtls' | 'none';
-interface AuthParams {
+/** Standard authentication methods defined by the protocol */
+type StandardAuthMethod = 'bearer' | 'api-key' | 'mtls' | 'none';
+/** Authentication method - standard or custom (x- prefixed) */
+type AuthMethod = StandardAuthMethod | `x-${string}`;
+/** Authentication error codes */
+type AuthErrorCode = 'invalid_credentials' | 'expired' | 'insufficient_scope' | 'method_not_supported' | 'auth_required';
+/**
+ * Client-provided authentication credentials.
+ * Used in connect requests and authenticate calls.
+ */
+interface AuthCredentials {
+    /** The authentication method being used */
     method: AuthMethod;
-    token?: string;
+    /** The credential value (token, API key, etc.) */
+    credential?: string;
+    /** Method-specific additional data */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Server-advertised authentication capabilities.
+ * Included in connect response when auth is required.
+ */
+interface ServerAuthCapabilities {
+    /** Supported authentication methods (in preference order) */
+    methods: AuthMethod[];
+    /** Is authentication required to proceed? */
+    required: boolean;
+    /** OAuth2 authorization server metadata URL (RFC 8414) */
+    oauth2MetadataUrl?: string;
+    /** JWKS URL for local JWT verification (RFC 7517) */
+    jwksUrl?: string;
+    /** Realm identifier for this server */
+    realm?: string;
+}
+/**
+ * Authenticated principal information.
+ * Returned after successful authentication.
+ */
+interface AuthPrincipal {
+    /** Unique identifier for this principal */
+    id: string;
+    /** Token issuer (for federated auth) */
+    issuer?: string;
+    /** Additional claims from the credential */
+    claims?: Record<string, unknown>;
+    /** Token expiration timestamp (Unix ms) - from JWT exp claim */
+    expiresAt?: number;
+}
+/**
+ * Authentication error details.
+ */
+interface AuthError {
+    /** Error code */
+    code: AuthErrorCode;
+    /** Human-readable error message */
+    message: string;
+}
+/**
+ * Result of an authentication attempt.
+ */
+interface AuthResult {
+    /** Whether authentication succeeded */
+    success: boolean;
+    /** Authenticated principal (if success) */
+    principal?: AuthPrincipal;
+    /** Error details (if failure) */
+    error?: AuthError;
 }
+/**
+ * Authentication for federated connections.
+ */
 interface FederationAuth {
     method: 'bearer' | 'api-key' | 'mtls';
     credentials?: string;
@@ -745,7 +835,8 @@ interface ConnectRequestParams {
     reclaimAgents?: AgentId[];
     /** Policy for unexpected disconnect */
     disconnectPolicy?: DisconnectPolicy;
-    auth?: AuthParams;
+    /** Authentication credentials */
+    auth?: AuthCredentials;
     _meta?: Meta;
 }
 interface ConnectRequest extends MAPRequestBase<ConnectRequestParams> {
@@ -767,6 +858,12 @@ interface ConnectResponseResult {
     reclaimedAgents?: Agent[];
     /** Currently owned agents */
     ownedAgents?: AgentId[];
+    /** Authenticated principal (if auth succeeded) */
+    principal?: AuthPrincipal;
+    /** Auth required but not provided - client should authenticate */
+    authRequired?: ServerAuthCapabilities;
+    /** Token to resume this session later */
+    resumeToken?: string;
     _meta?: Meta;
 }
 interface DisconnectRequestParams {
@@ -1114,6 +1211,39 @@ interface AuthRefreshResponseResult {
     refreshToken?: string;
     _meta?: Meta;
 }
+/**
+ * Parameters for map/authenticate request.
+ * Used when auth negotiation is required after initial connect.
+ */
+interface AuthenticateRequestParams {
+    /** The authentication method being used */
+    method: AuthMethod;
+    /** The credential value (token, API key, etc.) */
+    credential?: string;
+    /** Method-specific additional data */
+    metadata?: Record<string, unknown>;
+    _meta?: Meta;
+}
+interface AuthenticateRequest extends MAPRequestBase<AuthenticateRequestParams> {
+    method: 'map/authenticate';
+    params: AuthenticateRequestParams;
+}
+/**
+ * Response from map/authenticate request.
+ */
+interface AuthenticateResponseResult {
+    /** Whether authentication succeeded */
+    success: boolean;
+    /** Session ID (if auth succeeded) */
+    sessionId?: SessionId;
+    /** Participant ID (if auth succeeded) */
+    participantId?: ParticipantId;
+    /** Authenticated principal (if auth succeeded) */
+    principal?: AuthPrincipal;
+    /** Error details (if auth failed) */
+    error?: AuthError;
+    _meta?: Meta;
+}
 interface ScopesListRequestParams {
     parent?: ScopeId;
     _meta?: Meta;
@@ -1606,6 +1736,7 @@ declare const SESSION_METHODS: {
 };
 /** Auth methods */
 declare const AUTH_METHODS: {
+    readonly AUTHENTICATE: "map/authenticate";
     readonly AUTH_REFRESH: "map/auth/refresh";
 };
 /** Permission methods */
@@ -1623,12 +1754,15 @@ declare const NOTIFICATION_METHODS: {
     readonly MESSAGE: "map/message";
     /** Client acknowledges received events (for backpressure) */
     readonly SUBSCRIBE_ACK: "map/subscribe.ack";
+    /** Server notifies client that auth is about to expire */
+    readonly AUTH_EXPIRING: "map/auth/expiring";
 };
 /** All MAP methods */
 declare const MAP_METHODS: {
     readonly FEDERATION_CONNECT: "map/federation/connect";
     readonly FEDERATION_ROUTE: "map/federation/route";
     readonly PERMISSIONS_UPDATE: "map/permissions/update";
+    readonly AUTHENTICATE: "map/authenticate";
     readonly AUTH_REFRESH: "map/auth/refresh";
     readonly SESSION_LIST: "map/session/list";
     readonly SESSION_LOAD: "map/session/load";
@@ -1691,6 +1825,9 @@ declare const AUTH_ERROR_CODES: {
     readonly AUTH_FAILED: 1001;
     readonly TOKEN_EXPIRED: 1002;
     readonly PERMISSION_DENIED: 1003;
+    readonly INSUFFICIENT_SCOPE: 1004;
+    readonly METHOD_NOT_SUPPORTED: 1005;
+    readonly INVALID_CREDENTIALS: 1006;
 };
 /** Routing error codes */
 declare const ROUTING_ERROR_CODES: {
@@ -1752,6 +1889,9 @@ declare const ERROR_CODES: {
     readonly AUTH_FAILED: 1001;
     readonly TOKEN_EXPIRED: 1002;
     readonly PERMISSION_DENIED: 1003;
+    readonly INSUFFICIENT_SCOPE: 1004;
+    readonly METHOD_NOT_SUPPORTED: 1005;
+    readonly INVALID_CREDENTIALS: 1006;
     readonly PARSE_ERROR: -32700;
     readonly INVALID_REQUEST: -32600;
     readonly METHOD_NOT_FOUND: -32601;
@@ -1776,6 +1916,108 @@ declare function isBroadcastAddress(address: Address): address is BroadcastAddre
 /** Check if an address is a hierarchical address */
 declare function isHierarchicalAddress(address: Address): address is HierarchicalAddress;
 
+/**
+ * Agentic-Mesh Stream Adapter
+ *
+ * Wraps agentic-mesh's TunnelStream as a MAP SDK Stream interface.
+ * This enables MAP clients/agents to communicate over encrypted mesh
+ * networks (Nebula, Tailscale, Headscale).
+ *
+ * @module
+ */
+
+/**
+ * Peer endpoint for mesh connection.
+ * Re-exported from agentic-mesh for convenience.
+ */
+interface MeshPeerEndpoint {
+    /** Peer identifier */
+    peerId: string;
+    /** Transport-specific address (IP, URL, etc.) */
+    address: string;
+    /** Optional port (for TCP-based transports) */
+    port?: number;
+    /** Additional transport-specific metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Transport adapter interface (subset used by this module).
+ * Full interface is defined in agentic-mesh.
+ */
+interface MeshTransportAdapter {
+    /** Whether the transport is currently active */
+    readonly active: boolean;
+    /** Start the transport */
+    start(): Promise<void>;
+    /** Connect to a peer endpoint */
+    connect(endpoint: MeshPeerEndpoint): Promise<boolean>;
+    /** Check if connected to a peer */
+    isConnected(peerId: string): boolean;
+}
+/**
+ * Configuration for agentic-mesh stream.
+ */
+interface AgenticMeshStreamConfig {
+    /**
+     * The agentic-mesh transport adapter (Nebula, Tailscale, etc.).
+     *
+     * Create using agentic-mesh factory functions:
+     * - `createNebulaTransport()` for Nebula networks
+     * - `createTailscaleTransport()` for Tailscale networks
+     */
+    transport: MeshTransportAdapter;
+    /**
+     * Remote peer to connect to.
+     */
+    peer: MeshPeerEndpoint;
+    /**
+     * Local peer ID for identification.
+     * Used to generate unique stream IDs.
+     */
+    localPeerId: string;
+    /**
+     * Connection timeout in milliseconds.
+     * @default 10000
+     */
+    timeout?: number;
+}
+/**
+ * Creates a MAP Stream over an agentic-mesh tunnel.
+ *
+ * This wraps agentic-mesh's TunnelStream (NDJSON over encrypted transport)
+ * and adapts it to the MAP SDK's Stream interface.
+ *
+ * Requires `agentic-mesh` to be installed as a peer dependency.
+ *
+ * @param config - Stream configuration
+ * @returns Promise resolving to a connected MAP Stream
+ * @throws Error if agentic-mesh is not installed
+ * @throws Error if peer connection fails
+ *
+ * @example
+ * ```typescript
+ * import { createNebulaTransport } from 'agentic-mesh';
+ * import { agenticMeshStream, ClientConnection } from '@multi-agent-protocol/sdk';
+ *
+ * // Create Nebula transport
+ * const transport = createNebulaTransport({
+ *   configPath: '/etc/nebula/config.yml',
+ * });
+ *
+ * // Create MAP stream over mesh
+ * const stream = await agenticMeshStream({
+ *   transport,
+ *   peer: { peerId: 'server', address: '10.0.0.1', port: 4242 },
+ *   localPeerId: 'my-client',
+ * });
+ *
+ * // Use with MAP client
+ * const client = new ClientConnection(stream, { name: 'MeshClient' });
+ * await client.connect();
+ * ```
+ */
+declare function agenticMeshStream(config: AgenticMeshStreamConfig): Promise<Stream>;
+
 /**
  * Stream utilities for MAP protocol transport
  *
@@ -2122,157 +2364,1497 @@ declare class BaseConnection {
 }
 
 /**
- * Client connection for MAP protocol
+ * ACP (Agent Client Protocol) types for ACP-over-MAP tunneling.
  *
- * Used by clients to connect to a MAP system, query agents,
- * subscribe to events, and send messages.
+ * These types are bundled directly in the MAP SDK for simplicity,
+ * enabling ACP semantics to be preserved when routing through MAP.
+ *
+ * @see https://agentclientprotocol.com/
+ * @module
  */
-
 /**
- * Options for automatic reconnection
+ * A unique identifier for a conversation session.
  */
-interface ReconnectionOptions {
-    /** Enable automatic reconnection (default: false) */
-    enabled: boolean;
-    /** Maximum number of retry attempts (default: 10) */
-    maxRetries?: number;
-    /** Initial delay in milliseconds (default: 1000) */
-    baseDelayMs?: number;
-    /** Maximum delay in milliseconds (default: 30000) */
-    maxDelayMs?: number;
-    /** Add jitter to delays (default: true) */
-    jitter?: boolean;
-    /** Restore subscriptions after reconnect (default: true) */
-    restoreSubscriptions?: boolean;
-    /** Replay missed events on restore (default: true) */
-    replayOnRestore?: boolean;
-    /** Maximum events to replay per subscription (default: 1000) */
-    maxReplayEventsPerSubscription?: number;
+type ACPSessionId = string;
+/**
+ * JSON-RPC request ID.
+ */
+type ACPRequestId = string | number | null;
+/**
+ * Protocol version identifier.
+ */
+type ACPProtocolVersion = number;
+/**
+ * Unique identifier for a tool call within a session.
+ */
+type ACPToolCallId = string;
+/**
+ * Unique identifier for a permission option.
+ */
+type ACPPermissionOptionId = string;
+/**
+ * Unique identifier for a session mode.
+ */
+type ACPSessionModeId = string;
+/**
+ * ACP JSON-RPC request structure.
+ */
+interface ACPRequest<TParams = unknown> {
+    jsonrpc: "2.0";
+    id: ACPRequestId;
+    method: string;
+    params?: TParams;
 }
 /**
- * Reconnection event types
+ * ACP JSON-RPC notification structure (no response expected).
  */
-type ReconnectionEventType = 'disconnected' | 'reconnecting' | 'reconnected' | 'reconnectFailed' | 'subscriptionRestored' | 'subscriptionRestoreFailed';
+interface ACPNotification<TParams = unknown> {
+    jsonrpc: "2.0";
+    method: string;
+    params?: TParams;
+}
 /**
- * Handler for reconnection events
+ * ACP JSON-RPC success response structure.
  */
-type ReconnectionEventHandler = (event: {
-    type: ReconnectionEventType;
-    attempt?: number;
-    delay?: number;
-    error?: Error;
-    subscriptionId?: SubscriptionId;
-    newSubscriptionId?: SubscriptionId;
-}) => void;
+interface ACPSuccessResponse<TResult = unknown> {
+    jsonrpc: "2.0";
+    id: ACPRequestId;
+    result: TResult;
+}
 /**
- * Options for client connection
+ * ACP JSON-RPC error object.
  */
-interface ClientConnectionOptions extends BaseConnectionOptions {
-    /** Client name for identification */
-    name?: string;
-    /** Client capabilities */
-    capabilities?: ParticipantCapabilities;
-    /** Factory to create new stream for reconnection */
-    createStream?: () => Promise<Stream>;
-    /** Reconnection options */
-    reconnection?: ReconnectionOptions;
+interface ACPErrorObject {
+    code: ACPErrorCode;
+    message: string;
+    data?: unknown;
 }
 /**
- * Options for ClientConnection.connect() static method
+ * ACP JSON-RPC error response structure.
  */
-interface ClientConnectOptions {
-    /** Client name for identification */
-    name?: string;
-    /** Client capabilities to advertise */
-    capabilities?: ParticipantCapabilities;
-    /** Authentication credentials */
-    auth?: {
-        method: 'bearer' | 'api-key' | 'mtls' | 'none';
-        token?: string;
-    };
-    /**
-     * Reconnection configuration.
-     * - `true` = enable with defaults
-     * - `false` or omitted = disabled
-     * - `ReconnectionOptions` = enable with custom settings
-     */
-    reconnection?: boolean | ReconnectionOptions;
-    /** Connection timeout in ms (default: 10000) */
-    connectTimeout?: number;
+interface ACPErrorResponse {
+    jsonrpc: "2.0";
+    id: ACPRequestId;
+    error: ACPErrorObject;
 }
 /**
- * Client connection to a MAP system.
- *
- * Provides methods for:
- * - Querying agents and structure
- * - Subscribing to events
- * - Sending messages to agents
- * - (With permissions) Steering agents
+ * Union of all ACP JSON-RPC response types.
  */
-declare class ClientConnection {
-    #private;
-    constructor(stream: Stream, options?: ClientConnectionOptions);
-    /**
-     * Connect to a MAP server via WebSocket URL.
-     *
-     * Handles:
-     * - WebSocket creation and connection
-     * - Stream wrapping
-     * - Auto-configuration of createStream for reconnection
-     * - Initial MAP protocol connect handshake
-     *
-     * @param url - WebSocket URL (ws:// or wss://)
-     * @param options - Connection options
-     * @returns Connected ClientConnection instance
-     *
-     * @example
-     * ```typescript
-     * const client = await ClientConnection.connect('ws://localhost:8080', {
-     *   name: 'MyClient',
-     *   reconnection: true
-     * });
-     *
-     * // Already connected, ready to use
-     * const agents = await client.listAgents();
-     * ```
-     */
-    static connect(url: string, options?: ClientConnectOptions): Promise<ClientConnection>;
-    /**
-     * Connect to the MAP system
-     */
-    connect(options?: {
-        sessionId?: SessionId;
-        /** Token to resume a previously disconnected session */
-        resumeToken?: string;
-        auth?: {
-            method: 'bearer' | 'api-key' | 'mtls' | 'none';
-            token?: string;
-        };
-    }): Promise<ConnectResponseResult>;
-    /**
-     * Disconnect from the MAP system
-     * @param reason - Optional reason for disconnecting
-     * @returns Resume token that can be used to resume this session later
-     */
-    disconnect(reason?: string): Promise<string | undefined>;
-    /**
-     * Whether the client is connected
-     */
-    get isConnected(): boolean;
-    /**
-     * Current session ID
-     */
-    get sessionId(): SessionId | null;
-    /**
-     * Server capabilities
-     */
-    get serverCapabilities(): ParticipantCapabilities | null;
+type ACPResponse<TResult = unknown> = ACPSuccessResponse<TResult> | ACPErrorResponse;
+/**
+ * Union of all ACP JSON-RPC message types.
+ */
+type ACPMessage = ACPRequest | ACPNotification | ACPSuccessResponse | ACPErrorResponse;
+/**
+ * Predefined ACP error codes following JSON-RPC specification.
+ */
+type ACPErrorCode = -32700 | -32600 | -32601 | -32602 | -32603 | -32800 | -32000 | -32002 | number;
+/**
+ * Standard ACP error codes with semantic names.
+ */
+declare const ACP_ERROR_CODES: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly REQUEST_CANCELLED: -32800;
+    readonly AUTH_REQUIRED: -32000;
+    readonly SESSION_NOT_FOUND: -32002;
+};
+/**
+ * Error class for ACP protocol errors.
+ * Preserves the original ACP error code and data.
+ */
+declare class ACPError extends Error {
+    readonly code: ACPErrorCode;
+    readonly data?: unknown;
+    constructor(code: ACPErrorCode, message: string, data?: unknown);
     /**
-     * AbortSignal that triggers when the connection closes
+     * Create an ACPError from an error response.
      */
-    get signal(): AbortSignal;
+    static fromResponse(error: ACPErrorObject): ACPError;
     /**
-     * Promise that resolves when the connection closes
+     * Convert to JSON-RPC error object.
+     */
+    toErrorObject(): ACPErrorObject;
+}
+/**
+ * The _meta property for ACP extensibility.
+ */
+type ACPMeta = {
+    [key: string]: unknown;
+} | null;
+/**
+ * Metadata about the implementation of a client or agent.
+ */
+interface ACPImplementation {
+    _meta?: ACPMeta;
+    /** Programmatic name of the implementation. */
+    name: string;
+    /** Human-readable title for display. */
+    title?: string | null;
+    /** Version string (e.g., "1.0.0"). */
+    version: string;
+}
+/**
+ * File system capabilities supported by the client.
+ */
+interface ACPFileSystemCapability {
+    _meta?: ACPMeta;
+    /** Whether the client supports fs/read_text_file. */
+    readTextFile?: boolean;
+    /** Whether the client supports fs/write_text_file. */
+    writeTextFile?: boolean;
+}
+/**
+ * Capabilities supported by the client.
+ */
+interface ACPClientCapabilities {
+    _meta?: ACPMeta;
+    /** File system capabilities. */
+    fs?: ACPFileSystemCapability;
+    /** Whether the client supports terminal methods. */
+    terminal?: boolean;
+}
+/**
+ * Prompt capabilities supported by the agent.
+ */
+interface ACPPromptCapabilities {
+    _meta?: ACPMeta;
+    /** Agent supports audio content. */
+    audio?: boolean;
+    /** Agent supports embedded resource context. */
+    embeddedContext?: boolean;
+    /** Agent supports image content. */
+    image?: boolean;
+}
+/**
+ * MCP capabilities supported by the agent.
+ */
+interface ACPMcpCapabilities {
+    _meta?: ACPMeta;
+    /** Agent supports HTTP MCP servers. */
+    http?: boolean;
+    /** Agent supports SSE MCP servers. */
+    sse?: boolean;
+}
+/**
+ * Session capabilities supported by the agent.
+ */
+interface ACPSessionCapabilities {
+    _meta?: ACPMeta;
+    /** Whether the agent supports session/fork. */
+    fork?: {
+        _meta?: ACPMeta;
+    } | null;
+    /** Whether the agent supports session/list. */
+    list?: {
+        _meta?: ACPMeta;
+    } | null;
+    /** Whether the agent supports session/resume. */
+    resume?: {
+        _meta?: ACPMeta;
+    } | null;
+}
+/**
+ * Capabilities supported by the agent.
+ */
+interface ACPAgentCapabilities {
+    _meta?: ACPMeta;
+    /** Whether the agent supports session/load. */
+    loadSession?: boolean;
+    /** MCP capabilities. */
+    mcpCapabilities?: ACPMcpCapabilities;
+    /** Prompt capabilities. */
+    promptCapabilities?: ACPPromptCapabilities;
+    /** Session capabilities. */
+    sessionCapabilities?: ACPSessionCapabilities;
+}
+/**
+ * Describes an available authentication method.
+ */
+interface ACPAuthMethod {
+    _meta?: ACPMeta;
+    /** Unique identifier for this auth method. */
+    id: string;
+    /** Human-readable name. */
+    name: string;
+    /** Optional description. */
+    description?: string | null;
+}
+/**
+ * Request parameters for the initialize method.
+ */
+interface ACPInitializeRequest {
+    _meta?: ACPMeta;
+    /** The latest protocol version supported by the client. */
+    protocolVersion: ACPProtocolVersion;
+    /** Information about the client implementation. */
+    clientInfo?: ACPImplementation | null;
+    /** Capabilities supported by the client. */
+    clientCapabilities?: ACPClientCapabilities;
+}
+/**
+ * Response to the initialize method.
+ */
+interface ACPInitializeResponse {
+    _meta?: ACPMeta;
+    /** The negotiated protocol version. */
+    protocolVersion: ACPProtocolVersion;
+    /** Information about the agent implementation. */
+    agentInfo?: ACPImplementation | null;
+    /** Capabilities supported by the agent. */
+    agentCapabilities?: ACPAgentCapabilities;
+    /** Available authentication methods. */
+    authMethods?: ACPAuthMethod[];
+}
+/**
+ * Request parameters for the authenticate method.
+ */
+interface ACPAuthenticateRequest {
+    _meta?: ACPMeta;
+    /** The ID of the authentication method to use. */
+    methodId: string;
+}
+/**
+ * Response to the authenticate method.
+ */
+interface ACPAuthenticateResponse {
+    _meta?: ACPMeta;
+}
+/**
+ * Environment variable for MCP server configuration.
+ */
+interface ACPEnvVariable {
+    _meta?: ACPMeta;
+    name: string;
+    value: string;
+}
+/**
+ * HTTP header for MCP server configuration.
+ */
+interface ACPHttpHeader {
+    _meta?: ACPMeta;
+    name: string;
+    value: string;
+}
+/**
+ * Stdio transport configuration for MCP.
+ */
+interface ACPMcpServerStdio {
+    _meta?: ACPMeta;
+    name: string;
+    command: string;
+    args: string[];
+    env: ACPEnvVariable[];
+}
+/**
+ * HTTP transport configuration for MCP.
+ */
+interface ACPMcpServerHttp {
+    _meta?: ACPMeta;
+    type: "http";
+    name: string;
+    url: string;
+    headers: ACPHttpHeader[];
+}
+/**
+ * SSE transport configuration for MCP.
+ */
+interface ACPMcpServerSse {
+    _meta?: ACPMeta;
+    type: "sse";
+    name: string;
+    url: string;
+    headers: ACPHttpHeader[];
+}
+/**
+ * MCP server configuration (union of all transport types).
+ */
+type ACPMcpServer = ACPMcpServerStdio | ACPMcpServerHttp | ACPMcpServerSse;
+/**
+ * A mode the agent can operate in.
+ */
+interface ACPSessionMode {
+    _meta?: ACPMeta;
+    id: ACPSessionModeId;
+    name: string;
+    description?: string | null;
+}
+/**
+ * The set of modes and the currently active one.
+ */
+interface ACPSessionModeState {
+    _meta?: ACPMeta;
+    availableModes: ACPSessionMode[];
+    currentModeId: ACPSessionModeId;
+}
+/**
+ * Request parameters for creating a new session.
+ */
+interface ACPNewSessionRequest {
+    _meta?: ACPMeta;
+    /** The working directory for this session. */
+    cwd: string;
+    /** List of MCP servers to connect to. */
+    mcpServers: ACPMcpServer[];
+}
+/**
+ * Response from creating a new session.
+ */
+interface ACPNewSessionResponse {
+    _meta?: ACPMeta;
+    /** Unique identifier for the created session. */
+    sessionId: ACPSessionId;
+    /** Initial mode state if supported. */
+    modes?: ACPSessionModeState | null;
+}
+/**
+ * Request parameters for loading an existing session.
+ */
+interface ACPLoadSessionRequest {
+    _meta?: ACPMeta;
+    /** The ID of the session to load. */
+    sessionId: ACPSessionId;
+    /** The working directory for this session. */
+    cwd: string;
+    /** List of MCP servers to connect to. */
+    mcpServers: ACPMcpServer[];
+}
+/**
+ * Response from loading an existing session.
+ */
+interface ACPLoadSessionResponse {
+    _meta?: ACPMeta;
+    /** Mode state if supported. */
+    modes?: ACPSessionModeState | null;
+}
+/**
+ * Request parameters for setting a session mode.
+ */
+interface ACPSetSessionModeRequest {
+    _meta?: ACPMeta;
+    /** The ID of the session. */
+    sessionId: ACPSessionId;
+    /** The ID of the mode to set. */
+    modeId: ACPSessionModeId;
+}
+/**
+ * Response to session/set_mode method.
+ */
+interface ACPSetSessionModeResponse {
+    _meta?: ACPMeta;
+}
+/**
+ * Optional annotations for content.
+ */
+interface ACPAnnotations {
+    _meta?: ACPMeta;
+    audience?: ACPRole[] | null;
+    lastModified?: string | null;
+    priority?: number | null;
+}
+/**
+ * Role in a conversation.
+ */
+type ACPRole = "assistant" | "user";
+/**
+ * Text content block.
+ */
+interface ACPTextContent {
+    _meta?: ACPMeta;
+    type: "text";
+    text: string;
+    annotations?: ACPAnnotations | null;
+}
+/**
+ * Image content block.
+ */
+interface ACPImageContent {
+    _meta?: ACPMeta;
+    type: "image";
+    data: string;
+    mimeType: string;
+    annotations?: ACPAnnotations | null;
+}
+/**
+ * Audio content block.
+ */
+interface ACPAudioContent {
+    _meta?: ACPMeta;
+    type: "audio";
+    data: string;
+    mimeType: string;
+    annotations?: ACPAnnotations | null;
+}
+/**
+ * Resource link content block.
+ */
+interface ACPResourceLink {
+    _meta?: ACPMeta;
+    type: "resource_link";
+    uri: string;
+    name: string;
+    title?: string | null;
+    description?: string | null;
+    mimeType?: string | null;
+    size?: number | null;
+    annotations?: ACPAnnotations | null;
+}
+/**
+ * Text resource contents.
+ */
+interface ACPTextResourceContents {
+    _meta?: ACPMeta;
+    uri: string;
+    text: string;
+    mimeType?: string | null;
+}
+/**
+ * Binary resource contents.
+ */
+interface ACPBlobResourceContents {
+    _meta?: ACPMeta;
+    uri: string;
+    blob: string;
+    mimeType?: string | null;
+}
+/**
+ * Embedded resource content block.
+ */
+interface ACPEmbeddedResource {
+    _meta?: ACPMeta;
+    type: "resource";
+    resource: ACPTextResourceContents | ACPBlobResourceContents;
+    annotations?: ACPAnnotations | null;
+}
+/**
+ * Union of all content block types.
+ */
+type ACPContentBlock = ACPTextContent | ACPImageContent | ACPAudioContent | ACPResourceLink | ACPEmbeddedResource;
+/**
+ * Request parameters for sending a user prompt.
+ */
+interface ACPPromptRequest {
+    _meta?: ACPMeta;
+    /** The ID of the session. */
+    sessionId: ACPSessionId;
+    /** The content blocks of the user's message. */
+    prompt: ACPContentBlock[];
+}
+/**
+ * Reasons why an agent stops processing.
+ */
+type ACPStopReason = "end_turn" | "max_tokens" | "max_turn_requests" | "refusal" | "cancelled";
+/**
+ * Response from processing a user prompt.
+ */
+interface ACPPromptResponse {
+    _meta?: ACPMeta;
+    /** Why the agent stopped processing. */
+    stopReason: ACPStopReason;
+}
+/**
+ * Notification to cancel ongoing operations for a session.
+ */
+interface ACPCancelNotification {
+    _meta?: ACPMeta;
+    /** The ID of the session to cancel operations for. */
+    sessionId: ACPSessionId;
+}
+/**
+ * Categories of tools.
+ */
+type ACPToolKind = "read" | "edit" | "delete" | "move" | "search" | "execute" | "think" | "fetch" | "switch_mode" | "other";
+/**
+ * Execution status of a tool call.
+ */
+type ACPToolCallStatus = "pending" | "in_progress" | "completed" | "failed";
+/**
+ * A file location being accessed by a tool.
+ */
+interface ACPToolCallLocation {
+    _meta?: ACPMeta;
+    path: string;
+    line?: number | null;
+}
+/**
+ * A diff representing file modifications.
+ */
+interface ACPDiff {
+    _meta?: ACPMeta;
+    path: string;
+    oldText?: string | null;
+    newText: string;
+}
+/**
+ * Terminal reference.
+ */
+interface ACPTerminal {
+    _meta?: ACPMeta;
+    terminalId: string;
+}
+/**
+ * Standard content wrapper.
+ */
+interface ACPContent {
+    _meta?: ACPMeta;
+    content: ACPContentBlock;
+}
+/**
+ * Tool call content types.
+ */
+type ACPToolCallContent = (ACPContent & {
+    type: "content";
+}) | (ACPDiff & {
+    type: "diff";
+}) | (ACPTerminal & {
+    type: "terminal";
+});
+/**
+ * A tool call requested by the language model.
+ */
+interface ACPToolCall {
+    _meta?: ACPMeta;
+    toolCallId: ACPToolCallId;
+    title: string;
+    kind?: ACPToolKind;
+    status?: ACPToolCallStatus;
+    rawInput?: unknown;
+    rawOutput?: unknown;
+    content?: ACPToolCallContent[];
+    locations?: ACPToolCallLocation[];
+}
+/**
+ * An update to an existing tool call.
+ */
+interface ACPToolCallUpdate {
+    _meta?: ACPMeta;
+    toolCallId: ACPToolCallId;
+    title?: string | null;
+    kind?: ACPToolKind | null;
+    status?: ACPToolCallStatus | null;
+    rawInput?: unknown;
+    rawOutput?: unknown;
+    content?: ACPToolCallContent[] | null;
+    locations?: ACPToolCallLocation[] | null;
+}
+/**
+ * Priority levels for plan entries.
+ */
+type ACPPlanEntryPriority = "high" | "medium" | "low";
+/**
+ * Status of a plan entry.
+ */
+type ACPPlanEntryStatus = "pending" | "in_progress" | "completed";
+/**
+ * A single entry in the execution plan.
+ */
+interface ACPPlanEntry {
+    _meta?: ACPMeta;
+    content: string;
+    priority: ACPPlanEntryPriority;
+    status: ACPPlanEntryStatus;
+}
+/**
+ * An execution plan.
+ */
+interface ACPPlan {
+    _meta?: ACPMeta;
+    entries: ACPPlanEntry[];
+}
+/**
+ * A streamed chunk of content.
+ */
+interface ACPContentChunk {
+    _meta?: ACPMeta;
+    content: ACPContentBlock;
+}
+/**
+ * Available command input type.
+ */
+interface ACPUnstructuredCommandInput {
+    _meta?: ACPMeta;
+}
+/**
+ * Available command input.
+ */
+type ACPAvailableCommandInput = ACPUnstructuredCommandInput;
+/**
+ * Information about an available command.
+ */
+interface ACPAvailableCommand {
+    _meta?: ACPMeta;
+    name: string;
+    description: string;
+    input?: ACPAvailableCommandInput | null;
+}
+/**
+ * Available commands update.
+ */
+interface ACPAvailableCommandsUpdate {
+    _meta?: ACPMeta;
+    availableCommands: ACPAvailableCommand[];
+}
+/**
+ * Current mode update.
+ */
+interface ACPCurrentModeUpdate {
+    _meta?: ACPMeta;
+    currentModeId: ACPSessionModeId;
+}
+/**
+ * Session info update.
+ */
+interface ACPSessionInfoUpdate {
+    _meta?: ACPMeta;
+    title?: string | null;
+    updatedAt?: string | null;
+}
+/**
+ * All session update types.
+ */
+type ACPSessionUpdate = (ACPContentChunk & {
+    sessionUpdate: "user_message_chunk";
+}) | (ACPContentChunk & {
+    sessionUpdate: "agent_message_chunk";
+}) | (ACPContentChunk & {
+    sessionUpdate: "agent_thought_chunk";
+}) | (ACPToolCall & {
+    sessionUpdate: "tool_call";
+}) | (ACPToolCallUpdate & {
+    sessionUpdate: "tool_call_update";
+}) | (ACPPlan & {
+    sessionUpdate: "plan";
+}) | (ACPAvailableCommandsUpdate & {
+    sessionUpdate: "available_commands_update";
+}) | (ACPCurrentModeUpdate & {
+    sessionUpdate: "current_mode_update";
+}) | (ACPSessionInfoUpdate & {
+    sessionUpdate: "session_info_update";
+});
+/**
+ * Session notification containing an update.
+ */
+interface ACPSessionNotification {
+    _meta?: ACPMeta;
+    sessionId: ACPSessionId;
+    update: ACPSessionUpdate;
+}
+/**
+ * Permission option kind.
+ */
+type ACPPermissionOptionKind = "allow_once" | "allow_always" | "reject_once" | "reject_always";
+/**
+ * A permission option.
+ */
+interface ACPPermissionOption {
+    _meta?: ACPMeta;
+    optionId: ACPPermissionOptionId;
+    name: string;
+    kind: ACPPermissionOptionKind;
+}
+/**
+ * Request for user permission to execute a tool call.
+ */
+interface ACPRequestPermissionRequest {
+    _meta?: ACPMeta;
+    sessionId: ACPSessionId;
+    toolCall: ACPToolCallUpdate;
+    options: ACPPermissionOption[];
+}
+/**
+ * Permission outcome when user selected an option.
+ */
+interface ACPSelectedPermissionOutcome {
+    _meta?: ACPMeta;
+    outcome: "selected";
+    optionId: ACPPermissionOptionId;
+}
+/**
+ * Permission outcome when cancelled.
+ */
+interface ACPCancelledPermissionOutcome {
+    outcome: "cancelled";
+}
+/**
+ * Permission request outcome.
+ */
+type ACPRequestPermissionOutcome = ACPSelectedPermissionOutcome | ACPCancelledPermissionOutcome;
+/**
+ * Response to a permission request.
+ */
+interface ACPRequestPermissionResponse {
+    _meta?: ACPMeta;
+    outcome: ACPRequestPermissionOutcome;
+}
+/**
+ * Request to read content from a text file.
+ */
+interface ACPReadTextFileRequest {
+    _meta?: ACPMeta;
+    sessionId: ACPSessionId;
+    path: string;
+    line?: number | null;
+    limit?: number | null;
+}
+/**
+ * Response containing file contents.
+ */
+interface ACPReadTextFileResponse {
+    _meta?: ACPMeta;
+    content: string;
+}
+/**
+ * Request to write content to a text file.
+ */
+interface ACPWriteTextFileRequest {
+    _meta?: ACPMeta;
+    sessionId: ACPSessionId;
+    path: string;
+    content: string;
+}
+/**
+ * Response to write text file.
+ */
+interface ACPWriteTextFileResponse {
+    _meta?: ACPMeta;
+}
+/**
+ * Request to create a new terminal.
+ */
+interface ACPCreateTerminalRequest {
+    _meta?: ACPMeta;
+    sessionId: ACPSessionId;
+    command: string;
+    args?: string[];
+    cwd?: string | null;
+    env?: ACPEnvVariable[];
+    outputByteLimit?: number | null;
+}
+/**
+ * Response containing the terminal ID.
+ */
+interface ACPCreateTerminalResponse {
+    _meta?: ACPMeta;
+    terminalId: string;
+}
+/**
+ * Request to get terminal output.
+ */
+interface ACPTerminalOutputRequest {
+    _meta?: ACPMeta;
+    sessionId: ACPSessionId;
+    terminalId: string;
+}
+/**
+ * Terminal exit status.
+ */
+interface ACPTerminalExitStatus {
+    _meta?: ACPMeta;
+    exitCode?: number | null;
+    signal?: string | null;
+}
+/**
+ * Response containing terminal output.
+ */
+interface ACPTerminalOutputResponse {
+    _meta?: ACPMeta;
+    output: string;
+    truncated: boolean;
+    exitStatus?: ACPTerminalExitStatus | null;
+}
+/**
+ * Request to release a terminal.
+ */
+interface ACPReleaseTerminalRequest {
+    _meta?: ACPMeta;
+    sessionId: ACPSessionId;
+    terminalId: string;
+}
+/**
+ * Response to release terminal.
+ */
+interface ACPReleaseTerminalResponse {
+    _meta?: ACPMeta;
+}
+/**
+ * Request to wait for terminal exit.
+ */
+interface ACPWaitForTerminalExitRequest {
+    _meta?: ACPMeta;
+    sessionId: ACPSessionId;
+    terminalId: string;
+}
+/**
+ * Response with terminal exit status.
+ */
+interface ACPWaitForTerminalExitResponse {
+    _meta?: ACPMeta;
+    exitCode?: number | null;
+    signal?: string | null;
+}
+/**
+ * Request to kill a terminal command.
+ */
+interface ACPKillTerminalCommandRequest {
+    _meta?: ACPMeta;
+    sessionId: ACPSessionId;
+    terminalId: string;
+}
+/**
+ * Response to kill terminal command.
+ */
+interface ACPKillTerminalCommandResponse {
+    _meta?: ACPMeta;
+}
+/**
+ * Context for ACP messages tunneled through MAP.
+ */
+interface ACPContext {
+    /** Unique identifier for this virtual ACP stream. */
+    streamId: string;
+    /** ACP session ID (null before session/new is called). */
+    sessionId: ACPSessionId | null;
+    /** Direction of message flow. */
+    direction: "client-to-agent" | "agent-to-client";
+    /** Information about a pending client request (for agent→client requests). */
+    pendingClientRequest?: {
+        requestId: ACPRequestId;
+        method: string;
+        timeout?: number;
+    };
+}
+/**
+ * Envelope wrapping ACP JSON-RPC messages for transport through MAP.
+ *
+ * This is the payload format used when sending ACP messages via MAP's send().
+ */
+interface ACPEnvelope {
+    /**
+     * The original ACP JSON-RPC message.
+     */
+    acp: {
+        jsonrpc: "2.0";
+        id?: ACPRequestId;
+        method?: string;
+        params?: unknown;
+        result?: unknown;
+        error?: ACPErrorObject;
+    };
+    /**
+     * ACP-specific routing context.
+     */
+    acpContext: ACPContext;
+}
+/**
+ * Handlers that the client provides for agent→client requests.
+ */
+interface ACPClientHandlers {
+    /**
+     * Handle permission request from agent.
+     */
+    requestPermission(params: ACPRequestPermissionRequest): Promise<ACPRequestPermissionResponse>;
+    /**
+     * Handle session update notification from agent.
+     */
+    sessionUpdate(params: ACPSessionNotification): Promise<void>;
+    /**
+     * Handle read text file request (optional, based on capabilities).
+     */
+    readTextFile?(params: ACPReadTextFileRequest): Promise<ACPReadTextFileResponse>;
+    /**
+     * Handle write text file request (optional, based on capabilities).
+     */
+    writeTextFile?(params: ACPWriteTextFileRequest): Promise<ACPWriteTextFileResponse>;
+    /**
+     * Handle create terminal request (optional, based on capabilities).
+     */
+    createTerminal?(params: ACPCreateTerminalRequest): Promise<ACPCreateTerminalResponse>;
+    /**
+     * Handle terminal output request (optional, based on capabilities).
+     */
+    terminalOutput?(params: ACPTerminalOutputRequest): Promise<ACPTerminalOutputResponse>;
+    /**
+     * Handle release terminal request (optional, based on capabilities).
+     */
+    releaseTerminal?(params: ACPReleaseTerminalRequest): Promise<ACPReleaseTerminalResponse>;
+    /**
+     * Handle wait for terminal exit request (optional, based on capabilities).
+     */
+    waitForTerminalExit?(params: ACPWaitForTerminalExitRequest): Promise<ACPWaitForTerminalExitResponse>;
+    /**
+     * Handle kill terminal command request (optional, based on capabilities).
+     */
+    killTerminal?(params: ACPKillTerminalCommandRequest): Promise<ACPKillTerminalCommandResponse>;
+}
+/**
+ * Context passed to agent handlers.
+ */
+interface ACPAgentContext {
+    /** The stream ID for this ACP session. */
+    streamId: string;
+    /** Current ACP session ID (null before newSession). */
+    sessionId: ACPSessionId | null;
+    /** The MAP participant ID of the client. */
+    clientParticipantId: string;
+}
+/**
+ * Handler interface for agents that support ACP.
+ */
+interface ACPAgentHandler {
+    /**
+     * Handle initialize request.
+     */
+    initialize(params: ACPInitializeRequest, ctx: ACPAgentContext): Promise<ACPInitializeResponse>;
+    /**
+     * Handle authenticate request (optional).
+     */
+    authenticate?(params: ACPAuthenticateRequest, ctx: ACPAgentContext): Promise<ACPAuthenticateResponse>;
+    /**
+     * Handle new session request.
+     */
+    newSession(params: ACPNewSessionRequest, ctx: ACPAgentContext): Promise<ACPNewSessionResponse>;
+    /**
+     * Handle load session request (optional).
+     */
+    loadSession?(params: ACPLoadSessionRequest, ctx: ACPAgentContext): Promise<ACPLoadSessionResponse>;
+    /**
+     * Handle set session mode request (optional).
+     */
+    setSessionMode?(params: ACPSetSessionModeRequest, ctx: ACPAgentContext): Promise<ACPSetSessionModeResponse>;
+    /**
+     * Handle prompt request.
+     */
+    prompt(params: ACPPromptRequest, ctx: ACPAgentContext): Promise<ACPPromptResponse>;
+    /**
+     * Handle cancel notification.
+     */
+    cancel(params: ACPCancelNotification, ctx: ACPAgentContext): Promise<void>;
+}
+/**
+ * Current stable ACP protocol version.
+ */
+declare const ACP_PROTOCOL_VERSION = 20241007;
+/**
+ * ACP method names.
+ */
+declare const ACP_METHODS: {
+    readonly INITIALIZE: "initialize";
+    readonly AUTHENTICATE: "authenticate";
+    readonly SESSION_NEW: "session/new";
+    readonly SESSION_LOAD: "session/load";
+    readonly SESSION_SET_MODE: "session/set_mode";
+    readonly SESSION_PROMPT: "session/prompt";
+    readonly SESSION_CANCEL: "session/cancel";
+    readonly SESSION_UPDATE: "session/update";
+    readonly REQUEST_PERMISSION: "request_permission";
+    readonly FS_READ_TEXT_FILE: "fs/read_text_file";
+    readonly FS_WRITE_TEXT_FILE: "fs/write_text_file";
+    readonly TERMINAL_CREATE: "terminal/create";
+    readonly TERMINAL_OUTPUT: "terminal/output";
+    readonly TERMINAL_RELEASE: "terminal/release";
+    readonly TERMINAL_WAIT_FOR_EXIT: "terminal/wait_for_exit";
+    readonly TERMINAL_KILL: "terminal/kill";
+};
+/**
+ * Check if a message is an ACP request.
+ */
+declare function isACPRequest(msg: ACPMessage): msg is ACPRequest;
+/**
+ * Check if a message is an ACP notification.
+ */
+declare function isACPNotification(msg: ACPMessage): msg is ACPNotification;
+/**
+ * Check if a message is an ACP response.
+ */
+declare function isACPResponse(msg: ACPMessage): msg is ACPResponse;
+/**
+ * Check if a response is an error response.
+ */
+declare function isACPErrorResponse(response: ACPResponse): response is ACPErrorResponse;
+/**
+ * Check if a response is a success response.
+ */
+declare function isACPSuccessResponse<T>(response: ACPResponse<T>): response is ACPSuccessResponse<T>;
+/**
+ * Check if a payload is an ACP envelope.
+ */
+declare function isACPEnvelope(payload: unknown): payload is ACPEnvelope;
+
+/**
+ * ACPStreamConnection - Client-side virtual ACP connection over MAP.
+ *
+ * Provides a familiar ACP interface while using MAP's send/subscribe
+ * primitives for transport. Supports request/response correlation,
+ * timeout handling, and session lifecycle management.
+ *
+ * @module
+ */
+
+/**
+ * Options for creating an ACP stream connection.
+ */
+interface ACPStreamOptions {
+    /** Target agent that will handle ACP requests */
+    targetAgent: AgentId;
+    /** Client-side handlers for agent→client requests */
+    client: ACPClientHandlers;
+    /** Optional: expose MAP events alongside ACP (for observability) */
+    exposeMapEvents?: boolean;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/**
+ * Events emitted by ACPStreamConnection.
+ */
+interface ACPStreamEvents {
+    /** Emitted when ACP session is lost after reconnection */
+    sessionLost: (info: {
+        sessionId: ACPSessionId;
+        reason: string;
+    }) => void;
+    /** Emitted when the stream successfully reconnects */
+    reconnected: () => void;
+    /** Emitted when reconnection is in progress */
+    reconnecting: () => void;
+    /** Emitted when the stream is closed */
+    close: () => void;
+    /** Emitted on errors */
+    error: (error: Error) => void;
+}
+/**
+ * Virtual ACP connection over MAP.
+ *
+ * Provides the full ACP client interface, routing all requests through
+ * the underlying MAP connection to a target agent.
+ *
+ * @example
+ * ```typescript
+ * const acp = new ACPStreamConnection(mapClient, {
+ *   targetAgent: 'coding-agent-1',
+ *   client: {
+ *     requestPermission: async (req) => ({ outcome: { outcome: 'selected', optionId: 'allow' } }),
+ *     sessionUpdate: async (update) => { console.log(update); },
+ *   }
+ * });
+ *
+ * await acp.initialize({ protocolVersion: 20241007, clientInfo: { name: 'IDE', version: '1.0' } });
+ * const { sessionId } = await acp.newSession({ cwd: '/project', mcpServers: [] });
+ * const result = await acp.prompt({ sessionId, prompt: [{ type: 'text', text: 'Hello' }] });
+ * ```
+ */
+declare class ACPStreamConnection extends EventEmitter {
+    #private;
+    /**
+     * Create a new ACP stream connection.
+     *
+     * @param mapClient - The underlying MAP client connection
+     * @param options - Stream configuration options
+     */
+    constructor(mapClient: ClientConnection, options: ACPStreamOptions);
+    /** Unique identifier for this ACP stream */
+    get streamId(): string;
+    /** Target agent this stream connects to */
+    get targetAgent(): AgentId;
+    /** Current ACP session ID (null until newSession called) */
+    get sessionId(): ACPSessionId | null;
+    /** Whether initialize() has been called */
+    get initialized(): boolean;
+    /** Agent capabilities from initialize response */
+    get capabilities(): ACPAgentCapabilities | null;
+    /** Whether the stream is closed */
+    get isClosed(): boolean;
+    /** Last processed event ID (for reconnection support) */
+    get lastEventId(): string | null;
+    /** Whether the stream is currently reconnecting */
+    get isReconnecting(): boolean;
+    /**
+     * Initialize the ACP connection with the target agent.
+     */
+    initialize(params: ACPInitializeRequest): Promise<ACPInitializeResponse>;
+    /**
+     * Authenticate with the agent.
+     */
+    authenticate(params: ACPAuthenticateRequest): Promise<ACPAuthenticateResponse>;
+    /**
+     * Create a new ACP session.
+     */
+    newSession(params: ACPNewSessionRequest): Promise<ACPNewSessionResponse>;
+    /**
+     * Load an existing ACP session.
+     */
+    loadSession(params: ACPLoadSessionRequest): Promise<ACPLoadSessionResponse>;
+    /**
+     * Set the session mode.
+     */
+    setSessionMode(params: ACPSetSessionModeRequest): Promise<ACPSetSessionModeResponse>;
+    /**
+     * Send a prompt to the agent.
+     * Updates are received via the sessionUpdate handler.
+     */
+    prompt(params: ACPPromptRequest): Promise<ACPPromptResponse>;
+    /**
+     * Cancel ongoing operations for the current session.
+     */
+    cancel(params?: Partial<ACPCancelNotification>): Promise<void>;
+    /**
+     * Call an ACP extension method on the target agent.
+     *
+     * Extension methods are prefixed with "_" (e.g., "_macro/spawnAgent").
+     * The agent must support the extension for this to succeed.
+     *
+     * @param method - The extension method name (e.g., "_macro/spawnAgent")
+     * @param params - Parameters to pass to the extension method
+     * @returns The result from the extension method
+     *
+     * @example
+     * ```typescript
+     * const result = await acp.callExtension("_macro/spawnAgent", {
+     *   task: "Implement feature X",
+     *   cwd: "/project"
+     * });
+     * ```
+     */
+    callExtension<TParams = unknown, TResult = unknown>(method: string, params?: TParams): Promise<TResult>;
+    /**
+     * Close this ACP stream and clean up resources.
+     */
+    close(): Promise<void>;
+}
+/**
+ * Create an ACP stream connection from a MAP client.
+ *
+ * @param mapClient - The underlying MAP client connection
+ * @param options - Stream configuration options
+ * @returns A new ACPStreamConnection instance
+ */
+declare function createACPStream(mapClient: ClientConnection, options: ACPStreamOptions): ACPStreamConnection;
+
+/**
+ * Client connection for MAP protocol
+ *
+ * Used by clients to connect to a MAP system, query agents,
+ * subscribe to events, and send messages.
+ */
+
+/**
+ * Options for automatic reconnection
+ */
+interface ReconnectionOptions {
+    /** Enable automatic reconnection (default: false) */
+    enabled: boolean;
+    /** Maximum number of retry attempts (default: 10) */
+    maxRetries?: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    baseDelayMs?: number;
+    /** Maximum delay in milliseconds (default: 30000) */
+    maxDelayMs?: number;
+    /** Add jitter to delays (default: true) */
+    jitter?: boolean;
+    /** Restore subscriptions after reconnect (default: true) */
+    restoreSubscriptions?: boolean;
+    /** Replay missed events on restore (default: true) */
+    replayOnRestore?: boolean;
+    /** Maximum events to replay per subscription (default: 1000) */
+    maxReplayEventsPerSubscription?: number;
+}
+/**
+ * Reconnection event types
+ */
+type ReconnectionEventType = 'disconnected' | 'reconnecting' | 'reconnected' | 'reconnectFailed' | 'subscriptionRestored' | 'subscriptionRestoreFailed';
+/**
+ * Handler for reconnection events
+ */
+type ReconnectionEventHandler = (event: {
+    type: ReconnectionEventType;
+    attempt?: number;
+    delay?: number;
+    error?: Error;
+    subscriptionId?: SubscriptionId;
+    newSubscriptionId?: SubscriptionId;
+}) => void;
+/**
+ * Options for client connection
+ */
+interface ClientConnectionOptions extends BaseConnectionOptions {
+    /** Client name for identification */
+    name?: string;
+    /** Client capabilities */
+    capabilities?: ParticipantCapabilities;
+    /** Factory to create new stream for reconnection */
+    createStream?: () => Promise<Stream>;
+    /** Reconnection options */
+    reconnection?: ReconnectionOptions;
+}
+/**
+ * Options for ClientConnection.connect() static method
+ */
+interface ClientConnectOptions {
+    /** Client name for identification */
+    name?: string;
+    /** Client capabilities to advertise */
+    capabilities?: ParticipantCapabilities;
+    /** Authentication credentials */
+    auth?: {
+        method: 'bearer' | 'api-key' | 'mtls' | 'none';
+        token?: string;
+    };
+    /**
+     * Reconnection configuration.
+     * - `true` = enable with defaults
+     * - `false` or omitted = disabled
+     * - `ReconnectionOptions` = enable with custom settings
+     */
+    reconnection?: boolean | ReconnectionOptions;
+    /** Connection timeout in ms (default: 10000) */
+    connectTimeout?: number;
+}
+/**
+ * Options for ClientConnection.connectMesh() static method
+ */
+interface MeshConnectOptions {
+    /** The agentic-mesh transport adapter (Nebula, Tailscale, etc.) */
+    transport: MeshTransportAdapter;
+    /** Remote peer to connect to */
+    peer: MeshPeerEndpoint;
+    /** Local peer ID for identification */
+    localPeerId: string;
+    /** Client name for identification */
+    name?: string;
+    /** Client capabilities to advertise */
+    capabilities?: ParticipantCapabilities;
+    /** Authentication credentials */
+    auth?: {
+        method: 'bearer' | 'api-key' | 'mtls' | 'none';
+        token?: string;
+    };
+    /**
+     * Reconnection configuration.
+     * - `true` = enable with defaults
+     * - `false` or omitted = disabled
+     * - `ReconnectionOptions` = enable with custom settings
+     */
+    reconnection?: boolean | ReconnectionOptions;
+    /** Connection timeout in ms (default: 10000) */
+    timeout?: number;
+}
+/**
+ * Client connection to a MAP system.
+ *
+ * Provides methods for:
+ * - Querying agents and structure
+ * - Subscribing to events
+ * - Sending messages to agents
+ * - (With permissions) Steering agents
+ *
+ * ## Response Shape Patterns
+ *
+ * Methods follow consistent response shape conventions:
+ *
+ * **Create Operations** return the full entity that was created:
+ * - `registerAgent()` → `{ agent: Agent }`
+ * - `createScope()` → `{ scope: Scope }`
+ * - `subscribe()` → `Subscription` (full subscription object)
+ *
+ * **Query Operations** return the requested data:
+ * - `listAgents()` → `{ agents: Agent[] }`
+ * - `getAgent()` → `{ agent: Agent, children?: Agent[] }`
+ * - `getScope()` → `Scope`
+ * - `listScopes()` → `{ scopes: Scope[] }`
+ *
+ * **Action Operations** return confirmation with reference ID:
+ * - `send()` → `{ messageId: string }`
+ * - `inject()` → `{ accepted: boolean }`
+ *
+ * **Lifecycle Operations** return status:
+ * - `connect()` → `ConnectResponseResult` (session info, capabilities, auth status)
+ * - `disconnect()` → `string | undefined` (resume token)
+ * - `authenticate()` → `{ success: boolean, principal?: AuthPrincipal }`
+ */
+declare class ClientConnection {
+    #private;
+    constructor(stream: Stream, options?: ClientConnectionOptions);
+    /**
+     * Connect to a MAP server via WebSocket URL.
+     *
+     * Handles:
+     * - WebSocket creation and connection
+     * - Stream wrapping
+     * - Auto-configuration of createStream for reconnection
+     * - Initial MAP protocol connect handshake
+     *
+     * @param url - WebSocket URL (ws:// or wss://)
+     * @param options - Connection options
+     * @returns Connected ClientConnection instance
+     *
+     * @example
+     * ```typescript
+     * const client = await ClientConnection.connect('ws://localhost:8080', {
+     *   name: 'MyClient',
+     *   reconnection: true
+     * });
+     *
+     * // Already connected, ready to use
+     * const agents = await client.listAgents();
+     * ```
+     */
+    static connect(url: string, options?: ClientConnectOptions): Promise<ClientConnection>;
+    /**
+     * Connect to a MAP server via agentic-mesh transport.
+     *
+     * Handles:
+     * - Dynamic import of agentic-mesh (optional peer dependency)
+     * - Stream creation over encrypted mesh tunnel
+     * - Auto-configuration of createStream for reconnection
+     * - Initial MAP protocol connect handshake
+     *
+     * Requires `agentic-mesh` to be installed as a peer dependency.
+     *
+     * @param options - Mesh connection options
+     * @returns Connected ClientConnection instance
+     *
+     * @example
+     * ```typescript
+     * import { createNebulaTransport } from 'agentic-mesh';
+     *
+     * const transport = createNebulaTransport({
+     *   configPath: '/etc/nebula/config.yml',
+     * });
+     *
+     * const client = await ClientConnection.connectMesh({
+     *   transport,
+     *   peer: { peerId: 'server', address: '10.0.0.1', port: 4242 },
+     *   localPeerId: 'my-client',
+     *   name: 'MeshClient',
+     *   reconnection: true
+     * });
+     *
+     * const agents = await client.listAgents();
+     * ```
+     */
+    static connectMesh(options: MeshConnectOptions): Promise<ClientConnection>;
+    /**
+     * Connect to the MAP system
+     *
+     * @param options - Connection options
+     * @param options.sessionId - Specific session ID to use
+     * @param options.resumeToken - Token to resume a previously disconnected session
+     * @param options.auth - Authentication credentials
+     * @param options.onTokenExpiring - Callback invoked before token expires for proactive refresh
+     */
+    connect(options?: {
+        sessionId?: SessionId;
+        /** Token to resume a previously disconnected session */
+        resumeToken?: string;
+        /** Authentication credentials */
+        auth?: {
+            method: 'bearer' | 'api-key' | 'mtls' | 'none';
+            credential?: string;
+        };
+        /** Callback invoked when token is about to expire. Return new credentials to refresh. */
+        onTokenExpiring?: (expiresAt: number) => Promise<{
+            method: string;
+            credential: string;
+        } | void>;
+    }): Promise<ConnectResponseResult>;
+    /**
+     * Get the resume token for this session.
+     * Can be used to reconnect and restore session state after disconnection.
+     *
+     * @returns The resume token, or undefined if not available
+     */
+    getResumeToken(): string | undefined;
+    /**
+     * Reconnect to the server, optionally using a resume token to restore session.
+     *
+     * @param resumeToken - Token to resume previous session. If not provided, uses the last known token.
+     * @returns Connect response result
+     *
+     * @example
+     * ```typescript
+     * // Save token before disconnect
+     * const token = await client.disconnect();
+     *
+     * // Later, reconnect with the token
+     * const result = await client.reconnect(token);
+     * console.log('Reconnected:', result.reconnected);
+     * ```
+     */
+    reconnect(resumeToken?: string): Promise<ConnectResponseResult>;
+    /**
+     * Authenticate with the server after connection.
+     *
+     * Use this when the server returns `authRequired` in the connect response,
+     * indicating that authentication is needed before accessing protected resources.
+     *
+     * @param auth - Authentication credentials
+     * @returns Authentication result with principal if successful
+     *
+     * @example
+     * ```typescript
+     * const connectResult = await client.connect();
+     *
+     * if (connectResult.authRequired) {
+     *   const authResult = await client.authenticate({
+     *     method: 'api-key',
+     *     credential: process.env.API_KEY,
+     *   });
+     *
+     *   if (authResult.success) {
+     *     console.log('Authenticated as:', authResult.principal?.id);
+     *   }
+     * }
+     * ```
+     */
+    authenticate(auth: {
+        method: 'bearer' | 'api-key' | 'mtls' | 'none';
+        credential?: string;
+    }): Promise<AuthenticateResponseResult>;
+    /**
+     * Refresh authentication credentials.
+     *
+     * Use this to update credentials before they expire for long-lived connections.
+     *
+     * @param auth - New authentication credentials
+     * @returns Updated principal information
+     */
+    refreshAuth(auth: {
+        method: "bearer" | "api-key" | "mtls" | "none";
+        credential?: string;
+    }): Promise<{
+        success: boolean;
+        principal?: AuthPrincipal;
+        error?: {
+            code: string;
+            message: string;
+        };
+    }>;
+    /**
+     * Disconnect from the MAP system
+     * @param reason - Optional reason for disconnecting
+     * @returns Resume token that can be used to resume this session later
+     */
+    disconnect(reason?: string): Promise<string | undefined>;
+    /**
+     * Whether the client is connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Current session ID
+     */
+    get sessionId(): SessionId | null;
+    /**
+     * Server capabilities
+     */
+    get serverCapabilities(): ParticipantCapabilities | null;
+    /**
+     * AbortSignal that triggers when the connection closes
+     */
+    get signal(): AbortSignal;
+    /**
+     * Promise that resolves when the connection closes
      */
     get closed(): Promise<void>;
     /**
@@ -2346,6 +3928,51 @@ declare class ClientConnection {
         timeout?: number;
         meta?: MessageMeta;
     }): Promise<Message<T>>;
+    /**
+     * Create a virtual ACP stream connection to an agent.
+     *
+     * This allows clients to interact with ACP-compatible agents using the
+     * familiar ACP interface while routing all messages through MAP.
+     *
+     * @param options - Stream configuration options
+     * @returns ACPStreamConnection instance ready for initialize()
+     *
+     * @example
+     * ```typescript
+     * const acp = client.createACPStream({
+     *   targetAgent: 'coding-agent-1',
+     *   client: {
+     *     requestPermission: async (req) => ({
+     *       outcome: { outcome: 'selected', optionId: 'allow' }
+     *     }),
+     *     sessionUpdate: async (update) => {
+     *       console.log('Agent update:', update);
+     *     }
+     *   }
+     * });
+     *
+     * await acp.initialize({
+     *   protocolVersion: 20241007,
+     *   clientInfo: { name: 'IDE', version: '1.0' }
+     * });
+     * const { sessionId } = await acp.newSession({ cwd: '/project', mcpServers: [] });
+     * const result = await acp.prompt({
+     *   sessionId,
+     *   prompt: [{ type: 'text', text: 'Hello' }]
+     * });
+     *
+     * await acp.close();
+     * ```
+     */
+    createACPStream(options: Omit<ACPStreamOptions, 'mapClient'>): ACPStreamConnection;
+    /**
+     * Get an active ACP stream by ID.
+     */
+    getACPStream(streamId: string): ACPStreamConnection | undefined;
+    /**
+     * Get all active ACP streams.
+     */
+    get acpStreams(): ReadonlyMap<string, ACPStreamConnection>;
     /**
      * Subscribe to events
      */
@@ -2563,6 +4190,45 @@ interface AgentConnectOptions {
     /** Connection timeout in ms (default: 10000) */
     connectTimeout?: number;
 }
+/**
+ * Options for AgentConnection.connectMesh() static method
+ */
+interface AgentMeshConnectOptions {
+    /** The agentic-mesh transport adapter (Nebula, Tailscale, etc.) */
+    transport: MeshTransportAdapter;
+    /** Remote peer to connect to */
+    peer: MeshPeerEndpoint;
+    /** Local peer ID for identification */
+    localPeerId: string;
+    /** Agent name */
+    name?: string;
+    /** Agent role */
+    role?: string;
+    /** Agent capabilities to advertise */
+    capabilities?: ParticipantCapabilities;
+    /** Agent visibility settings */
+    visibility?: AgentVisibility;
+    /** Parent agent ID (for child agents) */
+    parent?: AgentId;
+    /** Initial scopes to join */
+    scopes?: ScopeId[];
+    /** Initial metadata */
+    metadata?: Record<string, unknown>;
+    /** Authentication credentials */
+    auth?: {
+        method: 'bearer' | 'api-key' | 'mtls' | 'none';
+        token?: string;
+    };
+    /**
+     * Reconnection configuration.
+     * - `true` = enable with defaults
+     * - `false` or omitted = disabled
+     * - `AgentReconnectionOptions` = enable with custom settings
+     */
+    reconnection?: boolean | AgentReconnectionOptions;
+    /** Connection timeout in ms (default: 10000) */
+    timeout?: number;
+}
 /**
  * Agent connection to a MAP system.
  *
@@ -2605,6 +4271,43 @@ declare class AgentConnection {
      * ```
      */
     static connect(url: string, options?: AgentConnectOptions): Promise<AgentConnection>;
+    /**
+     * Connect and register an agent via agentic-mesh transport.
+     *
+     * Handles:
+     * - Dynamic import of agentic-mesh (optional peer dependency)
+     * - Stream creation over encrypted mesh tunnel
+     * - Auto-configuration of createStream for reconnection
+     * - Initial MAP protocol connect handshake
+     * - Agent registration
+     *
+     * Requires `agentic-mesh` to be installed as a peer dependency.
+     *
+     * @param options - Mesh connection and agent options
+     * @returns Connected and registered AgentConnection instance
+     *
+     * @example
+     * ```typescript
+     * import { createNebulaTransport } from 'agentic-mesh';
+     *
+     * const transport = createNebulaTransport({
+     *   configPath: '/etc/nebula/config.yml',
+     * });
+     *
+     * const agent = await AgentConnection.connectMesh({
+     *   transport,
+     *   peer: { peerId: 'server', address: '10.0.0.1', port: 4242 },
+     *   localPeerId: 'my-agent',
+     *   name: 'MeshWorker',
+     *   role: 'processor',
+     *   reconnection: true
+     * });
+     *
+     * agent.onMessage(handleMessage);
+     * await agent.busy();
+     * ```
+     */
+    static connectMesh(options: AgentMeshConnectOptions): Promise<AgentConnection>;
     /**
      * Connect and register with the MAP system
      */
@@ -2620,6 +4323,59 @@ declare class AgentConnection {
         connection: ConnectResponseResult;
         agent: Agent;
     }>;
+    /**
+     * Authenticate with the server after connection.
+     *
+     * Use this when the server returns `authRequired` in the connect response,
+     * indicating that authentication is needed before registering or accessing
+     * protected resources.
+     *
+     * @param auth - Authentication credentials
+     * @returns Authentication result with principal if successful
+     *
+     * @example
+     * ```typescript
+     * const agent = new AgentConnection(stream, { name: 'MyAgent' });
+     *
+     * // First connect to get auth requirements
+     * const connectResult = await agent.connectOnly();
+     *
+     * if (connectResult.authRequired) {
+     *   const authResult = await agent.authenticate({
+     *     method: 'api-key',
+     *     token: process.env.AGENT_API_KEY,
+     *   });
+     *
+     *   if (authResult.success) {
+     *     // Now register the agent
+     *     await agent.register({ name: 'MyAgent', role: 'worker' });
+     *   }
+     * }
+     * ```
+     */
+    authenticate(auth: {
+        method: 'bearer' | 'api-key' | 'mtls' | 'none';
+        token?: string;
+    }): Promise<AuthenticateResponseResult>;
+    /**
+     * Refresh authentication credentials.
+     *
+     * Use this to update credentials before they expire for long-lived connections.
+     *
+     * @param auth - New authentication credentials
+     * @returns Updated principal information
+     */
+    refreshAuth(auth: {
+        method: "bearer" | "api-key" | "mtls" | "none";
+        token?: string;
+    }): Promise<{
+        success: boolean;
+        principal?: AuthPrincipal;
+        error?: {
+            code: string;
+            message: string;
+        };
+    }>;
     /**
      * Disconnect from the MAP system
      * @param reason - Optional reason for disconnecting
@@ -3177,4 +4933,4 @@ declare function canAgentMessageAgent(senderAgent: Agent, targetAgentId: AgentId
     sharedScopes?: ScopeId[];
 }, config?: AgentPermissionConfig): boolean;
 
-export { type AgentLifecycle as $, type AgentId as A, type BaseConnectionOptions as B, type ConnectResponseResult as C, type DisconnectResponseResult as D, type ErrorCategory as E, type FederationBufferConfig as F, type ScopesJoinResponseResult as G, type ScopesLeaveResponseResult as H, type ScopesListResponseResult as I, type MessageId as J, type SendResponseResult as K, type SubscriptionId as L, type MAPError as M, type SubscribeResponseResult as N, AGENT_ERROR_CODES as O, type ParticipantCapabilities as P, AUTH_ERROR_CODES as Q, type RequestId as R, type Stream as S, AUTH_METHODS as T, type UnsubscribeResponseResult as U, type AcceptanceContext as V, type AgentAcceptanceRule as W, type AgentConnectOptions as X, AgentConnection as Y, type AgentConnectionOptions as Z, type AgentIncludeOptions as _, type MAPErrorData as a, FEDERATION_METHODS as a$, type AgentMessagingRule as a0, type AgentPermissionConfig as a1, type AgentPermissions as a2, type AgentReconnectionEventHandler as a3, type AgentReconnectionEventType as a4, type AgentReconnectionOptions as a5, type AgentRelationship as a6, type AgentRelationshipType as a7, type AgentState as a8, type AgentVisibility as a9, type AuthRefreshRequest as aA, type AuthRefreshRequestParams as aB, type AuthRefreshResponseResult as aC, BaseConnection as aD, type BroadcastAddress as aE, CAPABILITY_REQUIREMENTS as aF, CORE_METHODS as aG, type ClientAcceptanceRule as aH, type ClientConnectOptions as aI, ClientConnection as aJ, type ClientConnectionOptions as aK, type ConnectRequest as aL, type ConnectRequestParams as aM, type CorrelationId as aN, DEFAULT_AGENT_PERMISSION_CONFIG as aO, type DeliverySemantics as aP, type DirectAddress as aQ, type DisconnectPolicy as aR, type DisconnectRequest as aS, type DisconnectRequestParams as aT, ERROR_CODES as aU, EVENT_TYPES as aV, EXTENSION_METHODS as aW, type EventInput as aX, type EventNotification as aY, type EventNotificationParams as aZ, FEDERATION_ERROR_CODES as a_, type AgentVisibilityRule as aa, type AgentsGetRequest as ab, type AgentsGetRequestParams as ac, type AgentsListFilter as ad, type AgentsListRequest as ae, type AgentsListRequestParams as af, type AgentsRegisterRequest as ag, type AgentsRegisterRequestParams as ah, type AgentsResumeRequest as ai, type AgentsResumeRequestParams as aj, type AgentsResumeResponseResult as ak, type AgentsSpawnRequest as al, type AgentsSpawnRequestParams as am, type AgentsStopRequest as an, type AgentsStopRequestParams as ao, type AgentsStopResponseResult as ap, type AgentsSuspendRequest as aq, type AgentsSuspendRequestParams as ar, type AgentsSuspendResponseResult as as, type AgentsUnregisterRequest as at, type AgentsUnregisterRequestParams as au, type AgentsUpdateRequest as av, type AgentsUpdateRequestParams as aw, type AnyMessage as ax, type AuthMethod as ay, type AuthParams as az, type FederationEnvelope as b, ROUTING_ERROR_CODES as b$, type FederatedAddress as b0, type FederationAuth as b1, type FederationConnectRequest as b2, type FederationConnectRequestParams as b3, type FederationMetadata as b4, type FederationReplayConfig as b5, type FederationRouteRequest as b6, type FederationRouteRequestParams as b7, type GatewayReconnectionEvent as b8, type GatewayReconnectionEventHandler as b9, type MessagePriority as bA, type MessageRelationship as bB, type MessageSentEventData as bC, type MessageVisibility as bD, type Meta as bE, type MultiAddress as bF, NOTIFICATION_METHODS as bG, type NotificationHandler as bH, OBSERVATION_METHODS as bI, type OverflowHandler as bJ, type OverflowInfo as bK, PERMISSION_METHODS as bL, PROTOCOL_ERROR_CODES as bM, PROTOCOL_VERSION as bN, type Participant as bO, type ParticipantAddress as bP, type PermissionAction as bQ, type PermissionContext as bR, type PermissionParticipant as bS, type PermissionResult as bT, type PermissionSystemConfig as bU, type PermissionsAgentUpdatedEventData as bV, type PermissionsClientUpdatedEventData as bW, type PermissionsUpdateRequest as bX, type PermissionsUpdateRequestParams as bY, type PermissionsUpdateResponseResult as bZ, RESOURCE_ERROR_CODES as b_, type GatewayReconnectionEventType as ba, type GatewayReconnectionOptions as bb, type GraphEdge as bc, type HierarchicalAddress as bd, type InjectDelivery as be, type InjectDeliveryResult as bf, type InjectRequest as bg, type InjectRequestParams as bh, type InjectResponseResult as bi, JSONRPC_VERSION as bj, type JoinPolicy as bk, LIFECYCLE_METHODS as bl, type MAPNotification as bm, type MAPNotificationBase as bn, type MAPRequest as bo, type MAPRequestBase as bp, type MAPResponse as bq, type MAPResponseError as br, type MAPResponseSuccess as bs, MAP_METHODS as bt, type MessageDeliveredEventData as bu, type MessageFailedEventData as bv, type MessageHandler as bw, type MessageMeta as bx, type MessageNotification as by, type MessageNotificationParams as bz, type Message as c, type TransportType as c$, type ReconnectionEventHandler as c0, type ReconnectionEventType as c1, type ReconnectionOptions as c2, type ReplayRequest as c3, type ReplayRequestParams as c4, type ReplayResponseResult as c5, type ReplayedEvent as c6, type RequestHandler as c7, type RoleAddress as c8, SCOPE_METHODS as c9, type SendRequest as cA, type SendRequestParams as cB, type SessionCloseRequest as cC, type SessionCloseRequestParams as cD, type SessionCloseResponseResult as cE, type SessionListRequest as cF, type SessionListRequestParams as cG, type SessionListResponseResult as cH, type SessionLoadRequest as cI, type SessionLoadRequestParams as cJ, type SessionLoadResponseResult as cK, type StateChangeHandler as cL, type StreamingCapabilities as cM, type StructureGraphRequest as cN, type StructureGraphRequestParams as cO, type StructureGraphResponseResult as cP, type StructureVisibilityRule as cQ, type SubscribeRequest as cR, type SubscribeRequestParams as cS, Subscription as cT, type SubscriptionAckNotification as cU, type SubscriptionAckParams as cV, type SubscriptionOptions$1 as cW, type SubscriptionState as cX, type SystemAcceptanceRule as cY, type SystemAddress as cZ, type Timestamp as c_, SESSION_METHODS as ca, STATE_METHODS as cb, STEERING_METHODS as cc, STRUCTURE_METHODS as cd, type ScopeAddress as ce, type ScopeMessagingRule as cf, type ScopeVisibility as cg, type ScopeVisibilityRule as ch, type ScopesCreateRequest as ci, type ScopesCreateRequestParams as cj, type ScopesDeleteRequest as ck, type ScopesDeleteRequestParams as cl, type ScopesDeleteResponseResult as cm, type ScopesGetRequest as cn, type ScopesGetRequestParams as co, type ScopesGetResponseResult as cp, type ScopesJoinRequest as cq, type ScopesJoinRequestParams as cr, type ScopesLeaveRequest as cs, type ScopesLeaveRequestParams as ct, type ScopesListRequest as cu, type ScopesListRequestParams as cv, type ScopesMembersRequest as cw, type ScopesMembersRequestParams as cx, type ScopesMembersResponseResult as cy, type SendPolicy as cz, type FederationRoutingConfig as d, type UnsubscribeRequest as d0, type UnsubscribeRequestParams as d1, canAgentAcceptMessage as d2, canAgentMessageAgent as d3, canAgentSeeAgent as d4, canControlAgent as d5, canJoinScope as d6, canMessageAgent as d7, canPerformAction as d8, canPerformMethod as d9, type SystemExposure as dA, canSeeAgent as da, canSeeScope as db, canSendToScope as dc, createEvent as dd, createStreamPair as de, createSubscription as df, deepMergePermissions as dg, filterVisibleAgents as dh, filterVisibleEvents as di, filterVisibleScopes as dj, hasCapability as dk, isAgentExposed as dl, isBroadcastAddress as dm, isDirectAddress as dn, isEventTypeExposed as dp, isFederatedAddress as dq, isHierarchicalAddress as dr, isOrphanedAgent as ds, isScopeExposed as dt, isSuccessResponse as du, mapVisibilityToRule as dv, ndJsonStream as dw, resolveAgentPermissions as dx, waitForOpen as dy, websocketStream as dz, type EventType as e, type SessionId as f, type FederationConnectResponseResult as g, type FederationRouteResponseResult as h, type ConnectionState as i, type ParticipantId as j, type ParticipantType as k, type ScopeId as l, type Agent as m, type Scope as n, type Address as o, type SubscriptionFilter as p, type Event as q, type AgentsGetResponseResult as r, type AgentsListResponseResult as s, type AgentsRegisterResponseResult as t, type AgentsSpawnResponseResult as u, type AgentsUnregisterResponseResult as v, type AgentsUpdateResponseResult as w, type ProtocolVersion as x, type SessionInfo as y, type ScopesCreateResponseResult as z };
+export { type ACPReadTextFileRequest as $, type AgentId as A, type BaseConnectionOptions as B, type ConnectResponseResult as C, type DisconnectResponseResult as D, type ErrorCategory as E, type FederationBufferConfig as F, type ScopesJoinResponseResult as G, type ScopesLeaveResponseResult as H, type ScopesListResponseResult as I, type MessageId as J, type SendResponseResult as K, type SubscriptionId as L, type MAPError as M, type SubscribeResponseResult as N, type AgentVisibility as O, type ParticipantCapabilities as P, type ScopeVisibility as Q, type RequestId as R, type Stream as S, type AgentState as T, type UnsubscribeResponseResult as U, type MessageMeta as V, AgentConnection as W, type ACPAgentHandler as X, type ACPSessionNotification as Y, type ACPRequestPermissionRequest as Z, type ACPRequestPermissionResponse as _, type MAPErrorData as a, type ACPPlan as a$, type ACPReadTextFileResponse as a0, type ACPWriteTextFileRequest as a1, type ACPWriteTextFileResponse as a2, type ACPCreateTerminalRequest as a3, type ACPCreateTerminalResponse as a4, type ACPTerminalOutputRequest as a5, type ACPTerminalOutputResponse as a6, type ACPReleaseTerminalRequest as a7, type ACPReleaseTerminalResponse as a8, type ACPWaitForTerminalExitRequest as a9, type ACPEnvVariable as aA, type ACPEnvelope as aB, ACPError as aC, type ACPErrorCode as aD, type ACPErrorObject as aE, type ACPErrorResponse as aF, type ACPFileSystemCapability as aG, type ACPHttpHeader as aH, type ACPImageContent as aI, type ACPImplementation as aJ, type ACPInitializeRequest as aK, type ACPInitializeResponse as aL, type ACPLoadSessionRequest as aM, type ACPLoadSessionResponse as aN, type ACPMcpCapabilities as aO, type ACPMcpServer as aP, type ACPMcpServerHttp as aQ, type ACPMcpServerSse as aR, type ACPMcpServerStdio as aS, type ACPMessage as aT, type ACPMeta as aU, type ACPNewSessionRequest as aV, type ACPNewSessionResponse as aW, type ACPNotification as aX, type ACPPermissionOption as aY, type ACPPermissionOptionId as aZ, type ACPPermissionOptionKind as a_, type ACPWaitForTerminalExitResponse as aa, type ACPKillTerminalCommandRequest as ab, type ACPKillTerminalCommandResponse as ac, type ACPSessionId as ad, type ACPAgentCapabilities as ae, type ACPAgentContext as af, type ACPAnnotations as ag, type ACPAudioContent as ah, type ACPAuthMethod as ai, type ACPAuthenticateRequest as aj, type ACPAuthenticateResponse as ak, type ACPAvailableCommand as al, type ACPAvailableCommandsUpdate as am, type ACPBlobResourceContents as an, type ACPCancelNotification as ao, type ACPCancelledPermissionOutcome as ap, type ACPCapability as aq, type ACPClientCapabilities as ar, type ACPClientHandlers as as, type ACPContent as at, type ACPContentBlock as au, type ACPContentChunk as av, type ACPContext as aw, type ACPCurrentModeUpdate as ax, type ACPDiff as ay, type ACPEmbeddedResource as az, type FederationEnvelope as b, type AgentsListFilter as b$, type ACPPlanEntry as b0, type ACPPlanEntryPriority as b1, type ACPPlanEntryStatus as b2, type ACPPromptCapabilities as b3, type ACPPromptRequest as b4, type ACPPromptResponse as b5, type ACPProtocolVersion as b6, type ACPRequest as b7, type ACPRequestId as b8, type ACPRequestPermissionOutcome as b9, type ACPToolCallUpdate as bA, type ACPToolKind as bB, ACP_ERROR_CODES as bC, ACP_METHODS as bD, ACP_PROTOCOL_VERSION as bE, AGENT_ERROR_CODES as bF, AUTH_ERROR_CODES as bG, AUTH_METHODS as bH, type AcceptanceContext as bI, type AgentAcceptanceRule as bJ, type AgentConnectOptions as bK, type AgentConnectionOptions as bL, type AgentIncludeOptions as bM, type AgentLifecycle as bN, type AgentMeshConnectOptions as bO, type AgentMessagingRule as bP, type AgentPermissionConfig as bQ, type AgentPermissions as bR, type AgentReconnectionEventHandler as bS, type AgentReconnectionEventType as bT, type AgentReconnectionOptions as bU, type AgentRelationship as bV, type AgentRelationshipType as bW, type AgentVisibilityRule as bX, type AgenticMeshStreamConfig as bY, type AgentsGetRequest as bZ, type AgentsGetRequestParams as b_, type ACPResourceLink as ba, type ACPResponse as bb, type ACPRole as bc, type ACPSelectedPermissionOutcome as bd, type ACPSessionCapabilities as be, type ACPSessionInfoUpdate as bf, type ACPSessionMode as bg, type ACPSessionModeId as bh, type ACPSessionModeState as bi, type ACPSessionUpdate as bj, type ACPSetSessionModeRequest as bk, type ACPSetSessionModeResponse as bl, type ACPStopReason as bm, ACPStreamConnection as bn, type ACPStreamEvents as bo, type ACPStreamOptions as bp, type ACPSuccessResponse as bq, type ACPTerminal as br, type ACPTerminalExitStatus as bs, type ACPTextContent as bt, type ACPTextResourceContents as bu, type ACPToolCall as bv, type ACPToolCallContent as bw, type ACPToolCallId as bx, type ACPToolCallLocation as by, type ACPToolCallStatus as bz, type Message as c, type FederationRouteRequest as c$, type AgentsListRequest as c0, type AgentsListRequestParams as c1, type AgentsRegisterRequest as c2, type AgentsRegisterRequestParams as c3, type AgentsResumeRequest as c4, type AgentsResumeRequestParams as c5, type AgentsResumeResponseResult as c6, type AgentsSpawnRequest as c7, type AgentsSpawnRequestParams as c8, type AgentsStopRequest as c9, type ClientAcceptanceRule as cA, type ClientConnectOptions as cB, ClientConnection as cC, type ClientConnectionOptions as cD, type ConnectRequest as cE, type ConnectRequestParams as cF, type CorrelationId as cG, DEFAULT_AGENT_PERMISSION_CONFIG as cH, type DeliverySemantics as cI, type DirectAddress as cJ, type DisconnectPolicy as cK, type DisconnectRequest as cL, type DisconnectRequestParams as cM, ERROR_CODES as cN, EVENT_TYPES as cO, EXTENSION_METHODS as cP, type EventInput as cQ, type EventNotification as cR, type EventNotificationParams as cS, FEDERATION_ERROR_CODES as cT, FEDERATION_METHODS as cU, type FederatedAddress as cV, type FederationAuth as cW, type FederationConnectRequest as cX, type FederationConnectRequestParams as cY, type FederationMetadata as cZ, type FederationReplayConfig as c_, type AgentsStopRequestParams as ca, type AgentsStopResponseResult as cb, type AgentsSuspendRequest as cc, type AgentsSuspendRequestParams as cd, type AgentsSuspendResponseResult as ce, type AgentsUnregisterRequest as cf, type AgentsUnregisterRequestParams as cg, type AgentsUpdateRequest as ch, type AgentsUpdateRequestParams as ci, type AnyMessage as cj, type AuthCredentials as ck, type AuthError as cl, type AuthErrorCode as cm, type AuthMethod as cn, type AuthPrincipal as co, type AuthRefreshRequest as cp, type AuthRefreshRequestParams as cq, type AuthRefreshResponseResult as cr, type AuthResult as cs, type AuthenticateRequest as ct, type AuthenticateRequestParams as cu, type AuthenticateResponseResult as cv, BaseConnection as cw, type BroadcastAddress as cx, CAPABILITY_REQUIREMENTS as cy, CORE_METHODS as cz, type FederationRoutingConfig as d, type ReplayRequest as d$, type FederationRouteRequestParams as d0, type GatewayReconnectionEvent as d1, type GatewayReconnectionEventHandler as d2, type GatewayReconnectionEventType as d3, type GatewayReconnectionOptions as d4, type GraphEdge as d5, type HierarchicalAddress as d6, type InjectDelivery as d7, type InjectDeliveryResult as d8, type InjectRequest as d9, type Meta as dA, type MultiAddress as dB, NOTIFICATION_METHODS as dC, type NotificationHandler as dD, OBSERVATION_METHODS as dE, type OverflowHandler as dF, type OverflowInfo as dG, PERMISSION_METHODS as dH, PROTOCOL_ERROR_CODES as dI, PROTOCOL_VERSION as dJ, type Participant as dK, type ParticipantAddress as dL, type PermissionAction as dM, type PermissionContext as dN, type PermissionParticipant as dO, type PermissionResult as dP, type PermissionSystemConfig as dQ, type PermissionsAgentUpdatedEventData as dR, type PermissionsClientUpdatedEventData as dS, type PermissionsUpdateRequest as dT, type PermissionsUpdateRequestParams as dU, type PermissionsUpdateResponseResult as dV, RESOURCE_ERROR_CODES as dW, ROUTING_ERROR_CODES as dX, type ReconnectionEventHandler as dY, type ReconnectionEventType as dZ, type ReconnectionOptions as d_, type InjectRequestParams as da, type InjectResponseResult as db, JSONRPC_VERSION as dc, type JoinPolicy as dd, LIFECYCLE_METHODS as de, type MAPNotification as df, type MAPNotificationBase as dg, type MAPRequest as dh, type MAPRequestBase as di, type MAPResponse as dj, type MAPResponseError as dk, type MAPResponseSuccess as dl, MAP_METHODS as dm, type MeshConnectOptions as dn, type MeshPeerEndpoint as dp, type MeshTransportAdapter as dq, type MessageDeliveredEventData as dr, type MessageFailedEventData as ds, type MessageHandler as dt, type MessageNotification as du, type MessageNotificationParams as dv, type MessagePriority as dw, type MessageRelationship as dx, type MessageSentEventData as dy, type MessageVisibility as dz, type EventType as e, agenticMeshStream as e$, type ReplayRequestParams as e0, type ReplayResponseResult as e1, type ReplayedEvent as e2, type RequestHandler as e3, type RoleAddress as e4, SCOPE_METHODS as e5, SESSION_METHODS as e6, STATE_METHODS as e7, STEERING_METHODS as e8, STRUCTURE_METHODS as e9, type SessionCloseResponseResult as eA, type SessionListRequest as eB, type SessionListRequestParams as eC, type SessionListResponseResult as eD, type SessionLoadRequest as eE, type SessionLoadRequestParams as eF, type SessionLoadResponseResult as eG, type StandardAuthMethod as eH, type StateChangeHandler as eI, type StreamingCapabilities as eJ, type StructureGraphRequest as eK, type StructureGraphRequestParams as eL, type StructureGraphResponseResult as eM, type StructureVisibilityRule as eN, type SubscribeRequest as eO, type SubscribeRequestParams as eP, Subscription as eQ, type SubscriptionAckNotification as eR, type SubscriptionAckParams as eS, type SubscriptionOptions$1 as eT, type SubscriptionState as eU, type SystemAcceptanceRule as eV, type SystemAddress as eW, type Timestamp as eX, type TransportType as eY, type UnsubscribeRequest as eZ, type UnsubscribeRequestParams as e_, type ScopeAddress as ea, type ScopeMessagingRule as eb, type ScopeVisibilityRule as ec, type ScopesCreateRequest as ed, type ScopesCreateRequestParams as ee, type ScopesDeleteRequest as ef, type ScopesDeleteRequestParams as eg, type ScopesDeleteResponseResult as eh, type ScopesGetRequest as ei, type ScopesGetRequestParams as ej, type ScopesGetResponseResult as ek, type ScopesJoinRequest as el, type ScopesJoinRequestParams as em, type ScopesLeaveRequest as en, type ScopesLeaveRequestParams as eo, type ScopesListRequest as ep, type ScopesListRequestParams as eq, type ScopesMembersRequest as er, type ScopesMembersRequestParams as es, type ScopesMembersResponseResult as et, type SendPolicy as eu, type SendRequest as ev, type SendRequestParams as ew, type ServerAuthCapabilities as ex, type SessionCloseRequest as ey, type SessionCloseRequestParams as ez, type SessionId as f, canAgentAcceptMessage as f0, canAgentMessageAgent as f1, canAgentSeeAgent as f2, canControlAgent as f3, canJoinScope as f4, canMessageAgent as f5, canPerformAction as f6, canPerformMethod as f7, canSeeAgent as f8, canSeeScope as f9, ndJsonStream as fA, resolveAgentPermissions as fB, waitForOpen as fC, websocketStream as fD, type SystemExposure as fE, canSendToScope as fa, createACPStream as fb, createEvent as fc, createStreamPair as fd, createSubscription as fe, deepMergePermissions as ff, filterVisibleAgents as fg, filterVisibleEvents as fh, filterVisibleScopes as fi, hasCapability as fj, isACPEnvelope as fk, isACPErrorResponse as fl, isACPNotification as fm, isACPRequest as fn, isACPResponse as fo, isACPSuccessResponse as fp, isAgentExposed as fq, isBroadcastAddress as fr, isDirectAddress as fs, isEventTypeExposed as ft, isFederatedAddress as fu, isHierarchicalAddress as fv, isOrphanedAgent as fw, isScopeExposed as fx, isSuccessResponse as fy, mapVisibilityToRule as fz, type FederationConnectResponseResult as g, type FederationRouteResponseResult as h, type ConnectionState as i, type ParticipantId as j, type ParticipantType as k, type ScopeId as l, type Agent as m, type Scope as n, type Address as o, type SubscriptionFilter as p, type Event as q, type AgentsGetResponseResult as r, type AgentsListResponseResult as s, type AgentsRegisterResponseResult as t, type AgentsSpawnResponseResult as u, type AgentsUnregisterResponseResult as v, type AgentsUpdateResponseResult as w, type ProtocolVersion as x, type SessionInfo as y, type ScopesCreateResponseResult as z };