@band-ai/sdk 0.3.4 → 0.4.0

package/README.md

@@ -44,6 +44,25 @@ Requires Node.js 22+.
 
 Each adapter wraps a different LLM framework. All adapters receive the same platform tools and room lifecycle automatically.
 
+### GitHub Copilot CLI ACP (public preview)
+
+`CopilotACPAdapter` connects Band rooms to [GitHub Copilot CLI's ACP server](https://docs.github.com/en/copilot/reference/copilot-cli-reference/acp-server). Install the optional ACP peer alongside the CLI, then use the default stdio transport:
+
+```bash
+pnpm add @agentclientprotocol/sdk
+npm install -g @github/copilot
+```
+
+```ts
+import { CopilotACPAdapter } from "@band-ai/sdk";
+
+const adapter = new CopilotACPAdapter({ cwd: process.cwd() });
+```
+
+It launches `copilot --acp --stdio`. For an already-running listener, use `{ host, port }`; the SDK only owns its client socket, never that listener. The default injected Band MCP server is loopback-only, so a remote/containerized Copilot server needs `enableMcpTools: false` and caller-provided reachable `mcpServers`.
+
+Copilot CLI authentication and BYOK remain CLI configuration. Supply auth/BYOK environment variables through `env` only for stdio; a TCP listener already owns its environment. ACP is public preview, and Copilot tool filtering and reasoning effort are server launch-time settings rather than per-session adapter options.
+
 ### Generic
 
 Bring your own logic with a single async callback:
@@ -160,6 +179,28 @@ const agent = Agent.create({
 await agent.run();
 ```
 
+### OMP ACP
+
+`OmpACPAdapter` connects Band rooms to [OMP's](https://omp.sh/) ACP server. Install the optional ACP peer alongside OMP itself:
+
+```bash
+pnpm add @agentclientprotocol/sdk
+curl -fsSL https://omp.sh/install | sh
+```
+
+```ts
+import { Agent, OmpACPAdapter, loadAgentConfig } from "@band-ai/sdk";
+
+const agent = Agent.create({
+  adapter: new OmpACPAdapter({ cwd: process.cwd() }),
+  config: loadAgentConfig("my_agent"),
+});
+
+await agent.run();
+```
+
+It launches `omp acp`. OMP performs `read`/`write`/`bash` itself — this SDK's ACP client doesn't implement `fs`/`terminal` handlers, so `clientCapabilities` is left unset — but OMP still gates `bash`/`edit`/`delete`/`move` through `session/request_permission` under its default (non-yolo) ACP approval mode; don't configure OMP with `tools.approvalMode: yolo` if you want that gate to stay active. OMP resolves its own provider credentials (a stored login or one of 60+ provider-specific environment variables — see [OMP's provider docs](https://github.com/can1357/oh-my-pi/blob/main/docs/providers.md)); pass any needed values through `env`. The SDK never reads or logs them.
+
 ### LangGraph
 
 ```ts
@@ -204,6 +245,8 @@ import { Agent, SimpleAdapter, loadAgentConfig } from "@band-ai/sdk";
 import type { AdapterToolsProtocol, HistoryProvider, PlatformMessage } from "@band-ai/sdk";
 
 class MyAdapter extends SimpleAdapter<HistoryProvider> {
+  protected readonly provider = "my-adapter";
+
   async onMessage(message: PlatformMessage, tools: AdapterToolsProtocol): Promise<void> {
     await tools.sendMessage("Hello from my custom adapter!");
   }
@@ -328,6 +371,8 @@ Working examples live in `examples/`. Each folder is self-contained.
 | `examples/gemini/` | Gemini | Gemini 3 Flash |
 | `examples/claude-sdk/` | Claude Agent SDK | MCP tools, room-scoped resume |
 | `examples/codex/` | Codex | Thread mapping, local commands |
+| `examples/omp-acp/` | OMP | ACP stdio, permission-gated writes |
+| `examples/copilot-acp/` | GitHub Copilot CLI | ACP stdio or existing TCP listener |
 | `examples/langgraph/` | LangGraph | Graph-based agent |
 | `examples/custom-adapter/` | SimpleAdapter | Custom adapter protocol |
 | `examples/parlant/` | Parlant | Guideline-based behavior |
@@ -362,11 +407,19 @@ Agent.create({ adapter, config })
 
 `agent.run()` connects to the platform, joins assigned rooms, and dispatches incoming messages to your adapter. It handles `SIGINT`/`SIGTERM` for graceful shutdown. Pass `{ signals: false }` to disable signal handling in tests.
 
+## Migration
+
+Adapter failure reporting is structured (`MessagingTools.sendFailure`, required
+`SimpleAdapter.provider`, nested A2A `metadata.failure`). See
+[docs/migrations/structured-adapter-failure-reporting.md](docs/migrations/structured-adapter-failure-reporting.md).
+
 ## Development
 
 ```bash
 pnpm install
+pnpm build       # build dist/ — some tests compile a consumer against it
 pnpm test        # unit tests
 pnpm typecheck   # tsc --noEmit
-pnpm build       # build dist/
 ```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for which tests need that build and why.

package/dist/{ClaudeSDKAdapter-CXud2DBE.d.ts → CopilotACPAdapter-BCpbHFB0.d.ts}

@@ -1,12 +1,13 @@
-import { S as SimpleAdapter } from './simpleAdapter--wznuoOw.js';
-import { A as AdapterToolsProtocol, a as AgentToolsProtocol, c as MessagingTools, T as ToolExecutor, f as ToolSchemaProvider, H as HistoryConverter } from './protocols-Bwwcql0h.js';
-import { H as HistoryProvider, P as PlatformMessage } from './types-DFUtpxah.js';
+import { S as SimpleAdapter } from './simpleAdapter-eLvsAQNo.js';
+import { A as AdapterToolsProtocol, b as AgentToolsProtocol, e as MessagingTools, T as ToolExecutor, i as ToolSchemaProvider, H as HistoryConverter } from './protocols-Dpci6uae.js';
+import { H as HistoryProvider, P as PlatformMessage } from './types-CKU1N0SK.js';
 import { L as Logger } from './logger-CABQOnlR.js';
-import { C as CustomToolDef } from './customTools-BzF0IISO.js';
-import { m as ToolModelMessage, n as ToolModelSchema, M as MetadataMap } from './dtos-B8KU_q4d.js';
-import { s as GoogleADKMessages, q as GoogleADKHistoryConverter, e as A2ASessionState, A as A2AAuth, G as GatewaySessionState, a as A2AGatewayAdapterOptions, n as ParlantMessages, P as ParlantHistoryConverter, t as OpencodeSessionState, O as OpencodeHistoryConverter } from './opencode-Bld62x5t.js';
-import { c as createBandMcpBackend } from './backends-D-dBdDm-.js';
-import { M as McpToolRegistration } from './sdk-qKJtMma_.js';
+import { C as CustomToolDef } from './customTools-Bfecd0mJ.js';
+import { m as ToolModelMessage, n as ToolModelSchema, M as MetadataMap } from './dtos-CjQsN1_h.js';
+import { u as GoogleADKMessages, s as GoogleADKHistoryConverter, e as A2ASessionState, A as A2AAuth, G as GatewaySessionState, a as A2AGatewayAdapterOptions, n as ParlantMessages, P as ParlantHistoryConverter, C as ChatTurn, v as OpencodeSessionState, O as OpencodeHistoryConverter, r as ACPClientSessionState } from './acp-client-DUXyczlF.js';
+import { c as createBandMcpBackend } from './backends-CgsPQa9B.js';
+import { M as McpToolRegistration } from './sdk-Cin80BTC.js';
+import { Client, ClientSideConnection, RequestPermissionRequest, McpServer, ClientCapabilities, SessionMode, SessionConfigSelectOption } from '@agentclientprotocol/sdk';
 
 type GenericAdapterHandler = (args: {
     message: PlatformMessage;
@@ -20,6 +21,7 @@ type GenericAdapterHandler = (args: {
     agentDescription: string;
 }) => Promise<void>;
 declare class GenericAdapter extends SimpleAdapter<HistoryProvider> {
+    protected readonly provider = "generic";
     private readonly handler;
     constructor(handler: GenericAdapterHandler);
     onMessage(message: PlatformMessage, tools: AdapterToolsProtocol, history: HistoryProvider, participantsMessage: string | null, contactsMessage: string | null, context: {
@@ -108,7 +110,7 @@ type CodexRpcEvent = CodexRpcRequestEvent | CodexRpcNotificationEvent;
 interface CodexClientLike {
     connect(): Promise<void>;
     initialize(params: InitializeParams): Promise<void>;
-    request<TResult>(method: string, params?: Record<string, unknown>): Promise<TResult>;
+    request<TResult>(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<TResult>;
     notify(method: string, params?: Record<string, unknown>): Promise<void>;
     respond(requestId: RequestId, result: Record<string, unknown> | DynamicToolCallResponse): Promise<void>;
     respondError(requestId: RequestId, code: number, message: string, data?: unknown): Promise<void>;
@@ -140,7 +142,7 @@ declare class CodexAppServerStdioClient implements CodexClientLike {
     });
     connect(): Promise<void>;
     initialize(params: InitializeParams): Promise<void>;
-    request<TResult>(method: string, params?: Record<string, unknown>): Promise<TResult>;
+    request<TResult>(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<TResult>;
     notify(method: string, params?: Record<string, unknown>): Promise<void>;
     respond(requestId: RequestId, result: Record<string, unknown> | DynamicToolCallResponse): Promise<void>;
     respondError(requestId: RequestId, code: number, message: string, data?: unknown): Promise<void>;
@@ -200,6 +202,7 @@ interface CodexAdapterOptions {
     logger?: Logger;
 }
 declare class CodexAdapter extends SimpleAdapter<HistoryProvider, AgentToolsProtocol> {
+    protected readonly provider = "codex";
     private readonly baseConfig;
     private readonly roomConfigOverrides;
     private readonly customTools;
@@ -221,14 +224,21 @@ declare class CodexAdapter extends SimpleAdapter<HistoryProvider, AgentToolsProt
         isSessionBootstrap: boolean;
         roomId: string;
     }): Promise<void>;
+    private ensureClientAndThread;
+    private startTurn;
+    private runEventLoop;
     onCleanup(roomId: string): Promise<void>;
     onRuntimeStop(): Promise<void>;
     private getConfig;
     private ensureSystemPrompt;
     private ensureClient;
+    private takeClientForReset;
     private resetClient;
+    private abandonClient;
+    private evictOnTransportFailure;
     private debug;
     private getOrCreateThread;
+    private assertCurrentClient;
     private buildThreadStartParams;
     private buildThreadResumeParams;
     private buildThreadConfigOverrides;
@@ -241,9 +251,15 @@ declare class CodexAdapter extends SimpleAdapter<HistoryProvider, AgentToolsProt
     private extractToolItem;
     private extractThoughtText;
     private emitTurnOutcome;
+    private reportAndDeliverTurnFailure;
     private extractTurnError;
     private currentMention;
     private handleLocalCommand;
+    private handleHelpCommand;
+    private handleStatusCommand;
+    private handleModelCommand;
+    private handleModelListCommand;
+    private handleReasoningCommand;
     private safeSendEvent;
 }
 
@@ -280,6 +296,8 @@ interface ToolCallingModel {
 interface ToolCallingAdapterOptions {
     model: ToolCallingModel;
     toolFormat: "openai" | "anthropic";
+    /** Passed through as `AgentFailure.provider` on a provider failure. Defaults to `DEFAULT_PROVIDER` when omitted. */
+    provider?: string;
     systemPrompt?: string;
     includeMemoryTools?: boolean;
     maxToolRounds?: number;
@@ -291,6 +309,7 @@ type ToolCallingTools = MessagingTools & ToolExecutor & ToolSchemaProvider;
 declare class ToolCallingAdapter extends SimpleAdapter<HistoryProvider, ToolCallingTools> {
     private readonly model;
     private readonly toolFormat;
+    protected readonly provider: string;
     private readonly systemPrompt?;
     private readonly includeMemoryTools;
     private readonly maxToolRounds;
@@ -328,7 +347,7 @@ declare class VercelAISDKToolCallingModel implements ToolCallingModel {
     complete(request: ToolCallingModelRequest): Promise<ToolCallingResponse>;
 }
 
-interface VercelAISDKAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model">, VercelAISDKToolCallingModelOptions {
+interface VercelAISDKAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model" | "provider">, VercelAISDKToolCallingModelOptions {
 }
 declare class VercelAISDKAdapter extends ToolCallingAdapter {
     constructor(options: VercelAISDKAdapterOptions);
@@ -367,7 +386,7 @@ declare class OpenAIToolCallingModel implements ToolCallingModel {
     private getClient;
 }
 
-interface OpenAIAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model"> {
+interface OpenAIAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model" | "provider"> {
     model?: ToolCallingModel;
     openAIModel?: string;
     apiKey?: string;
@@ -405,7 +424,7 @@ declare class AnthropicToolCallingModel implements ToolCallingModel {
     private getClient;
 }
 
-interface AnthropicAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model"> {
+interface AnthropicAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model" | "provider"> {
     model?: ToolCallingModel;
     anthropicModel?: string;
     apiKey?: string;
@@ -459,7 +478,7 @@ declare class GeminiToolCallingModel implements ToolCallingModel {
     private ensurePartFactories;
 }
 
-interface GeminiAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model"> {
+interface GeminiAdapterOptions extends Omit<ToolCallingAdapterOptions, "toolFormat" | "model" | "provider"> {
     model?: ToolCallingModel;
     geminiModel?: string;
     apiKey?: string;
@@ -534,6 +553,7 @@ interface GoogleADKAdapterOptions {
     sdkFactory?: () => Promise<GoogleAdkSdkLike>;
 }
 declare class GoogleADKAdapter extends SimpleAdapter<GoogleADKMessages, AdapterToolsProtocol> {
+    protected readonly provider = "google-adk";
     private readonly model;
     private readonly systemPromptOverride?;
     private readonly customSection;
@@ -584,6 +604,7 @@ interface LangGraphAdapterOptions {
     logger?: Logger;
 }
 declare class LangGraphAdapter extends SimpleAdapter<HistoryProvider, AdapterToolsProtocol> {
+    protected readonly provider = "langgraph";
     private readonly llm?;
     private readonly checkpointer?;
     private readonly graph?;
@@ -646,6 +667,7 @@ type A2AClientFactory = (input: {
     authHeaders: Record<string, string>;
 }) => Promise<A2AClientLike>;
 declare class A2AAdapter extends SimpleAdapter<A2ASessionState, MessagingTools> {
+    protected readonly provider = "a2a";
     private readonly remoteUrl;
     private readonly authHeaders;
     private readonly streaming;
@@ -676,6 +698,7 @@ declare class A2AAdapter extends SimpleAdapter<A2ASessionState, MessagingTools>
 }
 
 declare class A2AGatewayAdapter extends SimpleAdapter<GatewaySessionState, MessagingTools> {
+    protected readonly provider = "a2a-gateway";
     private readonly bandRest;
     private readonly gatewayUrl;
     private readonly host;
@@ -686,6 +709,7 @@ declare class A2AGatewayAdapter extends SimpleAdapter<GatewaySessionState, Messa
     private readonly peerPageSize;
     private readonly maxPeerPages;
     private readonly serverFactory;
+    private readonly logger;
     private readonly peersBySlug;
     private readonly peersById;
     private readonly contextToRoom;
@@ -774,6 +798,14 @@ interface ParlantAdapterOptions {
     customSection?: string;
     includeBaseInstructions?: boolean;
     responseTimeoutSeconds?: number;
+    /**
+     * Most turns of prior conversation to replay into a new session.
+     * Defaults to 100.  The value is a cap, not a toggle: `0` replays none.
+     *
+     * A reply is never replayed without the question it answers, so the result
+     * can be one turn shorter than the cap - and `1` replays nothing whenever
+     * the newest turn is an answer.
+     */
     maxHistoryMessages?: number;
     historyConverter?: ParlantHistoryConverter;
     clientFactory?: ParlantClientFactory;
@@ -781,6 +813,7 @@ interface ParlantAdapterOptions {
 }
 type ParlantClientFactory = () => Promise<ParlantClientLike>;
 declare class ParlantAdapter extends SimpleAdapter<ParlantMessages, MessagingTools> {
+    protected readonly provider = "parlant";
     private readonly environment;
     private readonly baseUrl?;
     private readonly agentId;
@@ -818,9 +851,7 @@ declare class ParlantAdapter extends SimpleAdapter<ParlantMessages, MessagingToo
     private createClient;
 }
 
-interface LettaMessage {
-    role: "user" | "assistant";
-    content: string;
+interface LettaMessage extends ChatTurn {
     sender: string;
     senderType: string;
 }
@@ -922,6 +953,14 @@ interface LettaAdapterOptions {
     systemPrompt?: string;
     customSection?: string;
     includeBaseInstructions?: boolean;
+    /**
+     * Most turns of prior conversation to replay into a new session.
+     * Defaults to 100.  The value is a cap, not a toggle: `0` replays none.
+     *
+     * A reply is never replayed without the question it answers, so the result
+     * can be one turn shorter than the cap - and `1` replays nothing whenever
+     * the newest turn is an answer.
+     */
     maxHistoryMessages?: number;
     emitReasoningEvents?: boolean;
     historyConverter?: LettaHistoryConverter;
@@ -929,6 +968,7 @@ interface LettaAdapterOptions {
     logger?: Logger;
 }
 declare class LettaAdapter extends SimpleAdapter<LettaMessages, AdapterToolsProtocol> {
+    protected readonly provider = "letta";
     private readonly model;
     private readonly lettaApiKey?;
     private readonly lettaBaseUrl?;
@@ -1145,6 +1185,7 @@ interface OpencodeAdapterOptions {
     logger?: Logger;
 }
 declare class OpencodeAdapter extends SimpleAdapter<OpencodeSessionState, AdapterToolsProtocol> {
+    protected readonly provider = "opencode";
     private readonly config;
     private readonly customTools;
     private readonly clientFactory;
@@ -1163,6 +1204,7 @@ declare class OpencodeAdapter extends SimpleAdapter<OpencodeSessionState, Adapte
         isSessionBootstrap: boolean;
         roomId: string;
     }): Promise<void>;
+    private startTurn;
     onCleanup(roomId: string): Promise<void>;
     private getOrCreateRoomState;
     private ensureClientStarted;
@@ -1187,10 +1229,22 @@ declare class OpencodeAdapter extends SimpleAdapter<OpencodeSessionState, Adapte
     private ensureSession;
     private beginTurn;
     private watchTurnCompletion;
+    private handleTurnTimeout;
+    private abortAndAbandonSession;
+    private abandonSession;
+    private handleSessionError;
+    private reportTerminalFailure;
     private releaseTurnWait;
     private finishTurn;
+    private failInteractivePromptDelivery;
     private clearTurnState;
     private emitSessionTaskEvent;
+    /**
+     * "blocked" and "empty" are both a no-op today, but `deliverFallbackText`
+     * needs to tell them apart: only "empty" means the shared guard already
+     * passed, so it's safe to go on and send its own fallback message.
+     */
+    private flushTurnText;
     private deliverFallbackText;
     private reportToolCall;
     private reportToolResult;
@@ -1200,7 +1254,7 @@ declare class OpencodeAdapter extends SimpleAdapter<OpencodeSessionState, Adapte
     private parsePermissionReply;
     private parseQuestionAnswers;
     private formatQuestionPrompt;
-    private formatError;
+    private toAgentFailure;
     private formatOpenCodeError;
 }
 
@@ -1216,6 +1270,7 @@ interface ClaudeSDKMessageLike {
     type: string;
     session_id?: string;
     subtype?: string;
+    is_error?: boolean;
     result?: unknown;
     summary?: string;
     message?: ClaudeAssistantMessage;
@@ -1252,6 +1307,7 @@ interface ClaudeSDKAdapterOptions {
     logger?: Logger;
 }
 declare class ClaudeSDKAdapter extends SimpleAdapter<HistoryProvider, AdapterToolsProtocol> {
+    protected readonly provider = "claude-sdk";
     private readonly model;
     private readonly customSection?;
     private readonly includeBaseInstructions;
@@ -1276,8 +1332,173 @@ declare class ClaudeSDKAdapter extends SimpleAdapter<HistoryProvider, AdapterToo
         roomId: string;
     }): Promise<void>;
     private doMessage;
+    private startQuery;
+    private consumeQueryEvents;
     onCleanup(roomId: string): Promise<void>;
     private reportSessionId;
 }
 
-export { type DynamicToolSpec as $, A2AAdapter as A, OpencodeAdapter as B, CODEX_REASONING_EFFORTS as C, type OpencodeAdapterConfig as D, type OpencodeApprovalMode as E, type OpencodeApprovalReply as F, GeminiAdapter as G, type OpencodeQuestionMode as H, type ParlantAdapterOptions as I, type VercelAISDKAdapterOptions as J, type A2AClientFactory as K, LangGraphAdapter as L, type A2AClientLike as M, type AnthropicClientFactory as N, OpenAIAdapter as O, ParlantAdapter as P, AnthropicToolCallingModel as Q, type AnthropicToolCallingModelOptions as R, type ClaudeSDKQuery as S, type ToolCallingModel as T, type ClaudeSDKQueryParams as U, VercelAISDKAdapter as V, CodexAppServerStdioClient as W, type CodexClientLike as X, CodexJsonRpcError as Y, type DynamicToolCallParams as Z, type DynamicToolCallResponse as _, type A2AAdapterOptions as a, type GeminiClientFactory as a0, GeminiToolCallingModel as a1, type GeminiToolCallingModelOptions as a2, HttpOpencodeClient as a3, type HttpOpencodeClientOptions as a4, HttpStatusError as a5, type LettaAgentCreateParams as a6, type LettaClientFactory as a7, type LettaClientLike as a8, LettaHistoryConverter as a9, type LettaMessage as aa, type LettaMessageCreateParams as ab, type LettaMessages as ac, type LettaRequestOptions as ad, type LettaResponse as ae, type LettaResponseMessage as af, type OpenAIClientFactory as ag, OpenAIToolCallingModel as ah, type OpenAIToolCallingModelOptions as ai, type OpencodeClientLike as aj, type ParlantClientFactory as ak, type ParlantClientLike as al, type ToolCall as am, ToolCallingAdapter as an, type ToolCallingAdapterOptions as ao, type ToolCallingModelRequest as ap, type ToolCallingResponse as aq, type ToolResult as ar, type TurnStartParams as as, VercelAISDKToolCallingModel as at, type VercelAISDKToolCallingModelOptions as au, runSingleToolRound as av, A2AGatewayAdapter as b, AnthropicAdapter as c, type AnthropicAdapterOptions as d, CODEX_REASONING_SUMMARIES as e, CODEX_WEB_SEARCH_MODES as f, type ClaudePermissionMode as g, ClaudeSDKAdapter as h, type ClaudeSDKAdapterOptions as i, CodexAdapter as j, type CodexAdapterConfig as k, type CodexApprovalPolicy as l, type CodexReasoningEffort as m, type CodexReasoningSummary as n, type CodexSandboxMode as o, type CodexWebSearchMode as p, type GeminiAdapterOptions as q, GenericAdapter as r, type GenericAdapterHandler as s, GoogleADKAdapter as t, type GoogleADKAdapterOptions as u, type LangGraphAdapterOptions as v, type LangGraphGraph as w, LettaAdapter as x, type LettaAdapterOptions as y, type OpenAIAdapterOptions as z };
+interface ACPClientConnectionHandle {
+    connection: ClientSideConnection;
+    stop(): Promise<void>;
+}
+type ACPClientConnectionFactory = (client: Client, options: {
+    command: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}) => Promise<ACPClientConnectionHandle>;
+type ACPPermissionRequest = RequestPermissionRequest & {
+    roomId: string;
+};
+type ACPPermissionAbandonReason = "timeout" | "room-closed" | "adapter-stopped" | "connection-lost";
+type ACPPermissionEndReason = ACPPermissionAbandonReason | "settled" | "no-answer";
+
+interface ACPModeRequest {
+    roomId: string;
+    sessionId: string;
+    currentModeId: string;
+    modes: readonly SessionMode[];
+}
+interface ACPModelRequest {
+    roomId: string;
+    sessionId: string;
+    currentModelId: string;
+    models: readonly SessionConfigSelectOption[];
+}
+interface ACPClientAdapterBaseOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    mcpServers?: McpServer[];
+    authMethod?: string | null;
+    enableMemoryTools?: boolean;
+    enableMcpTools?: boolean;
+    additionalMcpTools?: McpToolRegistration[];
+    clientCapabilities?: ClientCapabilities;
+    connectionFactory?: ACPClientConnectionFactory;
+    resolvePermission?: (request: ACPPermissionRequest, signal: AbortSignal) => Promise<string | undefined>;
+    permissionTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    resolveSessionMode?: (request: ACPModeRequest, signal: AbortSignal) => Promise<string | undefined>;
+    resolveSessionModel?: (request: ACPModelRequest, signal: AbortSignal) => Promise<string | undefined>;
+    logger?: Logger;
+}
+interface ACPClientStdioOptions extends ACPClientAdapterBaseOptions {
+    command: string | string[];
+    host?: never;
+    port?: never;
+}
+interface ACPClientTcpOptions extends ACPClientAdapterBaseOptions {
+    command?: never;
+    host: string;
+    port: number;
+}
+type ACPClientAdapterOptions = ACPClientStdioOptions | ACPClientTcpOptions;
+declare class ACPClientAdapter extends SimpleAdapter<ACPClientSessionState, AdapterToolsProtocol> {
+    protected readonly provider: string;
+    private readonly command;
+    private readonly cwd;
+    private readonly env?;
+    private readonly mcpServers;
+    private readonly authMethod?;
+    private readonly enableMemoryTools;
+    private readonly enableMcpTools;
+    private readonly additionalMcpTools;
+    private readonly clientCapabilities?;
+    private readonly connectionFactory?;
+    private readonly tcpEndpoint;
+    private readonly roomToSession;
+    private readonly sessionToRoom;
+    private readonly roomTools;
+    private readonly activeSessions;
+    private readonly bootstrappedSessions;
+    private readonly abandonedSessions;
+    private readonly pendingPermissions;
+    private readonly sessionsInFlight;
+    private readonly roomTurnLocks;
+    private readonly roomGeneration;
+    private readonly resolvePermission?;
+    private readonly resolveSessionMode?;
+    private readonly resolveSessionModel?;
+    private readonly permissionTimeoutMs;
+    private readonly turnTimeoutMs;
+    private readonly logger;
+    private backend;
+    private backendPromise;
+    private client;
+    private connectionHandle;
+    private pendingConnectionStop;
+    private connection;
+    private connectionState;
+    private started;
+    private systemPrompt;
+    private spawnPromise;
+    private connectionGeneration;
+    constructor(options: ACPClientAdapterOptions);
+    onStarted(agentName: string, agentDescription: string): Promise<void>;
+    onMessage(message: PlatformMessage, tools: AdapterToolsProtocol, history: ACPClientSessionState, participantsMessage: string | null, contactsMessage: string | null, context: {
+        isSessionBootstrap: boolean;
+        roomId: string;
+    }): Promise<void>;
+    private runTurn;
+    private abandonTimedOutTurn;
+    private withRoomTurnLock;
+    onCleanup(roomId: string): Promise<void>;
+    onRuntimeStop(): Promise<void>;
+    stop(): Promise<void>;
+    private rehydrate;
+    private linkSession;
+    private nextRoomGeneration;
+    private isCurrentGeneration;
+    private raceAgainstConnectionClose;
+    private unlinkRoom;
+    private unlinkOwner;
+    private sessionKey;
+    private ensureConnection;
+    private spawnConnection;
+    private getOrCreateSession;
+    private establishSession;
+    private linkOrAbandon;
+    private configureSessionMode;
+    private configureSessionModel;
+    private resolveManualSelection;
+    private tryRestoreSession;
+    private buildSessionMcpServers;
+    private getOrCreateBackend;
+    private createBackend;
+    private buildSystemContext;
+    private routePermissionRequest;
+    private handlePermissionRequest;
+    private toResponse;
+    private safeWarn;
+    private resolveManually;
+    private discardLateAnswer;
+    private abandon;
+    private trackPending;
+    private untrackPending;
+    private cancelPendingPermissions;
+    private cancelAllPendingPermissions;
+    private pruneConnectionGeneration;
+    private flushChunks;
+}
+
+declare const DEFAULT_OMP_ACP_COMMAND: readonly ["omp", "acp"];
+interface OmpACPAdapterOptions extends Omit<ACPClientStdioOptions, "command"> {
+    command?: string | string[];
+}
+declare class OmpACPAdapter extends ACPClientAdapter {
+    protected readonly provider = "omp-acp";
+    constructor(options?: OmpACPAdapterOptions);
+}
+
+declare const DEFAULT_COPILOT_ACP_COMMAND: readonly ["copilot", "--acp", "--stdio"];
+interface CopilotACPStdioOptions extends Omit<ACPClientStdioOptions, "command"> {
+    command?: string | string[];
+}
+type CopilotACPTcpOptions = ACPClientTcpOptions;
+type CopilotACPAdapterOptions = CopilotACPStdioOptions | CopilotACPTcpOptions;
+declare class CopilotACPAdapter extends ACPClientAdapter {
+    protected readonly provider = "copilot-acp";
+    constructor(options?: CopilotACPAdapterOptions);
+}
+
+export { type VercelAISDKAdapterOptions as $, A2AAdapter as A, type GeminiAdapterOptions as B, CODEX_REASONING_EFFORTS as C, DEFAULT_COPILOT_ACP_COMMAND as D, GenericAdapter as E, type GenericAdapterHandler as F, GeminiAdapter as G, GoogleADKAdapter as H, type GoogleADKAdapterOptions as I, type LangGraphAdapterOptions as J, type LangGraphGraph as K, LangGraphAdapter as L, LettaAdapter as M, type LettaAdapterOptions as N, OmpACPAdapter as O, type OmpACPAdapterOptions as P, OpenAIAdapter as Q, type OpenAIAdapterOptions as R, OpencodeAdapter as S, type OpencodeAdapterConfig as T, type OpencodeApprovalMode as U, type OpencodeApprovalReply as V, type OpencodeQuestionMode as W, ParlantAdapter as X, type ParlantAdapterOptions as Y, type ToolCallingModel as Z, VercelAISDKAdapter as _, type A2AAdapterOptions as a, type A2AClientFactory as a0, type A2AClientLike as a1, type ACPPermissionAbandonReason as a2, type ACPPermissionEndReason as a3, type ACPPermissionRequest as a4, type AnthropicClientFactory as a5, AnthropicToolCallingModel as a6, type AnthropicToolCallingModelOptions as a7, type ClaudeSDKQuery as a8, type ClaudeSDKQueryParams as a9, type ParlantClientFactory as aA, type ParlantClientLike as aB, type ToolCall as aC, ToolCallingAdapter as aD, type ToolCallingAdapterOptions as aE, type ToolCallingModelRequest as aF, type ToolCallingResponse as aG, type ToolResult as aH, type TurnStartParams as aI, VercelAISDKToolCallingModel as aJ, type VercelAISDKToolCallingModelOptions as aK, runSingleToolRound as aL, CodexAppServerStdioClient as aa, type CodexClientLike as ab, CodexJsonRpcError as ac, type DynamicToolCallParams as ad, type DynamicToolCallResponse as ae, type DynamicToolSpec as af, type GeminiClientFactory as ag, GeminiToolCallingModel as ah, type GeminiToolCallingModelOptions as ai, HttpOpencodeClient as aj, type HttpOpencodeClientOptions as ak, HttpStatusError as al, type LettaAgentCreateParams as am, type LettaClientFactory as an, type LettaClientLike as ao, LettaHistoryConverter as ap, type LettaMessage as aq, type LettaMessageCreateParams as ar, type LettaMessages as as, type LettaRequestOptions as at, type LettaResponse as au, type LettaResponseMessage as av, type OpenAIClientFactory as aw, OpenAIToolCallingModel as ax, type OpenAIToolCallingModelOptions as ay, type OpencodeClientLike as az, A2AGatewayAdapter as b, ACPClientAdapter as c, type ACPClientAdapterBaseOptions as d, type ACPClientAdapterOptions as e, type ACPClientStdioOptions as f, type ACPClientTcpOptions as g, AnthropicAdapter as h, type AnthropicAdapterOptions as i, CODEX_REASONING_SUMMARIES as j, CODEX_WEB_SEARCH_MODES as k, type ClaudePermissionMode as l, ClaudeSDKAdapter as m, type ClaudeSDKAdapterOptions as n, CodexAdapter as o, type CodexAdapterConfig as p, type CodexApprovalPolicy as q, type CodexReasoningEffort as r, type CodexReasoningSummary as s, type CodexSandboxMode as t, type CodexWebSearchMode as u, CopilotACPAdapter as v, type CopilotACPAdapterOptions as w, type CopilotACPStdioOptions as x, type CopilotACPTcpOptions as y, DEFAULT_OMP_ACP_COMMAND as z };