fix(acp): distinguish settled-with-open-tools reply state across steers

This commit is contained in:
Mohamed Boudra
2026-11-20 17:48:40 +01:00
parent ca20a44c0c
commit 4aa2a349cb
2 changed files with 188 additions and 14 deletions
@@ -393,6 +393,8 @@ interface DeferredTurnState {
resolve(outcome: DeferredTurnOutcome): void;
}
type DeferredReplyState = "idle" | "open" | "settled_with_open_tools" | "settled";
interface ActivePrompt {
turnId: string;
settled: Promise<void>;
@@ -401,8 +403,7 @@ interface ActivePrompt {
wirePromptLane: Promise<void>;
lastPromptResponseWireSeq: number | null;
crossedEndTurn: boolean;
replyOpen: boolean;
replySettled: boolean;
replyState: DeferredReplyState;
deferred: DeferredTurnState | null;
}
@@ -726,8 +727,7 @@ class AcpRuntime {
wirePromptLane: Promise.resolve(),
lastPromptResponseWireSeq: null,
crossedEndTurn: false,
replyOpen: false,
replySettled: false,
replyState: "idle",
deferred: null,
};
// The SDK dispatches notifications without awaiting them, so the prompt response can resolve
@@ -1648,6 +1648,7 @@ class AcpRuntime {
}
this.fallbackChunkIds.clear();
active.lastPromptResponseWireSeq = null;
if (active.replyState === "settled_with_open_tools") active.replyState = "idle";
const response = await this.call(
this.connection.prompt({ sessionId: this.nativeSessionId, prompt }),
);
@@ -1779,10 +1780,7 @@ class AcpRuntime {
if (!active.deferred && wasOpenQualifying && !isOpen && this.toolKeepsTurnOpen(snapshot)) {
active.crossedEndTurn = true;
}
if (isOpenQualifying) {
active.replyOpen = false;
active.replySettled = false;
}
if (isOpenQualifying) active.replyState = "idle";
if (active.deferred) this.scheduleDeferredSettle();
}
@@ -1792,16 +1790,15 @@ class AcpRuntime {
): void {
const active = this.activePrompt;
if (!active || !this.isPostWirePrompt(active, wireSeq)) return;
if (kind === "agent_message_chunk") active.replyOpen = true;
active.replySettled = false;
if (kind === "agent_message_chunk") active.replyState = "open";
else if (active.replyState !== "open") active.replyState = "idle";
if (active.deferred) this.scheduleDeferredSettle();
}
private noteDeferredUsageUpdate(wireSeq: number): void {
const active = this.activePrompt;
if (!active || !this.isPostWirePrompt(active, wireSeq) || !active.replyOpen) return;
active.replyOpen = false;
active.replySettled = true;
if (!active || !this.isPostWirePrompt(active, wireSeq) || active.replyState !== "open") return;
active.replyState = this.hasQualifyingOpenTools() ? "settled_with_open_tools" : "settled";
if (active.deferred) this.scheduleDeferredSettle();
}
@@ -1815,7 +1812,9 @@ class AcpRuntime {
deferred.timer = null;
}
if (this.hasDeferredBlockers()) return;
const delayMs = active.replySettled
const settled =
active.replyState === "settled" || active.replyState === "settled_with_open_tools";
const delayMs = settled
? (config.settleDelayMs ?? DEFAULT_DEFERRED_SETTLE_DELAY_MS)
: (config.quietLimitMs ?? DEFAULT_DEFERRED_QUIET_LIMIT_MS);
deferred.timer = setTimeout(() => {
+175
View File
@@ -5448,4 +5448,179 @@ describe("deferTurnOnRunningTools", () => {
await connection.close();
}
});
it("keeps the turn open for a second background tool reply that starts during a second steer", async () => {
let promptCount = 0;
let releaseSteer1: (() => void) | null = null;
const { connector, instances } = connectorHarness({
handleRequest(instance, request) {
if (request.method !== "session/prompt") return false;
promptCount += 1;
if (promptCount === 1) {
instance.notify("session/update", {
sessionId: "connector-session",
update: {
sessionUpdate: "tool_call",
toolCallId: "bg-s1",
name: "run_command",
title: "Job 1",
status: "in_progress",
},
});
instance.notify("session/update", {
sessionId: "connector-session",
update: {
sessionUpdate: "tool_call",
toolCallId: "bg-s2",
name: "run_command",
title: "Job 2",
status: "in_progress",
},
});
instance.respond(request, { stopReason: "end_turn" });
return true;
}
if (promptCount === 2) {
releaseSteer1 = () => {
instance.notify("session/update", {
sessionId: "connector-session",
update: textChunk("Steer 1 ACK"),
});
instance.respond(request, { stopReason: "end_turn" });
// Job 1 finishes and sends its reply + usage while Job 2 is STILL running.
instance.notify("session/update", {
sessionId: "connector-session",
update: {
sessionUpdate: "tool_call_update",
toolCallId: "bg-s1",
status: "completed",
},
});
instance.notify("session/update", {
sessionId: "connector-session",
update: textChunk("Job 1 done."),
});
instance.notify("session/update", {
sessionId: "connector-session",
update: { sessionUpdate: "usage_update", used: 200, size: 1000 },
});
};
return true;
}
// During Steer 2, Job 2 completes and starts streaming its reply before Steer 2 ends.
instance.notify("session/update", {
sessionId: "connector-session",
update: {
sessionUpdate: "tool_call_update",
toolCallId: "bg-s2",
status: "completed",
},
});
instance.notify("session/update", {
sessionId: "connector-session",
update: textChunk("Job 2 part 1 "),
});
instance.respond(request, { stopReason: "end_turn" });
return true;
},
});
const registration = runAcpProvider({
id: "deferred-second-tool-steer",
label: "Deferred Second Tool Steer",
connector,
acpOptions: {
deferTurnOnRunningTools: {
settleDelayMs: 40,
quietLimitMs: 1_500,
},
},
});
const connection = await registration.connect({
versions: [1],
capabilities: ["prompt.message", "prompt.steer"],
});
const events: ProviderEvent[] = [];
connection.onEvent((event) => events.push(event));
try {
await connection.send(openInput());
await waitForEvent(events, (event) => event.type === "session.ready");
await connection.send({
type: "session.prompt",
sessionId: "session-1",
prompt: {
clientMessageId: "two-tool-steer-turn",
delivery: "auto",
input: { type: "message", content: [{ type: "text", text: "run two jobs" }] },
},
});
await waitForEvent(
events,
(event) =>
event.type === "timeline.item" &&
event.item.type === "tool_call" &&
event.item.id === "bg-s2",
);
await new Promise((resolve) => setTimeout(resolve, 20));
await connection.send({
type: "session.prompt",
sessionId: "session-1",
prompt: {
clientMessageId: "two-tool-steer-1",
delivery: "steer",
input: { type: "message", content: [{ type: "text", text: "steer 1" }] },
},
});
await connection.send({
type: "session.prompt",
sessionId: "session-1",
prompt: {
clientMessageId: "two-tool-steer-2",
delivery: "steer",
input: { type: "message", content: [{ type: "text", text: "steer 2" }] },
},
});
await new Promise((resolve) => setTimeout(resolve, 20));
releaseSteer1!();
await waitForEvent(
events,
(event) =>
event.type === "timeline.item" &&
event.item.type === "assistant_message" &&
event.item.text.includes("Job 2 part 1"),
);
// Pause longer than settleDelayMs (40ms): turn must stay open for Job 2's remaining chunks.
await new Promise((resolve) => setTimeout(resolve, 160));
expect(
events.some(
(event) =>
event.type === "session.turn" &&
event.turnId === "acp:two-tool-steer-turn" &&
event.state !== "started",
),
).toBe(false);
// Job 2 finishes streaming and sends usage_update -> turn now completes cleanly.
instances[1].notify("session/update", {
sessionId: "connector-session",
update: textChunk("and part 2."),
});
instances[1].notify("session/update", {
sessionId: "connector-session",
update: { sessionUpdate: "usage_update", used: 350, size: 1000 },
});
await waitForEvent(
events,
(event) =>
event.type === "session.turn" &&
event.turnId === "acp:two-tool-steer-turn" &&
event.state === "completed",
400,
);
} finally {
await connection.close();
}
});
});