@band-ai/sdk 0.3.4 → 0.4.1

package/dist/{ClaudeSDKAdapter-Cx6zhSaG.d.cts → CopilotACPAdapter-Clid9xGR.d.cts}

@@ -1,12 +1,13 @@
-import { S as SimpleAdapter } from './simpleAdapter-BpT4XbZC.cjs';
-import { A as AdapterToolsProtocol, a as AgentToolsProtocol, c as MessagingTools, T as ToolExecutor, f as ToolSchemaProvider, H as HistoryConverter } from './protocols-Bz1rxcUg.cjs';
-import { H as HistoryProvider, P as PlatformMessage } from './types-BNNtOXu3.cjs';
+import { S as SimpleAdapter } from './simpleAdapter-D75rcz9n.cjs';
+import { A as AdapterToolsProtocol, b as AgentToolsProtocol, e as MessagingTools, T as ToolExecutor, i as ToolSchemaProvider, H as HistoryConverter } from './protocols-CabgO52c.cjs';
+import { H as HistoryProvider, P as PlatformMessage } from './types-DtcOLALn.cjs';
 import { L as Logger } from './logger-CABQOnlR.cjs';
-import { C as CustomToolDef } from './customTools-BzF0IISO.cjs';
-import { m as ToolModelMessage, n as ToolModelSchema, M as MetadataMap } from './dtos-B8KU_q4d.cjs';
-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-2YdscIc1.cjs';
-import { c as createBandMcpBackend } from './backends-ZLxmQrTZ.cjs';
-import { M as McpToolRegistration } from './sdk-BTciSLRQ.cjs';
+import { C as CustomToolDef } from './customTools-Bfecd0mJ.cjs';
+import { m as ToolModelMessage, n as ToolModelSchema, M as MetadataMap } from './dtos-CjQsN1_h.cjs';
+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-D-I_5lK-.cjs';
+import { c as createBandMcpBackend } from './backends-Dh2WXcHQ.cjs';
+import { M as McpToolRegistration } from './sdk-CXNqzoY1.cjs';
+import { Client, ClientSideConnection, RequestPermissionRequest, McpServer, ClientCapabilities, SessionMode, SessionConfigOption, 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,182 @@ 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 ACPConfigRequest {
+    roomId: string;
+    sessionId: string;
+    configOptions: readonly SessionConfigOption[];
+}
+type ACPConfigSelections = Readonly<Record<string, string | undefined>>;
+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>;
+    resolveSessionConfig?: (request: ACPConfigRequest, signal: AbortSignal) => Promise<ACPConfigSelections | 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 resolveSessionConfig?;
+    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 configureSessionConfig;
+    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 ToolCallingModel as $, A2AAdapter as A, type CopilotACPTcpOptions as B, CODEX_REASONING_EFFORTS as C, DEFAULT_COPILOT_ACP_COMMAND as D, DEFAULT_OMP_ACP_COMMAND as E, type GeminiAdapterOptions as F, GeminiAdapter as G, GenericAdapter as H, type GenericAdapterHandler as I, GoogleADKAdapter as J, type GoogleADKAdapterOptions as K, LangGraphAdapter as L, type LangGraphAdapterOptions as M, type LangGraphGraph as N, LettaAdapter as O, type LettaAdapterOptions as P, OmpACPAdapter as Q, type OmpACPAdapterOptions as R, OpenAIAdapter as S, type OpenAIAdapterOptions as T, OpencodeAdapter as U, type OpencodeAdapterConfig as V, type OpencodeApprovalMode as W, type OpencodeApprovalReply as X, type OpencodeQuestionMode as Y, ParlantAdapter as Z, type ParlantAdapterOptions as _, type A2AAdapterOptions as a, VercelAISDKAdapter as a0, type VercelAISDKAdapterOptions as a1, type A2AClientFactory as a2, type A2AClientLike as a3, type ACPPermissionAbandonReason as a4, type ACPPermissionEndReason as a5, type ACPPermissionRequest as a6, type AnthropicClientFactory as a7, AnthropicToolCallingModel as a8, type AnthropicToolCallingModelOptions as a9, type OpenAIToolCallingModelOptions as aA, type OpencodeClientLike as aB, type ParlantClientFactory as aC, type ParlantClientLike as aD, type ToolCall as aE, ToolCallingAdapter as aF, type ToolCallingAdapterOptions as aG, type ToolCallingModelRequest as aH, type ToolCallingResponse as aI, type ToolResult as aJ, type TurnStartParams as aK, VercelAISDKToolCallingModel as aL, type VercelAISDKToolCallingModelOptions as aM, runSingleToolRound as aN, type ClaudeSDKQuery as aa, type ClaudeSDKQueryParams as ab, CodexAppServerStdioClient as ac, type CodexClientLike as ad, CodexJsonRpcError as ae, type DynamicToolCallParams as af, type DynamicToolCallResponse as ag, type DynamicToolSpec as ah, type GeminiClientFactory as ai, GeminiToolCallingModel as aj, type GeminiToolCallingModelOptions as ak, HttpOpencodeClient as al, type HttpOpencodeClientOptions as am, HttpStatusError as an, type LettaAgentCreateParams as ao, type LettaClientFactory as ap, type LettaClientLike as aq, LettaHistoryConverter as ar, type LettaMessage as as, type LettaMessageCreateParams as at, type LettaMessages as au, type LettaRequestOptions as av, type LettaResponse as aw, type LettaResponseMessage as ax, type OpenAIClientFactory as ay, OpenAIToolCallingModel as az, A2AGatewayAdapter as b, ACPClientAdapter as c, type ACPClientAdapterBaseOptions as d, type ACPClientAdapterOptions as e, type ACPClientStdioOptions as f, type ACPClientTcpOptions as g, type ACPConfigRequest as h, type ACPConfigSelections as i, AnthropicAdapter as j, type AnthropicAdapterOptions as k, CODEX_REASONING_SUMMARIES as l, CODEX_WEB_SEARCH_MODES as m, type ClaudePermissionMode as n, ClaudeSDKAdapter as o, type ClaudeSDKAdapterOptions as p, CodexAdapter as q, type CodexAdapterConfig as r, type CodexApprovalPolicy as s, type CodexReasoningEffort as t, type CodexReasoningSummary as u, type CodexSandboxMode as v, type CodexWebSearchMode as w, CopilotACPAdapter as x, type CopilotACPAdapterOptions as y, type CopilotACPStdioOptions as z };

