@multi-agent-protocol/sdk 0.0.3 → 0.0.5

package/dist/{index-C7XPWnxS.d.cts → index-DMcRbXOS.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 */
@@ -739,6 +769,8 @@ interface ConnectRequestParams {
     name?: string;
     capabilities?: ParticipantCapabilities;
     sessionId?: SessionId;
+    /** Token to resume a previously disconnected session */
+    resumeToken?: string;
     /** Reclaim orphaned agents from previous connection */
     reclaimAgents?: AgentId[];
     /** Policy for unexpected disconnect */
@@ -777,6 +809,8 @@ interface DisconnectRequest extends MAPRequestBase<DisconnectRequestParams> {
 }
 interface DisconnectResponseResult {
     session: SessionInfo;
+    /** Token to resume this session later */
+    resumeToken?: string;
     _meta?: Meta;
 }
 interface SessionListRequestParams {
@@ -1767,8 +1801,6 @@ declare function isSuccessResponse<T>(response: MAPResponse<T>): response is MAP
 declare function isDirectAddress(address: Address): address is DirectAddress;
 /** Check if an address is a federated address */
 declare function isFederatedAddress(address: Address): address is FederatedAddress;
-/** Check if an address is a scope address */
-declare function isScopeAddress(address: Address): address is ScopeAddress;
 /** Check if an address is a broadcast address */
 declare function isBroadcastAddress(address: Address): address is BroadcastAddress;
 /** Check if an address is a hierarchical address */
@@ -1808,6 +1840,15 @@ declare function ndJsonStream(readable: ReadableStream<Uint8Array>, writable: Wr
  * @returns Stream interface for MAP messages
  */
 declare function websocketStream(ws: WebSocket): Stream;
+/**
+ * Wait for a WebSocket to open with timeout.
+ *
+ * @param ws - WebSocket instance
+ * @param timeoutMs - Timeout in milliseconds (default: 10000)
+ * @returns Promise that resolves when WebSocket is open
+ * @throws Error if connection times out or fails
+ */
+declare function waitForOpen(ws: WebSocket, timeoutMs?: number): Promise<void>;
 /**
  * Creates a pair of connected in-memory streams for testing.
  *
@@ -2110,6 +2151,1156 @@ declare class BaseConnection {
     close(): Promise<void>;
 }
 
+/**
+ * ACP (Agent Client Protocol) types for ACP-over-MAP tunneling.
+ *
+ * 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
+ */
+/**
+ * A unique identifier for a conversation session.
+ */
+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;
+}
+/**
+ * ACP JSON-RPC notification structure (no response expected).
+ */
+interface ACPNotification<TParams = unknown> {
+    jsonrpc: "2.0";
+    method: string;
+    params?: TParams;
+}
+/**
+ * ACP JSON-RPC success response structure.
+ */
+interface ACPSuccessResponse<TResult = unknown> {
+    jsonrpc: "2.0";
+    id: ACPRequestId;
+    result: TResult;
+}
+/**
+ * ACP JSON-RPC error object.
+ */
+interface ACPErrorObject {
+    code: ACPErrorCode;
+    message: string;
+    data?: unknown;
+}
+/**
+ * ACP JSON-RPC error response structure.
+ */
+interface ACPErrorResponse {
+    jsonrpc: "2.0";
+    id: ACPRequestId;
+    error: ACPErrorObject;
+}
+/**
+ * Union of all ACP JSON-RPC response types.
+ */
+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);
+    /**
+     * Create an ACPError from an error response.
+     */
+    static fromResponse(error: ACPErrorObject): ACPError;
+    /**
+     * 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>;
+    /**
+     * 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
  *
@@ -2166,6 +3357,29 @@ interface ClientConnectionOptions extends BaseConnectionOptions {
     /** 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;
+}
 /**
  * Client connection to a MAP system.
  *
@@ -2178,11 +3392,38 @@ interface ClientConnectionOptions extends BaseConnectionOptions {
 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;
@@ -2190,8 +3431,10 @@ declare class ClientConnection {
     }): 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<void>;
+    disconnect(reason?: string): Promise<string | undefined>;
     /**
      * Whether the client is connected
      */
@@ -2283,6 +3526,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
      */
@@ -2467,6 +3755,39 @@ interface AgentConnectionOptions extends BaseConnectionOptions {
     /** Reconnection options */
     reconnection?: AgentReconnectionOptions;
 }
+/**
+ * Options for AgentConnection.connect() static method
+ */
+interface AgentConnectOptions {
+    /** 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) */
+    connectTimeout?: number;
+}
 /**
  * Agent connection to a MAP system.
  *
@@ -2481,11 +3802,41 @@ interface AgentConnectionOptions extends BaseConnectionOptions {
 declare class AgentConnection {
     #private;
     constructor(stream: Stream, options?: AgentConnectionOptions);
+    /**
+     * Connect and register an agent via WebSocket URL.
+     *
+     * Handles:
+     * - WebSocket creation and connection
+     * - Stream wrapping
+     * - Auto-configuration of createStream for reconnection
+     * - Initial MAP protocol connect handshake
+     * - Agent registration
+     *
+     * @param url - WebSocket URL (ws:// or wss://)
+     * @param options - Connection and agent options
+     * @returns Connected and registered AgentConnection instance
+     *
+     * @example
+     * ```typescript
+     * const agent = await AgentConnection.connect('ws://localhost:8080', {
+     *   name: 'Worker',
+     *   role: 'processor',
+     *   reconnection: true
+     * });
+     *
+     * // Already registered, ready to work
+     * agent.onMessage(handleMessage);
+     * await agent.busy();
+     * ```
+     */
+    static connect(url: string, options?: AgentConnectOptions): Promise<AgentConnection>;
     /**
      * Connect and register with the MAP system
      */
     connect(options?: {
         agentId?: AgentId;
+        /** Token to resume a previously disconnected session */
+        resumeToken?: string;
         auth?: {
             method: 'bearer' | 'api-key' | 'mtls' | 'none';
             token?: string;
@@ -2496,8 +3847,10 @@ declare class AgentConnection {
     }>;
     /**
      * 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<void>;
+    disconnect(reason?: string): Promise<string | undefined>;
     /**
      * Whether the agent is connected
      */
@@ -3049,4 +4402,4 @@ declare function canAgentMessageAgent(senderAgent: Agent, targetAgentId: AgentId
     sharedScopes?: ScopeId[];
 }, config?: AgentPermissionConfig): boolean;
 
-export { type AgentMessagingRule 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, AgentConnection as X, type AgentConnectionOptions as Y, type AgentIncludeOptions as Z, type AgentLifecycle as _, type MAPErrorData as a, type FederationAuth as a$, type AgentPermissionConfig as a0, type AgentPermissions as a1, type AgentReconnectionEventHandler as a2, type AgentReconnectionEventType as a3, type AgentReconnectionOptions as a4, type AgentRelationship as a5, type AgentRelationshipType as a6, type AgentState as a7, type AgentVisibility as a8, type AgentVisibilityRule as a9, type AuthRefreshRequestParams as aA, type AuthRefreshResponseResult as aB, BaseConnection as aC, type BroadcastAddress as aD, CAPABILITY_REQUIREMENTS as aE, CORE_METHODS as aF, type ClientAcceptanceRule as aG, ClientConnection as aH, type ClientConnectionOptions as aI, type ConnectRequest as aJ, type ConnectRequestParams as aK, type CorrelationId as aL, DEFAULT_AGENT_PERMISSION_CONFIG as aM, type DeliverySemantics as aN, type DirectAddress as aO, type DisconnectPolicy as aP, type DisconnectRequest as aQ, type DisconnectRequestParams as aR, ERROR_CODES as aS, EVENT_TYPES as aT, EXTENSION_METHODS as aU, type EventInput as aV, type EventNotification as aW, type EventNotificationParams as aX, FEDERATION_ERROR_CODES as aY, FEDERATION_METHODS as aZ, type FederatedAddress as a_, type AgentsGetRequest as aa, type AgentsGetRequestParams as ab, type AgentsListFilter as ac, type AgentsListRequest as ad, type AgentsListRequestParams as ae, type AgentsRegisterRequest as af, type AgentsRegisterRequestParams as ag, type AgentsResumeRequest as ah, type AgentsResumeRequestParams as ai, type AgentsResumeResponseResult as aj, type AgentsSpawnRequest as ak, type AgentsSpawnRequestParams as al, type AgentsStopRequest as am, type AgentsStopRequestParams as an, type AgentsStopResponseResult as ao, type AgentsSuspendRequest as ap, type AgentsSuspendRequestParams as aq, type AgentsSuspendResponseResult as ar, type AgentsUnregisterRequest as as, type AgentsUnregisterRequestParams as at, type AgentsUpdateRequest as au, type AgentsUpdateRequestParams as av, type AnyMessage as aw, type AuthMethod as ax, type AuthParams as ay, type AuthRefreshRequest as az, type FederationEnvelope as b, type ReconnectionEventType as b$, type FederationConnectRequest as b0, type FederationConnectRequestParams as b1, type FederationMetadata as b2, type FederationReplayConfig as b3, type FederationRouteRequest as b4, type FederationRouteRequestParams as b5, type GatewayReconnectionEvent as b6, type GatewayReconnectionEventHandler as b7, type GatewayReconnectionEventType as b8, type GatewayReconnectionOptions as b9, type MessageSentEventData as bA, type MessageVisibility as bB, type Meta as bC, type MultiAddress as bD, NOTIFICATION_METHODS as bE, type NotificationHandler as bF, OBSERVATION_METHODS as bG, type OverflowHandler as bH, type OverflowInfo as bI, PERMISSION_METHODS as bJ, PROTOCOL_ERROR_CODES as bK, PROTOCOL_VERSION as bL, type Participant as bM, type ParticipantAddress as bN, type PermissionAction as bO, type PermissionContext as bP, type PermissionParticipant as bQ, type PermissionResult as bR, type PermissionSystemConfig as bS, type PermissionsAgentUpdatedEventData as bT, type PermissionsClientUpdatedEventData as bU, type PermissionsUpdateRequest as bV, type PermissionsUpdateRequestParams as bW, type PermissionsUpdateResponseResult as bX, RESOURCE_ERROR_CODES as bY, ROUTING_ERROR_CODES as bZ, type ReconnectionEventHandler as b_, type GraphEdge as ba, type HierarchicalAddress as bb, type InjectDelivery as bc, type InjectDeliveryResult as bd, type InjectRequest as be, type InjectRequestParams as bf, type InjectResponseResult as bg, JSONRPC_VERSION as bh, type JoinPolicy as bi, LIFECYCLE_METHODS as bj, type MAPNotification as bk, type MAPNotificationBase as bl, type MAPRequest as bm, type MAPRequestBase as bn, type MAPResponse as bo, type MAPResponseError as bp, type MAPResponseSuccess as bq, MAP_METHODS as br, type MessageDeliveredEventData as bs, type MessageFailedEventData as bt, type MessageHandler as bu, type MessageMeta as bv, type MessageNotification as bw, type MessageNotificationParams as bx, type MessagePriority as by, type MessageRelationship as bz, type Message as c, type UnsubscribeRequestParams as c$, type ReconnectionOptions as c0, type ReplayRequest as c1, type ReplayRequestParams as c2, type ReplayResponseResult as c3, type ReplayedEvent as c4, type RequestHandler as c5, type RoleAddress as c6, SCOPE_METHODS as c7, SESSION_METHODS as c8, STATE_METHODS as c9, type SessionCloseRequest as cA, type SessionCloseRequestParams as cB, type SessionCloseResponseResult as cC, type SessionListRequest as cD, type SessionListRequestParams as cE, type SessionListResponseResult as cF, type SessionLoadRequest as cG, type SessionLoadRequestParams as cH, type SessionLoadResponseResult as cI, type StateChangeHandler as cJ, type StreamingCapabilities as cK, type StructureGraphRequest as cL, type StructureGraphRequestParams as cM, type StructureGraphResponseResult as cN, type StructureVisibilityRule as cO, type SubscribeRequest as cP, type SubscribeRequestParams as cQ, Subscription as cR, type SubscriptionAckNotification as cS, type SubscriptionAckParams as cT, type SubscriptionOptions$1 as cU, type SubscriptionState as cV, type SystemAcceptanceRule as cW, type SystemAddress as cX, type Timestamp as cY, type TransportType as cZ, type UnsubscribeRequest as c_, STEERING_METHODS as ca, STRUCTURE_METHODS as cb, type ScopeAddress as cc, type ScopeMessagingRule as cd, type ScopeVisibility as ce, type ScopeVisibilityRule as cf, type ScopesCreateRequest as cg, type ScopesCreateRequestParams as ch, type ScopesDeleteRequest as ci, type ScopesDeleteRequestParams as cj, type ScopesDeleteResponseResult as ck, type ScopesGetRequest as cl, type ScopesGetRequestParams as cm, type ScopesGetResponseResult as cn, type ScopesJoinRequest as co, type ScopesJoinRequestParams as cp, type ScopesLeaveRequest as cq, type ScopesLeaveRequestParams as cr, type ScopesListRequest as cs, type ScopesListRequestParams as ct, type ScopesMembersRequest as cu, type ScopesMembersRequestParams as cv, type ScopesMembersResponseResult as cw, type SendPolicy as cx, type SendRequest as cy, type SendRequestParams as cz, type FederationRoutingConfig as d, canAgentAcceptMessage as d0, canAgentMessageAgent as d1, canAgentSeeAgent as d2, canControlAgent as d3, canJoinScope as d4, canMessageAgent as d5, canPerformAction as d6, canPerformMethod as d7, canSeeAgent as d8, canSeeScope as d9, canSendToScope as da, createEvent as db, createStreamPair as dc, createSubscription as dd, deepMergePermissions as de, filterVisibleAgents as df, filterVisibleEvents as dg, filterVisibleScopes as dh, hasCapability as di, isAgentExposed as dj, isBroadcastAddress as dk, isDirectAddress as dl, isEventTypeExposed as dm, isFederatedAddress as dn, isHierarchicalAddress as dp, isOrphanedAgent as dq, isScopeAddress as dr, isScopeExposed as ds, isSuccessResponse as dt, mapVisibilityToRule as du, ndJsonStream as dv, resolveAgentPermissions as dw, websocketStream as dx, type SystemExposure as dy, 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 ACPCreateTerminalRequest 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, AgentConnection as O, type ParticipantCapabilities as P, type ACPAgentHandler as Q, type RequestId as R, type Stream as S, type ACPSessionNotification as T, type UnsubscribeResponseResult as U, type ACPRequestPermissionRequest as V, type ACPRequestPermissionResponse as W, type ACPReadTextFileRequest as X, type ACPReadTextFileResponse as Y, type ACPWriteTextFileRequest as Z, type ACPWriteTextFileResponse as _, type MAPErrorData as a, type ACPPromptCapabilities as a$, type ACPCreateTerminalResponse as a0, type ACPTerminalOutputRequest as a1, type ACPTerminalOutputResponse as a2, type ACPReleaseTerminalRequest as a3, type ACPReleaseTerminalResponse as a4, type ACPWaitForTerminalExitRequest as a5, type ACPWaitForTerminalExitResponse as a6, type ACPKillTerminalCommandRequest as a7, type ACPKillTerminalCommandResponse as a8, type ACPSessionId as a9, type ACPErrorObject as aA, type ACPErrorResponse as aB, type ACPFileSystemCapability as aC, type ACPHttpHeader as aD, type ACPImageContent as aE, type ACPImplementation as aF, type ACPInitializeRequest as aG, type ACPInitializeResponse as aH, type ACPLoadSessionRequest as aI, type ACPLoadSessionResponse as aJ, type ACPMcpCapabilities as aK, type ACPMcpServer as aL, type ACPMcpServerHttp as aM, type ACPMcpServerSse as aN, type ACPMcpServerStdio as aO, type ACPMessage as aP, type ACPMeta as aQ, type ACPNewSessionRequest as aR, type ACPNewSessionResponse as aS, type ACPNotification as aT, type ACPPermissionOption as aU, type ACPPermissionOptionId as aV, type ACPPermissionOptionKind as aW, type ACPPlan as aX, type ACPPlanEntry as aY, type ACPPlanEntryPriority as aZ, type ACPPlanEntryStatus as a_, type ACPAgentCapabilities as aa, type ACPAgentContext as ab, type ACPAnnotations as ac, type ACPAudioContent as ad, type ACPAuthMethod as ae, type ACPAuthenticateRequest as af, type ACPAuthenticateResponse as ag, type ACPAvailableCommand as ah, type ACPAvailableCommandsUpdate as ai, type ACPBlobResourceContents as aj, type ACPCancelNotification as ak, type ACPCancelledPermissionOutcome as al, type ACPCapability as am, type ACPClientCapabilities as an, type ACPClientHandlers as ao, type ACPContent as ap, type ACPContentBlock as aq, type ACPContentChunk as ar, type ACPContext as as, type ACPCurrentModeUpdate as at, type ACPDiff as au, type ACPEmbeddedResource as av, type ACPEnvVariable as aw, type ACPEnvelope as ax, ACPError as ay, type ACPErrorCode as az, type FederationEnvelope as b, type AgentsRegisterRequestParams as b$, type ACPPromptRequest as b0, type ACPPromptResponse as b1, type ACPProtocolVersion as b2, type ACPRequest as b3, type ACPRequestId as b4, type ACPRequestPermissionOutcome as b5, type ACPResourceLink as b6, type ACPResponse as b7, type ACPRole as b8, type ACPSelectedPermissionOutcome as b9, ACP_PROTOCOL_VERSION as bA, AGENT_ERROR_CODES as bB, AUTH_ERROR_CODES as bC, AUTH_METHODS as bD, type AcceptanceContext as bE, type AgentAcceptanceRule as bF, type AgentConnectOptions as bG, type AgentConnectionOptions as bH, type AgentIncludeOptions as bI, type AgentLifecycle as bJ, type AgentMessagingRule as bK, type AgentPermissionConfig as bL, type AgentPermissions as bM, type AgentReconnectionEventHandler as bN, type AgentReconnectionEventType as bO, type AgentReconnectionOptions as bP, type AgentRelationship as bQ, type AgentRelationshipType as bR, type AgentState as bS, type AgentVisibility as bT, type AgentVisibilityRule as bU, type AgentsGetRequest as bV, type AgentsGetRequestParams as bW, type AgentsListFilter as bX, type AgentsListRequest as bY, type AgentsListRequestParams as bZ, type AgentsRegisterRequest as b_, type ACPSessionCapabilities as ba, type ACPSessionInfoUpdate as bb, type ACPSessionMode as bc, type ACPSessionModeId as bd, type ACPSessionModeState as be, type ACPSessionUpdate as bf, type ACPSetSessionModeRequest as bg, type ACPSetSessionModeResponse as bh, type ACPStopReason as bi, ACPStreamConnection as bj, type ACPStreamEvents as bk, type ACPStreamOptions as bl, type ACPSuccessResponse as bm, type ACPTerminal as bn, type ACPTerminalExitStatus as bo, type ACPTextContent as bp, type ACPTextResourceContents as bq, type ACPToolCall as br, type ACPToolCallContent as bs, type ACPToolCallId as bt, type ACPToolCallLocation as bu, type ACPToolCallStatus as bv, type ACPToolCallUpdate as bw, type ACPToolKind as bx, ACP_ERROR_CODES as by, ACP_METHODS as bz, type Message as c, type InjectRequestParams as c$, type AgentsResumeRequest as c0, type AgentsResumeRequestParams as c1, type AgentsResumeResponseResult as c2, type AgentsSpawnRequest as c3, type AgentsSpawnRequestParams as c4, type AgentsStopRequest as c5, type AgentsStopRequestParams as c6, type AgentsStopResponseResult as c7, type AgentsSuspendRequest as c8, type AgentsSuspendRequestParams as c9, type DisconnectRequest as cA, type DisconnectRequestParams as cB, ERROR_CODES as cC, EVENT_TYPES as cD, EXTENSION_METHODS as cE, type EventInput as cF, type EventNotification as cG, type EventNotificationParams as cH, FEDERATION_ERROR_CODES as cI, FEDERATION_METHODS as cJ, type FederatedAddress as cK, type FederationAuth as cL, type FederationConnectRequest as cM, type FederationConnectRequestParams as cN, type FederationMetadata as cO, type FederationReplayConfig as cP, type FederationRouteRequest as cQ, type FederationRouteRequestParams as cR, type GatewayReconnectionEvent as cS, type GatewayReconnectionEventHandler as cT, type GatewayReconnectionEventType as cU, type GatewayReconnectionOptions as cV, type GraphEdge as cW, type HierarchicalAddress as cX, type InjectDelivery as cY, type InjectDeliveryResult as cZ, type InjectRequest as c_, type AgentsSuspendResponseResult as ca, type AgentsUnregisterRequest as cb, type AgentsUnregisterRequestParams as cc, type AgentsUpdateRequest as cd, type AgentsUpdateRequestParams as ce, type AnyMessage as cf, type AuthMethod as cg, type AuthParams as ch, type AuthRefreshRequest as ci, type AuthRefreshRequestParams as cj, type AuthRefreshResponseResult as ck, BaseConnection as cl, type BroadcastAddress as cm, CAPABILITY_REQUIREMENTS as cn, CORE_METHODS as co, type ClientAcceptanceRule as cp, type ClientConnectOptions as cq, ClientConnection as cr, type ClientConnectionOptions as cs, type ConnectRequest as ct, type ConnectRequestParams as cu, type CorrelationId as cv, DEFAULT_AGENT_PERMISSION_CONFIG as cw, type DeliverySemantics as cx, type DirectAddress as cy, type DisconnectPolicy as cz, type FederationRoutingConfig as d, type ScopeVisibility as d$, type InjectResponseResult as d0, JSONRPC_VERSION as d1, type JoinPolicy as d2, LIFECYCLE_METHODS as d3, type MAPNotification as d4, type MAPNotificationBase as d5, type MAPRequest as d6, type MAPRequestBase as d7, type MAPResponse as d8, type MAPResponseError as d9, type PermissionContext as dA, type PermissionParticipant as dB, type PermissionResult as dC, type PermissionSystemConfig as dD, type PermissionsAgentUpdatedEventData as dE, type PermissionsClientUpdatedEventData as dF, type PermissionsUpdateRequest as dG, type PermissionsUpdateRequestParams as dH, type PermissionsUpdateResponseResult as dI, RESOURCE_ERROR_CODES as dJ, ROUTING_ERROR_CODES as dK, type ReconnectionEventHandler as dL, type ReconnectionEventType as dM, type ReconnectionOptions as dN, type ReplayRequest as dO, type ReplayRequestParams as dP, type ReplayResponseResult as dQ, type ReplayedEvent as dR, type RequestHandler as dS, type RoleAddress as dT, SCOPE_METHODS as dU, SESSION_METHODS as dV, STATE_METHODS as dW, STEERING_METHODS as dX, STRUCTURE_METHODS as dY, type ScopeAddress as dZ, type ScopeMessagingRule as d_, type MAPResponseSuccess as da, MAP_METHODS as db, type MessageDeliveredEventData as dc, type MessageFailedEventData as dd, type MessageHandler as de, type MessageMeta as df, type MessageNotification as dg, type MessageNotificationParams as dh, type MessagePriority as di, type MessageRelationship as dj, type MessageSentEventData as dk, type MessageVisibility as dl, type Meta as dm, type MultiAddress as dn, NOTIFICATION_METHODS as dp, type NotificationHandler as dq, OBSERVATION_METHODS as dr, type OverflowHandler as ds, type OverflowInfo as dt, PERMISSION_METHODS as du, PROTOCOL_ERROR_CODES as dv, PROTOCOL_VERSION as dw, type Participant as dx, type ParticipantAddress as dy, type PermissionAction as dz, type EventType as e, createSubscription as e$, type ScopeVisibilityRule as e0, type ScopesCreateRequest as e1, type ScopesCreateRequestParams as e2, type ScopesDeleteRequest as e3, type ScopesDeleteRequestParams as e4, type ScopesDeleteResponseResult as e5, type ScopesGetRequest as e6, type ScopesGetRequestParams as e7, type ScopesGetResponseResult as e8, type ScopesJoinRequest as e9, type SubscribeRequest as eA, type SubscribeRequestParams as eB, Subscription as eC, type SubscriptionAckNotification as eD, type SubscriptionAckParams as eE, type SubscriptionOptions$1 as eF, type SubscriptionState as eG, type SystemAcceptanceRule as eH, type SystemAddress as eI, type Timestamp as eJ, type TransportType as eK, type UnsubscribeRequest as eL, type UnsubscribeRequestParams as eM, canAgentAcceptMessage as eN, canAgentMessageAgent as eO, canAgentSeeAgent as eP, canControlAgent as eQ, canJoinScope as eR, canMessageAgent as eS, canPerformAction as eT, canPerformMethod as eU, canSeeAgent as eV, canSeeScope as eW, canSendToScope as eX, createACPStream as eY, createEvent as eZ, createStreamPair as e_, type ScopesJoinRequestParams as ea, type ScopesLeaveRequest as eb, type ScopesLeaveRequestParams as ec, type ScopesListRequest as ed, type ScopesListRequestParams as ee, type ScopesMembersRequest as ef, type ScopesMembersRequestParams as eg, type ScopesMembersResponseResult as eh, type SendPolicy as ei, type SendRequest as ej, type SendRequestParams as ek, type SessionCloseRequest as el, type SessionCloseRequestParams as em, type SessionCloseResponseResult as en, type SessionListRequest as eo, type SessionListRequestParams as ep, type SessionListResponseResult as eq, type SessionLoadRequest as er, type SessionLoadRequestParams as es, type SessionLoadResponseResult as et, type StateChangeHandler as eu, type StreamingCapabilities as ev, type StructureGraphRequest as ew, type StructureGraphRequestParams as ex, type StructureGraphResponseResult as ey, type StructureVisibilityRule as ez, type SessionId as f, deepMergePermissions as f0, filterVisibleAgents as f1, filterVisibleEvents as f2, filterVisibleScopes as f3, hasCapability as f4, isACPEnvelope as f5, isACPErrorResponse as f6, isACPNotification as f7, isACPRequest as f8, isACPResponse as f9, isACPSuccessResponse as fa, isAgentExposed as fb, isBroadcastAddress as fc, isDirectAddress as fd, isEventTypeExposed as fe, isFederatedAddress as ff, isHierarchicalAddress as fg, isOrphanedAgent as fh, isScopeExposed as fi, isSuccessResponse as fj, mapVisibilityToRule as fk, ndJsonStream as fl, resolveAgentPermissions as fm, waitForOpen as fn, websocketStream as fo, type SystemExposure as fp, 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 };