@band-ai/sdk 0.1.2 → 0.1.4

package/dist/adapters.js

@@ -1,6 +1,4 @@
 import {
-  ACPClientAdapter,
-  ACPServer,
   AnthropicAdapter,
   AnthropicToolCallingModel,
   CODEX_REASONING_EFFORTS,
@@ -22,35 +20,1536 @@ import {
   OpenAIAdapter,
   OpenAIToolCallingModel,
   OpencodeAdapter,
-  ThenvoiACPServerAdapter,
   ToolCallingAdapter,
   VercelAISDKAdapter,
   VercelAISDKToolCallingModel,
   runSingleToolRound
-} from "./chunk-A3TDK6GP.js";
-import "./chunk-NIAQBANR.js";
-import "./chunk-LY55KYVI.js";
-import "./chunk-5CXIMAH2.js";
+} from "./chunk-RHVH2GZR.js";
+import {
+  ThenvoiMcpServer,
+  ThenvoiMcpSseServer
+} from "./chunk-MSL6CWHY.js";
 import "./chunk-EDPKUUJL.js";
+import {
+  ACPClientHistoryConverter,
+  ACPServerHistoryConverter
+} from "./chunk-FYVLUGW7.js";
 import {
   A2AAdapter,
   A2AGatewayAdapter,
   A2AHistoryConverter,
   GatewayHistoryConverter,
   GatewayServer,
+  LazyAsyncValue,
   ParlantAdapter,
   ParlantHistoryConverter,
   buildA2AAuthHeaders,
-  createGatewayServer
-} from "./chunk-FUODYQRE.js";
-import "./chunk-AVVDPXP4.js";
-import "./chunk-INA6YZTZ.js";
+  createGatewayServer,
+  parseToolCall,
+  parseToolResult
+} from "./chunk-W5NDZSYE.js";
+import {
+  SimpleAdapter
+} from "./chunk-AVVDPXP4.js";
+import {
+  ensureHandlePrefix
+} from "./chunk-INA6YZTZ.js";
 import "./chunk-GVEQ3RAH.js";
-import "./chunk-SFVKOEQH.js";
+import {
+  renderSystemPrompt
+} from "./chunk-SFVKOEQH.js";
 import "./chunk-ZZJRRBPQ.js";
 import "./chunk-3BKAC4OZ.js";
 import "./chunk-OD2G5LFQ.js";
