fix(acp): keep settled tool rows stable on Stop

This commit is contained in:
Mohamed Boudra
2026-11-20 13:02:14 +01:00
parent aed906aaba
commit 0b30bf032b
2 changed files with 98 additions and 2 deletions
@@ -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);
}
+89
View File
@@ -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();
}