@band-ai/sdk 0.3.4 → 0.4.1

package/dist/adapters.js

@@ -1,6 +1,9 @@
 import {
+  ACPClientAdapter,
+  ACPServer,
   AnthropicAdapter,
   AnthropicToolCallingModel,
+  BandACPServerAdapter,
   CODEX_REASONING_EFFORTS,
   CODEX_REASONING_SUMMARIES,
   CODEX_WEB_SEARCH_MODES,
@@ -8,6 +11,9 @@ import {
   CodexAdapter,
   CodexAppServerStdioClient,
   CodexJsonRpcError,
+  CopilotACPAdapter,
+  DEFAULT_COPILOT_ACP_COMMAND,
+  DEFAULT_OMP_ACP_COMMAND,
   GeminiAdapter,
   GeminiToolCallingModel,
   GenericAdapter,
@@ -17,1943 +23,37 @@ import {
   LangGraphAdapter,
   LettaAdapter,
   LettaHistoryConverter,
+  OmpACPAdapter,
   OpenAIAdapter,
   OpenAIToolCallingModel,
   OpencodeAdapter,
   ToolCallingAdapter,
   VercelAISDKAdapter,
   VercelAISDKToolCallingModel,
-  runSingleToolRound,
-  systemUpdateParts
-} from "./chunk-MQBBWYRP.js";
-import {
-  BandMcpServer,
-  BandMcpSseServer,
-  generateAuthToken
-} from "./chunk-WA7CHXUS.js";
-import "./chunk-XWHWJP4I.js";
-import {
-  ACPClientHistoryConverter,
-  ACPServerHistoryConverter
-} from "./chunk-V5TSWS7P.js";
+  runSingleToolRound
+} from "./chunk-UFO6XMCV.js";
+import "./chunk-UL3Y5C4J.js";
+import "./chunk-JDW5WSGF.js";
 import {
   A2AAdapter,
   A2AGatewayAdapter,
   A2AHistoryConverter,
   GatewayHistoryConverter,
   GatewayServer,
-  LazyAsyncValue,
   ParlantAdapter,
   ParlantHistoryConverter,
   buildA2AAuthHeaders,
-  createGatewayServer,
-  parseToolCall,
-  parseToolResult
-} from "./chunk-K5KAEYPF.js";
-import {
-  SimpleAdapter
-} from "./chunk-AVVDPXP4.js";
-import {
-  ensureHandlePrefix,
-  mentionSubjectsFromMetadata,
-  replaceUuidMentions
-} from "./chunk-OH6VVVKT.js";
-import {
-  renderSystemPrompt
-} from "./chunk-YJ42AZO4.js";
-import {
-  MCP_SERVER_NAME
-} from "./chunk-MQY74R7D.js";
-import {
-  isBlankEventContent
-} from "./chunk-F63TPOI3.js";
-import "./chunk-KXJ74J73.js";
-import "./chunk-JADCAMZY.js";
-import {
-  NoopLogger
-} from "./chunk-OD2G5LFQ.js";
-import {
-  UnsupportedFeatureError,
-  ValidationError
-} from "./chunk-JY75VSQK.js";
-
-// src/adapters/acp/ACPClientAdapter.ts
-import { spawn } from "child_process";
-import { Readable, Writable } from "stream";
-
-// src/adapters/shared/withTimeout.ts
-async function withTimeout(promise, timeoutMs, message) {
-  let timer;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-      })
-    ]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// src/adapters/acp/types.ts
-var DEFAULT_ACP_SERVER_MODES = [
-  {
-    id: "default",
-    name: "Default",
-    description: "General-purpose chat mode"
-  },
-  {
-    id: "code",
-    name: "Code",
-    description: "Route prompts toward coding peers when available"
-  }
-];
-function createPendingPrompt(sessionId) {
-  let markDone = () => void 0;
-  const done = new Promise((resolve) => {
-    markDone = resolve;
-  });
-  return {
-    sessionId,
-    done,
-    markDone,
-    terminalMessageSeen: false,
-    completionTimer: null
-  };
-}
-function choosePermissionOption(options) {
-  if (options.length === 0) {
-    return null;
-  }
-  return options.find((option) => option.kind === "allow_once") ?? options.find((option) => option.kind === "allow_always") ?? options[0];
-}
-function asJsonSafe(value) {
-  if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => asJsonSafe(item));
-  }
-  if (typeof value === "object") {
-    if ("model_dump" in value && typeof value.model_dump === "function") {
-      return asJsonSafe(value.model_dump());
-    }
-    if ("toJSON" in value && typeof value.toJSON === "function") {
-      return asJsonSafe(value.toJSON());
-    }
-    return Object.fromEntries(
-      Object.entries(value).map(([key, item]) => [key, asJsonSafe(item)])
-    );
-  }
-  return String(value);
-}
-function normalizeMcpServers(mcpServers) {
-  if (!mcpServers) {
-    return [];
-  }
-  return mcpServers.map((server) => asJsonSafe(server)).filter((server) => !!server && typeof server === "object" && !Array.isArray(server));
-}
-
-// src/adapters/acp/client.ts
-var BandACPClient = class {
-  sessionChunks = /* @__PURE__ */ new Map();
-  permissionHandler;
-  // The handler is connection-scoped and required at construction, so it is
-  // already in place before the agent process is spawned: there is no window
-  // in which a `session/request_permission` has nowhere to go.
-  constructor(permissionHandler) {
-    this.permissionHandler = permissionHandler;
-  }
-  async sessionUpdate(params) {
-    const chunk = toCollectedChunk(params.update);
-    if (!chunk) {
-      return;
-    }
-    const existing = this.sessionChunks.get(params.sessionId) ?? [];
-    existing.push(chunk);
-    this.sessionChunks.set(params.sessionId, existing);
-  }
-  async requestPermission(params) {
-    return this.permissionHandler(params);
-  }
-  // Named for the one thing it clears: collected chunks are per-turn, and a
-  // per-turn caller must not be able to reach anything with a longer life.
-  resetChunks(sessionId) {
-    this.sessionChunks.delete(sessionId);
-  }
-  getCollectedText(sessionId) {
-    return this.getCollectedChunks(sessionId).filter((chunk) => chunk.chunkType === "text").map((chunk) => chunk.content).join("");
-  }
-  getCollectedChunks(sessionId) {
-    if (sessionId) {
-      return coalesceChunks(this.sessionChunks.get(sessionId) ?? []);
-    }
-    return [...this.sessionChunks.values()].flatMap((chunks) => coalesceChunks(chunks));
-  }
-  async extMethod(method, params) {
-    if (method === "cursor/ask_question") {
-      const options = Array.isArray(params.options) ? params.options : [];
-      const selected = choosePermissionOption(
-        options.filter((option) => !!option && typeof option === "object")
-      );
-      if (!selected) {
-        return {
-          outcome: {
-            type: "cancelled"
-          }
-        };
-      }
-      return {
-        outcome: {
-          type: "selected",
-          optionId: selected.optionId
-        }
-      };
-    }
-    if (method === "cursor/create_plan") {
-      return {
-        outcome: {
-          type: "approved"
-        }
-      };
-    }
-    return {};
-  }
-  async extNotification(method, params) {
-    const sessionId = toOptionalString(params.sessionId) ?? toOptionalString(params.session_id);
-    if (!sessionId) {
-      return;
-    }
-    if (method === "cursor/update_todos") {
-      const todos = Array.isArray(params.todos) ? params.todos : [];
-      const lines = todos.filter((todo) => !!todo && typeof todo === "object").map((todo) => `- [${todo.completed === true ? "x" : " "}] ${String(todo.content ?? "")}`).filter((line) => line.trim().length > 0);
-      if (lines.length > 0) {
-        this.appendChunk(sessionId, {
-          chunkType: "plan",
-          content: lines.join("\n"),
-          metadata: {},
-          streamed: false
-        });
-      }
-      return;
-    }
-    if (method === "cursor/task") {
-      const result = toOptionalString(params.result);
-      if (result) {
-        this.appendChunk(sessionId, {
-          chunkType: "text",
-          content: `[Task completed] ${result}`,
-          metadata: {},
-          streamed: false
-        });
-      }
-    }
-  }
-  appendChunk(sessionId, chunk) {
-    const existing = this.sessionChunks.get(sessionId) ?? [];
-    existing.push(chunk);
-    this.sessionChunks.set(sessionId, existing);
-  }
-};
-function coalesceChunks(chunks) {
-  const result = [];
-  const openRuns = /* @__PURE__ */ new Map();
-  for (const chunk of chunks) {
-    if (!chunk.streamed) {
-      openRuns.clear();
-      result.push({ ...chunk });
-      continue;
-    }
-    const openRun = openRuns.get(chunk.chunkType);
-    if (openRun) {
-      openRun.content += chunk.content;
-      continue;
-    }
-    const clone = { ...chunk };
-    openRuns.set(chunk.chunkType, clone);
-    result.push(clone);
-  }
-  return result;
-}
-function toCollectedChunk(update) {
-  switch (update.sessionUpdate) {
-    case "agent_message_chunk":
-      return {
-        chunkType: "text",
-        content: extractTextFromContent(update.content),
-        metadata: {},
-        streamed: true
-      };
-    case "agent_thought_chunk":
-      return {
-        chunkType: "thought",
-        content: extractTextFromContent(update.content),
-        metadata: {},
-        streamed: true
-      };
-    case "tool_call":
-      return {
-        chunkType: "tool_call",
-        content: update.title,
-        metadata: {
-          tool_call_id: update.toolCallId,
-          raw_input: update.rawInput,
-          status: update.status ?? "pending"
-        },
-        streamed: false
-      };
-    case "tool_call_update":
-      return {
-        chunkType: "tool_result",
-        content: extractToolOutput(update),
-        metadata: {
-          tool_call_id: update.toolCallId,
-          status: update.status ?? "completed"
-        },
-        streamed: false
-      };
-    case "plan":
-      return {
-        chunkType: "plan",
-        content: update.entries.map((entry) => entry.content).join("\n"),
-        metadata: {},
-        streamed: false
-      };
-    default:
-      return null;
-  }
-}
-function extractToolOutput(update) {
-  if (typeof update.rawOutput === "string") {
-    return update.rawOutput;
-  }
-  if (update.rawOutput !== void 0 && update.rawOutput !== null) {
-    try {
-      return JSON.stringify(update.rawOutput);
-    } catch {
-      return String(update.rawOutput);
-    }
-  }
-  const parts = (update.content ?? []).map(extractTextFromToolContent).filter((text) => text.length > 0);
-  return parts.join("\n");
-}
-function extractTextFromToolContent(content) {
-  if (content.type === "content") {
-    return extractTextFromContent(content.content);
-  }
-  if (content.type === "diff") {
-    return content.newText;
-  }
-  if (content.type === "terminal") {
-    return `[Terminal: ${content.terminalId}]`;
-  }
-  return "";
-}
-function extractTextFromContent(content) {
-  switch (content.type) {
-    case "text":
-      return content.text;
-    case "resource_link":
-      return `[Resource: ${content.title ?? content.name ?? content.uri}]`;
-    case "resource": {
-      const resource = content.resource;
-      if ("text" in resource && typeof resource.text === "string") {
-        return resource.text;
-      }
-      return `[Resource: ${resource.uri ?? "embedded"}]`;
-    }
-    case "image":
-      return `[Image: ${content.mimeType ?? "image"}]`;
-    case "audio":
-      return `[Audio: ${content.mimeType ?? "audio"}]`;
-    default:
-      return "";
-  }
-}
-function toOptionalString(value) {
-  return typeof value === "string" && value.length > 0 ? value : null;
-}
-
-// src/adapters/acp/loader.ts
-var acpModule = new LazyAsyncValue({
-  load: async () => {
-    return await import("@agentclientprotocol/sdk").catch((error) => {
-      throw new UnsupportedFeatureError(
-        `ACP adapters require optional dependency "@agentclientprotocol/sdk". Install it with "pnpm add @agentclientprotocol/sdk". (${error instanceof Error ? error.message : String(error)})`
-      );
-    });
-  }
-});
-
-// src/adapters/acp/ACPClientAdapter.ts
-var DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 6e4;
-var SET_SESSION_MODE_TIMEOUT_MS = 1e4;
-var ACPClientAdapter = class extends SimpleAdapter {
-  command;
-  cwd;
-  env;
-  mcpServers;
-  authMethod;
-  enableMemoryTools;
-  enableMcpTools;
-  additionalMcpTools;
-  clientCapabilities;
-  connectionFactory;
-  roomToSession = /* @__PURE__ */ new Map();
-  sessionToRoom = /* @__PURE__ */ new Map();
-  roomTools = /* @__PURE__ */ new Map();
-  activeSessions = /* @__PURE__ */ new Set();
-  bootstrappedSessions = /* @__PURE__ */ new Set();
-  pendingPermissions = /* @__PURE__ */ new Map();
-  sessionsInFlight = /* @__PURE__ */ new Map();
-  roomTurnLocks = /* @__PURE__ */ new Map();
-  // Bumped each time a room starts a *new* establishment (never on a
-  // coalesced reuse) and whenever a room is torn down. An establishment
-  // captures its own value at the start; if the room has moved on by the
-  // time it would link/activate a session, it was superseded and must not.
-  roomGeneration = /* @__PURE__ */ new Map();
-  resolvePermission;
-  resolveSessionMode;
-  permissionTimeoutMs;
-  logger;
-  backend = null;
-  backendPromise = null;
-  client = null;
-  connectionHandle = null;
-  connection = null;
-  connectionState = null;
-  started = false;
-  systemPrompt = "";
-  spawnPromise = null;
-  constructor(options) {
-    super({
-      historyConverter: new ACPClientHistoryConverter()
-    });
-    this.command = Array.isArray(options.command) ? [...options.command] : [options.command];
-    if (this.command.length === 0 || this.command[0].length === 0) {
-      throw new Error("ACPClientAdapter requires a command");
-    }
-    this.cwd = options.cwd ?? process.cwd();
-    this.env = options.env;
-    this.mcpServers = [...options.mcpServers ?? []];
-    this.authMethod = options.authMethod;
-    this.enableMemoryTools = options.enableMemoryTools ?? false;
-    this.enableMcpTools = options.enableMcpTools ?? true;
-    this.additionalMcpTools = [...options.additionalMcpTools ?? []];
-    this.clientCapabilities = options.clientCapabilities;
-    this.connectionFactory = options.connectionFactory ?? createSubprocessConnection;
-    this.resolvePermission = options.resolvePermission;
-    this.resolveSessionMode = options.resolveSessionMode;
-    this.logger = options.logger ?? new NoopLogger();
-    this.permissionTimeoutMs = options.permissionTimeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
-    if ((this.resolvePermission || this.resolveSessionMode) && (!Number.isFinite(this.permissionTimeoutMs) || this.permissionTimeoutMs <= 0)) {
-      throw new ValidationError(`permissionTimeoutMs must be a positive finite number, got ${options.permissionTimeoutMs}`);
-    }
-  }
-  async onStarted(agentName, agentDescription) {
-    await super.onStarted(agentName, agentDescription);
-    this.started = true;
-    this.systemPrompt = renderSystemPrompt({
-      agentName,
-      agentDescription,
-      includeBaseInstructions: false
-    });
-    await this.ensureConnection();
-  }
-  async onMessage(message, tools, history, participantsMessage, contactsMessage, context) {
-    if (context.isSessionBootstrap) {
-      this.rehydrate(history);
-    }
-    this.roomTools.set(context.roomId, tools);
-    await this.withRoomTurnLock(context.roomId, () => this.runTurn(message, tools, participantsMessage, contactsMessage, context));
-  }
-  async runTurn(message, tools, participantsMessage, contactsMessage, context) {
-    const connection = await this.ensureConnection();
-    const client = this.client;
-    if (!client) {
-      throw new Error("ACP client was not initialized");
-    }
-    const sessionId = await this.getOrCreateSession(context.roomId, connection);
-    client.resetChunks(sessionId);
-    const content = replaceUuidMentions(message.content, mentionSubjectsFromMetadata(message.metadata));
-    const messageWithContext = [...systemUpdateParts(participantsMessage, contactsMessage), content].join("\n\n");
-    const promptText = this.bootstrappedSessions.has(sessionId) ? messageWithContext : `${this.buildSystemContext(context.roomId, message)}
-
-${messageWithContext}`;
-    this.bootstrappedSessions.add(sessionId);
-    try {
-      await connection.prompt({
-        sessionId,
-        prompt: [{
-          type: "text",
-          text: promptText
-        }]
-      });
-    } catch (error) {
-      await this.stop();
-      await tools.sendEvent(`ACP agent error: ${toErrorMessage(error)}`, "error", {
-        acp_error: toErrorMessage(error)
-      });
-      return;
-    }
-    await this.flushChunks({
-      tools,
-      sessionId,
-      senderId: message.senderId,
-      senderHandle: message.senderName ?? message.senderType
-    });
-    await tools.sendEvent("ACP client session", "task", {
-      acp_client_session_id: sessionId,
-      acp_client_room_id: context.roomId
-    });
-  }
-  // A per-room async mutex: `fn` for a given `roomId` never overlaps another
-  // call for that same room, while different rooms stay fully concurrent.
-  // The tracked tail (`this.roomTurnLocks`) always settles — via the
-  // trailing `.catch` — so one turn's failure can't wedge every later turn
-  // for the room; the real result/rejection is still `run`, returned to this
-  // call's own caller.
-  async withRoomTurnLock(roomId, fn) {
-    const previous = this.roomTurnLocks.get(roomId) ?? Promise.resolve();
-    const run = previous.then(fn, fn);
-    this.roomTurnLocks.set(roomId, run.catch(() => void 0));
-    return run;
-  }
-  async onCleanup(roomId) {
-    const sessionId = this.unlinkRoom(roomId);
-    this.roomTools.delete(roomId);
-    this.sessionsInFlight.delete(roomId);
-    this.roomTurnLocks.delete(roomId);
-    this.nextRoomGeneration(roomId);
-    if (sessionId) {
-      this.activeSessions.delete(sessionId);
-      this.bootstrappedSessions.delete(sessionId);
-      this.cancelPendingPermissions(sessionId, "room-closed");
-    }
-  }
-  async onRuntimeStop() {
-    await this.stop();
-  }
-  async stop() {
-    this.spawnPromise = null;
-    this.connectionState = null;
-    this.activeSessions.clear();
-    this.bootstrappedSessions.clear();
-    this.roomToSession.clear();
-    this.sessionToRoom.clear();
-    this.roomTools.clear();
-    this.sessionsInFlight.clear();
-    this.roomTurnLocks.clear();
-    for (const roomId of this.roomGeneration.keys()) {
-      this.nextRoomGeneration(roomId);
-    }
-    this.cancelAllPendingPermissions("adapter-stopped");
-    this.client = null;
-    this.connection = null;
-    if (this.backend) {
-      const backend = this.backend;
-      this.backend = null;
-      await backend.stop();
-    }
-    if (this.connectionHandle) {
-      const handle = this.connectionHandle;
-      this.connectionHandle = null;
-      await handle.stop();
-    }
-  }
-  rehydrate(history) {
-    for (const [roomId, sessionId] of Object.entries(history.roomToSession)) {
-      if (!this.roomToSession.has(roomId)) {
-        this.linkSession(roomId, sessionId);
-      }
-    }
-  }
-  // The only writer of both session maps, so they cannot drift: replacing a
-  // room's session drops the old session's route, and a session id already
-  // routed to another room is refused rather than silently re-pointed — two
-  // rooms sharing one session id would make its permission requests
-  // unattributable. Returns whether the link was made — a caller that goes
-  // on to activate/configure/prompt a session regardless of a `false` here
-  // would use a session this room was refused, not just fail to route its
-  // permissions.
-  linkSession(roomId, sessionId) {
-    const routedRoomId = this.sessionToRoom.get(sessionId);
-    if (routedRoomId !== void 0 && routedRoomId !== roomId) {
-      this.safeWarn("refusing to route one ACP session to a second room", {
-        sessionId,
-        roomId,
-        routedRoomId
-      });
-      return false;
-    }
-    const replacedSessionId = this.roomToSession.get(roomId);
-    if (replacedSessionId !== void 0 && replacedSessionId !== sessionId) {
-      this.sessionToRoom.delete(replacedSessionId);
-    }
-    this.roomToSession.set(roomId, sessionId);
-    this.sessionToRoom.set(sessionId, roomId);
-    return true;
-  }
-  nextRoomGeneration(roomId) {
-    const next = (this.roomGeneration.get(roomId) ?? 0) + 1;
-    this.roomGeneration.set(roomId, next);
-    return next;
-  }
-  isCurrentGeneration(roomId, generation) {
-    return this.roomGeneration.get(roomId) === generation;
-  }
-  // The installed ACP SDK's `sendRequest` never rejects a pending call when
-  // its connection closes (no server response ever arrives to reject it
-  // with) — so a session-establishment RPC in flight when the subprocess
-  // dies would otherwise hang forever, wedging the room's `sessionsInFlight`
-  // entry along with it. Racing every such RPC against the connection's own
-  // `closed` promise gives it a real, prompt failure instead.
-  raceAgainstConnectionClose(connection, operation) {
-    let reject = () => void 0;
-    const closedRejection = new Promise((_resolve, rejectFn) => {
-      reject = rejectFn;
-    });
-    void connection.closed.then(() => reject(new Error("ACP connection closed while a session operation was still in flight")));
-    return Promise.race([operation, closedRejection]);
-  }
-  unlinkRoom(roomId) {
-    const sessionId = this.roomToSession.get(roomId);
-    this.roomToSession.delete(roomId);
-    if (sessionId !== void 0) {
-      this.sessionToRoom.delete(sessionId);
-    }
-    return sessionId;
-  }
-  async ensureConnection() {
-    if (this.connection && !this.connection.signal.aborted) {
-      return this.connection;
-    }
-    if (!this.started) {
-      throw new Error("ACPClientAdapter was not started");
-    }
-    const isCreator = !this.spawnPromise;
-    if (isCreator) {
-      this.spawnPromise = this.spawnConnection();
-    }
-    try {
-      return await this.spawnPromise;
-    } finally {
-      if (isCreator) this.spawnPromise = null;
-    }
-  }
-  async spawnConnection() {
-    const acp = await acpModule.get();
-    const client = new BandACPClient((params) => this.routePermissionRequest(params));
-    const handle = await this.connectionFactory(client, {
-      command: this.command,
-      cwd: this.cwd,
-      env: this.env
-    });
-    const connection = handle.connection;
-    const initializeResult = await connection.initialize({
-      protocolVersion: acp.PROTOCOL_VERSION,
-      clientCapabilities: this.clientCapabilities ?? {}
-    });
-    if (this.authMethod) {
-      await connection.authenticate({
-        methodId: this.authMethod
-      });
-    }
-    this.client = client;
-    this.connection = connection;
-    this.connectionHandle = handle;
-    this.connectionState = initializeResult;
-    void connection.closed.finally(() => {
-      if (this.connection === connection) {
-        this.connection = null;
-        this.connectionHandle = null;
-        this.connectionState = null;
-        this.activeSessions.clear();
-        this.cancelAllPendingPermissions("connection-lost");
-      }
-    });
-    return connection;
-  }
-  async getOrCreateSession(roomId, connection) {
-    const existingSessionId = this.roomToSession.get(roomId);
-    if (existingSessionId && this.activeSessions.has(existingSessionId)) {
-      return existingSessionId;
-    }
-    const inFlight = this.sessionsInFlight.get(roomId);
-    if (inFlight) {
-      return inFlight;
-    }
-    const generation = this.nextRoomGeneration(roomId);
-    const establishing = this.establishSession(roomId, existingSessionId, connection, generation);
-    establishing.finally(() => {
-      if (this.sessionsInFlight.get(roomId) === establishing) {
-        this.sessionsInFlight.delete(roomId);
-      }
-    }).catch(() => void 0);
-    this.sessionsInFlight.set(roomId, establishing);
-    return establishing;
-  }
-  async establishSession(roomId, existingSessionId, connection, generation) {
-    const mcpServers = await this.buildSessionMcpServers();
-    if (existingSessionId) {
-      const restored = await this.tryRestoreSession(connection, existingSessionId, mcpServers);
-      if (restored.ok) {
-        this.linkOrAbandon(roomId, existingSessionId, generation);
-        this.activeSessions.add(existingSessionId);
-        this.bootstrappedSessions.add(existingSessionId);
-        await this.configureSessionMode(roomId, existingSessionId, restored.modes, connection);
-        return existingSessionId;
-      }
-    }
-    const created = await this.raceAgainstConnectionClose(connection, connection.newSession({
-      cwd: this.cwd,
-      mcpServers
-    }));
-    this.linkOrAbandon(roomId, created.sessionId, generation);
-    this.activeSessions.add(created.sessionId);
-    await this.configureSessionMode(roomId, created.sessionId, created.modes, connection);
-    return created.sessionId;
-  }
-  // The single gate an establishment must pass before it's allowed to claim
-  // the room: it must still be the room's current generation (not
-  // superseded by a teardown or a fresher establishment while this one was
-  // awaiting an RPC), and its session id must not already belong to another
-  // room. Either failure throws — this establishment cannot silently
-  // continue to activate, configure, and prompt a session it has no right
-  // to use for this room.
-  linkOrAbandon(roomId, sessionId, generation) {
-    if (!this.isCurrentGeneration(roomId, generation)) {
-      throw new Error(`ACP session establishment for room "${roomId}" was superseded before it could be linked`);
-    }
-    if (!this.linkSession(roomId, sessionId)) {
-      throw new Error(`ACP session "${sessionId}" could not be linked to room "${roomId}": already routed elsewhere`);
-    }
-  }
-  // Best-effort: never throws, so a mode switch going wrong can't take a
-  // session establishment down with it.
-  async configureSessionMode(roomId, sessionId, modes, connection) {
-    if (!this.resolveSessionMode || !modes) {
-      return;
-    }
-    const availableModes = Array.isArray(modes.availableModes) ? modes.availableModes : [];
-    if (availableModes.length === 0) {
-      return;
-    }
-    const selectedModeId = await this.resolveSessionModeManually(
-      (signal) => this.resolveSessionMode({
-        roomId,
-        sessionId,
-        currentModeId: modes.currentModeId,
-        modes: availableModes
-      }, signal),
-      connection.signal
-    );
-    if (!selectedModeId || selectedModeId === modes.currentModeId) {
-      return;
-    }
-    if (!availableModes.some((mode) => mode?.id === selectedModeId)) {
-      this.safeWarn("resolveSessionMode selected a mode id this session does not advertise", {
-        sessionId,
-        selectedModeId,
-        availableModeIds: availableModes.map((mode) => mode?.id)
-      });
-      return;
-    }
-    try {
-      await withTimeout(
-        connection.setSessionMode({ sessionId, modeId: selectedModeId }),
-        SET_SESSION_MODE_TIMEOUT_MS,
-        `setSessionMode did not respond within ${SET_SESSION_MODE_TIMEOUT_MS}ms`
-      );
-    } catch (error) {
-      this.safeWarn("failed to switch session into the selected mode", {
-        sessionId,
-        selectedModeId,
-        error: String(error)
-      });
-    }
-  }
-  async resolveSessionModeManually(resolver, signal) {
-    const controller = new AbortController();
-    const abort = () => controller.abort();
-    signal.addEventListener("abort", abort, { once: true });
-    let timer;
-    try {
-      const cancelled = new Promise((resolve) => {
-        controller.signal.addEventListener("abort", () => resolve(void 0), { once: true });
-      });
-      const timeout = new Promise((resolve) => {
-        timer = setTimeout(() => resolve(void 0), this.permissionTimeoutMs);
-      });
-      return await Promise.race([
-        Promise.resolve().then(() => resolver(controller.signal)).catch((error) => {
-          this.safeWarn("resolveSessionMode threw; preserving the harness default", { error: String(error) });
-          return void 0;
-        }),
-        timeout,
-        cancelled
-      ]);
-    } finally {
-      clearTimeout(timer);
-      signal.removeEventListener("abort", abort);
-      controller.abort();
-    }
-  }
-  async tryRestoreSession(connection, sessionId, mcpServers) {
-    const capabilities = this.connectionState?.agentCapabilities;
-    const params = { cwd: this.cwd, mcpServers, sessionId };
-    const restore = capabilities?.loadSession ? () => connection.loadSession(params) : capabilities?.sessionCapabilities?.resume ? () => connection.unstable_resumeSession(params) : null;
-    if (!restore) {
-      return { ok: false };
-    }
-    try {
-      const restored = await this.raceAgainstConnectionClose(connection, restore());
-      return { ok: true, modes: restored?.modes };
-    } catch {
-      return { ok: false };
-    }
-  }
-  async buildSessionMcpServers() {
-    const mcpServers = [...this.mcpServers];
-    if (!this.enableMcpTools) {
-      return mcpServers;
-    }
-    const backend = await this.getOrCreateBackend();
-    if (backend.kind === "http") {
-      const url = backend.server.url;
-      if (!url) {
-        throw new Error("Band MCP HTTP backend did not expose a URL");
-      }
-      mcpServers.push({
-        type: "http",
-        name: MCP_SERVER_NAME,
-        url,
-        headers: [{ name: "Authorization", value: `Bearer ${backend.authToken}` }]
-      });
-      return mcpServers;
-    }
-    if (backend.kind === "sse") {
-      const url = backend.server.sseUrl;
-      if (!url) {
-        throw new Error("Band MCP SSE backend did not expose a URL");
-      }
-      mcpServers.push({
-        type: "sse",
-        name: MCP_SERVER_NAME,
-        url,
-        headers: [{ name: "Authorization", value: `Bearer ${backend.authToken}` }]
-      });
-      return mcpServers;
-    }
-    return mcpServers;
-  }
-  async getOrCreateBackend() {
-    if (this.backend) {
-      return this.backend;
-    }
-    this.backendPromise ??= this.createBackend().finally(() => {
-      this.backendPromise = null;
-    });
-    return this.backendPromise;
-  }
-  async createBackend() {
-    const mcpCapabilities = this.connectionState?.agentCapabilities?.mcpCapabilities;
-    const transport = mcpCapabilities?.http ? "http" : mcpCapabilities?.sse ? "sse" : null;
-    if (transport === null) {
-      throw new Error(
-        "ACP agent does not advertise MCP transport support: its initialize response has mcpCapabilities.http and .sse both false or missing, so Band tools cannot be exposed to it over MCP."
-      );
-    }
-    const authToken = generateAuthToken();
-    if (transport === "sse") {
-      const server2 = new BandMcpSseServer({
-        tools: (roomId) => this.roomTools.get(roomId),
-        enableMemoryTools: this.enableMemoryTools,
-        enableContactTools: true,
-        additionalTools: this.additionalMcpTools,
-        authToken
-      });
-      await server2.start();
-      this.backend = {
-        kind: "sse",
-        server: server2,
-        authToken,
-        stop: async () => {
-          await server2.stop();
-        }
-      };
-      return this.backend;
-    }
-    const server = new BandMcpServer({
-      tools: (roomId) => this.roomTools.get(roomId),
-      enableMemoryTools: this.enableMemoryTools,
-      enableContactTools: true,
-      additionalTools: this.additionalMcpTools,
-      authToken
-    });
-    await server.start();
-    this.backend = {
-      kind: "http",
-      server,
-      authToken,
-      stop: async () => {
-        await server.stop();
-      }
-    };
-    return this.backend;
-  }
-  buildSystemContext(roomId, message) {
-    const requesterName = message.senderName ?? message.senderId;
-    const requesterId = message.senderId;
-    return [
-      "[System Context]",
-      this.systemPrompt,
-      "",
-      "## Room Context",
-      "You are connected to Band using Band MCP tools.",
-      "Use the Band tools for any visible room action. Plain text output is not posted back to the room.",
-      "",
-      `Current room_id: ${roomId}`,
-      `Current requester name: ${requesterName}`,
-      `Current requester id: ${requesterId}`,
-      "",
-      "All Band MCP tool calls must include room_id."
-    ].join("\n");
-  }
-  // The connection's single permission entry point, and total by
-  // construction: every path resolves, nothing throws, and a request that
-  // can't be attributed to a live room is cancelled *and* warned rather than
-  // silently declined. `activeSessions` is the gate that keeps a dead
-  // session from raising a live prompt — `roomToSession` deliberately
-  // outlives a dropped connection so the session can be restored later.
-  async routePermissionRequest(params) {
-    const isActive = this.activeSessions.has(params.sessionId);
-    const roomId = isActive ? this.sessionToRoom.get(params.sessionId) : void 0;
-    const tools = roomId === void 0 ? void 0 : this.roomTools.get(roomId);
-    if (roomId === void 0 || !tools) {
-      this.safeWarn("cancelling a permission request that maps to no live room", {
-        sessionId: params.sessionId,
-        toolName: params.toolCall?.title,
-        sessionActive: isActive,
-        roomId
-      });
-      return { outcome: { outcome: "cancelled" } };
-    }
-    try {
-      return await this.handlePermissionRequest(tools, roomId, params);
-    } catch (error) {
-      this.safeWarn("permission handling failed; cancelling the request", {
-        sessionId: params.sessionId,
-        roomId,
-        error: String(error)
-      });
-      return { outcome: { outcome: "cancelled" } };
-    }
-  }
-  async handlePermissionRequest(tools, roomId, params) {
-    const toolName = params.toolCall.title ?? "unknown";
-    const autoSelection = this.resolvePermission ? void 0 : choosePermissionOption(params.options);
-    const controller = this.resolvePermission ? new AbortController() : void 0;
-    if (controller) {
-      this.trackPending(params.sessionId, controller);
-    }
-    let requestEventFailed = false;
-    const [, resolvedChosenId] = await Promise.all([
-      // Started immediately rather than serialized in front of a manual
-      // wait that can take up to `permissionTimeoutMs`.
-      tools.sendEvent(`Permission requested: ${toolName}`, "tool_call", {
-        permission_request: true,
-        tool_name: toolName,
-        tool_call_id: params.toolCall.toolCallId,
-        acp_session_id: params.sessionId,
-        auto_allowed: autoSelection !== void 0 && autoSelection !== null
-      }).catch((error) => {
-        requestEventFailed = true;
-        this.safeWarn("failed to post the permission-requested event; cancelling the request", {
-          roomId,
-          sessionId: params.sessionId,
-          error: String(error)
-        });
-        if (controller) {
-          this.abandon(controller, "no-answer");
-        }
-      }),
-      controller ? this.resolveManually(roomId, params, controller) : Promise.resolve(autoSelection?.optionId)
-    ]);
-    const chosenId = requestEventFailed ? void 0 : resolvedChosenId;
-    const response = this.toResponse(chosenId, params.options, { roomId, sessionId: params.sessionId });
-    if (controller && !controller.signal.aborted) {
-      this.abandon(controller, response.outcome.outcome === "selected" ? "settled" : "no-answer");
-    }
-    return response;
-  }
-  // `undefined`, or an id absent from this request's own `options` (a buggy
-  // or stale caller), both map to `cancelled` — never silently treated as a
-  // deny. A real match, reject-kind options included, maps to `selected`.
-  toResponse(chosenId, options, context) {
-    if (chosenId === void 0) {
-      return { outcome: { outcome: "cancelled" } };
-    }
-    if (!options.some((option) => option.optionId === chosenId)) {
-      this.safeWarn("resolvePermission chose an option this request does not offer", {
-        ...context,
-        chosenId,
-        optionIds: options.map((option) => option.optionId)
-      });
-      return { outcome: { outcome: "cancelled" } };
-    }
-    return { outcome: { outcome: "selected", optionId: chosenId } };
-  }
-  // A caller-supplied `Logger` isn't guaranteed to be synchronous or
-  // non-throwing. Every best-effort warning in this file routes through here
-  // so one failing sink — a synchronous throw, or an `async` implementation
-  // rejecting (the `Logger` interface's `void` return type permits either;
-  // a bare try/catch only ever catches the former) — can't turn a warning
-  // into an unhandled rejection in its place.
-  safeWarn(message, context) {
-    try {
-      Promise.resolve(this.logger.warn(message, context)).catch(() => void 0);
-    } catch {
-    }
-  }
-  // Races the caller-supplied resolver against `controller`'s abort signal,
-  // which is the request's single termination channel: the timeout below
-  // fires it with `"timeout"`, and `cancelPendingPermissions` /
-  // `cancelAllPendingPermissions` fire it with the reason their caller
-  // supplies. `controller` is the same object tracked in `pendingPermissions`,
-  // so there is exactly one cancellation channel here, not a second
-  // hand-rolled one alongside it.
-  async resolveManually(roomId, params, controller) {
-    const abandoned = new Promise((resolve) => {
-      controller.signal.addEventListener("abort", () => resolve(void 0));
-    });
-    const timer = setTimeout(() => this.abandon(controller, "timeout"), this.permissionTimeoutMs);
-    try {
-      return await Promise.race([
-        // `resolvePermission` is caller-supplied; nothing guarantees it's
-        // `async` or otherwise well-behaved. `Promise.resolve().then(...)`
-        // normalizes a synchronous throw the same way it normalizes a
-        // rejected promise, so both land in the `.catch` below rather than
-        // escaping this race uncaught.
-        Promise.resolve().then(() => this.resolvePermission({ ...params, roomId }, controller.signal)).then((chosenId) => this.discardLateAnswer(chosenId, controller, roomId, params.sessionId)).catch((error) => {
-          this.safeWarn("resolvePermission threw; treating as no answer", { error: String(error) });
-          return void 0;
-        }),
-        abandoned
-      ]);
-    } finally {
-      clearTimeout(timer);
-      this.untrackPending(params.sessionId, controller);
-    }
-  }
-  // An answer that lands after the request was given up on can no longer be
-  // honoured — the response has already gone back to the agent. It is dropped
-  // either way; warning is what makes "my click did nothing" explicable.
-  discardLateAnswer(chosenId, controller, roomId, sessionId) {
-    if (!controller.signal.aborted || chosenId === void 0) {
-      return chosenId;
-    }
-    this.safeWarn("resolvePermission answered after the request was abandoned; discarding", {
-      roomId,
-      sessionId,
-      chosenId,
-      reason: String(controller.signal.reason)
-    });
-    return void 0;
-  }
-  // The only place a permission's controller is ever aborted, so every
-  // `signal.reason` a consumer can observe comes from the documented union.
-  abandon(controller, reason) {
-    controller.abort(reason);
-  }
-  trackPending(sessionId, controller) {
-    const pending = this.pendingPermissions.get(sessionId) ?? /* @__PURE__ */ new Set();
-    pending.add(controller);
-    this.pendingPermissions.set(sessionId, pending);
-  }
-  untrackPending(sessionId, controller) {
-    const pending = this.pendingPermissions.get(sessionId);
-    pending?.delete(controller);
-    if (pending?.size === 0) {
-      this.pendingPermissions.delete(sessionId);
-    }
-  }
-  cancelPendingPermissions(sessionId, reason) {
-    for (const controller of this.pendingPermissions.get(sessionId) ?? []) {
-      this.abandon(controller, reason);
-    }
-  }
-  cancelAllPendingPermissions(reason) {
-    for (const sessionId of this.pendingPermissions.keys()) {
-      this.cancelPendingPermissions(sessionId, reason);
-    }
-  }
-  async flushChunks(input) {
-    const client = this.client;
-    if (!client) {
-      return;
-    }
-    for (const chunk of client.getCollectedChunks(input.sessionId)) {
-      if (isBlankEventContent(chunk.content)) {
-        continue;
-      }
-      if (chunk.chunkType === "text") {
-        await input.tools.sendMessage(chunk.content, [{
-          id: input.senderId,
-          handle: input.senderHandle
-        }]);
-        continue;
-      }
-      const messageType = chunk.chunkType === "plan" ? "task" : chunk.chunkType;
-      await input.tools.sendEvent(
-        chunk.content,
-        messageType,
-        chunk.metadata
-      );
-    }
-  }
-};
-async function createSubprocessConnection(client, options) {
-  const acp = await acpModule.get();
-  const child = spawn(options.command[0], options.command.slice(1), {
-    cwd: options.cwd,
-    env: {
-      ...process.env,
-      ...options.env
-    },
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (!child.stdin || !child.stdout) {
-    throw new Error("ACP subprocess did not expose stdio pipes");
-  }
-  const stream = acp.ndJsonStream(
-    Writable.toWeb(child.stdin),
-    Readable.toWeb(child.stdout)
-  );
-  const connection = new acp.ClientSideConnection(() => client, stream);
-  return {
-    connection,
-    stop: async () => {
-      await new Promise((resolve) => {
-        if (child.exitCode !== null || child.signalCode !== null) {
-          resolve();
-          return;
-        }
-        let settled = false;
-        const finish = () => {
-          if (settled) {
-            return;
-          }
-          settled = true;
-          child.off("exit", finish);
-          child.off("close", finish);
-          resolve();
-        };
-        child.once("exit", finish);
-        child.once("close", finish);
-        if (!child.killed) {
-          child.kill();
-        }
-        if (child.exitCode !== null || child.signalCode !== null) {
-          finish();
-        }
-      });
-    }
-  };
-}
-function toErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-
-// src/adapters/acp/ACPServer.ts
-import { Readable as Readable2, Writable as Writable2 } from "stream";
-
-// src/adapters/acp/BandACPServerAdapter.ts
-import { randomUUID } from "crypto";
-
-// src/adapters/acp/eventConverter.ts
-var EventConverter = class {
-  static convert(message) {
-    switch (message.messageType) {
-      case "text":
-        return {
-          sessionUpdate: "agent_message_chunk",
-          content: {
-            type: "text",
-            text: message.content
-          }
-        };
-      case "thought":
-        return {
-          sessionUpdate: "agent_thought_chunk",
-          content: {
-            type: "text",
-            text: message.content
-          }
-        };
-      case "tool_call":
-        return this.convertToolCall(message.content);
-      case "tool_result":
-        return this.convertToolResult(message.content);
-      case "error":
-        return {
-          sessionUpdate: "agent_message_chunk",
-          content: {
-            type: "text",
-            text: `[Error] ${message.content}`
-          }
-        };
-      case "task":
-        return {
-          sessionUpdate: "plan",
-          entries: [{
-            content: message.content,
-            priority: "medium",
-            status: "in_progress"
-          }]
-        };
-      default:
-        return null;
-    }
-  }
-  static convertToolCall(value) {
-    const parsed = parseToolCall(value);
-    if (!parsed) {
-      return {
-        sessionUpdate: "agent_message_chunk",
-        content: {
-          type: "text",
-          text: value
-        }
-      };
-    }
-    return {
-      sessionUpdate: "tool_call",
-      toolCallId: parsed.toolCallId,
-      title: parsed.name,
-      kind: "other",
-      status: "in_progress",
-      rawInput: parsed.args
-    };
-  }
-  static convertToolResult(value) {
-    const parsed = parseToolResult(value);
-    if (!parsed) {
-      return {
-        sessionUpdate: "agent_message_chunk",
-        content: {
-          type: "text",
-          text: value
-        }
-      };
-    }
-    const textBlock = {
-      type: "text",
-      text: parsed.output
-    };
-    const content = [{
-      type: "content",
-      content: textBlock
-    }];
-    return {
-      sessionUpdate: "tool_call_update",
-      toolCallId: parsed.toolCallId,
-      status: parsed.isError ? "failed" : "completed",
-      rawOutput: parsed.output,
-      content
-    };
-  }
-};
-
-// src/adapters/acp/pushHandler.ts
-var ACPPushHandler = class {
-  adapter;
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  async handlePushEvent(message, roomId) {
-    const sessionId = this.adapter.getSessionForRoom(roomId);
-    const connection = this.adapter.getConnection();
-    if (!sessionId || !connection) {
-      return;
-    }
-    const update = EventConverter.convert(message);
-    if (!update) {
-      return;
-    }
-    await connection.sessionUpdate({
-      sessionId,
-      update
-    });
-  }
-};
-
-// src/adapters/acp/router.ts
-var AgentRouter = class {
-  modeToPeer;
-  slashCommands;
-  constructor(options) {
-    this.modeToPeer = { ...options?.modeToPeer ?? {} };
-    this.slashCommands = Object.fromEntries(
-      Object.entries(options?.slashCommands ?? {}).map(([command, peer]) => [command.toLowerCase(), peer])
-    );
-  }
-  resolve(text, currentMode) {
-    if (text.startsWith("/")) {
-      const [command, ...rest] = text.slice(1).split(/\s+/);
-      const peer = this.slashCommands[command?.toLowerCase() ?? ""];
-      if (peer) {
-        return {
-          text: rest.join(" ").trim(),
-          targetPeer: peer
-        };
-      }
-    }
-    if (currentMode && this.modeToPeer[currentMode]) {
-      return {
-        text,
-        targetPeer: this.modeToPeer[currentMode]
-      };
-    }
-    return {
-      text,
-      targetPeer: null
-    };
-  }
-};
-
-// src/adapters/acp/BandACPServerAdapter.ts
-var DEFAULT_MAX_SESSIONS = 100;
-var DEFAULT_PROMPT_TIMEOUT_MS = 3e5;
-var DEFAULT_PROMPT_COMPLETION_GRACE_MS = 250;
-var BandACPServerAdapter = class extends SimpleAdapter {
-  bandRest;
-  maxSessions;
-  responseTimeoutMs;
-  promptCompletionGraceMs;
-  sessionModes;
-  sessionToRoom = /* @__PURE__ */ new Map();
-  roomToSession = /* @__PURE__ */ new Map();
-  pendingPrompts = /* @__PURE__ */ new Map();
-  sessionModeIds = /* @__PURE__ */ new Map();
-  sessionModelIds = /* @__PURE__ */ new Map();
-  sessionCwds = /* @__PURE__ */ new Map();
-  sessionMcpServers = /* @__PURE__ */ new Map();
-  connection = null;
-  agentId = null;
-  sessionsInFlight = 0;
-  router;
-  pushHandler;
-  constructor(options) {
-    super({
-      historyConverter: new ACPServerHistoryConverter()
-    });
-    this.bandRest = options.bandRest;
-    this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
-    this.responseTimeoutMs = options.responseTimeoutMs ?? DEFAULT_PROMPT_TIMEOUT_MS;
-    this.promptCompletionGraceMs = options.promptCompletionGraceMs ?? DEFAULT_PROMPT_COMPLETION_GRACE_MS;
-    this.sessionModes = options.sessionModes?.length ? [...options.sessionModes] : [...DEFAULT_ACP_SERVER_MODES];
-    this.router = new AgentRouter({
-      modeToPeer: options.modeToPeer,
-      slashCommands: options.slashCommands
-    });
-    this.pushHandler = new ACPPushHandler(this);
-  }
-  bindConnection(connection) {
-    this.connection = connection;
-  }
-  getConnection() {
-    return this.connection;
-  }
-  hasSession(sessionId) {
-    return this.sessionToRoom.has(sessionId);
-  }
-  getSessionIds() {
-    return [...this.sessionToRoom.keys()];
-  }
-  getSessionForRoom(roomId) {
-    return this.roomToSession.get(roomId) ?? null;
-  }
-  get displayName() {
-    return this.agentName;
-  }
-  getSessionCwd(sessionId) {
-    return this.sessionCwds.get(sessionId) ?? ".";
-  }
-  getModeState(sessionId) {
-    return {
-      availableModes: this.sessionModes,
-      currentModeId: this.sessionModeIds.get(sessionId) ?? this.sessionModes[0]?.id ?? "default"
-    };
-  }
-  setSessionModes(modes) {
-    this.sessionModes.splice(0, this.sessionModes.length, ...modes);
-  }
-  setSessionMode(sessionId, modeId) {
-    this.sessionModeIds.set(sessionId, modeId);
-  }
-  setSessionModel(sessionId, modelId) {
-    this.sessionModelIds.set(sessionId, modelId);
-  }
-  updateSessionContext(sessionId, input) {
-    if (input.cwd) {
-      this.sessionCwds.set(sessionId, input.cwd);
-    }
-    if (input.mcpServers) {
-      const normalized = normalizeMcpServers(input.mcpServers);
-      if (normalized.length > 0) {
-        this.sessionMcpServers.set(sessionId, normalized);
-      } else {
-        this.sessionMcpServers.delete(sessionId);
-      }
-    }
-  }
-  async verifyCredentials() {
-    try {
-      await this.bandRest.getAgentMe();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async onStarted(agentName, agentDescription) {
-    await super.onStarted(agentName, agentDescription);
-    try {
-      const identity = await this.bandRest.getAgentMe();
-      this.agentId = identity.id;
-    } catch {
-      this.agentId = null;
-    }
-  }
-  async createSession(input = {}) {
-    this.sessionsInFlight += 1;
-    const activeCount = this.sessionToRoom.size + this.sessionsInFlight;
-    if (activeCount > this.maxSessions) {
-      this.sessionsInFlight = Math.max(0, this.sessionsInFlight - 1);
-      throw new Error(`Maximum ACP sessions (${this.maxSessions}) reached`);
-    }
-    try {
-      const room = await this.bandRest.createChat();
-      const sessionId = randomUUID();
-      const normalizedMcpServers = normalizeMcpServers(input.mcpServers);
-      this.sessionToRoom.set(sessionId, room.id);
-      this.roomToSession.set(room.id, sessionId);
-      this.sessionCwds.set(sessionId, input.cwd ?? ".");
-      if (normalizedMcpServers.length > 0) {
-        this.sessionMcpServers.set(sessionId, normalizedMcpServers);
-      }
-      try {
-        await this.bandRest.createChatEvent(room.id, {
-          content: "ACP session context",
-          messageType: "task",
-          metadata: {
-            acp_session_id: sessionId,
-            acp_room_id: room.id,
-            acp_cwd: input.cwd ?? ".",
-            acp_mcp_servers: normalizedMcpServers
-          }
-        });
-      } catch (error) {
-        this.sessionToRoom.delete(sessionId);
-        this.roomToSession.delete(room.id);
-        this.sessionCwds.delete(sessionId);
-        this.sessionMcpServers.delete(sessionId);
-        this.sessionModeIds.delete(sessionId);
-        this.sessionModelIds.delete(sessionId);
-        throw error;
-      }
-      return sessionId;
-    } finally {
-      this.sessionsInFlight = Math.max(0, this.sessionsInFlight - 1);
-    }
-  }
-  async handlePrompt(sessionId, text) {
-    const roomId = this.sessionToRoom.get(sessionId);
-    if (!roomId) {
-      throw new Error(`Unknown ACP session: ${sessionId}`);
-    }
-    const pending = createPendingPrompt(sessionId);
-    this.pendingPrompts.set(roomId, pending);
-    const resolved = this.router.resolve(text, this.sessionModeIds.get(sessionId));
-    const promptText = this.prependSessionContext(sessionId, resolved.text);
-    const participants = await this.bandRest.listChatParticipants(roomId);
-    const mentions = this.resolveMentions(participants, resolved.targetPeer);
-    try {
-      await this.bandRest.createChatMessage(roomId, {
-        content: promptText,
-        mentions
-      });
-      await Promise.race([
-        pending.done,
-        new Promise((_, reject) => {
-          const timer = setTimeout(() => {
-            reject(new Error(`ACP prompt timed out after ${this.responseTimeoutMs}ms`));
-          }, this.responseTimeoutMs);
-          pending.done.finally(() => clearTimeout(timer)).catch(() => void 0);
-        })
-      ]);
-    } finally {
-      this.finishPendingPrompt(roomId, pending, false);
-    }
-  }
-  async onMessage(message, _tools, history, _participantsMessage, _contactsMessage, context) {
-    if (context.isSessionBootstrap) {
-      this.rehydrate(history);
-    }
-    if (this.agentId && message.senderId === this.agentId) {
-      return;
-    }
-    const pending = this.pendingPrompts.get(context.roomId);
-    if (pending && this.connection) {
-      const update = EventConverter.convert(message);
-      if (update) {
-        await this.connection.sessionUpdate({
-          sessionId: pending.sessionId,
-          update
-        });
-      }
-      if (message.messageType === "text" || message.messageType === "error") {
-        pending.terminalMessageSeen = true;
-      }
-      if (update || pending.terminalMessageSeen) {
-        this.schedulePromptCompletion(context.roomId, pending);
-      }
-      return;
-    }
-    if (this.connection) {
-      await this.pushHandler.handlePushEvent(message, context.roomId);
-    }
-  }
-  async onCleanup(roomId) {
-    const sessionId = this.roomToSession.get(roomId);
-    if (sessionId) {
-      this.roomToSession.delete(roomId);
-      this.sessionToRoom.delete(sessionId);
-      this.sessionModeIds.delete(sessionId);
-      this.sessionModelIds.delete(sessionId);
-      this.sessionCwds.delete(sessionId);
-      this.sessionMcpServers.delete(sessionId);
-    }
-    this.finishPendingPrompt(roomId, this.pendingPrompts.get(roomId) ?? null, true);
-  }
-  async onRuntimeStop() {
-    for (const roomId of [...this.roomToSession.keys()]) {
-      await this.onCleanup(roomId);
-    }
-    this.connection = null;
-  }
-  async cancelPrompt(sessionId) {
-    const roomId = this.sessionToRoom.get(sessionId);
-    if (!roomId) {
-      return;
-    }
-    this.finishPendingPrompt(roomId, this.pendingPrompts.get(roomId) ?? null, true);
-  }
-  async closeSession(sessionId) {
-    const roomId = this.sessionToRoom.get(sessionId);
-    if (!roomId) {
-      return;
-    }
-    await this.onCleanup(roomId);
-  }
-  rehydrate(history) {
-    for (const [sessionId, roomId] of Object.entries(history.sessionToRoom)) {
-      if (!this.sessionToRoom.has(sessionId)) {
-        this.sessionToRoom.set(sessionId, roomId);
-      }
-      if (!this.roomToSession.has(roomId)) {
-        this.roomToSession.set(roomId, sessionId);
-      }
-    }
-    for (const [sessionId, cwd] of Object.entries(history.sessionCwd)) {
-      if (!this.sessionCwds.has(sessionId)) {
-        this.sessionCwds.set(sessionId, cwd);
-      }
-    }
-    for (const [sessionId, mcpServers] of Object.entries(history.sessionMcpServers)) {
-      if (!this.sessionMcpServers.has(sessionId)) {
-        this.sessionMcpServers.set(sessionId, [...mcpServers]);
-      }
-    }
-  }
-  prependSessionContext(sessionId, text) {
-    const cwd = this.sessionCwds.get(sessionId);
-    const mcpServers = this.sessionMcpServers.get(sessionId) ?? [];
-    if (!cwd && mcpServers.length === 0) {
-      return text;
-    }
-    const lines = ["[ACP Session Context]"];
-    if (cwd) {
-      lines.push(`Editor cwd: ${cwd}`);
-    }
-    if (mcpServers.length > 0) {
-      lines.push("Editor MCP servers:");
-      lines.push(...mcpServers.map((server) => formatMcpServerLine(server)));
-      lines.push("These MCP servers belong to the connected editor session.");
-    }
-    lines.push("");
-    lines.push(text);
-    return lines.join("\n");
-  }
-  resolveMentions(participants, targetPeer) {
-    const filtered = participants.filter((participant) => {
-      if (this.agentId && participant.id === this.agentId) {
-        return false;
-      }
-      if (!targetPeer) {
-        return true;
-      }
-      const normalizedTarget = targetPeer.startsWith("@") ? targetPeer.slice(1) : targetPeer;
-      const participantHandles = [
-        participant.handle,
-        ensureHandlePrefix(participant.handle)?.slice(1)
-      ].filter((value) => typeof value === "string" && value.length > 0);
-      return participant.name === targetPeer || participant.name === normalizedTarget || participantHandles.includes(targetPeer) || participantHandles.includes(normalizedTarget);
-    });
-    return filtered.map((participant) => ({
-      id: participant.id,
-      handle: participant.handle ?? void 0,
-      name: participant.name
-    }));
-  }
-  schedulePromptCompletion(roomId, pending) {
-    if (this.pendingPrompts.get(roomId) !== pending) {
-      return;
-    }
-    if (pending.completionTimer) {
-      clearTimeout(pending.completionTimer);
-    }
-    pending.completionTimer = setTimeout(() => {
-      this.finishPendingPrompt(roomId, pending, true);
-    }, this.promptCompletionGraceMs);
-  }
-  finishPendingPrompt(roomId, pending, setDone) {
-    const current = this.pendingPrompts.get(roomId);
-    if (!current || pending && current !== pending) {
-      return;
-    }
-    this.pendingPrompts.delete(roomId);
-    if (current.completionTimer) {
-      clearTimeout(current.completionTimer);
-      current.completionTimer = null;
-    }
-    if (setDone) {
-      current.markDone();
-    }
-  }
-};
-function formatMcpServerLine(server) {
-  const type = typeof server.type === "string" ? server.type : "unknown";
-  const name = typeof server.name === "string" ? server.name : typeof server.command === "string" ? server.command : typeof server.url === "string" ? server.url : "unnamed";
-  const details = [type];
-  if (type === "stdio" && typeof server.command === "string") {
-    details.push(`command=${server.command}`);
-  }
-  if (type !== "stdio" && typeof server.url === "string") {
-    details.push(`url=${server.url}`);
-  }
-  return `- ${name} (${details.join(", ")})`;
-}
-
-// src/adapters/acp/cursorExtensions.ts
-var CursorExtensionHandler = class {
-  async extMethod(method, params) {
-    if (method === "cursor/ask_question") {
-      const options = Array.isArray(params.options) ? params.options : [];
-      const first = options.find((option) => !!option && typeof option === "object");
-      if (!first) {
-        return {
-          outcome: {
-            type: "cancelled"
-          }
-        };
-      }
-      return {
-        outcome: {
-          type: "selected",
-          optionId: String(first.optionId ?? first.id ?? "0")
-        }
-      };
-    }
-    if (method === "cursor/create_plan") {
-      return {
-        outcome: {
-          type: "approved"
-        }
-      };
-    }
-    return null;
-  }
-  async extNotification(method, params, context) {
-    if (method === "cursor/update_todos") {
-      const todos = Array.isArray(params.todos) ? params.todos : [];
-      const text = todos.filter((todo) => !!todo && typeof todo === "object").map((todo) => `- [${todo.completed === true ? "x" : " "}] ${String(todo.content ?? "")}`).join("\n");
-      if (text.length > 0) {
-        await context.connection.sessionUpdate({
-          sessionId: context.sessionId,
-          update: {
-            sessionUpdate: "agent_message_chunk",
-            content: {
-              type: "text",
-              text
-            }
-          }
-        });
-      }
-      return;
-    }
-    if (method === "cursor/task" && typeof params.result === "string" && params.result.length > 0) {
-      await context.connection.sessionUpdate({
-        sessionId: context.sessionId,
-        update: {
-          sessionUpdate: "agent_message_chunk",
-          content: {
-            type: "text",
-            text: `[Task completed] ${params.result}`
-          }
-        }
-      });
-    }
-  }
-};
-
-// src/adapters/acp/ACPServer.ts
-var ACPServer = class {
-  adapter;
-  authMethods;
-  agentInfo;
-  extensionHandler;
-  connection = null;
-  constructor(adapter, options) {
-    this.adapter = adapter;
-    if (options?.modes?.length) {
-      this.adapter.setSessionModes([...options.modes]);
-    }
-    this.authMethods = options?.authMethods ?? [{
-      id: "api_key",
-      name: "API Key",
-      description: "Authenticate with BAND_API_KEY (legacy THENVOI_API_KEY)."
-    }];
-    this.agentInfo = options?.agentInfo ?? {};
-    this.extensionHandler = options?.extensionHandler ?? new CursorExtensionHandler();
-  }
-  async connectStream(stream) {
-    if (this.connection && !this.connection.signal.aborted) {
-      return this.connection;
-    }
-    const acp = await acpModule.get();
-    this.connection = new acp.AgentSideConnection((connection) => {
-      this.adapter.bindConnection(connection);
-      return this;
-    }, stream);
-    void this.connection.closed.finally(() => {
-      if (this.connection?.signal.aborted) {
-        this.adapter.bindConnection(null);
-      }
-    });
-    return this.connection;
-  }
-  connectStdio(options) {
-    const stdin = options?.stdin ?? process.stdin;
-    const stdout = options?.stdout ?? process.stdout;
-    return acpModule.get().then((acp) => this.connectStream(
-      acp.ndJsonStream(
-        Writable2.toWeb(stdout),
-        Readable2.toWeb(stdin)
-      )
-    ));
-  }
-  get closed() {
-    return this.connection?.closed ?? Promise.resolve();
-  }
-  async initialize(params) {
-    const acp = await acpModule.get();
-    return {
-      protocolVersion: params.protocolVersion === acp.PROTOCOL_VERSION ? params.protocolVersion : acp.PROTOCOL_VERSION,
-      agentCapabilities: {
-        loadSession: true,
-        promptCapabilities: {
-          image: false,
-          audio: false,
-          embeddedContext: true
-        },
-        sessionCapabilities: {
-          list: {},
-          resume: {},
-          fork: {},
-          close: {}
-        }
-      },
-      agentInfo: {
-        name: this.agentInfo.name ?? "band-agent",
-        title: this.agentInfo.title ?? this.adapter.displayName ?? "Band Agent",
-        version: this.agentInfo.version ?? "0.1.0"
-      },
-      authMethods: this.authMethods
-    };
-  }
-  async newSession(params) {
-    const sessionId = await this.adapter.createSession({
-      cwd: params.cwd,
-      mcpServers: params.mcpServers
-    });
-    return {
-      sessionId,
-      modes: this.adapter.getModeState(sessionId)
-    };
-  }
-  async loadSession(params) {
-    if (!this.adapter.hasSession(params.sessionId)) {
-      const acp = await acpModule.get();
-      throw acp.RequestError.resourceNotFound(params.sessionId);
-    }
-    this.adapter.updateSessionContext(params.sessionId, {
-      cwd: params.cwd,
-      mcpServers: params.mcpServers
-    });
-    return {
-      modes: this.adapter.getModeState(params.sessionId)
-    };
-  }
-  async listSessions(params) {
-    const sessions = this.adapter.getSessionIds().filter((sessionId) => !params.cwd || this.adapter.getSessionCwd(sessionId) === params.cwd).map((sessionId) => ({
-      sessionId,
-      cwd: this.adapter.getSessionCwd(sessionId)
-    }));
-    return { sessions };
-  }
-  async unstable_forkSession(params) {
-    if (!this.adapter.hasSession(params.sessionId)) {
-      const acp = await acpModule.get();
-      throw acp.RequestError.resourceNotFound(params.sessionId);
-    }
-    const sessionId = await this.adapter.createSession({
-      cwd: params.cwd,
-      mcpServers: params.mcpServers
-    });
-    return {
-      sessionId
-    };
-  }
-  async unstable_resumeSession(params) {
-    if (!this.adapter.hasSession(params.sessionId)) {
-      const acp = await acpModule.get();
-      throw acp.RequestError.resourceNotFound(params.sessionId);
-    }
-    this.adapter.updateSessionContext(params.sessionId, {
-      cwd: params.cwd,
-      mcpServers: params.mcpServers
-    });
-    return {
-      modes: this.adapter.getModeState(params.sessionId)
-    };
-  }
-  async unstable_closeSession(params) {
-    await this.adapter.closeSession(params.sessionId);
-    return {};
-  }
-  async setSessionMode(params) {
-    if (!this.adapter.hasSession(params.sessionId)) {
-      const acp = await acpModule.get();
-      throw acp.RequestError.resourceNotFound(params.sessionId);
-    }
-    this.adapter.setSessionMode(params.sessionId, params.modeId);
-    return {};
-  }
-  async unstable_setSessionModel(params) {
-    if (!this.adapter.hasSession(params.sessionId)) {
-      const acp = await acpModule.get();
-      throw acp.RequestError.resourceNotFound(params.sessionId);
-    }
-    this.adapter.setSessionModel(params.sessionId, params.modelId);
-    return {};
-  }
-  async setSessionConfigOption(_params) {
-    return {
-      configOptions: []
-    };
-  }
-  async authenticate(params) {
-    if (params.methodId !== "api_key" && params.methodId !== "cursor_login") {
-      const acp = await acpModule.get();
-      throw acp.RequestError.authRequired(void 0, `Unsupported auth method: ${params.methodId}`);
-    }
-    const ok = await this.adapter.verifyCredentials();
-    if (!ok) {
-      const acp = await acpModule.get();
-      throw acp.RequestError.authRequired(void 0, "Authentication failed");
-    }
-    return {};
-  }
-  async prompt(params) {
-    const text = extractPromptText(params.prompt);
-    await this.adapter.handlePrompt(params.sessionId, text);
-    return {
-      stopReason: "end_turn"
-    };
-  }
-  async cancel(params) {
-    await this.adapter.cancelPrompt(params.sessionId);
-  }
-  async extMethod(method, params) {
-    if (this.extensionHandler.extMethod) {
-      const result = await this.extensionHandler.extMethod(method, params);
-      if (result) {
-        return result;
-      }
-    }
-    return {
-      error: `Unknown extension method: ${method}`
-    };
-  }
-  async extNotification(method, params) {
-    const sessionId = typeof params.sessionId === "string" ? params.sessionId : typeof params.session_id === "string" ? params.session_id : null;
-    if (!sessionId || !this.adapter.hasSession(sessionId)) {
-      return;
-    }
-    const connection = this.adapter.getConnection();
-    if (!connection) {
-      return;
-    }
-    if (this.extensionHandler.extNotification) {
-      await this.extensionHandler.extNotification(method, params, { sessionId, connection });
-    }
-  }
-};
-function extractPromptText(prompt) {
-  const parts = [];
-  for (const block of prompt) {
-    if (block.type === "text") {
-      parts.push(block.text);
-      continue;
-    }
-    if (block.type === "image") {
-      parts.push(block.uri ? `[Image: ${block.uri}]` : "[Image]");
-      continue;
-    }
-    if (block.type === "audio") {
-      parts.push("[Audio]");
-      continue;
-    }
-    if (block.type === "resource_link") {
-      parts.push(`[Resource: ${block.title ?? block.name ?? block.uri}]`);
-      continue;
-    }
-    if (block.type === "resource") {
-      const resource = block.resource;
-      if ("text" in resource && typeof resource.text === "string") {
-        parts.push(resource.text);
-      } else {
-        parts.push(`[Resource: ${resource.uri ?? "embedded"}]`);
-      }
-    }
-  }
-  return parts.join("\n").trim();
-}
+  createGatewayServer
+} from "./chunk-HNWZZXAE.js";
+import "./chunk-OGOXY43L.js";
+import "./chunk-CBCHTTUY.js";
+import "./chunk-RJNJUISR.js";
+import "./chunk-SHZBLLDQ.js";
+import "./chunk-JIZE4EC6.js";
+import "./chunk-6BE2EG5P.js";
+import "./chunk-TGDDFBYS.js";
+import "./chunk-ZYOXI4JL.js";
+import "./chunk-4OVNFDD7.js";
 export {
   A2AAdapter,
   A2AGatewayAdapter,
@@ -1970,6 +70,9 @@ export {
   CodexAdapter,
   CodexAppServerStdioClient,
   CodexJsonRpcError,
+  CopilotACPAdapter,
+  DEFAULT_COPILOT_ACP_COMMAND,
+  DEFAULT_OMP_ACP_COMMAND,
   GatewayHistoryConverter,
   GatewayServer,
   GeminiAdapter,
@@ -1981,6 +84,7 @@ export {
   LangGraphAdapter,
   LettaAdapter,
   LettaHistoryConverter,
+  OmpACPAdapter,
   OpenAIAdapter,
   OpenAIToolCallingModel,
   OpencodeAdapter,