Ensure concurrent prompts are handled.

This basically implements the pending prompt queueing RFD. When
a prompt request is received while the agent is already generating,
we immediately forward the message to Claude and then wait until
it replays the message back to us. When it replays it, we respond to
the previous prompt request with "end_turn", which also singifies to
the client that the message is now being processed by the agent.

See agentclientprotocol/agent-client-protocol#484.

Author: SteffenDE

src/acp-agent.ts

@@ -149,6 +149,9 @@ type Session = {
   permissionMode: PermissionMode;
   settingsManager: SettingsManager;
   configOptions: SessionConfigOption[];
+  promptRunning: boolean;
+  pendingMessages: Map<string, { resolve: (cancelled: boolean) => void; order: number }>;
+  nextPendingOrder: number;
 };
 
 type SessionHistoryEntry = {
@@ -292,6 +295,11 @@ export class ClaudeAcpAgent implements Agent {
     return {
       protocolVersion: 1,
       agentCapabilities: {
+        _meta: {
+          claudeCode: {
+            promptQueueing: true,
+          },
+        },
         promptCapabilities: {
           image: true,
           embeddedContext: true,
@@ -611,20 +619,39 @@ export class ClaudeAcpAgent implements Agent {
   }
 
   async prompt(params: PromptRequest): Promise<PromptResponse> {
-    if (!this.sessions[params.sessionId]) {
+    const session = this.sessions[params.sessionId];
+    if (!session) {
       throw new Error("Session not found");
     }
 
-    this.sessions[params.sessionId].cancelled = false;
+    session.cancelled = false;
 
-    const { query, input } = this.sessions[params.sessionId];
+    const userMessage = promptToClaude(params);
 
-    input.push(promptToClaude(params));
+    if (session.promptRunning) {
+      const uuid = randomUUID();
+      userMessage.uuid = uuid;
+      session.input.push(userMessage);
+      const order = session.nextPendingOrder++;
+      const cancelled = await new Promise<boolean>((resolve) => {
+        session.pendingMessages.set(uuid, { resolve, order });
+      });
+      if (cancelled) {
+        return { stopReason: "cancelled" };
+      }
+    } else {
+      session.input.push(userMessage);
+    }
+
+    session.promptRunning = true;
+    let handedOff = false;
+
+    try {
     while (true) {
-      const { value: message, done } = await (query as AsyncGenerator<SDKMessageTemp, void>).next();
+      const { value: message, done } = await (session.query as AsyncGenerator<SDKMessageTemp, void>).next();
 
       if (done || !message) {
-        if (this.sessions[params.sessionId].cancelled) {
+        if (session.cancelled) {
           return { stopReason: "cancelled" };
         }
         break;
@@ -651,7 +678,7 @@ export class ClaudeAcpAgent implements Agent {
           }
           break;
         case "result": {
-          if (this.sessions[params.sessionId].cancelled) {
+          if (session.cancelled) {
             return { stopReason: "cancelled" };
           }
 
@@ -704,10 +731,23 @@ export class ClaudeAcpAgent implements Agent {
         }
         case "user":
         case "assistant": {
-          if (this.sessions[params.sessionId].cancelled) {
+          if (session.cancelled) {
             break;
           }
 
+          // Check for queued prompt replay
+          if (message.type === "user" && "uuid" in message && message.uuid) {
+            const pending = session.pendingMessages.get(message.uuid as string);
+            if (pending) {
+              pending.resolve(false);
+              session.pendingMessages.delete(message.uuid as string);
+              handedOff = true;
+              // the current loop stops with end_turn,
+              // the loop of the next prompt continues running
+              return { stopReason: "end_turn" };
+            }
+          }
+
           // Slash commands like /compact can generate invalid output... doesn't match
           // their own docs: https://docs.anthropic.com/en/docs/claude-code/sdk/sdk-slash-commands#%2Fcompact-compact-conversation-history
           if (
@@ -793,14 +833,35 @@ export class ClaudeAcpAgent implements Agent {
       }
     }
     throw new Error("Session did not end in result");
+    } finally {
+      if (!handedOff) {
+        session.promptRunning = false;
+        // This usually should not happen, but in case the loop finishes
+        // without claude sending all message replays, we resolve the
+        // next pending prompt call to ensure no prompts get stuck.
+        if (session.pendingMessages.size > 0) {
+          const next = [...session.pendingMessages.entries()]
+            .sort((a, b) => a[1].order - b[1].order)[0];
+          if (next) {
+            next[1].resolve(false);
+            session.pendingMessages.delete(next[0]);
+          }
+        }
+      }
+    }
   }
 
   async cancel(params: CancelNotification): Promise<void> {
-    if (!this.sessions[params.sessionId]) {
+    const session = this.sessions[params.sessionId];
+    if (!session) {
       throw new Error("Session not found");
     }
-    this.sessions[params.sessionId].cancelled = true;
-    await this.sessions[params.sessionId].query.interrupt();
+    session.cancelled = true;
+    for (const [, pending] of session.pendingMessages) {
+      pending.resolve(true);
+    }
+    session.pendingMessages.clear();
+    await session.query.interrupt();
   }
 
   async unstable_setSessionModel(
@@ -1246,6 +1307,10 @@ export class ClaudeAcpAgent implements Agent {
       // here works to find zed's managed node version.
       executable: process.execPath as any,
       executableArgs: isStaticBinary() ? ["--cli"] : undefined,
+      extraArgs: {
+        ...userProvidedOptions?.extraArgs,
+        "replay-user-messages": "",
+      },
       ...(process.env.CLAUDE_CODE_EXECUTABLE
         ? { pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE }
         : isStaticBinary()
@@ -1305,6 +1370,9 @@ export class ClaudeAcpAgent implements Agent {
       permissionMode,
       settingsManager,
       configOptions: [],
+      promptRunning: false,
+      pendingMessages: new Map(),
+      nextPendingOrder: 0,
     };
 
     const initializationResult = await q.initializationResult();