From 99232246bb8a33a1c8d34fe5fcc42a890a596abd Mon Sep 17 00:00:00 2001 From: Mohamed Boudra Date: Fri, 20 Nov 2026 18:39:19 +0100 Subject: [PATCH] fix(acp,server): enforce shutdown deadline on connector close and bound settings wait on queued Stop --- .../src/server/acp-internal/connection.ts | 32 ++--- packages/plugin/src/server/acp.test.ts | 16 ++- .../server/src/server/agent/agent-manager.ts | 11 +- .../src/server/agent/plugin-provider.test.ts | 127 ++++++++++++++++++ 4 files changed, 163 insertions(+), 23 deletions(-) diff --git a/packages/plugin/src/server/acp-internal/connection.ts b/packages/plugin/src/server/acp-internal/connection.ts index 9b4e1692cb..23f5ae8244 100644 --- a/packages/plugin/src/server/acp-internal/connection.ts +++ b/packages/plugin/src/server/acp-internal/connection.ts @@ -952,8 +952,12 @@ class AcpRuntime { close(options?: { force?: boolean }): Promise { 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 { @@ -1939,7 +1943,7 @@ function ownConnectorStream(source: Stream): { } { const reader = source.readable.getReader(); const writer = source.writable.getWriter(); - let closed = false; + let closing: Promise | 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"); }, }; } diff --git a/packages/plugin/src/server/acp.test.ts b/packages/plugin/src/server/acp.test.ts index 0fe6c788a3..d4b4adc210 100644 --- a/packages/plugin/src/server/acp.test.ts +++ b/packages/plugin/src/server/acp.test.ts @@ -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(); diff --git a/packages/server/src/server/agent/agent-manager.ts b/packages/server/src/server/agent/agent-manager.ts index 33216d6f24..678ed8efa4 100644 --- a/packages/server/src/server/agent/agent-manager.ts +++ b/packages/server/src/server/agent/agent-manager.ts @@ -3279,7 +3279,16 @@ export class AgentManager { agentId: string, operation: (agent: ActiveManagedAgent) => Promise, ): Promise { - 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); diff --git a/packages/server/src/server/agent/plugin-provider.test.ts b/packages/server/src/server/agent/plugin-provider.test.ts index dbebea0fcb..d45967e7fe 100644 --- a/packages/server/src/server/agent/plugin-provider.test.ts +++ b/packages/server/src/server/agent/plugin-provider.test.ts @@ -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(); + } +});