@band-ai/sdk 0.4.2 → 0.4.3

package/dist/{chunk-KXLV645N.js → chunk-VHYPQAQ5.js}

@@ -5926,74 +5926,17 @@ import { spawn as spawn2 } from "child_process";
 import { createConnection } from "net";
 import { Duplex, 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 BandACPClient = class {
   sessionChunks = /* @__PURE__ */ new Map();
   permissionHandler;
+  extensionHandler;
   // 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) {
+  constructor(permissionHandler, extensionHandler) {
     this.permissionHandler = permissionHandler;
+    this.extensionHandler = extensionHandler;
   }
   beginSession(sessionId) {
     this.sessionChunks.set(sessionId, []);
@@ -6038,62 +5981,26 @@ var BandACPClient = class {
     return 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 {};
+    const result = await this.extensionHandler?.extMethod?.(
+      method,
+      params,
+      { sessionId: sessionIdFrom(params) }
+    );
+    return result ?? {};
   }
   async extNotification(method, params) {
-    const sessionId = toOptionalString(params.sessionId) ?? toOptionalString(params.session_id);
-    if (!sessionId) {
+    const sessionId = sessionIdFrom(params);
+    const chunks = await this.extensionHandler?.extNotification?.(
+      method,
+      params,
+      { sessionId }
+    );
+    const targetSessionId = sessionId ?? this.extensionHandler?.extensionSessionId?.() ?? null;
+    if (!targetSessionId || !chunks) {
       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
-        });
-      }
+    for (const chunk of chunks) {
+      this.appendChunk(targetSessionId, chunk);
     }
   }
   appendChunk(sessionId, chunk) {
@@ -6218,6 +6125,68 @@ function extractTextFromContent(content) {
 function toOptionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
+function sessionIdFrom(params) {
+  return toOptionalString(params.sessionId) ?? toOptionalString(params.session_id);
+}
+
+// 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/loader.ts
 var acpModule = new LazyAsyncValue({
@@ -6263,6 +6232,7 @@ var ACPClientAdapter = class extends SimpleAdapter {
   additionalMcpTools;
   clientCapabilities;
   connectionFactory;
+  extensionHandler;
   tcpEndpoint;
   // The value's `generation` is the connection generation the session was
   // last established/restored against. `client` is the exact BandACPClient
@@ -6327,6 +6297,7 @@ var ACPClientAdapter = class extends SimpleAdapter {
     this.additionalMcpTools = [...options.additionalMcpTools ?? []];
     this.clientCapabilities = options.clientCapabilities;
     this.connectionFactory = options.connectionFactory;
+    this.extensionHandler = options.extensionHandler;
     this.tcpEndpoint = tcpEndpoint;
     this.resolvePermission = options.resolvePermission;
     this.resolveSessionMode = options.resolveSessionMode;
@@ -6382,6 +6353,7 @@ var ACPClientAdapter = class extends SimpleAdapter {
     let client = null;
     let sessionId;
     let generation = 0;
+    await this.onAcpTurnStarted(message, tools, context);
     try {
       const ensured = await this.ensureConnection();
       connection = ensured.connection;
@@ -6392,6 +6364,7 @@ var ACPClientAdapter = class extends SimpleAdapter {
       }
       sessionId = await this.getOrCreateSession(context.roomId, connection, generation, client);
       const sessionKey = this.sessionKey(generation, sessionId);
+      await this.onAcpSessionReady(message, tools, context, sessionId);
       client.beginSession(sessionId);
       const content = replaceUuidMentions(message.content, mentionSubjectsFromMetadata(message.metadata));
       const messageWithContext = [...systemUpdateParts(participantsMessage, contactsMessage), content].join("\n\n");
@@ -6462,8 +6435,16 @@ ${messageWithContext}`;
           ...configError ? { optionId: configError.optionId, selectedValue: configError.selectedValue } : {}
         }
       );
+    } finally {
+      await this.onAcpTurnFinished(message, tools, context);
     }
   }
+  async onAcpTurnStarted(_message, _tools, _context) {
+  }
+  async onAcpTurnFinished(_message, _tools, _context) {
+  }
+  async onAcpSessionReady(_message, _tools, _context, _sessionId) {
+  }
   // Best-effort: tells the agent to stop working on a turn Band has already
   // given up waiting for (the ACP client has no way to force it), evicts the
   // session so the room's next turn re-establishes rather than reuses it
@@ -6633,6 +6614,9 @@ ${messageWithContext}`;
   sessionKey(generation, sessionId) {
     return `${generation}:${sessionId}`;
   }
+  roomIdForSession(sessionId) {
+    return [...this.roomToSession.entries()].find(([, owner]) => owner.sessionId === sessionId)?.[0];
+  }
   async ensureConnection() {
     if (this.connection && !this.connection.signal.aborted) {
       return { connection: this.connection, generation: this.connectionGeneration };
@@ -6669,7 +6653,10 @@ ${messageWithContext}`;
         throw new Error(CONNECTION_ATTEMPT_SUPERSEDED_ERROR);
       }
       const owner = { generation: -1 };
-      const client = new BandACPClient((params) => this.routePermissionRequest(params, owner.generation));
+      const client = new BandACPClient(
+        (params) => this.routePermissionRequest(params, owner.generation),
+        this.extensionHandler
+      );
       handle = await (this.connectionFactory ? this.connectionFactory(client, {
         command: this.command,
         cwd: this.cwd,
@@ -8304,6 +8291,358 @@ var CopilotACPAdapter = class extends ACPClientAdapter {
   }
 };
 
+// src/adapters/cursor-acp/CursorACPAdapter.ts
+var DEFAULT_CURSOR_ACP_COMMAND = ["agent", "acp"];
+var DEFAULT_CURSOR_DECISION_TIMEOUT_MS = 3e5;
+var DEFAULT_CURSOR_MAX_PENDING_DECISIONS = 10;
+var CursorExtensions = class {
+  adapter = null;
+  todosBySession = /* @__PURE__ */ new Map();
+  bind(adapter) {
+    this.adapter = adapter;
+  }
+  async resolvePermission(request, signal) {
+    return this.adapter?.resolveCursorPermission(request, signal);
+  }
+  extensionSessionId() {
+    return this.adapter?.extensionSessionId() ?? null;
+  }
+  async extMethod(method, params, context) {
+    return this.adapter?.resolveExtension(method, params, context.sessionId) ?? null;
+  }
+  async extNotification(method, params, context) {
+    const sessionId = context.sessionId ?? this.extensionSessionId();
+    if (!sessionId) {
+      return;
+    }
+    if (method === "cursor/update_todos") {
+      const content = this.updateTodos(sessionId, params);
+      if (!content) {
+        return;
+      }
+      return [{ chunkType: "plan", content, metadata: { cursor_todos: true }, streamed: false }];
+    }
+    if (method === "cursor/task") {
+      const description = stringValue(params.description);
+      if (!description) {
+        return [];
+      }
+      const subagentType = stringValue(params.subagentType) ?? "unspecified";
+      const model = stringValue(params.model);
+      const suffix = model ? ` (${model})` : "";
+      return [{ chunkType: "plan", content: `[Cursor ${subagentType} task] ${description}${suffix}`, metadata: {}, streamed: false }];
+    }
+    if (method === "cursor/generate_image") {
+      const description = stringValue(params.description);
+      if (!description) {
+        return [];
+      }
+      const filePath = stringValue(params.filePath);
+      return [{ chunkType: "plan", content: `[Cursor generated image] ${description}${filePath ? ` \u2192 ${filePath}` : ""}`, metadata: {}, streamed: false }];
+    }
+  }
+  forgetSession(sessionId) {
+    this.todosBySession.delete(sessionId);
+  }
+  clearSessions() {
+    this.todosBySession.clear();
+  }
+  updateTodos(sessionId, params) {
+    const todos = parseTodos(params.todos);
+    if (params.merge === true) {
+      const current2 = this.todosBySession.get(sessionId) ?? /* @__PURE__ */ new Map();
+      for (const todo of todos) {
+        current2.set(todo.id, todo);
+      }
+      this.todosBySession.set(sessionId, current2);
+    } else {
+      this.todosBySession.set(sessionId, new Map(todos.map((todo) => [todo.id, todo])));
+    }
+    const current = this.todosBySession.get(sessionId);
+    return current && current.size > 0 ? [...current.values()].map((todo) => `- [${todoMark(todo.status)}] ${todo.content}`).join("\n") : void 0;
+  }
+};
+var CursorACPAdapter = class extends ACPClientAdapter {
+  provider = "cursor-acp";
+  approvalMode;
+  questionMode;
+  planMode;
+  decisionTimeoutMs;
+  maxPendingDecisions;
+  authorizedSenders;
+  decisionLogger;
+  extensions;
+  turns = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  activeTurn = null;
+  turnTail = Promise.resolve();
+  constructor(options = {}) {
+    const extensions = new CursorExtensions();
+    validateOptions(options);
+    const env = cursorEnv(options);
+    super({
+      ...options,
+      env,
+      command: options.command ?? [...DEFAULT_CURSOR_ACP_COMMAND],
+      authMethod: "cursor_login",
+      extensionHandler: extensions,
+      resolvePermission: (request, signal) => extensions.resolvePermission(request, signal)
+    });
+    extensions.bind(this);
+    this.extensions = extensions;
+    this.approvalMode = options.approvalMode ?? "manual";
+    this.questionMode = options.questionMode ?? "manual";
+    this.planMode = options.planMode ?? "manual";
+    this.decisionTimeoutMs = options.decisionTimeoutMs ?? DEFAULT_CURSOR_DECISION_TIMEOUT_MS;
+    this.maxPendingDecisions = options.maxPendingDecisions ?? DEFAULT_CURSOR_MAX_PENDING_DECISIONS;
+    this.authorizedSenders = options.decisionAuthorizedSenders ? new Set(options.decisionAuthorizedSenders) : null;
+    this.decisionLogger = resolveLogger(options.logger);
+  }
+  async onMessage(message, tools, history, participantsMessage, contactsMessage, context) {
+    if (await this.handleControl(message, tools, context.roomId)) {
+      return;
+    }
+    await this.withCursorTurnLock(() => super.onMessage(message, tools, history, participantsMessage, contactsMessage, context));
+  }
+  async onAcpTurnStarted(message, tools, context) {
+    const turn = { messageId: message.id, roomId: context.roomId, tools, requesterId: message.senderId };
+    this.turns.set(context.roomId, turn);
+    this.activeTurn = turn;
+  }
+  async onAcpSessionReady(message, _tools, context, sessionId) {
+    const turn = this.turns.get(context.roomId);
+    if (turn?.messageId === message.id) {
+      turn.sessionId = sessionId;
+    }
+  }
+  async onAcpTurnFinished(message, _tools, context) {
+    const turn = this.turns.get(context.roomId);
+    if (turn?.messageId === message.id) {
+      this.turns.delete(context.roomId);
+      this.cancelRoom(context.roomId);
+    }
+    if (this.activeTurn?.messageId === message.id) {
+      this.activeTurn = null;
+    }
+  }
+  async onCleanup(roomId) {
+    const sessionId = this.turns.get(roomId)?.sessionId;
+    this.cancelRoom(roomId);
+    this.turns.delete(roomId);
+    if (this.activeTurn?.roomId === roomId) {
+      this.activeTurn = null;
+    }
+    await super.onCleanup(roomId);
+    if (sessionId) {
+      this.extensions.forgetSession(sessionId);
+    }
+  }
+  async stop() {
+    for (const decision of this.pending.values()) {
+      decision.resolve(void 0);
+    }
+    this.pending.clear();
+    this.turns.clear();
+    this.activeTurn = null;
+    this.extensions.clearSessions();
+    await super.stop();
+  }
+  async resolveExtension(method, params, sessionId) {
+    const roomId = sessionId ? this.roomIdForSession(sessionId) : this.activeTurn?.roomId;
+    const turn = roomId ? this.turns.get(roomId) : void 0;
+    if (!turn || sessionId && turn.sessionId !== sessionId) {
+      return { outcome: { outcome: "cancelled" } };
+    }
+    if (method === "cursor/ask_question") {
+      return this.resolveQuestion(turn.roomId, turn, params);
+    }
+    if (method === "cursor/create_plan") {
+      return this.resolvePlan(turn.roomId, turn, params);
+    }
+    return {};
+  }
+  async resolveCursorPermission(request, signal) {
+    if (this.approvalMode === "autoAccept") {
+      return allowOption(request.options)?.optionId;
+    }
+    if (this.approvalMode === "autoDecline") {
+      return void 0;
+    }
+    const turn = this.turns.get(request.roomId);
+    if (!turn) {
+      return void 0;
+    }
+    const options = request.options.map((option) => option.optionId);
+    const token = await this.waitForDecision("permission", request.roomId, turn, /* @__PURE__ */ new Map([["permission", options]]), /* @__PURE__ */ new Set(), `Cursor needs permission. Reply \`/cursor select {token} option-id\` or \`/cursor deny {token}\`.`, signal);
+    return typeof token === "string" && options.includes(token) ? token : void 0;
+  }
+  extensionSessionId() {
+    return this.activeTurn?.sessionId ?? null;
+  }
+  async resolveQuestion(roomId, turn, params) {
+    const questions = questionChoices(params.questions);
+    if (questions.choices.size === 0) {
+      return { outcome: { outcome: "cancelled" } };
+    }
+    if (this.questionMode === "autoCancel") {
+      return { outcome: { outcome: "cancelled" } };
+    }
+    if (this.questionMode === "autoFirst") {
+      return answered(Object.fromEntries([...questions.choices].map(([id, options]) => [id, [options[0]]])));
+    }
+    const result = await this.waitForDecision("question", roomId, turn, questions.choices, questions.multiSelect, "Cursor needs input. Reply `/cursor answer {token} question-id=option-id[,option-id] ...`.");
+    return isRecord2(result) ? result : { outcome: { outcome: "cancelled" } };
+  }
+  async resolvePlan(roomId, turn, params) {
+    if (this.planMode === "autoAccept") {
+      return { outcome: { outcome: "accepted" } };
+    }
+    if (this.planMode === "autoDecline") {
+      return { outcome: { outcome: "rejected" } };
+    }
+    const title = stringValue(params.title) ?? "Cursor plan";
+    const result = await this.waitForDecision("plan", roomId, turn, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set(), `${title} needs approval. Reply \`/cursor accept {token}\` or \`/cursor reject {token}\`.`);
+    return isRecord2(result) ? result : { outcome: { outcome: "cancelled" } };
+  }
+  async waitForDecision(kind, roomId, turn, choices, multiSelect, prompt, signal) {
+    if (this.pending.size >= this.maxPendingDecisions) {
+      this.pending.values().next().value?.resolve(void 0);
+    }
+    const token = crypto.randomUUID().slice(0, 8);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => settle(void 0), this.decisionTimeoutMs);
+      const abort = () => settle(void 0);
+      const settle = (value) => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", abort);
+        this.pending.delete(token);
+        resolve(value);
+      };
+      this.pending.set(token, { kind, roomId, choices, multiSelect, resolve: settle });
+      signal?.addEventListener("abort", abort, { once: true });
+      void turn.tools.sendMessage(prompt.replaceAll("{token}", token), [turn.requesterId]).catch((error) => {
+        this.decisionLogger.warn("cursor_acp.decision_prompt_delivery_failed", { roomId, kind, error: String(error) });
+        settle(void 0);
+      });
+    });
+  }
+  async handleControl(message, tools, roomId) {
+    const words = message.content.trim().split(/\s+/);
+    if (words[0]?.toLowerCase() !== "/cursor") {
+      return false;
+    }
+    if (words.length === 1 || words[1]?.toLowerCase() === "decisions") {
+      const entries = [...this.pending.entries()].filter(([, decision2]) => decision2.roomId === roomId).map(([token2, decision2]) => `\`${token2}\` (${decision2.kind})`);
+      await tools.sendMessage(`Pending Cursor decisions: ${entries.join(", ") || "none"}`);
+      return true;
+    }
+    const [_, action, token, ...args] = words;
+    const decision = token ? this.pending.get(token) : void 0;
+    if (!decision || decision.roomId !== roomId) {
+      await tools.sendMessage(`Cursor decision \`${token ?? ""}\` is not pending.`);
+      return true;
+    }
+    if (this.authorizedSenders && !this.authorizedSenders.has(message.senderId)) {
+      await tools.sendMessage("You are not authorized to resolve Cursor decisions.");
+      return true;
+    }
+    const result = commandResult(action ?? "", args, decision);
+    if (result === null) {
+      await tools.sendMessage(`That command is not valid for Cursor ${decision.kind} decision \`${token}\`.`);
+      return true;
+    }
+    decision.resolve(result);
+    await tools.sendMessage(`Cursor ${decision.kind} decision \`${token}\` resolved.`);
+    return true;
+  }
+  cancelRoom(roomId) {
+    for (const [token, decision] of this.pending) {
+      if (decision.roomId === roomId) {
+        decision.resolve(void 0);
+        this.pending.delete(token);
+      }
+    }
+  }
+  async withCursorTurnLock(run) {
+    const queued = this.turnTail.then(run, run);
+    this.turnTail = queued.then(() => void 0, () => void 0);
+    return queued;
+  }
+};
+function cursorEnv(options) {
+  const env = { ...options.env };
+  if (options.apiKey) env.CURSOR_API_KEY ??= options.apiKey;
+  if (options.authToken) env.CURSOR_AUTH_TOKEN ??= options.authToken;
+  return Object.keys(env).length > 0 ? env : void 0;
+}
+function validateOptions(options) {
+  if (options.apiKey && options.authToken) throw new Error("set either apiKey or authToken, not both");
+  if (Array.isArray(options.command) && options.command.length === 0) throw new Error("Cursor ACP command must not be empty");
+  if (options.decisionTimeoutMs !== void 0 && (!Number.isFinite(options.decisionTimeoutMs) || options.decisionTimeoutMs <= 0)) throw new Error("decisionTimeoutMs must be a positive finite number");
+  if (options.maxPendingDecisions !== void 0 && (!Number.isInteger(options.maxPendingDecisions) || options.maxPendingDecisions <= 0)) throw new Error("maxPendingDecisions must be a positive integer");
+}
+function allowOption(options) {
+  return options.find((option) => option.kind === "allow_once") ?? options.find((option) => option.kind === "allow_always");
+}
+function questionChoices(value) {
+  const choices = /* @__PURE__ */ new Map();
+  const multiSelect = /* @__PURE__ */ new Set();
+  if (!Array.isArray(value)) return { choices, multiSelect };
+  for (const question of value) {
+    if (!isRecord2(question) || typeof question.id !== "string" || !Array.isArray(question.options)) continue;
+    const options = question.options.filter(isRecord2).map((option) => stringValue(option.id)).filter((id) => !!id);
+    if (options.length === 0) continue;
+    choices.set(question.id, options);
+    if (question.allowMultiple === true) multiSelect.add(question.id);
+  }
+  return { choices, multiSelect };
+}
+function commandResult(action, args, decision) {
+  if (decision.kind === "permission") return action === "deny" ? void 0 : action === "select" && args.length === 1 && decision.choices.get("permission")?.includes(args[0] ?? "") ? args[0] : null;
+  if (decision.kind === "plan") return action === "accept" ? { outcome: { outcome: "accepted" } } : action === "reject" ? { outcome: { outcome: "rejected" } } : null;
+  if (action !== "answer") return null;
+  const selected = {};
+  for (const argument of args) {
+    const [id, raw] = argument.split("=", 2);
+    const values = raw?.split(",") ?? [];
+    const offered = id ? decision.choices.get(id) : void 0;
+    if (!id || !offered || selected[id] || values.length === 0 || values.length > 1 && !decision.multiSelect.has(id) || values.some((value) => !offered.includes(value))) return null;
+    selected[id] = values;
+  }
+  return Object.keys(selected).length === decision.choices.size ? answered(selected) : null;
+}
+function answered(selected) {
+  return { outcome: { outcome: "answered", answers: Object.entries(selected).map(([questionId, selectedOptionIds]) => ({ questionId, selectedOptionIds })) } };
+}
+function parseTodos(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((todo) => {
+    if (!isRecord2(todo)) return [];
+    const id = stringValue(todo.id);
+    const content = stringValue(todo.content);
+    const status = stringValue(todo.status);
+    return id && content && status ? [{ id, content, status }] : [];
+  });
+}
+function todoMark(status) {
+  switch (status) {
+    case "completed":
+      return "x";
+    case "in_progress":
+      return "~";
+    case "cancelled":
+      return "-";
+    default:
+      return " ";
+  }
+}
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
 export {
   GenericAdapter,
   CodexJsonRpcError,
@@ -8340,5 +8679,7 @@ export {
   DEFAULT_OMP_ACP_COMMAND,
   OmpACPAdapter,
   DEFAULT_COPILOT_ACP_COMMAND,
-  CopilotACPAdapter
+  CopilotACPAdapter,
+  DEFAULT_CURSOR_ACP_COMMAND,
+  CursorACPAdapter
 };