-import "./chunk-YR3BOQNW.js";
+import {
+  UnsupportedFeatureError
+} from "./chunk-YR3BOQNW.js";
+
+// src/adapters/acp/ACPClientAdapter.ts
+import { spawn } from "child_process";
+import { Readable, Writable } from "stream";
+
+// 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 ThenvoiACPClient = class {
+  sessionChunks = /* @__PURE__ */ new Map();
+  permissionHandlers = /* @__PURE__ */ new Map();
+  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) {
+    const handler = this.permissionHandlers.get(params.sessionId);
+    if (handler) {
+      return handler(params);
+    }
+    return {
+      outcome: {
+        outcome: "cancelled"
+      }
+    };
+  }
+  setPermissionHandler(sessionId, handler) {
+    if (!handler) {
+      this.permissionHandlers.delete(sessionId);
+      return;
+    }
+    this.permissionHandlers.set(sessionId, handler);
+  }
+  resetSession(sessionId) {
+    this.sessionChunks.delete(sessionId);
+    this.permissionHandlers.delete(sessionId);
+  }
+  getCollectedText(sessionId) {
+    return this.getCollectedChunks(sessionId).filter((chunk) => chunk.chunkType === "text").map((chunk) => chunk.content).join("");
+  }
+  getCollectedChunks(sessionId) {
+    if (sessionId) {
+      return [...this.sessionChunks.get(sessionId) ?? []];
+    }
+    return [...this.sessionChunks.values()].flatMap((chunks) => 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: {}
+        });
+      }
+      return;
+    }
+    if (method === "cursor/task") {
+      const result = toOptionalString(params.result);
+      if (result) {
+        this.appendChunk(sessionId, {
+          chunkType: "text",
+          content: `[Task completed] ${result}`,
+          metadata: {}
+        });
+      }
+    }
+  }
+  appendChunk(sessionId, chunk) {
+    const existing = this.sessionChunks.get(sessionId) ?? [];
+    existing.push(chunk);
+    this.sessionChunks.set(sessionId, existing);
+  }
+};
+function toCollectedChunk(update) {
+  switch (update.sessionUpdate) {
+    case "agent_message_chunk":
+      return {
+        chunkType: "text",
+        content: extractTextFromContent(update.content),
+        metadata: {}
+      };
+    case "agent_thought_chunk":
+      return {
+        chunkType: "thought",
+        content: extractTextFromContent(update.content),
+        metadata: {}
+      };
+    case "tool_call":
+      return {
+        chunkType: "tool_call",
+        content: update.title,
+        metadata: {
+          tool_call_id: update.toolCallId,
+          raw_input: update.rawInput,
+          status: update.status ?? "pending"
+        }
+      };
+    case "tool_call_update":
+      return {
+        chunkType: "tool_result",
+        content: extractToolOutput(update),
+        metadata: {
+          tool_call_id: update.toolCallId,
+          status: update.status ?? "completed"
+        }
+      };
+    case "plan":
+      return {
+        chunkType: "plan",
+        content: update.entries.map((entry) => entry.content).join("\n"),
+        metadata: {}
+      };
+    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 ACPClientAdapter = class extends SimpleAdapter {
+  command;
+  cwd;
+  env;
+  mcpServers;
+  authMethod;
+  enableMemoryTools;
+  enableMcpTools;
+  additionalMcpTools;
+  clientCapabilities;
+  connectionFactory;
+  roomToSession = /* @__PURE__ */ new Map();
+  roomTools = /* @__PURE__ */ new Map();
+  activeSessions = /* @__PURE__ */ new Set();
+  bootstrappedSessions = /* @__PURE__ */ new Set();
+  backend = 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;
+  }
+  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);
+    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.resetSession(sessionId);
+    client.setPermissionHandler(
+      sessionId,
+      (params) => this.handlePermissionRequest(tools, context.roomId, params)
+    );
+    const promptText = this.bootstrappedSessions.has(sessionId) ? message.content : `${this.buildSystemContext(context.roomId, message)}
+
+${message.content}`;
+    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
+    });
+  }
+  async onCleanup(roomId) {
+    const sessionId = this.roomToSession.get(roomId);
+    this.roomToSession.delete(roomId);
+    this.roomTools.delete(roomId);
+    if (sessionId) {
+      this.activeSessions.delete(sessionId);
+      this.bootstrappedSessions.delete(sessionId);
+      this.client?.setPermissionHandler(sessionId, void 0);
+    }
+  }
+  async onRuntimeStop() {
+    await this.stop();
+  }
+  async stop() {
+    this.spawnPromise = null;
+    this.connectionState = null;
+    this.activeSessions.clear();
+    this.bootstrappedSessions.clear();
+    this.roomToSession.clear();
+    this.roomTools.clear();
+    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.roomToSession.set(roomId, 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 ThenvoiACPClient();
+    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();
+      }
+    });
+    return connection;
+  }
+  async getOrCreateSession(roomId, connection) {
+    const existingSessionId = this.roomToSession.get(roomId);
+    const mcpServers = await this.buildSessionMcpServers();
+    if (existingSessionId) {
+      if (this.activeSessions.has(existingSessionId)) {
+        return existingSessionId;
+      }
+      const restored = await this.tryRestoreSession(connection, existingSessionId, mcpServers);
+      if (restored) {
+        this.activeSessions.add(existingSessionId);
+        this.bootstrappedSessions.add(existingSessionId);
+        return existingSessionId;
+      }
+    }
+    const created = await connection.newSession({
+      cwd: this.cwd,
+      mcpServers
+    });
+    this.roomToSession.set(roomId, created.sessionId);
+    this.activeSessions.add(created.sessionId);
+    return created.sessionId;
+  }
+  async tryRestoreSession(connection, sessionId, mcpServers) {
+    try {
+      if (this.connectionState?.agentCapabilities?.loadSession) {
+        await connection.loadSession({
+          cwd: this.cwd,
+          mcpServers,
+          sessionId
+        });
+        return true;
+      }
+      if (this.connectionState?.agentCapabilities?.sessionCapabilities?.resume) {
+        await connection.unstable_resumeSession({
+          cwd: this.cwd,
+          mcpServers,
+          sessionId
+        });
+        return true;
+      }
+    } catch {
+      return false;
+    }
+    return 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("Thenvoi MCP HTTP backend did not expose a URL");
+      }
+      mcpServers.push({
+        type: "http",
+        name: "thenvoi",
+        url,
+        headers: []
+      });
+      return mcpServers;
+    }
+    if (backend.kind === "sse") {
+      const url = backend.server.sseUrl;
+      if (!url) {
+        throw new Error("Thenvoi MCP SSE backend did not expose a URL");
+      }
+      mcpServers.push({
+        type: "sse",
+        name: "thenvoi",
+        url,
+        headers: []
+      });
+      return mcpServers;
+    }
+    return mcpServers;
+  }
+  async getOrCreateBackend() {
+    if (this.backend) {
+      return this.backend;
+    }
+    const transport = this.connectionState?.agentCapabilities?.mcpCapabilities?.http ? "http" : this.connectionState?.agentCapabilities?.mcpCapabilities?.sse ? "sse" : "http";
+    if (transport === "sse") {
+      const server2 = new ThenvoiMcpSseServer({
+        tools: (roomId) => this.roomTools.get(roomId),
+        enableMemoryTools: this.enableMemoryTools,
+        enableContactTools: true,
+        additionalTools: this.additionalMcpTools
+      });
+      await server2.start();
+      this.backend = {
+        kind: "sse",
+        server: server2,
+        stop: async () => {
+          await server2.stop();
+        }
+      };
+      return this.backend;
+    }
+    const server = new ThenvoiMcpServer({
+      tools: (roomId) => this.roomTools.get(roomId),
+      enableMemoryTools: this.enableMemoryTools,
+      enableContactTools: true,
+      additionalTools: this.additionalMcpTools
+    });
+    await server.start();
+    this.backend = {
+      kind: "http",
+      server,
+      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 Thenvoi using Thenvoi MCP tools.",
+      "Use the Thenvoi 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 Thenvoi MCP tool calls must include room_id."
+    ].join("\n");
+  }
+  async handlePermissionRequest(tools, roomId, params) {
+    const selected = choosePermissionOption(params.options);
+    const toolName = params.toolCall.title ?? "unknown";
+    await 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: selected !== null
+    });
+    if (!selected) {
+      return {
+        outcome: {
+          outcome: "cancelled"
+        }
+      };
+    }
+    return {
+      outcome: {
+        outcome: "selected",
+        optionId: selected.optionId
+      }
+    };
+  }
+  async flushChunks(input) {
+    const client = this.client;
+    if (!client) {
+      return;
+    }
+    for (const chunk of client.getCollectedChunks(input.sessionId)) {
+      if (chunk.chunkType === "text") {
+        if (chunk.content.length > 0) {
+          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/ThenvoiACPServerAdapter.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/ThenvoiACPServerAdapter.ts
+var DEFAULT_MAX_SESSIONS = 100;
+var DEFAULT_PROMPT_TIMEOUT_MS = 3e5;
+var DEFAULT_PROMPT_COMPLETION_GRACE_MS = 250;
+var ThenvoiACPServerAdapter = class extends SimpleAdapter {
+  thenvoiRest;
+  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.thenvoiRest = options.thenvoiRest;
+    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.thenvoiRest.getAgentMe();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async onStarted(agentName, agentDescription) {
+    await super.onStarted(agentName, agentDescription);
+    try {
+      const identity = await this.thenvoiRest.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.thenvoiRest.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.thenvoiRest.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.thenvoiRest.listChatParticipants(roomId);
+    const mentions = this.resolveMentions(participants, resolved.targetPeer);
+    try {
+      await this.thenvoiRest.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 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 ?? "thenvoi-agent",
+        title: this.agentInfo.title ?? this.adapter.displayName ?? "Thenvoi 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();
+}
 export {
   A2AAdapter,
   A2AGatewayAdapter,