package/dist/{opencode-2YdscIc1.d.cts → acp-client-D-I_5lK-.d.cts}

@@ -1,5 +1,6 @@
-import { H as HistoryConverter } from './protocols-Bz1rxcUg.cjs';
-import { R as RestApi } from './types-BgYFd_Yw.cjs';
+import { H as HistoryConverter } from './protocols-CabgO52c.cjs';
+import { R as RestApi } from './types-42-HWeX8.cjs';
+import { L as Logger } from './logger-CABQOnlR.cjs';
 
 interface GoogleADKMessage {
     role: "user" | "model";
@@ -118,6 +119,7 @@ interface GatewayServerOptions {
     onRequest: (request: GatewayRequest) => AsyncIterable<GatewayA2AStatusUpdateEvent>;
     onCancel?: (request: GatewayCancelRequest) => Promise<void>;
     loadModules?: () => Promise<unknown>;
+    logger?: Logger;
 }
 type GatewayServerFactory = (options: GatewayServerOptions) => GatewayServerLike;
 interface A2AGatewayAdapterOptions {
@@ -131,11 +133,21 @@ interface A2AGatewayAdapterOptions {
     peerPageSize?: number;
     maxPeerPages?: number;
     serverFactory?: GatewayServerFactory;
+    logger?: Logger;
 }
 
-interface ParlantMessage {
+interface ChatTurn {
     role: "user" | "assistant";
     content: string;
+    /**
+     * Display name of whoever produced the turn.  Optional so a caller with no
+     * notion of per-turn identity still satisfies the constraint; both adapter
+     * message types supply it.
+     */
+    sender?: string;
+}
+
+interface ParlantMessage extends ChatTurn {
     sender: string;
     senderType: string;
 }
@@ -156,4 +168,11 @@ declare class OpencodeHistoryConverter {
 }
 declare function extractOpencodeSessionId(raw: Array<Record<string, unknown>>): string | null;
 
-export { type A2AAuth as A, type GatewaySessionState as G, OpencodeHistoryConverter as O, ParlantHistoryConverter as P, type A2AGatewayAdapterOptions as a, type GatewayServerLike as b, type GatewayServerOptions as c, A2AHistoryConverter as d, type A2ASessionState as e, type GatewayA2AMessage as f, type GatewayA2AStatusUpdateEvent as g, type GatewayCancelRequest as h, type GatewayPeer as i, type GatewayRequest as j, type GatewayServerFactory as k, type GatewayTaskState as l, type ParlantMessage as m, type ParlantMessages as n, type PendingA2ATask as o, buildA2AAuthHeaders as p, GoogleADKHistoryConverter as q, type GoogleADKMessage as r, type GoogleADKMessages as s, type OpencodeSessionState as t, extractGoogleAdkSessionId as u, extractOpencodeSessionId as v };
+interface ACPClientSessionState {
+    roomToSession: Record<string, string>;
+}
+declare class ACPClientHistoryConverter implements HistoryConverter<ACPClientSessionState> {
+    convert(raw: Array<Record<string, unknown>>): ACPClientSessionState;
+}
+
+export { type A2AAuth as A, type ChatTurn as C, type GatewaySessionState as G, OpencodeHistoryConverter as O, ParlantHistoryConverter as P, type A2AGatewayAdapterOptions as a, type GatewayServerLike as b, type GatewayServerOptions as c, A2AHistoryConverter as d, type A2ASessionState as e, type GatewayA2AMessage as f, type GatewayA2AStatusUpdateEvent as g, type GatewayCancelRequest as h, type GatewayPeer as i, type GatewayRequest as j, type GatewayServerFactory as k, type GatewayTaskState as l, type ParlantMessage as m, type ParlantMessages as n, type PendingA2ATask as o, buildA2AAuthHeaders as p, ACPClientHistoryConverter as q, type ACPClientSessionState as r, GoogleADKHistoryConverter as s, type GoogleADKMessage as t, type GoogleADKMessages as u, type OpencodeSessionState as v, extractGoogleAdkSessionId as w, extractOpencodeSessionId as x };

package/dist/{opencode-Bld62x5t.d.ts → acp-client-DUXyczlF.d.ts}

@@ -1,5 +1,6 @@
-import { H as HistoryConverter } from './protocols-Bwwcql0h.js';
-import { R as RestApi } from './types-BivGO7I9.js';
+import { H as HistoryConverter } from './protocols-Dpci6uae.js';
+import { R as RestApi } from './types-CjxZekMH.js';
+import { L as Logger } from './logger-CABQOnlR.js';
 
 interface GoogleADKMessage {
     role: "user" | "model";
@@ -118,6 +119,7 @@ interface GatewayServerOptions {
     onRequest: (request: GatewayRequest) => AsyncIterable<GatewayA2AStatusUpdateEvent>;
     onCancel?: (request: GatewayCancelRequest) => Promise<void>;
     loadModules?: () => Promise<unknown>;
+    logger?: Logger;
 }
 type GatewayServerFactory = (options: GatewayServerOptions) => GatewayServerLike;
 interface A2AGatewayAdapterOptions {
@@ -131,11 +133,21 @@ interface A2AGatewayAdapterOptions {
     peerPageSize?: number;
     maxPeerPages?: number;
     serverFactory?: GatewayServerFactory;
+    logger?: Logger;
 }
 
-interface ParlantMessage {
+interface ChatTurn {
     role: "user" | "assistant";
     content: string;
+    /**
+     * Display name of whoever produced the turn.  Optional so a caller with no
+     * notion of per-turn identity still satisfies the constraint; both adapter
+     * message types supply it.
+     */
+    sender?: string;
+}
+
+interface ParlantMessage extends ChatTurn {
     sender: string;
     senderType: string;
 }
@@ -156,4 +168,11 @@ declare class OpencodeHistoryConverter {
 }
 declare function extractOpencodeSessionId(raw: Array<Record<string, unknown>>): string | null;
 
-export { type A2AAuth as A, type GatewaySessionState as G, OpencodeHistoryConverter as O, ParlantHistoryConverter as P, type A2AGatewayAdapterOptions as a, type GatewayServerLike as b, type GatewayServerOptions as c, A2AHistoryConverter as d, type A2ASessionState as e, type GatewayA2AMessage as f, type GatewayA2AStatusUpdateEvent as g, type GatewayCancelRequest as h, type GatewayPeer as i, type GatewayRequest as j, type GatewayServerFactory as k, type GatewayTaskState as l, type ParlantMessage as m, type ParlantMessages as n, type PendingA2ATask as o, buildA2AAuthHeaders as p, GoogleADKHistoryConverter as q, type GoogleADKMessage as r, type GoogleADKMessages as s, type OpencodeSessionState as t, extractGoogleAdkSessionId as u, extractOpencodeSessionId as v };
+interface ACPClientSessionState {
+    roomToSession: Record<string, string>;
+}
+declare class ACPClientHistoryConverter implements HistoryConverter<ACPClientSessionState> {
+    convert(raw: Array<Record<string, unknown>>): ACPClientSessionState;
+}
+
+export { type A2AAuth as A, type ChatTurn as C, type GatewaySessionState as G, OpencodeHistoryConverter as O, ParlantHistoryConverter as P, type A2AGatewayAdapterOptions as a, type GatewayServerLike as b, type GatewayServerOptions as c, A2AHistoryConverter as d, type A2ASessionState as e, type GatewayA2AMessage as f, type GatewayA2AStatusUpdateEvent as g, type GatewayCancelRequest as h, type GatewayPeer as i, type GatewayRequest as j, type GatewayServerFactory as k, type GatewayTaskState as l, type ParlantMessage as m, type ParlantMessages as n, type PendingA2ATask as o, buildA2AAuthHeaders as p, ACPClientHistoryConverter as q, type ACPClientSessionState as r, GoogleADKHistoryConverter as s, type GoogleADKMessage as t, type GoogleADKMessages as u, type OpencodeSessionState as v, extractGoogleAdkSessionId as w, extractOpencodeSessionId as x };

package/dist/acp-server-BlcYMxKt.d.ts

@@ -0,0 +1,17 @@
+import { H as HistoryConverter } from './protocols-Dpci6uae.js';
+import { G as GatewaySessionState } from './acp-client-DUXyczlF.js';
+
+declare class GatewayHistoryConverter implements HistoryConverter<GatewaySessionState> {
+    convert(raw: Array<Record<string, unknown>>): GatewaySessionState;
+}
+
+interface ACPServerSessionState {
+    sessionToRoom: Record<string, string>;
+    sessionCwd: Record<string, string>;
+    sessionMcpServers: Record<string, Array<Record<string, unknown>>>;
+}
+declare class ACPServerHistoryConverter implements HistoryConverter<ACPServerSessionState> {
+    convert(raw: Array<Record<string, unknown>>): ACPServerSessionState;
+}
+
+export { type ACPServerSessionState as A, GatewayHistoryConverter as G, ACPServerHistoryConverter as a };

package/dist/acp-server-CJhclo6P.d.cts

@@ -0,0 +1,17 @@
+import { H as HistoryConverter } from './protocols-CabgO52c.cjs';
+import { G as GatewaySessionState } from './acp-client-D-I_5lK-.cjs';
+
+declare class GatewayHistoryConverter implements HistoryConverter<GatewaySessionState> {
+    convert(raw: Array<Record<string, unknown>>): GatewaySessionState;
+}
+
+interface ACPServerSessionState {
+    sessionToRoom: Record<string, string>;
+    sessionCwd: Record<string, string>;
+    sessionMcpServers: Record<string, Array<Record<string, unknown>>>;
+}
+declare class ACPServerHistoryConverter implements HistoryConverter<ACPServerSessionState> {
+    convert(raw: Array<Record<string, unknown>>): ACPServerSessionState;
+}
+
+export { type ACPServerSessionState as A, GatewayHistoryConverter as G, ACPServerHistoryConverter as a };