fix(acp,server): enforce shutdown deadline on connector close and bound settings wait on queued Stop

This commit is contained in:
Mohamed Boudra
2026-11-20 18:39:19 +01:00
parent 2f6efa93f1
commit 99232246bb
4 changed files with 163 additions and 23 deletions
@@ -952,8 +952,12 @@ class AcpRuntime {
close(options?: { force?: boolean }): Promise<void> {
if (this.closePromise) return this.closePromise;
this.closing = true;
this.closePromise = this.closeInternal(options);
return this.closePromise;
const promise = this.closeInternal(options).catch((error) => {
if (this.closePromise === promise) this.closePromise = null;
throw error;
});
this.closePromise = promise;
return promise;
}
private async closeInternal(options?: { force?: boolean }): Promise<void> {
@@ -1939,7 +1943,7 @@ function ownConnectorStream(source: Stream): {
} {
const reader = source.readable.getReader();
const writer = source.writable.getWriter();
let closed = false;
let closing: Promise<unknown> | null = null;
const stream: Stream = {
readable: new ReadableStream({
async pull(controller) {
@@ -1962,18 +1966,16 @@ function ownConnectorStream(source: Stream): {
return {
stream,
async close(options?: { force?: boolean }) {
if (closed) return;
closed = true;
const closeWrite = options?.force
? settlesWithin(
writer.abort(new Error("Paseo aborted the ACP connector")).catch(() => undefined),
250,
)
: writer.close();
await Promise.allSettled([
reader.cancel(new Error("Paseo closed the ACP connector")),
closeWrite,
]);
if (!closing) {
const closeWrite = options?.force
? writer.abort(new Error("Paseo aborted the ACP connector"))
: writer.close();
closing = Promise.allSettled([
reader.cancel(new Error("Paseo closed the ACP connector")),
closeWrite,
]);
}
await withTimeout(closing, 1_000, "ACP connector did not close");
},
};
}
+9 -7
View File
@@ -6034,7 +6034,7 @@ describe("deferTurnOnRunningTools", () => {
}
});
it("retires a connector-backed deferred session even when the cancel write stalls", async () => {
it("reports interrupt failure when a connector refuses to confirm shutdown within the deadline", async () => {
let releaseStalledWrite: (() => void) | null = null;
const base = connectorHarness({
handleRequest(instance, request) {
@@ -6110,20 +6110,22 @@ describe("deferTurnOnRunningTools", () => {
requestId: "stalled-conn-int",
sessionId: "session-1",
});
await waitForEvent(
const failed = await waitForEvent(
events,
(event) => event.type === "request.completed" && event.requestId === "stalled-conn-int",
2_500,
(event) => event.type === "request.failed" && event.requestId === "stalled-conn-int",
3_000,
);
expect(failed.type === "request.failed" && failed.error.message).toContain(
"ACP connector did not close",
);
expect(
events.filter(
events.some(
(event) =>
event.type === "session.turn" &&
event.turnId === "acp:stalled-conn-turn" &&
event.state === "canceled",
),
).toHaveLength(1);
expect(events.filter((event) => event.type === "session.closed")).toHaveLength(1);
).toBe(false);
} finally {
releaseStalledWrite?.();
await connection.close();
@@ -3279,7 +3279,16 @@ export class AgentManager {
agentId: string,
operation: (agent: ActiveManagedAgent) => Promise<T>,
): Promise<T> {
await this.pendingCancellations.get(agentId)?.catch(() => undefined);
const pendingCancellation = this.pendingCancellations.get(agentId);
if (pendingCancellation) {
await this.waitWithTimeout({
operation: pendingCancellation.then(
() => undefined,
() => undefined,
),
timeoutMs: this.rescueTimeouts.interruptSessionMs,
});
}
const agent = await this.ensureInteractiveSessionUnlocked(agentId);
try {
return await operation(agent);
@@ -3278,3 +3278,130 @@ test("does not block mode changes after a plugin refuses Stop by ignoring sessio
await plugins.shutdown();
}
});
test("bounds settings wait when Stop is queued behind an unanswered steer", async () => {
const logger = createTestLogger();
let currentMode = "code";
let releaseSteer: (() => void) | null = null;
const harness = createProviderHarness({
capabilities: ["prompt.message", "prompt.steer", "session.interrupt", "session.configure"],
async handleInput(input, emit) {
if (input.type === "session.open") {
emit({
type: "session.opened",
requestId: input.requestId,
sessionId: input.sessionId,
capabilities: [
"prompt.message",
"prompt.steer",
"session.interrupt",
"session.configure",
],
restoration: "core",
title: input.config.title,
cwd: input.config.cwd,
});
emit({
type: "session.config",
sessionId: input.sessionId,
config: {
mode: currentMode,
modes: [
{ id: "code", label: "Code" },
{ id: "plan", label: "Plan" },
],
models: [],
thinkingOptions: [],
},
});
emit({ type: "session.ready", requestId: input.requestId, sessionId: input.sessionId });
return true;
}
if (input.type === "session.prompt") {
if (input.prompt.delivery === "steer") {
releaseSteer = () =>
emit({
type: "session.prompt_result",
sessionId: input.sessionId,
clientMessageId: input.prompt.clientMessageId,
result: { type: "steer", turnId: "steer-turn" },
});
return true;
}
emit({
type: "session.prompt_result",
sessionId: input.sessionId,
clientMessageId: input.prompt.clientMessageId,
result: { type: "turn", turnId: "steer-turn" },
});
emit({
type: "session.turn",
sessionId: input.sessionId,
turnId: "steer-turn",
state: "started",
});
return true;
}
if (input.type === "session.interrupt") {
return true;
}
if (input.type === "session.configure") {
if (input.changes.mode) currentMode = input.changes.mode;
emit({
type: "session.config",
sessionId: input.sessionId,
config: {
mode: currentMode,
modes: [
{ id: "code", label: "Code" },
{ id: "plan", label: "Plan" },
],
models: [],
thinkingOptions: [],
},
});
emit({ type: "request.completed", requestId: input.requestId });
return true;
}
return false;
},
});
const plugins = new PluginAgentClientRegistry(logger);
plugins.replace([harness.registration]);
const registry = buildProviderRegistry(logger, { pluginProviders: plugins.definitions() });
const manager = new AgentManager({
logger,
clients: { "plugin-direct": registry["plugin-direct"].createClient(logger) },
providerDefinitions: { "plugin-direct": registry["plugin-direct"] },
rescueTimeouts: { interruptSessionMs: 50 },
});
try {
const agent = await manager.createAgent(
{ provider: "plugin-direct", cwd: tmpdir() },
undefined,
{ workspaceId: undefined },
);
const stream = manager.streamAgent(agent.id, "start");
void stream.next();
await expect
.poll(() => manager.getAgent(agent.id)?.lifecycle, { timeout: 2_000 })
.toBe("running");
// Start an unanswered steer, queue Stop behind it, then change mode.
const steerPromise = manager.steerAgentRun(agent.id, "unanswered steer").catch(() => undefined);
await new Promise((resolve) => setTimeout(resolve, 20));
const stopPromise = manager.cancelAgentRun(agent.id);
await new Promise((resolve) => setTimeout(resolve, 10));
// Mode change must complete within the bounded interrupt timeout even while Stop is queued.
await manager.setAgentMode(agent.id, "plan");
expect(manager.getAgent(agent.id)?.currentModeId).toBe("plan");
releaseSteer?.();
await Promise.all([steerPromise, stopPromise]);
} finally {
releaseSteer?.();
await Promise.all(manager.listAgents().map((item) => manager.closeAgent(item.id)));
await plugins.shutdown();
}
});