From 0b30bf032bc3171cf1be78943ecb5c6137bb77d1 Mon Sep 17 00:00:00 2001 From: Mohamed Boudra Date: Fri, 20 Nov 2026 13:02:14 +0100 Subject: [PATCH] fix(acp): keep settled tool rows stable on Stop --- .../src/server/acp-internal/connection.ts | 11 ++- packages/plugin/src/server/acp.test.ts | 89 +++++++++++++++++++ 2 files changed, 98 insertions(+), 2 deletions(-) diff --git a/packages/plugin/src/server/acp-internal/connection.ts b/packages/plugin/src/server/acp-internal/connection.ts index efed0a0c28..f4e19da0f4 100644 --- a/packages/plugin/src/server/acp-internal/connection.ts +++ b/packages/plugin/src/server/acp-internal/connection.ts @@ -76,6 +76,7 @@ interface AcpToolCallRecord { snapshot: AcpToolCallSnapshot; turnId?: string; settlement?: AcpToolSettlement; + stopped?: boolean; } export async function createAcpProviderConnection( @@ -1277,7 +1278,7 @@ class AcpRuntime { ): void { const previous = this.toolCalls.get(update.toolCallId); // A stopped tool can still report output and terminal echoes after the next prompt. - if (previous?.settlement === "canceled") return; + if (previous?.stopped || previous?.settlement === "canceled") return; if (update.sessionUpdate === "tool_call") this.fallbackChunkIds.clear(); const previousStatus = previous?.snapshot.status; const backgroundProgress = @@ -1420,10 +1421,16 @@ class AcpRuntime { ): void { for (const [id, record] of this.toolCalls) { const { snapshot, turnId, settlement } = record; - if (settlement === "canceled" || (settlement && state !== "canceled")) continue; if (snapshot.status !== "pending" && snapshot.status !== "in_progress") continue; if (options?.turnId && options.turnId !== turnId) continue; if (options?.preserveInProgressTools && snapshot.status === "in_progress") continue; + if (settlement) { + // Antigravity can acknowledge Stop for a tool whose row already settled. + if (state === "canceled" && this.outOfTurnActivity && settlement !== "canceled") { + this.toolCalls.set(id, { ...record, stopped: true }); + } + continue; + } this.toolCalls.set(id, { ...record, settlement: state }); this.emitToolCall(terminalToolItem(toolTimelineItem(snapshot), state), turnId); } diff --git a/packages/plugin/src/server/acp.test.ts b/packages/plugin/src/server/acp.test.ts index 699a0e7cd3..2ba2575ad3 100644 --- a/packages/plugin/src/server/acp.test.ts +++ b/packages/plugin/src/server/acp.test.ts @@ -1126,6 +1126,86 @@ lines.on("line", (line) => { await connection.close(); }); + it("keeps an earlier tool completed when stopping a later prompt", async () => { + let followUp: AcpRequestMessage | undefined; + const { connector } = connectorHarness({ + promptUpdates: () => [ + { + sessionUpdate: "tool_call", + toolCallId: "first-tool", + title: "Run tests", + kind: "execute", + status: "in_progress", + }, + ], + handleMessage(instance, message) { + if (!("method" in message)) return false; + if (message.method === "session/prompt" && "id" in message) { + if (countRequests(instance, "session/prompt") === 1) return false; + followUp = message; + return true; + } + if (message.method === "session/cancel" && followUp) { + instance.respond(followUp, { stopReason: "cancelled" }); + return true; + } + return false; + }, + }); + const registration = runAcpProvider({ id: "stop-later-prompt", label: "ACP", connector }); + const connection = await registration.connect({ + versions: [1], + capabilities: ["prompt.message"], + }); + const events: ProviderEvent[] = []; + connection.onEvent((event) => events.push(event)); + try { + await connection.send(openInput()); + await waitForEvent(events, (event) => event.type === "session.ready"); + for (const clientMessageId of ["first", "second"]) { + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId, + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: clientMessageId }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === `acp:${clientMessageId}` && + event.state === (clientMessageId === "first" ? "completed" : "started"), + ); + } + await connection.send({ + type: "session.interrupt", + requestId: "stop-second", + sessionId: "session-1", + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:second" && + event.state === "canceled", + ); + expect( + events.flatMap((event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "first-tool" + ? [event.item.status] + : [], + ), + ).toEqual(["running", "completed"]); + } finally { + await connection.close(); + } + }); + it.each([ { counts: null, context: false, expected: [] }, { @@ -2982,6 +3062,15 @@ describe("ACP out-of-turn background activity", () => { turnCountAfterCancel, ); expect(await queryCanStop(connection, events, "stop-after-cancel-echo")).toBe(true); + expect( + events.flatMap((event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "pending-before-stop" + ? [event.item.status] + : [], + ), + ).toEqual(["running", "completed"]); } finally { await connection.close(); }