@prismatic-io/lux 0.0.2-preview.18 → 0.0.2-preview.21

package/src/drivers/copilot/index.ts

@@ -0,0 +1,292 @@
+import { realpath } from "node:fs/promises";
+import {
+  type AgentDriver,
+  type Answer,
+  type Artifact,
+  type DriverEventMap,
+  defineDriver,
+  discoverCliVersion,
+  type ReadyState,
+  type StartContext,
+  selectModelAndReasoningEffort,
+  TypedEmitter,
+} from "../../core/index.js";
+import { AcpEvents } from "../shared/acp-events.js";
+import { permissionAnswer, permissionRequestText, records } from "../shared/acp-interaction.js";
+import { AcpTransport, asRecord, type RpcId, type RpcRecord } from "../shared/acp-transport.js";
+import { walkArtifacts } from "../shared/artifacts.js";
+import {
+  buildCopilotArgs,
+  COPILOT_MODE_IDS,
+  type CopilotDriverConfig,
+  CopilotDriverConfigSchema,
+} from "./config.js";
+
+class CopilotDriver implements AgentDriver {
+  private readonly emitter = new TypedEmitter<DriverEventMap>();
+  private readonly events: AcpEvents;
+  private transport: AcpTransport | undefined;
+  private sessionId: string | undefined;
+  private cwd: string | undefined;
+  private artifactsDir: string | undefined;
+  private ready = false;
+  private runPromise: Promise<void> | undefined;
+  private terminal = false;
+  private idleTimer: NodeJS.Timeout | undefined;
+  private interruptCount = 0;
+  private readonly interrupts = new Map<string, { id: RpcId; params: RpcRecord }>();
+
+  private readonly config: CopilotDriverConfig;
+
+  constructor(config: CopilotDriverConfig) {
+    this.config = config;
+    this.events = new AcpEvents("copilot", config.maxToolCalls, config.maxQueuedBytes);
+  }
+
+  on<K extends keyof DriverEventMap>(
+    event: K,
+    handler: (e: DriverEventMap[K]) => void | Promise<void>,
+  ): void {
+    this.emitter.on(event, handler);
+  }
+  off<K extends keyof DriverEventMap>(
+    event: K,
+    handler: (e: DriverEventMap[K]) => void | Promise<void>,
+  ): void {
+    this.emitter.off(event, handler);
+  }
+
+  async start(ctx: StartContext): Promise<ReadyState> {
+    if (this.transport || this.terminal)
+      throw new Error("Copilot driver cannot be started twice or after close");
+    this.cwd = await realpath(this.config.cwd ?? ctx.artifactsDir);
+    this.artifactsDir = await realpath(ctx.artifactsDir);
+    const cliVersion = await discoverCliVersion(this.config.command);
+    const transport = new AcpTransport({
+      label: "Copilot ACP",
+      command: this.config.command,
+      args: buildCopilotArgs(this.config),
+      cwd: this.cwd,
+      env: { ...process.env, ...this.config.env },
+      signal: ctx.abortSignal,
+      maxLineBytes: this.config.maxLineBytes,
+      maxQueuedBytes: this.config.maxQueuedBytes,
+      onMessage: (message) => this.message(message),
+      onFailure: (error) => this.fail(error),
+      onActivity: () => this.bumpIdleTimer(),
+    });
+    this.transport = transport;
+    try {
+      await transport.spawned();
+      const initialized = await this.request("initialize", {
+        protocolVersion: 1,
+        clientInfo: { name: "lux", version: "1" },
+        clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+      });
+      if (initialized.protocolVersion !== 1)
+        throw new Error("Copilot ACP returned an unsupported protocol version");
+      if (!records(initialized.authMethods).some((method) => method.id === "copilot-login")) {
+        throw new Error(
+          "Expected Copilot ACP with copilot-login authentication; check the configured command points to GitHub Copilot CLI",
+        );
+      }
+      const session = await this.request("session/new", { cwd: this.cwd, mcpServers: [] });
+      if (typeof session.sessionId !== "string") throw new Error("Copilot ACP omitted sessionId");
+      this.sessionId = session.sessionId;
+      const modeId = COPILOT_MODE_IDS[this.config.mode];
+      const currentModeId = asRecord(session.modes)?.currentModeId;
+      if (currentModeId !== modeId) {
+        if (!records(asRecord(session.modes)?.availableModes).some((mode) => mode.id === modeId))
+          throw new Error(`Copilot ACP does not advertise the '${this.config.mode}' mode`);
+        await this.request("session/set_mode", { sessionId: this.sessionId, modeId });
+      }
+      this.ready = true;
+      this.bumpIdleTimer();
+      this.runPromise = this.run(ctx.prompt).catch((error: unknown) => this.fail(error));
+      return {
+        agentId: "copilot",
+        model: this.config.model,
+        ...(typeof asRecord(initialized.agentInfo)?.version === "string"
+          ? { agentVersion: String(asRecord(initialized.agentInfo)?.version) }
+          : {}),
+        detail: {
+          sessionId: this.sessionId,
+          transport: "acp",
+          protocolVersion: 1,
+          ...(cliVersion ? { cliVersion } : {}),
+          mode: this.config.mode,
+          reasoningEffort: this.config.reasoningEffort,
+          modelResolution: "requested",
+          nativeConfig: session.configOptions ?? [],
+          usageAvailability: "unknown",
+          isolation: "none",
+        },
+      };
+    } catch (error) {
+      await this.close();
+      throw error;
+    }
+  }
+
+  private request(method: string, params: RpcRecord): Promise<RpcRecord> {
+    if (!this.transport) throw new Error("Copilot ACP has not started");
+    return this.transport.request(method, params, this.config.startupTimeoutMs);
+  }
+
+  private async run(prompt: string): Promise<void> {
+    const result = await this.transport?.request("session/prompt", {
+      sessionId: this.sessionId,
+      prompt: [{ type: "text", text: prompt }],
+    });
+    await this.transport?.drained();
+    if (this.terminal) return;
+    if (result?.stopReason !== "end_turn")
+      throw new Error(`Copilot stopped with ${String(result?.stopReason ?? "unknown reason")}`);
+    this.terminal = true;
+    clearTimeout(this.idleTimer);
+    await this.emitter.emit("done", {
+      exitReason: "done",
+      summary: {
+        sessionId: this.sessionId,
+        stopReason: result.stopReason,
+        usageAvailability: "unknown",
+      },
+    });
+  }
+
+  private async message(message: RpcRecord): Promise<void> {
+    if (this.terminal) return;
+    const method = String(message.method);
+    const params = asRecord(message.params) ?? {};
+    const id = message.id;
+    if (typeof id === "number" || typeof id === "string") {
+      if (typeof params.sessionId === "string" && params.sessionId !== this.sessionId) {
+        this.transport?.write({ id, error: { code: -32602, message: "Unknown session" } });
+        return;
+      }
+      if (method !== "session/request_permission") {
+        this.transport?.write({
+          id,
+          error: { code: -32601, message: `Unsupported method: ${method}` },
+        });
+        return;
+      }
+      if (++this.interruptCount > this.config.maxInterrupts) {
+        this.transport?.write({ id, result: { outcome: { outcome: "cancelled" } } });
+        throw new Error("Copilot exceeded maxInterrupts");
+      }
+      const interruptId = `copilot-${id}`;
+      if (this.interrupts.has(interruptId)) throw new Error("Copilot reused a pending request ID");
+      this.interrupts.set(interruptId, { id, params });
+      clearTimeout(this.idleTimer);
+      await this.emitter.emit("interrupt", {
+        kind: "approve",
+        id: interruptId,
+        request: permissionRequestText(params),
+        context: params,
+      });
+      return;
+    }
+    if (method === "session/update") {
+      if (params.sessionId !== this.sessionId) return;
+      const update = asRecord(params.update);
+      if (update)
+        for (const event of this.events.update(update)) await this.emitter.emit("progress", event);
+    }
+  }
+
+  async respond(answer: Answer): Promise<void> {
+    const pending = this.interrupts.get(answer.id);
+    if (!pending) throw new Error(`Copilot has no pending interrupt '${answer.id}'`);
+    this.transport?.write({ id: pending.id, result: permissionAnswer(pending.params, answer) });
+    this.interrupts.delete(answer.id);
+    this.bumpIdleTimer();
+  }
+
+  private bumpIdleTimer(): void {
+    clearTimeout(this.idleTimer);
+    if (!this.ready || this.terminal || this.interrupts.size > 0) return;
+    this.idleTimer = setTimeout(
+      () =>
+        this.fail(
+          new Error(`Copilot emitted no event for ${this.config.idleTimeoutMs}ms`),
+          "idle-timeout",
+        ),
+      this.config.idleTimeoutMs,
+    );
+  }
+
+  private fail(error: unknown, exitReason: "error" | "idle-timeout" = "error"): void {
+    if (this.terminal) return;
+    this.terminal = true;
+    clearTimeout(this.idleTimer);
+    if (this.ready)
+      void this.transport?.drained().then(() =>
+        this.emitter.emit("error", {
+          exitReason,
+          reason: error instanceof Error ? error.message : String(error),
+        }),
+      );
+    void this.transport?.close();
+  }
+
+  async quiesce(): Promise<void> {
+    clearTimeout(this.idleTimer);
+    const cancelling = !this.terminal && this.sessionId !== undefined;
+    this.terminal = true;
+    if (cancelling) {
+      for (const pending of this.interrupts.values())
+        this.transport?.write({ id: pending.id, result: { outcome: { outcome: "cancelled" } } });
+      this.transport?.write({ method: "session/cancel", params: { sessionId: this.sessionId } });
+      let timer: NodeJS.Timeout | undefined;
+      try {
+        await Promise.race([
+          this.runPromise,
+          new Promise<void>((resolve) => {
+            timer = setTimeout(resolve, 200);
+          }),
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    this.interrupts.clear();
+    await this.transport?.close();
+  }
+
+  async collect(): Promise<Artifact[]> {
+    await this.quiesce();
+    if (!this.cwd) return [];
+    const artifacts = await walkArtifacts(this.cwd);
+    return this.cwd === this.artifactsDir
+      ? artifacts
+      : artifacts.map((artifact) => ({ ...artifact, root: this.cwd as string }));
+  }
+
+  async close(): Promise<void> {
+    await this.quiesce();
+    this.emitter.removeAllListeners();
+  }
+}
+
+export const copilotDriver = defineDriver({
+  name: "copilot",
+  configSchema: CopilotDriverConfigSchema,
+  runtime: (config) => ({
+    commands: [config.command],
+    capabilities: {
+      interactive: !config.allowAllTools,
+      "tool-calls": true,
+      "tool-results": true,
+      artifacts: true,
+      usage: false,
+      cost: false,
+      isolation: false,
+    },
+  }),
+  selectHarness: selectModelAndReasoningEffort,
+  create: (config) => new CopilotDriver(config),
+});
+
+export type { CopilotDriverConfig };
+export { buildCopilotArgs, CopilotDriverConfigSchema };

package/src/drivers/cursor/README.md

@@ -10,17 +10,20 @@ set `command` to its absolute path if another application owns that name.
   config: {
     command: "/absolute/path/to/cursor/agent",
     model: "YOUR_CURSOR_MODEL_ID",
-    // Optional: only accepted when ACP advertises this effort value.
+    // Optional: one of low, medium, high, xhigh; applied only when ACP advertises it.
     // reasoningEffort: "low",
   },
 }
 ```
 
-`model` is required. Use an explicit model ID from your installed Cursor CLI;
-some IDs encode reasoning effort. Lux passes that ID through `--model` and
-rejects a different model when the session reports one. If `reasoningEffort` is
-supplied, Lux requires a matching advertised ACP thought-level selector and
-checks the response confirms the requested value before sending the prompt.
+`model` is required. Cursor's model list is account-scoped (`agent
+--list-models` after login), so the harness catalog keeps it open: any ID is
+accepted in configuration and in a `matrix`, and some IDs encode reasoning
+effort. Lux passes that ID through `--model` and rejects a different model when
+the session reports one. If `reasoningEffort` is supplied (`low`, `medium`,
+`high`, or `xhigh`), Lux requires a matching advertised ACP thought-level
+selector and checks the response confirms the requested value before sending
+the prompt. No default effort is applied.
 
 Supported interactions are Cursor's native multiple-choice questions, plan
 approval, and ACP tool permissions. Lux grants one-operation permissions only;

package/src/drivers/cursor/config.ts

@@ -1,12 +1,11 @@
 import { z } from "zod";
+import { cursorCatalog } from "../../core/index.js";
 
 export const CursorDriverConfigSchema = z
   .object({
     command: z.string().min(1).default("agent"),
-    /** Cursor model IDs may include an effort suffix; never inherit Auto. */
     model: z.string().min(1),
-    /** Applied only through an advertised ACP thought-level selector. */
-    reasoningEffort: z.string().min(1).optional(),
+    reasoningEffort: z.enum(cursorCatalog.efforts).optional(),
     mode: z.enum(["agent", "plan", "ask"]).default("agent"),
     cwd: z.string().optional(),
     env: z.record(z.string(), z.string()).optional(),

package/src/drivers/cursor/index.ts

@@ -8,17 +8,19 @@ import {
   discoverCliVersion,
   type ReadyState,
   type StartContext,
+  selectModelAndReasoningEffort,
   TypedEmitter,
 } from "../../core/index.js";
+import { AcpEvents } from "../shared/acp-events.js";
+import { permissionRequestText, records } from "../shared/acp-interaction.js";
+import { AcpTransport, asRecord, type RpcId, type RpcRecord } from "../shared/acp-transport.js";
 import { walkArtifacts } from "../shared/artifacts.js";
-import { AcpTransport, asRecord, type RpcId, type RpcRecord } from "./acp-transport.js";
 import { buildCursorArgs, type CursorDriverConfig, CursorDriverConfigSchema } from "./config.js";
-import { CursorEvents } from "./events.js";
-import { cursorAnswer, cursorQuestionText, effortSelector, records } from "./interaction.js";
+import { cursorAnswer, cursorQuestionText, effortSelector } from "./interaction.js";
 
 class CursorDriver implements AgentDriver {
   private readonly emitter = new TypedEmitter<DriverEventMap>();
-  private readonly events: CursorEvents;
+  private readonly events: AcpEvents;
   private transport: AcpTransport | undefined;
   private sessionId: string | undefined;
   private cwd: string | undefined;
@@ -34,7 +36,7 @@ class CursorDriver implements AgentDriver {
 
   constructor(config: CursorDriverConfig) {
     this.config = config;
-    this.events = new CursorEvents(config.maxToolCalls, config.maxQueuedBytes);
+    this.events = new AcpEvents("cursor", config.maxToolCalls, config.maxQueuedBytes);
   }
 
   on<K extends keyof DriverEventMap>(
@@ -57,6 +59,7 @@ class CursorDriver implements AgentDriver {
     this.artifactsDir = await realpath(ctx.artifactsDir);
     const cliVersion = await discoverCliVersion(this.config.command);
     const transport = new AcpTransport({
+      label: "Cursor ACP",
       command: this.config.command,
       args: buildCursorArgs(this.config),
       cwd: this.cwd,
@@ -198,7 +201,7 @@ class CursorDriver implements AgentDriver {
           request:
             method === "cursor/create_plan"
               ? String(params.plan ?? params.overview ?? "Approve this plan?")
-              : String(asRecord(params.toolCall)?.title ?? "Approve this tool call?"),
+              : permissionRequestText(params),
           context: params,
         });
       }
@@ -309,6 +312,7 @@ export const cursorDriver = defineDriver({
       isolation: false,
     },
   }),
+  selectHarness: selectModelAndReasoningEffort,
   create: (config) => new CursorDriver(config),
 });
 

package/src/drivers/cursor/interaction.ts

@@ -1,13 +1,6 @@
 import type { Answer } from "../../core/index.js";
-import { asRecord, type RpcRecord } from "./acp-transport.js";
-
-export const records = (value: unknown): RpcRecord[] =>
-  Array.isArray(value)
-    ? value.flatMap((entry): RpcRecord[] => {
-        const record = asRecord(entry);
-        return record ? [record] : [];
-      })
-    : [];
+import { permissionAnswer, records } from "../shared/acp-interaction.js";
+import { asRecord, type RpcRecord } from "../shared/acp-transport.js";
 
 export const cursorQuestionText = (params: RpcRecord): string =>
   `Return a JSON object mapping each question ID to its selected option ID. For questions allowing multiple selections, use an array of option IDs.\n\n${records(
@@ -57,16 +50,7 @@ export const cursorAnswer = (method: string, params: RpcRecord, answer: Answer):
         : { outcome: "rejected", ...(answer.reason ? { reason: answer.reason } : {}) },
     };
   }
-  const option = records(params.options).find(
-    (entry) => entry.kind === (answer.approved ? "allow_once" : "reject_once"),
-  );
-  // A Lux approval applies to this operation, never a remembered permission.
-  return {
-    outcome:
-      option && typeof option.optionId === "string"
-        ? { outcome: "selected", optionId: option.optionId }
-        : { outcome: "cancelled" },
-  };
+  return permissionAnswer(params, answer);
 };
 
 const optionValues = (options: unknown): string[] =>

package/src/drivers/{cursor/events.ts → shared/acp-events.ts}

@@ -1,19 +1,22 @@
 import { type Progress, toolResultProgress } from "../../core/index.js";
+import { records } from "./acp-interaction.js";
 import { asRecord, type RpcRecord } from "./acp-transport.js";
-import { records } from "./interaction.js";
 
 type ToolState = { value: RpcRecord; bytes: number; name: string };
 
-export class CursorEvents {
+/** Normalizes ACP `session/update` notifications into Lux progress events. */
+export class AcpEvents {
   private seq = 0;
   private retainedBytes = 0;
   private readonly tools = new Map<string, ToolState>();
   private readonly completed = new Set<string>();
 
+  private readonly prefix: string;
   private readonly maxToolCalls: number;
   private readonly maxBytes: number;
 
-  constructor(maxToolCalls: number, maxBytes: number) {
+  constructor(prefix: string, maxToolCalls: number, maxBytes: number) {
+    this.prefix = prefix;
     this.maxToolCalls = maxToolCalls;
     this.maxBytes = maxBytes;
   }
@@ -28,7 +31,7 @@ export class CursorEvents {
       if (content?.type !== "text" || typeof content.text !== "string") return [];
       return [
         {
-          id: `cursor-message-${++this.seq}`,
+          id: `${this.prefix}-message-${++this.seq}`,
           kind: update.sessionUpdate === "agent_message_chunk" ? "agent-message" : "reasoning",
           payload: { text: content.text },
           ts,
@@ -36,20 +39,28 @@ export class CursorEvents {
       ];
     }
     if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") {
-      return [{ id: `cursor-update-${++this.seq}`, kind: "cursor-update", payload: update, ts }];
+      return [
+        {
+          id: `${this.prefix}-update-${++this.seq}`,
+          kind: `${this.prefix}-update`,
+          payload: update,
+          ts,
+        },
+      ];
     }
     const id = update.toolCallId;
-    if (typeof id !== "string") throw new Error("Cursor ACP tool update omitted toolCallId");
+    if (typeof id !== "string")
+      throw new Error(`${this.prefix} ACP tool update omitted toolCallId`);
     if (this.completed.has(id)) return [];
     const old = this.tools.get(id);
     if (!old && this.tools.size + this.completed.size >= this.maxToolCalls)
-      throw new Error("Cursor ACP exceeded maxToolCalls");
+      throw new Error(`${this.prefix} ACP exceeded maxToolCalls`);
     const value = { ...old?.value, ...update };
     const bytes = Buffer.byteLength(JSON.stringify(value));
     this.retainedBytes += bytes - (old?.bytes ?? 0);
     if (this.retainedBytes > this.maxBytes)
-      throw new Error("Cursor ACP tool state exceeded maxQueuedBytes");
-    const name = old?.name ?? String(value.title ?? value.kind ?? "cursor-tool");
+      throw new Error(`${this.prefix} ACP tool state exceeded maxQueuedBytes`);
+    const name = old?.name ?? String(value.title ?? value.kind ?? `${this.prefix}-tool`);
     this.tools.set(id, { value, bytes, name });
     const events: Progress[] = old
       ? []

package/src/drivers/shared/acp-interaction.ts

@@ -0,0 +1,27 @@
+import type { Answer } from "../../core/index.js";
+import { asRecord, type RpcRecord } from "./acp-transport.js";
+
+export const records = (value: unknown): RpcRecord[] =>
+  Array.isArray(value)
+    ? value.flatMap((entry): RpcRecord[] => {
+        const record = asRecord(entry);
+        return record ? [record] : [];
+      })
+    : [];
+
+/** A Lux approval applies to this operation only, never a remembered permission. */
+export const permissionAnswer = (params: RpcRecord, answer: Answer): RpcRecord => {
+  if (answer.kind !== "approve") throw new Error("ACP permission requires an approval answer");
+  const option = records(params.options).find(
+    (entry) => entry.kind === (answer.approved ? "allow_once" : "reject_once"),
+  );
+  return {
+    outcome:
+      option && typeof option.optionId === "string"
+        ? { outcome: "selected", optionId: option.optionId }
+        : { outcome: "cancelled" },
+  };
+};
+
+export const permissionRequestText = (params: RpcRecord): string =>
+  String(asRecord(params.toolCall)?.title ?? "Approve this tool call?");

package/src/drivers/{cursor → shared}/acp-transport.ts

@@ -8,6 +8,8 @@ export const asRecord = (value: unknown): RpcRecord | undefined =>
     : undefined;
 
 type TransportOptions = {
+  /** Harness name used in failure messages. */
+  label: string;
   command: string;
   args: string[];
   cwd: string;
@@ -55,7 +57,7 @@ export class AcpTransport {
       if (!this.stopped)
         this.fail(
           new Error(
-            `Cursor ACP exited before completion (code=${exitCode}, signal=${signal})${this.stderrTail ? `: ${this.stderrTail}` : ""}`,
+            `${this.options.label} exited before completion (code=${exitCode}, signal=${signal})${this.stderrTail ? `: ${this.stderrTail}` : ""}`,
           ),
         );
     });
@@ -66,14 +68,16 @@ export class AcpTransport {
   }
 
   request(method: string, params: RpcRecord, timeoutMs?: number): Promise<RpcRecord> {
-    if (this.stopped) return Promise.reject(new Error("Cursor ACP is closed"));
+    if (this.stopped) return Promise.reject(new Error(`${this.options.label} is closed`));
     const id = this.nextId++;
     return new Promise((resolve, reject) => {
       const timer =
         timeoutMs === undefined
           ? undefined
           : setTimeout(() => {
-              this.fail(new Error(`Cursor ACP ${method} timed out after ${timeoutMs}ms`));
+              this.fail(
+                new Error(`${this.options.label} ${method} timed out after ${timeoutMs}ms`),
+              );
             }, timeoutMs);
       this.pending.set(id, { resolve, reject, timer });
       try {
@@ -85,10 +89,10 @@ export class AcpTransport {
   }
 
   write(message: RpcRecord): void {
-    if (this.stopped) throw new Error("Cursor ACP is closed");
+    if (this.stopped) throw new Error(`${this.options.label} is closed`);
     const line = `${JSON.stringify({ jsonrpc: "2.0", ...message })}\n`;
     if (Buffer.byteLength(line) > this.options.maxLineBytes)
-      throw new Error("Cursor ACP outgoing message exceeded maxLineBytes");
+      throw new Error(`${this.options.label} outgoing message exceeded maxLineBytes`);
     this.process.child.stdin.write(line);
   }
 
@@ -98,7 +102,7 @@ export class AcpTransport {
 
   async close(): Promise<void> {
     this.stopped = true;
-    this.rejectPending(new Error("Cursor ACP is closed"));
+    this.rejectPending(new Error(`${this.options.label} is closed`));
     this.buffer = Buffer.alloc(0);
     await this.process.terminate();
   }
@@ -126,7 +130,7 @@ export class AcpTransport {
       const end = newline === -1 ? chunk.length : newline;
       const segment = chunk.subarray(offset, end);
       if (this.buffer.length + segment.length > this.options.maxLineBytes) {
-        this.fail(new Error("Cursor ACP stdout line exceeded maxLineBytes"));
+        this.fail(new Error(`${this.options.label} stdout line exceeded maxLineBytes`));
         return;
       }
       this.buffer = Buffer.concat([this.buffer, segment]);
@@ -147,7 +151,7 @@ export class AcpTransport {
       /* Rejected below. */
     }
     if (message?.jsonrpc !== "2.0") {
-      this.fail(new Error("Cursor ACP returned an invalid JSON-RPC message"));
+      this.fail(new Error(`${this.options.label} returned an invalid JSON-RPC message`));
       return;
     }
     this.options.onActivity();
@@ -157,13 +161,14 @@ export class AcpTransport {
       this.pending.delete(message.id as RpcId);
       clearTimeout(pending.timer);
       const error = asRecord(message.error);
-      if (error) pending.reject(new Error(String(error.message ?? "Cursor ACP request failed")));
+      if (error)
+        pending.reject(new Error(String(error.message ?? `${this.options.label} request failed`)));
       else pending.resolve(asRecord(message.result) ?? {});
       return;
     }
     this.queuedBytes += line.length;
     if (this.queuedBytes > this.options.maxQueuedBytes) {
-      this.fail(new Error("Cursor ACP pending events exceeded maxQueuedBytes"));
+      this.fail(new Error(`${this.options.label} pending events exceeded maxQueuedBytes`));
       return;
     }
     const queued = message;