diff --git a/packages/plugin/src/server/acp-internal/connection.ts b/packages/plugin/src/server/acp-internal/connection.ts index 2a83f6f1a9..2323a95291 100644 --- a/packages/plugin/src/server/acp-internal/connection.ts +++ b/packages/plugin/src/server/acp-internal/connection.ts @@ -89,6 +89,9 @@ export async function createAcpProviderConnection( if (probe.agentCapabilities.loadSession) { supportedCapabilities.push("session.persistence"); } + if (options.acpOptions?.deferTurnOnRunningTools) { + supportedCapabilities.push("prompt.steer"); + } await probe.close(); const capabilities = negotiateProviderCapabilities(request.capabilities, supportedCapabilities); const listeners = new Set<(event: ProviderEvent) => void>(); @@ -214,10 +217,13 @@ async function dispatch(input: ProviderInput, state: AcpConnectionState): Promis await mutateSession(session, () => session.runtime.prompt(input)); return; } - case "session.interrupt": - await requireSession(state, input.sessionId).runtime.interrupt(); + case "session.interrupt": { + const session = requireSession(state, input.sessionId); + const retired = await session.runtime.interrupt(); state.emit({ type: "request.completed", requestId: input.requestId }); + if (retired) retireSession(state, input.sessionId); return; + } case "session.permission": requireSession(state, input.sessionId).runtime.respondToPermission( input.permissionId, @@ -304,6 +310,12 @@ async function listSessions( } } +function retireSession(state: AcpConnectionState, sessionId: string): void { + if (state.sessions.delete(sessionId)) { + state.emit({ type: "session.closed", sessionId }); + } +} + async function openSession( input: Extract, state: AcpConnectionState, @@ -317,6 +329,7 @@ async function openSession( cwd: input.config.cwd, env: input.config.env, emit: state.emit, + onRetired: () => retireSession(state, input.sessionId), }); try { const capabilities = await runtime.open(input, state.capabilities); @@ -358,6 +371,7 @@ interface StartRuntimeOptions { cwd?: string; env: Readonly>; emit(event: ProviderEvent): void; + onRetired?: () => void; } interface PendingPermission { @@ -366,6 +380,33 @@ interface PendingPermission { resolve(response: RequestPermissionResponse): void; } +type DeferredTurnOutcome = + | { type: "complete"; terminalizeTools: boolean } + | { type: "cancel" } + | { type: "fail"; error: { message: string } }; + +interface DeferredTurnState { + timer: ReturnType | null; + resolve(outcome: DeferredTurnOutcome): void; +} + +type DeferredReplyState = "idle" | "open" | "settled_with_open_tools" | "settled"; + +interface ActivePrompt { + turnId: string; + settled: Promise; + cancelling: boolean; + wirePromptsInFlight: number; + wirePromptLane: Promise; + lastPromptResponseWireSeq: number | null; + crossedEndTurn: boolean; + replyState: DeferredReplyState; + deferred: DeferredTurnState | null; +} + +const DEFAULT_DEFERRED_SETTLE_DELAY_MS = 500; +const DEFAULT_DEFERRED_QUIET_LIMIT_MS = 120_000; + class AcpRuntime { readonly connection: ClientSideConnection; agentCapabilities: AgentCapabilities = {}; @@ -374,6 +415,8 @@ class AcpRuntime { private emit: (event: ProviderEvent) => void; private readonly messages = new Map(); private readonly toolCalls = new Map(); + private readonly liveOpenToolIds = new Set(); + private readonly canceledToolCallIds = new Set(); // Running tool rows published by transformers; the turn's terminal closes any left open. private readonly vendorToolCalls = new Map(); private readonly pendingCompactions = new Set(); @@ -401,21 +444,33 @@ class AcpRuntime { private replayWindow: "replay" | "skip" | null = null; private lastLoadUpdateAt = 0; private closing = false; + private closePromise: Promise | null = null; + private deferredRetirement: Promise | null = null; + private deferredFinalized = false; private processFailed = false; private configTransaction = false; private stagedTransformerConfig: ProviderConfigState | null = null; - private readonly closeConnector: () => Promise; + private readonly closeConnector: (options?: { + force?: boolean; + timeoutMs?: number; + }) => Promise; + private readonly whenConnectorClosed: () => Promise | null; private notificationLane: Promise = Promise.resolve(); + private incomingWireSeq = 0; + private readonly sessionUpdateWireSeqs: number[] = []; private autoAccept = false; - private activePrompt: { turnId: string; settled: Promise; cancelling: boolean } | null = - null; + private activePrompt: ActivePrompt | null = null; private lastUsage: ProviderUsage = {}; static async start(options: StartRuntimeOptions): Promise { let child: ChildProcessWithoutNullStreams | null = null; let spawnFailure: Promise | null = null; let stream: Stream; - let closeConnector = async () => {}; + let closeConnector: (options?: { + force?: boolean; + timeoutMs?: number; + }) => Promise = async () => {}; + let whenConnectorClosed: () => Promise | null = () => null; if (options.options.command) { // COMPAT(pluginProviderLaunch): added in v0.10.0, remove after 2027-03-29 once plugin host floor >= v0.10.0. // Standalone callers and older hosts do not send a daemon-resolved launch. @@ -438,8 +493,9 @@ class AcpRuntime { const owned = ownConnectorStream(await options.options.connector()); stream = owned.stream; closeConnector = owned.close; + whenConnectorClosed = owned.whenClosed; } - const runtime = new AcpRuntime(stream, child, closeConnector, options); + const runtime = new AcpRuntime(stream, child, closeConnector, whenConnectorClosed, options); try { const initialize = withTimeout( runtime.call( @@ -466,41 +522,51 @@ class AcpRuntime { private constructor( stream: Stream, child: ChildProcessWithoutNullStreams | null, - closeConnector: () => Promise, + closeConnector: (options?: { force?: boolean; timeoutMs?: number }) => Promise, + whenConnectorClosed: () => Promise | null, private readonly options: StartRuntimeOptions, ) { this.child = child; this.closeConnector = closeConnector; + this.whenConnectorClosed = whenConnectorClosed; this.emit = options.emit; this.transformers = options.options.transformers ?? []; const client: Client = { requestPermission: (request) => this.requestPermission(request), - sessionUpdate: (notification) => - this.enqueueNotification(() => this.sessionUpdate(notification)), + sessionUpdate: (notification) => { + const wireSeq = this.sessionUpdateWireSeqs.shift() ?? ++this.incomingWireSeq; + return this.enqueueNotification(() => this.sessionUpdate(notification, wireSeq)); + }, }; this.connection = new ClientSideConnection( () => client, - routeVendorNotifications(stream, (method, params) => this.vendorNotification(method, params)), + routeIncomingMessages( + stream, + (method, params) => this.vendorNotification(method, params), + (message) => this.observeWireMessage(message), + ), ); if (!child) void this.connection.closed.then(() => this.handleUnexpectedTransportClose()); child?.on("error", (error) => { + const message = describeError(error); this.processFailed = true; - this.settlePendingWork(); + this.settlePendingWork(message); if (this.closing || !this.nativeSessionId) return; this.emit({ type: "session.runtime_failed", sessionId: this.options.boundarySessionId, - error: { message: describeError(error) }, + error: { message }, }); }); child?.once("close", (code, signal) => { if (this.closing || this.processFailed || !this.nativeSessionId) return; + const message = `ACP process exited (${signal ?? code ?? "unknown"})`; this.processFailed = true; - this.settlePendingWork(); + this.settlePendingWork(message); this.emit({ type: "session.runtime_failed", sessionId: this.options.boundarySessionId, - error: { message: `ACP process exited (${signal ?? code ?? "unknown"})` }, + error: { message }, }); }); } @@ -609,10 +675,31 @@ class AcpRuntime { } async prompt(input: Extract): Promise { + if (this.closing || this.processFailed || this.deferredRetirement) { + throw new Error("ACP session is closed"); + } + if (input.prompt.delivery === "steer") { + this.steerDeferredPrompt(input); + return; + } const active = this.activePrompt; if (active) { - await this.interrupt(); + if (active.deferred && active.wirePromptsInFlight === 0) { + // Wire session/prompt already resolved; finish the deferred turn without sending + // session/cancel so running background tools stay alive into the follow-up turn. + this.finishDeferredTurn(active, { type: "complete", terminalizeTools: false }); + } else { + const retired = await this.interrupt(); + if (retired) { + // Notify caller that the session closed before failing the replacement prompt. + this.options.onRetired?.(); + throw new Error("ACP session retired after stopping deferred background work"); + } + } await active.settled; + if (this.closing || this.processFailed || this.deferredRetirement) { + throw new Error("ACP session is closed"); + } } const prompt = toAcpPrompt(input.prompt); this.replayWindow = null; @@ -643,6 +730,17 @@ class AcpRuntime { turnId, state: "started", }); + const activePrompt: ActivePrompt = { + turnId, + settled: Promise.resolve(), + cancelling: false, + wirePromptsInFlight: 1, + wirePromptLane: Promise.resolve(), + lastPromptResponseWireSeq: null, + crossedEndTurn: false, + replyState: "idle", + deferred: null, + }; // The SDK dispatches notifications without awaiting them, so the prompt response can resolve // while earlier session updates are still queued. Apply them before the turn ends. const settled = this.call( @@ -650,6 +748,7 @@ class AcpRuntime { ).then( async (response): Promise => { await this.drainNotifications(); + activePrompt.wirePromptsInFlight -= 1; if (response.usage) { this.lastUsage = { ...this.lastUsage, @@ -665,47 +764,95 @@ class AcpRuntime { }); } const state = response.stopReason === "cancelled" ? "canceled" : "completed"; - this.fallbackChunkIds.clear(); - this.terminalizeTransientItems(state); - this.finishTurnPermissions(turnId); - this.emit({ - type: "session.turn", - sessionId: this.options.boundarySessionId, - turnId, - state, - }); + if (response.stopReason === "end_turn" && this.shouldDeferTurn(activePrompt)) { + await this.settleDeferredPrompt(activePrompt); + return undefined; + } + this.finishPromptTurn(turnId, state); return undefined; }, async (error): Promise => { await this.drainNotifications(); - this.fallbackChunkIds.clear(); - this.terminalizeTransientItems("failed"); - this.finishTurnPermissions(turnId); - this.emit({ - type: "session.turn", - sessionId: this.options.boundarySessionId, - turnId, - state: "failed", - error: { message: describeError(error) }, - }); + activePrompt.wirePromptsInFlight -= 1; + this.finishPromptTurn(turnId, "failed", { message: describeError(error) }); return undefined; }, ); - this.activePrompt = { turnId, settled, cancelling: false }; + activePrompt.settled = settled; + this.activePrompt = activePrompt; void settled.finally(() => { if (this.activePrompt?.turnId === turnId) this.activePrompt = null; }); } - async interrupt(): Promise { + async interrupt(): Promise { + if (this.deferredRetirement) return this.deferredRetirement; const active = this.activePrompt; + const deferredTurnId = active?.deferred ? active.turnId : null; + if (active && deferredTurnId) { + const retirement = this.retireDeferredTurn(active, deferredTurnId).catch((error) => { + if (this.deferredRetirement === retirement) this.deferredRetirement = null; + throw error; + }); + this.deferredRetirement = retirement; + return retirement; + } if (active) active.cancelling = true; try { await this.call(this.connection.cancel({ sessionId: this.nativeSessionId })); } finally { // An agent may wait for its outstanding permission replies before ending the prompt. - if (active) this.finishTurnPermissions(active.turnId); + if (active) { + this.finishTurnPermissions(active.turnId); + } } + return false; + } + + private finalizeDeferredTurn(deferredTurnId: string, emitRetired: boolean): void { + if (this.deferredFinalized) return; + this.deferredFinalized = true; + this.finishPromptTurn(deferredTurnId, "canceled", undefined, { + suppressTrailingToolEcho: true, + }); + if (emitRetired) this.options.onRetired?.(); + } + + private async retireDeferredTurn(active: ActivePrompt, deferredTurnId: string): Promise { + active.cancelling = true; + // Record open tools owned by Stop before writing session/cancel so any failure + // update arriving during cancel preserves their canceled state. + for (const id of this.liveOpenToolIds) this.canceledToolCallIds.add(id); + let cancelTimedOut = false; + if (!this.closing) { + try { + await withTimeout( + this.call(this.connection.cancel({ sessionId: this.nativeSessionId })), + 1_000, + `ACP session ${this.nativeSessionId} did not accept cancel`, + ); + } catch { + cancelTimedOut = true; + } finally { + // An agent may wait for its outstanding permission replies before ending the prompt. + this.finishTurnPermissions(active.turnId); + } + } + // ACP v1 has no response or end boundary for session/cancel once session/prompt + // already returned. Close the process first while the turn still appears running, + // then emit the canceled turn synchronously before request.completed and session.closed + // so queued work and config changes immediately observe the retired session. + try { + await this.close({ force: cancelTimedOut, timeoutMs: 1_000 }); + } catch (error) { + void this.whenConnectorClosed()?.then( + () => this.finalizeDeferredTurn(deferredTurnId, true), + () => undefined, + ); + throw error; + } + this.finalizeDeferredTurn(deferredTurnId, false); + return true; } listSessions(cwd?: string) { @@ -758,6 +905,7 @@ class AcpRuntime { sessionId: this.options.boundarySessionId, permissionId, }); + if (this.activePrompt?.deferred) this.scheduleDeferredSettle(); } async configure( @@ -833,11 +981,20 @@ class AcpRuntime { await this.close(); } - async close(): Promise { - if (this.closing) return; + close(options?: { force?: boolean; timeoutMs?: number }): Promise { + if (this.closePromise) return this.closePromise; this.closing = true; + 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; timeoutMs?: number }): Promise { this.settlePendingWork(); - await this.closeConnector(); + await this.closeConnector(options); const child = this.child; if (!child || this.processFailed) return; if (child.exitCode !== null || child.signalCode !== null) return; @@ -1066,6 +1223,7 @@ class AcpRuntime { const permissionId = `permission:${request.toolCall.toolCallId}`; return new Promise((resolve) => { this.permissions.set(permissionId, { request, resolve, turnId: this.activePrompt?.turnId }); + if (this.activePrompt?.deferred) this.scheduleDeferredSettle(); this.emit({ type: "session.permission", sessionId: this.options.boundarySessionId, @@ -1085,7 +1243,31 @@ class AcpRuntime { }); } - private sessionUpdate(notification: SessionNotification): void { + private observeWireMessage(message: unknown): void { + if (typeof message !== "object" || message === null) return; + const record = message as Record; + if (record.method === "session/update") { + this.sessionUpdateWireSeqs.push(++this.incomingWireSeq); + return; + } + if ( + !("method" in record) && + "id" in record && + typeof record.result === "object" && + record.result !== null && + typeof (record.result as Record).stopReason === "string" && + this.activePrompt && + this.activePrompt.lastPromptResponseWireSeq === null + ) { + this.activePrompt.lastPromptResponseWireSeq = ++this.incomingWireSeq; + } + } + + private isPostWirePrompt(active: ActivePrompt, wireSeq: number): boolean { + return active.lastPromptResponseWireSeq !== null && wireSeq > active.lastPromptResponseWireSeq; + } + + private sessionUpdate(notification: SessionNotification, wireSeq: number): void { if (notification.sessionId !== this.nativeSessionId) return; if (this.replayWindow) this.lastLoadUpdateAt = performance.now(); if (this.replayWindow === "skip") { @@ -1096,7 +1278,7 @@ class AcpRuntime { update.sessionUpdate === "current_mode_update" || update.sessionUpdate === "usage_update" ) { - this.reduceStateUpdate(update); + this.reduceStateUpdate(update, wireSeq); } return; } @@ -1107,10 +1289,10 @@ class AcpRuntime { this.reduceUserMessageChunk(notification.update); return; } - this.reduceUpdate(notification.update); + this.reduceUpdate(notification.update, wireSeq); } - private reduceUpdate(update: SessionUpdate): void { + private reduceUpdate(update: SessionUpdate, wireSeq: number): void { if ( update.sessionUpdate === "agent_message_chunk" || update.sessionUpdate === "agent_thought_chunk" || @@ -1144,15 +1326,16 @@ class AcpRuntime { : {}), }, }); + this.noteDeferredChunk(update.sessionUpdate, wireSeq); return; } if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") { if (update.sessionUpdate === "tool_call") this.fallbackChunkIds.clear(); - this.reduceToolCall(update); + this.reduceToolCall(update, wireSeq); return; } if (update.sessionUpdate === "plan") this.fallbackChunkIds.clear(); - this.reduceStateUpdate(update); + this.reduceStateUpdate(update, wireSeq); } // Historical user messages arrive only as replayed chunks; a live prompt @@ -1196,7 +1379,7 @@ class AcpRuntime { return id; } - private reduceStateUpdate(update: SessionUpdate): void { + private reduceStateUpdate(update: SessionUpdate, wireSeq: number): void { if (update.sessionUpdate === "plan") { this.emit({ type: "timeline.item", @@ -1253,6 +1436,7 @@ class AcpRuntime { sessionId: this.options.boundarySessionId, usage: this.lastUsage, }); + this.noteDeferredUsageUpdate(wireSeq); return; } if (update.sessionUpdate === "compaction_update") { @@ -1267,12 +1451,20 @@ class AcpRuntime { status: update.status === "completed" ? "completed" : "loading", }, }); + if (this.activePrompt?.deferred) this.scheduleDeferredSettle(); } } - private terminalizeTransientItems(state: "completed" | "failed" | "canceled"): void { + private terminalizeTransientItems( + state: "completed" | "failed" | "canceled", + options?: { preserveQualifyingOpenTools?: boolean; suppressTrailingToolEcho?: boolean }, + ): void { + const preserve = options?.preserveQualifyingOpenTools === true; for (const [id, snapshot] of this.toolCalls) { if (snapshot.status !== "pending" && snapshot.status !== "in_progress") continue; + if (preserve && this.liveOpenToolIds.has(id) && this.toolKeepsTurnOpen(snapshot)) continue; + this.liveOpenToolIds.delete(id); + if (options?.suppressTrailingToolEcho) this.canceledToolCallIds.add(id); const completed: AcpToolCallSnapshot = { ...snapshot, status: state === "completed" ? "completed" : "failed", @@ -1302,18 +1494,42 @@ class AcpRuntime { this.pendingCompactions.clear(); } - private reduceToolCall(update: ToolCall | ToolCallUpdate): void { + private reduceToolCall( + update: Extract, + wireSeq: number, + ): void { + if ( + update.sessionUpdate === "tool_call_update" && + this.canceledToolCallIds.has(update.toolCallId) + ) { + return; + } + if (update.sessionUpdate === "tool_call") { + this.canceledToolCallIds.delete(update.toolCallId); + } const current = this.toolCalls.get(update.toolCallId); + const wasOpenQualifying = + current !== undefined && + this.liveOpenToolIds.has(current.id) && + this.toolKeepsTurnOpen(current); let snapshot = mergeToolCallSnapshot(update, current); const context = { sessionId: this.options.boundarySessionId }; for (const transformer of this.transformers) snapshot = transformer.toolCall?.(snapshot, context) ?? snapshot; this.toolCalls.set(snapshot.id, snapshot); + const isOpen = snapshot.status === "pending" || snapshot.status === "in_progress"; + if (this.replayWindow === null) { + if (isOpen) this.liveOpenToolIds.add(snapshot.id); + else this.liveOpenToolIds.delete(snapshot.id); + } this.emit({ type: "timeline.item", sessionId: this.options.boundarySessionId, item: toolTimelineItem(snapshot), }); + const isOpenQualifying = + this.liveOpenToolIds.has(snapshot.id) && this.toolKeepsTurnOpen(snapshot); + this.noteDeferredToolTransition(wasOpenQualifying, isOpenQualifying, isOpen, snapshot, wireSeq); } private vendorNotification(method: string, params: unknown): void { @@ -1376,25 +1592,306 @@ class AcpRuntime { private handleUnexpectedTransportClose(): void { if (this.closing || this.processFailed) return; + const message = "ACP transport closed unexpectedly"; this.processFailed = true; - this.settlePendingWork(); + this.settlePendingWork(message); if (!this.nativeSessionId) return; this.emit({ type: "session.runtime_failed", sessionId: this.options.boundarySessionId, - error: { message: "ACP transport closed unexpectedly" }, + error: { message }, }); } - private settlePendingWork(): void { + private settlePendingWork(failureMessage?: string): void { for (const permission of this.permissions.values()) { permission.resolve({ outcome: { outcome: "cancelled" } }); } this.permissions.clear(); + if (this.activePrompt?.deferred) { + this.finishDeferredTurn( + this.activePrompt, + failureMessage ? { type: "fail", error: { message: failureMessage } } : { type: "cancel" }, + ); + } this.commandWaiter?.(); this.commandWaiter = null; } + private finishPromptTurn( + turnId: string, + state: "completed" | "failed" | "canceled", + error?: { message: string }, + options?: { preserveQualifyingOpenTools?: boolean; suppressTrailingToolEcho?: boolean }, + ): void { + this.fallbackChunkIds.clear(); + this.terminalizeTransientItems(state, options); + this.finishTurnPermissions(turnId); + if (state === "failed") { + this.emit({ + type: "session.turn", + sessionId: this.options.boundarySessionId, + turnId, + state, + error: error ?? { message: "ACP turn failed" }, + }); + return; + } + this.emit({ + type: "session.turn", + sessionId: this.options.boundarySessionId, + turnId, + state, + }); + } + + private steerDeferredPrompt(input: Extract): void { + const active = this.activePrompt; + const deferred = active?.deferred; + if (!active || !deferred || active.cancelling || this.closing || this.processFailed) { + this.emit({ + type: "session.prompt_result", + sessionId: this.options.boundarySessionId, + clientMessageId: input.prompt.clientMessageId, + result: { + type: "failed", + error: { + message: "ACP session can only steer while waiting on deferred background tools", + }, + }, + }); + return; + } + if (input.prompt.clearPendingPermissions) { + this.finishTurnPermissions(active.turnId); + } + const prompt = toAcpPrompt(input.prompt); + active.wirePromptsInFlight += 1; + this.scheduleDeferredSettle(); + this.replayWindow = null; + this.fallbackChunkIds.clear(); + this.emit({ + type: "timeline.item", + sessionId: this.options.boundarySessionId, + item: { + type: "user_message", + id: input.prompt.clientMessageId, + text: prompt + .filter((part) => part.type === "text") + .map((part) => part.text) + .join("\n"), + clientMessageId: input.prompt.clientMessageId, + }, + }); + this.emit({ + type: "session.prompt_result", + sessionId: this.options.boundarySessionId, + clientMessageId: input.prompt.clientMessageId, + result: { type: "steer", turnId: active.turnId }, + }); + const runSteer = async (): Promise => { + try { + if ( + this.closing || + this.processFailed || + active.cancelling || + active.deferred !== deferred + ) { + return; + } + 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 }), + ); + await this.drainNotifications(); + if (this.closing || this.deferredRetirement || active.deferred !== deferred) return; + if (response.usage) { + this.lastUsage = { + ...this.lastUsage, + inputTokens: response.usage.inputTokens, + outputTokens: response.usage.outputTokens, + cachedInputTokens: response.usage.cachedReadTokens ?? undefined, + }; + this.emit({ + type: "session.usage", + sessionId: this.options.boundarySessionId, + turnId: active.turnId, + usage: this.lastUsage, + }); + } + if (response.stopReason === "cancelled") { + this.finishDeferredTurn(active, { type: "cancel" }); + return; + } + if (response.stopReason !== "end_turn" && active.wirePromptsInFlight === 1) { + this.finishDeferredTurn(active, { type: "complete", terminalizeTools: true }); + } + } catch (error) { + await this.drainNotifications(); + if (this.closing || this.deferredRetirement || active.deferred !== deferred) return; + if (this.processFailed) { + this.finishDeferredTurn(active, { + type: "fail", + error: { message: describeError(error) }, + }); + } else { + this.emit({ + type: "session.notice", + sessionId: this.options.boundarySessionId, + notice: { + id: `acp:steer-error:${input.prompt.clientMessageId}`, + severity: "error", + title: "Follow-up prompt failed", + description: describeError(error), + }, + }); + } + } finally { + if (active.lastPromptResponseWireSeq === null) { + active.lastPromptResponseWireSeq = this.incomingWireSeq; + } + active.wirePromptsInFlight -= 1; + this.scheduleDeferredSettle(); + } + }; + active.wirePromptLane = active.wirePromptLane.then(runSteer); + } + + private async settleDeferredPrompt(active: ActivePrompt): Promise { + this.fallbackChunkIds.clear(); + const outcome = await new Promise((resolve) => { + active.deferred = { timer: null, resolve }; + this.scheduleDeferredSettle(); + }); + if (this.closing || this.deferredRetirement) return; + if (outcome.type === "fail") { + this.finishPromptTurn(active.turnId, "failed", outcome.error); + return; + } + this.finishPromptTurn( + active.turnId, + outcome.type === "cancel" ? "canceled" : "completed", + undefined, + { + preserveQualifyingOpenTools: outcome.type === "complete" && !outcome.terminalizeTools, + suppressTrailingToolEcho: outcome.type === "cancel", + }, + ); + } + + private toolKeepsTurnOpen(snapshot: AcpToolCallSnapshot): boolean { + const defer = this.options.options.acpOptions?.deferTurnOnRunningTools; + if (!defer) return false; + return defer.keepsTurnOpen ? defer.keepsTurnOpen(snapshot) : true; + } + + private hasQualifyingOpenTools(): boolean { + for (const id of this.liveOpenToolIds) { + const snapshot = this.toolCalls.get(id); + if (snapshot && this.toolKeepsTurnOpen(snapshot)) return true; + } + return false; + } + + private hasDeferredBlockers(): boolean { + return ( + (this.activePrompt?.wirePromptsInFlight ?? 0) > 0 || + this.hasQualifyingOpenTools() || + this.permissions.size > 0 || + this.pendingCompactions.size > 0 + ); + } + + private shouldDeferTurn(active: ActivePrompt): boolean { + if (!this.options.options.acpOptions?.deferTurnOnRunningTools) return false; + if (active.cancelling || this.closing || this.processFailed) return false; + return this.hasQualifyingOpenTools() || active.crossedEndTurn; + } + + private finishDeferredTurn(active: ActivePrompt, outcome: DeferredTurnOutcome): void { + const deferred = active.deferred; + if (!deferred) return; + if (deferred.timer) clearTimeout(deferred.timer); + active.deferred = null; + deferred.resolve(outcome); + } + + private noteDeferredToolTransition( + wasOpenQualifying: boolean, + isOpenQualifying: boolean, + isOpen: boolean, + snapshot: AcpToolCallSnapshot, + wireSeq: number, + ): void { + const active = this.activePrompt; + if (!active || wasOpenQualifying === isOpenQualifying) return; + if (!active.deferred && !this.isPostWirePrompt(active, wireSeq)) return; + if (!active.deferred && wasOpenQualifying && !isOpen && this.toolKeepsTurnOpen(snapshot)) { + active.crossedEndTurn = true; + } + if (isOpenQualifying) active.replyState = "idle"; + if (active.deferred) this.scheduleDeferredSettle(); + } + + private noteDeferredChunk( + kind: "agent_message_chunk" | "agent_thought_chunk", + wireSeq: number, + ): void { + const active = this.activePrompt; + if (!active || !this.isPostWirePrompt(active, wireSeq)) return; + 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.replyState !== "open") return; + active.replyState = this.hasQualifyingOpenTools() ? "settled_with_open_tools" : "settled"; + if (active.deferred) this.scheduleDeferredSettle(); + } + + private scheduleDeferredSettle(): void { + const active = this.activePrompt; + const deferred = active?.deferred; + const config = this.options.options.acpOptions?.deferTurnOnRunningTools; + if (!active || !deferred || !config || active.cancelling) return; + if (deferred.timer) { + clearTimeout(deferred.timer); + deferred.timer = null; + } + if (this.hasDeferredBlockers()) return; + 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(() => { + deferred.timer = null; + void this.trySettleDeferredTurn(active, deferred); + }, delayMs); + } + + private async trySettleDeferredTurn( + active: ActivePrompt, + deferred: DeferredTurnState, + ): Promise { + await this.drainNotifications(); + if ( + this.closing || + this.processFailed || + active.cancelling || + active.deferred !== deferred || + deferred.timer !== null || + this.hasDeferredBlockers() + ) { + return; + } + this.finishDeferredTurn(active, { type: "complete", terminalizeTools: true }); + } + private waitForInitialCommands(): Promise { if (this.receivedInitialCommands) return Promise.resolve(); const timeoutMs = this.options.options.acpOptions?.initialCommandsTimeoutMs ?? 1_000; @@ -1421,9 +1918,10 @@ class AcpRuntime { } } -function routeVendorNotifications( +function routeIncomingMessages( stream: Stream, - receive: (method: string, params: unknown) => void, + receiveVendor: (method: string, params: unknown) => void, + observeWire: (message: unknown) => void, ): Stream { const clientMethods = new Set(Object.values(CLIENT_METHODS)); return { @@ -1435,11 +1933,14 @@ function routeVendorNotifications( // The SDK dispatches extensions asynchronously and can resolve a later response first. // Run synchronous vendor transforms in wire order, inside the configuration transaction. try { - receive(message.method, message.params); + receiveVendor(message.method, message.params); } catch (error) { console.error("Error handling ACP vendor notification", error); } - } else controller.enqueue(message); + } else { + observeWire(message); + controller.enqueue(message); + } }, }), ), @@ -1470,11 +1971,12 @@ function permissionOptionBehavior( function ownConnectorStream(source: Stream): { stream: Stream; - close(): Promise; + close(options?: { force?: boolean; timeoutMs?: number }): Promise; + whenClosed(): Promise | null; } { 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) { @@ -1496,13 +1998,29 @@ function ownConnectorStream(source: Stream): { }; return { stream, - async close() { - if (closed) return; - closed = true; - await Promise.allSettled([ - reader.cancel(new Error("Paseo closed the ACP connector")), - writer.close(), - ]); + whenClosed: () => closing, + async close(options?: { force?: boolean; timeoutMs?: number }) { + 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, + ]).then((results) => { + if (options?.timeoutMs === undefined) return undefined; + const rejected = results.find( + (result): result is PromiseRejectedResult => result.status === "rejected", + ); + if (rejected) throw rejected.reason; + return undefined; + }); + } + if (options?.timeoutMs !== undefined) { + await withTimeout(closing, options.timeoutMs, "ACP connector did not close"); + } else { + await closing.catch(() => undefined); + } }, }; } diff --git a/packages/plugin/src/server/acp.test.ts b/packages/plugin/src/server/acp.test.ts index 718e96ac1c..05f9a26481 100644 --- a/packages/plugin/src/server/acp.test.ts +++ b/packages/plugin/src/server/acp.test.ts @@ -1,4 +1,4 @@ -import { mkdtemp, rm, writeFile } from "node:fs/promises"; +import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import path from "node:path"; import { @@ -2452,3 +2452,3821 @@ it("rewrites the session-ready, notification and configure-commit config snapsho await connection.close(); } }); + +describe("deferTurnOnRunningTools", () => { + it("keeps the turn open across end_turn until a running tool completes and the reply settles", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "cmd-1", + name: "run_command", + title: "Run background job", + status: "in_progress", + rawInput: { CommandLine: "sleep 10" }, + }, + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Started in background."), + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 100, size: 1000 }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-turn", + label: "Deferred Turn", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 30, quietLimitMs: 500 }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "turn-1", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "cmd-1" && + event.item.status === "running", + ); + // Give end_turn time to drain; the turn must remain open while cmd-1 is in_progress. + await new Promise((resolve) => setTimeout(resolve, 60)); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:turn-1" && + event.state !== "started", + ), + ).toBe(false); + + // Tool completes, followed by a usage_update before any assistant text: must NOT settle yet. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "cmd-1", + status: "completed", + rawOutput: { stdout: "DONE" }, + }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 150, size: 1000 }, + }); + await new Promise((resolve) => setTimeout(resolve, 60)); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:turn-1" && + event.state !== "started", + ), + ).toBe(false); + + // Model emits follow-up reply and usage_update: turn settles after settleDelayMs. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Background job finished: DONE."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 200, size: 1000 }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:turn-1" && + event.state === "completed", + ); + expect( + events.filter((event) => event.type === "session.turn").map((event) => event.state), + ).toEqual(["started", "completed"]); + } finally { + await connection.close(); + } + }); + + it("does not defer when keepsTurnOpen excludes the running tool", async () => { + const { connector } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "daemon-1", + name: "run_command", + title: "Start dev server", + status: "in_progress", + rawInput: { CommandLine: "npm run dev", IsDaemon: true }, + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-daemon", + label: "Deferred Daemon", + connector, + acpOptions: { + deferTurnOnRunningTools: { + settleDelayMs: 30, + quietLimitMs: 500, + keepsTurnOpen(toolCall) { + const input = toolCall.input; + return !( + typeof input === "object" && + input !== null && + !Array.isArray(input) && + input.IsDaemon === true + ); + }, + }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "daemon-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start server" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:daemon-turn" && + event.state === "completed", + ); + } finally { + await connection.close(); + } + }); + + it("settles via quietLimitMs when a background tool finishes with no follow-up reply", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "silent-1", + name: "run_command", + title: "Silent job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-quiet", + label: "Deferred Quiet", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 20, quietLimitMs: 50 }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "quiet-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run silent" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "silent-1", + ); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "silent-1", status: "completed" }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:quiet-turn" && + event.state === "completed", + ); + } finally { + await connection.close(); + } + }); + + it("preserves running tools across a follow-up prompt without sending session/cancel", async () => { + let promptCount = 0; + let cancelCount = 0; + const { connector, instances } = connectorHarness({ + handleMessage(_instance, message) { + if ("method" in message && message.method === "session/cancel") { + cancelCount += 1; + return true; + } + return false; + }, + 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-1", + name: "run_command", + title: "Long job", + status: "in_progress", + }, + }); + } else { + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("ACK"), + }); + } + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-followup", + label: "Deferred Followup", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 500 }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "turn-1", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start long job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-1", + ); + await new Promise((resolve) => setTimeout(resolve, 40)); + + // Send a follow-up prompt while bg-1 is still running. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "turn-2", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "ping" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:turn-1" && + event.state === "completed", + ); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "assistant_message" && + event.item.text === "ACK", + ); + // No session/cancel was sent, and turn-2 stays deferred while bg-1 is still running. + expect(cancelCount).toBe(0); + await new Promise((resolve) => setTimeout(resolve, 50)); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:turn-2" && + event.state !== "started", + ), + ).toBe(false); + + // Now bg-1 finishes and the agent replies. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "bg-1", status: "completed" }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Long job done."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 220, size: 1000 }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:turn-2" && + event.state === "completed", + ); + } finally { + await connection.close(); + } + }); + + it("cancels a deferred turn on interrupt and ignores trailing cancellation tool failures", async () => { + let cancelCount = 0; + const { connector, instances } = connectorHarness({ + handleMessage(_instance, message) { + if ("method" in message && message.method === "session/cancel") { + cancelCount += 1; + return true; + } + return false; + }, + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "cancel-me", + name: "run_command", + title: "Cancelable job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-cancel", + label: "Deferred Cancel", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 500 }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "cancel-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "cancel-me", + ); + await new Promise((resolve) => setTimeout(resolve, 40)); + + await connection.send({ + type: "session.interrupt", + requestId: "stop-1", + sessionId: "session-1", + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:cancel-turn" && + event.state === "canceled", + ); + await waitForEvent(events, (event) => event.type === "session.closed"); + expect(cancelCount).toBe(1); + expect(instances[1].readsCanceled).toBe(true); + const toolEvents = events.filter( + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "cancel-me", + ); + expect(toolEvents.at(-1)).toMatchObject({ + type: "timeline.item", + item: { id: "cancel-me", status: "canceled" }, + }); + } finally { + await connection.close(); + } + }); + + it("fails a deferred turn cleanly when the transport closes unexpectedly", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "crash-1", + name: "run_command", + title: "Crashing job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-crash", + label: "Deferred Crash", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 500 }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "crash-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "crash-1", + ); + await new Promise((resolve) => setTimeout(resolve, 40)); + + instances[1].closeFromAgent(); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:crash-turn" && + event.state === "failed", + ); + } finally { + await connection.close(); + } + }); + + it("steers a deferred turn without session/cancel and refuses steering while a wire prompt is in flight", async () => { + let promptCount = 0; + let cancelCount = 0; + let holdFirstPrompt: (() => void) | null = null; + const { connector, instances } = connectorHarness({ + handleMessage(_instance, message) { + if ("method" in message && message.method === "session/cancel") { + cancelCount += 1; + return true; + } + return false; + }, + 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-steer", + name: "run_command", + title: "Long background job", + status: "in_progress", + }, + }); + holdFirstPrompt = () => instance.respond(request, { stopReason: "end_turn" }); + return true; + } + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Steered ACK"), + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-steer", + label: "Deferred Steer", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 500 }, + }, + }); + const connection = await registration.connect({ + versions: [1], + capabilities: ["prompt.message", "prompt.steer"], + }); + expect(connection.capabilities).toContain("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: "turn-1", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-steer", + ); + + // Steering while the wire prompt is still in flight is rejected so callers can fall back. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-too-early", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "early steer" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && + event.clientMessageId === "steer-too-early" && + event.result.type === "failed", + ); + + // Resolve the wire prompt so the turn enters deferred mode. + holdFirstPrompt!(); + await new Promise((resolve) => setTimeout(resolve, 40)); + + // Steering while deferred succeeds in-turn without sending session/cancel. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-1", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "status?" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && + event.clientMessageId === "steer-1" && + event.result.type === "steer" && + event.result.turnId === "acp:turn-1", + ); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "assistant_message" && + event.item.text === "Steered ACK", + ); + expect(cancelCount).toBe(0); + await new Promise((resolve) => setTimeout(resolve, 40)); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:turn-1" && + event.state !== "started", + ), + ).toBe(false); + + // Background job finishes and replies: the single turn completes cleanly. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "bg-steer", status: "completed" }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Job complete."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 300, size: 1000 }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:turn-1" && + event.state === "completed", + ); + expect(cancelCount).toBe(0); + } finally { + await connection.close(); + } + }); + + it("keeps the turn open if a new qualifying tool arrives as the settle timer expires", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "tool-1", + name: "run_command", + title: "First job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-race", + label: "Deferred Race", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 30, quietLimitMs: 500 }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "race-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run jobs" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "tool-1", + ); + await new Promise((resolve) => setTimeout(resolve, 40)); + + // First tool completes and arms the 30ms settle timer. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "tool-1", status: "completed" }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Starting second job."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 100, size: 1000 }, + }); + + // Right as the 30ms timer fires, a second qualifying tool starts. + await new Promise((resolve) => setTimeout(resolve, 28)); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "tool-2", + name: "run_command", + title: "Second job", + status: "in_progress", + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "tool-2" && + event.item.status === "running", + ); + await new Promise((resolve) => setTimeout(resolve, 60)); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:race-turn" && + event.state !== "started", + ), + ).toBe(false); + + // Once tool-2 finishes and the model replies, the turn completes. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "tool-2", status: "completed" }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Second job done."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 200, size: 1000 }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:race-turn" && + event.state === "completed", + ); + } finally { + await connection.close(); + } + }); + + it("suppresses deferred cancel echoes across a new prompt without filtering opt-out providers", async () => { + // Part 1: Opt-out provider (no deferTurnOnRunningTools) still receives late tool updates after cancel. + let optOutPrompt: AcpRequestMessage | null = null; + const optOut = connectorHarness({ + handleMessage(instance, message) { + if ("method" in message && message.method === "session/cancel" && optOutPrompt) { + instance.respond(optOutPrompt, { stopReason: "cancelled" }); + optOutPrompt = null; + return true; + } + return false; + }, + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + optOutPrompt = request; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "optout-tool", + name: "run_command", + title: "Opt-out tool", + status: "in_progress", + }, + }); + return true; + }, + }); + const optOutReg = runAcpProvider({ + id: "optout-cancel", + label: "Opt-out Cancel", + connector: optOut.connector, + }); + const optOutConn = await optOutReg.connect({ + versions: [1], + capabilities: ["prompt.message"], + }); + const optOutEvents: ProviderEvent[] = []; + optOutConn.onEvent((event) => optOutEvents.push(event)); + try { + await optOutConn.send(openInput()); + await waitForEvent(optOutEvents, (event) => event.type === "session.ready"); + await optOutConn.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "optout-1", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "go" }] }, + }, + }); + await waitForEvent( + optOutEvents, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "optout-tool", + ); + await optOutConn.send({ + type: "session.interrupt", + requestId: "optout-stop", + sessionId: "session-1", + }); + await waitForEvent( + optOutEvents, + (event) => + event.type === "session.turn" && + event.turnId === "acp:optout-1" && + event.state === "canceled", + ); + optOut.instances[1].notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "optout-tool", + status: "completed", + rawOutput: { ok: true }, + }, + }); + await waitForEvent( + optOutEvents, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "optout-tool" && + event.item.status === "completed", + ); + } finally { + await optOutConn.close(); + } + + // Part 2: Deferred-canceled tool echo arriving AFTER a new prompt starts is still suppressed. + let promptNum = 0; + const deferred = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + promptNum += 1; + if (promptNum === 1) { + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "late-echo", + name: "run_command", + title: "Canceled tool", + status: "in_progress", + }, + }); + } else { + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Second turn"), + }); + } + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const deferredReg = runAcpProvider({ + id: "deferred-echo", + label: "Deferred Echo", + connector: deferred.connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 500 }, + }, + }); + const deferredConn = await deferredReg.connect({ + versions: [1], + capabilities: ["prompt.message"], + }); + const deferredEvents: ProviderEvent[] = []; + deferredConn.onEvent((event) => deferredEvents.push(event)); + try { + await deferredConn.send(openInput()); + await waitForEvent(deferredEvents, (event) => event.type === "session.ready"); + await deferredConn.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "echo-turn-1", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "first" }] }, + }, + }); + await waitForEvent( + deferredEvents, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "late-echo", + ); + await new Promise((resolve) => setTimeout(resolve, 40)); + await deferredConn.send({ + type: "session.interrupt", + requestId: "echo-stop", + sessionId: "session-1", + }); + await waitForEvent( + deferredEvents, + (event) => + event.type === "session.turn" && + event.turnId === "acp:echo-turn-1" && + event.state === "canceled", + ); + await waitForEvent(deferredEvents, (event) => event.type === "session.closed"); + expect(deferred.instances[1].readsCanceled).toBe(true); + const toolEvents = deferredEvents.filter( + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "late-echo", + ); + expect(toolEvents.at(-1)).toMatchObject({ + type: "timeline.item", + item: { id: "late-echo", status: "canceled" }, + }); + } finally { + await deferredConn.close(); + } + }); + + it("does not defer when stopReason is not end_turn", async () => { + const { connector } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "limit-tool", + name: "run_command", + title: "Stopped at limit", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "max_turn_requests" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-stop-reason", + label: "Deferred Stop Reason", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 500 }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "limit-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:limit-turn" && + event.state === "completed", + ); + } finally { + await connection.close(); + } + }); + + it("queues back-to-back steers without cancel and waits for a streaming background reply after steer end_turn", async () => { + let promptCount = 0; + let cancelCount = 0; + let finishFirstSteer: (() => void) | null = null; + const { connector, instances } = connectorHarness({ + handleMessage(_instance, message) { + if ("method" in message && message.method === "session/cancel") { + cancelCount += 1; + return true; + } + return false; + }, + 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-multi", + name: "run_command", + title: "Background job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + } + if (promptCount === 2) { + finishFirstSteer = () => { + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Steer 1 ACK"), + }); + instance.respond(request, { stopReason: "end_turn" }); + }; + return true; + } + // During steer 2, the background tool finishes and begins streaming its reply before end_turn. + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "bg-multi", + status: "completed", + }, + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Background reply part 1 "), + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-multi-steer", + label: "Deferred Multi Steer", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 50, 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: "multi-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-multi", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + // Send two back-to-back steers while steer 1 is still awaiting its wire response. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-a", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "first follow-up" }] }, + }, + }); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-b", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "second follow-up" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && + event.clientMessageId === "steer-a" && + event.result.type === "steer", + ); + expect(cancelCount).toBe(0); + + // Release steer 1; steer 2 runs next, gets accepted, and completes bg-multi while starting its reply. + await expect.poll(() => finishFirstSteer).not.toBeNull(); + finishFirstSteer!(); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && + event.clientMessageId === "steer-b" && + event.result.type === "steer", + ); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "assistant_message" && + event.item.text.includes("Background reply part 1"), + ); + + // Turn must remain open past settleDelayMs (50ms) until part 2 and usage_update arrive. + await new Promise((resolve) => setTimeout(resolve, 150)); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:multi-turn" && + event.state !== "started", + ), + ).toBe(false); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("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:multi-turn" && + event.state === "completed", + ); + expect(cancelCount).toBe(0); + expect(events).toContainEqual( + expect.objectContaining({ + type: "timeline.item", + item: expect.objectContaining({ + type: "assistant_message", + text: "Background reply part 1 part 2.", + }), + }), + ); + } finally { + await connection.close(); + } + }); + + it("delivers a queued steer even when an earlier steer returns max_turn_requests", async () => { + let promptCount = 0; + let finishFirstSteer: (() => void) | null = null; + const { connector } = 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-drop", + name: "run_command", + title: "Background job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + } + if (promptCount === 2) { + finishFirstSteer = () => instance.respond(request, { stopReason: "max_turn_requests" }); + return true; + } + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Second steer delivered"), + }); + instance.respond(request, { stopReason: "max_turn_requests" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-steer-deliver", + label: "Deferred Steer Deliver", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 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: "drop-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-drop", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-1", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "first steer" }] }, + }, + }); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-2", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "second steer" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && + event.clientMessageId === "steer-2" && + event.result.type === "steer", + ); + await expect.poll(() => finishFirstSteer).not.toBeNull(); + finishFirstSteer!(); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "assistant_message" && + event.item.text === "Second steer delivered", + ); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:drop-turn" && + event.state === "completed", + ); + expect(promptCount).toBe(3); + } finally { + await connection.close(); + } + }); + + it("ignores steer usage_update from before a background tool finishes so the background reply is not cut short", async () => { + let promptCount = 0; + 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-usage", + name: "run_command", + title: "Background job", + status: "in_progress", + }, + }); + } else { + // Steer replies and emits usage_update while bg-usage is still in_progress. + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Steer reply"), + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 150, size: 1000 }, + }); + } + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-steer-usage", + label: "Deferred Steer Usage", + 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: "usage-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-usage", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + // Steer completes with its own reply + usage_update while bg-usage is still running. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-usage", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "status?" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "assistant_message" && + event.item.text === "Steer reply", + ); + + // Now bg-usage completes. The earlier steer usage_update must NOT trigger the 40ms timer. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "bg-usage", status: "completed" }, + }); + await new Promise((resolve) => setTimeout(resolve, 120)); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:usage-turn" && + event.state !== "started", + ), + ).toBe(false); + + // Background reply arrives after the thinking gap and closes with usage_update. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Background result ready."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 250, size: 1000 }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:usage-turn" && + event.state === "completed", + ); + } finally { + await connection.close(); + } + }); + + it("ignores steer usage_update when the background tool completes during the steer request", async () => { + let promptCount = 0; + 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-mid-steer", + name: "run_command", + title: "Background job", + status: "in_progress", + }, + }); + } else { + // Tool completes while steer is in flight, followed by steer reply + steer usage_update. + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "bg-mid-steer", + status: "completed", + }, + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Steer reply"), + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 180, size: 1000 }, + }); + } + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-mid-steer-usage", + label: "Deferred Mid-Steer Usage", + 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: "mid-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-mid-steer", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-mid", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "status?" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "assistant_message" && + event.item.text === "Steer reply", + ); + + // Must NOT settle after 40ms settleDelayMs using the steer's usage_update. + await new Promise((resolve) => setTimeout(resolve, 120)); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:mid-turn" && + event.state !== "started", + ), + ).toBe(false); + + // Background reply arrives after the steer and settles via its own usage_update. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Background result."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 260, size: 1000 }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:mid-turn" && + event.state === "completed", + ); + } finally { + await connection.close(); + } + }); + + it("reports a notice and still delivers a queued steer when an earlier steer rejects with an RPC error", async () => { + let promptCount = 0; + let failFirstSteer: (() => void) | null = null; + const { connector } = 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-rpc-err", + name: "run_command", + title: "Background job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + } + if (promptCount === 2) { + failFirstSteer = () => instance.reject(request, "Transient steer error"); + return true; + } + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Second steer succeeded"), + }); + instance.respond(request, { stopReason: "max_turn_requests" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-steer-rpc-err", + label: "Deferred Steer RPC Err", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 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: "rpc-err-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-rpc-err", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-fail", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "first" }] }, + }, + }); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-next", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "second" }] }, + }, + }); + await expect.poll(() => failFirstSteer).not.toBeNull(); + failFirstSteer!(); + + await waitForEvent( + events, + (event) => + event.type === "session.notice" && + event.notice.severity === "error" && + event.notice.description?.includes("Transient steer error") === true, + ); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "assistant_message" && + event.item.text === "Second steer succeeded", + ); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:rpc-err-turn" && + event.state === "completed", + ); + expect(promptCount).toBe(3); + } finally { + await connection.close(); + } + }); + + it("keeps the background job running when a lone steer rejects and cancels cleanly if Stop raced the rejection", async () => { + let promptCount = 0; + let rejectHeldSteer: (() => 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-keep-alive", + name: "run_command", + title: "Background job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + } + if (promptCount === 2) { + instance.reject(request, "Steer rejected"); + return true; + } + if (promptCount === 3) { + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "bg-cancel-race", + name: "run_command", + title: "Cancelable job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + } + if (promptCount === 4) { + rejectHeldSteer = () => instance.reject(request, "Request aborted"); + return true; + } + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-lone-steer-reject", + label: "Deferred Lone Steer Reject", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 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"); + + // Case 1: Lone steer rejects while bg-keep-alive is still running -> notice emitted, turn stays open. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "keep-alive-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-keep-alive", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "lone-steer-fail", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "status?" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.notice" && + event.notice.severity === "error" && + event.notice.description?.includes("Steer rejected") === true, + ); + await new Promise((resolve) => setTimeout(resolve, 50)); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:keep-alive-turn" && + event.state !== "started", + ), + ).toBe(false); + + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "bg-keep-alive", + status: "completed", + }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Job finished."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 200, size: 1000 }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:keep-alive-turn" && + event.state === "completed", + ); + + // Case 2: Explicit Stop before steer rejects -> turn reports canceled, not failed. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "cancel-race-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start 2" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-cancel-race", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "raced-steer", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "follow up" }] }, + }, + }); + await expect.poll(() => rejectHeldSteer).not.toBeNull(); + await connection.send({ + type: "session.interrupt", + requestId: "stop-race", + sessionId: "session-1", + }); + // Unanswered steer past cancelTimeoutMs cancels the turn and fails the wedged runtime + // so the session is recovered instead of overlapping late updates with a new prompt. + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:cancel-race-turn" && + event.state === "canceled", + ); + await waitForEvent(events, (event) => event.type === "session.closed"); + expect(instances[1].readsCanceled).toBe(true); + + // Direct prompts to the retired session must fail cleanly instead of reusing it. + await expect( + connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "after-retire", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "should fail" }] }, + }, + }), + ).rejects.toThrow("Unknown session"); + } finally { + await connection.close(); + } + }); + + it("terminates a command-backed ACP child process when an interrupted steer retires the session", async () => { + const dir = await mkdtemp(path.join(tmpdir(), "paseo-acp-wedged-steer-")); + const pidFile = path.join(dir, "session.pid"); + const script = path.join(dir, "wedged-agent.cjs"); + await writeFile( + script, + ` + const { writeFileSync } = require("node:fs"); + const { createInterface } = require("node:readline"); + const send = (msg) => process.stdout.write(JSON.stringify({ jsonrpc: "2.0", ...msg }) + "\\n"); + let promptCount = 0; + createInterface({ input: process.stdin }).on("line", (line) => { + const msg = JSON.parse(line); + if (msg.method === "initialize") { + send({ id: msg.id, result: { protocolVersion: 1, agentCapabilities: {} } }); + } else if (msg.method === "session/new") { + writeFileSync(process.env.PID_FILE, String(process.pid)); + send({ id: msg.id, result: { sessionId: "wedged-s1", configOptions: [] } }); + } else if (msg.method === "session/prompt") { + promptCount += 1; + if (promptCount === 1) { + send({ method: "session/update", params: { sessionId: "wedged-s1", update: { + sessionUpdate: "tool_call", toolCallId: "bg-wedged", name: "run_command", + title: "Background job", status: "in_progress", + } } }); + send({ id: msg.id, result: { stopReason: "end_turn" } }); + } + // Prompt 2 (the steer) is intentionally never answered, even after session/cancel. + } else if (msg.method === "session/close") { + send({ id: msg.id, result: {} }); + } + }); + `, + ); + const registration = runAcpProvider({ + id: "wedged-command-acp", + label: "Wedged Command ACP", + command: [process.execPath, script], + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 500 }, + }, + }); + const connection = await registration.connect({ + versions: [1], + capabilities: ["prompt.message", "prompt.steer"], + }); + const events: ProviderEvent[] = []; + connection.onEvent((event) => events.push(event)); + try { + const open = openInput(); + await connection.send({ + ...open, + config: { ...open.config, env: { PID_FILE: pidFile } }, + }); + await waitForEvent(events, (event) => event.type === "session.ready"); + const pid = Number((await readFile(pidFile, "utf8")).trim()); + expect(Number.isInteger(pid) && pid > 0).toBe(true); + + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "wedged-1", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-wedged", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "wedged-steer", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "hang here" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && + event.clientMessageId === "wedged-steer" && + event.result.type === "steer", + ); + + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "wedged-replacement", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "replace wedged turn" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:wedged-1" && + event.state === "canceled", + ); + await waitForEvent(events, (event) => event.type === "session.closed"); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && + event.clientMessageId === "wedged-replacement" && + event.result.type === "failed", + ); + expect( + events.some( + (event) => event.type === "session.turn" && event.turnId === "acp:wedged-replacement", + ), + ).toBe(false); + + // The wedged child process must actually be terminated. + await expect + .poll(() => { + try { + process.kill(pid, 0); + return "alive"; + } catch { + return "dead"; + } + }) + .toBe("dead"); + } finally { + await connection.close(); + await rm(dir, { recursive: true, force: true }); + } + }); + + it("does not let excluded daemon tool updates delay settlement of a completed background job", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "daemon-chatty", + name: "run_command", + title: "Dev server", + status: "in_progress", + rawInput: { CommandLine: "npm run dev", IsDaemon: true }, + }, + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "build-job", + name: "run_command", + title: "Build", + status: "in_progress", + rawInput: { CommandLine: "npm run build" }, + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-chatty-daemon", + label: "Deferred Chatty Daemon", + connector, + acpOptions: { + deferTurnOnRunningTools: { + settleDelayMs: 60, + quietLimitMs: 1_500, + keepsTurnOpen(toolCall) { + const input = toolCall.input; + return !( + typeof input === "object" && + input !== null && + !Array.isArray(input) && + input.IsDaemon === true + ); + }, + }, + }, + }); + const connection = await registration.connect({ + versions: [1], + capabilities: ["prompt.message"], + }); + const events: ProviderEvent[] = []; + connection.onEvent((event) => events.push(event)); + let daemonTicker: ReturnType | null = null; + try { + await connection.send(openInput()); + await waitForEvent(events, (event) => event.type === "session.ready"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "chatty-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "build" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "build-job", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + // Build completes and sends reply + usage_update while daemon emits updates every 20ms. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "build-job", status: "completed" }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Build succeeded."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 120, size: 1000 }, + }); + let tick = 0; + daemonTicker = setInterval(() => { + tick += 1; + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "daemon-chatty", + status: "in_progress", + rawOutput: { stdout: `log ${tick}` }, + }, + }); + }, 20); + + // Turn must still settle in ~60ms despite the daemon updates every 20ms. + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:chatty-turn" && + event.state === "completed", + ); + } finally { + if (daemonTicker) clearInterval(daemonTicker); + await connection.close(); + } + }); + + it("releases a deferred turn when a running tool is later reclassified as an excluded daemon", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "late-daemon", + name: "run_command", + title: "Dev server", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-late-daemon", + label: "Deferred Late Daemon", + connector, + acpOptions: { + deferTurnOnRunningTools: { + settleDelayMs: 25, + quietLimitMs: 60, + keepsTurnOpen(toolCall) { + const input = toolCall.input; + return !( + typeof input === "object" && + input !== null && + !Array.isArray(input) && + input.IsDaemon === true + ); + }, + }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "late-daemon-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start dev server" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "late-daemon", + ); + await new Promise((resolve) => setTimeout(resolve, 30)); + + // Late update supplies IsDaemon: true -> leaves qualifying work and arms quietLimitMs. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "late-daemon", + rawInput: { CommandLine: "npm run dev", IsDaemon: true }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:late-daemon-turn" && + event.state === "completed", + ); + } finally { + await connection.close(); + } + }); + + it("does not delay reply settlement when a completed tool receives late output", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "late-out-tool", + name: "run_command", + title: "Build", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-late-output", + label: "Deferred Late Output", + connector, + acpOptions: { + deferTurnOnRunningTools: { + settleDelayMs: 30, + quietLimitMs: 1_500, + }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "late-out-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "build" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "late-out-tool", + ); + await new Promise((resolve) => setTimeout(resolve, 20)); + + // Tool completes, post-tool reply and usage_update arm the short settleDelayMs timer. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "late-out-tool", + status: "completed", + }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Build succeeded."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 200, size: 1000 }, + }); + // Late output on the already-completed tool must not reset the short reply timer to quietLimitMs. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "late-out-tool", + rawOutput: { output: "trailing log line" }, + }, + }); + + const startedAt = Date.now(); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:late-out-turn" && + event.state === "completed", + 400, + ); + expect(Date.now() - startedAt).toBeLessThan(400); + } finally { + await connection.close(); + } + }); + + it("settles on the reply timer when reply text starts before the last background tool completes", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "bg-a", + name: "run_command", + title: "Job A", + status: "in_progress", + }, + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "bg-b", + name: "run_command", + title: "Job B", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-overlap-reply", + label: "Deferred Overlap Reply", + connector, + acpOptions: { + deferTurnOnRunningTools: { + settleDelayMs: 30, + quietLimitMs: 1_500, + }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "overlap-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run both jobs" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-b", + ); + await new Promise((resolve) => setTimeout(resolve, 20)); + + // Job A finishes and assistant starts streaming the reply while Job B is still running. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "bg-a", status: "completed" }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Both jobs are finishing up."), + }); + // Job B completes, then the reply's usage_update arrives -> should settle via settleDelayMs. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "bg-b", status: "completed" }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 300, size: 1000 }, + }); + + const startedAt = Date.now(); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:overlap-turn" && + event.state === "completed", + 400, + ); + expect(Date.now() - startedAt).toBeLessThan(400); + } finally { + await connection.close(); + } + }); + + it("settles on the reply timer when reply usage arrives before the final background tool completes", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "bg-u1", + name: "run_command", + title: "Job 1", + status: "in_progress", + }, + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "bg-u2", + name: "run_command", + title: "Job 2", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-usage-before-tool", + label: "Deferred Usage Before Tool", + connector, + acpOptions: { + deferTurnOnRunningTools: { + settleDelayMs: 30, + quietLimitMs: 1_500, + }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "usage-first-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run jobs" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-u2", + ); + await new Promise((resolve) => setTimeout(resolve, 20)); + + // Job 1 finishes, reply + usage_update arrive while Job 2 is still running. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "bg-u1", status: "completed" }, + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("All done."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 300, size: 1000 }, + }); + await new Promise((resolve) => setTimeout(resolve, 50)); + // Still running because Job 2 has not completed yet. + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:usage-first-turn" && + event.state !== "started", + ), + ).toBe(false); + + // Job 2 completes -> should settle via settleDelayMs, not quietLimitMs. + const startedAt = Date.now(); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "tool_call_update", toolCallId: "bg-u2", status: "completed" }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:usage-first-turn" && + event.state === "completed", + 400, + ); + expect(Date.now() - startedAt).toBeLessThan(400); + } finally { + await connection.close(); + } + }); + + it("defers the turn when a running tool completes immediately after end_turn in the same batch", async () => { + const { connector, instances } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "bg-race", + name: "run_command", + title: "Fast background job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + // Completion arrives right after end_turn in the same wire batch. + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "bg-race", + status: "completed", + }, + }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-post-end-turn-race", + label: "Deferred Post End Turn Race", + connector, + acpOptions: { + deferTurnOnRunningTools: { + settleDelayMs: 30, + quietLimitMs: 1_500, + }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "race-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run fast bg job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-race" && + event.item.status === "completed", + ); + await new Promise((resolve) => setTimeout(resolve, 60)); + // Turn must still be open waiting for the post-tool reply. + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:race-turn" && + event.state !== "started", + ), + ).toBe(false); + + // Post-tool reply + usage_update arrive and settle the deferred turn. + instances[1].notify("session/update", { + sessionId: "connector-session", + update: textChunk("Background job finished."), + }); + instances[1].notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 250, size: 1000 }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:race-turn" && + event.state === "completed", + 400, + ); + expect( + events.some( + (event) => + event.type === "timeline.item" && + event.item.type === "assistant_message" && + event.item.text === "Background job finished.", + ), + ).toBe(true); + } finally { + await connection.close(); + } + }); + + it("does not defer when an open tool is reclassified as an excluded daemon immediately after end_turn", async () => { + const { connector } = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "daemon-race", + name: "run_command", + title: "Dev server", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + // Reclassification to IsDaemon: true arrives in the same batch right after end_turn. + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "daemon-race", + rawInput: { CommandLine: "npm run dev", IsDaemon: true }, + }, + }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-daemon-race", + label: "Deferred Daemon Race", + connector, + acpOptions: { + deferTurnOnRunningTools: { + settleDelayMs: 30, + quietLimitMs: 1_500, + keepsTurnOpen(toolCall) { + const input = toolCall.input; + return !( + typeof input === "object" && + input !== null && + !Array.isArray(input) && + input.IsDaemon === true + ); + }, + }, + }, + }); + 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"); + const startedAt = Date.now(); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "daemon-race-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start dev server" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:daemon-race-turn" && + event.state === "completed", + 400, + ); + expect(Date.now() - startedAt).toBeLessThan(400); + } finally { + await connection.close(); + } + }); + + it("settles on the reply timer when background completion and reply arrive immediately after steer end_turn", async () => { + let promptCount = 0; + const { connector } = 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-after-steer", + name: "run_command", + title: "Background job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + } + // Steer response followed immediately in the same wire batch by background completion + reply + usage. + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Steer ACK"), + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 100, size: 1000 }, + }); + instance.respond(request, { stopReason: "end_turn" }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "bg-after-steer", + status: "completed", + }, + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Background finished."), + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 300, size: 1000 }, + }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-post-steer-batch", + label: "Deferred Post Steer Batch", + 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: "post-steer-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run bg" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-after-steer", + ); + await new Promise((resolve) => setTimeout(resolve, 20)); + + const startedAt = Date.now(); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "post-steer-followup", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "status?" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:post-steer-turn" && + event.state === "completed", + 400, + ); + expect(Date.now() - startedAt).toBeLessThan(400); + } finally { + await connection.close(); + } + }); + + it("preserves a settled background reply across a second queued steer with no new background work", async () => { + let promptCount = 0; + let releaseSteer1: (() => void) | null = null; + const { connector } = 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-two-steers", + name: "run_command", + title: "Background job", + 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.notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 100, size: 1000 }, + }); + instance.respond(request, { stopReason: "end_turn" }); + // Background job finishes and replies immediately after Steer 1 returns end_turn. + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call_update", + toolCallId: "bg-two-steers", + status: "completed", + }, + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Background finished."), + }); + instance.notify("session/update", { + sessionId: "connector-session", + update: { sessionUpdate: "usage_update", used: 250, size: 1000 }, + }); + }; + return true; + } + // Steer 2 returns end_turn with no new background work. + instance.notify("session/update", { + sessionId: "connector-session", + update: textChunk("Steer 2 ACK"), + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const registration = runAcpProvider({ + id: "deferred-two-steers-settled", + label: "Deferred Two Steers Settled", + 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-steers-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run bg" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-two-steers", + ); + await new Promise((resolve) => setTimeout(resolve, 20)); + + // Queue two steers back-to-back. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-one", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "first steer" }] }, + }, + }); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "steer-two", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "second steer" }] }, + }, + }); + await new Promise((resolve) => setTimeout(resolve, 20)); + + const startedAt = Date.now(); + releaseSteer1!(); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:two-steers-turn" && + event.state === "completed", + 400, + ); + expect(Date.now() - startedAt).toBeLessThan(400); + expect(promptCount).toBe(3); + } finally { + 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(); + } + }); + + it("waits for process exit and emits terminal events once across overlapping interrupts", async () => { + const dir = await mkdtemp(path.join(tmpdir(), "paseo-acp-overlap-interrupt-")); + temporaryDirectories.push(dir); + const scriptPath = path.join(dir, "slow-exit-acp.mjs"); + const pidFile = path.join(dir, "child.pid"); + await writeFile( + scriptPath, + [ + `import { writeFileSync } from "node:fs";`, + `import { createInterface } from "node:readline";`, + `writeFileSync(${JSON.stringify(pidFile)}, String(process.pid));`, + `process.on("SIGTERM", () => { setTimeout(() => process.exit(0), 250); });`, + `const write = (msg) => process.stdout.write(JSON.stringify(msg) + "\\n");`, + `let prompts = 0;`, + `createInterface({ input: process.stdin }).on("line", (line) => {`, + ` if (!line.trim()) return;`, + ` const msg = JSON.parse(line);`, + ` if (msg.method === "initialize") {`, + ` write({ jsonrpc: "2.0", id: msg.id, result: { protocolVersion: 1, agentCapabilities: {} } });`, + ` return;`, + ` }`, + ` if (msg.method === "session/new") {`, + ` write({ jsonrpc: "2.0", id: msg.id, result: { sessionId: "slow-session" } });`, + ` return;`, + ` }`, + ` if (msg.method === "session/prompt") {`, + ` prompts += 1;`, + ` if (prompts === 1) {`, + ` write({ jsonrpc: "2.0", method: "session/update", params: { sessionId: "slow-session", update: { sessionUpdate: "tool_call", toolCallId: "slow-bg", name: "run_command", title: "Job", status: "in_progress" } } });`, + ` write({ jsonrpc: "2.0", id: msg.id, result: { stopReason: "end_turn" } });`, + ` }`, + ` }`, + `});`, + ].join("\n"), + "utf8", + ); + const registration = runAcpProvider({ + id: "deferred-overlap-interrupt", + label: "Deferred Overlap Interrupt", + command: [process.execPath, scriptPath], + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 30, 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: "slow-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "slow-bg", + ); + await new Promise((resolve) => setTimeout(resolve, 40)); + + // Start a hung steer so the session is actively awaiting a steer response. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "slow-steer", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "steer" }] }, + }, + }); + await waitForEvent( + events, + (event) => event.type === "session.prompt_result" && event.clientMessageId === "slow-steer", + ); + + const childPid = Number((await readFile(pidFile, "utf8")).trim()); + const startedAt = Date.now(); + await Promise.all([ + connection.send({ + type: "session.interrupt", + requestId: "int-1", + sessionId: "session-1", + }), + connection.send({ + type: "session.interrupt", + requestId: "int-2", + sessionId: "session-1", + }), + ]); + await waitForEvent( + events, + (event) => event.type === "request.completed" && event.requestId === "int-1", + ); + await waitForEvent( + events, + (event) => event.type === "request.completed" && event.requestId === "int-2", + ); + + // Both interrupts waited for the 250ms SIGTERM exit, and process is now dead. + expect(Date.now() - startedAt).toBeGreaterThanOrEqual(200); + expect(() => process.kill(childPid, 0)).toThrow(); + + // Canceled turn and session.closed were each emitted exactly once. + expect( + events.filter( + (event) => + event.type === "session.turn" && + event.turnId === "acp:slow-turn" && + event.state === "canceled", + ), + ).toHaveLength(1); + expect(events.filter((event) => event.type === "session.closed")).toHaveLength(1); + } finally { + await connection.close(); + } + }); + + it("lets deferred retirement be the sole emitter of cancellation when a steer returns cancelled during a slow cancel write", async () => { + let promptCount = 0; + let respondSteerCancelled: (() => void) | null = null; + let releaseCancelWrite: (() => void) | null = null; + let closedConnector = false; + const base = 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-slow-cancel", + name: "run_command", + title: "Job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + } + respondSteerCancelled = () => instance.respond(request, { stopReason: "cancelled" }); + return true; + }, + }); + const connector = async () => { + const inner = await base.connector(); + closedConnector = false; + const writer = inner.writable.getWriter(); + const writable = new WritableStream({ + async write(message) { + if ("method" in message && message.method === "session/cancel") { + respondSteerCancelled?.(); + await new Promise((resolve) => { + releaseCancelWrite = resolve; + }); + } + await writer.write(message); + }, + async close() { + closedConnector = true; + await writer.close(); + }, + async abort(reason) { + closedConnector = true; + await writer.abort(reason); + }, + }); + return { readable: inner.readable, writable }; + }; + const registration = runAcpProvider({ + id: "deferred-slow-cancel-steer", + label: "Deferred Slow Cancel Steer", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 30, 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: "slow-cancel-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-slow-cancel", + ); + await new Promise((resolve) => setTimeout(resolve, 20)); + + // Start an in-flight steer, then initiate Stop while session/cancel write is held open. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "slow-cancel-steer", + delivery: "steer", + input: { type: "message", content: [{ type: "text", text: "steer" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && event.clientMessageId === "slow-cancel-steer", + ); + await new Promise((resolve) => setTimeout(resolve, 20)); + + const interruptPromise = connection.send({ + type: "session.interrupt", + requestId: "slow-cancel-int", + sessionId: "session-1", + }); + await new Promise((resolve) => setTimeout(resolve, 40)); + + // Even though steer returned stopReason: "cancelled", retirement has not closed yet: + // no canceled turn should be emitted yet, and a replacement prompt must be rejected. + expect(closedConnector).toBe(false); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:slow-cancel-turn" && + event.state === "canceled", + ), + ).toBe(false); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "replacement-during-retire", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "too early" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && + event.clientMessageId === "replacement-during-retire" && + event.result.type === "failed", + ); + + // Release the cancel write: retirement closes the transport and emits cancellation once. + releaseCancelWrite!(); + await interruptPromise; + await waitForEvent( + events, + (event) => event.type === "request.completed" && event.requestId === "slow-cancel-int", + ); + expect(closedConnector).toBe(true); + expect( + events.filter( + (event) => + event.type === "session.turn" && + event.turnId === "acp:slow-cancel-turn" && + event.state === "canceled", + ), + ).toHaveLength(1); + expect(events.filter((event) => event.type === "session.closed")).toHaveLength(1); + } finally { + releaseCancelWrite?.(); + await connection.close(); + } + }); + + it("tears down a deferred ACP child when stdin stalls behind a large steer", async () => { + const dir = await mkdtemp(path.join(tmpdir(), "paseo-acp-stalled-stdin-")); + temporaryDirectories.push(dir); + const scriptPath = path.join(dir, "stalled-stdin-acp.mjs"); + const pidFile = path.join(dir, "child.pid"); + await writeFile( + scriptPath, + [ + `import { writeFileSync } from "node:fs";`, + `writeFileSync(${JSON.stringify(pidFile)}, String(process.pid));`, + `const write = (msg) => process.stdout.write(JSON.stringify(msg) + "\\n");`, + `let buffer = "";`, + `const onData = (chunk) => {`, + ` buffer += chunk.toString("utf8");`, + ` let idx;`, + ` while ((idx = buffer.indexOf("\\n")) !== -1) {`, + ` const line = buffer.slice(0, idx).trim();`, + ` buffer = buffer.slice(idx + 1);`, + ` if (!line) continue;`, + ` const msg = JSON.parse(line);`, + ` if (msg.method === "initialize") {`, + ` write({ jsonrpc: "2.0", id: msg.id, result: { protocolVersion: 1, agentCapabilities: {} } });`, + ` } else if (msg.method === "session/new") {`, + ` write({ jsonrpc: "2.0", id: msg.id, result: { sessionId: "stalled-session" } });`, + ` } else if (msg.method === "session/prompt") {`, + ` write({ jsonrpc: "2.0", method: "session/update", params: { sessionId: "stalled-session", update: { sessionUpdate: "tool_call", toolCallId: "stalled-bg", name: "run_command", title: "Job", status: "in_progress" } } });`, + ` write({ jsonrpc: "2.0", id: msg.id, result: { stopReason: "end_turn" } });`, + ` // Stop reading stdin so a large follow-up steer fills the pipe buffer.`, + ` process.stdin.off("data", onData);`, + ` process.stdin.pause();`, + ` setInterval(() => {}, 10_000);`, + ` return;`, + ` }`, + ` }`, + `};`, + `process.stdin.on("data", onData);`, + ].join("\n"), + "utf8", + ); + const registration = runAcpProvider({ + id: "deferred-stalled-stdin", + label: "Deferred Stalled Stdin", + command: [process.execPath, scriptPath], + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 30, quietLimitMs: 5_000 }, + }, + }); + 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: "stalled-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "stalled-bg", + ); + await new Promise((resolve) => setTimeout(resolve, 40)); + + // Fill the child's stdin pipe buffer with a 2 MB steer while the child is paused. + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "stalled-steer", + delivery: "steer", + input: { + type: "message", + content: [{ type: "text", text: "x".repeat(2 * 1024 * 1024) }], + }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "session.prompt_result" && event.clientMessageId === "stalled-steer", + ); + await new Promise((resolve) => setTimeout(resolve, 40)); + + const childPid = Number((await readFile(pidFile, "utf8")).trim()); + await connection.send({ + type: "session.interrupt", + requestId: "stalled-int", + sessionId: "session-1", + }); + await waitForEvent( + events, + (event) => event.type === "request.completed" && event.requestId === "stalled-int", + 3_000, + ); + expect(() => process.kill(childPid, 0)).toThrow(); + expect( + events.filter( + (event) => + event.type === "session.turn" && + event.turnId === "acp:stalled-turn" && + event.state === "canceled", + ), + ).toHaveLength(1); + expect(events.filter((event) => event.type === "session.closed")).toHaveLength(1); + } finally { + await connection.close(); + } + }); + + 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) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "stalled-conn-bg", + name: "run_command", + title: "Job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const connector = async () => { + const inner = await base.connector(); + const writer = inner.writable.getWriter(); + const writable = new WritableStream({ + async write(message) { + if ("method" in message && message.method === "session/cancel") { + await new Promise((resolve) => { + releaseStalledWrite = resolve; + }); + } + await writer.write(message); + }, + close: () => writer.close(), + abort: (reason) => writer.abort(reason), + }); + return { readable: inner.readable, writable }; + }; + const registration = runAcpProvider({ + id: "deferred-stalled-connector", + label: "Deferred Stalled Connector", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 30, quietLimitMs: 5_000 }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "stalled-conn-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "stalled-conn-bg", + ); + await new Promise((resolve) => setTimeout(resolve, 20)); + + await connection.send({ + type: "session.interrupt", + requestId: "stalled-conn-int", + sessionId: "session-1", + }); + const failed = await waitForEvent( + events, + (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.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:stalled-conn-turn" && + event.state === "canceled", + ), + ).toBe(false); + + // Once the connector finishes closing after the deadline, the turn and session retire cleanly. + releaseStalledWrite!(); + await waitForEvent( + events, + (event) => + event.type === "session.turn" && + event.turnId === "acp:stalled-conn-turn" && + event.state === "canceled", + 2_000, + ); + await waitForEvent(events, (event) => event.type === "session.closed", 2_000); + expect(events.filter((event) => event.type === "session.closed")).toHaveLength(1); + } finally { + releaseStalledWrite?.(); + await connection.close(); + } + }); + + it("reports interrupt failure when a connector rejects readable shutdown", async () => { + let connectorCall = 0; + const base = connectorHarness({ + handleRequest(instance, request) { + if (request.method !== "session/prompt") return false; + instance.notify("session/update", { + sessionId: "connector-session", + update: { + sessionUpdate: "tool_call", + toolCallId: "reject-cancel-bg", + name: "run_command", + title: "Job", + status: "in_progress", + }, + }); + instance.respond(request, { stopReason: "end_turn" }); + return true; + }, + }); + const connector = async () => { + connectorCall += 1; + const inner = await base.connector(); + if (connectorCall === 1) return inner; + const reader = inner.readable.getReader(); + const readable = new ReadableStream({ + async pull(controller) { + const next = await reader.read(); + if (next.done) controller.close(); + else controller.enqueue(next.value); + }, + async cancel() { + await reader.cancel(); + throw new Error("connector cancel rejected"); + }, + }); + return { readable, writable: inner.writable }; + }; + const registration = runAcpProvider({ + id: "deferred-reject-cancel", + label: "Deferred Reject Cancel", + connector, + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 30, quietLimitMs: 5_000 }, + }, + }); + 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"); + await connection.send({ + type: "session.prompt", + sessionId: "session-1", + prompt: { + clientMessageId: "reject-cancel-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run job" }] }, + }, + }); + await waitForEvent( + events, + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "reject-cancel-bg", + ); + await new Promise((resolve) => setTimeout(resolve, 20)); + + await connection.send({ + type: "session.interrupt", + requestId: "reject-cancel-int", + sessionId: "session-1", + }); + const failed = await waitForEvent( + events, + (event) => event.type === "request.failed" && event.requestId === "reject-cancel-int", + 2_000, + ); + expect(failed.type === "request.failed" && failed.error.message).toContain( + "connector cancel rejected", + ); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:reject-cancel-turn" && + event.state === "canceled", + ), + ).toBe(false); + } finally { + await connection.close(); + } + }); + + it("does not enforce the deferred Stop deadline on non-deferred probe shutdown", async () => { + const base = connectorHarness(); + const connector = async () => { + const inner = await base.connector(); + const writer = inner.writable.getWriter(); + const writable = new WritableStream({ + write: (message) => writer.write(message), + async close() { + await new Promise((resolve) => setTimeout(resolve, 1_100)); + await writer.close(); + }, + abort: (reason) => writer.abort(reason), + }); + return { readable: inner.readable, writable }; + }; + const registration = runAcpProvider({ + id: "slow-probe-close", + label: "Slow Probe Close", + connector, + }); + const connection = await registration.connect({ + versions: [1], + capabilities: ["prompt.message"], + }); + await connection.close(); + }); +}); diff --git a/packages/plugin/src/server/acp.ts b/packages/plugin/src/server/acp.ts index d3fb394c25..e1be1884d6 100644 --- a/packages/plugin/src/server/acp.ts +++ b/packages/plugin/src/server/acp.ts @@ -53,6 +53,18 @@ export interface AcpOptions { initialCommandsTimeoutMs?: number; /** Allow delayed session/load updates before publishing the session as ready. */ loadReplayQuietPeriodMs?: number; + /** + * Keep a turn open after `end_turn` while qualifying tool calls are still running, + * settling once those tools finish and the agent finishes its follow-up reply. + */ + deferTurnOnRunningTools?: { + /** Delay after `usage_update` closes a follow-up reply before settling. Defaults to 500ms. */ + settleDelayMs?: number; + /** Quiet limit after qualifying tools finish if no reply settles via `usage_update`. Defaults to 120_000ms. */ + quietLimitMs?: number; + /** Predicate deciding whether an open tool call keeps the turn open. Defaults to all running tools. */ + keepsTurnOpen?: (toolCall: AcpToolCallSnapshot) => boolean; + }; /** An unattended mode that approves ACP allow-once requests in the specified native mode. */ autoAcceptMode?: { mode: Omit; diff --git a/packages/server/src/server/agent/agent-manager.ts b/packages/server/src/server/agent/agent-manager.ts index 1714144f24..678ed8efa4 100644 --- a/packages/server/src/server/agent/agent-manager.ts +++ b/packages/server/src/server/agent/agent-manager.ts @@ -881,6 +881,7 @@ export class AgentManager { >(); private readonly collectingRuntimes = new Set(); private readonly lifecycleMutationTails = new Map>(); + private readonly pendingCancellations = new Map>(); private readonly agentStreamCoalescer: AgentStreamCoalescer; private mcpBaseUrl: string | null; private readonly mcpAuthToken: string | null; @@ -2463,80 +2464,83 @@ export class AgentManager { // reload or close; providers do no sequencing of their own. async setAgentMode(agentId: string, modeId: string): Promise { - return this.runLifecycleMutation(agentId, async () => { - const agent = await this.ensureInteractiveSessionUnlocked(agentId); - const notice = (await agent.session.setMode(modeId)) ?? null; - await this.drainSessionEvents(agentId); - const currentMode = (await agent.session.getCurrentMode()) ?? modeId; - agent.config.modeId = currentMode ?? undefined; - agent.currentModeId = currentMode; - // Update runtimeInfo to reflect the new mode - if (agent.runtimeInfo) { - agent.runtimeInfo = { ...agent.runtimeInfo, modeId: currentMode }; - } - this.touchUpdatedAt(agent); - this.emitState(agent); - return notice; - }); + return this.runLifecycleMutation(agentId, () => + this.withLiveInteractiveSessionUnlocked(agentId, async (agent) => { + const notice = (await agent.session.setMode(modeId)) ?? null; + await this.drainSessionEvents(agentId); + const currentMode = (await agent.session.getCurrentMode()) ?? modeId; + agent.config.modeId = currentMode ?? undefined; + agent.currentModeId = currentMode; + // Update runtimeInfo to reflect the new mode + if (agent.runtimeInfo) { + agent.runtimeInfo = { ...agent.runtimeInfo, modeId: currentMode }; + } + this.touchUpdatedAt(agent); + this.emitState(agent); + return notice; + }), + ); } async setAgentModel(agentId: string, modelId: string | null): Promise { - return this.runLifecycleMutation(agentId, async () => { - const agent = await this.ensureInteractiveSessionUnlocked(agentId); - const normalizedModelId = - typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null; + return this.runLifecycleMutation(agentId, () => + this.withLiveInteractiveSessionUnlocked(agentId, async (agent) => { + const normalizedModelId = + typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null; - const selection = await agent.session.setModel?.(normalizedModelId); - await this.drainSessionEvents(agentId); + const selection = await agent.session.setModel?.(normalizedModelId); + await this.drainSessionEvents(agentId); - // A reset clears the preference even when the provider retains its active model. - let effectiveModelId = normalizedModelId; - if (normalizedModelId !== null && selection) effectiveModelId = selection.model; + // A reset clears the preference even when the provider retains its active model. + let effectiveModelId = normalizedModelId; + if (normalizedModelId !== null && selection) effectiveModelId = selection.model; - agent.config.model = effectiveModelId ?? undefined; - if (agent.runtimeInfo) { - agent.runtimeInfo = { ...agent.runtimeInfo, model: effectiveModelId }; - } - this.refreshSessionPersistence(agent); - this.touchUpdatedAt(agent); - this.emitState(agent); - }); + agent.config.model = effectiveModelId ?? undefined; + if (agent.runtimeInfo) { + agent.runtimeInfo = { ...agent.runtimeInfo, model: effectiveModelId }; + } + this.refreshSessionPersistence(agent); + this.touchUpdatedAt(agent); + this.emitState(agent); + }), + ); } async setAgentThinkingOption( agentId: string, thinkingOptionId: string | null, ): Promise { - return this.runLifecycleMutation(agentId, async () => { - const agent = await this.ensureInteractiveSessionUnlocked(agentId); - const normalizedThinkingOptionId = - typeof thinkingOptionId === "string" && thinkingOptionId.trim().length > 0 - ? thinkingOptionId - : null; + return this.runLifecycleMutation(agentId, () => + this.withLiveInteractiveSessionUnlocked(agentId, async (agent) => { + const normalizedThinkingOptionId = + typeof thinkingOptionId === "string" && thinkingOptionId.trim().length > 0 + ? thinkingOptionId + : null; - let notice: AgentProviderNotice | null = null; - if (agent.session.setThinkingOption) { - notice = (await agent.session.setThinkingOption(normalizedThinkingOptionId)) ?? null; - } - await this.drainSessionEvents(agentId); + let notice: AgentProviderNotice | null = null; + if (agent.session.setThinkingOption) { + notice = (await agent.session.setThinkingOption(normalizedThinkingOptionId)) ?? null; + } + await this.drainSessionEvents(agentId); - let effectiveThinkingOptionId = normalizedThinkingOptionId; - const runtimeInfo = await agent.session.getRuntimeInfo(); - if (runtimeInfo.thinkingOptionId !== undefined) { - effectiveThinkingOptionId = runtimeInfo.thinkingOptionId; - } + let effectiveThinkingOptionId = normalizedThinkingOptionId; + const runtimeInfo = await agent.session.getRuntimeInfo(); + if (runtimeInfo.thinkingOptionId !== undefined) { + effectiveThinkingOptionId = runtimeInfo.thinkingOptionId; + } - agent.config.thinkingOptionId = effectiveThinkingOptionId ?? undefined; - if (agent.runtimeInfo) { - agent.runtimeInfo = { - ...agent.runtimeInfo, - thinkingOptionId: effectiveThinkingOptionId, - }; - } - this.touchUpdatedAt(agent); - this.emitState(agent); - return notice; - }); + agent.config.thinkingOptionId = effectiveThinkingOptionId ?? undefined; + if (agent.runtimeInfo) { + agent.runtimeInfo = { + ...agent.runtimeInfo, + thinkingOptionId: effectiveThinkingOptionId, + }; + } + this.touchUpdatedAt(agent); + this.emitState(agent); + return notice; + }), + ); } /** @@ -2546,42 +2550,45 @@ export class AgentManager { * one step once the provider accepts. Patches to one agent run one at a time, in arrival order. */ async setAgentOptions(agentId: string, requested: ProviderOptionsPatch): Promise { - return this.runLifecycleMutation(agentId, async () => { - const agent = await this.ensureInteractiveSessionUnlocked(agentId); - const patch = this.convertLegacyOptions(agent.provider, requested); - let ended: ProviderOptionsPatch = {}; - let sent: ProviderOptionsPatch = {}; - if (Object.keys(patch).length > 0) { - // A provider that cannot apply options to a running agent must not store them either. - if (!agent.session.applyOptions) { - throw new ProviderOptionsValidationError( - agent.provider, - Object.keys(patch).map((key) => ({ - path: [key], - message: "cannot change on a running session; it applies when the agent is opened", - })), + return this.runLifecycleMutation(agentId, () => + this.withLiveInteractiveSessionUnlocked(agentId, async (agent) => { + const patch = this.convertLegacyOptions(agent.provider, requested); + let ended: ProviderOptionsPatch = {}; + let sent: ProviderOptionsPatch = {}; + if (Object.keys(patch).length > 0) { + // A provider that cannot apply options to a running agent must not store them either. + if (!agent.session.applyOptions) { + throw new ProviderOptionsValidationError( + agent.provider, + Object.keys(patch).map((key) => ({ + path: [key], + message: "cannot change on a running session; it applies when the agent is opened", + })), + ); + } + const set = Object.fromEntries( + Object.entries(patch).filter(([, value]) => value != null), ); + const resolved = this.effectiveOptionsFor(agent.provider, set); + sent = Object.fromEntries(Object.keys(patch).map((key) => [key, resolved[key] ?? null])); + const modelBefore = agent.runtimeInfo?.model; + ended = (await agent.session.applyOptions(sent)) ?? {}; + // Changes the provider made on its own while applying are older than its final answer. + await this.drainSessionEvents(agentId); + await this.refreshRuntimeInfo(agent, { emit: false }); + // An option can choose the model too, as an fx connection does. Reopening the agent on + // the earlier preference would send that model to the new connection. + const modelAfter = agent.runtimeInfo?.model; + if (agent.config.model && modelAfter && modelAfter !== modelBefore) { + agent.config.model = modelAfter; + } } - const set = Object.fromEntries(Object.entries(patch).filter(([, value]) => value != null)); - const resolved = this.effectiveOptionsFor(agent.provider, set); - sent = Object.fromEntries(Object.keys(patch).map((key) => [key, resolved[key] ?? null])); - const modelBefore = agent.runtimeInfo?.model; - ended = (await agent.session.applyOptions(sent)) ?? {}; - // Changes the provider made on its own while applying are older than its final answer. - await this.drainSessionEvents(agentId); - await this.refreshRuntimeInfo(agent, { emit: false }); - // An option can choose the model too, as an fx connection does. Reopening the agent on - // the earlier preference would send that model to the new connection. - const modelAfter = agent.runtimeInfo?.model; - if (agent.config.model && modelAfter && modelAfter !== modelBefore) { - agent.config.model = modelAfter; - } - } - this.storeOptionsPatch({ agent, patch: { ...patch, ...ended } }); - this.updateEffectiveOptions({ agent, sent, reported: ended }); - this.touchUpdatedAt(agent); - this.emitState(agent); - }); + this.storeOptionsPatch({ agent, patch: { ...patch, ...ended } }); + this.updateEffectiveOptions({ agent, sent, reported: ended }); + this.touchUpdatedAt(agent); + this.emitState(agent); + }), + ); } /** The config as the opened session left it: its own difference from the options it was given. */ @@ -3267,6 +3274,33 @@ export class AgentManager { return this.requireSessionAgent(agentId); } + /** Inside the agent's lane: transparently reopens a retired plugin session before applying config. */ + private async withLiveInteractiveSessionUnlocked( + agentId: string, + operation: (agent: ActiveManagedAgent) => Promise, + ): Promise { + 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); + } catch (error) { + if (!isStaleProviderSessionError(error)) throw error; + await this.runs.getPendingRun(agentId)?.settledPromise.catch(() => undefined); + if (this.hasInFlightRun(agentId)) throw error; + await this.trackAgentRegistrationOperation(this.reloadAgentSessionInternal(agentId)); + return await operation(this.requireSessionAgent(agentId)); + } + } + private async *streamAfterHistoryLoad( agentId: string, prompt: AgentPromptInput, @@ -3925,10 +3959,18 @@ export class AgentManager { } async cancelAgentRun(agentId: string): Promise { - return this.runForegroundMutation(agentId, () => { + const cancellation = this.runForegroundMutation(agentId, () => { this.requireSessionAgent(agentId).pendingReplacement = false; return this.cancelAgentRunNow(agentId); }); + this.pendingCancellations.set(agentId, cancellation); + try { + return await cancellation; + } finally { + if (this.pendingCancellations.get(agentId) === cancellation) { + this.pendingCancellations.delete(agentId); + } + } } private async cancelAgentRunNow(agentId: string): Promise { diff --git a/packages/server/src/server/agent/plugin-provider.test.ts b/packages/server/src/server/agent/plugin-provider.test.ts index dd0877ed6d..d45967e7fe 100644 --- a/packages/server/src/server/agent/plugin-provider.test.ts +++ b/packages/server/src/server/agent/plugin-provider.test.ts @@ -6,6 +6,7 @@ import { createIdleRuntimeCleanup } from "./idle-runtime-cleanup/index.js"; import { relative } from "node:path"; import { execFileSync } from "node:child_process"; import { fileURLToPath } from "node:url"; +import { runAcpProvider, type AcpStreamMessage } from "@getpaseo/plugin/server/acp"; import type { ProviderConnection, ProviderLaunch, @@ -13,6 +14,7 @@ import type { ProviderInput, ProviderRegistration, } from "@getpaseo/plugin/server/provider"; +import { sendPreparedPromptToAgent } from "./agent-prompt.js"; import { setImmediate as nextTurn } from "node:timers/promises"; import { describe, expect, test } from "vitest"; import { createTestLogger } from "../../test-utils/test-logger.js"; @@ -2814,3 +2816,592 @@ test("resumes a goose session saved by the generic ACP provider", async () => { await plugins.shutdown(); } }); + +test("preserves a deferred ACP background job on steer and cancels it on explicit Stop through AgentManager", async () => { + const logger = createTestLogger(); + const home = await mkdtemp(join(tmpdir(), "paseo-acp-deferred-daemon-")); + const storage = new AgentStorage(join(home, "agents"), logger); + let cancelCount = 0; + let promptCount = 0; + let currentMode = "default"; + let notifyAgent: ((message: AcpStreamMessage) => void) | null = null; + let holdNextPrompt: ((release: () => void) => void) | null = null; + const modeConfig = () => [ + { + id: "mode", + name: "Mode", + category: "mode", + type: "select", + currentValue: currentMode, + options: [ + { value: "default", name: "Default" }, + { value: "plan", name: "Plan" }, + ], + }, + ]; + const registration = runAcpProvider({ + id: "deferred-acp-daemon", + label: "Deferred ACP Daemon", + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 1_000 }, + }, + connector() { + let controller!: ReadableStreamDefaultController; + const readable = new ReadableStream({ + start(ctrl) { + controller = ctrl; + }, + }); + const send = (message: AcpStreamMessage) => controller.enqueue(message); + notifyAgent = send; + const writable = new WritableStream({ + write(message) { + if (!("method" in message)) return; + if (message.method === "session/cancel") { + cancelCount += 1; + return; + } + if (!("id" in message)) return; + if (message.method === "initialize") { + send({ + jsonrpc: "2.0", + id: message.id, + result: { protocolVersion: 1, agentCapabilities: { loadSession: true } }, + }); + return; + } + if (message.method === "session/new") { + send({ + jsonrpc: "2.0", + id: message.id, + result: { sessionId: "acp-s1", configOptions: modeConfig() }, + }); + return; + } + if (message.method === "session/load") { + send({ jsonrpc: "2.0", id: message.id, result: { configOptions: modeConfig() } }); + return; + } + if (message.method === "session/set_config_option") { + const params = message.params as { value?: string } | undefined; + if (typeof params?.value === "string") currentMode = params.value; + send({ jsonrpc: "2.0", id: message.id, result: { configOptions: modeConfig() } }); + return; + } + if (message.method === "session/prompt") { + promptCount += 1; + if (promptCount === 1) { + send({ + jsonrpc: "2.0", + method: "session/update", + params: { + sessionId: "acp-s1", + update: { + sessionUpdate: "tool_call", + toolCallId: "bg-job-1", + name: "run_command", + title: "Background job", + status: "in_progress", + }, + }, + }); + } else if (promptCount === 2) { + send({ + jsonrpc: "2.0", + method: "session/update", + params: { + sessionId: "acp-s1", + update: { + sessionUpdate: "agent_message_chunk", + content: { type: "text", text: "Steered reply" }, + }, + }, + }); + } else { + send({ + jsonrpc: "2.0", + method: "session/update", + params: { + sessionId: "acp-s1", + update: { + sessionUpdate: "tool_call", + toolCallId: "bg-job-2", + name: "run_command", + title: "Cancelable job", + status: "in_progress", + }, + }, + }); + } + if (holdNextPrompt) { + const hook = holdNextPrompt; + holdNextPrompt = null; + hook(() => + send({ jsonrpc: "2.0", id: message.id, result: { stopReason: "cancelled" } }), + ); + return; + } + send({ jsonrpc: "2.0", id: message.id, result: { stopReason: "end_turn" } }); + return; + } + if (message.method === "session/close") { + send({ jsonrpc: "2.0", id: message.id, result: {} }); + } + }, + }); + return { readable, writable }; + }, + }); + const plugins = new PluginAgentClientRegistry(logger); + plugins.replace([registration]); + const manager = new AgentManager({ clients: plugins.clients(), registry: storage, logger }); + try { + const agent = await manager.createAgent({ provider: registration.id, cwd: home }, undefined, { + workspaceId: undefined, + }); + const first = await sendPreparedPromptToAgent({ + agentManager: manager, + agentStorage: storage, + agentId: agent.id, + prompt: "start background job", + logger, + }); + expect(first.disposition).toBe("turn_started"); + if (first.disposition === "turn_started") await first.started; + await new Promise((resolve) => setTimeout(resolve, 40)); + expect(manager.getAgent(agent.id)?.lifecycle).toBe("running"); + + // Follow-up steer through AgentManager preserves the background job without session/cancel. + const followUp = await sendPreparedPromptToAgent({ + agentManager: manager, + agentStorage: storage, + agentId: agent.id, + prompt: "still working?", + activeTurnBehavior: "steer", + logger, + }); + expect(followUp.disposition).toBe("steered"); + expect(cancelCount).toBe(0); + await new Promise((resolve) => setTimeout(resolve, 40)); + expect(manager.getAgent(agent.id)?.lifecycle).toBe("running"); + + // Completing the job + reply + usage_update settles the turn cleanly. + notifyAgent!({ + jsonrpc: "2.0", + method: "session/update", + params: { + sessionId: "acp-s1", + update: { sessionUpdate: "tool_call_update", toolCallId: "bg-job-1", status: "completed" }, + }, + }); + notifyAgent!({ + jsonrpc: "2.0", + method: "session/update", + params: { + sessionId: "acp-s1", + update: { + sessionUpdate: "agent_message_chunk", + content: { type: "text", text: "Background job finished." }, + }, + }, + }); + notifyAgent!({ + jsonrpc: "2.0", + method: "session/update", + params: { + sessionId: "acp-s1", + update: { sessionUpdate: "usage_update", used: 120, size: 1000 }, + }, + }); + await expect.poll(() => manager.getAgent(agent.id)?.lifecycle, { timeout: 3_000 }).toBe("idle"); + expect(cancelCount).toBe(0); + + // Start a second deferred job, send two steers while steer 1 waits on ACP, and press Stop. + let heldSteerResponse: (() => void) | null = null; + const second = await sendPreparedPromptToAgent({ + agentManager: manager, + agentStorage: storage, + agentId: agent.id, + prompt: "start cancelable job", + logger, + }); + if (second.disposition === "turn_started") await second.started; + await new Promise((resolve) => setTimeout(resolve, 40)); + expect(manager.getAgent(agent.id)?.lifecycle).toBe("running"); + + // Hold the next steer prompt so Stop races with a queued second steer. + holdNextPrompt = (release) => { + heldSteerResponse = release; + }; + const steerOne = await sendPreparedPromptToAgent({ + agentManager: manager, + agentStorage: storage, + agentId: agent.id, + prompt: "held steer 1", + activeTurnBehavior: "steer", + logger, + }); + expect(steerOne.disposition).toBe("steered"); + const steerTwo = await sendPreparedPromptToAgent({ + agentManager: manager, + agentStorage: storage, + agentId: agent.id, + prompt: "queued steer 2", + activeTurnBehavior: "steer", + logger, + }); + expect(steerTwo.disposition).toBe("steered"); + await expect.poll(() => heldSteerResponse).not.toBeNull(); + const promptsBeforeStop = promptCount; + + // Stop must send session/cancel immediately, retire the deferred session cleanly, + // and never dispatch the queued steer 2 to ACP. + await manager.cancelAgentRun(agent.id); + expect(cancelCount).toBe(1); + await expect.poll(() => manager.getAgent(agent.id)?.lifecycle, { timeout: 3_000 }).toBe("idle"); + expect(promptCount).toBe(promptsBeforeStop); + + // Changing mode immediately after stopping a deferred turn must transparently reopen the session. + await manager.setAgentMode(agent.id, "plan"); + expect(manager.getAgent(agent.id)?.currentModeId).toBe("plan"); + expect(currentMode).toBe("plan"); + } finally { + await Promise.all(manager.listAgents().map((item) => manager.closeAgent(item.id))); + await plugins.shutdown(); + await storage.flush(); + await rm(home, { recursive: true, force: true }); + } +}); + +test("reopens cleanly for mode changes and follow-up sends initiated while Stop is closing a slow ACP process", async () => { + const logger = createTestLogger(); + const home = await mkdtemp(join(tmpdir(), "paseo-acp-slow-stop-")); + const storage = new AgentStorage(join(home, "agents"), logger); + const script = join(home, "slow-stop-agent.cjs"); + const { writeFile } = await import("node:fs/promises"); + await writeFile( + script, + ` + const { createInterface } = require("node:readline"); + const send = (msg) => process.stdout.write(JSON.stringify({ jsonrpc: "2.0", ...msg }) + "\\n"); + let mode = "default"; + const configOptions = () => [{ + id: "mode", name: "Mode", category: "mode", type: "select", currentValue: mode, + options: [{ value: "default", name: "Default" }, { value: "plan", name: "Plan" }], + }]; + process.on("SIGTERM", () => { + setTimeout(() => process.exit(0), 250); + }); + createInterface({ input: process.stdin }).on("line", (line) => { + const msg = JSON.parse(line); + if (msg.method === "initialize") { + send({ id: msg.id, result: { protocolVersion: 1, agentCapabilities: { loadSession: true } } }); + } else if (msg.method === "session/new") { + send({ id: msg.id, result: { sessionId: "slow-s1", configOptions: configOptions() } }); + } else if (msg.method === "session/load") { + send({ id: msg.id, result: { configOptions: configOptions() } }); + } else if (msg.method === "session/set_config_option") { + if (msg.params && typeof msg.params.value === "string") mode = msg.params.value; + send({ id: msg.id, result: { configOptions: configOptions() } }); + } else if (msg.method === "session/prompt") { + const text = msg.params?.prompt?.[0]?.text ?? ""; + if (text.includes("start bg")) { + send({ method: "session/update", params: { sessionId: "slow-s1", update: { + sessionUpdate: "tool_call", toolCallId: "slow-bg-1", name: "run_command", + title: "Slow bg job", status: "in_progress", + } } }); + } else { + send({ method: "session/update", params: { sessionId: "slow-s1", update: { + sessionUpdate: "agent_message_chunk", content: { type: "text", text: "After stop reply" }, + } } }); + } + send({ id: msg.id, result: { stopReason: "end_turn" } }); + } else if (msg.method === "session/close") { + send({ id: msg.id, result: {} }); + } + }); + `, + ); + const registration = runAcpProvider({ + id: "slow-stop-acp", + label: "Slow Stop ACP", + command: [process.execPath, script], + acpOptions: { + deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 1_000 }, + }, + }); + const plugins = new PluginAgentClientRegistry(logger); + plugins.replace([registration]); + const manager = new AgentManager({ clients: plugins.clients(), registry: storage, logger }); + try { + const agent = await manager.createAgent({ provider: registration.id, cwd: home }, undefined, { + workspaceId: undefined, + }); + const first = await sendPreparedPromptToAgent({ + agentManager: manager, + agentStorage: storage, + agentId: agent.id, + prompt: "start bg", + logger, + }); + if (first.disposition === "turn_started") await first.started; + await new Promise((resolve) => setTimeout(resolve, 40)); + expect(manager.getAgent(agent.id)?.lifecycle).toBe("running"); + + // Start Stop (takes 250ms to terminate the child on SIGTERM) and trigger a mode change mid-shutdown. + const stopPromise = manager.cancelAgentRun(agent.id); + await new Promise((resolve) => setTimeout(resolve, 50)); + const modePromise = manager.setAgentMode(agent.id, "plan"); + await Promise.all([stopPromise, modePromise]); + expect(manager.getAgent(agent.id)?.currentModeId).toBe("plan"); + expect(manager.getAgent(agent.id)?.lifecycle).toBe("idle"); + + // A follow-up prompt immediately after Stop + mode change succeeds cleanly. + const next = await sendPreparedPromptToAgent({ + agentManager: manager, + agentStorage: storage, + agentId: agent.id, + prompt: "fresh prompt", + logger, + }); + expect(next.disposition).toBe("turn_started"); + if (next.disposition === "turn_started") await next.started; + await expect.poll(() => manager.getAgent(agent.id)?.lifecycle, { timeout: 3_000 }).toBe("idle"); + } finally { + await Promise.all(manager.listAgents().map((item) => manager.closeAgent(item.id))); + await plugins.shutdown(); + await storage.flush(); + await rm(home, { recursive: true, force: true }); + } +}); + +test("does not block mode changes after a plugin refuses Stop by ignoring session.interrupt", async () => { + const logger = createTestLogger(); + let currentMode = "code"; + const harness = createProviderHarness({ + async handleInput(input, emit) { + if (input.type === "session.open") { + emit({ + type: "session.opened", + requestId: input.requestId, + sessionId: input.sessionId, + capabilities: ["prompt.message", "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") { + emit({ + type: "session.prompt_result", + sessionId: input.sessionId, + clientMessageId: input.prompt.clientMessageId, + result: { type: "turn", turnId: "hung-turn" }, + }); + emit({ + type: "session.turn", + sessionId: input.sessionId, + turnId: "hung-turn", + state: "started", + }); + return true; + } + if (input.type === "session.interrupt") { + // Intentionally never acknowledge 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"); + + const cancelResult = await manager.cancelAgentRun(agent.id); + expect(cancelResult.status).toBe("refused"); + + // Settings change must not hang behind the unacknowledged session.interrupt. + await manager.setAgentMode(agent.id, "plan"); + expect(manager.getAgent(agent.id)?.currentModeId).toBe("plan"); + } finally { + await Promise.all(manager.listAgents().map((item) => manager.closeAgent(item.id))); + 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(); + } +}); diff --git a/packages/server/src/server/agent/plugin-provider.ts b/packages/server/src/server/agent/plugin-provider.ts index f14385bf9c..bb327e0299 100644 --- a/packages/server/src/server/agent/plugin-provider.ts +++ b/packages/server/src/server/agent/plugin-provider.ts @@ -739,6 +739,7 @@ class ProviderRuntimeSession { } async configure(changes: ProviderConfigChanges): Promise { + if (this.terminal) throw new StaleProviderSessionError(this.id); const input: Extract = { type: "session.configure", requestId: randomUUID(), diff --git a/plugins/antigravity-provider/server/provider.test.ts b/plugins/antigravity-provider/server/provider.test.ts index ca635794d8..385e2ec882 100644 --- a/plugins/antigravity-provider/server/provider.test.ts +++ b/plugins/antigravity-provider/server/provider.test.ts @@ -213,3 +213,156 @@ describe("installation", () => { ).resolves.toEqual({ status: "not_installed" }); }); }); + +it("keeps a turn open for backgrounded run_command calls but not IsDaemon commands", async () => { + const { directory, launch } = await launchAgent(` + const { createInterface } = require("node:readline"); + const send = (message) => process.stdout.write(JSON.stringify({ jsonrpc: "2.0", ...message }) + "\\n"); + let turn = 0; + createInterface({ input: process.stdin }).on("line", (line) => { + const { id, method, params } = JSON.parse(line); + switch (method) { + case "initialize": + send({ id, result: { protocolVersion: 1, agentCapabilities: {} } }); + break; + case "session/new": + send({ id, result: { sessionId: "agy-session", configOptions: [ + { id: "mode", name: "Mode", category: "mode", type: "select", currentValue: "default", + options: [{ value: "default", name: "Default" }] }, + ] } }); + break; + case "session/prompt": + turn += 1; + if (turn === 1) { + send({ method: "session/update", params: { sessionId: params.sessionId, update: { + sessionUpdate: "tool_call", toolCallId: "daemon-1", name: "run_command", + title: "Dev server", status: "in_progress", rawInput: { CommandLine: "npm run dev", IsDaemon: true }, + } } }); + send({ id, result: { stopReason: "end_turn" } }); + } else { + send({ method: "session/update", params: { sessionId: params.sessionId, update: { + sessionUpdate: "tool_call", toolCallId: "bg-1", name: "run_command", + title: "Background build", status: "in_progress", rawInput: { CommandLine: "sleep 1" }, + } } }); + send({ id, result: { stopReason: "end_turn" } }); + setTimeout(() => { + send({ method: "session/update", params: { sessionId: params.sessionId, update: { + sessionUpdate: "tool_call_update", toolCallId: "bg-1", status: "completed", + } } }); + send({ method: "session/update", params: { sessionId: params.sessionId, update: { + sessionUpdate: "agent_message_chunk", content: { type: "text", text: "Build finished." }, + } } }); + send({ method: "session/update", params: { sessionId: params.sessionId, update: { + sessionUpdate: "usage_update", used: 50, size: 1000, + } } }); + }, 80); + } + break; + case "session/close": + send({ id, result: {} }); + break; + } + }); + `); + const provider = createAntigravityProvider(); + const connection = await provider.connect({ + launch, + versions: [1], + capabilities: ["prompt.message"], + }); + const events: ProviderEvent[] = []; + connection.onEvent((event) => events.push(event)); + try { + await connection.send({ + type: "session.open", + requestId: "open-1", + sessionId: "agy-test", + history: "skip", + config: { + cwd: directory, + env: {}, + mcpServers: {}, + settings: {}, + persist: false, + }, + }); + await expect + .poll(() => events.find((event) => event.type === "session.ready"), { timeout: 3_000 }) + .toBeDefined(); + + // Turn 1: IsDaemon: true completes immediately on end_turn. + await connection.send({ + type: "session.prompt", + sessionId: "agy-test", + prompt: { + clientMessageId: "daemon-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "start dev server" }] }, + }, + }); + await expect + .poll( + () => + events.find( + (event) => + event.type === "session.turn" && + event.turnId === "acp:daemon-turn" && + event.state === "completed", + ), + { timeout: 3_000 }, + ) + .toBeDefined(); + + // Turn 2: non-daemon background command keeps turn open until completion + reply + usage_update. + await connection.send({ + type: "session.prompt", + sessionId: "agy-test", + prompt: { + clientMessageId: "bg-turn", + delivery: "auto", + input: { type: "message", content: [{ type: "text", text: "run build" }] }, + }, + }); + await expect + .poll( + () => + events.find( + (event) => + event.type === "timeline.item" && + event.item.type === "tool_call" && + event.item.id === "bg-1" && + event.item.status === "running", + ), + { timeout: 3_000 }, + ) + .toBeDefined(); + expect( + events.some( + (event) => + event.type === "session.turn" && + event.turnId === "acp:bg-turn" && + event.state === "completed", + ), + ).toBe(false); + await expect + .poll( + () => + events.find( + (event) => + event.type === "session.turn" && + event.turnId === "acp:bg-turn" && + event.state === "completed", + ), + { timeout: 3_000 }, + ) + .toBeDefined(); + expect(events).toContainEqual( + expect.objectContaining({ + type: "timeline.item", + item: expect.objectContaining({ type: "assistant_message", text: "Build finished." }), + }), + ); + } finally { + await connection.close(); + } +}); diff --git a/plugins/antigravity-provider/server/provider.ts b/plugins/antigravity-provider/server/provider.ts index 417a36d886..acadd0b472 100644 --- a/plugins/antigravity-provider/server/provider.ts +++ b/plugins/antigravity-provider/server/provider.ts @@ -95,6 +95,16 @@ export function createAntigravityProvider(): ProviderRegistration { acpOptions: { waitForInitialCommands: true, loadReplayQuietPeriodMs: 200, + // COMPAT(antigravityAcpV1DeferredTurn): added in v0.18.0, remove once Antigravity CLI supports ACP v2 state_update. + deferTurnOnRunningTools: { + keepsTurnOpen(toolCall) { + const input = toolCall.input; + if (typeof input === "object" && input !== null && !Array.isArray(input)) { + return input.IsDaemon !== true; + } + return true; + }, + }, autoAcceptMode: { mode: { id: "full-access",