From e16c23e0477bd89d59732b03617ee0b5bfc60be6 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Fri, 7 Aug 2026 17:49:47 +0800 Subject: [PATCH 01/25] feat(serve): add pollable turn-status endpoints for daemon sessions Add GET /session/:id/turns/current and GET /session/:id/turns/:promptId so external callers can poll a turn's lifecycle state (queued / running / completed / cancelled / error) and result instead of holding the SSE stream for the whole turn lifetime. - Live state comes from the bridge's pending prompt queue; settled outcomes from persisted turn_result transcript records, so results survive daemon restarts and the daemon keeps no per-turn memory - Each prompt captures its own recording and settles exactly that one, so overlapping turns (DAEMON-003 deadline overlap) can never misattribute one turn's outcome to another promptId - Enforces the same client authorization as POST /session/:id/prompt Refs #8680 --- docs/design/daemon-turn-status-endpoint.md | 138 +++++++ packages/acp-bridge/src/bridge.test.ts | 309 +++++++++++++++ packages/acp-bridge/src/bridge.ts | 112 ++++++ packages/acp-bridge/src/bridgeTypes.ts | 39 ++ packages/acp-bridge/src/status.ts | 9 + .../cli/src/acp-integration/acpAgent.test.ts | 250 ++++++++++++ packages/cli/src/acp-integration/acpAgent.ts | 109 ++++++ .../acp-integration/session/Session.test.ts | 367 ++++++++++++++++++ .../src/acp-integration/session/Session.ts | 195 ++++++++++ packages/cli/src/serve/acp-session-bridge.ts | 1 + packages/cli/src/serve/routes/session.ts | 74 ++++ packages/cli/src/serve/server.test.ts | 121 ++++++ .../serve/server/telemetry-catalog.test.ts | 2 +- packages/cli/src/serve/server/telemetry.ts | 12 + .../src/services/chatRecordingService.test.ts | 38 ++ .../core/src/services/chatRecordingService.ts | 53 ++- packages/core/src/utils/transcript-records.ts | 1 + 17 files changed, 1827 insertions(+), 3 deletions(-) create mode 100644 docs/design/daemon-turn-status-endpoint.md diff --git a/docs/design/daemon-turn-status-endpoint.md b/docs/design/daemon-turn-status-endpoint.md new file mode 100644 index 00000000000..2dded47068d --- /dev/null +++ b/docs/design/daemon-turn-status-endpoint.md @@ -0,0 +1,138 @@ +# Daemon turn-status endpoint + +## Goal + +Provide pollable HTTP endpoints that report one turn's state for a session: +queued, running, or settled (completed with stop reason, cancelled, error), +including the agent reply text. Today the only way to observe a turn's +outcome is the SSE stream (`turn_complete` / `turn_error` keyed by +`promptId`); a client that cannot hold an SSE connection has no way to ask +"what happened to my prompt". + +## Routes + +Both routes are live-session-owner scoped and read-only, in the same class as +`GET /session/:id/pending-prompts`: they resolve the owning runtime via +`resolveLiveSessionRuntime`, authorize the caller via the +`X-Qwen-Client-Id` header (`parseClientIdHeader`), and never fall back to +another runtime. + +- `GET /session/:id/turns/:promptId` — status of that exact prompt. + - `200` with the turn status object. + - `404 { code: 'prompt_not_found' }` when neither the live pending queue + nor the persisted transcript knows that promptId. +- `GET /session/:id/turns/current` — status of the session's current turn: + the running prompt, else the queued FIFO head, else the most recent + persisted outcome, else `{ state: 'idle' }`. + +Shared errors: `404` unknown session (`SessionNotFoundError`), `400` +`invalid_client_id` for a client id bound to another session. + +## Response shape + +```json +{ + "sessionId": "…", + "state": "idle | queued | running | completed | cancelled | error", + "promptId": "…", + "promptText": "…", + "promptTextTruncated": false, + "queuedAt": 0, + "startedAt": 0, + "endedAt": 0, + "stopReason": "end_turn", + "error": { "message": "…", "code": "…" }, + "resultText": "…", + "resultTruncated": false, + "originatorClientId": "…" +} +``` + +Field presence: optional fields are omitted rather than defaulted. In +particular `promptTextTruncated` / `resultTruncated` are only present when +`true` — consumers must treat an absent flag as `false`. + +- `queued` / `running` mirror the bridge's live `pendingPromptList` + (`queuedAt` at admission, `startedAt` at FIFO dispatch). +- `completed` / `cancelled` / `error` mirror the persisted `turn_result` + record (`startedAt` / `endedAt`, `stopReason` for completions, `error` + for failures). A `stopReason` of `cancelled` is reported as + `state: 'cancelled'`. +- `promptText` mirrors the pending-prompt extraction: first non-empty text + block, `[image]` for image-only prompts. `resultText` accumulates + `agent_message_chunk` text streamed during the turn (tool output and + thought chunks excluded by design). Both are capped at + `TURN_RESULT_TEXT_MAX_CHARS` (32 KiB) with the paired `*Truncated` flag. + The cap applies to both projections: the live `queued` / `running` + status caps `promptText` the same way the settled record does, so the + same promptId reports a consistent shape before and after settlement. + +## Persistence: reuse the transcript, no daemon memory + +Settled outcomes must survive daemon restarts and must not require the +daemon to retain per-turn state. The agent therefore appends one +`turn_result` system record to the EXISTING session transcript JSONL +(`/chats/.jsonl`) through the existing +`ChatRecordingService` append path — no new files, no new write machinery: + +- `ChatRecordingService.recordTurnResult(payload)` appends a + `type: 'system'`, `subtype: 'turn_result'` record, best-effort like + `recordFileHistorySnapshot`: a recording failure must never break turn + settlement. +- `Session` accumulates the turn in flight (`#turnRecording`): the record + is created at admission after `assertCanStartTurn()` for prompts carrying + an invocation context (daemon-admitted prompts only — internal + cron/notification turns are not pollable), accumulates streamed agent + text in `sendUpdate`, and settles on every exit path (early + admission-cancel, pendingSend-cancel, normal completion, thrown error). + Each `prompt()` call captures its own record reference and settles that + exact reference; the shared slot is only published once the predecessor + turn has settled and the turn's model loop starts. This keeps DAEMON-003 + deadline overlaps (the bridge releases the FIFO while the agent is still + executing the old turn) from misattributing one turn's outcome to the + other turn's promptId. +- ACP per-session configs keep chat recording enabled by default, so every + daemon session writes its transcript; the top-level ACP process disabling + `chatRecording` does not affect sessions. + +Reads go through the `qwen/control/session/turn_status` ext-method on the +owning ACP child: it flushes the recording service (so a just-settled turn +is visible — the flush is best-effort and a recorder in a write-failure +state still falls through to the scan), then scans the transcript backward +from the tail with +`SessionTranscriptReader` for `turn_result` records — exact `promptId` +match, or the most recent record when no promptId is given. The scan is +bounded (10 pages x 500 records) so a pathological lookup cannot read a +huge transcript end to end. + +## Bridge resolution order + +`AcpSessionBridge.getSessionTurnStatus(sessionId, context?, promptId?)`: + +1. Authorize the caller against the session (mirrors `/prompt`). +2. Live state wins: a prompt on `pendingPromptList` (not removed) has not + settled, so no record can exist for it. With `promptId`, exact match; + without, the running entry, then the queued FIFO head. +3. Otherwise the ext-method above. A persisted record maps to the settled + states; `null` maps to `undefined` (with promptId → 404) or + `{ state: 'idle' }` (current). + +`PendingPromptEntry.startedAt` is stamped at FIFO dispatch (at creation +for a prompt admitted straight to running). + +## Failure semantics + +- Turn settlement never depends on recording: `recordTurnResult` is + best-effort, and the Session settle path swallows recording errors. +- A transcript without `turn_result` records (session never settled a + daemon turn, or recording disabled/failed) simply yields `idle` / + `prompt_not_found`. +- A prompt removed from the pending list before it settles — cancelled + while still `queued`, or removed while `running` — never produces a + `turn_result` record: the SSE channel publishes the terminal + (`cancelled` / `removed`), but polling reports `404 prompt_not_found` + for that promptId from the removal on. This is intentional — removals + are not pollable — and consumers relying on those outcomes should use + the SSE channel. +- The ext-method throws for non-live sessions; the bridge routes it only to + the owning child. diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 07a7f792c46..7c7ba7f18ed 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -68,6 +68,7 @@ import { ShellExecutionService, stableSessionArtifactId, ToolNames, + TURN_RESULT_TEXT_MAX_CHARS, } from '@qwen-code/qwen-code-core'; import { FakeAgent, @@ -7071,6 +7072,314 @@ describe('createAcpSessionBridge', () => { }); }); + describe('getSessionTurnStatus', () => { + it('reports the running turn from the live pending list', async () => { + let resolveTurn: (() => void) | undefined; + const turnGate = new Promise((r) => { + resolveTurn = r; + }); + const handle = makeChannel({ + promptImpl: async () => { + await turnGate; + return { stopReason: 'end_turn' } as PromptResponse; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const promptPromise = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'live turn' }], + }, + undefined, + { promptId: 'prompt-live' }, + ); + + await vi.waitFor(() => { + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(1); + }); + + const current = await bridge.getSessionTurnStatus(session.sessionId); + expect(current).toMatchObject({ + sessionId: session.sessionId, + state: 'running', + promptId: 'prompt-live', + promptText: 'live turn', + }); + expect(current?.queuedAt).toBeTypeOf('number'); + expect(current?.startedAt).toBeTypeOf('number'); + + const byId = await bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-live', + ); + expect(byId).toEqual(current); + + resolveTurn!(); + await promptPromise; + await bridge.shutdown(); + }); + + it('caps live promptText at TURN_RESULT_TEXT_MAX_CHARS', async () => { + let resolveTurn: (() => void) | undefined; + const turnGate = new Promise((r) => { + resolveTurn = r; + }); + const handle = makeChannel({ + promptImpl: async () => { + await turnGate; + return { stopReason: 'end_turn' } as PromptResponse; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const longText = 'x'.repeat(TURN_RESULT_TEXT_MAX_CHARS + 100); + const promptPromise = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: longText }], + }, + undefined, + { promptId: 'prompt-long' }, + ); + + await vi.waitFor(() => { + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(1); + }); + + const status = await bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-long', + ); + expect(status?.promptText).toHaveLength(TURN_RESULT_TEXT_MAX_CHARS); + expect(status?.promptTextTruncated).toBe(true); + + resolveTurn!(); + await promptPromise; + await bridge.shutdown(); + }); + + it('rejects a foreign clientId like /prompt does', async () => { + const bridge = makeBridge({ + channelFactory: async () => makeChannel().channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + await expect( + bridge.getSessionTurnStatus(session.sessionId, { + clientId: 'forged-client', + }), + ).rejects.toBeInstanceOf(InvalidClientIdError); + await bridge.shutdown(); + }); + + it('reports queued prompts behind a running turn', async () => { + let resolveFirst: (() => void) | undefined; + const firstGate = new Promise((r) => { + resolveFirst = r; + }); + const handle = makeChannel({ + promptImpl: async (req: PromptRequest) => { + if ((req.prompt[0] as { text?: string }).text === 'blocking') { + await firstGate; + } + return { stopReason: 'end_turn' } as PromptResponse; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const p1 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'blocking' }], + }, + undefined, + { promptId: 'prompt-first' }, + ); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'waiting' }], + }, + undefined, + { promptId: 'prompt-second' }, + ); + + await vi.waitFor(() => { + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(2); + }); + + // Current = the running turn, not the queued head. + const current = await bridge.getSessionTurnStatus(session.sessionId); + expect(current).toMatchObject({ + state: 'running', + promptId: 'prompt-first', + }); + + const queued = await bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-second', + ); + expect(queued).toMatchObject({ + state: 'queued', + promptId: 'prompt-second', + promptText: 'waiting', + }); + expect(queued?.startedAt).toBeUndefined(); + + resolveFirst!(); + await p1; + await p2; + await bridge.shutdown(); + }); + + it('falls back to persisted turn_result records once settled', async () => { + const turnResult = { + promptId: 'prompt-done', + state: 'completed', + stopReason: 'end_turn', + startedAt: 1000, + endedAt: 2000, + promptText: 'settled prompt', + resultText: 'settled answer', + originatorClientId: 'client-9', + }; + const handle = makeChannel({ + promptImpl: () => ({ stopReason: 'end_turn' }), + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { v: 1, sessionId: 'ignored', turnResult }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + await bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'settled prompt' }], + }, + undefined, + { promptId: 'prompt-done' }, + ); + + const byId = await bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-done', + ); + expect(byId).toMatchObject({ + sessionId: session.sessionId, + state: 'completed', + promptId: 'prompt-done', + stopReason: 'end_turn', + resultText: 'settled answer', + originatorClientId: 'client-9', + }); + + const current = await bridge.getSessionTurnStatus(session.sessionId); + expect(current).toEqual(byId); + await bridge.shutdown(); + }); + + it('resolves undefined for unknown promptId and idle for empty current', async () => { + const handle = makeChannel({ + promptImpl: () => ({ stopReason: 'end_turn' }), + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { v: 1, sessionId: 'ignored', turnResult: null }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'missing'), + ).resolves.toBeUndefined(); + + await expect( + bridge.getSessionTurnStatus(session.sessionId), + ).resolves.toEqual({ sessionId: session.sessionId, state: 'idle' }); + await bridge.shutdown(); + }); + + it('prefers live queue state over persisted records', async () => { + let resolveTurn: (() => void) | undefined; + const turnGate = new Promise((r) => { + resolveTurn = r; + }); + const extCalls: string[] = []; + const handle = makeChannel({ + promptImpl: async () => { + await turnGate; + return { stopReason: 'end_turn' } as PromptResponse; + }, + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + extCalls.push(method); + return { v: 1, sessionId: 'ignored', turnResult: null }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const promptPromise = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'live wins' }], + }, + undefined, + { promptId: 'prompt-live' }, + ); + await vi.waitFor(() => { + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(1); + }); + + const status = await bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-live', + ); + expect(status?.state).toBe('running'); + expect(extCalls).toHaveLength(0); + + resolveTurn!(); + await promptPromise; + await bridge.shutdown(); + }); + + it('throws SessionNotFoundError for unknown sessions', async () => { + const bridge = makeBridge(); + await expect(bridge.getSessionTurnStatus('unknown')).rejects.toThrow( + SessionNotFoundError, + ); + }); + }); + describe('prompt terminal exactly-once (DAEMON-002/003/004/005)', () => { /** All formal turn terminals published for one promptId. */ const terminalsFor = (events: BridgeEvent[], promptId: string) => diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index b09b86a2c3b..fe473e06aaf 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -21,6 +21,7 @@ import type { import type { ApprovalMode, RebuiltSessionArtifactSnapshot, + TurnResultRecordPayload, } from '@qwen-code/qwen-code-core'; import { DAEMON_TRACEPARENT_META_KEY, @@ -29,6 +30,7 @@ import { PRIVATE_ACP_CAPABILITY_ENV, PRIVATE_PARENT_CAPABILITY_META_KEY, SESSION_ARTIFACT_PERSISTENCE_VERSION, + TURN_RESULT_TEXT_MAX_CHARS, TrustGateError, normalizeSnapshotPayload, ShellExecutionService, @@ -112,6 +114,7 @@ import type { BridgeRestoredSession, BridgeSessionGoal, BridgeSessionSummary, + BridgeTurnStatus, BridgePendingInteraction, BridgeClientRequestContext, CloseSessionOpts, @@ -1270,6 +1273,73 @@ function extractPromptText( return hasImage ? '[image]' : ''; } +/** + * Project a live pending-prompt entry into the pollable turn status shape + * (`queued` while waiting on the FIFO, `running` once dispatched). + */ +function liveTurnStatus( + sessionId: string, + pending: PendingPromptEntry, +): BridgeTurnStatus { + // Mirror the settled-record contract: `promptText` is capped at + // TURN_RESULT_TEXT_MAX_CHARS with the paired truncation flag, so the + // same promptId reports a consistent shape before and after settle. + const promptTextTruncated = pending.text.length > TURN_RESULT_TEXT_MAX_CHARS; + return { + sessionId, + state: pending.state === 'running' ? 'running' : 'queued', + promptId: pending.promptId, + promptText: promptTextTruncated + ? pending.text.slice(0, TURN_RESULT_TEXT_MAX_CHARS) + : pending.text, + ...(promptTextTruncated ? { promptTextTruncated: true } : {}), + queuedAt: pending.queuedAt, + ...(pending.startedAt !== undefined + ? { startedAt: pending.startedAt } + : {}), + ...(pending.originatorClientId !== undefined + ? { originatorClientId: pending.originatorClientId } + : {}), + }; +} + +/** + * Project a persisted `turn_result` record into the pollable turn status + * shape. The record's `state` is already settled (`completed` / + * `cancelled` / `error`). + */ +function settledTurnStatus( + sessionId: string, + record: TurnResultRecordPayload, +): BridgeTurnStatus { + return { + sessionId, + state: record.state, + promptId: record.promptId, + ...(record.stopReason !== undefined + ? { stopReason: record.stopReason } + : {}), + ...(record.error !== undefined ? { error: record.error } : {}), + startedAt: record.startedAt, + endedAt: record.endedAt, + ...(record.promptText !== undefined + ? { promptText: record.promptText } + : {}), + ...(record.promptTextTruncated !== undefined + ? { promptTextTruncated: record.promptTextTruncated } + : {}), + ...(record.resultText !== undefined + ? { resultText: record.resultText } + : {}), + ...(record.resultTruncated !== undefined + ? { resultTruncated: record.resultTruncated } + : {}), + ...(record.originatorClientId !== undefined + ? { originatorClientId: record.originatorClientId } + : {}), + }; +} + const DEFAULT_INIT_TIMEOUT_MS = 10_000; const PERSIST_TIMEOUT_MS = 5_000; // Bounded retries for the sub-session `parentSessionId` transcript write on the @@ -5233,6 +5303,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { text: extractPromptText(req.prompt), abortController: pendingAbort, state: isQueued ? 'queued' : 'running', + ...(!isQueued ? { startedAt: Date.now() } : {}), }; entry.pendingPromptList.push(pendingEntry); // DAEMON-003: absolute wallclock deadline. Armed at admission (the @@ -5357,6 +5428,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { if (pendingEntry.state === 'queued') { entry.todoStopGuardAwaitingQueuedPrompt = false; pendingEntry.state = 'running'; + pendingEntry.startedAt = Date.now(); entry.events.publish({ type: 'pending_prompt_started', promptId: pendingEntry.promptId, @@ -7307,6 +7379,46 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { })); }, + async getSessionTurnStatus(sessionId, context, promptId) { + const entry = byId.get(sessionId); + if (!entry) throw new SessionNotFoundError(sessionId); + // Authorize the caller against this session — mirrors /prompt and + // getPendingPrompts. + resolveTrustedClientId(entry, context?.clientId); + + // Live state wins: a prompt on the pending list has not settled yet, + // so no `turn_result` record can exist for it. + const live = entry.pendingPromptList.filter((p) => !p.removed); + if (promptId !== undefined) { + const match = live.find((p) => p.promptId === promptId); + if (match) return liveTurnStatus(sessionId, match); + } else { + const running = live.find((p) => p.state === 'running'); + if (running) return liveTurnStatus(sessionId, running); + const queuedHead = live.find((p) => p.state === 'queued'); + if (queuedHead) return liveTurnStatus(sessionId, queuedHead); + } + + // Settled state is durable: read the agent's persisted `turn_result` + // records. This survives daemon restarts (the pending list does not). + const result = await requestSessionStatus<{ + v: number; + sessionId: string; + turnResult: TurnResultRecordPayload | null; + }>(sessionId, SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + ...(promptId !== undefined ? { promptId } : {}), + }); + if (result.turnResult) { + return settledTurnStatus(sessionId, result.turnResult); + } + if (promptId !== undefined) { + // Neither the live queue nor the transcript knows this prompt. + return undefined; + } + // No live prompt and no settled outcome on record: idle. + return { sessionId, state: 'idle' as const }; + }, + removePendingPrompt(sessionId, promptId, context) { const entry = byId.get(sessionId); if (!entry) throw new SessionNotFoundError(sessionId); diff --git a/packages/acp-bridge/src/bridgeTypes.ts b/packages/acp-bridge/src/bridgeTypes.ts index 6eeee224f92..950aaa8aaba 100644 --- a/packages/acp-bridge/src/bridgeTypes.ts +++ b/packages/acp-bridge/src/bridgeTypes.ts @@ -607,6 +607,8 @@ export interface MidTurnQueueEntry { export interface PendingPromptEntry { promptId: string; queuedAt: number; + /** Wallclock ms the entry was dispatched on the FIFO (running start). */ + startedAt?: number; originatorClientId?: string; text: string; abortController: AbortController; @@ -647,6 +649,28 @@ export interface PendingPromptSummary { originatorClientId?: string; } +/** + * Pollable snapshot of one admitted prompt's turn, returned by + * `getSessionTurnStatus`. `queued` / `running` mirror the live + * `pendingPromptList`; settled states mirror the `turn_result` record + * persisted in the session transcript by the agent. + */ +export interface BridgeTurnStatus { + sessionId: string; + state: 'idle' | 'queued' | 'running' | 'completed' | 'cancelled' | 'error'; + promptId?: string; + promptText?: string; + promptTextTruncated?: boolean; + queuedAt?: number; + startedAt?: number; + endedAt?: number; + stopReason?: string; + error?: { message: string; code?: string }; + resultText?: string; + resultTruncated?: boolean; + originatorClientId?: string; +} + export interface BridgeDaemonStatusLimits { maxSessions: number | null; maxPendingPromptsPerSession: number | null; @@ -851,6 +875,21 @@ export interface AcpSessionBridge { context?: BridgeClientRequestContext, ): readonly PendingPromptSummary[]; + /** + * Return the pollable status of a turn. With `promptId`, resolves that + * exact prompt: live `pendingPromptList` first (queued / running), then + * the agent's persisted `turn_result` records (completed / cancelled / + * error); resolves `undefined` when neither knows it. Without + * `promptId`, returns the current turn: the running prompt, the queued + * FIFO head, the most recent persisted outcome, or `state: 'idle'`. + * Throws `SessionNotFoundError` for unknown ids. + */ + getSessionTurnStatus( + sessionId: string, + context?: BridgeClientRequestContext, + promptId?: string, + ): Promise; + /** * Remove a specific prompt from the pending queue. For `queued` prompts, * aborts them so the FIFO skips dispatch. For `running` prompts, aborts diff --git a/packages/acp-bridge/src/status.ts b/packages/acp-bridge/src/status.ts index edb3dfbd73a..bf080f28261 100644 --- a/packages/acp-bridge/src/status.ts +++ b/packages/acp-bridge/src/status.ts @@ -166,6 +166,15 @@ export const SERVE_CONTROL_EXT_METHODS = { * `{ sessionId }`; result: `{ active: ActiveGoalView | null }`. */ sessionGoalGet: 'qwen/control/session/goal/get', + /** + * Read a settled turn's persisted `turn_result` record from the session + * transcript. Live queued/running state comes from the bridge's pending + * prompt list instead; this is the durable source for completed / + * cancelled / error outcomes. Params: `{ sessionId, promptId? }`; result: + * `{ v: 1, sessionId, turnResult: TurnResultRecordPayload | null }` where + * `null` means no matching settled turn was found. + */ + sessionTurnStatus: 'qwen/control/session/turn_status', workspaceMcpRuntimeAdd: 'qwen/control/workspace/mcp/runtime-add', workspaceMcpRuntimeRemove: 'qwen/control/workspace/mcp/runtime-remove', workspaceReload: 'qwen/control/workspace/reload', diff --git a/packages/cli/src/acp-integration/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts index bb8fa06497b..427e5e32726 100644 --- a/packages/cli/src/acp-integration/acpAgent.test.ts +++ b/packages/cli/src/acp-integration/acpAgent.test.ts @@ -7048,6 +7048,256 @@ describe('QwenAgent MCP SSE/HTTP support', () => { await agentPromise; }); + it('reads a settled turn_result record by promptId', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const turnResult = { + promptId: 'prompt-1', + state: 'completed', + stopReason: 'end_turn', + startedAt: 1000, + endedAt: 2000, + promptText: 'hello', + resultText: 'world', + }; + const readPage = vi.fn().mockResolvedValue({ + sessionId, + records: [ + { type: 'user', subtype: undefined, message: {} }, + { type: 'system', subtype: 'turn_result', systemPayload: turnResult }, + ], + hasMore: false, + gaps: [], + startTime: 'start', + lastUpdated: 'end', + }); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: 'prompt-1', + }), + ).resolves.toEqual({ v: 1, sessionId, turnResult }); + + mockConnectionState.resolve(); + await agentPromise; + }); + + it('still scans the transcript when the pre-read flush fails', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + const innerConfig = await setupSessionMocks(sessionId); + const flushSpy = vi + .fn() + .mockRejectedValue(new Error('ENOSPC: no space left on device')); + innerConfig.getChatRecordingService = vi.fn().mockReturnValue({ + flush: flushSpy, + }); + const turnResult = { + promptId: 'prompt-1', + state: 'completed', + stopReason: 'end_turn', + startedAt: 1000, + endedAt: 2000, + promptText: 'hello', + resultText: 'world', + }; + const readPage = vi.fn().mockResolvedValue({ + sessionId, + records: [ + { type: 'system', subtype: 'turn_result', systemPayload: turnResult }, + ], + hasMore: false, + gaps: [], + startTime: 'start', + lastUpdated: 'end', + }); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: 'prompt-1', + }), + ).resolves.toEqual({ v: 1, sessionId, turnResult }); + expect(flushSpy).toHaveBeenCalled(); + + mockConnectionState.resolve(); + await agentPromise; + }); + + it('returns the most recent turn_result when no promptId is given', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const older = { + promptId: 'prompt-old', + state: 'completed', + startedAt: 1000, + endedAt: 2000, + }; + const newer = { + promptId: 'prompt-new', + state: 'cancelled', + startedAt: 3000, + endedAt: 3500, + }; + const readPage = vi.fn().mockResolvedValue({ + sessionId, + records: [ + { type: 'system', subtype: 'turn_result', systemPayload: older }, + { type: 'assistant', subtype: undefined, message: {} }, + { type: 'system', subtype: 'turn_result', systemPayload: newer }, + ], + hasMore: false, + gaps: [], + startTime: 'start', + lastUpdated: 'end', + }); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + }), + ).resolves.toEqual({ v: 1, sessionId, turnResult: newer }); + + mockConnectionState.resolve(); + await agentPromise; + }); + + it('returns turnResult null when no settled turn matches', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const readPage = vi.fn().mockResolvedValue({ + sessionId, + records: [{ type: 'user', subtype: undefined, message: {} }], + hasMore: false, + gaps: [], + startTime: 'start', + lastUpdated: 'end', + }); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: 'missing', + }), + ).resolves.toEqual({ v: 1, sessionId, turnResult: null }); + + mockConnectionState.resolve(); + await agentPromise; + }); + + it('rejects turn status reads with invalid params or non-live sessions', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + for (const params of [ + {}, + { sessionId: '' }, + { sessionId, promptId: '' }, + { sessionId, promptId: 42 }, + ]) { + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, params), + ).rejects.toThrow(); + } + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId: '22222222-2222-2222-2222-222222222222', + }), + ).rejects.toThrow(); + + mockConnectionState.resolve(); + await agentPromise; + }); + it('newSession with SSE MCP server creates MCPServerConfig with url', async () => { await setupSessionMocks('session-sse'); diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index e10461d9183..6b62e482461 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -111,6 +111,7 @@ import { type SessionArtifactSnapshotRecordPayload, type WorkspaceRememberContextMode, type ChatRecord, + type TurnResultRecordPayload, } from '@qwen-code/qwen-code-core'; import { randomUUID, timingSafeEqual } from 'node:crypto'; import { performance } from 'node:perf_hooks'; @@ -339,6 +340,56 @@ const SESSION_DRAIN_TIMEOUT_MS = 30_000; // Must be less than WORKSPACE_MEMORY_REMEMBER_TIMEOUT_MS (300s) in bridge.ts. const WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS = 295_000; +// Turn-status transcript scan bounds: settled `turn_result` records are +// appended at each turn's end, so a backward scan from the tail finds recent +// turns quickly. The caps keep a pathological lookup (ancient promptId in a +// huge transcript) from reading the whole file. +const TURN_STATUS_SCAN_PAGE_LIMIT = 500; +const TURN_STATUS_SCAN_MAX_PAGES = 10; + +/** + * Scan the session transcript backward from the tail for `turn_result` + * system records. With `promptId`, returns that exact turn's payload; + * without it, the most recent one. Resolves `undefined` when no match is + * found within the scan bounds. + */ +async function findSettledTurnResult( + reader: SessionTranscriptReader, + sessionId: string, + promptId: string | undefined, + workspaceCwd: string, +): Promise { + let cursor: string | undefined; + for (let page = 0; page < TURN_STATUS_SCAN_MAX_PAGES; page++) { + const result = await reader.readPage(sessionId, { + ...(cursor !== undefined + ? { cursor } + : { direction: 'backward' as const }), + limit: TURN_STATUS_SCAN_PAGE_LIMIT, + }); + // Backward pages hold the newest slice; walk from the tail so the most + // recent settled turn wins. + for (let i = result.records.length - 1; i >= 0; i--) { + const record = result.records[i]!; + if (record.type !== 'system' || record.subtype !== 'turn_result') { + continue; + } + const payload = record.systemPayload as TurnResultRecordPayload; + if (promptId === undefined || payload.promptId === promptId) { + return payload; + } + } + if (!result.hasMore || result.nextCursorState === undefined) { + return undefined; + } + cursor = encodeSessionTranscriptCursor( + result.nextCursorState, + workspaceCwd, + ); + } + return undefined; +} + type AcpSessionStartStage = | 'settings_load' | 'config_setup' @@ -9060,6 +9111,64 @@ class QwenAgent implements Agent { : null, }; } + case SERVE_CONTROL_EXT_METHODS.sessionTurnStatus: { + const sessionId = params['sessionId']; + if (typeof sessionId !== 'string' || !SESSION_ID_RE.test(sessionId)) { + throw RequestError.invalidParams( + undefined, + 'Invalid or missing sessionId', + ); + } + const rawPromptId = params['promptId']; + if ( + rawPromptId !== undefined && + (typeof rawPromptId !== 'string' || rawPromptId.length === 0) + ) { + throw RequestError.invalidParams( + undefined, + 'Invalid or missing promptId', + ); + } + // Throws when the session is not live in this child. Settled records + // only exist for sessions this child owns, so that is the honest + // scope — the bridge routes here only for the owning child. + const session = this.sessionOrThrow(sessionId); + const settings = loadSettingsCached(cwd); + return await runWithAcpRuntimeOutputDir(settings, cwd, async () => { + // Flush so a just-settled turn (append queued on the recording + // service's write tail) is visible to the read below. + // Best-effort: a recorder in a write-failure state (ENOSPC, + // lease loss) must not turn polling into a 500 — partial + // records already on disk remain scannable. + try { + await session.getConfig().getChatRecordingService()?.flush(); + } catch { + // Fall through to the scan. + } + try { + const reader = new SessionTranscriptReader(cwd); + const turnResult = await findSettledTurnResult( + reader, + sessionId, + typeof rawPromptId === 'string' ? rawPromptId : undefined, + cwd, + ); + return { + v: 1, + sessionId, + turnResult: turnResult ?? null, + }; + } catch (error) { + if ((error as NodeJS.ErrnoException).code === 'ENOENT') { + // Transcript file not written yet (no settled turn + // persisted). Scoped to the read so an unrelated ENOENT + // (settings/runtime resolution) still surfaces. + return { v: 1, sessionId, turnResult: null }; + } + throw error; + } + }); + } case SERVE_CONTROL_EXT_METHODS.sessionContinue: { const sessionId = params['sessionId']; if (typeof sessionId !== 'string' || sessionId.length === 0) { diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index bb5b33d5ae0..3af6901dbc0 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -316,6 +316,7 @@ describe('Session', () => { let switchModelSpy: ReturnType; let getAvailableCommandsSpy: ReturnType; let mockChatRecordingService: { + recordTurnResult: ReturnType; recordUserMessage: ReturnType; recordMidTurnUserMessage: ReturnType; recordUiTelemetryEvent: ReturnType; @@ -498,6 +499,7 @@ describe('Session', () => { }; mockChatRecordingService = { + recordTurnResult: vi.fn(), recordUserMessage: vi.fn(), recordMidTurnUserMessage: vi.fn(), recordUiTelemetryEvent: vi.fn(), @@ -2565,6 +2567,371 @@ describe('Session', () => { expect(core.getInvocationContext()).toBeUndefined(); }); + describe('turn result recording', () => { + const trustedContext: core.InvocationContextV1 = { + version: 1, + sessionId: 'test-session-id', + promptId: 'daemon-prompt-id', + originatorClientId: 'client-1', + }; + + it('records a completed turn_result for a daemon-admitted prompt', async () => { + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValue(createEmptyStream()); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'trusted prompt' }], + }, + trustedContext, + ); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledTimes( + 1, + ); + const payload = + mockChatRecordingService.recordTurnResult.mock.calls[0][0]; + expect(payload).toMatchObject({ + promptId: 'daemon-prompt-id', + state: 'completed', + stopReason: 'end_turn', + promptText: 'trusted prompt', + originatorClientId: 'client-1', + }); + expect(payload.startedAt).toBeLessThanOrEqual(payload.endedAt); + }); + + it('accumulates streamed agent text into resultText', async () => { + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: 'Hello, ' }] } }], + }, + }, + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: 'world!' }] } }], + }, + }, + ]), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'greet' }], + }, + trustedContext, + ); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + state: 'completed', + resultText: 'Hello, world!', + }), + ); + }); + + it('caps resultText at TURN_RESULT_TEXT_MAX_CHARS and flags truncation', async () => { + const longText = 'a'.repeat(core.TURN_RESULT_TEXT_MAX_CHARS + 100); + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: longText }] } }], + }, + }, + ]), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'long' }], + }, + trustedContext, + ); + + const payload = + mockChatRecordingService.recordTurnResult.mock.calls[0][0]; + expect(payload.resultText).toHaveLength( + core.TURN_RESULT_TEXT_MAX_CHARS, + ); + expect(payload.resultTruncated).toBe(true); + }); + + it('records a cancelled turn when admission aborts before dispatch', async () => { + let releaseAdmission!: () => void; + const admission = new Promise((resolve) => { + releaseAdmission = resolve; + }); + mockConfig.assertCanStartTurn = vi.fn().mockReturnValue(admission); + const cancellation = new AbortController(); + + const prompt = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'cancelled prompt' }], + }, + trustedContext, + cancellation.signal, + ); + await vi.waitFor(() => + expect(mockConfig.assertCanStartTurn).toHaveBeenCalledOnce(), + ); + cancellation.abort(); + releaseAdmission(); + + await expect(prompt).resolves.toEqual({ stopReason: 'cancelled' }); + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'daemon-prompt-id', + state: 'cancelled', + }), + ); + }); + + it('records an error turn when the model stream fails', async () => { + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValue(createFailingStream('model exploded')); + + await expect( + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'boom' }], + }, + trustedContext, + ), + ).rejects.toThrow('model exploded'); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'daemon-prompt-id', + state: 'error', + error: { message: 'model exploded' }, + }), + ); + }); + + it('records a cancelled turn when user cancel races a non-abort stream error', async () => { + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createFailingStream('Request was aborted.', () => { + void session.cancelPendingPrompt(); + }), + ); + + await expect( + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'cancel me' }], + }, + trustedContext, + ), + ).rejects.toThrow('Request was aborted.'); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'daemon-prompt-id', + state: 'cancelled', + }), + ); + }); + + it('does not record a turn_result without an invocation context', async () => { + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValue(createEmptyStream()); + + await session.prompt({ + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'standalone prompt' }], + }); + + expect( + mockChatRecordingService.recordTurnResult, + ).not.toHaveBeenCalled(); + }); + + it('keeps overlapping turn records attributed to their own promptIds', async () => { + // DAEMON-003 overlap: the bridge releases the FIFO on deadline + // while the agent is still executing, so the successor prompt is + // admitted before the predecessor settles. Each turn must still + // settle its own record under its own promptId. + mockConfig.assertCanStartTurn = vi.fn().mockResolvedValue(undefined); + let releaseFirst!: () => void; + const firstBlocked = new Promise((resolve) => { + releaseFirst = resolve; + }); + const firstStream = (async function* () { + yield { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: 'first answer' }] } }], + }, + }; + await firstBlocked; + })(); + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValueOnce(firstStream) + .mockResolvedValueOnce( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { content: { parts: [{ text: 'second answer' }] } }, + ], + }, + }, + ]), + ); + + const first = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'first prompt' }], + }, + trustedContext, + ); + await vi.waitFor(() => + expect(mockChat.sendMessageStream).toHaveBeenCalledTimes(1), + ); + + const secondContext: core.InvocationContextV1 = { + version: 1, + sessionId: 'test-session-id', + promptId: 'second-prompt-id', + originatorClientId: 'client-1', + }; + const second = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'second prompt' }], + }, + secondContext, + ); + // Third assertCanStartTurn call = the successor's prompt()-level + // admission (turn A used the prompt + inner calls). Flush + // microtasks so the successor's recording begin has run. + await vi.waitFor(() => + expect(mockConfig.assertCanStartTurn).toHaveBeenCalledTimes(3), + ); + await Promise.resolve(); + await Promise.resolve(); + + releaseFirst(); + await first; + await second; + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledTimes( + 2, + ); + const [firstPayload, secondPayload] = + mockChatRecordingService.recordTurnResult.mock.calls.map( + (call) => call[0], + ); + expect(firstPayload).toMatchObject({ + promptId: 'daemon-prompt-id', + state: 'cancelled', + promptText: 'first prompt', + resultText: 'first answer', + }); + expect(secondPayload).toMatchObject({ + promptId: 'second-prompt-id', + state: 'completed', + promptText: 'second prompt', + resultText: 'second answer', + }); + }); + + it('records a cancelled turn when cancelled while waiting for the predecessor', async () => { + // The successor is admitted while the predecessor still streams, + // then cancelled during the predecessor wait; it must settle its + // own cancelled record without disturbing the predecessor's. + mockConfig.assertCanStartTurn = vi.fn().mockResolvedValue(undefined); + let releaseFirst!: () => void; + const firstBlocked = new Promise((resolve) => { + releaseFirst = resolve; + }); + const firstStream = (async function* () { + yield { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [] } }], + }, + }; + await firstBlocked; + })(); + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValueOnce(firstStream) + .mockResolvedValueOnce(createEmptyStream()); + + const first = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'first prompt' }], + }, + trustedContext, + ); + await vi.waitFor(() => + expect(mockChat.sendMessageStream).toHaveBeenCalledTimes(1), + ); + + const secondContext: core.InvocationContextV1 = { + version: 1, + sessionId: 'test-session-id', + promptId: 'second-prompt-id', + }; + const admissionCancellation = new AbortController(); + const second = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'second prompt' }], + }, + secondContext, + admissionCancellation.signal, + ); + await vi.waitFor(() => + expect(mockConfig.assertCanStartTurn).toHaveBeenCalledTimes(3), + ); + await Promise.resolve(); + await Promise.resolve(); + admissionCancellation.abort(); + + releaseFirst(); + await first; + await expect(second).resolves.toEqual({ stopReason: 'cancelled' }); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledTimes( + 2, + ); + const [firstPayload, secondPayload] = + mockChatRecordingService.recordTurnResult.mock.calls.map( + (call) => call[0], + ); + expect(firstPayload).toMatchObject({ + promptId: 'daemon-prompt-id', + promptText: 'first prompt', + }); + expect(secondPayload).toMatchObject({ + promptId: 'second-prompt-id', + state: 'cancelled', + promptText: 'second prompt', + }); + }); + }); + it('rejects a trusted context for a different session', async () => { const trustedContext: core.InvocationContextV1 = { version: 1, diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index e79d1cfce46..2d85fc2b98b 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -42,6 +42,7 @@ import type { VisionBridgeResult, MemoryWriteCandidate, InvocationContextV1, + TurnResultRecordPayload, } from '@qwen-code/qwen-code-core'; import { AuthType, @@ -153,6 +154,7 @@ import { getFullTurnVisionModelSelector, splitImageParts, approxBase64Bytes, + TURN_RESULT_TEXT_MAX_CHARS, runWithRuntimeContentGenerator, runWithInvocationContext, } from '@qwen-code/qwen-code-core'; @@ -643,6 +645,62 @@ function hasInlineMediaContentBlock(content: ContentBlock[]): boolean { return content.some((part) => part.type === 'image' || part.type === 'audio'); } +/** + * Extract the prompt text recorded in a `turn_result` record. Mirrors the + * bridge's pending-prompt `extractPromptText`: first non-empty text block, + * an image placeholder for image-only prompts, else empty. + */ +function extractTurnPromptText(content: ContentBlock[]): string { + let hasImage = false; + for (const block of content) { + if (block.type === 'image') { + hasImage = true; + } + if (block.type === 'text' && block.text.length > 0) { + return block.text; + } + } + return hasImage ? '[image]' : ''; +} + +type InFlightTurnRecording = { + promptId: string; + originatorClientId?: string; + startedAt: number; + promptText: string; + promptTextTruncated: boolean; + resultText: string; + resultTruncated: boolean; +}; + +function truncateTurnText(text: string): { + text: string; + truncated: boolean; +} { + if (text.length <= TURN_RESULT_TEXT_MAX_CHARS) { + return { text, truncated: false }; + } + return { text: text.slice(0, TURN_RESULT_TEXT_MAX_CHARS), truncated: true }; +} + +function turnResultErrorPayload(error: unknown): { + message: string; + code?: string; +} { + const message = + error instanceof Error && error.message.length > 0 + ? error.message + : String(error); + const code = (error as { code?: unknown })?.code; + if (typeof code === 'string' && code.length > 0) { + return { message, code }; + } + if (typeof code === 'number') { + return { message, code: String(code) }; + } + return { message }; +} + function capMidTurnDrainItems(items: T[], fieldName: string): T[] { if (items.length <= MAX_MID_TURN_DRAIN_ITEMS) return items; @@ -1096,6 +1154,14 @@ export async function buildAvailableCommandsSnapshot( */ export class Session implements SessionContext { private pendingPrompt: AbortController | null = null; + /** + * In-flight `turn_result` accumulation for the turn whose model loop is + * currently streaming (only prompts carrying an invocation context). + * Assigned when the turn's loop starts, not at admission, so an + * overlapping successor cannot redirect this turn's chunks. Settled into + * the transcript at turn end; `null` when no pollable turn is streaming. + */ + #turnRecording: InFlightTurnRecording | null = null; /** * Tracks the completion of the current prompt so that the next prompt * can await it. This prevents a new prompt from reading chat history @@ -1991,7 +2057,9 @@ export class Session implements SessionContext { throw RequestError.invalidParams(undefined, 'Session is closing'); } await this.assertCanStartTurn(); + const turnRecording = this.#beginTurnRecording(params, invocationContext); if (admissionCancellation?.aborted) { + this.#settleTurnRecording('cancelled', turnRecording); return { stopReason: 'cancelled' }; } const todoStopGuardPreparation = @@ -2070,6 +2138,7 @@ export class Session implements SessionContext { if (pendingSend.signal.aborted) { releasePendingSend(); this.todoStopGuard.suspend(); + this.#settleTurnRecording('cancelled', turnRecording); return { stopReason: 'cancelled' }; } @@ -2088,12 +2157,24 @@ export class Session implements SessionContext { resolveCompletion = resolve; }); + // Publish this turn's recording only now that the predecessor turn has + // settled and this turn's model loop is about to start. Publishing at + // admission would let an overlapping successor (DAEMON-003 deadline + // overlap) redirect this turn's still-streaming chunks into the + // successor's record. + this.#turnRecording = turnRecording; + try { const result = await this.#executePrompt( params, pendingSend, invocationContext, ); + this.#settleTurnRecording( + result.stopReason === 'cancelled' ? 'cancelled' : 'completed', + turnRecording, + result, + ); releasePendingSend(); // Drain any cron prompts that queued while the prompt was active void this.#drainCronQueue(); @@ -2101,6 +2182,18 @@ export class Session implements SessionContext { this.#maybeEmitFollowupSuggestion(result); return result; } catch (error) { + // An explicit user cancel can surface as a non-AbortError (e.g. the + // provider SDK's "Request was aborted."), so classify the recording + // by the cancel reason instead of the error shape. + const userCancelled = + pendingSend.signal.aborted && + pendingSend.signal.reason === USER_CANCEL_ABORT_REASON; + this.#settleTurnRecording( + userCancelled ? 'cancelled' : 'error', + turnRecording, + undefined, + error, + ); if (error instanceof SessionWriterError) { throw new RequestError(error.rpcCode, error.message, { errorKind: error.errorKind, @@ -3635,6 +3728,7 @@ export class Session implements SessionContext { } async sendUpdate(update: SessionUpdate): Promise { + this.#accumulateTurnResultText(update); const params: SessionNotification = { sessionId: this.sessionId, update, @@ -3643,6 +3737,107 @@ export class Session implements SessionContext { await this.client.sessionUpdate(params); } + /** + * Start accumulating the `turn_result` record for this prompt. Only + * daemon-admitted prompts carry an invocation context (promptId); internal + * turns (cron, notifications, TUI) are not pollable, so nothing records. + */ + #beginTurnRecording( + params: PromptRequest, + invocationContext: InvocationContextV1 | undefined, + ): InFlightTurnRecording | null { + if (!invocationContext) { + return null; + } + const { text, truncated } = truncateTurnText( + extractTurnPromptText(params.prompt), + ); + return { + promptId: invocationContext.promptId, + ...(invocationContext.originatorClientId !== undefined + ? { originatorClientId: invocationContext.originatorClientId } + : {}), + startedAt: Date.now(), + promptText: text, + promptTextTruncated: truncated, + resultText: '', + resultTruncated: false, + }; + } + + /** + * Accumulate streamed agent text into the in-flight turn record. Only + * `agent_message_chunk` text counts — tool output and thought chunks are + * excluded by design (the result is the assistant's own words). + */ + #accumulateTurnResultText(update: SessionUpdate): void { + const recording = this.#turnRecording; + if (!recording || update.sessionUpdate !== 'agent_message_chunk') { + return; + } + const content = update.content; + if (content.type !== 'text' || content.text.length === 0) { + return; + } + if (recording.resultText.length >= TURN_RESULT_TEXT_MAX_CHARS) { + recording.resultTruncated = true; + return; + } + const remaining = TURN_RESULT_TEXT_MAX_CHARS - recording.resultText.length; + if (content.text.length > remaining) { + recording.resultText += content.text.slice(0, remaining); + recording.resultTruncated = true; + } else { + recording.resultText += content.text; + } + } + + /** + * Write the turn's captured `turn_result` record into the transcript. + * Settles the exact recording captured at turn start — never the current + * slot — so an overlapping turn cannot steal or lose this settlement. + * Best-effort: recording failures must never break turn settlement. + */ + #settleTurnRecording( + state: 'completed' | 'cancelled' | 'error', + recording: InFlightTurnRecording | null, + response?: PromptResponse, + error?: unknown, + ): void { + if (recording !== null && this.#turnRecording === recording) { + this.#turnRecording = null; + } + if (recording === null) { + return; + } + const payload: TurnResultRecordPayload = { + promptId: recording.promptId, + state, + ...(response?.stopReason !== undefined + ? { stopReason: response.stopReason } + : {}), + ...(state === 'error' ? { error: turnResultErrorPayload(error) } : {}), + startedAt: recording.startedAt, + endedAt: Date.now(), + promptText: recording.promptText, + ...(recording.promptTextTruncated ? { promptTextTruncated: true } : {}), + ...(recording.resultText.length > 0 + ? { resultText: recording.resultText } + : {}), + ...(recording.resultTruncated ? { resultTruncated: true } : {}), + ...(recording.originatorClientId !== undefined + ? { originatorClientId: recording.originatorClientId } + : {}), + }; + try { + this.config.getChatRecordingService()?.recordTurnResult(payload); + } catch (recordError) { + debugLogger.warn( + `Failed to record turn result: ${this.#formatError(recordError)}`, + ); + } + } + #getCurrentChat(): GeminiChat { return this.config.getGeminiClient()!.getChat(); } diff --git a/packages/cli/src/serve/acp-session-bridge.ts b/packages/cli/src/serve/acp-session-bridge.ts index dbec1b27e91..9449931be98 100644 --- a/packages/cli/src/serve/acp-session-bridge.ts +++ b/packages/cli/src/serve/acp-session-bridge.ts @@ -78,6 +78,7 @@ export type { BridgeGenerationStreamEvent, BridgeWorkspaceGenerationStreamEvent, BridgeSessionSummary, + BridgeTurnStatus, SessionMetadataUpdate, BridgeClientRequestContext, BridgeHeartbeatResult, diff --git a/packages/cli/src/serve/routes/session.ts b/packages/cli/src/serve/routes/session.ts index fb79bfbb061..973a41104b4 100644 --- a/packages/cli/src/serve/routes/session.ts +++ b/packages/cli/src/serve/routes/session.ts @@ -3763,6 +3763,80 @@ export function registerSessionRoutes( ), ); + // Turn status: pollable state of one admitted prompt's turn. `current` + // resolves the running turn (or queued FIFO head, latest settled outcome, + // idle); `:promptId` resolves that exact prompt. Live queue state comes + // from the bridge's pending list; settled outcomes (completed / cancelled + // / error) from the agent's persisted `turn_result` transcript records. + app.get('/session/:id/turns/current', (req, res) => { + const sessionId = requireSessionId(req, res); + if (sessionId === null) return; + const runtime = resolveLiveSessionRuntime( + sessionId, + res, + 'GET /session/:id/turns/current', + ); + if (!runtime) return; + const clientId = parseClientIdHeader(req, res); + if (clientId === null) return; + void (async () => { + try { + const status = await runtime.bridge.getSessionTurnStatus( + sessionId, + clientId !== undefined ? { clientId } : undefined, + ); + res.status(200).json(status); + } catch (err) { + sendBridgeError(res, err, { + route: 'GET /session/:id/turns/current', + sessionId, + }); + } + })(); + }); + + app.get('/session/:id/turns/:promptId', (req, res) => { + const sessionId = requireSessionId(req, res); + if (sessionId === null) return; + const runtime = resolveLiveSessionRuntime( + sessionId, + res, + 'GET /session/:id/turns/:promptId', + ); + if (!runtime) return; + const promptId = req.params['promptId']; + if (!promptId) { + res.status(400).json({ error: '`promptId` route parameter is required' }); + return; + } + const clientId = parseClientIdHeader(req, res); + if (clientId === null) return; + void (async () => { + try { + const status = await runtime.bridge.getSessionTurnStatus( + sessionId, + clientId !== undefined ? { clientId } : undefined, + promptId, + ); + if (!status) { + res.status(404).json({ + error: `Prompt ${promptId} not found in session ${sessionId}`, + code: 'prompt_not_found', + sessionId, + promptId, + }); + return; + } + res.status(200).json(status); + } catch (err) { + sendBridgeError(res, err, { + route: 'GET /session/:id/turns/:promptId', + sessionId, + }); + } + })(); + }); + app.post( '/session/:id/shell', mutate({ strict: true }), diff --git a/packages/cli/src/serve/server.test.ts b/packages/cli/src/serve/server.test.ts index cd8fbfb8c28..b1b1125c38f 100644 --- a/packages/cli/src/serve/server.test.ts +++ b/packages/cli/src/serve/server.test.ts @@ -90,6 +90,7 @@ import { type BridgeDaemonStatusSnapshot, type BridgeRestoredSession, type BridgeClientRequestContext, + type BridgeTurnStatus, type BridgeRestoreSessionRequest, type BridgeSession, type BridgeSessionSummary, @@ -530,6 +531,11 @@ interface FakeBridgeOpts { sessionId: string, promptId: string, ) => { removed: boolean }; + getSessionTurnStatusImpl?: ( + sessionId: string, + context: BridgeClientRequestContext | undefined, + promptId: string | undefined, + ) => Promise; spawnImpl?: (req: BridgeSpawnRequest) => Promise; changeSessionCwdImpl?: ( sessionId: string, @@ -779,6 +785,7 @@ interface FakeCloseSessionOpts { interface FakeBridge extends AcpSessionBridge { calls: BridgeSpawnRequest[]; + getSessionTurnStatusCalls: Array<{ sessionId: string; promptId?: string }>; loadCalls: BridgeRestoreSessionRequest[]; resumeCalls: BridgeRestoreSessionRequest[]; promptCalls: Array<{ @@ -1002,6 +1009,12 @@ function fakeBridge(opts: FakeBridgeOpts = {}): FakeBridge { }> = []; const removePendingPromptImpl = opts.removePendingPromptImpl ?? (() => ({ removed: true })); + const getSessionTurnStatusCalls: Array<{ + sessionId: string; + promptId?: string; + }> = []; + const getSessionTurnStatusImpl = + opts.getSessionTurnStatusImpl ?? (async () => undefined); const permissionVotes: FakeBridge['permissionVotes'] = []; const sessionPermissionVotes: FakeBridge['sessionPermissionVotes'] = []; const listCalls: string[] = []; @@ -1550,6 +1563,7 @@ function fakeBridge(opts: FakeBridgeOpts = {}): FakeBridge { // so existing assertions stay shape-compatible. permissionPolicy: 'first-responder' as const, calls, + getSessionTurnStatusCalls, loadCalls, resumeCalls, promptCalls, @@ -1945,6 +1959,13 @@ function fakeBridge(opts: FakeBridgeOpts = {}): FakeBridge { removePendingPromptCalls.push({ sessionId, promptId }); return removePendingPromptImpl(sessionId, promptId); }, + async getSessionTurnStatus(sessionId, context, promptId) { + getSessionTurnStatusCalls.push({ + sessionId, + ...(promptId !== undefined ? { promptId } : {}), + }); + return getSessionTurnStatusImpl(sessionId, context, promptId); + }, async executeShellCommand(sessionId, command, signal, context) { shellCalls.push({ sessionId, @@ -8044,6 +8065,106 @@ describe('createServeApp', () => { }); }); + describe('GET /session/:id/turns', () => { + const turnsApp = (bridge: FakeBridge) => + createServeApp( + { ...baseOpts, token: 'secret', workspace: WS_BOUND }, + undefined, + { bridge }, + ); + + it('200 with the current turn status', async () => { + const bridge = fakeBridge({ + getSessionTurnStatusImpl: async (sessionId) => ({ + sessionId, + state: 'running', + promptId: 'p-1', + promptText: 'doing things', + queuedAt: 1000, + startedAt: 1100, + }), + }); + const res = await request(turnsApp(bridge)) + .get('/session/s-1/turns/current') + .set('Host', `127.0.0.1:${baseOpts.port}`) + .set('Authorization', 'Bearer secret'); + expect(res.status).toBe(200); + expect(res.body).toMatchObject({ + sessionId: 's-1', + state: 'running', + promptId: 'p-1', + }); + expect(bridge.getSessionTurnStatusCalls).toEqual([{ sessionId: 's-1' }]); + }); + + it('200 with a settled turn status by promptId', async () => { + const bridge = fakeBridge({ + getSessionTurnStatusImpl: async (sessionId, _context, promptId) => ({ + sessionId, + state: 'completed', + promptId: promptId ?? 'p-1', + stopReason: 'end_turn', + resultText: 'done', + startedAt: 1000, + endedAt: 2000, + }), + }); + const res = await request(turnsApp(bridge)) + .get('/session/s-1/turns/p-1') + .set('Host', `127.0.0.1:${baseOpts.port}`) + .set('Authorization', 'Bearer secret'); + expect(res.status).toBe(200); + expect(res.body).toMatchObject({ + sessionId: 's-1', + state: 'completed', + promptId: 'p-1', + stopReason: 'end_turn', + resultText: 'done', + }); + }); + + it('404 prompt_not_found when the bridge resolves nothing', async () => { + const bridge = fakeBridge({ + getSessionTurnStatusImpl: async () => undefined, + }); + const res = await request(turnsApp(bridge)) + .get('/session/s-1/turns/nope') + .set('Host', `127.0.0.1:${baseOpts.port}`) + .set('Authorization', 'Bearer secret'); + expect(res.status).toBe(404); + expect(res.body.code).toBe('prompt_not_found'); + expect(res.body.promptId).toBe('nope'); + }); + + it('404 for unknown session', async () => { + const bridge = fakeBridge({ + getSessionTurnStatusImpl: async () => { + throw new SessionNotFoundError('unknown'); + }, + }); + const res = await request(turnsApp(bridge)) + .get('/session/unknown/turns/current') + .set('Host', `127.0.0.1:${baseOpts.port}`) + .set('Authorization', 'Bearer secret'); + expect(res.status).toBe(404); + }); + + it('400 when bridge throws InvalidClientIdError', async () => { + const bridge = fakeBridge({ + getSessionTurnStatusImpl: async () => { + throw new InvalidClientIdError('s-1', 'rogue'); + }, + }); + const res = await request(turnsApp(bridge)) + .get('/session/s-1/turns/current') + .set('Host', `127.0.0.1:${baseOpts.port}`) + .set('Authorization', 'Bearer secret') + .set('X-Qwen-Client-Id', 'rogue'); + expect(res.status).toBe(400); + expect(res.body.code).toBe('invalid_client_id'); + }); + }); + describe('host allowlist (loopback bind)', () => { it('rejects requests with an unrelated Host header', async () => { const app = createServeApp(baseOpts); diff --git a/packages/cli/src/serve/server/telemetry-catalog.test.ts b/packages/cli/src/serve/server/telemetry-catalog.test.ts index cdd457c6463..dbb773dc9be 100644 --- a/packages/cli/src/serve/server/telemetry-catalog.test.ts +++ b/packages/cli/src/serve/server/telemetry-catalog.test.ts @@ -98,7 +98,7 @@ describe('legacy session telemetry route drift guard', () => { .map(({ method, path }) => `${method} ${path}`) .sort(); - expect(registered).toHaveLength(50); + expect(registered).toHaveLength(52); expect(registered).toEqual(catalog); }); }); diff --git a/packages/cli/src/serve/server/telemetry.ts b/packages/cli/src/serve/server/telemetry.ts index 7e5bdc639c8..79ae2cc992f 100644 --- a/packages/cli/src/serve/server/telemetry.ts +++ b/packages/cli/src/serve/server/telemetry.ts @@ -275,6 +275,18 @@ export const legacySessionTelemetryRoutes = [ attribution: 'handler_resolved', route: 'DELETE /session/:id/pending-prompts/:promptId', }, + { + method: 'GET', + path: '/session/:id/turns/current', + attribution: 'handler_resolved', + route: 'GET /session/:id/turns/current', + }, + { + method: 'GET', + path: '/session/:id/turns/:promptId', + attribution: 'handler_resolved', + route: 'GET /session/:id/turns/:promptId', + }, { method: 'POST', path: '/session/:id/shell', diff --git a/packages/core/src/services/chatRecordingService.test.ts b/packages/core/src/services/chatRecordingService.test.ts index 300f2218727..68f61b51a5e 100644 --- a/packages/core/src/services/chatRecordingService.test.ts +++ b/packages/core/src/services/chatRecordingService.test.ts @@ -14,6 +14,7 @@ import { ChatRecordingService, type ChatRecord, type AtCommandRecordPayload, + type TurnResultRecordPayload, } from './chatRecordingService.js'; import { MAX_RETAINED_TOOL_RESULT_DISPLAY_CHARS } from '../utils/toolResultDisplayCompaction.js'; import * as jsonl from '../utils/jsonl-utils.js'; @@ -303,6 +304,43 @@ describe('ChatRecordingService', () => { }); }); + describe('recordTurnResult', () => { + it('records a settled turn outcome as a system payload', async () => { + const payload: TurnResultRecordPayload = { + promptId: 'prompt-1', + state: 'completed', + stopReason: 'end_turn', + startedAt: 1000, + endedAt: 2000, + promptText: 'hello', + resultText: 'world', + originatorClientId: 'client-1', + }; + + chatRecordingService.recordTurnResult(payload); + await chatRecordingService.flush(); + + expect(jsonl.writeLine).toHaveBeenCalledTimes(1); + const record = vi.mocked(jsonl.writeLine).mock.calls[0][1] as ChatRecord; + expect(record.type).toBe('system'); + expect(record.subtype).toBe('turn_result'); + expect(record.systemPayload).toEqual(payload); + }); + + it('is best-effort when recording is inactive', () => { + const inactive = new ChatRecordingService(mockConfig); + expect(() => + inactive.recordTurnResult({ + promptId: 'prompt-1', + state: 'cancelled', + startedAt: 1000, + endedAt: 1500, + }), + ).not.toThrow(); + expect(jsonl.writeLine).not.toHaveBeenCalled(); + }); + }); + describe('recordAtCommand', () => { it('should record @-command metadata as a system payload', async () => { const userParts: Part[] = [{ text: 'Hello, world!' }]; diff --git a/packages/core/src/services/chatRecordingService.ts b/packages/core/src/services/chatRecordingService.ts index a572291f306..2ef80710bbc 100644 --- a/packages/core/src/services/chatRecordingService.ts +++ b/packages/core/src/services/chatRecordingService.ts @@ -265,7 +265,8 @@ export interface ChatRecord { | 'file_history_snapshot' | 'user_text_elements' | 'session_artifact_event' - | 'session_artifact_snapshot'; + | 'session_artifact_snapshot' + | 'turn_result'; /** Working directory at time of message */ cwd: string; /** CLI version for compatibility tracking */ @@ -317,7 +318,8 @@ export interface ChatRecord { | FileHistorySnapshotRecordPayload | UserTextElementsRecordPayload | SessionArtifactEventRecordPayload - | SessionArtifactSnapshotRecordPayload; + | SessionArtifactSnapshotRecordPayload + | TurnResultRecordPayload; /** Background subagent that produced this record (e.g. "explore-7f3c"). */ agentId?: string; @@ -498,6 +500,34 @@ export interface UserTextElementsRecordPayload { textElements: unknown[]; } +/** + * Cap (in UTF-16 code units) on the prompt / result text stored in a + * `turn_result` record. Writers truncate and set the paired flag. + */ +export const TURN_RESULT_TEXT_MAX_CHARS = 32_768; + +/** + * Settled outcome of one admitted prompt, appended at turn settle so + * pollable turn-status queries survive daemon restarts. `state` + * distinguishes normal completion (`completed`, with `stopReason`), + * user/abort cancellation (`cancelled`), and failure (`error`). + */ +export interface TurnResultRecordPayload { + promptId: string; + state: 'completed' | 'cancelled' | 'error'; + stopReason?: string; + error?: { message: string; code?: string }; + /** Epoch ms the turn started executing (agent clock). */ + startedAt: number; + /** Epoch ms the turn settled (agent clock). */ + endedAt: number; + promptText?: string; + promptTextTruncated?: boolean; + resultText?: string; + resultTruncated?: boolean; + originatorClientId?: string; +} + export interface ChatRecordingFailureEvent { sessionId: string; error: Error; @@ -1852,6 +1882,25 @@ export class ChatRecordingService { await this.appendRecordStrict(record); } + /** + * Append the settled outcome of a turn. Best-effort by design: a + * recording failure must never break turn settlement, so this uses the + * non-strict append path (inactive/failed writers skip silently). + */ + recordTurnResult(payload: TurnResultRecordPayload): void { + try { + const record: ChatRecord = { + ...this.createBaseRecord('system'), + type: 'system', + subtype: 'turn_result', + systemPayload: payload, + }; + this.appendRecord(record); + } catch (error) { + debugLogger.error('Error recording turn result:', error); + } + } + private appendSerializedFileHistorySnapshotBatch( snapshots: SerializedFileHistorySnapshot[], ): void { diff --git a/packages/core/src/utils/transcript-records.ts b/packages/core/src/utils/transcript-records.ts index 714fc756c65..99ca212451b 100644 --- a/packages/core/src/utils/transcript-records.ts +++ b/packages/core/src/utils/transcript-records.ts @@ -102,6 +102,7 @@ const KNOWN_RECORD_SUBTYPES = new Set([ 'agent_launch_prompt', 'file_history_snapshot', 'session_source', + 'turn_result', ...ARTIFACT_RECORD_SUBTYPES, ]); From 24ddb5fb900b188fb3de251d8d48c26b45e08b65 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sat, 8 Aug 2026 12:31:19 +0800 Subject: [PATCH 02/25] test(serve): align turn status CI expectations --- packages/cli/src/acp-integration/session/Session.test.ts | 2 +- packages/cli/src/serve/server/telemetry-catalog.test.ts | 2 +- packages/cli/src/serve/server/telemetry.test.ts | 8 ++++---- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index 7dd8850578a..e309a5b0339 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -4010,7 +4010,7 @@ describe('Session', () => { }, trustedContext, ), - ).rejects.toThrow('Request was aborted.'); + ).resolves.toEqual({ stopReason: 'cancelled' }); expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( expect.objectContaining({ diff --git a/packages/cli/src/serve/server/telemetry-catalog.test.ts b/packages/cli/src/serve/server/telemetry-catalog.test.ts index dbb773dc9be..3c0a192f488 100644 --- a/packages/cli/src/serve/server/telemetry-catalog.test.ts +++ b/packages/cli/src/serve/server/telemetry-catalog.test.ts @@ -98,7 +98,7 @@ describe('legacy session telemetry route drift guard', () => { .map(({ method, path }) => `${method} ${path}`) .sort(); - expect(registered).toHaveLength(52); + expect(registered).toHaveLength(54); expect(registered).toEqual(catalog); }); }); diff --git a/packages/cli/src/serve/server/telemetry.test.ts b/packages/cli/src/serve/server/telemetry.test.ts index b7f38e58344..654d7538850 100644 --- a/packages/cli/src/serve/server/telemetry.test.ts +++ b/packages/cli/src/serve/server/telemetry.test.ts @@ -794,17 +794,17 @@ describe('daemonTelemetryMiddleware — recordRequest seam', () => { }); describe('legacy session telemetry route catalog', () => { - it('contains 52 unique routes with the audited 45/7 attribution split', () => { + it('contains 54 unique routes with the audited 47/7 attribution split', () => { const keys = legacySessionTelemetryRoutes.map( ({ method, path }) => `${method} ${path}`, ); - expect(keys).toHaveLength(52); - expect(new Set(keys).size).toBe(52); + expect(keys).toHaveLength(54); + expect(new Set(keys).size).toBe(54); expect( legacySessionTelemetryRoutes.filter( ({ attribution }) => attribution === 'handler_resolved', ), - ).toHaveLength(45); + ).toHaveLength(47); expect( legacySessionTelemetryRoutes.filter( ({ attribution }) => attribution === 'pre_resolved', From 83a4ebda05df6da6c8f70f2c7dc5ce080d9ff02c Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sat, 8 Aug 2026 12:37:47 +0800 Subject: [PATCH 03/25] fix(cli): record the canonical visible turn result --- .../acp-integration/session/Session.test.ts | 251 ++++++++++++++++++ .../src/acp-integration/session/Session.ts | 72 +++-- .../rewrite/MessageRewriteMiddleware.test.ts | 52 +++- .../rewrite/MessageRewriteMiddleware.ts | 45 +++- .../acp-integration/session/rewrite/index.ts | 1 + 5 files changed, 386 insertions(+), 35 deletions(-) diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index e309a5b0339..ec12e8ab873 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -3911,6 +3911,257 @@ describe('Session', () => { ); }); + it('records only top-level main-answer text', async () => { + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + (async function* () { + await session.sendUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'subagent detail' }, + _meta: { parentToolCallId: 'subagent-call' }, + }); + await session.sendUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'background status' }, + _meta: { qwenDiscreteMessage: true }, + }); + await session.sendUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'slash output' }, + _meta: { source: 'slash_command' }, + }); + yield { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: 'main answer' }] } }], + }, + }; + })(), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'answer me' }], + }, + trustedContext, + ); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + resultText: 'main answer', + }), + ); + }); + + it('does not let oversized subagent text consume the main-answer cap', async () => { + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + (async function* () { + await session.sendUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { + type: 'text', + text: 'x'.repeat(core.TURN_RESULT_TEXT_MAX_CHARS + 1), + }, + _meta: { parentToolCallId: 'subagent-call' }, + }); + yield { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: 'main answer' }] } }], + }, + }; + })(), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'answer me' }], + }, + trustedContext, + ); + + const payload = + mockChatRecordingService.recordTurnResult.mock.calls[0][0]; + expect(payload.resultText).toBe('main answer'); + expect(payload.resultTruncated).toBeUndefined(); + }); + + it('stores rewritten main text instead of appending it to raw text', async () => { + ( + mockSettings.user as { originalSettings?: Record } + ).originalSettings = { + messageRewrite: { + enabled: true, + target: 'message', + prompt: 'rewrite', + }, + }; + session.installRewriter(); + const rewrite = vi.fn().mockResolvedValue('rewritten answer'); + ( + session.messageRewriter as unknown as { + rewriter: { rewrite: typeof rewrite }; + } + ).rewriter.rewrite = rewrite; + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: 'raw answer' }] } }], + usageMetadata: { + promptTokenCount: 1, + candidatesTokenCount: 1, + totalTokenCount: 2, + }, + }, + }, + ]), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'answer me' }], + }, + trustedContext, + ); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ resultText: 'rewritten answer' }), + ); + }); + + it.each([ + ['empty output', () => Promise.resolve('')], + ['rewrite failure', () => Promise.reject(new Error('rewrite failed'))], + ])('falls back to raw main text on %s', async (_label, rewriteImpl) => { + ( + mockSettings.user as { originalSettings?: Record } + ).originalSettings = { + messageRewrite: { + enabled: true, + target: 'message', + prompt: 'rewrite', + }, + }; + session.installRewriter(); + const rewrite = vi.fn().mockImplementation(rewriteImpl); + ( + session.messageRewriter as unknown as { + rewriter: { rewrite: typeof rewrite }; + } + ).rewriter.rewrite = rewrite; + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: 'raw answer' }] } }], + usageMetadata: { + promptTokenCount: 1, + candidatesTokenCount: 1, + totalTokenCount: 2, + }, + }, + }, + ]), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'answer me' }], + }, + trustedContext, + ); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ resultText: 'raw answer' }), + ); + }); + + it('does not attribute a delayed rewrite to another prompt', async () => { + ( + mockSettings.user as { originalSettings?: Record } + ).originalSettings = { + messageRewrite: { + enabled: true, + target: 'message', + prompt: 'rewrite', + }, + }; + session.installRewriter(); + const rewrite = vi.fn().mockResolvedValue(''); + const middleware = session.messageRewriter as unknown as { + rewriter: { rewrite: typeof rewrite }; + sendUpdate: ( + update: SessionUpdate, + context: { + ownerPromptId: string; + turnIndex: number; + rewritten: boolean; + }, + ) => Promise; + }; + middleware.rewriter.rewrite = rewrite; + let releaseStream!: () => void; + const streamGate = new Promise((resolve) => { + releaseStream = resolve; + }); + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + (async function* () { + await streamGate; + yield { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { content: { parts: [{ text: 'prompt B answer' }] } }, + ], + usageMetadata: { + promptTokenCount: 1, + candidatesTokenCount: 1, + totalTokenCount: 2, + }, + }, + }; + })(), + ); + const prompt = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'prompt B' }], + }, + { ...trustedContext, promptId: 'prompt-b' }, + ); + await vi.waitFor(() => + expect(mockChat.sendMessageStream).toHaveBeenCalledOnce(), + ); + + await middleware.sendUpdate( + { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'late prompt A rewrite' }, + _meta: { rewritten: true, turnIndex: 1 }, + }, + { + ownerPromptId: 'prompt-a', + turnIndex: 1, + rewritten: true, + }, + ); + releaseStream(); + await prompt; + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'prompt-b', + resultText: 'prompt B answer', + }), + ); + }); + it('caps resultText at TURN_RESULT_TEXT_MAX_CHARS and flags truncation', async () => { const longText = 'a'.repeat(core.TURN_RESULT_TEXT_MAX_CHARS + 100); mockChat.sendMessageStream = vi.fn().mockResolvedValue( diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index cf0091db89d..82a19afc23d 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -303,6 +303,7 @@ import { import { MessageRewriteMiddleware, loadRewriteConfig, + type MessageRewriteEmissionContext, } from './rewrite/index.js'; import { DaemonTodoStopGuard, @@ -786,8 +787,8 @@ type InFlightTurnRecording = { startedAt: number; promptText: string; promptTextTruncated: boolean; - resultText: string; - resultTruncated: boolean; + resultSegments: Map; + nextDirectResultSegmentId: number; }; function truncateTurnText(text: string): { @@ -2484,7 +2485,8 @@ export class Session implements SessionContext { this.messageRewriter = new MessageRewriteMiddleware( this.config, rewriteConfig, - (update) => this.sendUpdate(update), + (update, context) => this.#deliverUpdate(update, context), + () => this.#turnRecording?.promptId, ); } } @@ -4871,7 +4873,14 @@ export class Session implements SessionContext { } async sendUpdate(update: SessionUpdate): Promise { - this.#accumulateTurnResultText(update); + await this.#deliverUpdate(update); + } + + async #deliverUpdate( + update: SessionUpdate, + rewriteContext?: MessageRewriteEmissionContext, + ): Promise { + this.#accumulateTurnResultText(update, rewriteContext); const params: SessionNotification = { sessionId: this.sessionId, update: projectAcpToolResultUpdate(update), @@ -4952,17 +4961,19 @@ export class Session implements SessionContext { startedAt: Date.now(), promptText: text, promptTextTruncated: truncated, - resultText: '', - resultTruncated: false, + resultSegments: new Map(), + nextDirectResultSegmentId: 0, }; } /** - * Accumulate streamed agent text into the in-flight turn record. Only - * `agent_message_chunk` text counts — tool output and thought chunks are - * excluded by design (the result is the assistant's own words). + * Capture the top-level answer shown to the user. Rewrite emissions replace + * their raw segment; subagent and discrete output never consumes the cap. */ - #accumulateTurnResultText(update: SessionUpdate): void { + #accumulateTurnResultText( + update: SessionUpdate, + rewriteContext?: MessageRewriteEmissionContext, + ): void { const recording = this.#turnRecording; if (!recording || update.sessionUpdate !== 'agent_message_chunk') { return; @@ -4971,17 +4982,33 @@ export class Session implements SessionContext { if (content.type !== 'text' || content.text.length === 0) { return; } - if (recording.resultText.length >= TURN_RESULT_TEXT_MAX_CHARS) { - recording.resultTruncated = true; + const meta = update._meta; + if ( + meta?.['parentToolCallId'] !== undefined || + meta?.['qwenDiscreteMessage'] === true || + meta?.['source'] === 'slash_command' + ) { return; } - const remaining = TURN_RESULT_TEXT_MAX_CHARS - recording.resultText.length; - if (content.text.length > remaining) { - recording.resultText += content.text.slice(0, remaining); - recording.resultTruncated = true; + if ( + rewriteContext?.ownerPromptId !== undefined && + rewriteContext.ownerPromptId !== recording.promptId + ) { + return; + } + + const segmentKey = rewriteContext + ? `rewrite:${rewriteContext.turnIndex}` + : `direct:${recording.nextDirectResultSegmentId++}`; + const segment = recording.resultSegments.get(segmentKey) ?? { + rawText: '', + }; + if (rewriteContext?.rewritten) { + segment.rewrittenText = (segment.rewrittenText ?? '') + content.text; } else { - recording.resultText += content.text; + segment.rawText += content.text; } + recording.resultSegments.set(segmentKey, segment); } /** @@ -5002,6 +5029,11 @@ export class Session implements SessionContext { if (recording === null) { return; } + const selectedResult = truncateTurnText( + [...recording.resultSegments.values()] + .map(({ rawText, rewrittenText }) => rewrittenText ?? rawText) + .join(''), + ); const payload: TurnResultRecordPayload = { promptId: recording.promptId, state, @@ -5013,10 +5045,10 @@ export class Session implements SessionContext { endedAt: Date.now(), promptText: recording.promptText, ...(recording.promptTextTruncated ? { promptTextTruncated: true } : {}), - ...(recording.resultText.length > 0 - ? { resultText: recording.resultText } + ...(selectedResult.text.length > 0 + ? { resultText: selectedResult.text } : {}), - ...(recording.resultTruncated ? { resultTruncated: true } : {}), + ...(selectedResult.truncated ? { resultTruncated: true } : {}), ...(recording.originatorClientId !== undefined ? { originatorClientId: recording.originatorClientId } : {}), diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts index de03503d627..b8edea424ac 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts @@ -33,12 +33,14 @@ const { MessageRewriteMiddleware } = await import( function createMiddleware( target: 'message' | 'thought' | 'all' = 'all', sendUpdate?: ReturnType, + getOwnerPromptId?: () => string | undefined, ) { const mockSendUpdate = sendUpdate ?? vi.fn().mockResolvedValue(undefined); const middleware = new MessageRewriteMiddleware( {} as Config, { enabled: true, target, prompt: 'test prompt' }, mockSendUpdate, + getOwnerPromptId ?? (() => undefined), ); return { middleware, mockSendUpdate }; } @@ -68,7 +70,10 @@ describe('MessageRewriteMiddleware', () => { } as unknown as SessionUpdate; await middleware.interceptUpdate(msgUpdate); - expect(mockSendUpdate).toHaveBeenCalledWith(msgUpdate); + expect(mockSendUpdate).toHaveBeenCalledWith(msgUpdate, { + turnIndex: 1, + rewritten: false, + }); }); }); @@ -91,11 +96,15 @@ describe('MessageRewriteMiddleware', () => { await middleware.flushTurn(); await middleware.waitForPendingRewrites(); - expect(mockSendUpdate).toHaveBeenNthCalledWith(3, { - sessionUpdate: 'agent_message_chunk', - content: { type: 'text', text: 'rewritten text' }, - _meta: { rewritten: true, turnIndex: 1 }, - }); + expect(mockSendUpdate).toHaveBeenNthCalledWith( + 3, + { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'rewritten text' }, + _meta: { rewritten: true, turnIndex: 1 }, + }, + { turnIndex: 1, rewritten: true }, + ); const { LlmRewriter } = await import('./LlmRewriter.js'); const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { @@ -219,6 +228,37 @@ describe('MessageRewriteMiddleware', () => { }); describe('rewrite metadata', () => { + it('keeps prompt ownership in callback context instead of wire metadata', async () => { + const { middleware, mockSendUpdate } = createMiddleware( + 'message', + undefined, + () => 'prompt-a', + ); + const original = { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'raw answer' }, + } as unknown as SessionUpdate; + + await middleware.interceptUpdate(original); + await middleware.flushTurn(); + await middleware.waitForPendingRewrites(); + + expect(mockSendUpdate.mock.calls).toEqual([ + [ + original, + { ownerPromptId: 'prompt-a', turnIndex: 1, rewritten: false }, + ], + [ + { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'rewritten text' }, + _meta: { rewritten: true, turnIndex: 1 }, + }, + { ownerPromptId: 'prompt-a', turnIndex: 1, rewritten: true }, + ], + ]); + }); + it('should emit rewritten message with _meta.rewritten=true', async () => { const { middleware, mockSendUpdate } = createMiddleware(); diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts index 5edb0daa754..8b7c9c7e981 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts @@ -35,6 +35,12 @@ const DEFAULT_REWRITE_TIMEOUT_MS = 30_000; // rewritten message's _meta. const REWRITE_META_EXCLUDED_KEYS = new Set([]); +export interface MessageRewriteEmissionContext { + ownerPromptId?: string; + turnIndex: number; + rewritten: boolean; +} + export class MessageRewriteMiddleware { private readonly turnBuffer: TurnBuffer; private readonly rewriter: LlmRewriter; @@ -42,11 +48,17 @@ export class MessageRewriteMiddleware { private readonly timeoutMs: number; private turnIndex = 0; private turnMeta: Record | undefined; + private turnOwnerPromptId: string | undefined; constructor( config: Config, rewriteConfig: MessageRewriteConfig, - private readonly sendUpdate: (update: SessionUpdate) => Promise, + private readonly sendUpdate: ( + update: SessionUpdate, + context?: MessageRewriteEmissionContext, + ) => Promise, + private readonly getOwnerPromptId: () => string | undefined = () => + undefined, ) { this.turnBuffer = new TurnBuffer(); this.rewriter = new LlmRewriter(config, rewriteConfig); @@ -84,9 +96,14 @@ export class MessageRewriteMiddleware { | Record | undefined; const text = content?.['text'] ?? ''; + const ownerPromptId = this.getOwnerPromptId(); // Always send original message as-is - await this.sendUpdate(update); + await this.sendUpdate(update, { + ...(ownerPromptId !== undefined ? { ownerPromptId } : {}), + turnIndex: this.turnIndex + 1, + rewritten: false, + }); if ( updateType === 'agent_message_chunk' && @@ -113,6 +130,7 @@ export class MessageRewriteMiddleware { if (didAccumulate) { this.captureTurnMeta(updateRecord); + this.turnOwnerPromptId ??= ownerPromptId; } } @@ -132,7 +150,9 @@ export class MessageRewriteMiddleware { async flushTurn(signal?: AbortSignal): Promise { const content = this.turnBuffer.flush(); const turnMeta = this.turnMeta; + const ownerPromptId = this.turnOwnerPromptId; this.turnMeta = undefined; + this.turnOwnerPromptId = undefined; if (!content) return; this.turnIndex++; @@ -158,15 +178,22 @@ export class MessageRewriteMiddleware { ); // Emit rewritten message with special _meta - await this.sendUpdate({ - sessionUpdate: 'agent_message_chunk', - content: { type: 'text', text: rewritten }, - _meta: { - ...turnMeta, - rewritten: true, + await this.sendUpdate( + { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: rewritten }, + _meta: { + ...turnMeta, + rewritten: true, + turnIndex: turnIdx, + }, + } as SessionUpdate, + { + ...(ownerPromptId !== undefined ? { ownerPromptId } : {}), turnIndex: turnIdx, + rewritten: true, }, - } as SessionUpdate); + ); } catch (error) { debugLogger.warn( `Turn ${turnIdx}: rewrite failed: ${error instanceof Error ? error.message : String(error)}`, diff --git a/packages/cli/src/acp-integration/session/rewrite/index.ts b/packages/cli/src/acp-integration/session/rewrite/index.ts index 40b18c241f7..108b83b2b97 100644 --- a/packages/cli/src/acp-integration/session/rewrite/index.ts +++ b/packages/cli/src/acp-integration/session/rewrite/index.ts @@ -5,5 +5,6 @@ */ export { MessageRewriteMiddleware } from './MessageRewriteMiddleware.js'; +export type { MessageRewriteEmissionContext } from './MessageRewriteMiddleware.js'; export { loadRewriteConfig } from './config.js'; export type { MessageRewriteConfig, TurnContent } from './types.js'; From 9dd87669f7a0eab5c8440f8b14779bbbcb159ca2 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sat, 8 Aug 2026 12:43:56 +0800 Subject: [PATCH 04/25] fix(acp-bridge): keep terminal turn status monotonic --- packages/acp-bridge/src/bridge.test.ts | 249 ++++++++++++++++++++++++- packages/acp-bridge/src/bridge.ts | 152 +++++++++++++-- 2 files changed, 377 insertions(+), 24 deletions(-) diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index bd64aafb195..3b034a9db0c 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -8245,6 +8245,232 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('keeps a completed turn pollable before its transcript record appears', async () => { + const handle = makeChannel({ + promptImpl: () => ({ stopReason: 'end_turn' }), + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { v: 1, sessionId: 'ignored', turnResult: null }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + + await bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'answer before persistence' }], + }, + undefined, + { promptId: 'prompt-complete-overlay' }, + ); + + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-complete-overlay', + ), + ).resolves.toMatchObject({ + sessionId: session.sessionId, + state: 'completed', + promptId: 'prompt-complete-overlay', + promptText: 'answer before persistence', + stopReason: 'end_turn', + }); + await expect( + bridge.getSessionTurnStatus(session.sessionId), + ).resolves.toMatchObject({ + state: 'completed', + promptId: 'prompt-complete-overlay', + }); + await bridge.shutdown(); + }); + + it('reports removed queued and running prompts as cancelled immediately', async () => { + let rejectRunning: ((err: Error) => void) | undefined; + const runningGate = new Promise((_resolve, reject) => { + rejectRunning = reject; + }); + const handle = makeChannel({ + promptImpl: (request) => + (request.prompt[0] as { text?: string }).text === 'running' + ? runningGate + : { stopReason: 'end_turn' }, + cancelImpl: () => { + rejectRunning?.(new Error('cancelled')); + }, + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { v: 1, sessionId: 'ignored', turnResult: null }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const running = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'running' }], + }, + undefined, + { promptId: 'prompt-remove-running' }, + ); + const queued = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-remove-queued' }, + ); + + await vi.waitFor(() => { + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(2); + }); + expect( + bridge.removePendingPrompt(session.sessionId, 'prompt-remove-queued'), + ).toEqual({ removed: true }); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-remove-queued', + ), + ).resolves.toMatchObject({ + state: 'cancelled', + stopReason: 'cancelled', + }); + + expect( + bridge.removePendingPrompt(session.sessionId, 'prompt-remove-running'), + ).toEqual({ removed: true }); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-remove-running', + ), + ).resolves.toMatchObject({ + state: 'cancelled', + stopReason: 'cancelled', + }); + + await expect(running).rejects.toBeDefined(); + await expect(queued).rejects.toMatchObject({ name: 'AbortError' }); + await bridge.shutdown(); + }); + + it('preserves a deadline error while enriching it from persistence', async () => { + let persistedResult: Record | null = null; + const handle = makeChannel({ + promptImpl: () => new Promise(() => {}), + cancelImpl: () => new Promise(() => {}), + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { + v: 1, + sessionId: 'ignored', + turnResult: persistedResult, + }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + + await expect( + bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'times out' }], + }, + undefined, + { promptId: 'prompt-deadline-overlay', deadlineMs: 20 }, + ), + ).rejects.toBeInstanceOf(PromptDeadlineExceededError); + + persistedResult = { + promptId: 'prompt-deadline-overlay', + state: 'cancelled', + stopReason: 'cancelled', + startedAt: 1000, + endedAt: 2000, + promptText: 'times out', + resultText: 'partial visible answer', + }; + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-deadline-overlay', + ), + ).resolves.toMatchObject({ + state: 'error', + error: { code: 'prompt_deadline_exceeded' }, + resultText: 'partial visible answer', + }); + await bridge.shutdown(); + }); + + it('bounds transient terminal statuses by eventRingSize', async () => { + const handle = makeChannel({ + promptImpl: () => ({ stopReason: 'end_turn' }), + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { v: 1, sessionId: 'ignored', turnResult: null }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + eventRingSize: 2, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + + for (const promptId of ['prompt-old', 'prompt-middle', 'prompt-new']) { + await bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: promptId }], + }, + undefined, + { promptId }, + ); + } + + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-old'), + ).resolves.toBeUndefined(); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-middle', + ), + ).resolves.toMatchObject({ state: 'completed' }); + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-new'), + ).resolves.toMatchObject({ state: 'completed' }); + await bridge.shutdown(); + }); + it('throws SessionNotFoundError for unknown sessions', async () => { const bridge = makeBridge(); await expect(bridge.getSessionTurnStatus('unknown')).rejects.toThrow( @@ -8638,7 +8864,7 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); - it('still publishes a terminal for a removed RUNNING prompt when the session closes before the agent cooperates', async () => { + it('keeps a removed RUNNING prompt cancelled when the session closes before the agent cooperates', async () => { const handle = wedgeChannel(); const bridge = makeBridge({ channelFactory: async () => handle.channel }); const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); @@ -8657,8 +8883,8 @@ describe('createAcpSessionBridge', () => { p1.catch(() => {}); await new Promise((r) => setTimeout(r, 20)); - // Remove the RUNNING prompt — the wedged agent ignores the cancel, - // so no terminal has been published yet. + // Remove the RUNNING prompt — the wedged agent ignores the cancel, but + // removal itself is already the authoritative cancelled outcome. expect( bridge.removePendingPrompt(session.sessionId, 'prompt-removed-running'), ).toEqual({ removed: true }); @@ -8668,19 +8894,24 @@ describe('createAcpSessionBridge', () => { expect( bridge.removePendingPrompt(session.sessionId, 'prompt-removed-running'), ).toEqual({ removed: false }); - expect(terminalsFor(events, 'prompt-removed-running')).toHaveLength(0); + await vi.waitFor(() => { + const removedTerms = terminalsFor(events, 'prompt-removed-running'); + expect(removedTerms).toHaveLength(1); + expect(removedTerms[0]?.type).toBe('turn_complete'); + expect( + (removedTerms[0]?.data as { stopReason?: string }).stopReason, + ).toBe('cancelled'); + }); - // Session closes before the agent ever settles: the teardown flush - // must still see the removed-but-unsettled prompt and publish its - // terminal before the bus closes. + // Session close races the uncooperative agent but must not replace the + // already-published cancellation with a teardown error. await bridge.closeSession(session.sessionId); const closedIdx = events.findIndex((e) => e.type === 'session_closed'); expect(closedIdx).toBeGreaterThan(-1); const terms = terminalsFor(events, 'prompt-removed-running'); expect(terms).toHaveLength(1); - expect(terms[0]?.type).toBe('turn_error'); - expect((terms[0]?.data as { code?: string }).code).toBe('session_closed'); + expect(terms[0]?.type).toBe('turn_complete'); expect(events.indexOf(terms[0]!)).toBeLessThan(closedIdx); await bridge.shutdown(); }); diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index d66b58e8a28..e8a05f9eb24 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -530,6 +530,14 @@ interface SessionEntry { * tail of `sendPrompt`. */ pendingPromptList: PendingPromptEntry[]; + /** + * Bounded bridge-owned terminal overlay. Formal terminal events are + * published before the agent's transcript writer is guaranteed to expose + * the matching `turn_result`, so polling consults this map to avoid a + * transient terminal-to-404 regression. + */ + terminalTurnStatuses: Map; + terminalTurnStatusLimit: number; /** Bridge prompt that owns the child Guard wait for this FIFO. */ todoStopGuardAwaitingQueuedPromptOwnerPromptId?: string; /** @@ -1192,6 +1200,66 @@ type PromptTerminal = | { kind: 'cancelled' } | { kind: 'error'; err: unknown }; +function truncateTurnText(text: string): { + text: string; + truncated: boolean; +} { + const truncated = text.length > TURN_RESULT_TEXT_MAX_CHARS; + return { + text: truncated ? text.slice(0, TURN_RESULT_TEXT_MAX_CHARS) : text, + truncated, + }; +} + +function rememberTerminalTurnStatus( + entry: SessionEntry, + pendingEntry: PendingPromptEntry, + terminal: PromptTerminal, +): void { + const promptText = truncateTurnText(pendingEntry.text); + const shared = { + sessionId: entry.sessionId, + promptId: pendingEntry.promptId, + promptText: promptText.text, + ...(promptText.truncated ? { promptTextTruncated: true } : {}), + queuedAt: pendingEntry.queuedAt, + ...(pendingEntry.startedAt !== undefined + ? { startedAt: pendingEntry.startedAt } + : {}), + endedAt: Date.now(), + ...(pendingEntry.originatorClientId !== undefined + ? { originatorClientId: pendingEntry.originatorClientId } + : {}), + }; + let status: BridgeTurnStatus; + if (terminal.kind === 'complete') { + const stopReason = terminal.result.stopReason; + status = { + ...shared, + state: stopReason === 'cancelled' ? 'cancelled' : 'completed', + ...(stopReason !== undefined ? { stopReason } : {}), + }; + } else if (terminal.kind === 'cancelled') { + status = { ...shared, state: 'cancelled', stopReason: 'cancelled' }; + } else { + const code = extractErrorCode(terminal.err); + status = { + ...shared, + state: 'error', + error: { + message: extractErrorMessage(terminal.err), + ...(code !== undefined ? { code } : {}), + }, + }; + } + entry.terminalTurnStatuses.set(pendingEntry.promptId, status); + while (entry.terminalTurnStatuses.size > entry.terminalTurnStatusLimit) { + const oldestPromptId = entry.terminalTurnStatuses.keys().next().value; + if (oldestPromptId === undefined) break; + entry.terminalTurnStatuses.delete(oldestPromptId); + } +} + /** * Publish the formal terminal event for an accepted prompt exactly once. * All terminal paths (agent settle, queued removal, deadline, session @@ -1217,6 +1285,7 @@ function publishPromptTerminal( return; } pendingEntry.terminalPublished = true; + rememberTerminalTurnStatus(entry, pendingEntry, terminal); const originatorClientId = pendingEntry.originatorClientId; if (terminal.kind === 'complete') { broadcastTurnComplete( @@ -1330,15 +1399,13 @@ function liveTurnStatus( // Mirror the settled-record contract: `promptText` is capped at // TURN_RESULT_TEXT_MAX_CHARS with the paired truncation flag, so the // same promptId reports a consistent shape before and after settle. - const promptTextTruncated = pending.text.length > TURN_RESULT_TEXT_MAX_CHARS; + const promptText = truncateTurnText(pending.text); return { sessionId, state: pending.state === 'running' ? 'running' : 'queued', promptId: pending.promptId, - promptText: promptTextTruncated - ? pending.text.slice(0, TURN_RESULT_TEXT_MAX_CHARS) - : pending.text, - ...(promptTextTruncated ? { promptTextTruncated: true } : {}), + promptText: promptText.text, + ...(promptText.truncated ? { promptTextTruncated: true } : {}), queuedAt: pending.queuedAt, ...(pending.startedAt !== undefined ? { startedAt: pending.startedAt } @@ -1386,6 +1453,43 @@ function settledTurnStatus( }; } +/** + * Keep the bridge's exactly-once formal outcome authoritative while allowing + * the durable transcript record to fill in content recorded slightly later. + */ +function enrichTerminalTurnStatus( + terminal: BridgeTurnStatus, + persisted: BridgeTurnStatus, +): BridgeTurnStatus { + return { + ...terminal, + ...(persisted.promptText !== undefined + ? { promptText: persisted.promptText } + : {}), + ...(persisted.promptTextTruncated !== undefined + ? { promptTextTruncated: persisted.promptTextTruncated } + : {}), + ...(persisted.resultText !== undefined + ? { resultText: persisted.resultText } + : {}), + ...(persisted.resultTruncated !== undefined + ? { resultTruncated: persisted.resultTruncated } + : {}), + ...(terminal.originatorClientId === undefined && + persisted.originatorClientId !== undefined + ? { originatorClientId: persisted.originatorClientId } + : {}), + }; +} + +function latestTerminalTurnStatus( + entry: SessionEntry, +): BridgeTurnStatus | undefined { + let latest: BridgeTurnStatus | undefined; + for (const status of entry.terminalTurnStatuses.values()) latest = status; + return latest; +} + const DEFAULT_INIT_TIMEOUT_MS = 10_000; const PERSIST_TIMEOUT_MS = 5_000; // Bounded retries for the sub-session `parentSessionId` transcript write on the @@ -4040,6 +4144,8 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { promptQueue: Promise.resolve(), pendingPromptCount: 0, pendingPromptList: [], + terminalTurnStatuses: new Map(), + terminalTurnStatusLimit: eventRingSize, midTurnMessageQueue: [], modelChangeQueue: Promise.resolve(), approvalModeQueue: Promise.resolve(), @@ -7896,8 +8002,28 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { }>(sessionId, SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { ...(promptId !== undefined ? { promptId } : {}), }); - if (result.turnResult) { - return settledTurnStatus(sessionId, result.turnResult); + const persisted = result.turnResult + ? settledTurnStatus(sessionId, result.turnResult) + : undefined; + if (promptId !== undefined) { + const terminal = entry.terminalTurnStatuses.get(promptId); + if (terminal && persisted) { + return enrichTerminalTurnStatus(terminal, persisted); + } + if (terminal) return terminal; + if (persisted) return persisted; + } else { + const terminal = latestTerminalTurnStatus(entry); + if (terminal && persisted && persisted.promptId === terminal.promptId) { + return enrichTerminalTurnStatus(terminal, persisted); + } + if (terminal && persisted) { + return (terminal.endedAt ?? 0) >= (persisted.endedAt ?? 0) + ? terminal + : persisted; + } + if (terminal) return terminal; + if (persisted) return persisted; } if (promptId !== undefined) { // Neither the live queue nor the transcript knows this prompt. @@ -7959,14 +8085,10 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { } catch { /* bus may be closed during session teardown */ } - // DAEMON-004: a deleted QUEUED prompt never dispatches, so nothing - // downstream would ever emit its formal terminal — publish the - // `cancelled` turn_complete now. Running prompts keep the existing - // cooperative cancel path (agent returns cancelled → turn_complete); - // the FIFO node's later AbortError is deduped by the latch. - if (target.state === 'queued') { - publishPromptTerminal(entry, target, { kind: 'cancelled' }); - } + // Publish immediately for both states so status polling cannot regress + // from queued/running to unknown while cooperative cancellation drains. + // The FIFO node's later terminal is deduped by the latch. + publishPromptTerminal(entry, target, { kind: 'cancelled' }); return { removed: true }; }, From 6153384a7e3372ce03baa61d03d54bb7d169abaf Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sat, 8 Aug 2026 12:49:05 +0800 Subject: [PATCH 05/25] fix(serve): bound turn status transcript scans --- .../cli/src/acp-integration/acpAgent.test.ts | 143 ++++++++++++++++++ packages/cli/src/acp-integration/acpAgent.ts | 1 + packages/cli/src/serve/server.test.ts | 33 +++- 3 files changed, 175 insertions(+), 2 deletions(-) diff --git a/packages/cli/src/acp-integration/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts index 2f0817c691e..c31157d2d7a 100644 --- a/packages/cli/src/acp-integration/acpAgent.test.ts +++ b/packages/cli/src/acp-integration/acpAgent.test.ts @@ -844,6 +844,7 @@ import { SessionTranscriptSnapshotUnavailableError, SessionTranscriptTooLargeError, SessionTranscriptPageTooLargeError, + SESSION_TRANSCRIPT_MAX_PAGE_BYTES, encodeSessionTranscriptCursor, unregisterGoalHook, getActiveGoal, @@ -8871,6 +8872,148 @@ describe('QwenAgent MCP SSE/HTTP support', () => { promptId: 'prompt-1', }), ).resolves.toEqual({ v: 1, sessionId, turnResult }); + expect(readPage).toHaveBeenCalledWith(sessionId, { + direction: 'backward', + limit: 500, + maxBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES, + }); + + mockConnectionState.resolve(); + await agentPromise; + }); + + it('paginates bounded turn_result scans until the promptId matches', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const cursorState = { + v: 1 as const, + sessionId, + fileIdentity: { dev: 1, ino: 2 }, + snapshotSize: 200, + position: 100, + leafUuid: 'leaf-1', + startTime: 'start', + lastUpdated: 'end', + }; + const requestedTurn = { + promptId: 'prompt-requested', + state: 'completed', + stopReason: 'end_turn', + startedAt: 3000, + endedAt: 4000, + resultText: 'requested answer', + }; + const readPage = vi + .fn() + .mockResolvedValueOnce({ + sessionId, + records: [ + { + type: 'system', + subtype: 'turn_result', + systemPayload: { + promptId: 'prompt-newer', + state: 'completed', + startedAt: 5000, + endedAt: 6000, + }, + }, + ], + hasMore: true, + nextCursorState: cursorState, + gaps: [], + startTime: 'start', + lastUpdated: 'end', + }) + .mockResolvedValueOnce({ + sessionId, + records: [ + { + type: 'system', + subtype: 'turn_result', + systemPayload: requestedTurn, + }, + ], + hasMore: false, + gaps: [], + startTime: 'start', + lastUpdated: 'end', + }); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: requestedTurn.promptId, + }), + ).resolves.toEqual({ v: 1, sessionId, turnResult: requestedTurn }); + const encodedCursor = Buffer.from( + JSON.stringify(cursorState), + 'utf8', + ).toString('base64url'); + expect(readPage).toHaveBeenNthCalledWith(2, sessionId, { + cursor: encodedCursor, + limit: 500, + maxBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES, + }); + + mockConnectionState.resolve(); + await agentPromise; + }); + + it('propagates oversized pages from bounded turn_result scans', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const pageError = new SessionTranscriptPageTooLargeError( + sessionId, + SESSION_TRANSCRIPT_MAX_PAGE_BYTES + 1, + SESSION_TRANSCRIPT_MAX_PAGE_BYTES, + ); + const readPage = vi.fn().mockRejectedValue(pageError); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: 'prompt-1', + }), + ).rejects.toBe(pageError); mockConnectionState.resolve(); await agentPromise; diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index 16faf722670..e4b61717ccd 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -394,6 +394,7 @@ async function findSettledTurnResult( ? { cursor } : { direction: 'backward' as const }), limit: TURN_STATUS_SCAN_PAGE_LIMIT, + maxBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES, }); // Backward pages hold the newest slice; walk from the tail so the most // recent settled turn wins. diff --git a/packages/cli/src/serve/server.test.ts b/packages/cli/src/serve/server.test.ts index 2348946f6b0..6a8bac50d20 100644 --- a/packages/cli/src/serve/server.test.ts +++ b/packages/cli/src/serve/server.test.ts @@ -916,7 +916,11 @@ interface FakeBridge extends AcpSessionBridge { NonNullable >[0]; calls: BridgeSpawnRequest[]; - getSessionTurnStatusCalls: Array<{ sessionId: string; promptId?: string }>; + getSessionTurnStatusCalls: Array<{ + sessionId: string; + context?: BridgeClientRequestContext; + promptId?: string; + }>; loadCalls: BridgeRestoreSessionRequest[]; resumeCalls: BridgeRestoreSessionRequest[]; promptCalls: Array<{ @@ -1151,6 +1155,7 @@ function fakeBridge(opts: FakeBridgeOpts = {}): FakeBridge { opts.removePendingPromptImpl ?? (() => ({ removed: true })); const getSessionTurnStatusCalls: Array<{ sessionId: string; + context?: BridgeClientRequestContext; promptId?: string; }> = []; const getSessionTurnStatusImpl = @@ -2140,6 +2145,7 @@ function fakeBridge(opts: FakeBridgeOpts = {}): FakeBridge { async getSessionTurnStatus(sessionId, context, promptId) { getSessionTurnStatusCalls.push({ sessionId, + ...(context !== undefined ? { context } : {}), ...(promptId !== undefined ? { promptId } : {}), }); return getSessionTurnStatusImpl(sessionId, context, promptId); @@ -9296,7 +9302,8 @@ describe('createServeApp', () => { const res = await request(turnsApp(bridge)) .get('/session/s-1/turns/p-1') .set('Host', `127.0.0.1:${baseOpts.port}`) - .set('Authorization', 'Bearer secret'); + .set('Authorization', 'Bearer secret') + .set('X-Qwen-Client-Id', 'client-1'); expect(res.status).toBe(200); expect(res.body).toMatchObject({ sessionId: 's-1', @@ -9305,6 +9312,28 @@ describe('createServeApp', () => { stopReason: 'end_turn', resultText: 'done', }); + expect(bridge.getSessionTurnStatusCalls).toEqual([ + { + sessionId: 's-1', + context: { clientId: 'client-1' }, + promptId: 'p-1', + }, + ]); + }); + + it('200 idle when current has no live or settled turn', async () => { + const bridge = fakeBridge({ + getSessionTurnStatusImpl: async (sessionId) => ({ + sessionId, + state: 'idle', + }), + }); + const res = await request(turnsApp(bridge)) + .get('/session/s-1/turns/current') + .set('Host', `127.0.0.1:${baseOpts.port}`) + .set('Authorization', 'Bearer secret'); + expect(res.status).toBe(200); + expect(res.body).toEqual({ sessionId: 's-1', state: 'idle' }); }); it('404 prompt_not_found when the bridge resolves nothing', async () => { From 22cccee6a21b86876c2a5428f039f23e7fc74a93 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sat, 8 Aug 2026 12:51:08 +0800 Subject: [PATCH 06/25] docs(serve): define pollable turn result semantics --- docs/design/daemon-turn-status-endpoint.md | 100 ++++++++++++--------- 1 file changed, 58 insertions(+), 42 deletions(-) diff --git a/docs/design/daemon-turn-status-endpoint.md b/docs/design/daemon-turn-status-endpoint.md index 2dded47068d..7d8ee1ed691 100644 --- a/docs/design/daemon-turn-status-endpoint.md +++ b/docs/design/daemon-turn-status-endpoint.md @@ -23,7 +23,7 @@ another runtime. nor the persisted transcript knows that promptId. - `GET /session/:id/turns/current` — status of the session's current turn: the running prompt, else the queued FIFO head, else the most recent - persisted outcome, else `{ state: 'idle' }`. + bridge terminal or persisted outcome, else `{ state: 'idle' }`. Shared errors: `404` unknown session (`SessionNotFoundError`), `400` `invalid_client_id` for a client id bound to another session. @@ -32,19 +32,14 @@ Shared errors: `404` unknown session (`SessionNotFoundError`), `400` ```json { - "sessionId": "…", - "state": "idle | queued | running | completed | cancelled | error", - "promptId": "…", - "promptText": "…", - "promptTextTruncated": false, - "queuedAt": 0, - "startedAt": 0, - "endedAt": 0, + "sessionId": "session-id", + "state": "completed", + "promptId": "prompt-id", + "promptText": "Summarize the build failure", + "startedAt": 1786152000000, + "endedAt": 1786152012000, "stopReason": "end_turn", - "error": { "message": "…", "code": "…" }, - "resultText": "…", - "resultTruncated": false, - "originatorClientId": "…" + "resultText": "The build failed because the route catalog assertion is stale." } ``` @@ -54,23 +49,30 @@ particular `promptTextTruncated` / `resultTruncated` are only present when - `queued` / `running` mirror the bridge's live `pendingPromptList` (`queuedAt` at admission, `startedAt` at FIFO dispatch). -- `completed` / `cancelled` / `error` mirror the persisted `turn_result` - record (`startedAt` / `endedAt`, `stopReason` for completions, `error` - for failures). A `stopReason` of `cancelled` is reported as - `state: 'cancelled'`. +- `completed` / `cancelled` / `error` come from the bridge's exactly-once + formal terminal while the daemon is live. A matching persisted + `turn_result` enriches that status with recorded content but cannot + overwrite its state, stop reason, error, or terminal timestamp. After a + daemon restart, settled state comes from the persisted record alone. A + `stopReason` of `cancelled` is reported as `state: 'cancelled'`. - `promptText` mirrors the pending-prompt extraction: first non-empty text - block, `[image]` for image-only prompts. `resultText` accumulates - `agent_message_chunk` text streamed during the turn (tool output and - thought chunks excluded by design). Both are capped at + block, `[image]` for image-only prompts. `resultText` is the canonical + top-level assistant answer visible to the user: subagent-owned chunks, + discrete messages, and slash-command output are excluded; when message + rewrite succeeds, rewritten text replaces the corresponding raw segment. + Tool, thought, background, and status output are also excluded. Rewrite + failure or an empty rewrite falls back to the raw top-level segment. Both + fields are capped at `TURN_RESULT_TEXT_MAX_CHARS` (32 KiB) with the paired `*Truncated` flag. + The result cap is applied after rewritten-versus-raw selection, so excluded + or replaced text does not consume the visible-answer budget. The cap applies to both projections: the live `queued` / `running` status caps `promptText` the same way the settled record does, so the same promptId reports a consistent shape before and after settlement. -## Persistence: reuse the transcript, no daemon memory +## Persistence and the terminal overlay -Settled outcomes must survive daemon restarts and must not require the -daemon to retain per-turn state. The agent therefore appends one +Settled outcomes survive daemon restarts by appending one `turn_result` system record to the EXISTING session transcript JSONL (`/chats/.jsonl`) through the existing `ChatRecordingService` append path — no new files, no new write machinery: @@ -82,8 +84,8 @@ daemon to retain per-turn state. The agent therefore appends one - `Session` accumulates the turn in flight (`#turnRecording`): the record is created at admission after `assertCanStartTurn()` for prompts carrying an invocation context (daemon-admitted prompts only — internal - cron/notification turns are not pollable), accumulates streamed agent - text in `sendUpdate`, and settles on every exit path (early + cron/notification turns are not pollable), accumulates canonical visible + answer segments in `sendUpdate`, and settles on every exit path (early admission-cancel, pendingSend-cancel, normal completion, thrown error). Each `prompt()` call captures its own record reference and settles that exact reference; the shared slot is only published once the predecessor @@ -91,9 +93,9 @@ daemon to retain per-turn state. The agent therefore appends one deadline overlaps (the bridge releases the FIFO while the agent is still executing the old turn) from misattributing one turn's outcome to the other turn's promptId. -- ACP per-session configs keep chat recording enabled by default, so every - daemon session writes its transcript; the top-level ACP process disabling - `chatRecording` does not affect sessions. +- Durable settled results require chat recording to be enabled for the + session. Live queue state and the recent terminal overlay remain available + while the daemon session is resident even when recording is unavailable. Reads go through the `qwen/control/session/turn_status` ext-method on the owning ACP child: it flushes the recording service (so a just-settled turn @@ -102,8 +104,16 @@ state still falls through to the scan), then scans the transcript backward from the tail with `SessionTranscriptReader` for `turn_result` records — exact `promptId` match, or the most recent record when no promptId is given. The scan is -bounded (10 pages x 500 records) so a pathological lookup cannot read a -huge transcript end to end. +bounded (10 pages x 500 records x 4 MiB per page) so a pathological lookup +cannot read a huge transcript end to end. Oversized pages fail the read; +they are not converted into a successful `turnResult: null` response. + +Transcript persistence is asynchronous relative to the bridge's formal +terminal event. To prevent a completed prompt from briefly regressing to +`prompt_not_found`, each live `SessionEntry` retains recent formal terminal +statuses in insertion order. The map is capped by the configured +`eventRingSize`; eviction only removes the transient overlay, so persisted +records remain queryable. ## Bridge resolution order @@ -113,9 +123,12 @@ huge transcript end to end. 2. Live state wins: a prompt on `pendingPromptList` (not removed) has not settled, so no record can exist for it. With `promptId`, exact match; without, the running entry, then the queued FIFO head. -3. Otherwise the ext-method above. A persisted record maps to the settled - states; `null` maps to `undefined` (with promptId → 404) or - `{ state: 'idle' }` (current). +3. Otherwise request the persisted record and consult the bounded terminal + overlay. For the same prompt, persisted prompt/result text enriches the + bridge terminal without changing its formal outcome. For `current`, the + newer `endedAt` wins when overlay and persistence refer to different + prompts. +4. If neither source has an outcome, return `undefined` (with promptId → 404) or `{ state: 'idle' }` (current). `PendingPromptEntry.startedAt` is stamped at FIFO dispatch (at creation for a prompt admitted straight to running). @@ -125,14 +138,17 @@ for a prompt admitted straight to running). - Turn settlement never depends on recording: `recordTurnResult` is best-effort, and the Session settle path swallows recording errors. - A transcript without `turn_result` records (session never settled a - daemon turn, or recording disabled/failed) simply yields `idle` / - `prompt_not_found`. -- A prompt removed from the pending list before it settles — cancelled - while still `queued`, or removed while `running` — never produces a - `turn_result` record: the SSE channel publishes the terminal - (`cancelled` / `removed`), but polling reports `404 prompt_not_found` - for that promptId from the removal on. This is intentional — removals - are not pollable — and consumers relying on those outcomes should use - the SSE channel. + daemon turn, or recording disabled/failed) can still return recent formal + outcomes from the live daemon overlay. After restart or overlay eviction, + an outcome that was never persisted yields `idle` / `prompt_not_found`. +- Removing either a queued or running prompt immediately publishes one + authoritative `cancelled` terminal and makes it pollable. Later agent + settlement or teardown cannot replace that outcome. +- A queued deadline publishes `error` with code + `prompt_deadline_exceeded`; polling moves directly from `queued` to that + error without an intermediate unknown result. +- A bridge deadline error remains authoritative if the agent later persists + a generic cancelled record; persisted `resultText` may still enrich the + error response. - The ext-method throws for non-live sessions; the bridge routes it only to the owning child. From 91b971ecf9713db8122cf77699caabcd279bf034 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sat, 8 Aug 2026 13:15:06 +0800 Subject: [PATCH 07/25] fix(serve): bound canonical turn result capture --- docs/design/daemon-turn-status-endpoint.md | 2 + packages/acp-bridge/src/bridgeTypes.ts | 14 ++-- .../acp-integration/session/Session.test.ts | 45 +++++++++++- .../src/acp-integration/session/Session.ts | 73 ++++++++++++++++--- packages/cli/src/serve/routes/session.ts | 3 +- 5 files changed, 114 insertions(+), 23 deletions(-) diff --git a/docs/design/daemon-turn-status-endpoint.md b/docs/design/daemon-turn-status-endpoint.md index 7d8ee1ed691..24ac4c8b32e 100644 --- a/docs/design/daemon-turn-status-endpoint.md +++ b/docs/design/daemon-turn-status-endpoint.md @@ -66,6 +66,8 @@ particular `promptTextTruncated` / `resultTruncated` are only present when `TURN_RESULT_TEXT_MAX_CHARS` (32 KiB) with the paired `*Truncated` flag. The result cap is applied after rewritten-versus-raw selection, so excluded or replaced text does not consume the visible-answer budget. + In-flight raw/rewrite candidates are separately bounded to 64 KiB and 256 + segments; loss of selected content at either bound sets `resultTruncated`. The cap applies to both projections: the live `queued` / `running` status caps `promptText` the same way the settled record does, so the same promptId reports a consistent shape before and after settlement. diff --git a/packages/acp-bridge/src/bridgeTypes.ts b/packages/acp-bridge/src/bridgeTypes.ts index 1c468e53a23..0339575f878 100644 --- a/packages/acp-bridge/src/bridgeTypes.ts +++ b/packages/acp-bridge/src/bridgeTypes.ts @@ -766,8 +766,9 @@ export interface PendingPromptSummary { /** * Pollable snapshot of one admitted prompt's turn, returned by * `getSessionTurnStatus`. `queued` / `running` mirror the live - * `pendingPromptList`; settled states mirror the `turn_result` record - * persisted in the session transcript by the agent. + * `pendingPromptList`; settled states come from the bridge's bounded formal + * terminal overlay and are enriched or restored from persisted `turn_result` + * records. */ export interface BridgeTurnStatus { sessionId: string; @@ -1058,10 +1059,11 @@ export interface AcpSessionBridge { /** * Return the pollable status of a turn. With `promptId`, resolves that * exact prompt: live `pendingPromptList` first (queued / running), then - * the agent's persisted `turn_result` records (completed / cancelled / - * error); resolves `undefined` when neither knows it. Without - * `promptId`, returns the current turn: the running prompt, the queued - * FIFO head, the most recent persisted outcome, or `state: 'idle'`. + * the bridge's recent formal terminal overlay and the agent's persisted + * `turn_result` records (completed / cancelled / error); resolves + * `undefined` when none knows it. Without `promptId`, returns the current + * turn: the running prompt, the queued FIFO head, the most recent terminal + * or persisted outcome, or `state: 'idle'`. * Throws `SessionNotFoundError` for unknown ids. */ getSessionTurnStatus( diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index ec12e8ab873..48f2277263d 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -4009,7 +4009,17 @@ describe('Session', () => { { type: core.StreamEventType.CHUNK, value: { - candidates: [{ content: { parts: [{ text: 'raw answer' }] } }], + candidates: [ + { + content: { + parts: [ + { + text: 'r'.repeat(core.TURN_RESULT_TEXT_MAX_CHARS * 3), + }, + ], + }, + }, + ], usageMetadata: { promptTokenCount: 1, candidatesTokenCount: 1, @@ -4028,9 +4038,10 @@ describe('Session', () => { trustedContext, ); - expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( - expect.objectContaining({ resultText: 'rewritten answer' }), - ); + const payload = + mockChatRecordingService.recordTurnResult.mock.calls[0][0]; + expect(payload.resultText).toBe('rewritten answer'); + expect(payload.resultTruncated).toBeUndefined(); }); it.each([ @@ -4191,6 +4202,32 @@ describe('Session', () => { expect(payload.resultTruncated).toBe(true); }); + it('bounds the number of captured result segments', async () => { + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createStreamWithChunks( + Array.from({ length: 257 }, () => ({ + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: 'x' }] } }], + }, + })), + ), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'many chunks' }], + }, + trustedContext, + ); + + const payload = + mockChatRecordingService.recordTurnResult.mock.calls[0][0]; + expect(payload.resultText).toBe('x'.repeat(256)); + expect(payload.resultTruncated).toBe(true); + }); + it('records a cancelled turn when admission aborts before dispatch', async () => { let releaseAdmission!: () => void; const admission = new Promise((resolve) => { diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index 82a19afc23d..73715b68555 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -787,10 +787,25 @@ type InFlightTurnRecording = { startedAt: number; promptText: string; promptTextTruncated: boolean; - resultSegments: Map; + resultSegments: Map< + string, + { + rawText: string; + rawTruncated?: boolean; + rewrittenText?: string; + rewrittenTruncated?: boolean; + } + >; + resultCapturedChars: number; + resultSegmentsTruncated: boolean; nextDirectResultSegmentId: number; }; +// Hold a raw candidate and its possible replacement without allowing a +// tool-heavy turn to grow the recording accumulator without bound. +const TURN_RESULT_CAPTURE_MAX_CHARS = TURN_RESULT_TEXT_MAX_CHARS * 2; +const TURN_RESULT_CAPTURE_MAX_SEGMENTS = 256; + function truncateTurnText(text: string): { text: string; truncated: boolean; @@ -2923,6 +2938,7 @@ export class Session implements SessionContext { // admission would let an overlapping successor (DAEMON-003 deadline // overlap) redirect this turn's still-streaming chunks into the // successor's record. + if (turnRecording) turnRecording.startedAt = Date.now(); this.#turnRecording = turnRecording; try { @@ -4962,6 +4978,8 @@ export class Session implements SessionContext { promptText: text, promptTextTruncated: truncated, resultSegments: new Map(), + resultCapturedChars: 0, + resultSegmentsTruncated: false, nextDirectResultSegmentId: 0, }; } @@ -5000,15 +5018,35 @@ export class Session implements SessionContext { const segmentKey = rewriteContext ? `rewrite:${rewriteContext.turnIndex}` : `direct:${recording.nextDirectResultSegmentId++}`; - const segment = recording.resultSegments.get(segmentKey) ?? { - rawText: '', - }; + let segment = recording.resultSegments.get(segmentKey); + if (!segment) { + if (recording.resultSegments.size >= TURN_RESULT_CAPTURE_MAX_SEGMENTS) { + recording.resultSegmentsTruncated = true; + return; + } + segment = { rawText: '' }; + recording.resultSegments.set(segmentKey, segment); + } if (rewriteContext?.rewritten) { - segment.rewrittenText = (segment.rewrittenText ?? '') + content.text; - } else { - segment.rawText += content.text; + if (segment.rewrittenText === undefined) { + recording.resultCapturedChars -= segment.rawText.length; + segment.rawText = ''; + delete segment.rawTruncated; + segment.rewrittenText = ''; + } + const remaining = + TURN_RESULT_CAPTURE_MAX_CHARS - recording.resultCapturedChars; + segment.rewrittenText += content.text.slice(0, remaining); + recording.resultCapturedChars += Math.min(content.text.length, remaining); + if (content.text.length > remaining) segment.rewrittenTruncated = true; + return; } - recording.resultSegments.set(segmentKey, segment); + if (segment.rewrittenText !== undefined) return; + const remaining = + TURN_RESULT_CAPTURE_MAX_CHARS - recording.resultCapturedChars; + segment.rawText += content.text.slice(0, remaining); + recording.resultCapturedChars += Math.min(content.text.length, remaining); + if (content.text.length > remaining) segment.rawTruncated = true; } /** @@ -5029,10 +5067,17 @@ export class Session implements SessionContext { if (recording === null) { return; } + const selectedSegments = [...recording.resultSegments.values()].map( + (segment) => ({ + text: segment.rewrittenText ?? segment.rawText, + truncated: + segment.rewrittenText !== undefined + ? segment.rewrittenTruncated === true + : segment.rawTruncated === true, + }), + ); const selectedResult = truncateTurnText( - [...recording.resultSegments.values()] - .map(({ rawText, rewrittenText }) => rewrittenText ?? rawText) - .join(''), + selectedSegments.map(({ text }) => text).join(''), ); const payload: TurnResultRecordPayload = { promptId: recording.promptId, @@ -5048,7 +5093,11 @@ export class Session implements SessionContext { ...(selectedResult.text.length > 0 ? { resultText: selectedResult.text } : {}), - ...(selectedResult.truncated ? { resultTruncated: true } : {}), + ...(selectedResult.truncated || + selectedSegments.some(({ truncated }) => truncated) || + recording.resultSegmentsTruncated + ? { resultTruncated: true } + : {}), ...(recording.originatorClientId !== undefined ? { originatorClientId: recording.originatorClientId } : {}), diff --git a/packages/cli/src/serve/routes/session.ts b/packages/cli/src/serve/routes/session.ts index 9ddc21e50c0..6ab17bdf7dd 100644 --- a/packages/cli/src/serve/routes/session.ts +++ b/packages/cli/src/serve/routes/session.ts @@ -4720,7 +4720,8 @@ export function registerSessionRoutes( // resolves the running turn (or queued FIFO head, latest settled outcome, // idle); `:promptId` resolves that exact prompt. Live queue state comes // from the bridge's pending list; settled outcomes (completed / cancelled - // / error) from the agent's persisted `turn_result` transcript records. + // / error) from the bridge terminal overlay and persisted `turn_result` + // transcript records. app.get('/session/:id/turns/current', (req, res) => { const sessionId = requireSessionId(req, res); if (sessionId === null) return; From 65d6aceb70e3bfc8b968f956cb32f7464e690248 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sat, 8 Aug 2026 13:16:14 +0800 Subject: [PATCH 08/25] docs(serve): clarify turn result size units --- docs/design/daemon-turn-status-endpoint.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/docs/design/daemon-turn-status-endpoint.md b/docs/design/daemon-turn-status-endpoint.md index 24ac4c8b32e..6312ae45272 100644 --- a/docs/design/daemon-turn-status-endpoint.md +++ b/docs/design/daemon-turn-status-endpoint.md @@ -63,11 +63,13 @@ particular `promptTextTruncated` / `resultTruncated` are only present when Tool, thought, background, and status output are also excluded. Rewrite failure or an empty rewrite falls back to the raw top-level segment. Both fields are capped at - `TURN_RESULT_TEXT_MAX_CHARS` (32 KiB) with the paired `*Truncated` flag. + `TURN_RESULT_TEXT_MAX_CHARS` (32,768 UTF-16 code units) with the paired + `*Truncated` flag. The result cap is applied after rewritten-versus-raw selection, so excluded or replaced text does not consume the visible-answer budget. - In-flight raw/rewrite candidates are separately bounded to 64 KiB and 256 - segments; loss of selected content at either bound sets `resultTruncated`. + In-flight raw/rewrite candidates are separately bounded to 65,536 UTF-16 + code units and 256 segments; loss of selected content at either bound sets + `resultTruncated`. The cap applies to both projections: the live `queued` / `running` status caps `promptText` the same way the settled record does, so the same promptId reports a consistent shape before and after settlement. From fa817d5b63f3fed6df13ec910ec726558726ce46 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sun, 9 Aug 2026 14:40:53 +0800 Subject: [PATCH 09/25] fix(daemon): resolve turn status review blockers --- .../plans/daemon-turn-status-blocker-fixes.md | 114 ++++++++++ packages/acp-bridge/src/bridge.test.ts | 55 +++++ packages/acp-bridge/src/bridge.ts | 15 +- .../cli/src/acp-integration/acpAgent.test.ts | 55 +++++ packages/cli/src/acp-integration/acpAgent.ts | 20 +- .../acp-integration/session/Session.test.ts | 198 ++++++++++++++++++ .../src/acp-integration/session/Session.ts | 71 ++++--- .../rewrite/MessageRewriteMiddleware.test.ts | 48 ++++- .../rewrite/MessageRewriteMiddleware.ts | 11 + .../session/rewrite/TurnBuffer.ts | 6 +- 10 files changed, 557 insertions(+), 36 deletions(-) create mode 100644 docs/plans/daemon-turn-status-blocker-fixes.md diff --git a/docs/plans/daemon-turn-status-blocker-fixes.md b/docs/plans/daemon-turn-status-blocker-fixes.md new file mode 100644 index 00000000000..bd4f4159b22 --- /dev/null +++ b/docs/plans/daemon-turn-status-blocker-fixes.md @@ -0,0 +1,114 @@ +# Daemon Turn Status Blocker Fixes Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Fix the eight confirmed correctness blockers on PR #8682 without expanding the change to unresolved Suggestions. + +**Architecture:** Preserve the existing HTTP routes, persisted `turn_result` format, and bounded terminal overlay. Normalize controlled cancellation at its source, keep pending-list live state aligned with formal terminal publication, make result capture accept only canonical answer emissions, reset rewrite state at automatic-turn ownership boundaries, and map an empty transcript to “no persisted result.” + +**Tech Stack:** TypeScript, ACP bridge/session runtime, Vitest, JSONL transcript reader. + +## Global Constraints + +- Work from exact PR head `20a9dd451c1acc198a96e8f936f1b0256f2e5942` in the isolated worktree. +- Change only confirmed Critical behavior; defer unresolved Suggestions. +- Preserve route paths, response schema, authorization, memory bounds, and transcript scan bounds. +- Add a failing regression test before each production change. +- Run tests from the owning package directory. +- Do not force-push. + +--- + +### Task 1: Normalize controlled prompt cancellation + +**Files:** + +- Modify: `packages/cli/src/acp-integration/session/Session.ts` +- Test: `packages/cli/src/acp-integration/session/Session.test.ts` + +**Interfaces:** + +- Consumes: `AbortSignal.reason`, `USER_CANCEL_ABORT_REASON`, and `SESSION_DISPOSE_ABORT_REASON`. +- Produces: one shared controlled-cancellation predicate used by stream gates and the outer recording classifier. + +- [ ] Add a test where `dispose()` aborts a non-stream signal-aware await and assert the persisted state is `cancelled`. +- [ ] Run the focused test and verify it fails with persisted state `error`. +- [ ] Add a test where a successor supersedes a predecessor whose await rejects on abort and assert the predecessor persists `cancelled`. +- [ ] Run the focused test and verify it fails with persisted state `error`. +- [ ] Abort the predecessor with an explicit controlled reason and reuse one cancellation predicate in all classifiers. +- [ ] Run the focused tests and the complete `Session.test.ts` file. + +### Task 2: Preserve deadline recovery and terminal polling precedence + +**Files:** + +- Modify: `packages/acp-bridge/src/bridge.ts` +- Test: `packages/acp-bridge/src/bridge.test.ts` + +**Interfaces:** + +- Consumes: `PendingPromptEntry.removed`, `terminalPublished`, deadline rejection, and the terminal overlay. +- Produces: prompt polling that never reports a terminal prompt as live and a running removal that retains its deadline recovery fence. + +- [ ] Add a test that removes a running prompt whose agent ignores cancellation, advances past its deadline, and verifies the FIFO dispatches the successor. +- [ ] Run the test and verify the successor remains blocked. +- [ ] Add a test that expires a queued prompt behind a wedged predecessor and verifies by-id polling returns `prompt_deadline_exceeded`, not `queued`. +- [ ] Run the test and verify it reports `queued`. +- [ ] Separate “status terminal published” from “deadline recovery completed”: do not let running removal suppress deadline cleanup, and exclude formally terminal entries from live polling. +- [ ] Run the focused tests and the complete `bridge.test.ts` file. + +### Task 3: Capture only the canonical visible answer + +**Files:** + +- Modify: `packages/cli/src/acp-integration/session/Session.ts` +- Modify: `packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts` +- Test: `packages/cli/src/acp-integration/session/Session.test.ts` +- Test: `packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts` + +**Interfaces:** + +- Consumes: `MessageRewriteEmissionContext`, rewrite target, update metadata, and automatic-turn boundaries. +- Produces: result segments where only a message rewrite can replace a raw answer segment and automatic-turn residue cannot cross into a daemon prompt. + +- [ ] Add a test showing the token-limit diagnostic is visible on the wire but absent from persisted `resultText`; verify it fails. +- [ ] Add a `target: 'thought'` test proving the persisted result remains the raw answer; verify it fails with rewritten thought text. +- [ ] Add an aborted cron/notification residue test proving the next daemon prompt rewrites only its own answer; verify it fails with cross-turn content. +- [ ] Tag internal diagnostics as non-answer status output. +- [ ] Extend the internal rewrite context with whether the rewrite replaces message text, and gate replacement on that field. +- [ ] Add a middleware reset method that clears buffered turn state without emitting a rewrite, and invoke it after automatic work has drained and before publishing a daemon turn recording. +- [ ] Run the focused tests, then both complete test files. + +### Task 4: Treat an empty transcript as no persisted turn + +**Files:** + +- Modify: `packages/cli/src/acp-integration/acpAgent.ts` +- Test: `packages/cli/src/acp-integration/acpAgent.test.ts` + +**Interfaces:** + +- Consumes: `SessionTranscriptSnapshotUnavailableError` from a zero-record transcript. +- Produces: `{ v: 1, sessionId, turnResult: null }` only for the initial empty snapshot while preserving typed failures for unavailable non-empty snapshots and oversized transcripts. + +- [ ] Add a test whose turn-status reader throws `SessionTranscriptSnapshotUnavailableError` for an empty snapshot and assert `turnResult: null`; verify it fails. +- [ ] Implement the narrow empty-snapshot mapping without swallowing oversized-page or cursor errors. +- [ ] Run the focused test and complete `acpAgent.test.ts` file. + +### Task 5: Verify, self-audit, commit, and push + +**Files:** + +- Review all files changed by Tasks 1–4 and this plan. + +**Interfaces:** + +- Consumes: all four independently green task groups. +- Produces: a verified commit on `feat/daemon-turn-status-polling`. + +- [ ] Run package-focused tests for every changed test file. +- [ ] Run `npm run build` and `npm run typecheck` from the repository root. +- [ ] Run `npm run test:integration:cli:sandbox:none` and the daemon polling E2E scenarios where available. +- [ ] Perform two consecutive clean diff self-audit passes, resetting the count after any edit. +- [ ] Commit only the reviewed files with a Conventional Commit message. +- [ ] Fetch and verify the remote PR head has not moved, then push without force to `origin/feat/daemon-turn-status-polling`. diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index b0667977614..4fde7777061 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -9192,6 +9192,10 @@ describe('createAcpSessionBridge', () => { } return { stopReason: 'end_turn' } as PromptResponse; }, + extMethodImpl: (method) => + method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus + ? { v: 1, sessionId: 'ignored', turnResult: null } + : {}, }); const subscribe = ( @@ -9364,6 +9368,47 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('lets a removed running prompt deadline release the FIFO when cancel wedges', async () => { + const handle = wedgeChannel(); + const bridge = makeBridge({ channelFactory: async () => handle.channel }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const events: BridgeEvent[] = []; + subscribe(bridge, session.sessionId, events); + + const wedged = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'wedge' }], + }, + undefined, + { promptId: 'prompt-removed-wedge', deadlineMs: 60 }, + ); + wedged.catch(() => {}); + await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(1)); + expect( + bridge.removePendingPrompt(session.sessionId, 'prompt-removed-wedge'), + ).toEqual({ removed: true }); + + const followup = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'after removed wedge' }], + }, + undefined, + { promptId: 'prompt-after-removed-wedge' }, + ); + + await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(2)); + await expect(followup).resolves.toEqual({ stopReason: 'end_turn' }); + expect(terminalsFor(events, 'prompt-removed-wedge')).toHaveLength(1); + expect(terminalsFor(events, 'prompt-removed-wedge')[0]?.type).toBe( + 'turn_complete', + ); + await bridge.shutdown(); + }); + it('does not publish a stale deadline terminal for a prompt that completed in time (DAEMON-003)', async () => { const handle = makeChannel({ promptImpl: () => ({ stopReason: 'end_turn' }), @@ -9427,6 +9472,16 @@ describe('createAcpSessionBridge', () => { 'prompt_deadline_exceeded', ); }); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-queued-deadline', + ), + ).resolves.toMatchObject({ + state: 'error', + error: { code: 'prompt_deadline_exceeded' }, + }); await new Promise((r) => setTimeout(r, 60)); expect(terminalsFor(events, 'prompt-queued-deadline')).toHaveLength(1); expect( diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 8abefc88824..7a7863a808d 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -6238,7 +6238,12 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { () => undefined, ); const onDeadline = () => { - if (pendingEntry.terminalPublished) return; + if ( + pendingEntry.terminalPublished && + !(pendingEntry.removed && pendingEntry.state === 'running') + ) { + return; + } const deadlineErr = new PromptDeadlineExceededError(deadlineMs); writeStderrLine( `sendPrompt: prompt ${promptId} exceeded ${deadlineMs}ms deadline ` + @@ -8428,9 +8433,11 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // getPendingPrompts. resolveTrustedClientId(entry, context?.clientId); - // Live state wins: a prompt on the pending list has not settled yet, - // so no `turn_result` record can exist for it. - const live = entry.pendingPromptList.filter((p) => !p.removed); + // Live state wins for non-terminal pending prompts, for which no + // `turn_result` record can exist yet. + const live = entry.pendingPromptList.filter( + (p) => !p.removed && !p.terminalPublished, + ); if (promptId !== undefined) { const match = live.find((p) => p.promptId === promptId); if (match) return liveTurnStatus(sessionId, match); diff --git a/packages/cli/src/acp-integration/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts index 0e407a6615d..e9a9b38e0d6 100644 --- a/packages/cli/src/acp-integration/acpAgent.test.ts +++ b/packages/cli/src/acp-integration/acpAgent.test.ts @@ -9237,6 +9237,61 @@ describe('QwenAgent MCP SSE/HTTP support', () => { await agentPromise; }); + it('treats only an empty unavailable transcript as having no turn result', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const tempDir = await fs.mkdtemp( + path.join(os.tmpdir(), 'qwen-empty-turn-status-'), + ); + const transcriptPath = path.join(tempDir, `${sessionId}.jsonl`); + await fs.writeFile(transcriptPath, ''); + const snapshotError = new SessionTranscriptSnapshotUnavailableError( + sessionId, + ); + const readPage = vi.fn().mockRejectedValue(snapshotError); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + getSessionFilePath: () => transcriptPath, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + try { + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: 'prompt-1', + }), + ).resolves.toEqual({ v: 1, sessionId, turnResult: null }); + + await fs.writeFile(transcriptPath, '{partial'); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: 'prompt-1', + }), + ).rejects.toBe(snapshotError); + } finally { + mockConnectionState.resolve(); + await agentPromise; + await fs.rm(tempDir, { recursive: true, force: true }); + } + }); + it('rejects turn status reads with invalid params or non-live sessions', async () => { const sessionId = '11111111-1111-1111-1111-111111111111'; await setupSessionMocks(sessionId); diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index 21570b9c0ce..aba51df61e3 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -10417,8 +10417,9 @@ class QwenAgent implements Agent { } catch { // Fall through to the scan. } + let reader: SessionTranscriptReader | undefined; try { - const reader = new SessionTranscriptReader(cwd); + reader = new SessionTranscriptReader(cwd); const turnResult = await findSettledTurnResult( reader, sessionId, @@ -10437,6 +10438,23 @@ class QwenAgent implements Agent { // (settings/runtime resolution) still surfaces. return { v: 1, sessionId, turnResult: null }; } + if ( + error instanceof SessionTranscriptSnapshotUnavailableError && + reader + ) { + try { + const transcript = await fs.stat( + reader.getSessionFilePath(sessionId), + ); + if (transcript.size === 0) { + return { v: 1, sessionId, turnResult: null }; + } + } catch (statError) { + if ((statError as NodeJS.ErrnoException).code === 'ENOENT') { + return { v: 1, sessionId, turnResult: null }; + } + } + } throw error; } }); diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index b64020dff2b..b36b9609d8d 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -4240,6 +4240,110 @@ describe('Session', () => { expect(payload.resultTruncated).toBeUndefined(); }); + it('keeps the main answer when only thoughts are rewritten', async () => { + ( + mockSettings.user as { originalSettings?: Record } + ).originalSettings = { + messageRewrite: { + enabled: true, + target: 'thought', + prompt: 'rewrite', + }, + }; + session.installRewriter(); + const rewrite = vi.fn().mockResolvedValue('rewritten thought'); + ( + session.messageRewriter as unknown as { + rewriter: { rewrite: typeof rewrite }; + } + ).rewriter.rewrite = rewrite; + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { + content: { + parts: [ + { text: 'private reasoning', thought: true }, + { text: 'main answer' }, + ], + }, + }, + ], + usageMetadata: { + promptTokenCount: 1, + candidatesTokenCount: 1, + totalTokenCount: 2, + }, + }, + }, + ]), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'answer me' }], + }, + trustedContext, + ); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ resultText: 'main answer' }), + ); + }); + + it('does not persist framework diagnostics as the main answer', async () => { + mockConfig.getSessionTokenLimit = vi.fn().mockReturnValue(100); + mockGeminiClient.tryCompressChat.mockResolvedValueOnce({ + originalTokenCount: 1200, + newTokenCount: 101, + compressionStatus: core.CompressionStatus.COMPRESSED, + }); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'too large' }], + }, + trustedContext, + ); + + const payload = + mockChatRecordingService.recordTurnResult.mock.calls[0][0]; + expect(payload).toMatchObject({ + promptId: 'daemon-prompt-id', + state: 'completed', + stopReason: 'max_tokens', + }); + expect(payload.resultText).toBeUndefined(); + }); + + it('discards automatic-turn rewrite residue before recording a prompt', async () => { + const discardTurn = vi.fn(); + session.messageRewriter = { + discardTurn, + interceptUpdate: vi.fn().mockResolvedValue(undefined), + flushTurn: vi.fn().mockResolvedValue(undefined), + waitForPendingRewrites: vi.fn().mockResolvedValue(undefined), + } as unknown as Session['messageRewriter']; + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValue(createEmptyStream()); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'fresh prompt' }], + }, + trustedContext, + ); + + expect(discardTurn).toHaveBeenCalledOnce(); + }); + it.each([ ['empty output', () => Promise.resolve('')], ['rewrite failure', () => Promise.reject(new Error('rewrite failed'))], @@ -4504,6 +4608,47 @@ describe('Session', () => { ); }); + it('records a cancelled turn when session disposal aborts a Stop hook', async () => { + const messageBus = { + request: vi.fn().mockImplementation( + (request: { signal?: AbortSignal }) => + new Promise((_resolve, reject) => { + request.signal?.addEventListener( + 'abort', + () => reject(new Error('Request was aborted.')), + { once: true }, + ); + }), + ), + }; + mockConfig.getMessageBus = vi.fn().mockReturnValue(messageBus); + mockConfig.getDisableAllHooks = vi.fn().mockReturnValue(false); + mockConfig.hasHooksForEvent = vi + .fn() + .mockImplementation((eventName: string) => eventName === 'Stop'); + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValue(createEmptyStream()); + + const prompt = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'dispose me' }], + }, + trustedContext, + ); + await vi.waitFor(() => expect(messageBus.request).toHaveBeenCalled()); + session.dispose(); + + await expect(prompt).rejects.toThrow('Request was aborted.'); + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'daemon-prompt-id', + state: 'cancelled', + }), + ); + }); + it('does not record a turn_result without an invocation context', async () => { mockChat.sendMessageStream = vi .fn() @@ -4612,6 +4757,59 @@ describe('Session', () => { }); }); + it('records a superseded signal-aware stream as cancelled', async () => { + mockConfig.assertCanStartTurn = vi.fn().mockResolvedValue(undefined); + mockChat.sendMessageStream = vi + .fn() + .mockImplementationOnce( + ( + _model: string, + request: { config: { abortSignal: AbortSignal } }, + ) => + Promise.resolve( + (async function* () { + await new Promise((_resolve, reject) => { + request.config.abortSignal.addEventListener( + 'abort', + () => reject(new Error('Request was aborted.')), + { once: true }, + ); + }); + yield* createEmptyStream(); + })(), + ), + ) + .mockResolvedValueOnce(createEmptyStream()); + + const first = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'first prompt' }], + }, + trustedContext, + ); + await vi.waitFor(() => + expect(mockChat.sendMessageStream).toHaveBeenCalledOnce(), + ); + + const second = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'second prompt' }], + }, + { ...trustedContext, promptId: 'second-prompt-id' }, + ); + + await expect(first).resolves.toEqual({ stopReason: 'cancelled' }); + await expect(second).resolves.toEqual({ stopReason: 'end_turn' }); + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'daemon-prompt-id', + state: 'cancelled', + }), + ); + }); + it('records a cancelled turn when cancelled while waiting for the predecessor', async () => { // The successor is admitted while the predecessor still streams, // then cancelled during the predecessor wait; it must settle its diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index 05b9bf305a7..b27717ad660 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -318,6 +318,16 @@ const permissionRequestTails = new WeakMap< >(); const USER_CANCEL_ABORT_REASON = 'qwen:user-cancel'; const SESSION_DISPOSE_ABORT_REASON = 'qwen:session-dispose'; +const PROMPT_SUPERSEDED_ABORT_REASON = 'qwen:prompt-superseded'; + +function isControlledPromptAbort(signal: AbortSignal): boolean { + return ( + signal.aborted && + (signal.reason === USER_CANCEL_ABORT_REASON || + signal.reason === SESSION_DISPOSE_ABORT_REASON || + signal.reason === PROMPT_SUPERSEDED_ABORT_REASON) + ); +} const DAEMON_RETRY_META_KEY = 'qwen.daemon.retry'; const DAEMON_CONTINUE_META_KEY = 'qwen.daemon.continueLastTurn'; const TODO_STOP_GUARD_PROMPT_PREFIX = '[Todo Stop Guard] '; @@ -2911,7 +2921,7 @@ export class Session implements SessionContext { // After writer admission, install this prompt's AbortController before // awaiting the previous prompt so a session/cancel during that wait // targets us. A cancel during admission cannot target this pending prompt. - this.pendingPrompt?.abort(); + this.pendingPrompt?.abort(PROMPT_SUPERSEDED_ABORT_REASON); const pendingSend = new AbortController(); const cancelPendingSend = () => pendingSend.abort(USER_CANCEL_ABORT_REASON); if (admissionCancellation) { @@ -2978,6 +2988,8 @@ export class Session implements SessionContext { } } + this.messageRewriter?.discardTurn?.(); + // Cancelled while waiting for the previous prompt to finish. if (pendingSend.signal.aborted) { releasePendingSend(); @@ -3044,14 +3056,14 @@ export class Session implements SessionContext { } return result; } catch (error) { - // An explicit user cancel can surface as a non-AbortError (e.g. the + // A controlled prompt abort can surface as a non-AbortError (e.g. the // provider SDK's "Request was aborted."), so classify the recording - // by the cancel reason instead of the error shape. - const userCancelled = - pendingSend.signal.aborted && - pendingSend.signal.reason === USER_CANCEL_ABORT_REASON; + // by the abort reason instead of the error shape. + const controlledCancellation = isControlledPromptAbort( + pendingSend.signal, + ); this.#settleTurnRecording( - userCancelled ? 'cancelled' : 'error', + controlledCancellation ? 'cancelled' : 'error', turnRecording, undefined, error, @@ -3793,14 +3805,13 @@ export class Session implements SessionContext { strippedOrphanEntries = null; } - // Explicit user cancellation and session disposal are - // controlled aborts. Other AbortErrors still surface so - // infrastructure failures are not hidden as cancellations. - const isControlledCancellation = - pendingSend.signal.aborted && - (pendingSend.signal.reason === USER_CANCEL_ABORT_REASON || - pendingSend.signal.reason === - SESSION_DISPOSE_ABORT_REASON); + // User cancellation, session disposal, and prompt + // supersession are controlled aborts. Other AbortErrors + // still surface so infrastructure failures are not hidden + // as cancellations. + const isControlledCancellation = isControlledPromptAbort( + pendingSend.signal, + ); if (isControlledCancellation) { this.todoStopGuard.suspend(); return { stopReason: 'cancelled' }; @@ -4754,10 +4765,9 @@ export class Session implements SessionContext { true, ); } - const isControlledCancellation = - pendingSend.signal.aborted && - (pendingSend.signal.reason === USER_CANCEL_ABORT_REASON || - pendingSend.signal.reason === SESSION_DISPOSE_ABORT_REASON); + const isControlledCancellation = isControlledPromptAbort( + pendingSend.signal, + ); if (isControlledCancellation) { this.todoStopGuard.suspend(); return { @@ -4966,8 +4976,11 @@ export class Session implements SessionContext { async #deliverUpdate( update: SessionUpdate, rewriteContext?: MessageRewriteEmissionContext, + captureResultText = true, ): Promise { - this.#accumulateTurnResultText(update, rewriteContext); + if (captureResultText) { + this.#accumulateTurnResultText(update, rewriteContext); + } const params: SessionNotification = { sessionId: this.sessionId, update: projectAcpToolResultUpdate(update), @@ -5086,7 +5099,11 @@ export class Session implements SessionContext { return; } - const segmentKey = rewriteContext + if (rewriteContext?.rewritten && !rewriteContext.replacesMessageText) { + return; + } + + const segmentKey = rewriteContext?.replacesMessageText ? `rewrite:${rewriteContext.turnIndex}` : `direct:${recording.nextDirectResultSegmentId++}`; let segment = recording.resultSegments.get(segmentKey); @@ -5585,10 +5602,14 @@ export class Session implements SessionContext { } async #emitAgentDiagnosticMessage(text: string): Promise { - await this.sendUpdate({ - sessionUpdate: 'agent_message_chunk', - content: { type: 'text', text }, - }); + await this.#deliverUpdate( + { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text }, + }, + undefined, + false, + ); } async #drainMidTurnUserMessages( diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts index b8edea424ac..ca98acce478 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts @@ -73,6 +73,7 @@ describe('MessageRewriteMiddleware', () => { expect(mockSendUpdate).toHaveBeenCalledWith(msgUpdate, { turnIndex: 1, rewritten: false, + replacesMessageText: true, }); }); }); @@ -103,7 +104,7 @@ describe('MessageRewriteMiddleware', () => { content: { type: 'text', text: 'rewritten text' }, _meta: { rewritten: true, turnIndex: 1 }, }, - { turnIndex: 1, rewritten: true }, + { turnIndex: 1, rewritten: true, replacesMessageText: true }, ); const { LlmRewriter } = await import('./LlmRewriter.js'); @@ -179,6 +180,37 @@ describe('MessageRewriteMiddleware', () => { }); }); + describe('discardTurn', () => { + it('drops buffered automatic-turn content before the next prompt', async () => { + const { middleware } = createMiddleware('message'); + + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'aborted background residue' }, + } as unknown as SessionUpdate); + middleware.discardTurn(); + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'new prompt answer' }, + } as unknown as SessionUpdate); + await middleware.flushTurn(); + await middleware.waitForPendingRewrites(); + + const { LlmRewriter } = await import('./LlmRewriter.js'); + const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { + rewrite: ReturnType; + }; + expect(rewriter.rewrite).toHaveBeenCalledWith( + { + thoughts: [], + messages: ['new prompt answer'], + hasToolCalls: false, + }, + expect.any(AbortSignal), + ); + }); + }); + describe('flushTurn — tool_call boundary', () => { it('should flush before passing through tool_call', async () => { const { middleware, mockSendUpdate } = createMiddleware(); @@ -246,7 +278,12 @@ describe('MessageRewriteMiddleware', () => { expect(mockSendUpdate.mock.calls).toEqual([ [ original, - { ownerPromptId: 'prompt-a', turnIndex: 1, rewritten: false }, + { + ownerPromptId: 'prompt-a', + turnIndex: 1, + rewritten: false, + replacesMessageText: true, + }, ], [ { @@ -254,7 +291,12 @@ describe('MessageRewriteMiddleware', () => { content: { type: 'text', text: 'rewritten text' }, _meta: { rewritten: true, turnIndex: 1 }, }, - { ownerPromptId: 'prompt-a', turnIndex: 1, rewritten: true }, + { + ownerPromptId: 'prompt-a', + turnIndex: 1, + rewritten: true, + replacesMessageText: true, + }, ], ]); }); diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts index 8b7c9c7e981..01a30cf8f0f 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts @@ -39,6 +39,7 @@ export interface MessageRewriteEmissionContext { ownerPromptId?: string; turnIndex: number; rewritten: boolean; + replacesMessageText: boolean; } export class MessageRewriteMiddleware { @@ -103,6 +104,9 @@ export class MessageRewriteMiddleware { ...(ownerPromptId !== undefined ? { ownerPromptId } : {}), turnIndex: this.turnIndex + 1, rewritten: false, + replacesMessageText: + updateType === 'agent_message_chunk' && + (this.target === 'message' || this.target === 'all'), }); if ( @@ -192,6 +196,7 @@ export class MessageRewriteMiddleware { ...(ownerPromptId !== undefined ? { ownerPromptId } : {}), turnIndex: turnIdx, rewritten: true, + replacesMessageText: content.messages.length > 0, }, ); } catch (error) { @@ -203,6 +208,12 @@ export class MessageRewriteMiddleware { ); } + discardTurn(): void { + this.turnBuffer.discard(); + this.turnMeta = undefined; + this.turnOwnerPromptId = undefined; + } + private captureTurnMeta(update: Record): void { const meta = update['_meta']; if (!meta || typeof meta !== 'object' || Array.isArray(meta)) { diff --git a/packages/cli/src/acp-integration/session/rewrite/TurnBuffer.ts b/packages/cli/src/acp-integration/session/rewrite/TurnBuffer.ts index 7ab66fe3ec5..a87965d4eec 100644 --- a/packages/cli/src/acp-integration/session/rewrite/TurnBuffer.ts +++ b/packages/cli/src/acp-integration/session/rewrite/TurnBuffer.ts @@ -36,7 +36,7 @@ export class TurnBuffer { const messageText = this.messages.join(''); if (!thoughtText.trim() && !messageText.trim()) { - this.reset(); + this.discard(); return null; } @@ -46,11 +46,11 @@ export class TurnBuffer { hasToolCalls: this._hasToolCalls, }; - this.reset(); + this.discard(); return content; } - private reset(): void { + discard(): void { this.thoughts = []; this.messages = []; this._hasToolCalls = false; From f6961e7e9a92d0d29d7b170d7c9676dff53dba92 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sun, 9 Aug 2026 14:53:00 +0800 Subject: [PATCH 10/25] fix(daemon): preserve long streamed turn results --- packages/cli/src/acp-integration/session/Session.test.ts | 6 +++--- packages/cli/src/acp-integration/session/Session.ts | 4 +--- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index b36b9609d8d..dd39c57ab5f 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -4502,7 +4502,7 @@ describe('Session', () => { expect(payload.resultTruncated).toBe(true); }); - it('bounds the number of captured result segments', async () => { + it('captures streamed chunks until the character cap', async () => { mockChat.sendMessageStream = vi.fn().mockResolvedValue( createStreamWithChunks( Array.from({ length: 257 }, () => ({ @@ -4524,8 +4524,8 @@ describe('Session', () => { const payload = mockChatRecordingService.recordTurnResult.mock.calls[0][0]; - expect(payload.resultText).toBe('x'.repeat(256)); - expect(payload.resultTruncated).toBe(true); + expect(payload.resultText).toBe('x'.repeat(257)); + expect(payload.resultTruncated).toBeUndefined(); }); it('records a cancelled turn when admission aborts before dispatch', async () => { diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index b27717ad660..bd0260a91bf 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -809,7 +809,6 @@ type InFlightTurnRecording = { >; resultCapturedChars: number; resultSegmentsTruncated: boolean; - nextDirectResultSegmentId: number; }; // Hold a raw candidate and its possible replacement without allowing a @@ -5064,7 +5063,6 @@ export class Session implements SessionContext { resultSegments: new Map(), resultCapturedChars: 0, resultSegmentsTruncated: false, - nextDirectResultSegmentId: 0, }; } @@ -5105,7 +5103,7 @@ export class Session implements SessionContext { const segmentKey = rewriteContext?.replacesMessageText ? `rewrite:${rewriteContext.turnIndex}` - : `direct:${recording.nextDirectResultSegmentId++}`; + : 'direct'; let segment = recording.resultSegments.get(segmentKey); if (!segment) { if (recording.resultSegments.size >= TURN_RESULT_CAPTURE_MAX_SEGMENTS) { From 0df9510368137708bdba8a48b4cc20f1a09f5341 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sun, 9 Aug 2026 15:37:02 +0800 Subject: [PATCH 11/25] fix(daemon): harden turn status failure handling --- packages/acp-bridge/src/bridge.test.ts | 39 +++++++++ packages/acp-bridge/src/bridge.ts | 22 +++-- .../cli/src/acp-integration/acpAgent.test.ts | 83 ++++++++++++++++++- packages/cli/src/acp-integration/acpAgent.ts | 27 ++++++ 4 files changed, 162 insertions(+), 9 deletions(-) diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 4fde7777061..e48db263b14 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -8986,6 +8986,45 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('falls back to a terminal status when persisted lookup fails', async () => { + const handle = makeChannel({ + promptImpl: () => ({ stopReason: 'end_turn' }), + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + throw new Error('agent transport closed'); + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + await bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'completed before disconnect' }], + }, + undefined, + { promptId: 'prompt-disconnected' }, + ); + + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-disconnected', + ), + ).resolves.toMatchObject({ + state: 'completed', + promptId: 'prompt-disconnected', + promptText: 'completed before disconnect', + stopReason: 'end_turn', + }); + await bridge.shutdown(); + }); + it('reports removed queued and running prompts as cancelled immediately', async () => { let rejectRunning: ((err: Error) => void) | undefined; const runningGate = new Promise((_resolve, reject) => { diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 7a7863a808d..28d76123ac6 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -8450,25 +8450,35 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // Settled state is durable: read the agent's persisted `turn_result` // records. This survives daemon restarts (the pending list does not). - const result = await requestSessionStatus<{ + const terminal = + promptId !== undefined + ? entry.terminalTurnStatuses.get(promptId) + : latestTerminalTurnStatus(entry); + let result: { v: number; sessionId: string; turnResult: TurnResultRecordPayload | null; - }>(sessionId, SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { - ...(promptId !== undefined ? { promptId } : {}), - }); + }; + try { + result = await requestSessionStatus( + sessionId, + SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, + { ...(promptId !== undefined ? { promptId } : {}) }, + ); + } catch (error) { + if (terminal) return terminal; + throw error; + } const persisted = result.turnResult ? settledTurnStatus(sessionId, result.turnResult) : undefined; if (promptId !== undefined) { - const terminal = entry.terminalTurnStatuses.get(promptId); if (terminal && persisted) { return enrichTerminalTurnStatus(terminal, persisted); } if (terminal) return terminal; if (persisted) return persisted; } else { - const terminal = latestTerminalTurnStatus(entry); if (terminal && persisted && persisted.promptId === terminal.promptId) { return enrichTerminalTurnStatus(terminal, persisted); } diff --git a/packages/cli/src/acp-integration/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts index e9a9b38e0d6..f620edcfce5 100644 --- a/packages/cli/src/acp-integration/acpAgent.test.ts +++ b/packages/cli/src/acp-integration/acpAgent.test.ts @@ -9038,7 +9038,7 @@ describe('QwenAgent MCP SSE/HTTP support', () => { await agentPromise; }); - it('propagates oversized pages from bounded turn_result scans', async () => { + it('maps oversized pages from bounded turn_result scans to structured errors', async () => { const sessionId = '11111111-1111-1111-1111-111111111111'; await setupSessionMocks(sessionId); const pageError = new SessionTranscriptPageTooLargeError( @@ -9072,12 +9072,83 @@ describe('QwenAgent MCP SSE/HTTP support', () => { sessionId, promptId: 'prompt-1', }), - ).rejects.toBe(pageError); + ).rejects.toMatchObject({ + code: -32012, + data: { + errorKind: 'transcript_page_too_large', + sessionId, + pageBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES + 1, + maxBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES, + }, + }); mockConnectionState.resolve(); await agentPromise; }); + it.each([ + { + name: 'oversized snapshots', + error: new SessionTranscriptTooLargeError( + '11111111-1111-1111-1111-111111111111', + 300, + 200, + ), + expected: { + code: -32011, + data: { + errorKind: 'transcript_too_large', + sessionId: '11111111-1111-1111-1111-111111111111', + snapshotSize: 300, + maxBytes: 200, + }, + }, + }, + { + name: 'invalid internal cursors', + error: new InvalidSessionTranscriptCursorError(), + expected: { + code: -32602, + data: { errorKind: 'invalid_transcript_cursor' }, + }, + }, + ])( + 'maps $name from bounded turn_result scans', + async ({ error, expected }) => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage: vi.fn().mockRejectedValue(error), + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: 'prompt-1', + }), + ).rejects.toMatchObject(expected); + + mockConnectionState.resolve(); + await agentPromise; + }, + ); + it('still scans the transcript when the pre-read flush fails', async () => { const sessionId = '11111111-1111-1111-1111-111111111111'; const innerConfig = await setupSessionMocks(sessionId); @@ -9284,7 +9355,13 @@ describe('QwenAgent MCP SSE/HTTP support', () => { sessionId, promptId: 'prompt-1', }), - ).rejects.toBe(snapshotError); + ).rejects.toMatchObject({ + code: -32010, + data: { + errorKind: 'transcript_snapshot_unavailable', + sessionId, + }, + }); } finally { mockConnectionState.resolve(); await agentPromise; diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index aba51df61e3..427902dbfff 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -10455,6 +10455,33 @@ class QwenAgent implements Agent { } } } + if (error instanceof InvalidSessionTranscriptCursorError) { + throw new RequestError(-32602, error.message, { + errorKind: 'invalid_transcript_cursor', + }); + } + if (error instanceof SessionTranscriptSnapshotUnavailableError) { + throw new RequestError(-32010, error.message, { + errorKind: 'transcript_snapshot_unavailable', + sessionId, + }); + } + if (error instanceof SessionTranscriptTooLargeError) { + throw new RequestError(-32011, error.message, { + errorKind: 'transcript_too_large', + sessionId, + snapshotSize: error.snapshotSize, + maxBytes: error.maxBytes, + }); + } + if (error instanceof SessionTranscriptPageTooLargeError) { + throw new RequestError(-32012, error.message, { + errorKind: 'transcript_page_too_large', + sessionId, + pageBytes: error.pageBytes, + maxBytes: error.maxBytes, + }); + } throw error; } }); From 4f59282ba6b8aaa58f35494182d70afb6b954ea0 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sun, 9 Aug 2026 18:11:20 +0800 Subject: [PATCH 12/25] fix(cli): keep polled turn results user-visible --- .../acp-integration/session/Session.test.ts | 217 ++++++++++++++---- .../src/acp-integration/session/Session.ts | 24 +- .../rewrite/MessageRewriteMiddleware.test.ts | 26 +++ .../rewrite/MessageRewriteMiddleware.ts | 4 + 4 files changed, 208 insertions(+), 63 deletions(-) diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index dd39c57ab5f..c4d22287b1a 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -4321,6 +4321,47 @@ describe('Session', () => { expect(payload.resultText).toBeUndefined(); }); + it('does not persist voice bridge status as the main answer', async () => { + mockConfig.getEffectiveInputModalities = vi.fn().mockReturnValue({}); + Object.assign(mockSettings.merged as Record, { + voiceModel: 'qwen3-asr-flash', + env: { OPENAI_API_KEY: 'test-key' }, + }); + transcribeVoiceAudioSpy.mockResolvedValue('transcribed request'); + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [{ content: { parts: [{ text: 'main answer' }] } }], + }, + }, + ]), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [ + { type: 'text', text: 'answer this audio' }, + { + type: 'audio', + mimeType: 'audio/ogg', + data: 'T2dnUw==', + }, + ], + }, + trustedContext, + ); + + expect(agentMessageChunks()).toContain( + 'Converted 1 audio file(s) to text via qwen3-asr-flash. Your audio was sent to that model.', + ); + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ resultText: 'main answer' }), + ); + }); + it('discards automatic-turn rewrite residue before recording a prompt', async () => { const discardTurn = vi.fn(); session.messageRewriter = { @@ -4393,7 +4434,7 @@ describe('Session', () => { ); }); - it('does not attribute a delayed rewrite to another prompt', async () => { + it('falls back to raw text when rewritten delivery fails', async () => { ( mockSettings.user as { originalSettings?: Record } ).originalSettings = { @@ -4404,75 +4445,149 @@ describe('Session', () => { }, }; session.installRewriter(); - const rewrite = vi.fn().mockResolvedValue(''); - const middleware = session.messageRewriter as unknown as { - rewriter: { rewrite: typeof rewrite }; - sendUpdate: ( - update: SessionUpdate, - context: { - ownerPromptId: string; - turnIndex: number; - rewritten: boolean; - }, - ) => Promise; - }; - middleware.rewriter.rewrite = rewrite; - let releaseStream!: () => void; - const streamGate = new Promise((resolve) => { - releaseStream = resolve; - }); + const rewrite = vi.fn().mockResolvedValue('rewritten answer'); + ( + session.messageRewriter as unknown as { + rewriter: { rewrite: typeof rewrite }; + } + ).rewriter.rewrite = rewrite; + vi.mocked(mockClient.sessionUpdate).mockImplementation( + async ({ update }) => { + if ( + update.sessionUpdate === 'agent_message_chunk' && + update._meta?.['rewritten'] === true + ) { + throw new Error('rewritten update transport failed'); + } + }, + ); mockChat.sendMessageStream = vi.fn().mockResolvedValue( - (async function* () { - await streamGate; - yield { + createStreamWithChunks([ + { type: core.StreamEventType.CHUNK, value: { - candidates: [ - { content: { parts: [{ text: 'prompt B answer' }] } }, - ], + candidates: [{ content: { parts: [{ text: 'raw answer' }] } }], usageMetadata: { promptTokenCount: 1, candidatesTokenCount: 1, totalTokenCount: 2, }, }, - }; - })(), - ); - const prompt = session.prompt( - { - sessionId: 'test-session-id', - prompt: [{ type: 'text', text: 'prompt B' }], - }, - { ...trustedContext, promptId: 'prompt-b' }, - ); - await vi.waitFor(() => - expect(mockChat.sendMessageStream).toHaveBeenCalledOnce(), + }, + ]), ); - await middleware.sendUpdate( - { - sessionUpdate: 'agent_message_chunk', - content: { type: 'text', text: 'late prompt A rewrite' }, - _meta: { rewritten: true, turnIndex: 1 }, - }, + await session.prompt( { - ownerPromptId: 'prompt-a', - turnIndex: 1, - rewritten: true, + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'answer me' }], }, + trustedContext, ); - releaseStream(); - await prompt; expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( - expect.objectContaining({ - promptId: 'prompt-b', - resultText: 'prompt B answer', - }), + expect.objectContaining({ resultText: 'raw answer' }), ); }); + it.each([ + { + label: 'another prompt', + ownerPromptId: 'prompt-a' as string | undefined, + rewriteText: 'late prompt A rewrite', + }, + { + label: 'an automatic turn', + ownerPromptId: undefined, + rewriteText: 'late automatic rewrite', + }, + ])( + 'does not attribute a delayed rewrite from $label to the current prompt', + async ({ ownerPromptId, rewriteText }) => { + ( + mockSettings.user as { originalSettings?: Record } + ).originalSettings = { + messageRewrite: { + enabled: true, + target: 'message', + prompt: 'rewrite', + }, + }; + session.installRewriter(); + const rewrite = vi.fn().mockResolvedValue(''); + const middleware = session.messageRewriter as unknown as { + rewriter: { rewrite: typeof rewrite }; + sendUpdate: ( + update: SessionUpdate, + context: { + ownerPromptId?: string; + turnIndex: number; + rewritten: boolean; + replacesMessageText: boolean; + }, + ) => Promise; + }; + middleware.rewriter.rewrite = rewrite; + let releaseStream!: () => void; + const streamGate = new Promise((resolve) => { + releaseStream = resolve; + }); + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + (async function* () { + await streamGate; + yield { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { content: { parts: [{ text: 'prompt B answer' }] } }, + ], + usageMetadata: { + promptTokenCount: 1, + candidatesTokenCount: 1, + totalTokenCount: 2, + }, + }, + }; + })(), + ); + const prompt = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'prompt B' }], + }, + { ...trustedContext, promptId: 'prompt-b' }, + ); + await vi.waitFor(() => + expect(mockChat.sendMessageStream).toHaveBeenCalledOnce(), + ); + + await middleware.sendUpdate( + { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: rewriteText }, + _meta: { rewritten: true, turnIndex: 1 }, + }, + { + ...(ownerPromptId !== undefined ? { ownerPromptId } : {}), + turnIndex: 1, + rewritten: true, + replacesMessageText: true, + }, + ); + releaseStream(); + await prompt; + + expect( + mockChatRecordingService.recordTurnResult, + ).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'prompt-b', + resultText: 'prompt B answer', + }), + ); + }, + ); + it('caps resultText at TURN_RESULT_TEXT_MAX_CHARS and flags truncation', async () => { const longText = 'a'.repeat(core.TURN_RESULT_TEXT_MAX_CHARS + 100); mockChat.sendMessageStream = vi.fn().mockResolvedValue( diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index bd0260a91bf..beaf9646e8c 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -3529,7 +3529,7 @@ export class Session implements SessionContext { // Hook blocked the prompt - send notification to UI and return const blockReason = hookOutput?.getEffectiveReason() || 'No reason provided'; - await this.messageEmitter.emitAgentMessage( + await this.#emitAgentDiagnosticMessage( `✗ **UserPromptSubmit blocked**: ${blockReason}`, ); return { stopReason: 'end_turn' }; @@ -4176,7 +4176,7 @@ export class Session implements SessionContext { const stopOutput = hookOutput as StopHookOutput | undefined; if (stopOutput?.systemMessage) { - await this.messageEmitter.emitAgentMessage(stopOutput.systemMessage); + await this.#emitAgentDiagnosticMessage(stopOutput.systemMessage); } if ( @@ -4222,7 +4222,7 @@ export class Session implements SessionContext { warning, ); this.todoStopGuard.suspend(); - await this.messageEmitter.emitAgentMessage(warning); + await this.#emitAgentDiagnosticMessage(warning); debugLogger.warn(warning); return { stopReason: 'end_turn' }; } @@ -4977,9 +4977,6 @@ export class Session implements SessionContext { rewriteContext?: MessageRewriteEmissionContext, captureResultText = true, ): Promise { - if (captureResultText) { - this.#accumulateTurnResultText(update, rewriteContext); - } const params: SessionNotification = { sessionId: this.sessionId, update: projectAcpToolResultUpdate(update), @@ -4992,6 +4989,9 @@ export class Session implements SessionContext { this.activeTodoPlanRevision = undefined; } await this.client.sessionUpdate(params); + if (captureResultText) { + this.#accumulateTurnResultText(update, rewriteContext); + } if (update.sessionUpdate === 'plan') { this.#captureTodoPlanRevision(update); } @@ -5091,7 +5091,7 @@ export class Session implements SessionContext { return; } if ( - rewriteContext?.ownerPromptId !== undefined && + rewriteContext !== undefined && rewriteContext.ownerPromptId !== recording.promptId ) { return; @@ -9316,7 +9316,7 @@ export class Session implements SessionContext { const blockReason = preHookResult.blockReason || 'Blocked by PreToolUse hook'; try { - await this.messageEmitter.emitAgentMessage( + await this.#emitAgentDiagnosticMessage( `✗ **PreToolUse blocked**: ${toolName} - ${blockReason}`, ); } catch (emitError) { @@ -9744,7 +9744,7 @@ export class Session implements SessionContext { : undefined; if (visionBridgeNotice) { try { - await this.messageEmitter.emitAgentMessage(visionBridgeNotice); + await this.#emitAgentDiagnosticMessage(visionBridgeNotice); } catch (emitError) { debugLogger.debug( '[Session.runTool] Failed to emit vision bridge notice', @@ -10465,7 +10465,7 @@ export class Session implements SessionContext { ); if (selected) { try { - await this.messageEmitter.emitAgentMessage( + await this.#emitAgentDiagnosticMessage( formatFullTurnVisionNotice(fullTurnModel), ); } catch (error) { @@ -10499,7 +10499,7 @@ export class Session implements SessionContext { if (bridgeResult.status !== 'skipped' || bridgeResult.egressOccurred) { try { - await this.messageEmitter.emitAgentMessage( + await this.#emitAgentDiagnosticMessage( formatVisionBridgeNotice(bridgeResult), ); } catch (error) { @@ -10619,7 +10619,7 @@ export class Session implements SessionContext { if (transcribedCount > 0 || egressCount > 0) { try { - await this.messageEmitter.emitAgentMessage( + await this.#emitAgentDiagnosticMessage( transcribedCount > 0 ? this.#formatVoiceBridgeNotice(voiceModel, transcribedCount) : this.#formatVoiceBridgeEgressNotice(voiceModel, egressCount), diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts index ca98acce478..abfe7d1c32f 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts @@ -209,6 +209,32 @@ describe('MessageRewriteMiddleware', () => { expect.any(AbortSignal), ); }); + + it('drops an in-flight automatic-turn rewrite before the next prompt', async () => { + const { middleware, mockSendUpdate } = createMiddleware('message'); + const { LlmRewriter } = await import('./LlmRewriter.js'); + const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { + rewrite: ReturnType; + }; + let resolveRewrite!: (value: string) => void; + rewriter.rewrite.mockImplementationOnce( + () => + new Promise((resolve) => { + resolveRewrite = resolve; + }), + ); + + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'automatic turn answer' }, + } as unknown as SessionUpdate); + await middleware.flushTurn(); + middleware.discardTurn(); + resolveRewrite('late automatic rewrite'); + await middleware.waitForPendingRewrites(); + + expect(mockSendUpdate).toHaveBeenCalledTimes(1); + }); }); describe('flushTurn — tool_call boundary', () => { diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts index 01a30cf8f0f..d944031027e 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts @@ -48,6 +48,7 @@ export class MessageRewriteMiddleware { private readonly target: MessageRewriteConfig['target']; private readonly timeoutMs: number; private turnIndex = 0; + private generation = 0; private turnMeta: Record | undefined; private turnOwnerPromptId: string | undefined; @@ -161,6 +162,7 @@ export class MessageRewriteMiddleware { this.turnIndex++; const turnIdx = this.turnIndex; + const generation = this.generation; // Always enforce a timeout, combined with caller's signal if provided const timeoutSignal = AbortSignal.timeout(this.timeoutMs); @@ -176,6 +178,7 @@ export class MessageRewriteMiddleware { debugLogger.info(`Turn ${turnIdx}: no rewrite output`); return; } + if (generation !== this.generation) return; debugLogger.info( `Turn ${turnIdx}: rewritten ${rewritten.length} chars`, @@ -209,6 +212,7 @@ export class MessageRewriteMiddleware { } discardTurn(): void { + this.generation++; this.turnBuffer.discard(); this.turnMeta = undefined; this.turnOwnerPromptId = undefined; From 1343d90a6bbe2f23ceb90f139d1c952c637a8973 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Sun, 9 Aug 2026 23:02:07 +0800 Subject: [PATCH 13/25] fix(cli): harden polled turn result isolation --- docs/developers/qwen-serve-protocol.md | 7 +- .../acp-integration/session/Session.test.ts | 48 ++++++++ .../src/acp-integration/session/Session.ts | 2 +- .../session/rewrite/LlmRewriter.test.ts | 106 +++++++++++++++--- .../session/rewrite/LlmRewriter.ts | 27 +++-- .../rewrite/MessageRewriteMiddleware.test.ts | 50 +++++++++ .../rewrite/MessageRewriteMiddleware.ts | 13 ++- packages/cli/src/serve/capabilities.ts | 4 + packages/cli/src/serve/server.test.ts | 1 + 9 files changed, 224 insertions(+), 34 deletions(-) diff --git a/docs/developers/qwen-serve-protocol.md b/docs/developers/qwen-serve-protocol.md index fc996bd1c6f..00064c03685 100644 --- a/docs/developers/qwen-serve-protocol.md +++ b/docs/developers/qwen-serve-protocol.md @@ -174,7 +174,7 @@ registry. Clients **must** gate UI off `features`, not off `mode` (per design 'workspace_agents', 'workspace_agent_generate', 'workspace_env', 'workspace_preflight', 'session_context', 'session_context_usage', 'session_supported_commands', 'session_tasks', 'session_monitor_tool_correlation', 'session_stats', - 'session_lsp', 'session_status', + 'session_lsp', 'session_status', 'session_turn_status', 'session_close', 'session_metadata', 'session_organization', 'session_archive', 'mcp_guardrails', 'workspace_mcp_manage', 'mcp_guardrail_events', @@ -241,6 +241,8 @@ registry. Clients **must** gate UI off `features`, not off `mode` (per design `session_status` advertises `GET /session/:id/status`, the live bridge summary for a single session by id. In addition to `clientCount` and `hasActivePrompt`, live sessions expose `isWaitingForPermission`, `isWaitingForUserQuestion`, `pendingInteractionCount`, and a retained `turnError` after a failed turn. The error clears when the next prompt actually starts. Both the single-session status response and workspace session lists include `turnError` and `pendingInteractions`: render-ready permission actions or `ask_user_question` questions plus the `requestId` and selectable options required by the existing permission vote routes. Each user question has an `answerKey`; vote with `answers`, for example `{ "0": "Polling" }`, keyed by that value. Persisted-only sessions omit runtime state because no runtime exists. Older daemons return `404`; pre-flight this tag before polling a single session's status instead of scanning the full session list. +`session_turn_status` advertises `GET /session/:id/turns/current` and `GET /session/:id/turns/:promptId`. The current route returns the running turn, queued FIFO head, latest settled outcome, or `{ "state": "idle" }`; the prompt-specific route returns that prompt's live or persisted outcome, including `resultText` for the final main answer shown to the user when available. States are `idle`, `queued`, `running`, `completed`, `cancelled`, or `error`. A supported prompt-specific lookup with no matching turn returns `404 prompt_not_found`; clients must pre-flight this tag to distinguish that result from an older daemon that lacks the routes. + `session_info` advertises `GET /workspace/:id/session-info` and its `/workspaces/:workspace/session-info` twin. The response aggregates persisted active and archived session counts without hydrating list metadata. It is an explicit O(n) disk scan and must not be polled; clients should treat `truncated: true` as a lower-bound result. `session_approval_mode_control`, `workspace_tool_toggle`, `workspace_skill_toggle`, `workspace_init`, and `workspace_mcp_restart` advertise the mutation control routes documented below. They are strict-gated by the mutation gate (a daemon configured without a bearer token rejects them with 401 `token_required`). Older daemons return `404`; pre-flight each tag before exposing the corresponding affordance. @@ -1114,6 +1116,7 @@ Capability tags: - `session_monitor_tool_correlation` → monitor entries from `GET /session/:id/tasks` include `toolUseId` for transcript-to-task correlation - `session_status` → `GET /session/:id/status` +- `session_turn_status` → `GET /session/:id/turns/current` and `GET /session/:id/turns/:promptId` - `session_info` → `GET /workspace/:id/session-info` and `GET /workspaces/:workspace/session-info` - `session_transcript` → `GET /session/:id/transcript` - `workspace_persisted_transcript` → `GET /workspaces/:workspace/session/:id/transcript` @@ -2342,7 +2345,7 @@ ACP-over-HTTP uses the same request and response bodies through vendor methods ` ### Multi-workspace live-session routing -When `multi_workspace_sessions` is advertised, live-session operations identify their workspace from the `sessionId`; clients do not add a workspace selector to the URL. In addition to the existing owner-routed lifecycle operations, this applies to `PATCH /session/:id/metadata`, `POST /session/:id/recap`, `POST /session/:id/generate`, `POST /session/:id/btw`, `POST /session/:id/mid-turn-message`, `DELETE /session/:id/mid-turn-messages/:messageId`, `POST /session/:id/tasks/:taskId/cancel`, `POST /session/:id/goal/clear`, `POST /session/:id/continue`, `POST /session/:id/language`, `POST /session/:id/artifacts`, and `DELETE /session/:id/artifacts/:artifactId`. The daemon routes each request to the trusted runtime that owns the live session. An untrusted non-primary owner returns `403 untrusted_workspace`, a missing live owner returns `404 session_not_found`, and an ambiguous owner fails closed with `500 ambiguous_session_owner`. +When `multi_workspace_sessions` is advertised, live-session operations identify their workspace from the `sessionId`; clients do not add a workspace selector to the URL. In addition to the existing owner-routed lifecycle operations, this applies to `PATCH /session/:id/metadata`, `POST /session/:id/recap`, `POST /session/:id/generate`, `POST /session/:id/btw`, `POST /session/:id/mid-turn-message`, `DELETE /session/:id/mid-turn-messages/:messageId`, `GET /session/:id/turns/current`, `GET /session/:id/turns/:promptId`, `POST /session/:id/tasks/:taskId/cancel`, `POST /session/:id/goal/clear`, `POST /session/:id/continue`, `POST /session/:id/language`, `POST /session/:id/artifacts`, and `DELETE /session/:id/artifacts/:artifactId`. The daemon routes each request to the trusted runtime that owns the live session. An untrusted non-primary owner returns `403 untrusted_workspace`, a missing live owner returns `404 session_not_found`, and an ambiguous owner fails closed with `500 ambiguous_session_owner`. This rule is live-session-only and does not make every workspace-less session route multi-workspace-aware. Persisted or archived operations use their documented workspace-qualified routes. `POST /session/:id/branch`, `POST /session/:id/fork`, and `POST /session/:id/cd` intentionally remain primary-only and return `non_primary_session_route_not_supported` for non-primary owners. diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index c4d22287b1a..afb78cc756c 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -4321,6 +4321,54 @@ describe('Session', () => { expect(payload.resultText).toBeUndefined(); }); + it('does not append the scheduler exit summary to a cancelled turn result', async () => { + const scheduler = { + hasPendingWork: false, + enableDurable: vi.fn().mockResolvedValue(undefined), + stop: vi.fn(), + getExitSummary: vi.fn().mockReturnValue('Scheduler exit summary'), + }; + mockConfig.isCronEnabled = vi.fn().mockReturnValue(true); + mockConfig.getCronScheduler = vi.fn().mockReturnValue(scheduler); + let releaseStream!: () => void; + const streamGate = new Promise((resolve) => { + releaseStream = resolve; + }); + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + (async function* () { + await session.sendUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'main answer' }, + }); + await streamGate; + yield* createEmptyStream(); + })(), + ); + + const prompt = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'cancel me' }], + }, + trustedContext, + ); + await vi.waitFor(() => + expect(agentMessageChunks()).toContain('main answer'), + ); + + await session.cancelPendingPrompt(); + releaseStream(); + await prompt; + + expect(agentMessageChunks()).toContain('Scheduler exit summary'); + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + state: 'cancelled', + resultText: 'main answer', + }), + ); + }); + it('does not persist voice bridge status as the main answer', async () => { mockConfig.getEffectiveInputModalities = vi.fn().mockReturnValue({}); Object.assign(mockSettings.merged as Record, { diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index beaf9646e8c..12c873d9a55 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -2873,7 +2873,7 @@ export class Session implements SessionContext { const summary = scheduler.getExitSummary(); this.#stopCronSchedulerInRuntime(); if (summary) { - await this.messageEmitter.emitAgentMessage(summary); + await this.#emitAgentDiagnosticMessage(summary); } } } diff --git a/packages/cli/src/acp-integration/session/rewrite/LlmRewriter.test.ts b/packages/cli/src/acp-integration/session/rewrite/LlmRewriter.test.ts index 604293f9d51..97d1438c4f5 100644 --- a/packages/cli/src/acp-integration/session/rewrite/LlmRewriter.test.ts +++ b/packages/cli/src/acp-integration/session/rewrite/LlmRewriter.test.ts @@ -50,6 +50,15 @@ function makeTurn(messages: string[], thoughts: string[] = []): TurnContent { return { messages, thoughts, hasToolCalls: false }; } +async function rewriteAndCommit( + rewriter: InstanceType, + turn: TurnContent, +): Promise { + const output = await rewriter.rewrite(turn); + if (output) rewriter.commitOutput(output); + return output; +} + describe('LlmRewriter', () => { beforeEach(() => { mockGenerateContent.mockClear(); @@ -59,6 +68,32 @@ describe('LlmRewriter', () => { }); describe('contextTurns', () => { + it('does not expose a rewrite as context until it is committed', async () => { + mockGenerateContent + .mockResolvedValueOnce({ + candidates: [{ content: { parts: [{ text: 'pending rewrite' }] } }], + }) + .mockResolvedValue({ + candidates: [{ content: { parts: [{ text: 'later rewrite' }] } }], + }); + const rewriter = new LlmRewriter(makeConfig(), { + enabled: true, + target: 'all', + } as MessageRewriteConfig); + + const pending = await rewriter.rewrite(makeTurn(['first message'])); + await rewriter.rewrite(makeTurn(['second message'])); + const secondInput = + mockGenerateContent.mock.calls[1][0].contents[0].parts[0].text; + expect(secondInput).not.toContain('pending rewrite'); + + rewriter.commitOutput(pending!); + await rewriter.rewrite(makeTurn(['third message'])); + const thirdInput = + mockGenerateContent.mock.calls[2][0].contents[0].parts[0].text; + expect(thirdInput).toContain('pending rewrite'); + }); + it('should include last rewrite output by default (contextTurns=1)', async () => { const rewriter = new LlmRewriter(makeConfig(), { enabled: true, @@ -66,13 +101,13 @@ describe('LlmRewriter', () => { } as MessageRewriteConfig); // First call — no context - await rewriter.rewrite(makeTurn(['first message'])); + await rewriteAndCommit(rewriter, makeTurn(['first message'])); const firstInput = mockGenerateContent.mock.calls[0][0].contents[0].parts[0].text; expect(firstInput).not.toContain('上一轮改写结果'); // Second call — should include first rewrite output - await rewriter.rewrite(makeTurn(['second message'])); + await rewriteAndCommit(rewriter, makeTurn(['second message'])); const secondInput = mockGenerateContent.mock.calls[1][0].contents[0].parts[0].text; expect(secondInput).toContain('上一轮改写结果'); @@ -86,8 +121,8 @@ describe('LlmRewriter', () => { contextTurns: 0, } as MessageRewriteConfig); - await rewriter.rewrite(makeTurn(['first'])); - await rewriter.rewrite(makeTurn(['second'])); + await rewriteAndCommit(rewriter, makeTurn(['first'])); + await rewriteAndCommit(rewriter, makeTurn(['second'])); const secondInput = mockGenerateContent.mock.calls[1][0].contents[0].parts[0].text; @@ -108,7 +143,10 @@ describe('LlmRewriter', () => { } as MessageRewriteConfig); for (let i = 0; i < 6; i++) { - await rewriter.rewrite(makeTurn([`message number ${i} with length`])); + await rewriteAndCommit( + rewriter, + makeTurn([`message number ${i} with length`]), + ); } expect(historyOf(rewriter).length).toBe(2); @@ -122,7 +160,10 @@ describe('LlmRewriter', () => { } as MessageRewriteConfig); for (let i = 0; i < 4; i++) { - await rewriter.rewrite(makeTurn([`message number ${i} with length`])); + await rewriteAndCommit( + rewriter, + makeTurn([`message number ${i} with length`]), + ); } expect(historyOf(rewriter).length).toBe(0); @@ -136,7 +177,10 @@ describe('LlmRewriter', () => { } as MessageRewriteConfig); for (let i = 0; i < 4; i++) { - await rewriter.rewrite(makeTurn([`message number ${i} with length`])); + await rewriteAndCommit( + rewriter, + makeTurn([`message number ${i} with length`]), + ); } expect(historyOf(rewriter).length).toBe(4); @@ -163,12 +207,12 @@ describe('LlmRewriter', () => { contextTurns: 2, } as MessageRewriteConfig); - await rewriter.rewrite(makeTurn(['msg1'])); - await rewriter.rewrite(makeTurn(['msg2'])); - await rewriter.rewrite(makeTurn(['msg3'])); + await rewriteAndCommit(rewriter, makeTurn(['msg1'])); + await rewriteAndCommit(rewriter, makeTurn(['msg2'])); + await rewriteAndCommit(rewriter, makeTurn(['msg3'])); // 4th call — should include rewrite-B and rewrite-C (last 2), not rewrite-A - await rewriter.rewrite(makeTurn(['msg4'])); + await rewriteAndCommit(rewriter, makeTurn(['msg4'])); const input = mockGenerateContent.mock.calls[3][0].contents[0].parts[0].text; expect(input).not.toContain('rewrite-A'); @@ -194,9 +238,9 @@ describe('LlmRewriter', () => { contextTurns: 'all', } as MessageRewriteConfig); - await rewriter.rewrite(makeTurn(['msg1'])); - await rewriter.rewrite(makeTurn(['msg2'])); - await rewriter.rewrite(makeTurn(['msg3'])); + await rewriteAndCommit(rewriter, makeTurn(['msg1'])); + await rewriteAndCommit(rewriter, makeTurn(['msg2'])); + await rewriteAndCommit(rewriter, makeTurn(['msg3'])); const input = mockGenerateContent.mock.calls[2][0].contents[0].parts[0].text; @@ -231,6 +275,40 @@ describe('LlmRewriter', () => { }); describe('filtering', () => { + it('does not add an aborted rewrite to the next turn context', async () => { + let resolveRewrite!: (value: { + candidates: Array<{ content: { parts: Array<{ text: string }> } }>; + }) => void; + mockGenerateContent.mockImplementationOnce( + () => + new Promise((resolve) => { + resolveRewrite = resolve; + }), + ); + + const rewriter = new LlmRewriter(makeConfig(), { + enabled: true, + target: 'all', + } as MessageRewriteConfig); + const controller = new AbortController(); + const abortedRewrite = rewriter.rewrite( + makeTurn(['discarded automatic turn']), + controller.signal, + ); + + controller.abort(); + resolveRewrite({ + candidates: [{ content: { parts: [{ text: 'discarded rewrite' }] } }], + }); + await expect(abortedRewrite).resolves.toBeNull(); + await rewriter.rewrite(makeTurn(['current user turn'])); + + const currentInput = + mockGenerateContent.mock.calls[1][0].contents[0].parts[0].text; + expect(currentInput).not.toContain('discarded rewrite'); + expect(currentInput).not.toContain('上一轮改写结果'); + }); + it('should return null for empty input', async () => { const rewriter = new LlmRewriter(makeConfig(), { enabled: true, diff --git a/packages/cli/src/acp-integration/session/rewrite/LlmRewriter.ts b/packages/cli/src/acp-integration/session/rewrite/LlmRewriter.ts index 5783497f091..6d9d66f3e59 100644 --- a/packages/cli/src/acp-integration/session/rewrite/LlmRewriter.ts +++ b/packages/cli/src/acp-integration/session/rewrite/LlmRewriter.ts @@ -134,6 +134,8 @@ export class LlmRewriter { ], }); + if (signal?.aborted) return null; + const rewritten = result.text; // If LLM returns empty or very short, skip @@ -147,20 +149,6 @@ export class LlmRewriter { `--- OUTPUT ---\n${rewritten}\n---`, ); - // Update context for next turn. Only the last `contextTurns` outputs are - // ever read (see the context slice above), so keep at most that many to - // avoid unbounded growth over a long session. Infinity ('all') keeps - // everything; 0 means the history is never read, so store nothing. - if (this.contextTurns > 0) { - this.outputHistory.push(rewritten); - if ( - Number.isFinite(this.contextTurns) && - this.outputHistory.length > this.contextTurns - ) { - this.outputHistory = this.outputHistory.slice(-this.contextTurns); - } - } - return rewritten; } catch (error) { debugLogger.warn( @@ -169,4 +157,15 @@ export class LlmRewriter { return null; } } + + commitOutput(rewritten: string): void { + if (this.contextTurns <= 0) return; + this.outputHistory.push(rewritten); + if ( + Number.isFinite(this.contextTurns) && + this.outputHistory.length > this.contextTurns + ) { + this.outputHistory = this.outputHistory.slice(-this.contextTurns); + } + } } diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts index abfe7d1c32f..ea28601d833 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts @@ -22,6 +22,7 @@ vi.mock('@qwen-code/qwen-code-core', () => ({ vi.mock('./LlmRewriter.js', () => ({ LlmRewriter: vi.fn().mockImplementation(() => ({ rewrite: vi.fn().mockResolvedValue('rewritten text'), + commitOutput: vi.fn(), })), })); @@ -229,7 +230,9 @@ describe('MessageRewriteMiddleware', () => { content: { type: 'text', text: 'automatic turn answer' }, } as unknown as SessionUpdate); await middleware.flushTurn(); + const rewriteSignal = rewriter.rewrite.mock.calls[0][1] as AbortSignal; middleware.discardTurn(); + expect(rewriteSignal.aborted).toBe(true); resolveRewrite('late automatic rewrite'); await middleware.waitForPendingRewrites(); @@ -238,6 +241,53 @@ describe('MessageRewriteMiddleware', () => { }); describe('flushTurn — tool_call boundary', () => { + it('commits rewrite context only after successful delivery', async () => { + const { LlmRewriter } = await import('./LlmRewriter.js'); + const sendUpdate = vi.fn().mockImplementation(async (update) => { + if (update._meta?.rewritten === true) { + const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { + commitOutput: ReturnType; + }; + expect(rewriter.commitOutput).not.toHaveBeenCalled(); + } + }); + const { middleware } = createMiddleware('message', sendUpdate); + const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { + commitOutput: ReturnType; + }; + + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'main answer' }, + } as unknown as SessionUpdate); + await middleware.flushTurn(); + await middleware.waitForPendingRewrites(); + + expect(rewriter.commitOutput).toHaveBeenCalledWith('rewritten text'); + }); + + it('does not commit rewrite context when delivery fails', async () => { + const sendUpdate = vi.fn().mockImplementation(async (update) => { + if (update._meta?.rewritten === true) { + throw new Error('delivery failed'); + } + }); + const { middleware } = createMiddleware('message', sendUpdate); + const { LlmRewriter } = await import('./LlmRewriter.js'); + const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { + commitOutput: ReturnType; + }; + + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'main answer' }, + } as unknown as SessionUpdate); + await middleware.flushTurn(); + await middleware.waitForPendingRewrites(); + + expect(rewriter.commitOutput).not.toHaveBeenCalled(); + }); + it('should flush before passing through tool_call', async () => { const { middleware, mockSendUpdate } = createMiddleware(); diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts index d944031027e..fe155bd1856 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts @@ -49,6 +49,7 @@ export class MessageRewriteMiddleware { private readonly timeoutMs: number; private turnIndex = 0; private generation = 0; + private generationAbortController = new AbortController(); private turnMeta: Record | undefined; private turnOwnerPromptId: string | undefined; @@ -166,9 +167,11 @@ export class MessageRewriteMiddleware { // Always enforce a timeout, combined with caller's signal if provided const timeoutSignal = AbortSignal.timeout(this.timeoutMs); - const rewriteSignal = signal - ? AbortSignal.any([signal, timeoutSignal]) - : timeoutSignal; + const rewriteSignal = AbortSignal.any([ + ...(signal ? [signal] : []), + timeoutSignal, + this.generationAbortController.signal, + ]); this.pendingRewrites.push( (async () => { @@ -202,6 +205,8 @@ export class MessageRewriteMiddleware { replacesMessageText: content.messages.length > 0, }, ); + if (generation !== this.generation) return; + this.rewriter.commitOutput(rewritten); } catch (error) { debugLogger.warn( `Turn ${turnIdx}: rewrite failed: ${error instanceof Error ? error.message : String(error)}`, @@ -212,6 +217,8 @@ export class MessageRewriteMiddleware { } discardTurn(): void { + this.generationAbortController.abort(); + this.generationAbortController = new AbortController(); this.generation++; this.turnBuffer.discard(); this.turnMeta = undefined; diff --git a/packages/cli/src/serve/capabilities.ts b/packages/cli/src/serve/capabilities.ts index bedf3d200cd..78a6610f4bb 100644 --- a/packages/cli/src/serve/capabilities.ts +++ b/packages/cli/src/serve/capabilities.ts @@ -104,6 +104,10 @@ export const SERVE_CAPABILITY_REGISTRY = { session_stats: { since: 'v1' }, session_lsp: { since: 'v1' }, session_status: { since: 'v1' }, + // Poll one prompt's live or persisted turn outcome through + // `GET /session/:id/turns/current` or + // `GET /session/:id/turns/:promptId`. + session_turn_status: { since: 'v1' }, session_close: { since: 'v1' }, session_archive: { since: 'v1' }, session_metadata: { since: 'v1' }, diff --git a/packages/cli/src/serve/server.test.ts b/packages/cli/src/serve/server.test.ts index e223c7dcce1..888a05d393b 100644 --- a/packages/cli/src/serve/server.test.ts +++ b/packages/cli/src/serve/server.test.ts @@ -427,6 +427,7 @@ const EXPECTED_STAGE1_FEATURES = [ 'session_stats', 'session_lsp', 'session_status', + 'session_turn_status', 'session_close', 'session_archive', 'session_metadata', From 71dc1beb827ff2136ef19e001dee3d361d9572cc Mon Sep 17 00:00:00 2001 From: hit_aran Date: Mon, 10 Aug 2026 15:10:48 +0800 Subject: [PATCH 14/25] fix(daemon): harden turn result polling --- .../plans/daemon-turn-status-blocker-fixes.md | 158 ++++-- .../cli/qwen-serve-routes.test.ts | 1 + .../cli/qwen-serve-streaming.test.ts | 526 +++++++++++++++--- integration-tests/fake-openai-server.ts | 13 + packages/acp-bridge/src/bridge.test.ts | 352 ++++++++++-- packages/acp-bridge/src/bridge.ts | 113 +++- packages/acp-bridge/src/bridgeTypes.ts | 7 +- packages/acp-bridge/src/status.ts | 1 + .../cli/src/acp-integration/acpAgent.test.ts | 153 +++++ packages/cli/src/acp-integration/acpAgent.ts | 29 +- .../acp-integration/session/Session.test.ts | 234 +++++++- .../src/acp-integration/session/Session.ts | 182 +++--- .../rewrite/MessageRewriteMiddleware.test.ts | 29 + .../rewrite/MessageRewriteMiddleware.ts | 4 +- packages/cli/src/serve/routes/session.ts | 4 +- .../src/services/chatRecordingService.test.ts | 57 ++ .../core/src/services/chatRecordingService.ts | 150 ++++- .../core/src/services/sessionService.test.ts | 41 ++ packages/core/src/services/sessionService.ts | 1 + 19 files changed, 1766 insertions(+), 289 deletions(-) diff --git a/docs/plans/daemon-turn-status-blocker-fixes.md b/docs/plans/daemon-turn-status-blocker-fixes.md index bd4f4159b22..6a0f6e0bc21 100644 --- a/docs/plans/daemon-turn-status-blocker-fixes.md +++ b/docs/plans/daemon-turn-status-blocker-fixes.md @@ -1,114 +1,152 @@ -# Daemon Turn Status Blocker Fixes Implementation Plan +# Daemon Turn Status Bounded-History Fixes Implementation Plan > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. -**Goal:** Fix the eight confirmed correctness blockers on PR #8682 without expanding the change to unresolved Suggestions. +**Goal:** Make exact `sessionId + promptId` polling reliable for every active-history turn inside the existing bounded transcript scan window. -**Architecture:** Preserve the existing HTTP routes, persisted `turn_result` format, and bounded terminal overlay. Normalize controlled cancellation at its source, keep pending-list live state aligned with formal terminal publication, make result capture accept only canonical answer emissions, reset rewrite state at automatic-turn ownership boundaries, and map an empty transcript to “no persisted result.” +**Architecture:** Keep the existing HTTP routes and JSONL transcript. Use the transcript as the bounded durable source, retain only a small transient terminal overlay, and make every normally admitted terminal path append the same bounded `turn_result` shape. Fold the review comments into seven root-cause fixes rather than adding independent stores or state machines. -**Tech Stack:** TypeScript, ACP bridge/session runtime, Vitest, JSONL transcript reader. +**Tech Stack:** TypeScript, ACP bridge/session runtime, Vitest, JSONL transcript reader, real daemon integration tests. ## Global Constraints -- Work from exact PR head `20a9dd451c1acc198a96e8f936f1b0256f2e5942` in the isolated worktree. -- Change only confirmed Critical behavior; defer unresolved Suggestions. -- Preserve route paths, response schema, authorization, memory bounds, and transcript scan bounds. -- Add a failing regression test before each production change. -- Run tests from the owning package directory. -- Do not force-push. +- Work from exact PR head `3493ae055c0a4440c51a9013d3f47493381475bd`. +- “Within the system limit” means the current active transcript chain scanned backward for at most 10 pages × 500 records, with 4 MiB per page. +- Preserve `GET /session/:id/turns/:promptId` and `/turns/current`, client-id authorization, and the 32,768-character prompt/result cap. +- Agent-side model settlement keeps the existing best-effort recording behavior; bridge-owned pre-dispatch outcomes are acknowledged only after their strict transcript write succeeds. +- No database, unbounded daemon history, cron-result routing, or prompt-count index. +- Add and run a failing regression test before each production behavior change. +- Tests run from the owning package directory; integration tests run through the repository scripts or from `integration-tests/`. +- Do not commit, push, reply, resolve threads, rerun CI, or modify the PR without separate authorization. --- -### Task 1: Normalize controlled prompt cancellation +### Task 1: Fix deterministic capability CI failure **Files:** -- Modify: `packages/cli/src/acp-integration/session/Session.ts` -- Test: `packages/cli/src/acp-integration/session/Session.test.ts` +- Modify: `integration-tests/cli/qwen-serve-routes.test.ts` **Interfaces:** -- Consumes: `AbortSignal.reason`, `USER_CANCEL_ABORT_REASON`, and `SESSION_DISPOSE_ABORT_REASON`. -- Produces: one shared controlled-cancellation predicate used by stream gates and the outer recording classifier. +- Consumes: `SERVE_CAPABILITY_REGISTRY` order. +- Produces: integration baseline containing `session_turn_status` immediately after `session_status`. -- [ ] Add a test where `dispose()` aborts a non-stream signal-aware await and assert the persisted state is `cancelled`. -- [ ] Run the focused test and verify it fails with persisted state `error`. -- [ ] Add a test where a successor supersedes a predecessor whose await rejects on abort and assert the predecessor persists `cancelled`. -- [ ] Run the focused test and verify it fails with persisted state `error`. -- [ ] Abort the predecessor with an explicit controlled reason and reuse one cancellation predicate in all classifiers. -- [ ] Run the focused tests and the complete `Session.test.ts` file. +- [ ] Run the integration capability test and capture the expected missing-feature failure. +- [ ] Add only `session_turn_status` to the expected ordered list. +- [ ] Re-run the focused integration file and verify it passes. -### Task 2: Preserve deadline recovery and terminal polling precedence +### Task 2: Bound and race-proof terminal status resolution **Files:** - Modify: `packages/acp-bridge/src/bridge.ts` +- Modify: `packages/acp-bridge/src/bridgeTypes.ts` - Test: `packages/acp-bridge/src/bridge.test.ts` **Interfaces:** -- Consumes: `PendingPromptEntry.removed`, `terminalPublished`, deadline rejection, and the terminal overlay. -- Produces: prompt polling that never reports a terminal prompt as live and a running removal that retains its deadline recovery fence. +- Consumes: live pending entries, persisted `turn_result`, and recent formal terminal outcomes. +- Produces: a small fixed overlay that is re-read after the transcript RPC and evicted when persistence is visible. + +- [ ] Add a failing test where a terminal is published while `sessionTurnStatus` is awaiting and assert the post-await terminal wins. +- [ ] Add a failing capacity test independent of `eventRingSize` and a persisted-match eviction test. +- [ ] Introduce one small named overlay limit, re-read after await, and delete matching overlay entries after persisted enrichment. +- [ ] Run focused tests and the complete `bridge.test.ts` file. + +### Task 3: Persist all normally admitted terminal paths + +**Files:** + +- Modify: `packages/acp-bridge/src/bridge.ts` +- Modify: `packages/acp-bridge/src/status.ts` +- Modify: `packages/cli/src/acp-integration/acpAgent.ts` +- Modify: `packages/cli/src/acp-integration/session/Session.ts` +- Modify: `packages/core/src/services/chatRecordingService.ts` +- Test: corresponding collocated test files. + +**Interfaces:** + +- Consumes: trusted `InvocationContextV1`, bridge pre-dispatch cancellation/error terminals, and `ChatRecordingService.recordTurnResult`. +- Produces: one bounded persisted record for queued cancellation and for every failure after bridge admission but before model dispatch. -- [ ] Add a test that removes a running prompt whose agent ignores cancellation, advances past its deadline, and verifies the FIFO dispatches the successor. -- [ ] Run the test and verify the successor remains blocked. -- [ ] Add a test that expires a queued prompt behind a wedged predecessor and verifies by-id polling returns `prompt_deadline_exceeded`, not `queued`. -- [ ] Run the test and verify it reports `queued`. -- [ ] Separate “status terminal published” from “deadline recovery completed”: do not let running removal suppress deadline cleanup, and exclude formally terminal entries from live polling. -- [ ] Run the focused tests and the complete `bridge.test.ts` file. +- [ ] Add failing restart-oriented tests for queued cancellation and pre-record `assertCanStartTurn`/live-tool failure. +- [ ] Add a trusted child control method that appends a bridge-owned pre-dispatch terminal through the existing recording service; do not add a new file/store. +- [ ] Validate invocation session ownership before recording, create the recording before fallible child admission checks, and settle every exit path. +- [ ] Make `startedAt` optional until actual model dispatch and update projections/tests. +- [ ] Run focused bridge, agent, Session, and recording-service tests. -### Task 3: Capture only the canonical visible answer +### Task 4: Normalize bounded terminal errors + +**Files:** + +- Modify: `packages/core/src/services/chatRecordingService.ts` +- Modify: `packages/acp-bridge/src/bridge.ts` +- Modify: `packages/cli/src/acp-integration/session/Session.ts` +- Test: corresponding collocated test files. + +**Interfaces:** + +- Consumes: arbitrary thrown values from provider/tool/ACP paths. +- Produces: a non-throwing error payload with bounded message/code and explicit truncation metadata, shared by persisted and overlay projections. + +- [ ] Add failing tests for oversized message/code and throwing coercion/getters. +- [ ] Implement one core-safe terminal-error normalizer and use it on both sides. +- [ ] Verify oversized error records remain below transcript page limits and expose truncation flags. +- [ ] Run focused tests. + +### Task 5: Preserve canonical visible-answer and terminal consistency **Files:** - Modify: `packages/cli/src/acp-integration/session/Session.ts` - Modify: `packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts` -- Test: `packages/cli/src/acp-integration/session/Session.test.ts` -- Test: `packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts` +- Test: `Session.test.ts` and `MessageRewriteMiddleware.test.ts`. **Interfaces:** -- Consumes: `MessageRewriteEmissionContext`, rewrite target, update metadata, and automatic-turn boundaries. -- Produces: result segments where only a message rewrite can replace a raw answer segment and automatic-turn residue cannot cross into a daemon prompt. +- Consumes: raw answer chunks, rewritten replacements, diagnostic/status messages, prompt cancellation, and live-end cleanup. +- Produces: `resultText` equal to the final primary answer the user could observe. -- [ ] Add a test showing the token-limit diagnostic is visible on the wire but absent from persisted `resultText`; verify it fails. -- [ ] Add a `target: 'thought'` test proving the persisted result remains the raw answer; verify it fails with rewritten thought text. -- [ ] Add an aborted cron/notification residue test proving the next daemon prompt rewrites only its own answer; verify it fails with cross-turn content. -- [ ] Tag internal diagnostics as non-answer status output. -- [ ] Extend the internal rewrite context with whether the rewrite replaces message text, and gate replacement on that field. -- [ ] Add a middleware reset method that clears buffered turn state without emitting a rewrite, and invoke it after automatic work has drained and before publishing a daemon turn recording. -- [ ] Run the focused tests, then both complete test files. +- [ ] Add failing tests proving repeated-tool diagnostics are visible and rewrite-aware but excluded from `resultText`. +- [ ] Add failing tests for model error during an in-flight rewrite and cancellation immediately before rewrite delivery/commit. +- [ ] Route diagnostics with explicit non-answer metadata through the rewrite-aware path. +- [ ] Drain or discard the owning rewrite before settlement and re-check abort immediately before send and commit. +- [ ] Include awaited live-end cleanup in the terminal outcome so a later cleanup rejection cannot follow an already persisted `completed` result. +- [ ] Run both complete test files. -### Task 4: Treat an empty transcript as no persisted turn +### Task 6: Keep fork and rewind identities consistent **Files:** -- Modify: `packages/cli/src/acp-integration/acpAgent.ts` -- Test: `packages/cli/src/acp-integration/acpAgent.test.ts` +- Modify: `packages/core/src/services/sessionService.ts` +- Modify: `packages/acp-bridge/src/bridge.ts` +- Test: `sessionService.test.ts` and `bridge.test.ts`. **Interfaces:** -- Consumes: `SessionTranscriptSnapshotUnavailableError` from a zero-record transcript. -- Produces: `{ v: 1, sessionId, turnResult: null }` only for the initial empty snapshot while preserving typed failures for unavailable non-empty snapshots and oversized transcripts. +- Consumes: active transcript reconstruction, fork record copying, and successful rewind response. +- Produces: forks without source-session `turn_result` identity and rewinds without abandoned overlay terminals. -- [ ] Add a test whose turn-status reader throws `SessionTranscriptSnapshotUnavailableError` for an empty snapshot and assert `turnResult: null`; verify it fails. -- [ ] Implement the narrow empty-snapshot mapping without swallowing oversized-page or cursor errors. -- [ ] Run the focused test and complete `acpAgent.test.ts` file. +- [ ] Add a failing fork test proving a source `turn_result` is not copied. +- [ ] Add a failing rewind test proving an abandoned overlay result is no longer returned while surviving active transcript results remain readable. +- [ ] Exclude `turn_result` from fork copies and clear/reconcile terminal overlay immediately after successful transcript rewind. +- [ ] Run both complete test files. -### Task 5: Verify, self-audit, commit, and push +### Task 7: Full verification and review **Files:** -- Review all files changed by Tasks 1–4 and this plan. +- Review every changed and untracked file. **Interfaces:** -- Consumes: all four independently green task groups. -- Produces: a verified commit on `feat/daemon-turn-status-polling`. +- Consumes: all green task groups. +- Produces: a verified commit and non-force push after explicit user authorization. -- [ ] Run package-focused tests for every changed test file. -- [ ] Run `npm run build` and `npm run typecheck` from the repository root. -- [ ] Run `npm run test:integration:cli:sandbox:none` and the daemon polling E2E scenarios where available. -- [ ] Perform two consecutive clean diff self-audit passes, resetting the count after any edit. -- [ ] Commit only the reviewed files with a Conventional Commit message. -- [ ] Fetch and verify the remote PR head has not moved, then push without force to `origin/feat/daemon-turn-status-polling`. +- [ ] Run all focused test files from their package directories. +- [ ] Run formatting on changed files, inspect formatting changes, then `npm run lint`, `npm run build`, `npm run typecheck`, and `npm run bundle`. +- [ ] Run the six dedicated real-daemon scenarios for capability, completed result polling, the full public turn-state matrix, restart durability, diagnostic/result isolation, late-rewrite cancellation, and provider error polling. +- [ ] Ask the read-only test-engineer agent to audit every Critical as either public-daemon E2E or a deterministic component-level fault-injection regression. +- [ ] Perform two consecutive clean full-diff self-audit passes; any edit resets the count. +- [ ] Re-fetch PR head/state, confirm the reviewed base has not moved, then commit and push without force. diff --git a/integration-tests/cli/qwen-serve-routes.test.ts b/integration-tests/cli/qwen-serve-routes.test.ts index 40eb1f529af..12b0889ebc4 100644 --- a/integration-tests/cli/qwen-serve-routes.test.ts +++ b/integration-tests/cli/qwen-serve-routes.test.ts @@ -348,6 +348,7 @@ describe('qwen serve — capabilities envelope', () => { 'session_stats', 'session_lsp', 'session_status', + 'session_turn_status', 'session_close', 'session_archive', 'session_metadata', diff --git a/integration-tests/cli/qwen-serve-streaming.test.ts b/integration-tests/cli/qwen-serve-streaming.test.ts index 4121781b059..ef561d47145 100644 --- a/integration-tests/cli/qwen-serve-streaming.test.ts +++ b/integration-tests/cli/qwen-serve-streaming.test.ts @@ -157,10 +157,118 @@ let pendingWritePath = ''; let pendingReadPath = ''; let pendingReadMarker = ''; let pendingReadSentinel = ''; +let blockedPromptMarker = ''; +let blockedPromptGate: Promise | undefined; +let releaseBlockedPrompt: (() => void) | undefined; +let repeatedFailureMarker = ''; +let repeatedFailureRequestCount = 0; +let rewritePromptMarker = ''; +let delayedRewriteMarker = ''; +let delayedRewriteGate: Promise | undefined; +let releaseDelayedRewrite: (() => void) | undefined; +let providerErrorMarker = ''; + +const defaultSettings = { + experimental: { todoStopGuard: true }, + ui: { enableFollowupSuggestions: false }, +}; + +function writeUserSettings(settings: Record): void { + writeFileSync( + path.join(homeDir, '.qwen', 'settings.json'), + JSON.stringify(settings), + ); +} + +async function startDaemon(): Promise { + daemon = spawn( + process.execPath, + [ + CLI_BIN, + 'serve', + '--port', + '0', + '--token', + TOKEN, + '--hostname', + '127.0.0.1', + // Pin a scratch workspace so the daemon and every child session share + // one hermetic settings/trust boundary across direct and CI runs. + '--workspace', + workspaceDir, + ], + { + stdio: ['ignore', 'pipe', 'pipe'], + env: { + ...Object.fromEntries( + Object.entries(process.env).filter( + ([key]) => !/^(https?|all)_proxy$/i.test(key), + ), + ), + HOME: homeDir, + QWEN_HOME: path.join(homeDir, '.qwen'), + QWEN_ACP_LOCAL_READ_ROOTS: '', + NO_PROXY: '127.0.0.1,localhost', + no_proxy: '127.0.0.1,localhost', + OPENAI_API_KEY: 'fake-key', + OPENAI_BASE_URL: fakeServer.baseUrl, + OPENAI_MODEL: 'fake-model', + QWEN_MODEL: 'fake-model', + QWEN_CODE_ACP_REPEATED_TOOL_FAILURE_GUARD: repeatedFailureMarker + ? 'enforce' + : 'shadow', + }, + }, + ); + port = await new Promise((resolve, reject) => { + let buf = ''; + // Clear the boot timeout on success so it cannot keep vitest alive. + const bootTimer = setTimeout( + () => reject(new Error('daemon boot timeout')), + 10_000, + ); + const onData = (chunk: Buffer) => { + buf += chunk.toString(); + const m = buf.match(/listening on http:\/\/127\.0\.0\.1:(\d+)/); + if (m) { + daemon.stdout?.off('data', onData); + clearTimeout(bootTimer); + resolve(Number(m[1])); + } + }; + daemon.stdout!.on('data', onData); + daemon.once('exit', (c) => { + clearTimeout(bootTimer); + reject(new Error(`daemon exited with ${c}`)); + }); + }); + base = `http://127.0.0.1:${port}`; + client = new DaemonClient({ baseUrl: base, token: TOKEN }); +} + +async function stopDaemon(): Promise { + if (daemon && daemon.exitCode === null) { + daemon.kill('SIGTERM'); + await new Promise((resolve) => daemon.once('exit', resolve)); + } +} + +async function turnStatus( + sessionId: string, + promptId: string, +): Promise> { + const response = await fetch( + `${base}/session/${sessionId}/turns/${promptId}`, + { headers: { Authorization: `Bearer ${TOKEN}` } }, + ); + return response.ok + ? ((await response.json()) as Record) + : { status: response.status }; +} beforeAll(async () => { if (SKIP) return; - fakeServer = await startFakeOpenAIServer(({ body }) => { + fakeServer = await startFakeOpenAIServer(async ({ body }) => { const messages = JSON.stringify(body['messages'] ?? []); const hasToolResult = messages.includes('"role":"tool"') || messages.includes('"tool_call_id"'); @@ -186,6 +294,48 @@ beforeAll(async () => { return { content: 'The test Todo remains unfinished.' }; } + if (rewritePromptMarker && messages.includes(rewritePromptMarker)) { + if (delayedRewriteMarker) { + await delayedRewriteGate; + return { content: 'late rewritten text' }; + } + return { content: 'rewritten framework diagnostic' }; + } + + if (delayedRewriteMarker && messages.includes(delayedRewriteMarker)) { + return { content: 'raw answer before cancellation' }; + } + + if (blockedPromptMarker && messages.includes(blockedPromptMarker)) { + await blockedPromptGate; + return { content: 'blocking turn complete' }; + } + + if (repeatedFailureMarker && messages.includes(repeatedFailureMarker)) { + repeatedFailureRequestCount += 1; + const callCount = repeatedFailureRequestCount < 3 ? 4 : 1; + return { + toolCalls: Array.from({ length: callCount }, (_, index) => + fakeToolCall('read_file', { + file_path: path.join( + workspaceDir, + `missing-${repeatedFailureRequestCount}-${index}.txt`, + ), + }), + ), + }; + } + + if (providerErrorMarker && messages.includes(providerErrorMarker)) { + return { + httpError: { + status: 400, + message: 'simulated provider failure', + code: 'invalid_request', + }, + }; + } + if (pendingWritePath && messages.includes('fan-out') && !hasToolResult) { return { toolCalls: [ @@ -240,92 +390,14 @@ beforeAll(async () => { mkdirSync(qwenHome, { recursive: true }); writeFileSync( path.join(qwenHome, 'settings.json'), - JSON.stringify({ - experimental: { todoStopGuard: true }, - ui: { enableFollowupSuggestions: false }, - }), + JSON.stringify(defaultSettings), ); workspaceDir = mkdtempSync(path.join(tmpdir(), 'qwen-serve-streaming-ws-')); - daemon = spawn( - process.execPath, - [ - CLI_BIN, - 'serve', - '--port', - '0', - '--token', - TOKEN, - '--hostname', - '127.0.0.1', - // Per #3803 §02 (1 daemon = 1 workspace), pin the bound - // workspace so every `createOrAttachSession({ workspaceCwd })` - // below matches. Without this the daemon inherits the test - // runner's cwd (CI / IDE-launcher / direct vitest invocations - // all differ) and every session create returns 400 - // workspace_mismatch — the SSE / permission / Last-Event-ID - // tests below would all silently 404. A scratch workspace (not - // the checkout) also keeps sessions hermetic: the daemon merges - // the workspace's `.qwen/settings.json` into every session, and - // a stray one on a shared runner (e.g. a `tools.sandbox` mode or - // a `tools.core` allowlist missing `todo_write`) silently breaks - // the Stop Guard flow below. - '--workspace', - workspaceDir, - ], - { - stdio: ['ignore', 'pipe', 'pipe'], - env: { - ...Object.fromEntries( - Object.entries(process.env).filter( - ([key]) => !/^(https?|all)_proxy$/i.test(key), - ), - ), - HOME: homeDir, - QWEN_HOME: path.join(homeDir, '.qwen'), - QWEN_ACP_LOCAL_READ_ROOTS: '', - NO_PROXY: '127.0.0.1,localhost', - no_proxy: '127.0.0.1,localhost', - OPENAI_API_KEY: 'fake-key', - OPENAI_BASE_URL: fakeServer.baseUrl, - OPENAI_MODEL: 'fake-model', - QWEN_MODEL: 'fake-model', - }, - }, - ); - port = await new Promise((resolve, reject) => { - let buf = ''; - // Capture the timeout handle so we can clear it on success — an - // un-cleared 10s timer outlives the spawn promise and keeps the - // vitest event loop alive past the test, manifesting as - // intermittent flakes on slow CI. - const bootTimer = setTimeout( - () => reject(new Error('daemon boot timeout')), - 10_000, - ); - const onData = (chunk: Buffer) => { - buf += chunk.toString(); - const m = buf.match(/listening on http:\/\/127\.0\.0\.1:(\d+)/); - if (m) { - daemon.stdout?.off('data', onData); - clearTimeout(bootTimer); - resolve(Number(m[1])); - } - }; - daemon.stdout!.on('data', onData); - daemon.once('exit', (c) => { - clearTimeout(bootTimer); - reject(new Error(`daemon exited with ${c}`)); - }); - }); - base = `http://127.0.0.1:${port}`; - client = new DaemonClient({ baseUrl: base, token: TOKEN }); + await startDaemon(); }, 30_000); afterAll(async () => { - if (!SKIP && daemon && daemon.exitCode === null) { - daemon.kill('SIGTERM'); - await new Promise((r) => daemon.once('exit', r)); - } + if (!SKIP) await stopDaemon(); await fakeServer?.close(); if (homeDir) { rmSync(homeDir, { recursive: true, force: true }); @@ -877,3 +949,293 @@ describePOSIX('qwen serve — daemon Todo Stop Guard replay', () => { ); }, 60_000); }); + +describePOSIX('qwen serve — turn result blocker regressions', () => { + it('keeps exact queued cancellation and prior completion across daemon restart', async () => { + const session = await client.createOrAttachSession({ + workspaceCwd: workspaceDir, + sessionScope: 'thread', + }); + blockedPromptMarker = `blocked-turn-${Date.now()}`; + blockedPromptGate = new Promise((resolve) => { + releaseBlockedPrompt = resolve; + }); + + try { + const idleResponse = await fetch( + `${base}/session/${session.sessionId}/turns/current`, + { headers: { Authorization: `Bearer ${TOKEN}` } }, + ); + await expect(idleResponse.json()).resolves.toMatchObject({ + sessionId: session.sessionId, + state: 'idle', + }); + + const unknownResponse = await fetch( + `${base}/session/${session.sessionId}/turns/not-a-prompt`, + { headers: { Authorization: `Bearer ${TOKEN}` } }, + ); + expect(unknownResponse.status).toBe(404); + await expect(unknownResponse.json()).resolves.toMatchObject({ + code: 'prompt_not_found', + promptId: 'not-a-prompt', + }); + + const running = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [{ type: 'text', text: blockedPromptMarker }], + }), + ); + expect(running).toBeDefined(); + if (!running) return; + await expect + .poll(() => turnStatus(session.sessionId, running.promptId)) + .toMatchObject({ + promptId: running.promptId, + state: 'running', + startedAt: expect.any(Number), + }); + + const queued = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [{ type: 'text', text: 'cancel this queued prompt' }], + }), + ); + expect(queued).toBeDefined(); + if (!queued) return; + await expect + .poll(() => turnStatus(session.sessionId, queued.promptId)) + .toMatchObject({ + promptId: queued.promptId, + state: 'queued', + }); + expect( + await turnStatus(session.sessionId, queued.promptId), + ).not.toHaveProperty('startedAt'); + + await expect( + client.removePendingPrompt(session.sessionId, queued.promptId), + ).resolves.toMatchObject({ removed: true }); + await expect + .poll(() => turnStatus(session.sessionId, queued.promptId)) + .toMatchObject({ + promptId: queued.promptId, + state: 'cancelled', + }); + expect( + await turnStatus(session.sessionId, queued.promptId), + ).not.toHaveProperty('startedAt'); + + releaseBlockedPrompt?.(); + await expect + .poll(() => turnStatus(session.sessionId, running.promptId), { + timeout: 30_000, + }) + .toMatchObject({ + promptId: running.promptId, + state: 'completed', + resultText: 'blocking turn complete', + }); + + await stopDaemon(); + await startDaemon(); + await client.resumeSession(session.sessionId, { + workspaceCwd: workspaceDir, + }); + await expect( + turnStatus(session.sessionId, running.promptId), + ).resolves.toMatchObject({ + state: 'completed', + resultText: 'blocking turn complete', + }); + await expect( + turnStatus(session.sessionId, queued.promptId), + ).resolves.toMatchObject({ state: 'cancelled' }); + expect( + await turnStatus(session.sessionId, queued.promptId), + ).not.toHaveProperty('startedAt'); + } finally { + releaseBlockedPrompt?.(); + blockedPromptMarker = ''; + blockedPromptGate = undefined; + releaseBlockedPrompt = undefined; + await client.cancel(session.sessionId).catch(() => undefined); + await client.closeSession(session.sessionId).catch(() => undefined); + } + }, 90_000); + + it('rewrites repeated-tool diagnostics without recording them as the answer', async () => { + repeatedFailureMarker = `repeated-failure-${Date.now()}`; + repeatedFailureRequestCount = 0; + rewritePromptMarker = `rewrite-framework-diagnostic-${Date.now()}`; + writeUserSettings({ + ...defaultSettings, + messageRewrite: { + enabled: true, + target: 'message', + prompt: rewritePromptMarker, + contextTurns: 0, + }, + }); + await stopDaemon(); + await startDaemon(); + const session = await client.createOrAttachSession({ + workspaceCwd: workspaceDir, + sessionScope: 'thread', + }); + + try { + const accepted = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [{ type: 'text', text: repeatedFailureMarker }], + }), + ); + expect(accepted).toBeDefined(); + if (!accepted) return; + + await expect + .poll(() => turnStatus(session.sessionId, accepted.promptId), { + timeout: 60_000, + }) + .toMatchObject({ + state: 'completed', + }); + const status = await turnStatus(session.sessionId, accepted.promptId); + expect(status['resultText']).toBeUndefined(); + + const events: DaemonEvent[] = []; + const ac = new AbortController(); + for await (const event of sseFrames(session.sessionId, { + lastEventId: accepted.lastEventId, + signal: ac.signal, + })) { + events.push(event); + if (event.type === 'turn_complete') break; + } + ac.abort(); + expect(JSON.stringify(events)).toContain( + 'rewritten framework diagnostic', + ); + } finally { + repeatedFailureMarker = ''; + repeatedFailureRequestCount = 0; + rewritePromptMarker = ''; + writeUserSettings(defaultSettings); + await client.cancel(session.sessionId).catch(() => undefined); + await client.closeSession(session.sessionId).catch(() => undefined); + await stopDaemon(); + await startDaemon(); + } + }, 90_000); + + it('drops a rewrite that finishes after its turn is cancelled', async () => { + delayedRewriteMarker = `delayed-rewrite-${Date.now()}`; + rewritePromptMarker = `rewrite-cancelled-turn-${Date.now()}`; + delayedRewriteGate = new Promise((resolve) => { + releaseDelayedRewrite = resolve; + }); + writeUserSettings({ + ...defaultSettings, + messageRewrite: { + enabled: true, + target: 'message', + prompt: rewritePromptMarker, + contextTurns: 0, + timeoutMs: 60_000, + }, + }); + await stopDaemon(); + await startDaemon(); + const session = await client.createOrAttachSession({ + workspaceCwd: workspaceDir, + sessionScope: 'thread', + }); + + try { + const accepted = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [{ type: 'text', text: delayedRewriteMarker }], + }), + ); + expect(accepted).toBeDefined(); + if (!accepted) return; + + await expect + .poll( + () => + fakeServer.requests.some((request) => { + const messages = JSON.stringify(request.body['messages'] ?? []); + return messages.includes(rewritePromptMarker); + }), + { timeout: 30_000 }, + ) + .toBe(true); + const cancellation = client.cancel(session.sessionId); + await expect + .poll(() => turnStatus(session.sessionId, accepted.promptId), { + timeout: 30_000, + }) + .toMatchObject({ state: 'cancelled' }); + releaseDelayedRewrite?.(); + await cancellation; + + const status = await turnStatus(session.sessionId, accepted.promptId); + expect(JSON.stringify(status)).not.toContain('late rewritten text'); + + const events: DaemonEvent[] = []; + const ac = new AbortController(); + for await (const event of sseFrames(session.sessionId, { + lastEventId: accepted.lastEventId, + signal: ac.signal, + })) { + events.push(event); + if (event.type === 'turn_complete') break; + } + ac.abort(); + expect(JSON.stringify(events)).not.toContain('late rewritten text'); + } finally { + releaseDelayedRewrite?.(); + delayedRewriteMarker = ''; + delayedRewriteGate = undefined; + releaseDelayedRewrite = undefined; + rewritePromptMarker = ''; + writeUserSettings(defaultSettings); + await client.cancel(session.sessionId).catch(() => undefined); + await client.closeSession(session.sessionId).catch(() => undefined); + await stopDaemon(); + await startDaemon(); + } + }, 90_000); + + it('returns provider failures as pollable turn errors', async () => { + providerErrorMarker = `provider-error-${Date.now()}`; + const session = await client.createOrAttachSession({ + workspaceCwd: workspaceDir, + sessionScope: 'thread', + }); + + try { + const accepted = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [{ type: 'text', text: providerErrorMarker }], + }), + ); + expect(accepted).toBeDefined(); + if (!accepted) return; + await expect + .poll(() => turnStatus(session.sessionId, accepted.promptId), { + timeout: 30_000, + }) + .toMatchObject({ + state: 'error', + error: { + message: expect.any(String), + code: expect.any(String), + }, + }); + } finally { + providerErrorMarker = ''; + await client.closeSession(session.sessionId).catch(() => undefined); + } + }, 60_000); +}); diff --git a/integration-tests/fake-openai-server.ts b/integration-tests/fake-openai-server.ts index 7ba74a20930..c919fa75d5a 100644 --- a/integration-tests/fake-openai-server.ts +++ b/integration-tests/fake-openai-server.ts @@ -26,6 +26,11 @@ export type FakeOpenAIToolCall = { }; export type FakeOpenAIResponse = { + httpError?: { + status: number; + message: string; + code?: string; + }; model?: string; content?: string; contentChunks?: string[]; @@ -122,6 +127,14 @@ export async function startFakeOpenAIServer( requests.push({ body, headers: req.headers }); const response = await handler({ body, requestIndex }); + if (response.httpError) { + const { status, ...error } = response.httpError; + res.writeHead(status, { + 'content-type': 'application/json', + }); + res.end(JSON.stringify({ error })); + return; + } if (body['stream'] === true) { writeStreamed( res, diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 9bb5fbf1b4d..bf27c69ce6a 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -3593,6 +3593,56 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('clears terminal overlays after a successful transcript rewind', async () => { + const bridge = makeBridge({ + channelFactory: async () => + makeChannel({ + promptImpl: () => ({ stopReason: 'end_turn' }), + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { v: 1, sessionId: SESS_A, turnResult: null }; + } + if (method === SERVE_CONTROL_EXT_METHODS.sessionRewind) { + return { + targetTurnIndex: 0, + filesChanged: [], + filesFailed: [], + }; + } + return {}; + }, + }).channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + await bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'abandoned answer' }], + }, + undefined, + { promptId: 'prompt-before-rewind' }, + ); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-before-rewind', + ), + ).resolves.toMatchObject({ state: 'completed' }); + + await bridge.rewindSession(session.sessionId, { promptId: 'turn-0' }); + + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-before-rewind', + ), + ).resolves.toBeUndefined(); + await bridge.shutdown(); + }); + it('keeps durable artifacts when rewind cannot rebuild an artifact snapshot', async () => { const persistedSnapshots: unknown[] = []; const bridge = makeBridge({ @@ -9221,9 +9271,9 @@ describe('createAcpSessionBridge', () => { }); const queuedId = bridge.getPendingPrompts(session.sessionId)[1]?.promptId; expect(queuedId).toBeDefined(); - expect(bridge.removePendingPrompt(session.sessionId, queuedId!)).toEqual({ - removed: true, - }); + await expect( + bridge.removePendingPrompt(session.sessionId, queuedId!), + ).resolves.toEqual({ removed: true }); expect(() => bridge.sendPrompt(session.sessionId, { @@ -9692,12 +9742,12 @@ describe('createAcpSessionBridge', () => { await vi.waitFor(() => { expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(2); }); - expect( + await expect( bridge.removePendingPrompt( session.sessionId, 'removed-after-promotion', ), - ).toEqual({ removed: true }); + ).resolves.toEqual({ removed: true }); expect( handle.agent.extMethodCalls.some( (call) => call.method === TODO_STOP_GUARD_QUEUE_RELEASE_METHOD, @@ -9788,7 +9838,10 @@ describe('createAcpSessionBridge', () => { .spyOn(process.stderr, 'write') .mockImplementation(() => true); try { - const result = bridge.removePendingPrompt(session.sessionId, queuedId!); + const result = await bridge.removePendingPrompt( + session.sessionId, + queuedId!, + ); expect(result.removed).toBe(true); expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(1); await vi.waitFor(() => { @@ -9811,7 +9864,7 @@ describe('createAcpSessionBridge', () => { stderrSpy.mockRestore(); } - const again = bridge.removePendingPrompt( + const again = await bridge.removePendingPrompt( session.sessionId, 'nonexistent', ); @@ -9940,7 +9993,10 @@ describe('createAcpSessionBridge', () => { const runningId = pending[0]?.promptId; expect(runningId).toBeDefined(); - const result = bridge.removePendingPrompt(session.sessionId, runningId!); + const result = await bridge.removePendingPrompt( + session.sessionId, + runningId!, + ); expect(result.removed).toBe(true); // The running prompt is removed from the list immediately. @@ -9998,9 +10054,9 @@ describe('createAcpSessionBridge', () => { ?.promptId; expect(runningId).toBeDefined(); - expect(bridge.removePendingPrompt(session.sessionId, runningId!)).toEqual( - { removed: true }, - ); + await expect( + bridge.removePendingPrompt(session.sessionId, runningId!), + ).resolves.toEqual({ removed: true }); const p2 = bridge.sendPrompt(session.sessionId, { sessionId: session.sessionId, @@ -10019,11 +10075,11 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); - it('removePendingPrompt throws SessionNotFoundError for unknown sessions', () => { + it('removePendingPrompt throws SessionNotFoundError for unknown sessions', async () => { const bridge = makeBridge(); - expect(() => bridge.removePendingPrompt('unknown', 'some-id')).toThrow( - SessionNotFoundError, - ); + await expect( + bridge.removePendingPrompt('unknown', 'some-id'), + ).rejects.toThrow(SessionNotFoundError); }); it('getPendingPrompts throws SessionNotFoundError for unknown sessions', () => { @@ -10381,6 +10437,52 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('observes a terminal published while persisted lookup is pending', async () => { + let resolveLookup: (() => void) | undefined; + const lookupGate = new Promise((resolve) => { + resolveLookup = resolve; + }); + let lookupStarted = false; + const handle = makeChannel({ + promptImpl: () => ({ stopReason: 'end_turn' }), + extMethodImpl: async (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + lookupStarted = true; + await lookupGate; + return { v: 1, sessionId: 'ignored', turnResult: null }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + + const statusPromise = bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-settles-during-read', + ); + await vi.waitFor(() => expect(lookupStarted).toBe(true)); + await bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'settles during read' }], + }, + undefined, + { promptId: 'prompt-settles-during-read' }, + ); + resolveLookup!(); + + await expect(statusPromise).resolves.toMatchObject({ + state: 'completed', + promptId: 'prompt-settles-during-read', + }); + await bridge.shutdown(); + }); + it('falls back to a terminal status when persisted lookup fails', async () => { const handle = makeChannel({ promptImpl: () => ({ stopReason: 'end_turn' }), @@ -10420,6 +10522,65 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('drops a terminal overlay once persistence exposes the same turn', async () => { + let persistedResult: Record | null = { + promptId: 'prompt-persisted-overlay', + state: 'completed', + stopReason: 'end_turn', + startedAt: 1000, + endedAt: 2000, + promptText: 'persisted overlay', + resultText: 'persisted answer', + }; + const handle = makeChannel({ + promptImpl: () => ({ stopReason: 'end_turn' }), + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { + v: 1, + sessionId: 'ignored', + turnResult: persistedResult, + }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + await bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'persisted overlay' }], + }, + undefined, + { promptId: 'prompt-persisted-overlay' }, + ); + + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-persisted-overlay', + ), + ).resolves.toMatchObject({ + state: 'completed', + resultText: 'persisted answer', + }); + + persistedResult = null; + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-persisted-overlay', + ), + ).resolves.toBeUndefined(); + await bridge.shutdown(); + }); + it('reports removed queued and running prompts as cancelled immediately', async () => { let rejectRunning: ((err: Error) => void) | undefined; const runningGate = new Promise((_resolve, reject) => { @@ -10466,9 +10627,9 @@ describe('createAcpSessionBridge', () => { await vi.waitFor(() => { expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(2); }); - expect( + await expect( bridge.removePendingPrompt(session.sessionId, 'prompt-remove-queued'), - ).toEqual({ removed: true }); + ).resolves.toEqual({ removed: true }); await expect( bridge.getSessionTurnStatus( session.sessionId, @@ -10480,9 +10641,9 @@ describe('createAcpSessionBridge', () => { stopReason: 'cancelled', }); - expect( + await expect( bridge.removePendingPrompt(session.sessionId, 'prompt-remove-running'), - ).toEqual({ removed: true }); + ).resolves.toEqual({ removed: true }); await expect( bridge.getSessionTurnStatus( session.sessionId, @@ -10499,6 +10660,91 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('persists a queued cancellation before removePendingPrompt resolves', async () => { + let releaseRunning!: () => void; + const runningGate = new Promise((resolve) => { + releaseRunning = resolve; + }); + const recorded: Array> = []; + let releasePersistence!: () => void; + const persistenceGate = new Promise((resolve) => { + releasePersistence = resolve; + }); + const handle = makeChannel({ + promptImpl: async (request) => { + if ((request.prompt[0] as { text?: string }).text === 'running') { + await runningGate; + } + return { stopReason: 'end_turn' }; + }, + extMethodImpl: async (method, params) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + recorded.push(params as Record); + await persistenceGate; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const running = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'running' }], + }, + undefined, + { promptId: 'prompt-running-before-remove' }, + ); + const queued = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-durable-queued-remove' }, + ); + await vi.waitFor(() => + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(2), + ); + + const removal = bridge.removePendingPrompt( + session.sessionId, + 'prompt-durable-queued-remove', + ); + let removalSettled = false; + void removal.then( + () => { + removalSettled = true; + }, + () => {}, + ); + await vi.waitFor(() => expect(recorded).toHaveLength(1)); + await Promise.resolve(); + expect(removalSettled).toBe(false); + expect(recorded).toEqual([ + { + sessionId: session.sessionId, + turnResult: expect.objectContaining({ + promptId: 'prompt-durable-queued-remove', + state: 'cancelled', + stopReason: 'cancelled', + promptText: 'queued', + }), + }, + ]); + releasePersistence(); + await expect(removal).resolves.toEqual({ removed: true }); + + releaseRunning(); + await running; + await expect(queued).rejects.toMatchObject({ name: 'AbortError' }); + await bridge.shutdown(); + }); + it('preserves a deadline error while enriching it from persistence', async () => { let persistedResult: Record | null = null; const handle = makeChannel({ @@ -10552,10 +10798,21 @@ describe('createAcpSessionBridge', () => { error: { code: 'prompt_deadline_exceeded' }, resultText: 'partial visible answer', }); + persistedResult = null; + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-deadline-overlay', + ), + ).resolves.toMatchObject({ + state: 'error', + error: { code: 'prompt_deadline_exceeded' }, + }); await bridge.shutdown(); }); - it('bounds transient terminal statuses by eventRingSize', async () => { + it('bounds transient terminal statuses independently of eventRingSize', async () => { const handle = makeChannel({ promptImpl: () => ({ stopReason: 'end_turn' }), extMethodImpl: (method) => { @@ -10567,11 +10824,12 @@ describe('createAcpSessionBridge', () => { }); const bridge = makeBridge({ channelFactory: async () => handle.channel, - eventRingSize: 2, + eventRingSize: 100_000, }); const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); - for (const promptId of ['prompt-old', 'prompt-middle', 'prompt-new']) { + for (let index = 0; index < 65; index++) { + const promptId = `prompt-${index}`; await bridge.sendPrompt( session.sessionId, { @@ -10584,17 +10842,13 @@ describe('createAcpSessionBridge', () => { } await expect( - bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-old'), + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-0'), ).resolves.toBeUndefined(); await expect( - bridge.getSessionTurnStatus( - session.sessionId, - undefined, - 'prompt-middle', - ), + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-1'), ).resolves.toMatchObject({ state: 'completed' }); await expect( - bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-new'), + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-64'), ).resolves.toMatchObject({ state: 'completed' }); await bridge.shutdown(); }); @@ -10684,9 +10938,9 @@ describe('createAcpSessionBridge', () => { ); await new Promise((r) => setTimeout(r, 20)); - expect(bridge.removePendingPrompt(session.sessionId, 'prompt-b')).toEqual( - { removed: true }, - ); + await expect( + bridge.removePendingPrompt(session.sessionId, 'prompt-b'), + ).resolves.toEqual({ removed: true }); // B's terminal arrives immediately — while A is still running — as a // turn_complete{stopReason:'cancelled'} keyed to B's promptId. await vi.waitFor(() => { @@ -10820,9 +11074,9 @@ describe('createAcpSessionBridge', () => { ); wedged.catch(() => {}); await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(1)); - expect( + await expect( bridge.removePendingPrompt(session.sessionId, 'prompt-removed-wedge'), - ).toEqual({ removed: true }); + ).resolves.toEqual({ removed: true }); const followup = bridge.sendPrompt( session.sessionId, @@ -10916,11 +11170,21 @@ describe('createAcpSessionBridge', () => { state: 'error', error: { code: 'prompt_deadline_exceeded' }, }); + expect(handle.agent.extMethodCalls).toContainEqual({ + method: SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + params: { + sessionId: session.sessionId, + turnResult: expect.objectContaining({ + promptId: 'prompt-queued-deadline', + state: 'error', + error: expect.objectContaining({ + code: 'prompt_deadline_exceeded', + }), + }), + }, + }); await new Promise((r) => setTimeout(r, 60)); expect(terminalsFor(events, 'prompt-queued-deadline')).toHaveLength(1); - expect( - bridge.getSessionSummary(session.sessionId).turnError, - ).toBeUndefined(); // A queued prompt never ran, so its deadline terminal must not // advertise a session-level turnError nor arm the retry path — those @@ -11068,15 +11332,15 @@ describe('createAcpSessionBridge', () => { // Remove the RUNNING prompt — the wedged agent ignores the cancel, but // removal itself is already the authoritative cancelled outcome. - expect( + await expect( bridge.removePendingPrompt(session.sessionId, 'prompt-removed-running'), - ).toEqual({ removed: true }); + ).resolves.toEqual({ removed: true }); // The API no longer shows the prompt… expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(0); // …and a repeat removal is a no-op. - expect( + await expect( bridge.removePendingPrompt(session.sessionId, 'prompt-removed-running'), - ).toEqual({ removed: false }); + ).resolves.toEqual({ removed: false }); await vi.waitFor(() => { const removedTerms = terminalsFor(events, 'prompt-removed-running'); expect(removedTerms).toHaveLength(1); @@ -11160,9 +11424,9 @@ describe('createAcpSessionBridge', () => { ).toBe('running'); // Remove the now-running prompt 2. - expect( + await expect( bridge.removePendingPrompt(session.sessionId, 'prompt-promoted'), - ).toEqual({ removed: true }); + ).resolves.toEqual({ removed: true }); // Let prompt 2 settle cooperatively. releaseSecond!(); @@ -11270,7 +11534,7 @@ describe('createAcpSessionBridge', () => { // Fire all cancellation paths at once and let the deadline land on // top: the latch must keep every promptId at exactly one terminal. void bridge.cancelSession(session.sessionId).catch(() => {}); - bridge.removePendingPrompt(session.sessionId, 'prompt-b'); + await bridge.removePendingPrompt(session.sessionId, 'prompt-b'); await new Promise((r) => setTimeout(r, 150)); expect(terminalsFor(events, 'prompt-a')).toHaveLength(1); diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index abb2cecc285..19cc4db3c29 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -31,6 +31,7 @@ import { PRIVATE_PARENT_CAPABILITY_META_KEY, SESSION_ARTIFACT_PERSISTENCE_VERSION, TURN_RESULT_TEXT_MAX_CHARS, + normalizeTurnResultError, TrustGateError, normalizeSnapshotPayload, ShellExecutionService, @@ -610,7 +611,6 @@ interface SessionEntry { * transient terminal-to-404 regression. */ terminalTurnStatuses: Map; - terminalTurnStatusLimit: number; /** Bridge prompt that owns the child Guard wait for this FIFO. */ todoStopGuardAwaitingQueuedPromptOwnerPromptId?: string; /** @@ -1288,7 +1288,7 @@ function rememberTerminalTurnStatus( entry: SessionEntry, pendingEntry: PendingPromptEntry, terminal: PromptTerminal, -): void { +): BridgeTurnStatus { const promptText = truncateTurnText(pendingEntry.text); const shared = { sessionId: entry.sessionId, @@ -1315,22 +1315,52 @@ function rememberTerminalTurnStatus( } else if (terminal.kind === 'cancelled') { status = { ...shared, state: 'cancelled', stopReason: 'cancelled' }; } else { - const code = extractErrorCode(terminal.err); status = { ...shared, state: 'error', - error: { - message: extractErrorMessage(terminal.err), - ...(code !== undefined ? { code } : {}), - }, + error: normalizeTurnResultError(terminal.err), }; } entry.terminalTurnStatuses.set(pendingEntry.promptId, status); - while (entry.terminalTurnStatuses.size > entry.terminalTurnStatusLimit) { + while (entry.terminalTurnStatuses.size > TERMINAL_TURN_STATUS_OVERLAY_LIMIT) { const oldestPromptId = entry.terminalTurnStatuses.keys().next().value; if (oldestPromptId === undefined) break; entry.terminalTurnStatuses.delete(oldestPromptId); } + return status; +} + +function terminalStatusRecord( + status: BridgeTurnStatus, +): TurnResultRecordPayload { + if ( + status.promptId === undefined || + status.endedAt === undefined || + status.state === 'idle' || + status.state === 'queued' || + status.state === 'running' + ) { + throw new TypeError('Cannot persist a non-terminal turn status.'); + } + return { + promptId: status.promptId, + state: status.state, + ...(status.stopReason !== undefined + ? { stopReason: status.stopReason } + : {}), + ...(status.error !== undefined ? { error: status.error } : {}), + ...(status.startedAt !== undefined ? { startedAt: status.startedAt } : {}), + endedAt: status.endedAt, + ...(status.promptText !== undefined + ? { promptText: status.promptText } + : {}), + ...(status.promptTextTruncated !== undefined + ? { promptTextTruncated: status.promptTextTruncated } + : {}), + ...(status.originatorClientId !== undefined + ? { originatorClientId: status.originatorClientId } + : {}), + }; } /** @@ -1358,7 +1388,19 @@ function publishPromptTerminal( return; } pendingEntry.terminalPublished = true; - rememberTerminalTurnStatus(entry, pendingEntry, terminal); + const status = rememberTerminalTurnStatus(entry, pendingEntry, terminal); + if ( + !pendingEntry.dispatched && + pendingEntry.terminalPersistence === undefined + ) { + pendingEntry.terminalPersistence = entry.connection + .extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, { + sessionId: entry.sessionId, + turnResult: terminalStatusRecord(status), + }) + .then(() => undefined); + pendingEntry.terminalPersistence.catch(() => {}); + } const originatorClientId = pendingEntry.originatorClientId; if (terminal.kind === 'complete') { broadcastTurnComplete( @@ -1555,6 +1597,19 @@ function enrichTerminalTurnStatus( }; } +function matchesPersistedTerminal( + terminal: BridgeTurnStatus, + persisted: BridgeTurnStatus, +): boolean { + return ( + terminal.promptId === persisted.promptId && + terminal.state === persisted.state && + terminal.stopReason === persisted.stopReason && + terminal.error?.code === persisted.error?.code && + terminal.error?.message === persisted.error?.message + ); +} + function latestTerminalTurnStatus( entry: SessionEntry, ): BridgeTurnStatus | undefined { @@ -1565,6 +1620,7 @@ function latestTerminalTurnStatus( const DEFAULT_INIT_TIMEOUT_MS = 10_000; const PERSIST_TIMEOUT_MS = 5_000; +const TERMINAL_TURN_STATUS_OVERLAY_LIMIT = 64; // Bounded retries for the sub-session `parentSessionId` transcript write on the // spawn critical path — a transport/timeout hiccup gets a couple more tries // before the child is reported as live-only (`parentSessionPersisted:false`). @@ -4711,7 +4767,6 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { pendingAgentNotificationCount: 0, pendingPromptList: [], terminalTurnStatuses: new Map(), - terminalTurnStatusLimit: eventRingSize, midTurnMessageQueue: [], modelChangeQueue: Promise.resolve(), approvalModeQueue: Promise.resolve(), @@ -7204,7 +7259,16 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { void maybeCloseIdleSession(entry, 'prompt_settled'); }) .catch(() => {}); - return result; + return result.then( + async (value) => { + await pendingEntry.terminalPersistence; + return value; + }, + async (error: unknown) => { + await pendingEntry.terminalPersistence; + throw error; + }, + ); }, async cancelSession(sessionId, req, context) { @@ -8960,7 +9024,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // Settled state is durable: read the agent's persisted `turn_result` // records. This survives daemon restarts (the pending list does not). - const terminal = + const terminalBeforeRead = promptId !== undefined ? entry.terminalTurnStatuses.get(promptId) : latestTerminalTurnStatus(entry); @@ -8976,21 +9040,36 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { { ...(promptId !== undefined ? { promptId } : {}) }, ); } catch (error) { - if (terminal) return terminal; + if (terminalBeforeRead) return terminalBeforeRead; throw error; } + const terminal = + promptId !== undefined + ? entry.terminalTurnStatuses.get(promptId) + : latestTerminalTurnStatus(entry); const persisted = result.turnResult ? settledTurnStatus(sessionId, result.turnResult) : undefined; + const terminalPersisted = + terminal !== undefined && + persisted !== undefined && + matchesPersistedTerminal(terminal, persisted); + if (terminalPersisted && persisted.promptId !== undefined) { + entry.terminalTurnStatuses.delete(persisted.promptId); + } if (promptId !== undefined) { if (terminal && persisted) { - return enrichTerminalTurnStatus(terminal, persisted); + return terminalPersisted + ? persisted + : enrichTerminalTurnStatus(terminal, persisted); } if (terminal) return terminal; if (persisted) return persisted; } else { if (terminal && persisted && persisted.promptId === terminal.promptId) { - return enrichTerminalTurnStatus(terminal, persisted); + return terminalPersisted + ? persisted + : enrichTerminalTurnStatus(terminal, persisted); } if (terminal && persisted) { return (terminal.endedAt ?? 0) >= (persisted.endedAt ?? 0) @@ -9008,7 +9087,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { return { sessionId, state: 'idle' as const }; }, - removePendingPrompt(sessionId, promptId, context) { + async removePendingPrompt(sessionId, promptId, context) { const entry = byId.get(sessionId); if (!entry) throw new SessionNotFoundError(sessionId); // Authorize the caller BEFORE performing any mutation. @@ -9064,6 +9143,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // from queued/running to unknown while cooperative cancellation drains. // The FIFO node's later terminal is deduped by the latch. publishPromptTerminal(entry, target, { kind: 'cancelled' }); + await target.terminalPersistence; return { removed: true }; }, @@ -9502,6 +9582,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { throw err; } + entry.terminalTurnStatuses.clear(); const targetTurnIndex = (response['targetTurnIndex'] as number) ?? 0; const filesChanged = (response['filesChanged'] as string[]) ?? []; const filesFailed = (response['filesFailed'] as string[]) ?? []; diff --git a/packages/acp-bridge/src/bridgeTypes.ts b/packages/acp-bridge/src/bridgeTypes.ts index 382674b4e09..d559a63838b 100644 --- a/packages/acp-bridge/src/bridgeTypes.ts +++ b/packages/acp-bridge/src/bridgeTypes.ts @@ -7,6 +7,7 @@ import type { ApprovalMode, SessionGroupPresetColor, + TurnResultErrorPayload, } from '@qwen-code/qwen-code-core'; import type { CancelNotification, @@ -850,6 +851,8 @@ export interface PendingPromptEntry { * later publish attempts for the same prompt are suppressed. */ terminalPublished?: boolean; + /** Durable write for a terminal published before child prompt dispatch. */ + terminalPersistence?: Promise; /** Cancellation handshake; duplicate callers await rather than resend it. */ cancelForwardInitial?: Promise; /** Full cancellation handshake, used to fence the next FIFO dispatch. */ @@ -897,7 +900,7 @@ export interface BridgeTurnStatus { startedAt?: number; endedAt?: number; stopReason?: string; - error?: { message: string; code?: string }; + error?: TurnResultErrorPayload; resultText?: string; resultTruncated?: boolean; originatorClientId?: string; @@ -1200,7 +1203,7 @@ export interface AcpSessionBridge { sessionId: string, promptId: string, context?: BridgeClientRequestContext, - ): { removed: boolean }; + ): Promise<{ removed: boolean }>; /** * Cancel the in-flight prompt on the session. Throws diff --git a/packages/acp-bridge/src/status.ts b/packages/acp-bridge/src/status.ts index 7cfd6a38447..01f54d83ed6 100644 --- a/packages/acp-bridge/src/status.ts +++ b/packages/acp-bridge/src/status.ts @@ -192,6 +192,7 @@ export const SERVE_CONTROL_EXT_METHODS = { * `null` means no matching settled turn was found. */ sessionTurnStatus: 'qwen/control/session/turn_status', + sessionTurnResultRecord: 'qwen/control/session/turn_result/record', sessionMcpRuntimeAdd: 'qwen/control/session/mcp/runtime-add', sessionMcpRuntimeRemove: 'qwen/control/session/mcp/runtime-remove', workspaceMcpRuntimeAdd: 'qwen/control/workspace/mcp/runtime-add', diff --git a/packages/cli/src/acp-integration/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts index 85c39bdec2b..ee67a8914e5 100644 --- a/packages/cli/src/acp-integration/acpAgent.test.ts +++ b/packages/cli/src/acp-integration/acpAgent.test.ts @@ -190,6 +190,10 @@ vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => ({ (await importOriginal()) .parseInvocationContext, ), + isTurnResultRecordPayload: vi.fn( + (await importOriginal()) + .isTurnResultRecordPayload, + ), SESSION_ARTIFACT_PERSISTENCE_VERSION: 2, normalizeEventPayload: vi.fn((payload: unknown) => typeof payload === 'object' && @@ -8953,6 +8957,46 @@ describe('QwenAgent MCP SSE/HTTP support', () => { await agentPromise; }); + it('strictly records a bridge-owned pre-dispatch turn result', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + const innerConfig = await setupSessionMocks(sessionId); + const recordTurnResultStrict = vi.fn().mockResolvedValue(undefined); + innerConfig.getChatRecordingService = vi.fn().mockReturnValue({ + recordTurnResultStrict, + }); + const turnResult = { + promptId: 'prompt-queued-cancelled', + state: 'cancelled' as const, + stopReason: 'cancelled', + endedAt: 2000, + promptText: 'queued prompt', + }; + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, { + sessionId, + turnResult, + }), + ).resolves.toEqual({ v: 1, sessionId }); + expect(recordTurnResultStrict).toHaveBeenCalledWith(turnResult); + + mockConnectionState.resolve(); + await agentPromise; + }); + it('reads a settled turn_result record by promptId', async () => { const sessionId = '11111111-1111-1111-1111-111111111111'; await setupSessionMocks(sessionId); @@ -9109,6 +9153,115 @@ describe('QwenAgent MCP SSE/HTTP support', () => { await agentPromise; }); + it('stops an exact turn_result lookup after ten transcript pages', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const cursorState = { + v: 1 as const, + sessionId, + fileIdentity: { dev: 1, ino: 2 }, + snapshotSize: 200, + position: 100, + leafUuid: 'leaf-1', + startTime: 'start', + lastUpdated: 'end', + }; + const readPage = vi.fn().mockResolvedValue({ + sessionId, + records: [], + hasMore: true, + nextCursorState: cursorState, + gaps: [], + startTime: 'start', + lastUpdated: 'end', + }); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: 'outside-bounded-window', + }), + ).resolves.toEqual({ v: 1, sessionId, turnResult: null }); + expect(readPage).toHaveBeenCalledTimes(10); + + mockConnectionState.resolve(); + await agentPromise; + }); + + it('skips malformed turn_result payloads while finding an exact match', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const valid = { + promptId: 'prompt-valid', + state: 'completed', + endedAt: 2000, + resultText: 'valid answer', + }; + const readPage = vi.fn().mockResolvedValue({ + sessionId, + records: [ + { type: 'system', subtype: 'turn_result', systemPayload: valid }, + { + type: 'system', + subtype: 'turn_result', + systemPayload: { promptId: 'prompt-valid' }, + }, + ], + hasMore: false, + gaps: [], + startTime: 'start', + lastUpdated: 'end', + }); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + await expect( + agent.extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, { + sessionId, + promptId: valid.promptId, + }), + ).resolves.toEqual({ v: 1, sessionId, turnResult: valid }); + + mockConnectionState.resolve(); + await agentPromise; + }); + it('maps oversized pages from bounded turn_result scans to structured errors', async () => { const sessionId = '11111111-1111-1111-1111-111111111111'; await setupSessionMocks(sessionId); diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index fe6beb6c55a..d4f679beb11 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -90,6 +90,7 @@ import { SESSION_ARTIFACT_PERSISTENCE_VERSION, normalizeEventPayload, normalizeSnapshotPayload, + isTurnResultRecordPayload, startEventLoopLagMonitor, refreshMemoryInstruction, extractDaemonTraceContext, @@ -415,7 +416,8 @@ async function findSettledTurnResult( if (record.type !== 'system' || record.subtype !== 'turn_result') { continue; } - const payload = record.systemPayload as TurnResultRecordPayload; + const payload = record.systemPayload; + if (!isTurnResultRecordPayload(payload)) continue; if (promptId === undefined || payload.promptId === promptId) { return payload; } @@ -10577,6 +10579,31 @@ class QwenAgent implements Agent { : null, }; } + case SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord: { + const sessionId = params['sessionId']; + const turnResult = params['turnResult']; + if ( + typeof sessionId !== 'string' || + !SESSION_ID_RE.test(sessionId) || + !isTurnResultRecordPayload(turnResult) + ) { + throw RequestError.invalidParams( + undefined, + 'Invalid session turn result record', + ); + } + const session = this.sessionOrThrow(sessionId); + const recorder = session.getConfig().getChatRecordingService(); + if (!recorder) { + throw new RequestError( + -32021, + 'Session transcript writer is unavailable', + { errorKind: 'session_writer_unavailable' }, + ); + } + await recorder.recordTurnResultStrict(turnResult); + return { v: 1, sessionId }; + } case SERVE_CONTROL_EXT_METHODS.sessionTurnStatus: { const sessionId = params['sessionId']; if (typeof sessionId !== 'string' || !SESSION_ID_RE.test(sessionId)) { diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index c4215f988a1..1162bcbe22d 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -4316,6 +4316,22 @@ describe('Session', () => { }); it('does not persist framework diagnostics as the main answer', async () => { + ( + mockSettings.user as { originalSettings?: Record } + ).originalSettings = { + messageRewrite: { + enabled: true, + target: 'message', + prompt: 'rewrite', + }, + }; + session.installRewriter(); + const rewrite = vi.fn().mockResolvedValue('rewritten diagnostic'); + ( + session.messageRewriter as unknown as { + rewriter: { rewrite: typeof rewrite }; + } + ).rewriter.rewrite = rewrite; mockConfig.getSessionTokenLimit = vi.fn().mockReturnValue(100); mockGeminiClient.tryCompressChat.mockResolvedValueOnce({ originalTokenCount: 1200, @@ -4339,6 +4355,8 @@ describe('Session', () => { stopReason: 'max_tokens', }); expect(payload.resultText).toBeUndefined(); + expect(rewrite).toHaveBeenCalled(); + expect(agentMessageChunks()).toContain('rewritten diagnostic'); }); it('does not append the scheduler exit summary to a cancelled turn result', async () => { @@ -4740,6 +4758,75 @@ describe('Session', () => { state: 'cancelled', }), ); + expect( + mockChatRecordingService.recordTurnResult.mock.calls[0][0].startedAt, + ).toBeUndefined(); + }); + + it('records an error when admission fails before dispatch', async () => { + mockConfig.assertCanStartTurn = vi + .fn() + .mockRejectedValue(new Error('admission failed')); + + await expect( + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'rejected prompt' }], + }, + trustedContext, + ), + ).rejects.toThrow('admission failed'); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'daemon-prompt-id', + state: 'error', + error: { message: 'admission failed' }, + }), + ); + expect( + mockChatRecordingService.recordTurnResult.mock.calls[0][0].startedAt, + ).toBeUndefined(); + }); + + it('records an error when awaited turn finalization fails', async () => { + ( + session as unknown as { + liveConversationActive: boolean; + liveEndInstructionPending: boolean; + } + ).liveConversationActive = false; + ( + session as unknown as { liveEndInstructionPending: boolean } + ).liveEndInstructionPending = true; + mockGeminiClient.refreshSystemInstruction.mockRejectedValueOnce( + new Error('live cleanup failed'), + ); + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValue(createEmptyStream()); + + await expect( + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'cleanup failure' }], + }, + trustedContext, + ), + ).rejects.toThrow('live cleanup failed'); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledTimes( + 1, + ); + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'daemon-prompt-id', + state: 'error', + error: { message: 'live cleanup failed' }, + }), + ); }); it('records an error turn when the model stream fails', async () => { @@ -4766,6 +4853,70 @@ describe('Session', () => { ); }); + it('discards and drains rewrites before recording an error', async () => { + const discardTurn = vi.fn(); + const waitForPendingRewrites = vi.fn().mockResolvedValue(undefined); + session.messageRewriter = { + discardTurn, + interceptUpdate: vi.fn().mockResolvedValue(undefined), + flushTurn: vi.fn().mockResolvedValue(undefined), + waitForPendingRewrites, + } as unknown as Session['messageRewriter']; + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValue(createFailingStream('model exploded')); + + await expect( + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'boom' }], + }, + trustedContext, + ), + ).rejects.toThrow('model exploded'); + + expect(discardTurn).toHaveBeenCalledTimes(2); + expect(waitForPendingRewrites).toHaveBeenCalled(); + expect(discardTurn.mock.invocationCallOrder.at(-1)).toBeLessThan( + mockChatRecordingService.recordTurnResult.mock.invocationCallOrder[0], + ); + expect( + waitForPendingRewrites.mock.invocationCallOrder.at(-1), + ).toBeLessThan( + mockChatRecordingService.recordTurnResult.mock.invocationCallOrder[0], + ); + }); + + it('bounds persisted error message and code', async () => { + const originalError = Object.assign( + new Error('m'.repeat(core.TURN_RESULT_ERROR_MESSAGE_MAX_CHARS + 100)), + { code: 'c'.repeat(core.TURN_RESULT_ERROR_CODE_MAX_CHARS + 100) }, + ); + mockChat.sendMessageStream = vi.fn().mockRejectedValue(originalError); + + await expect( + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'large error' }], + }, + trustedContext, + ), + ).rejects.toBe(originalError); + + const payload = + mockChatRecordingService.recordTurnResult.mock.calls[0][0]; + expect(payload.error?.message).toHaveLength( + core.TURN_RESULT_ERROR_MESSAGE_MAX_CHARS, + ); + expect(payload.error?.code).toHaveLength( + core.TURN_RESULT_ERROR_CODE_MAX_CHARS, + ); + expect(payload.error?.messageTruncated).toBe(true); + expect(payload.error?.codeTruncated).toBe(true); + }); + it('records a cancelled turn when user cancel races a non-abort stream error', async () => { mockChat.sendMessageStream = vi.fn().mockResolvedValue( createFailingStream('Request was aborted.', () => { @@ -5090,6 +5241,7 @@ describe('Session', () => { 'Invocation context session does not match the active session', ); expect(mockChat.sendMessageStream).not.toHaveBeenCalled(); + expect(mockChatRecordingService.recordTurnResult).not.toHaveBeenCalled(); }); it('does not create invocation context for standalone ACP prompts', async () => { @@ -6083,6 +6235,7 @@ describe('Session', () => { const waitForPendingRewrites = vi.fn().mockResolvedValue(undefined); const interceptUpdate = vi.fn().mockResolvedValue(undefined); session.messageRewriter = { + discardTurn: vi.fn(), interceptUpdate, flushTurn, waitForPendingRewrites, @@ -9263,10 +9416,17 @@ describe('Session', () => { queueMatchingFailureStreak(); await expect( - session.prompt({ - sessionId: 'test-session-id', - prompt: [{ type: 'text', text: 'run the failing tool' }], - }), + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'run the failing tool' }], + }, + { + version: 1, + sessionId: 'test-session-id', + promptId: 'guard-stop-prompt', + }, + ), ).resolves.toEqual({ stopReason: 'end_turn' }); expect(execute).toHaveBeenCalledTimes(9); @@ -9312,6 +9472,12 @@ describe('Session', () => { }), }), ); + const recorded = + mockChatRecordingService.recordTurnResult.mock.calls[0][0]; + expect(recorded.promptId).toBe('guard-stop-prompt'); + expect(recorded.resultText ?? '').not.toContain( + 'Automatic continuation stopped', + ); } finally { restoreGuardMode(); } @@ -9739,6 +9905,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -9769,6 +9939,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -9878,6 +10052,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -10165,6 +10343,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -11665,6 +11847,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -11865,6 +12051,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -14642,6 +14832,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -14658,6 +14852,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: 'Cron jobs and loop wakeups disabled for the rest of this session due to token limit. Restart the session to re-enable.', @@ -18321,6 +18519,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: 'Stop hook blocked continuation 2 consecutive times; overriding and ending the turn.', @@ -18369,6 +18571,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: 'Stop hook blocked continuation 1 consecutive time; overriding and ending the turn.', @@ -19637,13 +19843,15 @@ describe('Session', () => { it('waits for pending rewrites before ending after cancelled ask_user_question', async () => { let releaseRewrite!: () => void; const flushTurn = vi.fn().mockResolvedValue(undefined); - const waitForPendingRewrites = vi.fn( - () => - new Promise((resolve) => { - releaseRewrite = resolve; - }), - ); + const rewriteGate = new Promise((resolve) => { + releaseRewrite = resolve; + }); + const waitForPendingRewrites = vi + .fn() + .mockImplementationOnce(() => rewriteGate) + .mockResolvedValue(undefined); session.messageRewriter = { + discardTurn: vi.fn(), interceptUpdate: vi.fn().mockResolvedValue(undefined), flushTurn, waitForPendingRewrites, @@ -19725,6 +19933,7 @@ describe('Session', () => { const waitForPendingRewrites = vi .fn() .mockResolvedValueOnce(undefined) + .mockResolvedValueOnce(undefined) .mockImplementationOnce( () => new Promise((resolve) => { @@ -19732,6 +19941,7 @@ describe('Session', () => { }), ); session.messageRewriter = { + discardTurn: vi.fn(), interceptUpdate: vi.fn().mockResolvedValue(undefined), flushTurn: vi.fn().mockResolvedValue(undefined), waitForPendingRewrites, @@ -19753,7 +19963,7 @@ describe('Session', () => { }); await vi.waitFor(() => { - expect(waitForPendingRewrites).toHaveBeenCalledTimes(2); + expect(waitForPendingRewrites).toHaveBeenCalledTimes(3); }); const internals = session as unknown as { @@ -24977,6 +25187,7 @@ describe('Session', () => { releaseWait = resolve; }); session.messageRewriter = { + discardTurn: vi.fn(), interceptUpdate: vi.fn().mockResolvedValue(undefined), waitForPendingRewrites: vi.fn(async () => { enterWait(); @@ -28339,6 +28550,7 @@ describe('Session', () => { }); let waitCalls = 0; session.messageRewriter = { + discardTurn: vi.fn(), interceptUpdate: vi.fn().mockResolvedValue(undefined), waitForPendingRewrites: vi.fn(async () => { if (++waitCalls !== 1) return; diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index 6200dad8967..0654f68a75c 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -174,6 +174,7 @@ import { splitImageParts, approxBase64Bytes, TURN_RESULT_TEXT_MAX_CHARS, + normalizeTurnResultError, runWithRuntimeContentGenerator, getInvocationContext, runWithInvocationContext, @@ -904,7 +905,7 @@ function extractTurnPromptText(content: ContentBlock[]): string { type InFlightTurnRecording = { promptId: string; originatorClientId?: string; - startedAt: number; + startedAt?: number; promptText: string; promptTextTruncated: boolean; resultSegments: Map< @@ -935,24 +936,6 @@ function truncateTurnText(text: string): { return { text: text.slice(0, TURN_RESULT_TEXT_MAX_CHARS), truncated: true }; } -function turnResultErrorPayload(error: unknown): { - message: string; - code?: string; -} { - const message = - error instanceof Error && error.message.length > 0 - ? error.message - : String(error); - const code = (error as { code?: unknown })?.code; - if (typeof code === 'string' && code.length > 0) { - return { message, code }; - } - if (typeof code === 'number') { - return { message, code: String(code) }; - } - return { message }; -} - function capMidTurnDrainItems(items: T[], fieldName: string): T[] { if (items.length <= MAX_MID_TURN_DRAIN_ITEMS) return items; @@ -3004,33 +2987,55 @@ export class Session implements SessionContext { admissionCancellation?: AbortSignal, modelPrompt?: string, ): Promise { - if (this.closing) { - throw RequestError.invalidParams(undefined, 'Session is closing'); - } - if (modelPrompt !== undefined && invocationContext === undefined) { - throw RequestError.invalidParams( - undefined, - 'Model-only prompt requires trusted invocation context', - ); - } - if (modelPrompt !== undefined && !isValidTrustedModelPrompt(modelPrompt)) { + if ( + invocationContext !== undefined && + invocationContext.sessionId !== this.config.getSessionId() + ) { throw RequestError.invalidParams( undefined, - 'Invalid trusted model-only prompt', + 'Invocation context session does not match the active session', ); } - await this.assertCanStartTurn(); - if ( - this.liveScreenContextTool || - this.liveTaskTools.length > 0 || - this.liveSpeakToUserTool - ) { - await this.#syncLiveToolDeclarations(); - } - if (this.closing) { - throw RequestError.invalidParams(undefined, 'Session is closing'); - } const turnRecording = this.#beginTurnRecording(params, invocationContext); + try { + if (this.closing) { + throw RequestError.invalidParams(undefined, 'Session is closing'); + } + if (modelPrompt !== undefined && invocationContext === undefined) { + throw RequestError.invalidParams( + undefined, + 'Model-only prompt requires trusted invocation context', + ); + } + if ( + modelPrompt !== undefined && + !isValidTrustedModelPrompt(modelPrompt) + ) { + throw RequestError.invalidParams( + undefined, + 'Invalid trusted model-only prompt', + ); + } + await this.assertCanStartTurn(); + if ( + this.liveScreenContextTool || + this.liveTaskTools.length > 0 || + this.liveSpeakToUserTool + ) { + await this.#syncLiveToolDeclarations(); + } + if (this.closing) { + throw RequestError.invalidParams(undefined, 'Session is closing'); + } + } catch (error) { + this.#settleTurnRecording('error', turnRecording, undefined, error); + if (error instanceof SessionWriterError) { + throw new RequestError(error.rpcCode, error.message, { + errorKind: error.errorKind, + }); + } + throw error; + } if (admissionCancellation?.aborted) { this.#settleTurnRecording('cancelled', turnRecording); return { stopReason: 'cancelled' }; @@ -3143,6 +3148,18 @@ export class Session implements SessionContext { if (turnRecording) turnRecording.startedAt = Date.now(); this.#turnRecording = turnRecording; + let settlement: + | { + state: 'completed' | 'cancelled' | 'error'; + response?: PromptResponse; + error?: unknown; + } + | undefined; + let promptResult: PromptResponse | undefined; + let promptFailure: unknown; + let didPromptFail = false; + let finalizationError: unknown; + let didFinalizationFail = false; try { const result = await this.#executePrompt( params, @@ -3151,11 +3168,11 @@ export class Session implements SessionContext { invocationContext, modelPrompt, ); - this.#settleTurnRecording( - result.stopReason === 'cancelled' ? 'cancelled' : 'completed', - turnRecording, - result, - ); + settlement = { + state: result.stopReason === 'cancelled' ? 'cancelled' : 'completed', + response: result, + }; + promptResult = result; releasePendingSend(); // Drain any cron prompts that queued while the prompt was active void this.#drainCronQueue(); @@ -3173,7 +3190,6 @@ export class Session implements SessionContext { promptId: channelDelivery.deliveryId, }); } - return result; } catch (error) { // A controlled prompt abort can surface as a non-AbortError (e.g. the // provider SDK's "Request was aborted."), so classify the recording @@ -3181,18 +3197,18 @@ export class Session implements SessionContext { const controlledCancellation = isControlledPromptAbort( pendingSend.signal, ); - this.#settleTurnRecording( - controlledCancellation ? 'cancelled' : 'error', - turnRecording, - undefined, + settlement = { + state: controlledCancellation ? 'cancelled' : 'error', error, - ); + }; + didPromptFail = true; if (error instanceof SessionWriterError) { - throw new RequestError(error.rpcCode, error.message, { + promptFailure = new RequestError(error.rpcCode, error.message, { errorKind: error.errorKind, }); + } else { + promptFailure = error; } - throw error; } finally { const stillOwnsPendingPrompt = this.pendingPrompt === pendingSend; releasePendingSend(); @@ -3215,10 +3231,37 @@ export class Session implements SessionContext { // cron job) is actually pending — otherwise the loop dies silently on // any post-arm error. void this.#startCronSchedulerInRuntime(); + try { + if (settlement?.state !== 'completed') { + this.messageRewriter?.discardTurn(); + } + await this.messageRewriter?.waitForPendingRewrites(); + await this.#consumeLiveEndInstruction(); + } catch (error) { + finalizationError = error; + didFinalizationFail = true; + settlement = { state: 'error', error }; + this.messageRewriter?.discardTurn(); + try { + await this.messageRewriter?.waitForPendingRewrites(); + } catch { + // The finalization error below remains authoritative. + } + } + if (settlement) { + this.#settleTurnRecording( + settlement.state, + turnRecording, + settlement.response, + settlement.error, + ); + } resolveCompletion(); this.pendingPromptCompletion = null; - await this.#consumeLiveEndInstruction(); } + if (didFinalizationFail) throw finalizationError; + if (didPromptFail) throw promptFailure; + return promptResult as PromptResponse; } /** @@ -5190,7 +5233,6 @@ export class Session implements SessionContext { ...(invocationContext.originatorClientId !== undefined ? { originatorClientId: invocationContext.originatorClientId } : {}), - startedAt: Date.now(), promptText: text, promptTextTruncated: truncated, resultSegments: new Map(), @@ -5304,8 +5346,10 @@ export class Session implements SessionContext { ...(response?.stopReason !== undefined ? { stopReason: response.stopReason } : {}), - ...(state === 'error' ? { error: turnResultErrorPayload(error) } : {}), - startedAt: recording.startedAt, + ...(state === 'error' ? { error: normalizeTurnResultError(error) } : {}), + ...(recording.startedAt !== undefined + ? { startedAt: recording.startedAt } + : {}), endedAt: Date.now(), promptText: recording.promptText, ...(recording.promptTextTruncated ? { promptTextTruncated: true } : {}), @@ -5697,7 +5741,7 @@ export class Session implements SessionContext { { recordToQwenLogger: false }, ); try { - await this.messageEmitter.emitAgentMessage( + await this.#emitAgentDiagnosticMessage( REPEATED_TOOL_FAILURE_STOP_MESSAGE, ); } catch (error) { @@ -5817,14 +5861,18 @@ export class Session implements SessionContext { } async #emitAgentDiagnosticMessage(text: string): Promise { - await this.#deliverUpdate( - { - sessionUpdate: 'agent_message_chunk', - content: { type: 'text', text }, - }, - undefined, - false, - ); + const update: SessionUpdate = { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text }, + _meta: { source: 'diagnostic', qwenDiscreteMessage: true }, + }; + if (this.messageRewriter) { + const signal = this.pendingPrompt?.signal; + await this.messageRewriter.interceptUpdate(update, signal); + await this.messageRewriter.flushTurn(signal); + return; + } + await this.#deliverUpdate(update); } async #drainMidTurnUserMessages( diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts index ea28601d833..20ce21b7e20 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts @@ -240,6 +240,35 @@ describe('MessageRewriteMiddleware', () => { }); }); + it('does not deliver or commit a rewrite after its turn signal aborts', async () => { + const { middleware, mockSendUpdate } = createMiddleware('message'); + const { LlmRewriter } = await import('./LlmRewriter.js'); + const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { + rewrite: ReturnType; + commitOutput: ReturnType; + }; + let resolveRewrite!: (value: string) => void; + rewriter.rewrite.mockImplementationOnce( + () => + new Promise((resolve) => { + resolveRewrite = resolve; + }), + ); + const turnAbort = new AbortController(); + + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'raw answer' }, + } as unknown as SessionUpdate); + await middleware.flushTurn(turnAbort.signal); + turnAbort.abort(); + resolveRewrite('late rewrite'); + await middleware.waitForPendingRewrites(); + + expect(mockSendUpdate).toHaveBeenCalledTimes(1); + expect(rewriter.commitOutput).not.toHaveBeenCalled(); + }); + describe('flushTurn — tool_call boundary', () => { it('commits rewrite context only after successful delivery', async () => { const { LlmRewriter } = await import('./LlmRewriter.js'); diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts index fe155bd1856..66bef7551c2 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts @@ -181,7 +181,7 @@ export class MessageRewriteMiddleware { debugLogger.info(`Turn ${turnIdx}: no rewrite output`); return; } - if (generation !== this.generation) return; + if (generation !== this.generation || rewriteSignal.aborted) return; debugLogger.info( `Turn ${turnIdx}: rewritten ${rewritten.length} chars`, @@ -205,7 +205,7 @@ export class MessageRewriteMiddleware { replacesMessageText: content.messages.length > 0, }, ); - if (generation !== this.generation) return; + if (generation !== this.generation || rewriteSignal.aborted) return; this.rewriter.commitOutput(rewritten); } catch (error) { debugLogger.warn( diff --git a/packages/cli/src/serve/routes/session.ts b/packages/cli/src/serve/routes/session.ts index b17d3d12313..1d85587ed52 100644 --- a/packages/cli/src/serve/routes/session.ts +++ b/packages/cli/src/serve/routes/session.ts @@ -4649,7 +4649,7 @@ export function registerSessionRoutes( mutate(), withOwnerMutableSession( 'DELETE /session/:id/pending-prompts/:promptId', - (req, res, sessionId, runtime) => { + async (req, res, sessionId, runtime) => { const clientId = parseClientIdHeader(req, res); if (clientId === null) return; const promptId = req.params['promptId']; @@ -4659,7 +4659,7 @@ export function registerSessionRoutes( .json({ error: '`promptId` route parameter is required' }); return; } - const result = runtime.bridge.removePendingPrompt( + const result = await runtime.bridge.removePendingPrompt( sessionId, promptId, clientId !== undefined ? { clientId } : undefined, diff --git a/packages/core/src/services/chatRecordingService.test.ts b/packages/core/src/services/chatRecordingService.test.ts index e4eb4f2bb43..15c5b3eca1b 100644 --- a/packages/core/src/services/chatRecordingService.test.ts +++ b/packages/core/src/services/chatRecordingService.test.ts @@ -12,6 +12,9 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; import type { Config } from '../config/config.js'; import { ChatRecordingService, + normalizeTurnResultError, + TURN_RESULT_ERROR_CODE_MAX_CHARS, + TURN_RESULT_ERROR_MESSAGE_MAX_CHARS, type ChatRecord, type AtCommandRecordPayload, type TurnResultRecordPayload, @@ -837,6 +840,60 @@ describe('ChatRecordingService', () => { ).not.toThrow(); expect(jsonl.writeLine).not.toHaveBeenCalled(); }); + + it('fails a strict turn-result write when recording is inactive', async () => { + const inactive = new ChatRecordingService(mockConfig); + await expect( + inactive.recordTurnResultStrict({ + promptId: 'prompt-1', + state: 'cancelled', + endedAt: 1500, + }), + ).rejects.toBeInstanceOf(SessionWriterUnavailableError); + }); + }); + + describe('normalizeTurnResultError', () => { + it('falls back safely when getters and string conversion throw', () => { + const unsafe = Object.defineProperties( + {}, + { + message: { + get: () => { + throw new Error('message getter failed'); + }, + }, + code: { + get: () => { + throw new Error('code getter failed'); + }, + }, + toString: { + value: () => { + throw new Error('string conversion failed'); + }, + }, + }, + ); + + expect(normalizeTurnResultError(unsafe)).toEqual({ + message: 'Unknown error', + }); + }); + + it('bounds message and code with explicit truncation flags', () => { + const normalized = normalizeTurnResultError({ + message: 'm'.repeat(TURN_RESULT_ERROR_MESSAGE_MAX_CHARS + 1), + code: 'c'.repeat(TURN_RESULT_ERROR_CODE_MAX_CHARS + 1), + }); + + expect(normalized.message).toHaveLength( + TURN_RESULT_ERROR_MESSAGE_MAX_CHARS, + ); + expect(normalized.code).toHaveLength(TURN_RESULT_ERROR_CODE_MAX_CHARS); + expect(normalized.messageTruncated).toBe(true); + expect(normalized.codeTruncated).toBe(true); + }); }); describe('recordAtCommand', () => { diff --git a/packages/core/src/services/chatRecordingService.ts b/packages/core/src/services/chatRecordingService.ts index 116a3295419..068543172ed 100644 --- a/packages/core/src/services/chatRecordingService.ts +++ b/packages/core/src/services/chatRecordingService.ts @@ -561,6 +561,79 @@ export interface UserTextElementsRecordPayload { * `turn_result` record. Writers truncate and set the paired flag. */ export const TURN_RESULT_TEXT_MAX_CHARS = 32_768; +export const TURN_RESULT_ERROR_MESSAGE_MAX_CHARS = 4_096; +export const TURN_RESULT_ERROR_CODE_MAX_CHARS = 256; + +export interface TurnResultErrorPayload { + message: string; + code?: string; + messageTruncated?: boolean; + codeTruncated?: boolean; +} + +function readErrorField(error: unknown, field: 'message' | 'code'): unknown { + if ( + (typeof error !== 'object' || error === null) && + typeof error !== 'function' + ) { + return undefined; + } + try { + return Reflect.get(error, field); + } catch { + return undefined; + } +} + +function truncateTurnResultErrorField( + value: string, + maxChars: number, +): { value: string; truncated: boolean } { + return value.length > maxChars + ? { value: value.slice(0, maxChars), truncated: true } + : { value, truncated: false }; +} + +export function normalizeTurnResultError( + error: unknown, +): TurnResultErrorPayload { + const rawMessage = readErrorField(error, 'message'); + let message = + typeof rawMessage === 'string' && rawMessage.length > 0 + ? rawMessage + : undefined; + if (message === undefined) { + try { + const converted = String(error); + if (converted.length > 0) message = converted; + } catch { + // Fall through to the stable generic value. + } + } + const boundedMessage = truncateTurnResultErrorField( + message ?? 'Unknown error', + TURN_RESULT_ERROR_MESSAGE_MAX_CHARS, + ); + + const rawCode = readErrorField(error, 'code'); + let code: string | undefined; + if (typeof rawCode === 'string' && rawCode.length > 0) { + code = rawCode; + } else if (typeof rawCode === 'number') { + code = String(rawCode); + } + const boundedCode = + code === undefined + ? undefined + : truncateTurnResultErrorField(code, TURN_RESULT_ERROR_CODE_MAX_CHARS); + + return { + message: boundedMessage.value, + ...(boundedMessage.truncated ? { messageTruncated: true } : {}), + ...(boundedCode !== undefined ? { code: boundedCode.value } : {}), + ...(boundedCode?.truncated ? { codeTruncated: true } : {}), + }; +} /** * Settled outcome of one admitted prompt, appended at turn settle so @@ -572,9 +645,9 @@ export interface TurnResultRecordPayload { promptId: string; state: 'completed' | 'cancelled' | 'error'; stopReason?: string; - error?: { message: string; code?: string }; + error?: TurnResultErrorPayload; /** Epoch ms the turn started executing (agent clock). */ - startedAt: number; + startedAt?: number; /** Epoch ms the turn settled (agent clock). */ endedAt: number; promptText?: string; @@ -584,6 +657,67 @@ export interface TurnResultRecordPayload { originatorClientId?: string; } +export function isTurnResultRecordPayload( + value: unknown, +): value is TurnResultRecordPayload { + if (typeof value !== 'object' || value === null) return false; + const payload = value as Record; + if ( + typeof payload['promptId'] !== 'string' || + payload['promptId'].length === 0 || + !['completed', 'cancelled', 'error'].includes(payload['state'] as string) || + typeof payload['endedAt'] !== 'number' || + !Number.isFinite(payload['endedAt']) + ) { + return false; + } + const optionalStringWithin = (field: string, maxChars?: number) => { + const fieldValue = payload[field]; + return ( + fieldValue === undefined || + (typeof fieldValue === 'string' && + (maxChars === undefined || fieldValue.length <= maxChars)) + ); + }; + const optionalBoolean = (field: string) => + payload[field] === undefined || typeof payload[field] === 'boolean'; + const optionalTimestamp = (field: string) => + payload[field] === undefined || + (typeof payload[field] === 'number' && Number.isFinite(payload[field])); + if ( + !optionalStringWithin('stopReason') || + !optionalTimestamp('startedAt') || + !optionalStringWithin('promptText', TURN_RESULT_TEXT_MAX_CHARS) || + !optionalBoolean('promptTextTruncated') || + !optionalStringWithin('resultText', TURN_RESULT_TEXT_MAX_CHARS) || + !optionalBoolean('resultTruncated') || + !optionalStringWithin('originatorClientId') + ) { + return false; + } + const error = payload['error']; + if (error === undefined) return payload['state'] !== 'error'; + if ( + payload['state'] !== 'error' || + typeof error !== 'object' || + error === null + ) { + return false; + } + const fields = error as Record; + return ( + typeof fields['message'] === 'string' && + fields['message'].length <= TURN_RESULT_ERROR_MESSAGE_MAX_CHARS && + (fields['code'] === undefined || + (typeof fields['code'] === 'string' && + fields['code'].length <= TURN_RESULT_ERROR_CODE_MAX_CHARS)) && + (fields['messageTruncated'] === undefined || + typeof fields['messageTruncated'] === 'boolean') && + (fields['codeTruncated'] === undefined || + typeof fields['codeTruncated'] === 'boolean') + ); +} + export interface ChatRecordingFailureEvent { sessionId: string; error: Error; @@ -2177,6 +2311,18 @@ export class ChatRecordingService { } } + async recordTurnResultStrict( + payload: TurnResultRecordPayload, + ): Promise { + const record: ChatRecord = { + ...this.createBaseRecord('system'), + type: 'system', + subtype: 'turn_result', + systemPayload: payload, + }; + await this.appendRecordStrict(record); + } + private appendSerializedFileHistorySnapshotBatch( snapshots: SerializedFileHistorySnapshot[], ): void { diff --git a/packages/core/src/services/sessionService.test.ts b/packages/core/src/services/sessionService.test.ts index 3a4548dcb29..2e9159d14c4 100644 --- a/packages/core/src/services/sessionService.test.ts +++ b/packages/core/src/services/sessionService.test.ts @@ -3209,6 +3209,47 @@ describe('SessionService', () => { expect(srcLines.every((r) => !r.forkedFrom)).toBe(true); }); + it('does not copy source turn_result identities into a fork', async () => { + const oldId = '31313131-3131-3131-3131-313131313131'; + const newId = '41414141-4141-4141-4141-414141414141'; + const { file, lines } = seedSession(oldId); + fs.writeFileSync( + file, + [ + ...lines, + { + uuid: 'turn-result-1', + parentUuid: 'u2', + sessionId: oldId, + type: 'system', + subtype: 'turn_result', + timestamp: '2026-04-22T00:00:02.000Z', + cwd: lines[0]!['cwd'], + version: 'test', + systemPayload: { + promptId: 'source-prompt-id', + state: 'completed', + endedAt: 2000, + }, + }, + ] + .map((record) => JSON.stringify(record)) + .join('\n') + '\n', + ); + + const result = await service.forkSession(oldId, newId); + const written = fs + .readFileSync(result.filePath, 'utf8') + .trim() + .split('\n') + .map((line) => JSON.parse(line)); + + expect(written).toHaveLength(2); + expect(written.some((record) => record.subtype === 'turn_result')).toBe( + false, + ); + }); + it('writes source metadata and drops the inherited title for sourced forks', async () => { const oldId = '10101010-1010-1010-1010-101010101010'; const newId = '20202020-2020-2020-2020-202020202020'; diff --git a/packages/core/src/services/sessionService.ts b/packages/core/src/services/sessionService.ts index a28443ac275..48457e086a5 100644 --- a/packages/core/src/services/sessionService.ts +++ b/packages/core/src/services/sessionService.ts @@ -1764,6 +1764,7 @@ export class SessionService { record.type === 'system' && (record.subtype === 'parent_session' || record.subtype === 'session_source' || + record.subtype === 'turn_result' || (options.source && record.subtype === 'custom_title')) ), ); From 7862b2868476085927e26051f8e38ac84bad6c5a Mon Sep 17 00:00:00 2001 From: hit_aran Date: Mon, 10 Aug 2026 18:26:20 +0800 Subject: [PATCH 15/25] fix(serve): return strict final turn result --- docs/design/daemon-turn-status-endpoint.md | 11 +- docs/developers/qwen-serve-protocol.md | 2 +- .../cli/qwen-serve-streaming.test.ts | 119 ++++++- packages/acp-bridge/src/bridge.test.ts | 41 +++ packages/acp-bridge/src/bridge.ts | 9 + packages/acp-bridge/src/bridgeTypes.ts | 2 + .../acp-integration/session/Session.test.ts | 304 +++++++++++++++++- .../src/acp-integration/session/Session.ts | 43 ++- .../rewrite/MessageRewriteMiddleware.test.ts | 46 +++ .../rewrite/MessageRewriteMiddleware.ts | 4 + .../src/services/chatRecordingService.test.ts | 32 ++ .../core/src/services/chatRecordingService.ts | 7 + 12 files changed, 608 insertions(+), 12 deletions(-) diff --git a/docs/design/daemon-turn-status-endpoint.md b/docs/design/daemon-turn-status-endpoint.md index 6312ae45272..db76fc5ee2f 100644 --- a/docs/design/daemon-turn-status-endpoint.md +++ b/docs/design/daemon-turn-status-endpoint.md @@ -45,7 +45,9 @@ Shared errors: `404` unknown session (`SessionNotFoundError`), `400` Field presence: optional fields are omitted rather than defaulted. In particular `promptTextTruncated` / `resultTruncated` are only present when -`true` — consumers must treat an absent flag as `false`. +`true` — consumers must treat an absent flag as `false`. A truncated result +also carries `resultCode: "RESULT_TEXT_TRUNCATED"` so consumers can reject an +incomplete answer without interpreting free text. - `queued` / `running` mirror the bridge's live `pendingPromptList` (`queuedAt` at admission, `startedAt` at FIFO dispatch). @@ -60,11 +62,14 @@ particular `promptTextTruncated` / `resultTruncated` are only present when top-level assistant answer visible to the user: subagent-owned chunks, discrete messages, and slash-command output are excluded; when message rewrite succeeds, rewritten text replaces the corresponding raw segment. - Tool, thought, background, and status output are also excluded. Rewrite + Tool, thought, background, and status output are also excluded. When a + response block calls a tool, its visible preamble is discarded; only the + final response block after the last tool boundary is retained. Rewrite failure or an empty rewrite falls back to the raw top-level segment. Both fields are capped at `TURN_RESULT_TEXT_MAX_CHARS` (32,768 UTF-16 code units) with the paired - `*Truncated` flag. + `*Truncated` flag. A truncated `resultText` also sets + `resultCode: "RESULT_TEXT_TRUNCATED"`. The result cap is applied after rewritten-versus-raw selection, so excluded or replaced text does not consume the visible-answer budget. In-flight raw/rewrite candidates are separately bounded to 65,536 UTF-16 diff --git a/docs/developers/qwen-serve-protocol.md b/docs/developers/qwen-serve-protocol.md index 4082b1ba6c4..aa7e3ad0eaf 100644 --- a/docs/developers/qwen-serve-protocol.md +++ b/docs/developers/qwen-serve-protocol.md @@ -257,7 +257,7 @@ registry. Clients **must** gate UI off `features`, not off `mode` (per design `session_status` advertises `GET /session/:id/status`, the live bridge summary for a single session by id. In addition to `clientCount` and `hasActivePrompt`, live sessions expose `isWaitingForPermission`, `isWaitingForUserQuestion`, `pendingInteractionCount`, and a retained `turnError` after a failed turn. The error clears when the next prompt actually starts. Both the single-session status response and workspace session lists include `turnError` and `pendingInteractions`: render-ready permission actions or `ask_user_question` questions plus the `requestId` and selectable options required by the existing permission vote routes. Each user question has an `answerKey`; vote with `answers`, for example `{ "0": "Polling" }`, keyed by that value. Persisted-only sessions omit runtime state because no runtime exists. Older daemons return `404`; pre-flight this tag before polling a single session's status instead of scanning the full session list. -`session_turn_status` advertises `GET /session/:id/turns/current` and `GET /session/:id/turns/:promptId`. The current route returns the running turn, queued FIFO head, latest settled outcome, or `{ "state": "idle" }`; the prompt-specific route returns that prompt's live or persisted outcome, including `resultText` for the final main answer shown to the user when available. States are `idle`, `queued`, `running`, `completed`, `cancelled`, or `error`. A supported prompt-specific lookup with no matching turn returns `404 prompt_not_found`; clients must pre-flight this tag to distinguish that result from an older daemon that lacks the routes. +`session_turn_status` advertises `GET /session/:id/turns/current` and `GET /session/:id/turns/:promptId`. The current route returns the running turn, queued FIFO head, latest settled outcome, or `{ "state": "idle" }`; the prompt-specific route returns that prompt's live or persisted outcome, including `resultText` for the final main answer shown to the user when available. A result exceeding the bounded response size carries `resultTruncated: true` and `resultCode: "RESULT_TEXT_TRUNCATED"`; consumers that require a complete answer must not deliver that result. States are `idle`, `queued`, `running`, `completed`, `cancelled`, or `error`. A supported prompt-specific lookup with no matching turn returns `404 prompt_not_found`; clients must pre-flight this tag to distinguish that result from an older daemon that lacks the routes. `session_info` advertises `GET /workspace/:id/session-info` and its `/workspaces/:workspace/session-info` twin. The response aggregates persisted active and archived session counts without hydrating list metadata. It is an explicit O(n) disk scan and must not be polled; clients should treat `truncated: true` as a lower-bound result. diff --git a/integration-tests/cli/qwen-serve-streaming.test.ts b/integration-tests/cli/qwen-serve-streaming.test.ts index ef561d47145..5ce17898dec 100644 --- a/integration-tests/cli/qwen-serve-streaming.test.ts +++ b/integration-tests/cli/qwen-serve-streaming.test.ts @@ -43,7 +43,10 @@ import { tmpdir } from 'node:os'; import * as path from 'node:path'; import { fileURLToPath } from 'node:url'; import { afterAll, beforeAll, describe, expect, it } from 'vitest'; -import { isPathWithinRoot } from '@qwen-code/qwen-code-core'; +import { + isPathWithinRoot, + TURN_RESULT_TEXT_MAX_CHARS, +} from '@qwen-code/qwen-code-core'; import { DaemonClient, parseSseStream } from '@qwen-code/sdk'; import type { DaemonEvent, DaemonSessionSummary } from '@qwen-code/sdk'; import { @@ -336,6 +339,34 @@ beforeAll(async () => { }; } + if (messages.includes('turn-final-answer-boundary-e2e')) { + const toolCallId = 'call_turn_final_answer_boundary'; + if (!messages.includes(toolCallId)) { + return { + content: 'I will inspect the fixture first. ', + toolCalls: [ + fakeToolCall( + 'read_file', + { + file_path: path.join( + workspaceDir, + 'turn-final-answer-boundary.txt', + ), + }, + toolCallId, + ), + ], + }; + } + return { content: 'The strict final answer is 42.' }; + } + + if (messages.includes('turn-result-truncation-e2e')) { + return { + content: 'z'.repeat(TURN_RESULT_TEXT_MAX_CHARS + 100), + }; + } + if (pendingWritePath && messages.includes('fan-out') && !hasToolResult) { return { toolCalls: [ @@ -393,6 +424,10 @@ beforeAll(async () => { JSON.stringify(defaultSettings), ); workspaceDir = mkdtempSync(path.join(tmpdir(), 'qwen-serve-streaming-ws-')); + writeFileSync( + path.join(workspaceDir, 'turn-final-answer-boundary.txt'), + '42', + ); await startDaemon(); }, 30_000); @@ -478,6 +513,88 @@ describePOSIX('qwen serve — turn result polling', () => { await client.closeSession(session.sessionId).catch(() => undefined); } }, 45_000); + + it('returns only the final answer after the last tool boundary', async () => { + const session = await client.createOrAttachSession({ + workspaceCwd: workspaceDir, + }); + + try { + const accepted = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [ + { + type: 'text', + text: 'turn-final-answer-boundary-e2e', + }, + ], + }), + ); + expect(accepted).toBeDefined(); + if (!accepted) return; + + await expect + .poll(() => turnStatus(session.sessionId, accepted.promptId), { + timeout: 30_000, + }) + .toMatchObject({ + sessionId: session.sessionId, + promptId: accepted.promptId, + state: 'completed', + stopReason: 'end_turn', + resultText: 'The strict final answer is 42.', + }); + } finally { + await client.cancel(session.sessionId).catch(() => undefined); + await client.closeSession(session.sessionId).catch(() => undefined); + } + }, 45_000); + + it('returns a stable code when the final answer exceeds the cap', async () => { + const session = await client.createOrAttachSession({ + workspaceCwd: workspaceDir, + }); + + try { + const accepted = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [ + { + type: 'text', + text: 'turn-result-truncation-e2e', + }, + ], + }), + ); + expect(accepted).toBeDefined(); + if (!accepted) return; + + let settled: Record = {}; + await expect + .poll( + async () => { + settled = await turnStatus(session.sessionId, accepted.promptId); + return settled['state']; + }, + { timeout: 30_000 }, + ) + .toBe('completed'); + + expect(settled).toMatchObject({ + sessionId: session.sessionId, + promptId: accepted.promptId, + stopReason: 'end_turn', + resultTruncated: true, + resultCode: 'RESULT_TEXT_TRUNCATED', + }); + expect(settled['resultText']).toBe( + 'z'.repeat(TURN_RESULT_TEXT_MAX_CHARS), + ); + } finally { + await client.cancel(session.sessionId).catch(() => undefined); + await client.closeSession(session.sessionId).catch(() => undefined); + } + }, 45_000); }); describePOSIX('qwen serve — child-crash recovery (real SIGKILL)', () => { diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index bf27c69ce6a..51d74516a6f 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -10581,6 +10581,47 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('projects the result truncation code from persistence', async () => { + const handle = makeChannel({ + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { + v: 1, + sessionId: 'ignored', + turnResult: { + promptId: 'prompt-truncated-result', + state: 'completed', + stopReason: 'end_turn', + endedAt: 2000, + resultText: 'bounded prefix', + resultTruncated: true, + }, + }; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-truncated-result', + ), + ).resolves.toMatchObject({ + state: 'completed', + stopReason: 'end_turn', + resultText: 'bounded prefix', + resultTruncated: true, + resultCode: 'RESULT_TEXT_TRUNCATED', + }); + await bridge.shutdown(); + }); + it('reports removed queued and running prompts as cancelled immediately', async () => { let rejectRunning: ((err: Error) => void) | undefined; const runningGate = new Promise((_resolve, reject) => { diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 19cc4db3c29..0115bc447ff 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -30,6 +30,7 @@ import { PRIVATE_ACP_CAPABILITY_ENV, PRIVATE_PARENT_CAPABILITY_META_KEY, SESSION_ARTIFACT_PERSISTENCE_VERSION, + TURN_RESULT_CODE_TEXT_TRUNCATED, TURN_RESULT_TEXT_MAX_CHARS, normalizeTurnResultError, TrustGateError, @@ -1562,6 +1563,11 @@ function settledTurnStatus( ...(record.resultTruncated !== undefined ? { resultTruncated: record.resultTruncated } : {}), + ...(record.resultTruncated === true + ? { + resultCode: record.resultCode ?? TURN_RESULT_CODE_TEXT_TRUNCATED, + } + : {}), ...(record.originatorClientId !== undefined ? { originatorClientId: record.originatorClientId } : {}), @@ -1590,6 +1596,9 @@ function enrichTerminalTurnStatus( ...(persisted.resultTruncated !== undefined ? { resultTruncated: persisted.resultTruncated } : {}), + ...(persisted.resultCode !== undefined + ? { resultCode: persisted.resultCode } + : {}), ...(terminal.originatorClientId === undefined && persisted.originatorClientId !== undefined ? { originatorClientId: persisted.originatorClientId } diff --git a/packages/acp-bridge/src/bridgeTypes.ts b/packages/acp-bridge/src/bridgeTypes.ts index d559a63838b..0d5409d38a0 100644 --- a/packages/acp-bridge/src/bridgeTypes.ts +++ b/packages/acp-bridge/src/bridgeTypes.ts @@ -7,6 +7,7 @@ import type { ApprovalMode, SessionGroupPresetColor, + TurnResultCode, TurnResultErrorPayload, } from '@qwen-code/qwen-code-core'; import type { @@ -903,6 +904,7 @@ export interface BridgeTurnStatus { error?: TurnResultErrorPayload; resultText?: string; resultTruncated?: boolean; + resultCode?: TurnResultCode; originatorClientId?: string; } diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index 1162bcbe22d..977d0d8fff6 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -4127,6 +4127,307 @@ describe('Session', () => { ); }); + it('records only the final answer after a tool-call boundary', async () => { + mockToolRegistry.getTool.mockReturnValue({ + name: 'read_file', + kind: core.Kind.Read, + build: vi.fn().mockReturnValue({ + params: { path: '/tmp/test.txt' }, + getDefaultPermission: vi.fn().mockResolvedValue('allow'), + getDescription: vi.fn().mockReturnValue('Read file'), + toolLocations: vi.fn().mockReturnValue([]), + execute: vi.fn().mockResolvedValue({ + llmContent: 'file contents', + returnDisplay: 'file contents', + }), + }), + }); + mockConfig.getApprovalMode = vi.fn().mockReturnValue(ApprovalMode.YOLO); + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValueOnce( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { + content: { + parts: [{ text: 'I will check the file first. ' }], + }, + }, + ], + functionCalls: [ + { + id: 'call-1', + name: 'read_file', + args: { path: '/tmp/test.txt' }, + }, + ], + }, + }, + ]), + ) + .mockResolvedValueOnce( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { + content: { + parts: [{ text: 'The final answer is 42.' }], + }, + }, + ], + }, + }, + ]), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'read the file' }], + }, + trustedContext, + ); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + state: 'completed', + stopReason: 'end_turn', + resultText: 'The final answer is 42.', + }), + ); + }); + + it('ignores a delayed rewrite from the discarded tool-call block', async () => { + ( + mockSettings.user as { originalSettings?: Record } + ).originalSettings = { + messageRewrite: { + enabled: true, + target: 'message', + prompt: 'rewrite', + }, + }; + session.installRewriter(); + const rewrite = vi.fn().mockResolvedValue(''); + const middleware = session.messageRewriter as unknown as { + rewriter: { rewrite: typeof rewrite }; + sendUpdate: ( + update: SessionUpdate, + context: { + ownerPromptId?: string; + turnIndex: number; + rewritten: boolean; + replacesMessageText: boolean; + }, + ) => Promise; + }; + middleware.rewriter.rewrite = rewrite; + mockToolRegistry.getTool.mockReturnValue({ + name: 'read_file', + kind: core.Kind.Read, + build: vi.fn().mockReturnValue({ + params: { path: '/tmp/test.txt' }, + getDefaultPermission: vi.fn().mockResolvedValue('allow'), + getDescription: vi.fn().mockReturnValue('Read file'), + toolLocations: vi.fn().mockReturnValue([]), + execute: vi.fn().mockResolvedValue({ + llmContent: 'file contents', + returnDisplay: 'file contents', + }), + }), + }); + mockConfig.getApprovalMode = vi.fn().mockReturnValue(ApprovalMode.YOLO); + let releaseFinalResponse!: () => void; + const finalResponseGate = new Promise((resolve) => { + releaseFinalResponse = resolve; + }); + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValueOnce( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { + content: { + parts: [{ text: 'I will check the file first. ' }], + }, + }, + ], + functionCalls: [ + { + id: 'call-1', + name: 'read_file', + args: { path: '/tmp/test.txt' }, + }, + ], + usageMetadata: { + promptTokenCount: 1, + candidatesTokenCount: 1, + totalTokenCount: 2, + }, + }, + }, + ]), + ) + .mockResolvedValueOnce( + (async function* () { + await finalResponseGate; + yield { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { + content: { + parts: [{ text: 'The final answer is 42.' }], + }, + }, + ], + usageMetadata: { + promptTokenCount: 1, + candidatesTokenCount: 1, + totalTokenCount: 2, + }, + }, + }; + })(), + ); + + const prompt = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'read the file' }], + }, + trustedContext, + ); + await vi.waitFor(() => + expect(mockChat.sendMessageStream).toHaveBeenCalledTimes(2), + ); + + await middleware.sendUpdate( + { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'rewritten tool preamble' }, + _meta: { rewritten: true, turnIndex: 1 }, + }, + { + ownerPromptId: trustedContext.promptId, + turnIndex: 1, + rewritten: true, + replacesMessageText: true, + }, + ); + releaseFinalResponse(); + await prompt; + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + resultText: 'The final answer is 42.', + }), + ); + }); + + it('discards text from a failed non-continuation retry attempt', async () => { + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { content: { parts: [{ text: 'discarded attempt' }] } }, + ], + }, + }, + { type: core.StreamEventType.RETRY, value: {} }, + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { content: { parts: [{ text: 'final answer' }] } }, + ], + }, + }, + ]), + ); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'answer me' }], + }, + trustedContext, + ); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ resultText: 'final answer' }), + ); + }); + + it('waits for final answer delivery before recording it', async () => { + let releaseDelivery!: () => void; + const deliveryGate = new Promise((resolve) => { + releaseDelivery = resolve; + }); + let markDeliveryStarted!: () => void; + const deliveryStarted = new Promise((resolve) => { + markDeliveryStarted = resolve; + }); + vi.mocked(mockClient.sessionUpdate).mockImplementation( + async ({ update }) => { + if ( + update.sessionUpdate === 'agent_message_chunk' && + update.content.type === 'text' && + update.content.text === 'delayed final answer' + ) { + markDeliveryStarted(); + await deliveryGate; + } + }, + ); + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createStreamWithChunks([ + { + type: core.StreamEventType.CHUNK, + value: { + candidates: [ + { + content: { + parts: [{ text: 'delayed final answer' }], + }, + }, + ], + }, + }, + ]), + ); + const prompt = session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'answer me' }], + }, + trustedContext, + ); + await deliveryStarted; + const releaseTimer = setTimeout(releaseDelivery, 20); + + try { + await prompt; + } finally { + clearTimeout(releaseTimer); + releaseDelivery(); + } + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ resultText: 'delayed final answer' }), + ); + }); + it('records only top-level main-answer text', async () => { mockChat.sendMessageStream = vi.fn().mockResolvedValue( (async function* () { @@ -4674,7 +4975,7 @@ describe('Session', () => { }, ); - it('caps resultText at TURN_RESULT_TEXT_MAX_CHARS and flags truncation', async () => { + it('returns a stable result code when resultText exceeds the cap', async () => { const longText = 'a'.repeat(core.TURN_RESULT_TEXT_MAX_CHARS + 100); mockChat.sendMessageStream = vi.fn().mockResolvedValue( createStreamWithChunks([ @@ -4701,6 +5002,7 @@ describe('Session', () => { core.TURN_RESULT_TEXT_MAX_CHARS, ); expect(payload.resultTruncated).toBe(true); + expect(payload.resultCode).toBe('RESULT_TEXT_TRUNCATED'); }); it('captures streamed chunks until the character cap', async () => { diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index 0654f68a75c..e4c045450e4 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -173,6 +173,7 @@ import { getFullTurnVisionModelSelector, splitImageParts, approxBase64Bytes, + TURN_RESULT_CODE_TEXT_TRUNCATED, TURN_RESULT_TEXT_MAX_CHARS, normalizeTurnResultError, runWithRuntimeContentGenerator, @@ -3874,6 +3875,7 @@ export class Session implements SessionContext { nextMessage = null; channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(channelDeliveryCapture); + this.#beginTurnResultResponseBlock(); const channelDeliveryCheckpoint = channelDeliveryResponseBlock?.length ?? 0; @@ -3896,7 +3898,7 @@ export class Session implements SessionContext { continue; } - this.messageEmitter.emitMessage( + await this.messageEmitter.emitMessage( part.text, 'assistant', part.thought, @@ -3934,6 +3936,8 @@ export class Session implements SessionContext { channelDeliveryResponseBlock.length = channelDeliveryCheckpoint; } + this.#beginTurnResultResponseBlock(); + this.messageRewriter?.discardBufferedTurn(); } await finalizeToolCallPreparations( preparationTracker, @@ -4031,6 +4035,7 @@ export class Session implements SessionContext { channelDeliveryResponseBlock, functionCalls.length > 0, ); + this.#commitTurnResultResponseBlock(functionCalls.length > 0); if (usageMetadata) { this.#recordPromptTokenCount(usageMetadata); @@ -4843,6 +4848,7 @@ export class Session implements SessionContext { channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock( options.channelDeliveryCapture, ); + this.#beginTurnResultResponseBlock(); const channelDeliveryCheckpoint = channelDeliveryResponseBlock?.length ?? 0; initialSend = false; @@ -4878,7 +4884,7 @@ export class Session implements SessionContext { const candidate = response.value.candidates[0]; for (const part of candidate.content?.parts ?? []) { if (!part.text) continue; - this.messageEmitter.emitMessage( + await this.messageEmitter.emitMessage( part.text, 'assistant', part.thought, @@ -4914,6 +4920,8 @@ export class Session implements SessionContext { if (channelDeliveryResponseBlock) { channelDeliveryResponseBlock.length = channelDeliveryCheckpoint; } + this.#beginTurnResultResponseBlock(); + this.messageRewriter?.discardBufferedTurn(); } await finalizeToolCallPreparations( preparationTracker, @@ -4993,6 +5001,7 @@ export class Session implements SessionContext { channelDeliveryResponseBlock, functionCalls.length > 0, ); + this.#commitTurnResultResponseBlock(functionCalls.length > 0); if (usageMetadata) { this.#recordPromptTokenCount(usageMetadata); @@ -5280,6 +5289,9 @@ export class Session implements SessionContext { ? `rewrite:${rewriteContext.turnIndex}` : 'direct'; let segment = recording.resultSegments.get(segmentKey); + if (rewriteContext?.rewritten && !segment) { + return; + } if (!segment) { if (recording.resultSegments.size >= TURN_RESULT_CAPTURE_MAX_SEGMENTS) { recording.resultSegmentsTruncated = true; @@ -5310,6 +5322,20 @@ export class Session implements SessionContext { if (content.text.length > remaining) segment.rawTruncated = true; } + #beginTurnResultResponseBlock(): void { + const recording = this.#turnRecording; + if (!recording) return; + recording.resultSegments.clear(); + recording.resultCapturedChars = 0; + recording.resultSegmentsTruncated = false; + } + + #commitTurnResultResponseBlock(hasFunctionCalls: boolean): void { + if (hasFunctionCalls) { + this.#beginTurnResultResponseBlock(); + } + } + /** * Write the turn's captured `turn_result` record into the transcript. * Settles the exact recording captured at turn start — never the current @@ -5340,6 +5366,10 @@ export class Session implements SessionContext { const selectedResult = truncateTurnText( selectedSegments.map(({ text }) => text).join(''), ); + const resultTruncated = + selectedResult.truncated || + selectedSegments.some(({ truncated }) => truncated) || + recording.resultSegmentsTruncated; const payload: TurnResultRecordPayload = { promptId: recording.promptId, state, @@ -5356,10 +5386,11 @@ export class Session implements SessionContext { ...(selectedResult.text.length > 0 ? { resultText: selectedResult.text } : {}), - ...(selectedResult.truncated || - selectedSegments.some(({ truncated }) => truncated) || - recording.resultSegmentsTruncated - ? { resultTruncated: true } + ...(resultTruncated + ? { + resultTruncated: true, + resultCode: TURN_RESULT_CODE_TEXT_TRUNCATED, + } : {}), ...(recording.originatorClientId !== undefined ? { originatorClientId: recording.originatorClientId } diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts index 20ce21b7e20..e8430d86ff7 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts @@ -240,6 +240,52 @@ describe('MessageRewriteMiddleware', () => { }); }); + it('discards only the current buffer without aborting prior rewrites', async () => { + const { middleware } = createMiddleware('message'); + const { LlmRewriter } = await import('./LlmRewriter.js'); + const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { + rewrite: ReturnType; + }; + let resolvePriorRewrite!: (value: string) => void; + rewriter.rewrite.mockImplementationOnce( + () => + new Promise((resolve) => { + resolvePriorRewrite = resolve; + }), + ); + + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'prior tool block' }, + } as unknown as SessionUpdate); + await middleware.flushTurn(); + const priorRewriteSignal = rewriter.rewrite.mock.calls[0][1] as AbortSignal; + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'failed retry attempt' }, + } as unknown as SessionUpdate); + + middleware.discardBufferedTurn(); + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'final answer' }, + } as unknown as SessionUpdate); + await middleware.flushTurn(); + resolvePriorRewrite('prior rewritten block'); + await middleware.waitForPendingRewrites(); + + expect(priorRewriteSignal.aborted).toBe(false); + expect(rewriter.rewrite).toHaveBeenNthCalledWith( + 2, + { + thoughts: [], + messages: ['final answer'], + hasToolCalls: false, + }, + expect.any(AbortSignal), + ); + }); + it('does not deliver or commit a rewrite after its turn signal aborts', async () => { const { middleware, mockSendUpdate } = createMiddleware('message'); const { LlmRewriter } = await import('./LlmRewriter.js'); diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts index 66bef7551c2..a8635b57414 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts @@ -220,6 +220,10 @@ export class MessageRewriteMiddleware { this.generationAbortController.abort(); this.generationAbortController = new AbortController(); this.generation++; + this.discardBufferedTurn(); + } + + discardBufferedTurn(): void { this.turnBuffer.discard(); this.turnMeta = undefined; this.turnOwnerPromptId = undefined; diff --git a/packages/core/src/services/chatRecordingService.test.ts b/packages/core/src/services/chatRecordingService.test.ts index 15c5b3eca1b..508398fae98 100644 --- a/packages/core/src/services/chatRecordingService.test.ts +++ b/packages/core/src/services/chatRecordingService.test.ts @@ -12,6 +12,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; import type { Config } from '../config/config.js'; import { ChatRecordingService, + isTurnResultRecordPayload, normalizeTurnResultError, TURN_RESULT_ERROR_CODE_MAX_CHARS, TURN_RESULT_ERROR_MESSAGE_MAX_CHARS, @@ -853,6 +854,37 @@ describe('ChatRecordingService', () => { }); }); + describe('isTurnResultRecordPayload', () => { + it('accepts only the stable result truncation code', () => { + expect( + isTurnResultRecordPayload({ + promptId: 'prompt-1', + state: 'completed', + endedAt: 2000, + resultTruncated: true, + resultCode: 'RESULT_TEXT_TRUNCATED', + }), + ).toBe(true); + expect( + isTurnResultRecordPayload({ + promptId: 'prompt-1', + state: 'completed', + endedAt: 2000, + resultTruncated: true, + resultCode: 'UNKNOWN_RESULT_CODE', + }), + ).toBe(false); + expect( + isTurnResultRecordPayload({ + promptId: 'prompt-1', + state: 'completed', + endedAt: 2000, + resultCode: 'RESULT_TEXT_TRUNCATED', + }), + ).toBe(false); + }); + }); + describe('normalizeTurnResultError', () => { it('falls back safely when getters and string conversion throw', () => { const unsafe = Object.defineProperties( diff --git a/packages/core/src/services/chatRecordingService.ts b/packages/core/src/services/chatRecordingService.ts index 068543172ed..18cfca9541c 100644 --- a/packages/core/src/services/chatRecordingService.ts +++ b/packages/core/src/services/chatRecordingService.ts @@ -654,9 +654,13 @@ export interface TurnResultRecordPayload { promptTextTruncated?: boolean; resultText?: string; resultTruncated?: boolean; + resultCode?: TurnResultCode; originatorClientId?: string; } +export const TURN_RESULT_CODE_TEXT_TRUNCATED = 'RESULT_TEXT_TRUNCATED' as const; +export type TurnResultCode = typeof TURN_RESULT_CODE_TEXT_TRUNCATED; + export function isTurnResultRecordPayload( value: unknown, ): value is TurnResultRecordPayload { @@ -691,6 +695,9 @@ export function isTurnResultRecordPayload( !optionalBoolean('promptTextTruncated') || !optionalStringWithin('resultText', TURN_RESULT_TEXT_MAX_CHARS) || !optionalBoolean('resultTruncated') || + (payload['resultCode'] !== undefined && + (payload['resultCode'] !== TURN_RESULT_CODE_TEXT_TRUNCATED || + payload['resultTruncated'] !== true)) || !optionalStringWithin('originatorClientId') ) { return false; From 24847a4d5911f6fa72d6d34091d57f17605a42c7 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Mon, 10 Aug 2026 20:34:12 +0800 Subject: [PATCH 16/25] fix(serve): persist deadline turn errors --- .../cli/qwen-serve-streaming.test.ts | 63 ++++++++++++++++++- packages/acp-bridge/src/bridge.test.ts | 10 +++ packages/acp-bridge/src/bridge.ts | 24 +++++-- packages/acp-bridge/src/bridgeTypes.ts | 4 ++ .../cli/src/acp-integration/acpAgent.test.ts | 39 ++++++++++++ packages/cli/src/acp-integration/acpAgent.ts | 24 ++++++- .../acp-integration/session/Session.test.ts | 35 +++++++++++ .../src/acp-integration/session/Session.ts | 55 ++++++++++++++-- 8 files changed, 241 insertions(+), 13 deletions(-) diff --git a/integration-tests/cli/qwen-serve-streaming.test.ts b/integration-tests/cli/qwen-serve-streaming.test.ts index 5ce17898dec..797a0fe1165 100644 --- a/integration-tests/cli/qwen-serve-streaming.test.ts +++ b/integration-tests/cli/qwen-serve-streaming.test.ts @@ -183,7 +183,9 @@ function writeUserSettings(settings: Record): void { ); } -async function startDaemon(): Promise { +async function startDaemon( + options: { promptDeadlineMs?: number } = {}, +): Promise { daemon = spawn( process.execPath, [ @@ -199,6 +201,9 @@ async function startDaemon(): Promise { // one hermetic settings/trust boundary across direct and CI runs. '--workspace', workspaceDir, + ...(options.promptDeadlineMs !== undefined + ? ['--prompt-deadline-ms', String(options.promptDeadlineMs)] + : []), ], { stdio: ['ignore', 'pipe', 'pipe'], @@ -1068,6 +1073,62 @@ describePOSIX('qwen serve — daemon Todo Stop Guard replay', () => { }); describePOSIX('qwen serve — turn result blocker regressions', () => { + it('keeps a dispatched deadline error across daemon restart', async () => { + await stopDaemon(); + await startDaemon({ promptDeadlineMs: 100 }); + const session = await client.createOrAttachSession({ + workspaceCwd: workspaceDir, + sessionScope: 'thread', + }); + blockedPromptMarker = `deadline-turn-${Date.now()}`; + blockedPromptGate = new Promise((resolve) => { + releaseBlockedPrompt = resolve; + }); + + try { + const accepted = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [{ type: 'text', text: blockedPromptMarker }], + }), + ); + expect(accepted).toBeDefined(); + if (!accepted) return; + + await expect + .poll(() => turnStatus(session.sessionId, accepted.promptId), { + timeout: 30_000, + }) + .toMatchObject({ + promptId: accepted.promptId, + state: 'error', + error: { code: 'prompt_deadline_exceeded' }, + }); + + releaseBlockedPrompt?.(); + await stopDaemon(); + await startDaemon(); + await client.resumeSession(session.sessionId, { + workspaceCwd: workspaceDir, + }); + await expect( + turnStatus(session.sessionId, accepted.promptId), + ).resolves.toMatchObject({ + promptId: accepted.promptId, + state: 'error', + error: { code: 'prompt_deadline_exceeded' }, + }); + } finally { + releaseBlockedPrompt?.(); + blockedPromptMarker = ''; + blockedPromptGate = undefined; + releaseBlockedPrompt = undefined; + await client.cancel(session.sessionId).catch(() => undefined); + await client.closeSession(session.sessionId).catch(() => undefined); + await stopDaemon(); + await startDaemon(); + } + }, 90_000); + it('keeps exact queued cancellation and prior completion across daemon restart', async () => { const session = await client.createOrAttachSession({ workspaceCwd: workspaceDir, diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 51d74516a6f..764e9952321 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -11068,6 +11068,16 @@ describe('createAcpSessionBridge', () => { await vi.waitFor(() => { expect(handle.agent.cancelCalls.length).toBeGreaterThan(0); }); + expect(handle.agent.extMethodCalls).toContainEqual({ + method: PROMPT_CANCEL_METHOD, + params: { + sessionId: session.sessionId, + terminalError: { + code: 'prompt_deadline_exceeded', + message: 'prompt exceeded the 50ms deadline', + }, + }, + }); // FIFO released: a follow-up prompt dispatches and completes. const followup = bridge.sendPrompt( session.sessionId, diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 0115bc447ff..44099ff08c7 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -136,6 +136,7 @@ import { LOAD_REPLAY_PAGE_SIZE_META_KEY, LOAD_REPLAY_VERSION, PROMPT_CANCEL_METHOD, + type PromptCancelRequest, REQUESTED_SESSION_ID_META_KEY, TODO_STOP_GUARD_QUEUE_RELEASE_METHOD, WORKTREE_MCP_DEFER_META_KEY, @@ -2613,6 +2614,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { entry: SessionEntry, pending: PendingPromptEntry, notification: CancelNotification, + terminalError?: PromptCancelRequest['terminalError'], ): Promise => { if (pending.cancelForwardInitial) { return pending.cancelForwardInitial; @@ -2620,7 +2622,10 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { const initial = (async () => { try { const extension = entry.connection - .extMethod(PROMPT_CANCEL_METHOD, notification) + .extMethod(PROMPT_CANCEL_METHOD, { + ...notification, + ...(terminalError !== undefined ? { terminalError } : {}), + } satisfies PromptCancelRequest) .then((result) => ({ kind: 'result' as const, result })); const outcome = await Promise.race([ extension, @@ -7133,9 +7138,20 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { ); cancelPendingForSession(sessionId); if (byId.get(sessionId) === entry) { - void forwardRunningPromptCancel(entry, pendingEntry, { - sessionId, - }).catch((err) => { + const abortReason = pendingAbort.signal.reason; + void forwardRunningPromptCancel( + entry, + pendingEntry, + { + sessionId, + }, + abortReason instanceof PromptDeadlineExceededError + ? { + code: 'prompt_deadline_exceeded', + message: abortReason.message, + } + : undefined, + ).catch((err) => { writeStderrLine( `[pending-prompt] cancel forward failed after removePendingPrompt session=${sessionId}: ${extractErrorMessage(err)}`, ); diff --git a/packages/acp-bridge/src/bridgeTypes.ts b/packages/acp-bridge/src/bridgeTypes.ts index 0d5409d38a0..892f7b68870 100644 --- a/packages/acp-bridge/src/bridgeTypes.ts +++ b/packages/acp-bridge/src/bridgeTypes.ts @@ -793,6 +793,10 @@ export interface TodoStopGuardQueueReleasedRequest { /** Parent-to-agent request that acknowledges prompt cancellation handling. */ export const PROMPT_CANCEL_METHOD = 'craft/cancelPendingPrompt'; +export type PromptCancelRequest = CancelNotification & { + terminalError?: TurnResultErrorPayload; +}; + /** * Reverse tool channel marker (issue #5626, Phase 2). The parent serve process * stamps this boolean on a client-hosted (extension) MCP server's diff --git a/packages/cli/src/acp-integration/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts index ee67a8914e5..72c7cff003d 100644 --- a/packages/cli/src/acp-integration/acpAgent.test.ts +++ b/packages/cli/src/acp-integration/acpAgent.test.ts @@ -3930,6 +3930,45 @@ describe('QwenAgent MCP SSE/HTTP support', () => { await agentPromise; }); + it('preserves a terminal error as the tracked prompt cancellation reason', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const { agent, agentPromise } = await bootAcpAgent(); + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + let finishPrompt: ((value: unknown) => void) | undefined; + lastSessionMock?.prompt.mockImplementation( + () => + new Promise((resolve) => { + finishPrompt = resolve; + }), + ); + const prompt = agent.prompt({ sessionId, prompt: [] }); + + await vi.waitFor(() => expect(lastSessionMock?.prompt).toHaveBeenCalled()); + const cancellationSignal = lastSessionMock?.prompt.mock.calls[0]?.[2] as + | AbortSignal + | undefined; + const cancellation = agent.extMethod(PROMPT_CANCEL_METHOD, { + sessionId, + terminalError: { + code: 'prompt_deadline_exceeded', + message: 'prompt exceeded the 50ms deadline', + }, + }); + + await vi.waitFor(() => expect(cancellationSignal?.aborted).toBe(true)); + expect(cancellationSignal?.reason).toMatchObject({ + code: 'prompt_deadline_exceeded', + message: 'prompt exceeded the 50ms deadline', + }); + finishPrompt?.({ stopReason: 'cancelled' }); + await expect(cancellation).resolves.toEqual({ cancelled: true }); + await prompt; + + mockConnectionState.resolve(); + await agentPromise; + }); + it('acknowledges cancellation as a no-op when no prompt call is active', async () => { const sessionId = '11111111-1111-1111-1111-111111111111'; await setupSessionMocks(sessionId); diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index d4f679beb11..63dc9357f41 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -335,6 +335,7 @@ import { LOAD_REPLAY_PAGE_SIZE_META_KEY, LOAD_REPLAY_VERSION, PROMPT_CANCEL_METHOD, + type PromptCancelRequest, REQUESTED_SESSION_ID_META_KEY, TODO_STOP_GUARD_QUEUE_RELEASE_METHOD, isValidTrustedModelPrompt, @@ -7901,7 +7902,7 @@ class QwenAgent implements Agent { switch (method) { case PROMPT_CANCEL_METHOD: { - const sessionId = params['sessionId']; + const { sessionId, terminalError } = params as PromptCancelRequest; if (typeof sessionId !== 'string' || sessionId.length === 0) { throw RequestError.invalidParams( undefined, @@ -7921,7 +7922,26 @@ class QwenAgent implements Agent { if (targetedCalls.size === 0) { return { cancelled: false }; } - targetedCalls.forEach((call) => call.controller.abort()); + let abortReason: Error | undefined; + if (terminalError !== undefined) { + if ( + typeof terminalError !== 'object' || + terminalError === null || + typeof terminalError.message !== 'string' || + terminalError.message.length === 0 || + typeof terminalError.code !== 'string' || + terminalError.code.length === 0 + ) { + throw RequestError.invalidParams( + undefined, + 'Invalid prompt terminal error', + ); + } + abortReason = Object.assign(new Error(terminalError.message), { + code: terminalError.code, + }); + } + targetedCalls.forEach((call) => call.controller.abort(abortReason)); await Promise.all(Array.from(targetedCalls, (call) => call.settled)); return { cancelled: true }; } diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index 977d0d8fff6..a2680d0d525 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -5244,6 +5244,41 @@ describe('Session', () => { ); }); + it('records a terminal parent cancellation as an error', async () => { + const cancellation = new AbortController(); + mockChat.sendMessageStream = vi.fn().mockResolvedValue( + createFailingStream('Request was aborted.', () => { + cancellation.abort( + Object.assign(new Error('prompt exceeded the 50ms deadline'), { + code: 'prompt_deadline_exceeded', + }), + ); + }), + ); + + await expect( + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'time out' }], + }, + trustedContext, + cancellation.signal, + ), + ).rejects.toThrow('Request was aborted.'); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'daemon-prompt-id', + state: 'error', + error: { + code: 'prompt_deadline_exceeded', + message: 'prompt exceeded the 50ms deadline', + }, + }), + ); + }); + it('records a cancelled turn when session disposal aborts a Stop hook', async () => { const messageBus = { request: vi.fn().mockImplementation( diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index e4c045450e4..941d810a488 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -345,6 +345,19 @@ function isControlledPromptAbort(signal: AbortSignal): boolean { signal.reason === PROMPT_SUPERSEDED_ABORT_REASON) ); } + +function getTerminalPromptAbortError(signal: AbortSignal): unknown | undefined { + if (!signal.aborted || isControlledPromptAbort(signal)) return undefined; + const reason = signal.reason; + if (typeof reason !== 'object' || reason === null) return undefined; + const record = reason as { code?: unknown; message?: unknown }; + return typeof record.code === 'string' && + record.code.length > 0 && + typeof record.message === 'string' && + record.message.length > 0 + ? reason + : undefined; +} const DAEMON_RETRY_META_KEY = 'qwen.daemon.retry'; const DAEMON_CONTINUE_META_KEY = 'qwen.daemon.continueLastTurn'; const TODO_STOP_GUARD_PROMPT_PREFIX = '[Todo Stop Guard] '; @@ -3038,6 +3051,16 @@ export class Session implements SessionContext { throw error; } if (admissionCancellation?.aborted) { + const terminalError = getTerminalPromptAbortError(admissionCancellation); + if (terminalError !== undefined) { + this.#settleTurnRecording( + 'error', + turnRecording, + undefined, + terminalError, + ); + throw terminalError; + } this.#settleTurnRecording('cancelled', turnRecording); return { stopReason: 'cancelled' }; } @@ -3048,7 +3071,11 @@ export class Session implements SessionContext { // targets us. A cancel during admission cannot target this pending prompt. this.pendingPrompt?.abort(PROMPT_SUPERSEDED_ABORT_REASON); const pendingSend = new AbortController(); - const cancelPendingSend = () => pendingSend.abort(USER_CANCEL_ABORT_REASON); + const cancelPendingSend = () => + pendingSend.abort( + getTerminalPromptAbortError(admissionCancellation!) ?? + USER_CANCEL_ABORT_REASON, + ); if (admissionCancellation) { admissionCancellation.addEventListener('abort', cancelPendingSend, { once: true, @@ -3119,6 +3146,16 @@ export class Session implements SessionContext { if (pendingSend.signal.aborted) { releasePendingSend(); this.todoStopGuard.suspend(); + const terminalError = getTerminalPromptAbortError(pendingSend.signal); + if (terminalError !== undefined) { + this.#settleTurnRecording( + 'error', + turnRecording, + undefined, + terminalError, + ); + throw terminalError; + } this.#settleTurnRecording('cancelled', turnRecording); return { stopReason: 'cancelled' }; } @@ -3169,10 +3206,15 @@ export class Session implements SessionContext { invocationContext, modelPrompt, ); - settlement = { - state: result.stopReason === 'cancelled' ? 'cancelled' : 'completed', - response: result, - }; + const terminalError = getTerminalPromptAbortError(pendingSend.signal); + settlement = + result.stopReason === 'cancelled' && terminalError !== undefined + ? { state: 'error', error: terminalError } + : { + state: + result.stopReason === 'cancelled' ? 'cancelled' : 'completed', + response: result, + }; promptResult = result; releasePendingSend(); // Drain any cron prompts that queued while the prompt was active @@ -3198,9 +3240,10 @@ export class Session implements SessionContext { const controlledCancellation = isControlledPromptAbort( pendingSend.signal, ); + const terminalError = getTerminalPromptAbortError(pendingSend.signal); settlement = { state: controlledCancellation ? 'cancelled' : 'error', - error, + error: terminalError ?? error, }; didPromptFail = true; if (error instanceof SessionWriterError) { From 47519e996b628bc603995f9009f421f4acca3f6f Mon Sep 17 00:00:00 2001 From: hit_aran Date: Tue, 11 Aug 2026 12:07:36 +0800 Subject: [PATCH 17/25] fix(daemon): preserve pollable turn results --- .../cli/qwen-serve-streaming.test.ts | 49 ++++ packages/acp-bridge/src/bridge.test.ts | 228 ++++++++++++++++-- packages/acp-bridge/src/bridge.ts | 83 ++++--- .../cli/src/acp-integration/acpAgent.test.ts | 66 +++++ packages/cli/src/acp-integration/acpAgent.ts | 13 +- .../acp-integration/session/Session.test.ts | 73 ++++++ .../src/acp-integration/session/Session.ts | 55 +++++ .../rewrite/MessageRewriteMiddleware.test.ts | 63 +++++ .../rewrite/MessageRewriteMiddleware.ts | 12 +- 9 files changed, 591 insertions(+), 51 deletions(-) diff --git a/integration-tests/cli/qwen-serve-streaming.test.ts b/integration-tests/cli/qwen-serve-streaming.test.ts index d51c742a551..d0b1010010b 100644 --- a/integration-tests/cli/qwen-serve-streaming.test.ts +++ b/integration-tests/cli/qwen-serve-streaming.test.ts @@ -1426,6 +1426,55 @@ describePOSIX('qwen serve — turn result blocker regressions', () => { } }, 90_000); + it('keeps retained prompt results and hides the rewound turn', async () => { + const session = await client.createOrAttachSession({ + workspaceCwd: workspaceDir, + sessionScope: 'thread', + }); + const promptIds: string[] = []; + + try { + for (const marker of ['rewind-a', 'rewind-b', 'rewind-c']) { + const accepted = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [{ type: 'text', text: marker }], + }), + ); + expect(accepted).toBeDefined(); + if (!accepted) return; + promptIds.push(accepted.promptId); + await expect + .poll(() => turnStatus(session.sessionId, accepted.promptId), { + timeout: 30_000, + }) + .toMatchObject({ state: 'completed' }); + } + + const { snapshots } = await client.getRewindSnapshots(session.sessionId); + const thirdTurn = snapshots.find((snapshot) => snapshot.turnIndex === 2); + expect(thirdTurn).toBeDefined(); + if (!thirdTurn) return; + + await expect( + client.rewindSession(session.sessionId, thirdTurn.promptId, { + rewindFiles: false, + }), + ).resolves.toMatchObject({ rewound: true, targetTurnIndex: 2 }); + await expect( + turnStatus(session.sessionId, promptIds[0]!), + ).resolves.toMatchObject({ state: 'completed' }); + await expect( + turnStatus(session.sessionId, promptIds[1]!), + ).resolves.toMatchObject({ state: 'completed' }); + await expect( + turnStatus(session.sessionId, promptIds[2]!), + ).resolves.toEqual({ status: 404 }); + } finally { + await client.cancel(session.sessionId).catch(() => undefined); + await client.closeSession(session.sessionId).catch(() => undefined); + } + }, 90_000); + it('rewrites repeated-tool diagnostics without recording them as the answer', async () => { repeatedFailureMarker = `repeated-failure-${Date.now()}`; repeatedFailureRequestCount = 0; diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 764e9952321..7eae6f0ec9c 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -3593,7 +3593,7 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); - it('clears terminal overlays after a successful transcript rewind', async () => { + it('keeps terminal overlays retained by a successful transcript rewind', async () => { const bridge = makeBridge({ channelFactory: async () => makeChannel({ @@ -3604,9 +3604,13 @@ describe('createAcpSessionBridge', () => { } if (method === SERVE_CONTROL_EXT_METHODS.sessionRewind) { return { - targetTurnIndex: 0, + targetTurnIndex: 2, filesChanged: [], filesFailed: [], + retainedTurnResultPromptIds: [ + 'prompt-before-rewind-a', + 'prompt-before-rewind-b', + ], }; } return {}; @@ -3614,30 +3618,43 @@ describe('createAcpSessionBridge', () => { }).channel, }); const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); - await bridge.sendPrompt( - session.sessionId, - { - sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'abandoned answer' }], - }, - undefined, - { promptId: 'prompt-before-rewind' }, - ); + for (const promptId of [ + 'prompt-before-rewind-a', + 'prompt-before-rewind-b', + 'prompt-before-rewind-c', + ]) { + await bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: promptId }], + }, + undefined, + { promptId }, + ); + } + + await bridge.rewindSession(session.sessionId, { promptId: 'turn-2' }); + await expect( bridge.getSessionTurnStatus( session.sessionId, undefined, - 'prompt-before-rewind', + 'prompt-before-rewind-a', ), ).resolves.toMatchObject({ state: 'completed' }); - - await bridge.rewindSession(session.sessionId, { promptId: 'turn-0' }); - await expect( bridge.getSessionTurnStatus( session.sessionId, undefined, - 'prompt-before-rewind', + 'prompt-before-rewind-b', + ), + ).resolves.toMatchObject({ state: 'completed' }); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-before-rewind-c', ), ).resolves.toBeUndefined(); await bridge.shutdown(); @@ -10786,6 +10803,185 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('keeps queued removal authoritative when terminal persistence fails', async () => { + let releaseRunning!: () => void; + const runningGate = new Promise((resolve) => { + releaseRunning = resolve; + }); + const handle = makeChannel({ + promptImpl: async (request) => { + if ((request.prompt[0] as { text?: string }).text === 'running') { + await runningGate; + } + return { stopReason: 'end_turn' }; + }, + extMethodImpl: async (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + throw new Error('session writer unavailable'); + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const running = bridge.sendPrompt(session.sessionId, { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'running' }], + }); + const queued = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-write-failure' }, + ); + void queued.catch(() => undefined); + await vi.waitFor(() => + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(2), + ); + + const removalOutcome = await bridge + .removePendingPrompt(session.sessionId, 'prompt-write-failure') + .then( + (value) => ({ value }), + (error: unknown) => ({ error }), + ); + releaseRunning(); + await running; + const queuedOutcome = await queued.then( + (value) => ({ value }), + (error: unknown) => ({ error }), + ); + await bridge.shutdown(); + + expect(removalOutcome).toEqual({ value: { removed: true } }); + expect(queuedOutcome).toMatchObject({ error: { name: 'AbortError' } }); + }); + + it('bounds queued terminal persistence before removal resolves', async () => { + let releaseRunning!: () => void; + const runningGate = new Promise((resolve) => { + releaseRunning = resolve; + }); + let releasePersistence!: () => void; + const persistenceGate = new Promise((resolve) => { + releasePersistence = resolve; + }); + const handle = makeChannel({ + promptImpl: async (request) => { + if ((request.prompt[0] as { text?: string }).text === 'running') { + await runningGate; + } + return { stopReason: 'end_turn' }; + }, + extMethodImpl: async (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + await persistenceGate; + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + initializeTimeoutMs: 20, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const running = bridge.sendPrompt(session.sessionId, { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'running' }], + }); + const queued = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-hung-write' }, + ); + void queued.catch(() => undefined); + await vi.waitFor(() => + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(2), + ); + + const removal = bridge.removePendingPrompt( + session.sessionId, + 'prompt-hung-write', + ); + const observed = await Promise.race([ + removal.then( + () => 'settled', + () => 'rejected', + ), + new Promise((resolve) => + setTimeout(() => resolve('still-pending'), 150), + ), + ]); + releasePersistence(); + await removal.catch(() => undefined); + releaseRunning(); + await running; + await queued.catch(() => undefined); + await bridge.shutdown(); + + expect(observed).toBe('settled'); + }); + + it('keeps a queued deadline authoritative when persistence fails', async () => { + let releaseRunning!: () => void; + const runningGate = new Promise((resolve) => { + releaseRunning = resolve; + }); + const handle = makeChannel({ + promptImpl: async () => { + await runningGate; + return { stopReason: 'end_turn' }; + }, + extMethodImpl: async (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + throw new Error('session writer unavailable'); + } + return {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const running = bridge.sendPrompt(session.sessionId, { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'running' }], + }); + const queued = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-deadline-write-failure', deadlineMs: 20 }, + ); + const queuedOutcomePromise = queued.then( + (value) => ({ value }), + (error: unknown) => ({ error }), + ); + await new Promise((resolve) => setTimeout(resolve, 50)); + releaseRunning(); + await running; + const queuedOutcome = await queuedOutcomePromise; + await bridge.shutdown(); + + expect(queuedOutcome).toHaveProperty('error'); + if (!('error' in queuedOutcome)) { + throw new Error('Expected queued prompt to reject'); + } + expect(queuedOutcome.error).toBeInstanceOf(PromptDeadlineExceededError); + }); + it('preserves a deadline error while enriching it from persistence', async () => { let persistedResult: Record | null = null; const handle = makeChannel({ diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 44099ff08c7..391622c915e 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -613,6 +613,8 @@ interface SessionEntry { * transient terminal-to-404 regression. */ terminalTurnStatuses: Map; + /** Maximum time to wait for a queued turn's best-effort transcript write. */ + terminalPersistenceTimeoutMs: number; /** Bridge prompt that owns the child Guard wait for this FIFO. */ todoStopGuardAwaitingQueuedPromptOwnerPromptId?: string; /** @@ -1365,6 +1367,18 @@ function terminalStatusRecord( }; } +/** Reuse one channel-exit rejection instead of adding a listener per call. */ +function getTransportClosedReject(entry: SessionEntry): Promise { + if (!entry.transportClosedReject) { + entry.transportClosedReject = entry.channel.exited.then(() => { + throw new BridgeChannelClosedError( + `mid-request (session ${entry.sessionId})`, + ); + }); + } + return entry.transportClosedReject; +} + /** * Publish the formal terminal event for an accepted prompt exactly once. * All terminal paths (agent settle, queued removal, deadline, session @@ -1395,13 +1409,27 @@ function publishPromptTerminal( !pendingEntry.dispatched && pendingEntry.terminalPersistence === undefined ) { - pendingEntry.terminalPersistence = entry.connection - .extMethod(SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, { - sessionId: entry.sessionId, - turnResult: terminalStatusRecord(status), - }) - .then(() => undefined); - pendingEntry.terminalPersistence.catch(() => {}); + pendingEntry.terminalPersistence = Promise.race([ + withTimeout( + entry.connection.extMethod( + SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + { + sessionId: entry.sessionId, + turnResult: terminalStatusRecord(status), + }, + ), + entry.terminalPersistenceTimeoutMs, + SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + ), + getTransportClosedReject(entry), + ]).then( + () => undefined, + (error: unknown) => { + writeStderrLine( + `[turn-result] session=${entry.sessionId} promptId=${pendingEntry.promptId} action=persist_failed error=${extractErrorMessage(error)}`, + ); + }, + ); } const originatorClientId = pendingEntry.originatorClientId; if (terminal.kind === 'complete') { @@ -4071,28 +4099,6 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { byId.get(sessionId)?.pendingInteractions.clear(); }; - /** - * Lazy-init the per-session `transportClosedReject` promise that - * `sendPrompt` / `setSessionModel` / `applyModelServiceId` race their - * ACP calls against. ONE listener is attached to `channel.exited` - * over the session's lifetime (the first caller "wins" and creates - * the promise; subsequent callers reuse it) — a per-call attach - * would grow Node's listener list linearly with prompt count on - * chatty sessions. The rejection message names the FIRST caller, - * which can be misleading if a later method observes the failure; - * the cost-benefit favors the single-listener invariant. - */ - const getTransportClosedReject = (entry: SessionEntry): Promise => { - if (!entry.transportClosedReject) { - entry.transportClosedReject = entry.channel.exited.then(() => { - throw new BridgeChannelClosedError( - `mid-request (session ${entry.sessionId})`, - ); - }); - } - return entry.transportClosedReject; - }; - const resolveWorkspaceKey = (rawWorkspaceCwd: string): string => { // #7139: host-shaped Windows paths reach the in-container bridge via // clients and persisted registrations; the shared helper maps them to @@ -4781,6 +4787,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { pendingAgentNotificationCount: 0, pendingPromptList: [], terminalTurnStatuses: new Map(), + terminalPersistenceTimeoutMs: initTimeoutMs, midTurnMessageQueue: [], modelChangeQueue: Promise.resolve(), approvalModeQueue: Promise.resolve(), @@ -9607,7 +9614,23 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { throw err; } - entry.terminalTurnStatuses.clear(); + const retainedTurnResultPromptIds = + response['retainedTurnResultPromptIds']; + if ( + Array.isArray(retainedTurnResultPromptIds) && + retainedTurnResultPromptIds.every( + (promptId): promptId is string => typeof promptId === 'string', + ) + ) { + const retained = new Set(retainedTurnResultPromptIds); + for (const promptId of entry.terminalTurnStatuses.keys()) { + if (!retained.has(promptId)) { + entry.terminalTurnStatuses.delete(promptId); + } + } + } else { + entry.terminalTurnStatuses.clear(); + } const targetTurnIndex = (response['targetTurnIndex'] as number) ?? 0; const filesChanged = (response['filesChanged'] as string[]) ?? []; const filesFailed = (response['filesFailed'] as string[]) ?? []; diff --git a/packages/cli/src/acp-integration/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts index 72c7cff003d..71507f744fd 100644 --- a/packages/cli/src/acp-integration/acpAgent.test.ts +++ b/packages/cli/src/acp-integration/acpAgent.test.ts @@ -1888,6 +1888,9 @@ describe('QwenAgent MCP SSE/HTTP support', () => { emitGoalStatus: ReturnType; restoreHistory: ReturnType; rewindToTurn: ReturnType; + getRetainedTurnResultPromptIds: ReturnType; + isTurnResultPromptIdRetained: ReturnType; + registerExternalTurnResultPromptId: ReturnType; getRewindableUserTurnCount: ReturnType; clearActiveTodoPlanRevision: ReturnType; clearTodoStopGuardTrust: ReturnType; @@ -3621,6 +3624,11 @@ describe('QwenAgent MCP SSE/HTTP support', () => { rewindToTurn: vi .fn() .mockReturnValue({ targetTurnIndex: 1, apiTruncateIndex: 2 }), + getRetainedTurnResultPromptIds: vi + .fn() + .mockReturnValue(['daemon-prompt-a']), + isTurnResultPromptIdRetained: vi.fn().mockReturnValue(true), + registerExternalTurnResultPromptId: vi.fn(), getRewindableUserTurnCount: vi.fn().mockReturnValue(1), clearActiveTodoPlanRevision: vi.fn(), clearTodoStopGuardTrust: vi.fn(), @@ -9095,6 +9103,60 @@ describe('QwenAgent MCP SSE/HTTP support', () => { await agentPromise; }); + it('does not return a turn_result from an abandoned rewind branch', async () => { + const sessionId = '11111111-1111-1111-1111-111111111111'; + await setupSessionMocks(sessionId); + const abandoned = { + promptId: 'prompt-abandoned', + state: 'completed', + stopReason: 'end_turn', + endedAt: 2000, + resultText: 'abandoned answer', + }; + const readPage = vi.fn().mockResolvedValue({ + sessionId, + records: [ + { type: 'system', subtype: 'turn_result', systemPayload: abandoned }, + ], + hasMore: false, + gaps: [], + startTime: 'start', + lastUpdated: 'end', + }); + vi.mocked(SessionTranscriptReader).mockImplementation( + () => + ({ + readPage, + }) as unknown as InstanceType, + ); + + const agentPromise = runAcpAgent( + mockConfig, + makeSessionSettings(), + mockArgv, + ); + await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); + const agent = capturedAgentFactory!({ + get closed() { + return mockConnectionState.promise; + }, + }) as AgentLike; + + await agent.newSession({ cwd: '/tmp', mcpServers: [] }); + lastSessionMock?.isTurnResultPromptIdRetained.mockReturnValue(false); + const response = await agent.extMethod( + SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, + { + sessionId, + promptId: 'prompt-abandoned', + }, + ); + + mockConnectionState.resolve(); + await agentPromise; + expect(response).toEqual({ v: 1, sessionId, turnResult: null }); + }); + it('paginates bounded turn_result scans until the promptId matches', async () => { const sessionId = '11111111-1111-1111-1111-111111111111'; await setupSessionMocks(sessionId); @@ -13019,6 +13081,7 @@ describe('QwenAgent MCP SSE/HTTP support', () => { historyBeforeRewind: [{ role: 'user', parts: [{ text: 'before' }] }], targetTurnIndex: 1, apiTruncateIndex: 2, + retainedTurnResultPromptIds: ['daemon-prompt-a'], filesChanged: [], filesFailed: [], artifactSnapshot, @@ -17090,6 +17153,9 @@ describe('QwenAgent loadSession / unstable_resumeSession', () => { // the SSE stream stays clean for clients that already have the // history rendered. expect(lastSessionMock?.replayHistory).not.toHaveBeenCalled(); + expect(lastSessionMock?.primeTurnFromHistory).toHaveBeenCalledWith( + messages, + ); const recording = lastSessionMock?.getConfig().getChatRecordingService(); expect(recording?.rebuildTurnBoundaries).toHaveBeenCalledWith(messages); expect( diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index 63dc9357f41..020f29c3cc1 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -400,6 +400,7 @@ async function findSettledTurnResult( sessionId: string, promptId: string | undefined, workspaceCwd: string, + isRetained: (promptId: string) => boolean, ): Promise { let cursor: string | undefined; for (let page = 0; page < TURN_STATUS_SCAN_MAX_PAGES; page++) { @@ -419,7 +420,10 @@ async function findSettledTurnResult( } const payload = record.systemPayload; if (!isTurnResultRecordPayload(payload)) continue; - if (promptId === undefined || payload.promptId === promptId) { + if ( + isRetained(payload.promptId) && + (promptId === undefined || payload.promptId === promptId) + ) { return payload; } } @@ -5062,7 +5066,6 @@ class QwenAgent implements Agent { const records = sessionData?.conversation.messages; let replayUpdates: SessionUpdate[] = []; if (records) { - createdSession.primeTurnFromHistory(records); const visibleRecords = selectVisibleHistoryRecords( records, shouldHideInheritedHistory(params), @@ -10622,6 +10625,7 @@ class QwenAgent implements Agent { ); } await recorder.recordTurnResultStrict(turnResult); + session.registerExternalTurnResultPromptId(turnResult.promptId); return { v: 1, sessionId }; } case SERVE_CONTROL_EXT_METHODS.sessionTurnStatus: { @@ -10666,6 +10670,7 @@ class QwenAgent implements Agent { sessionId, typeof rawPromptId === 'string' ? rawPromptId : undefined, cwd, + (promptId) => session.isTurnResultPromptIdRetained(promptId), ); return { v: 1, @@ -11119,6 +11124,7 @@ class QwenAgent implements Agent { success: true, historyBeforeRewind, ...rewindResult, + retainedTurnResultPromptIds: session.getRetainedTurnResultPromptIds(), filesChanged, filesFailed, ...(artifactSnapshot ? { artifactSnapshot } : {}), @@ -12325,6 +12331,9 @@ class QwenAgent implements Agent { config .getChatRecordingService() ?.rebuildTurnBoundaries(sessionData.conversation.messages); + if (options.replayHistory === false) { + session.primeTurnFromHistory(sessionData.conversation.messages); + } } if ( diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index a2680d0d525..2fafff240b1 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -2584,6 +2584,79 @@ describe('Session', () => { }); describe('rewindToTurn', () => { + it('restores an admission result recorded before the first user turn', () => { + session.primeTurnFromHistory([ + { + uuid: 'turn-result-1', + parentUuid: null, + sessionId: 'test-session-id', + timestamp: new Date(0).toISOString(), + type: 'system', + subtype: 'turn_result', + cwd: '/tmp', + version: 'test', + systemPayload: { + promptId: 'admission-error-prompt', + state: 'error', + endedAt: 1, + error: { message: 'writer unavailable' }, + }, + }, + ]); + + expect(session.getRetainedTurnResultPromptIds()).toEqual([ + 'admission-error-prompt', + ]); + }); + + it('retains daemon prompt ids for user turns kept by rewind', async () => { + mockChat.sendMessageStream = vi + .fn() + .mockResolvedValue(createEmptyStream()); + const countSpy = vi + .spyOn(session, 'getRewindableUserTurnCount') + .mockReturnValueOnce(0) + .mockReturnValueOnce(1); + + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'first' }], + }, + { + version: 1, + sessionId: 'test-session-id', + promptId: 'daemon-prompt-a', + }, + ); + await session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'second' }], + }, + { + version: 1, + sessionId: 'test-session-id', + promptId: 'daemon-prompt-b', + }, + ); + countSpy.mockRestore(); + const history: Content[] = [ + { role: 'user', parts: [{ text: 'first' }] }, + { role: 'model', parts: [{ text: 'first reply' }] }, + { role: 'user', parts: [{ text: 'second' }] }, + { role: 'model', parts: [{ text: 'second reply' }] }, + ]; + vi.mocked(mockChat.getHistory).mockReturnValue(history); + vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history); + + session.rewindToTurn(1); + + expect(session.getRetainedTurnResultPromptIds()).toEqual([ + 'daemon-prompt-a', + ]); + }); + it('truncates model history before the requested user turn and records rewind', async () => { const history: Content[] = [ { role: 'user', parts: [{ text: 'first' }] }, diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index 941d810a488..3500aa9652e 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -175,6 +175,7 @@ import { approxBase64Bytes, TURN_RESULT_CODE_TEXT_TRUNCATED, TURN_RESULT_TEXT_MAX_CHARS, + isTurnResultRecordPayload, normalizeTurnResultError, runWithRuntimeContentGenerator, getInvocationContext, @@ -918,6 +919,7 @@ function extractTurnPromptText(content: ContentBlock[]): string { type InFlightTurnRecording = { promptId: string; + turnIndex?: number; originatorClientId?: string; startedAt?: number; promptText: string; @@ -1531,6 +1533,7 @@ export class Session implements SessionContext { * the transcript at turn end; `null` when no pollable turn is streaming. */ #turnRecording: InFlightTurnRecording | null = null; + readonly #turnResultTurnIndexes = new Map(); /** * Tracks the completion of the current prompt so that the next prompt * can await it. This prevents a new prompt from reading chat history @@ -2749,7 +2752,22 @@ export class Session implements SessionContext { * Delegates to HistoryReplayer for consistent event emission. */ primeTurnFromHistory(records: ChatRecord[]): void { + this.#turnResultTurnIndexes.clear(); + let turnIndex = -1; for (const record of records) { + if (isUserPromptRecord(record)) { + turnIndex += 1; + } + if ( + record.type === 'system' && + record.subtype === 'turn_result' && + isTurnResultRecordPayload(record.systemPayload) + ) { + this.#turnResultTurnIndexes.set( + record.systemPayload.promptId, + Math.max(0, turnIndex), + ); + } if (record.subtype !== 'notification') continue; const backgroundTask = ( record.systemPayload as @@ -2850,9 +2868,30 @@ export class Session implements SessionContext { void this.#drainNotificationQueue(); } + for (const [promptId, turnIndex] of this.#turnResultTurnIndexes) { + if (turnIndex >= targetTurnIndex) { + this.#turnResultTurnIndexes.delete(promptId); + } + } + return { targetTurnIndex, apiTruncateIndex }; } + getRetainedTurnResultPromptIds(): string[] { + return [...this.#turnResultTurnIndexes.keys()]; + } + + isTurnResultPromptIdRetained(promptId: string): boolean { + return this.#turnResultTurnIndexes.has(promptId); + } + + registerExternalTurnResultPromptId(promptId: string): void { + this.#turnResultTurnIndexes.set( + promptId, + Math.max(0, this.getRewindableUserTurnCount() - 1), + ); + } + captureHistorySnapshot(): Content[] { return this.config.getGeminiClient()!.getChat().getHistoryShallow(); } @@ -3205,6 +3244,7 @@ export class Session implements SessionContext { channelDeliveryCapture, invocationContext, modelPrompt, + turnRecording, ); const terminalError = getTerminalPromptAbortError(pendingSend.signal); settlement = @@ -3472,6 +3512,7 @@ export class Session implements SessionContext { channelDeliveryCapture?: ChannelDeliveryCapture, invocationContext?: InvocationContextV1, modelPrompt?: string, + turnRecording?: InFlightTurnRecording | null, ): Promise { const sessionId = this.config.getSessionId(); if ( @@ -3494,6 +3535,7 @@ export class Session implements SessionContext { pendingSend, channelDeliveryCapture, modelPrompt, + turnRecording, ), ), ); @@ -3504,6 +3546,7 @@ export class Session implements SessionContext { pendingSend: AbortController, channelDeliveryCapture?: ChannelDeliveryCapture, modelPrompt?: string, + turnRecording?: InFlightTurnRecording | null, ): Promise { return Storage.runWithRuntimeBaseDir( this.runtimeBaseDir, @@ -3594,6 +3637,14 @@ export class Session implements SessionContext { // — so hold it (and a push-count snapshot) to restore on that path. let strippedOrphanEntries: Content[] | null = null; let orphanPushCountSnapshot = 0; + if (turnRecording) { + const rewindableTurnCount = this.getRewindableUserTurnCount(); + turnRecording.turnIndex = + isContinue || isRetry + ? Math.max(0, rewindableTurnCount - 1) + : rewindableTurnCount; + } + if (isContinue) { const recoveryPlan = buildSessionRecoveryPlanFromApiHistory({ sessionId: this.sessionId, @@ -5397,6 +5448,10 @@ export class Session implements SessionContext { if (recording === null) { return; } + this.#turnResultTurnIndexes.set( + recording.promptId, + recording.turnIndex ?? this.getRewindableUserTurnCount(), + ); const selectedSegments = [...recording.resultSegments.values()].map( (segment) => ({ text: segment.rewrittenText ?? segment.rawText, diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts index e8430d86ff7..eeff6789ba4 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.test.ts @@ -520,6 +520,69 @@ describe('MessageRewriteMiddleware', () => { turnIndex: 1, }); }); + + it('isolates a discrete diagnostic from buffered model output', async () => { + const { middleware, mockSendUpdate } = createMiddleware('message'); + const { LlmRewriter } = await import('./LlmRewriter.js'); + const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { + rewrite: ReturnType; + }; + rewriter.rewrite + .mockResolvedValueOnce('rewritten answer') + .mockResolvedValueOnce('rewritten diagnostic'); + + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'genuine model answer' }, + } as unknown as SessionUpdate); + await middleware.interceptUpdate({ + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'diagnostic notice' }, + _meta: { source: 'diagnostic', qwenDiscreteMessage: true }, + } as unknown as SessionUpdate); + await middleware.flushTurn(); + await middleware.waitForPendingRewrites(); + + expect(rewriter.rewrite).toHaveBeenNthCalledWith( + 1, + { + thoughts: [], + messages: ['genuine model answer'], + hasToolCalls: false, + }, + expect.any(AbortSignal), + ); + expect(rewriter.rewrite).toHaveBeenNthCalledWith( + 2, + { + thoughts: [], + messages: ['diagnostic notice'], + hasToolCalls: false, + }, + expect.any(AbortSignal), + ); + const rewrittenUpdates = mockSendUpdate.mock.calls + .map(([update]) => update as Record) + .filter( + (update) => + (update['_meta'] as Record | undefined)?.[ + 'rewritten' + ] === true, + ); + expect(rewrittenUpdates).toEqual([ + expect.objectContaining({ + _meta: { rewritten: true, turnIndex: 1 }, + }), + expect.objectContaining({ + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + rewritten: true, + turnIndex: 2, + }, + }), + ]); + }); }); describe('timeoutMs config', () => { diff --git a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts index a8635b57414..b30325e6171 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts @@ -100,6 +100,14 @@ export class MessageRewriteMiddleware { | undefined; const text = content?.['text'] ?? ''; const ownerPromptId = this.getOwnerPromptId(); + const meta = updateRecord['_meta'] as Record | undefined; + + if ( + updateType === 'agent_message_chunk' && + meta?.['qwenDiscreteMessage'] === true + ) { + await this.flushTurn(signal); + } // Always send original message as-is await this.sendUpdate(update, { @@ -113,9 +121,7 @@ export class MessageRewriteMiddleware { if ( updateType === 'agent_message_chunk' && - (updateRecord['_meta'] as Record | undefined)?.[ - 'source' - ] === 'slash_command' + meta?.['source'] === 'slash_command' ) { return; } From 497a1d260ad94865fb4a1562960d5cf3f94ad02d Mon Sep 17 00:00:00 2001 From: hit_aran Date: Tue, 11 Aug 2026 17:17:17 +0800 Subject: [PATCH 18/25] docs(serve): align turn status contract --- docs/design/daemon-turn-status-endpoint.md | 25 +++++++++++++++------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/docs/design/daemon-turn-status-endpoint.md b/docs/design/daemon-turn-status-endpoint.md index db76fc5ee2f..6f645ea6fd4 100644 --- a/docs/design/daemon-turn-status-endpoint.md +++ b/docs/design/daemon-turn-status-endpoint.md @@ -49,6 +49,13 @@ particular `promptTextTruncated` / `resultTruncated` are only present when also carries `resultCode: "RESULT_TEXT_TRUNCATED"` so consumers can reject an incomplete answer without interpreting free text. +`originatorClientId`, when present, identifies the trusted client that admitted +the prompt. An `error` payload may accompany `state: 'error'` and contains a +required `message` plus an optional `code`; `prompt_deadline_exceeded` identifies +the bridge deadline terminal. Error messages are capped at 4,096 UTF-16 code +units and codes at 256, with `messageTruncated` / `codeTruncated` set only when +the corresponding value was truncated. + - `queued` / `running` mirror the bridge's live `pendingPromptList` (`queuedAt` at admission, `startedAt` at FIFO dispatch). - `completed` / `cancelled` / `error` come from the bridge's exactly-once @@ -91,11 +98,13 @@ Settled outcomes survive daemon restarts by appending one `recordFileHistorySnapshot`: a recording failure must never break turn settlement. - `Session` accumulates the turn in flight (`#turnRecording`): the record - is created at admission after `assertCanStartTurn()` for prompts carrying - an invocation context (daemon-admitted prompts only — internal - cron/notification turns are not pollable), accumulates canonical visible - answer segments in `sendUpdate`, and settles on every exit path (early - admission-cancel, pendingSend-cancel, normal completion, thrown error). + is created after invocation-context validation but before admission checks, + including `assertCanStartTurn()`, for prompts carrying an invocation context + (daemon-admitted prompts only — internal cron/notification turns are not + pollable). This keeps admission failures queryable by promptId. The record + accumulates canonical visible answer segments in `sendUpdate` and settles on + every exit path (early admission-cancel, pendingSend-cancel, normal + completion, thrown error). Each `prompt()` call captures its own record reference and settles that exact reference; the shared slot is only published once the predecessor turn has settled and the turn's model loop starts. This keeps DAEMON-003 @@ -120,9 +129,9 @@ they are not converted into a successful `turnResult: null` response. Transcript persistence is asynchronous relative to the bridge's formal terminal event. To prevent a completed prompt from briefly regressing to `prompt_not_found`, each live `SessionEntry` retains recent formal terminal -statuses in insertion order. The map is capped by the configured -`eventRingSize`; eviction only removes the transient overlay, so persisted -records remain queryable. +statuses in insertion order. The map has a fixed limit of 64 entries, +independently of `eventRingSize`; eviction only removes the transient overlay, +so persisted records remain queryable. ## Bridge resolution order From 225d93c05c1d1083c4fafd9ee839f989e7acdbc9 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Wed, 12 Aug 2026 14:07:00 +0800 Subject: [PATCH 19/25] fix(serve): harden turn result lifecycle --- .../plans/daemon-turn-status-blocker-fixes.md | 25 +- packages/acp-bridge/src/bridge.test.ts | 358 +++++++++++++++++- packages/acp-bridge/src/bridge.ts | 155 ++++++-- packages/channels/base/src/AcpBridge.test.ts | 31 ++ packages/channels/base/src/AcpBridge.ts | 6 + .../base/src/DaemonChannelBridge.test.ts | 42 ++ .../channels/base/src/DaemonChannelBridge.ts | 2 + .../acp-integration/session/Session.test.ts | 170 +++++++++ .../src/acp-integration/session/Session.ts | 31 +- 9 files changed, 772 insertions(+), 48 deletions(-) diff --git a/docs/plans/daemon-turn-status-blocker-fixes.md b/docs/plans/daemon-turn-status-blocker-fixes.md index 6a0f6e0bc21..004a392adf8 100644 --- a/docs/plans/daemon-turn-status-blocker-fixes.md +++ b/docs/plans/daemon-turn-status-blocker-fixes.md @@ -10,7 +10,7 @@ ## Global Constraints -- Work from exact PR head `3493ae055c0a4440c51a9013d3f47493381475bd`. +- Round 7 verification starts from exact PR head `e733b25d1bd386620a2c22862da5c4fb3a0319cf`. - “Within the system limit” means the current active transcript chain scanned backward for at most 10 pages × 500 records, with 4 MiB per page. - Preserve `GET /session/:id/turns/:promptId` and `/turns/current`, client-id authorization, and the 32,768-character prompt/result cap. - Agent-side model settlement keeps the existing best-effort recording behavior; bridge-owned pre-dispatch outcomes are acknowledged only after their strict transcript write succeeds. @@ -150,3 +150,26 @@ - [ ] Ask the read-only test-engineer agent to audit every Critical as either public-daemon E2E or a deterministic component-level fault-injection regression. - [ ] Perform two consecutive clean full-diff self-audit passes; any edit resets the count. - [ ] Re-fetch PR head/state, confirm the reviewed base has not moved, then commit and push without force. + +### Task 8: Close Round 7 critical durability and compatibility gaps + +**Files:** + +- Modify: `packages/acp-bridge/src/bridge.ts` +- Modify: `packages/cli/src/acp-integration/session/Session.ts` +- Modify: `packages/channels/base/src/AcpBridge.ts` +- Modify: `packages/channels/base/src/DaemonChannelBridge.ts` +- Test: corresponding collocated test files. + +**Interfaces:** + +- Consumes: bridge prompt admission/forwarding, child session teardown, transcript replay, rewind turn indexes, and ACP diagnostic updates. +- Produces: durable bridge-owned terminals while the child writer remains available, consistent rewind identities, and Channel-visible diagnostics that remain excluded from `resultText`. + +- [x] Add a failing forward-rejection test proving a dispatched request rejected before child admission is strictly persisted. +- [x] Add failing close/kill tests proving queued prompts are durably cancelled before child teardown; a refused close leaves the session live but truthfully keeps the close-request cancellations. +- [x] Add failing replay/rewind tests where mid-turn and structural user records do not advance the turn-result index. +- [x] Add failing early continue/retry tests proving settlement uses the current turn index rather than the next index. +- [x] Add failing ACP and daemon Channel tests proving diagnostic messages remain visible while discrete background messages remain excluded. +- [x] Implement the minimum production changes needed to make each regression pass, one red-green cycle at a time. +- [x] Run the complete owning test files, build, typecheck, targeted real-daemon E2E, and two clean diff-audit passes. diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 1f4b8a533d1..fbc9d058966 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -9321,7 +9321,10 @@ describe('createAcpSessionBridge', () => { prompt: [{ type: 'text', text: 'will fail to forward' }], }, undefined, - { clientId: session.clientId }, + { + clientId: session.clientId, + promptId: 'prompt-forward-failed', + }, ) .catch(() => { // forward rejection surfaces to the caller too. @@ -9330,6 +9333,16 @@ describe('createAcpSessionBridge', () => { const evt = await peerCancel; expect(evt.type).toBe('prompt_cancelled'); expect((evt.data as { reason?: string }).reason).toBe('forward_failed'); + expect(h.agent.extMethodCalls).toContainEqual({ + method: SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + params: { + sessionId: session.sessionId, + turnResult: expect.objectContaining({ + promptId: 'prompt-forward-failed', + state: 'error', + }), + }, + }); // A rejected prompt request has already settled in the child. Sending a // late session-scoped cancel here could hit the queued successor. expect(cancelSpy).not.toHaveBeenCalled(); @@ -11495,10 +11508,15 @@ describe('createAcpSessionBridge', () => { } return { stopReason: 'end_turn' } as PromptResponse; }, - extMethodImpl: (method) => - method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus - ? { v: 1, sessionId: 'ignored', turnResult: null } - : {}, + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + return { v: 1, sessionId: 'ignored', turnResult: null }; + } + if (method === SERVE_CONTROL_EXT_METHODS.sessionClose) { + return { closed: true }; + } + return {}; + }, }); const subscribe = ( @@ -11889,7 +11907,7 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); - it('flushes error terminals for active and queued prompts before session_closed (DAEMON-005)', async () => { + it('persists queued cancellation before closing the child session (DAEMON-005)', async () => { const handle = wedgeChannel(); const bridge = makeBridge({ channelFactory: async () => handle.channel }); const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); @@ -11920,15 +11938,34 @@ describe('createAcpSessionBridge', () => { await bridge.closeSession(session.sessionId); + const queuedPersistenceIdx = handle.agent.extMethodCalls.findIndex( + ({ method, params }) => + method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord && + (params['turnResult'] as { promptId?: string } | undefined) + ?.promptId === 'prompt-b', + ); + const childCloseIdx = handle.agent.extMethodCalls.findIndex( + ({ method }) => method === SERVE_CONTROL_EXT_METHODS.sessionClose, + ); + expect(queuedPersistenceIdx).toBeGreaterThanOrEqual(0); + expect(queuedPersistenceIdx).toBeLessThan(childCloseIdx); + const closedIdx = events.findIndex((e) => e.type === 'session_closed'); expect(closedIdx).toBeGreaterThan(-1); for (const promptId of ['prompt-a', 'prompt-b']) { const terms = terminalsFor(events, promptId); expect(terms).toHaveLength(1); - expect(terms[0]?.type).toBe('turn_error'); - expect((terms[0]?.data as { code?: string }).code).toBe( - 'session_closed', - ); + if (promptId === 'prompt-a') { + expect(terms[0]?.type).toBe('turn_error'); + expect((terms[0]?.data as { code?: string }).code).toBe( + 'session_closed', + ); + } else { + expect(terms[0]?.type).toBe('turn_complete'); + expect((terms[0]?.data as { stopReason?: string }).stopReason).toBe( + 'cancelled', + ); + } // The terminal precedes the session_closed frame — subscribers keyed // on promptId observe the turn ending before the session vanishes. expect(events.indexOf(terms[0]!)).toBeLessThan(closedIdx); @@ -11936,6 +11973,202 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + it('does not overwrite an already-terminal queued prompt during close', async () => { + const handle = wedgeChannel(); + const bridge = makeBridge({ channelFactory: async () => handle.channel }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const p1 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'wedge' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + p1.catch(() => {}); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued deadline' }], + }, + undefined, + { promptId: 'prompt-b', deadlineMs: 10 }, + ); + p2.catch(() => {}); + + await vi.waitFor(async () => { + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-b'), + ).resolves.toMatchObject({ + state: 'error', + error: { code: 'prompt_deadline_exceeded' }, + }); + }); + await bridge.closeSession(session.sessionId); + + expect( + handle.agent.extMethodCalls + .filter( + ({ method, params }) => + method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord && + (params['turnResult'] as { promptId?: string } | undefined) + ?.promptId === 'prompt-b', + ) + .map(({ params }) => params['turnResult']), + ).toEqual([ + expect.objectContaining({ + promptId: 'prompt-b', + state: 'error', + error: expect.objectContaining({ + code: 'prompt_deadline_exceeded', + }), + }), + ]); + await bridge.shutdown(); + }); + + it.each(['close', 'kill'] as const)( + 'keeps the session live and retries queued persistence before %s', + async (operation) => { + let persistAvailable = false; + const activePrompt = deferred(); + const handle = makeChannel({ + promptImpl: () => activePrompt.promise, + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + if (!persistAvailable) throw new Error('writer unavailable'); + return {}; + } + return method === SERVE_CONTROL_EXT_METHODS.sessionClose + ? { closed: true } + : {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const p1 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'active' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + await vi.waitFor(() => + expect(handle.agent.promptCalls).toHaveLength(1), + ); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-b' }, + ); + p2.catch(() => {}); + + const teardown = + operation === 'close' + ? bridge.closeSession(session.sessionId) + : bridge.killSession(session.sessionId); + await expect(teardown).rejects.toThrow(); + + expect(bridge.sessionCount).toBe(1); + expect(handle.killed).toBe(false); + expect( + handle.agent.extMethodCalls.filter( + ({ method }) => method === SERVE_CONTROL_EXT_METHODS.sessionClose, + ), + ).toHaveLength(0); + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-b'), + ).resolves.toMatchObject({ + state: 'cancelled', + stopReason: 'cancelled', + }); + + activePrompt.resolve({ stopReason: 'end_turn' }); + await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); + await expect(p2).rejects.toMatchObject({ name: 'AbortError' }); + persistAvailable = true; + await expect( + operation === 'close' + ? bridge.closeSession(session.sessionId) + : bridge.killSession(session.sessionId), + ).resolves.toBe(operation === 'close' ? undefined : true); + expect( + handle.agent.extMethodCalls.filter( + ({ method }) => + method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + ), + ).toHaveLength(2); + expect(bridge.sessionCount).toBe(0); + await bridge.shutdown(); + }, + ); + + it('does not kill the channel when queued persistence times out before close', async () => { + const activePrompt = deferred(); + const handle = makeChannel({ + promptImpl: () => activePrompt.promise, + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + return new Promise>(() => {}); + } + return method === SERVE_CONTROL_EXT_METHODS.sessionClose + ? { closed: true } + : {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + initializeTimeoutMs: 20, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const p1 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'active' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(1)); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-b' }, + ); + p2.catch(() => {}); + + await expect(bridge.closeSession(session.sessionId)).rejects.toThrow( + /timed out/, + ); + expect(handle.killed).toBe(false); + expect(bridge.sessionCount).toBe(1); + expect( + handle.agent.extMethodCalls.filter( + ({ method }) => method === SERVE_CONTROL_EXT_METHODS.sessionClose, + ), + ).toHaveLength(0); + + activePrompt.resolve({ stopReason: 'end_turn' }); + await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); + await expect(p2).rejects.toMatchObject({ name: 'AbortError' }); + await bridge.shutdown(); + }); + it('keeps a removed RUNNING prompt cancelled when the session closes before the agent cooperates', async () => { const handle = wedgeChannel(); const bridge = makeBridge({ channelFactory: async () => handle.channel }); @@ -12080,7 +12313,7 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); - it('flushes error terminals for active and queued prompts before session_died on killSession (DAEMON-005)', async () => { + it('persists queued cancellation before killing the child session (DAEMON-005)', async () => { const handle = wedgeChannel(); const bridge = makeBridge({ channelFactory: async () => handle.channel }); const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); @@ -12111,15 +12344,34 @@ describe('createAcpSessionBridge', () => { await expect(bridge.killSession(session.sessionId)).resolves.toBe(true); + const queuedPersistenceIdx = handle.agent.extMethodCalls.findIndex( + ({ method, params }) => + method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord && + (params['turnResult'] as { promptId?: string } | undefined) + ?.promptId === 'prompt-b', + ); + const childCloseIdx = handle.agent.extMethodCalls.findIndex( + ({ method }) => method === SERVE_CONTROL_EXT_METHODS.sessionClose, + ); + expect(queuedPersistenceIdx).toBeGreaterThanOrEqual(0); + expect(queuedPersistenceIdx).toBeLessThan(childCloseIdx); + const diedIdx = events.findIndex((e) => e.type === 'session_died'); expect(diedIdx).toBeGreaterThan(-1); for (const promptId of ['prompt-a', 'prompt-b']) { const terms = terminalsFor(events, promptId); expect(terms).toHaveLength(1); - expect(terms[0]?.type).toBe('turn_error'); - expect((terms[0]?.data as { code?: string }).code).toBe( - 'session_killed', - ); + if (promptId === 'prompt-a') { + expect(terms[0]?.type).toBe('turn_error'); + expect((terms[0]?.data as { code?: string }).code).toBe( + 'session_killed', + ); + } else { + expect(terms[0]?.type).toBe('turn_complete'); + expect((terms[0]?.data as { stopReason?: string }).stopReason).toBe( + 'cancelled', + ); + } // The terminal precedes the session_died frame — a reorder that // flushes after events.close() would drop it into a closed bus. expect(events.indexOf(terms[0]!)).toBeLessThan(diedIdx); @@ -14817,7 +15069,9 @@ describe('createAcpSessionBridge', () => { if (method === SERVE_CONTROL_EXT_METHODS.sessionSource) { return { persisted: true }; } - return {}; + return method === 'qwen/control/session/close' + ? { closed: true } + : {}; }, resumeSessionImpl: () => ({}), }); @@ -19415,19 +19669,49 @@ describe('createAcpSessionBridge', () => { it('preserves bridge state when required agent close fails so retry can flush', async () => { let failClose = true; + const activePrompt = deferred(); const handle = makeChannel({ + promptImpl: () => activePrompt.promise, extMethodImpl: (method) => { if (method === 'qwen/control/session/close' && failClose) { failClose = false; throw new Error('flush failed'); } - return {}; + return method === 'qwen/control/session/close' + ? { closed: true } + : {}; }, }); const bridge = makeBridge({ channelFactory: async () => handle.channel, }); const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const events: BridgeEvent[] = []; + const drain = (async () => { + for await (const event of bridge.subscribeEvents(session.sessionId)) { + events.push(event); + } + })(); + const p1 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'active' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(1)); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-b' }, + ); + p2.catch(() => {}); await expect( bridge.closeSession(session.sessionId, undefined, { @@ -19435,8 +19719,11 @@ describe('createAcpSessionBridge', () => { }), ).rejects.toThrow(); - expect(handle.agent.extMethodCalls).toHaveLength(1); - expect(handle.agent.extMethodCalls[0]).toEqual({ + const closeCalls = handle.agent.extMethodCalls.filter( + ({ method }) => method === 'qwen/control/session/close', + ); + expect(closeCalls).toHaveLength(1); + expect(closeCalls[0]).toEqual({ method: 'qwen/control/session/close', params: { sessionId: session.sessionId, @@ -19450,12 +19737,43 @@ describe('createAcpSessionBridge', () => { clientId: session.clientId, }), ).not.toThrow(); + expect( + bridge + .getPendingPrompts(session.sessionId) + .some(({ promptId }) => promptId === 'prompt-b'), + ).toBe(false); + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-b'), + ).resolves.toMatchObject({ + promptId: 'prompt-b', + state: 'cancelled', + stopReason: 'cancelled', + }); + + activePrompt.resolve({ stopReason: 'end_turn' }); + await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); + await expect(p2).rejects.toMatchObject({ name: 'AbortError' }); + expect(handle.agent.promptCalls).toHaveLength(1); await bridge.closeSession(session.sessionId, undefined, { requireAgentClose: true, }); + await drain; - expect(handle.agent.extMethodCalls).toHaveLength(2); + expect( + handle.agent.extMethodCalls.filter( + ({ method }) => method === 'qwen/control/session/close', + ), + ).toHaveLength(2); + expect( + events + .filter( + (event) => + event.type === 'pending_prompt_completed' && + event.promptId === 'prompt-b', + ) + .map((event) => (event.data as { state?: string }).state), + ).toEqual(['removed']); expect(() => bridge.recordHeartbeat(session.sessionId, { clientId: session.clientId, diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 0013ac919bd..79ebfd11b99 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -1373,6 +1373,17 @@ function terminalStatusRecord( }; } +interface StrictTerminalPersistence { + promise: Promise; + state: 'pending' | 'succeeded' | 'failed'; + turnResult: TurnResultRecordPayload; +} + +const strictTerminalPersistences = new WeakMap< + SessionEntry, + Map +>(); + /** Reuse one channel-exit rejection instead of adding a listener per call. */ function getTransportClosedReject(entry: SessionEntry): Promise { if (!entry.transportClosedReject) { @@ -1398,6 +1409,7 @@ function publishPromptTerminal( entry: SessionEntry, pendingEntry: PendingPromptEntry, terminal: PromptTerminal, + options?: { persistIfDispatched?: boolean }, ): void { if (pendingEntry.terminalPublished) { // Dedup here is the designed steady state, not an anomaly: deadline @@ -1412,29 +1424,14 @@ function publishPromptTerminal( pendingEntry.terminalPublished = true; const status = rememberTerminalTurnStatus(entry, pendingEntry, terminal); if ( - !pendingEntry.dispatched && + (!pendingEntry.dispatched || options?.persistIfDispatched === true) && pendingEntry.terminalPersistence === undefined ) { - pendingEntry.terminalPersistence = Promise.race([ - withTimeout( - entry.connection.extMethod( - SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, - { - sessionId: entry.sessionId, - turnResult: terminalStatusRecord(status), - }, - ), - entry.terminalPersistenceTimeoutMs, - SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, - ), - getTransportClosedReject(entry), - ]).then( - () => undefined, - (error: unknown) => { - writeStderrLine( - `[turn-result] session=${entry.sessionId} promptId=${pendingEntry.promptId} action=persist_failed error=${extractErrorMessage(error)}`, - ); - }, + startStrictTerminalPersistence( + entry, + pendingEntry.promptId, + terminalStatusRecord(status), + pendingEntry, ); } const originatorClientId = pendingEntry.originatorClientId; @@ -1472,6 +1469,58 @@ function publishPromptTerminal( } } +function startStrictTerminalPersistence( + entry: SessionEntry, + promptId: string, + turnResult: TurnResultRecordPayload, + pendingEntry?: PendingPromptEntry, +): StrictTerminalPersistence { + const attempt: StrictTerminalPersistence = { + state: 'pending', + promise: Promise.resolve(), + turnResult, + }; + let attempts = strictTerminalPersistences.get(entry); + if (!attempts) { + attempts = new Map(); + strictTerminalPersistences.set(entry, attempts); + } + attempts.set(promptId, attempt); + attempt.promise = Promise.race([ + withTimeout( + entry.connection.extMethod( + SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + { + sessionId: entry.sessionId, + turnResult, + }, + ), + entry.terminalPersistenceTimeoutMs, + SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + ), + getTransportClosedReject(entry), + ]).then( + () => { + attempt.state = 'succeeded'; + if (attempts.get(promptId) === attempt) attempts.delete(promptId); + }, + (error: unknown) => { + attempt.state = 'failed'; + throw error; + }, + ); + const observed = attempt.promise.then( + () => undefined, + (error: unknown) => { + writeStderrLine( + `[turn-result] session=${entry.sessionId} promptId=${promptId} action=persist_failed error=${extractErrorMessage(error)}`, + ); + }, + ); + if (pendingEntry) pendingEntry.terminalPersistence = observed; + return attempt; +} + /** * Publish an error terminal for every prompt still pending on a session * that is being torn down (close/kill/channel crash/daemon shutdown), then @@ -1504,6 +1553,51 @@ function flushPromptTerminals( } } +async function cancelQueuedPromptsBeforeTeardown( + entry: SessionEntry, +): Promise { + const queued = entry.pendingPromptList.filter( + (pending) => !pending.dispatched && !pending.terminalPublished, + ); + for (const pending of queued) { + pending.removed = true; + try { + pending.abortController.abort( + new DOMException('Prompt cancelled by session teardown', 'AbortError'), + ); + } catch { + /* listeners must not break teardown */ + } + try { + entry.events.publish({ + type: 'pending_prompt_completed', + promptId: pending.promptId, + data: { + sessionId: entry.sessionId, + promptId: pending.promptId, + state: 'removed', + }, + ...(pending.originatorClientId + ? { originatorClientId: pending.originatorClientId } + : {}), + }); + } catch { + /* bus may be closed during teardown */ + } + publishPromptTerminal(entry, pending, { kind: 'cancelled' }); + } + const attempts = strictTerminalPersistences.get(entry); + if (!attempts) return; + await Promise.all( + [...attempts.entries()].map(([promptId, current]) => + current.state === 'pending' + ? current.promise + : startStrictTerminalPersistence(entry, promptId, current.turnResult) + .promise, + ), + ); +} + function hasControlCharacter(value: string): boolean { for (let i = 0; i < value.length; i += 1) { const code = value.charCodeAt(i); @@ -6176,6 +6270,12 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { permissionMediator.forgetSession(sessionId); entry.pendingPermissionIds.clear(); entry.pendingInteractions.clear(); + await cancelQueuedPromptsBeforeTeardown(entry); + } catch (error) { + entry.closing = false; + throw error; + } + try { agentSessionClosed = await notifyAgentSessionClose( entry, ci, @@ -7329,7 +7429,12 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { publishPromptTerminal(entry, pendingEntry, { kind: 'cancelled' }); return; } - publishPromptTerminal(entry, pendingEntry, { kind: 'error', err }); + publishPromptTerminal( + entry, + pendingEntry, + { kind: 'error', err }, + { persistIfDispatched: true }, + ); }, ); // Tail swallows failures so subsequent prompts still run. The caller @@ -10385,6 +10490,12 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { permissionMediator.forgetSession(sessionId); entry.pendingPermissionIds.clear(); entry.pendingInteractions.clear(); + try { + await cancelQueuedPromptsBeforeTeardown(entry); + } catch (error) { + entry.closing = false; + throw error; + } try { await notifyAgentSessionClose(entry, ci, 'killSession', { throwOnFailure: true, diff --git a/packages/channels/base/src/AcpBridge.test.ts b/packages/channels/base/src/AcpBridge.test.ts index 94ea4475e2d..558adecbfb0 100644 --- a/packages/channels/base/src/AcpBridge.test.ts +++ b/packages/channels/base/src/AcpBridge.test.ts @@ -513,6 +513,37 @@ describe('AcpBridge', () => { ); }); + it('returns a discrete diagnostic when no model answer is available', async () => { + const bridge = new AcpBridge({ + cliEntryPath: '/tmp/qwen', + cwd: '/tmp', + }) as unknown as TestableAcpBridge; + bridge.child = { killed: false, exitCode: null }; + bridge.connection = { + extMethod: vi.fn(), + prompt: vi.fn(async () => { + bridge.handleSessionUpdate({ + sessionId: 's-1', + update: { + sessionUpdate: 'agent_message_chunk', + content: { + type: 'text', + text: 'Session token limit exceeded.', + }, + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, + }, + }); + }), + }; + + await expect(bridge.prompt('s-1', 'question')).resolves.toBe( + 'Session token limit exceeded.', + ); + }); + it('emits a completed background response separately from the active turn', () => { const bridge = new AcpBridge({ cliEntryPath: '/tmp/qwen', diff --git a/packages/channels/base/src/AcpBridge.ts b/packages/channels/base/src/AcpBridge.ts index 4abb896233a..7ac1b194b84 100644 --- a/packages/channels/base/src/AcpBridge.ts +++ b/packages/channels/base/src/AcpBridge.ts @@ -381,6 +381,12 @@ export class AcpBridge extends EventEmitter implements ChannelAgentBridge { content.text ) { this.emit('backgroundResponse', sessionId, content.text); + } else if ( + meta['source'] === 'diagnostic' && + content?.type === 'text' && + content.text + ) { + this.emit('textChunk', sessionId, content.text); } break; } diff --git a/packages/channels/base/src/DaemonChannelBridge.test.ts b/packages/channels/base/src/DaemonChannelBridge.test.ts index 8335baf17c5..b79cab1eb33 100644 --- a/packages/channels/base/src/DaemonChannelBridge.test.ts +++ b/packages/channels/base/src/DaemonChannelBridge.test.ts @@ -630,6 +630,48 @@ describe('DaemonChannelBridge', () => { bridge.stop(); }); + it('returns a discrete diagnostic when no model answer is available', async () => { + const events = new EventQueue(); + const session = createFakeSession(events); + session.prompt.mockImplementation(async () => { + events.push({ + id: 1, + v: 1, + type: 'session_update', + data: { + sessionId: 'session-1', + update: { + sessionUpdate: 'agent_message_chunk', + content: { + type: 'text', + text: 'Session token limit exceeded.', + }, + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, + }, + }, + }); + events.push(turnCompleteEvent()); + return { stopReason: 'max_tokens' }; + }); + const bridge = new DaemonChannelBridge({ + cwd: '/repo', + sessionFactory: vi.fn().mockResolvedValue(session), + }); + + await bridge.start(); + await bridge.newSession('/repo'); + + await expect(bridge.prompt('session-1', 'summarize')).resolves.toBe( + 'Session token limit exceeded.', + ); + + events.close(); + bridge.stop(); + }); + it('emits the completed background response without appending it to the active turn', async () => { const events = new EventQueue(); const session = createFakeSession(events); diff --git a/packages/channels/base/src/DaemonChannelBridge.ts b/packages/channels/base/src/DaemonChannelBridge.ts index 806165fad99..870c6bf94ec 100644 --- a/packages/channels/base/src/DaemonChannelBridge.ts +++ b/packages/channels/base/src/DaemonChannelBridge.ts @@ -708,6 +708,8 @@ export class DaemonChannelBridge text ) { this.emit('backgroundResponse', sessionId, text); + } else if (meta['source'] === 'diagnostic' && text) { + this.emit('textChunk', sessionId, text); } break; } diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index e5b55fbcc4f..b5908460a66 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -2657,6 +2657,133 @@ describe('Session', () => { ]); }); + it('does not count a mid-turn user record as a rewindable turn', () => { + session.primeTurnFromHistory([ + chatRecord({ + uuid: 'user-a', + message: { role: 'user', parts: [{ text: 'first' }] }, + }), + chatRecord({ + uuid: 'tool-result-a', + parentUuid: 'user-a', + type: 'tool_result', + message: { + role: 'user', + parts: [ + { + functionResponse: { + id: 'call-a', + name: 'read_file', + response: { output: 'contents' }, + }, + }, + ], + }, + }), + chatRecord({ + uuid: 'mid-turn-a', + parentUuid: 'tool-result-a', + subtype: 'mid_turn_user_message', + message: { + role: 'user', + parts: [{ text: 'also check tests' }], + }, + }), + chatRecord({ + uuid: 'turn-result-a', + parentUuid: 'mid-turn-a', + type: 'system', + subtype: 'turn_result', + systemPayload: { + promptId: 'daemon-prompt-a', + state: 'completed', + stopReason: 'end_turn', + endedAt: 1, + }, + }), + chatRecord({ + uuid: 'user-b', + parentUuid: 'turn-result-a', + message: { role: 'user', parts: [{ text: 'second' }] }, + }), + ]); + const history: Content[] = [ + { role: 'user', parts: [{ text: 'first' }] }, + { role: 'model', parts: [{ functionCall: { name: 'read_file' } }] }, + { + role: 'user', + parts: [ + { + functionResponse: { + id: 'call-a', + name: 'read_file', + response: { output: 'contents' }, + }, + }, + { text: 'also check tests' }, + ], + }, + { role: 'model', parts: [{ text: 'first reply' }] }, + { role: 'user', parts: [{ text: 'second' }] }, + { role: 'model', parts: [{ text: 'second reply' }] }, + ]; + vi.mocked(mockChat.getHistory).mockReturnValue(history); + vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history); + + session.rewindToTurn(1); + + expect(session.getRetainedTurnResultPromptIds()).toContain( + 'daemon-prompt-a', + ); + }); + + it('does not count a pure system reminder as a rewindable turn', () => { + session.primeTurnFromHistory([ + chatRecord({ + uuid: 'user-a', + message: { role: 'user', parts: [{ text: 'first' }] }, + }), + chatRecord({ + uuid: 'reminder-a', + parentUuid: 'user-a', + message: { + role: 'user', + parts: [ + { + text: `${SYSTEM_REMINDER_OPEN}structural${SYSTEM_REMINDER_CLOSE}`, + }, + ], + }, + }), + chatRecord({ + uuid: 'turn-result-a', + parentUuid: 'reminder-a', + type: 'system', + subtype: 'turn_result', + systemPayload: { + promptId: 'daemon-prompt-a', + state: 'completed', + stopReason: 'end_turn', + endedAt: 1, + }, + }), + ]); + const history: Content[] = [ + { role: 'user', parts: [{ text: 'first' }] }, + { role: 'model', parts: [{ text: 'first reply' }] }, + { role: 'user', parts: [{ text: 'second' }] }, + { role: 'model', parts: [{ text: 'second reply' }] }, + ]; + vi.mocked(mockChat.getHistory).mockReturnValue(history); + vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history); + + session.rewindToTurn(1); + + expect(session.getRetainedTurnResultPromptIds()).toContain( + 'daemon-prompt-a', + ); + }); + it('truncates model history before the requested user turn and records rewind', async () => { const history: Content[] = [ { role: 'user', parts: [{ text: 'first' }] }, @@ -5165,6 +5292,49 @@ describe('Session', () => { ).toBeUndefined(); }); + it.each([ + ['continue', 'qwen.daemon.continueLastTurn'], + ['retry', 'qwen.daemon.retry'], + ])( + 'keeps an early %s failure attached to the current turn', + async (_label, metadataKey) => { + const countSpy = vi + .spyOn(session, 'getRewindableUserTurnCount') + .mockReturnValue(2); + mockConfig.assertCanStartTurn = vi + .fn() + .mockRejectedValue(new Error('admission failed')); + const promptId = `early-${_label}-failure`; + + await expect( + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: '' }], + _meta: { [metadataKey]: true }, + }, + { ...trustedContext, promptId }, + ), + ).rejects.toThrow('admission failed'); + countSpy.mockRestore(); + + const history: Content[] = [ + { role: 'user', parts: [{ text: 'first' }] }, + { role: 'model', parts: [{ text: 'first reply' }] }, + { role: 'user', parts: [{ text: 'second' }] }, + { role: 'model', parts: [{ text: 'second reply' }] }, + { role: 'user', parts: [{ text: 'third' }] }, + { role: 'model', parts: [{ text: 'third reply' }] }, + ]; + vi.mocked(mockChat.getHistory).mockReturnValue(history); + vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history); + + session.rewindToTurn(2); + + expect(session.getRetainedTurnResultPromptIds()).toContain(promptId); + }, + ); + it('records an error when awaited turn finalization fails', async () => { ( session as unknown as { diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index 3500aa9652e..03b758d2dd8 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -96,6 +96,7 @@ import { getPlanModeSystemReminder, getArenaSystemReminder, getStartupContextLength, + isReplayTurnStartType, isSystemReminderContent, buildSessionRecoveryPlanFromApiHistory, TURN_INTERRUPTION_HISTORY_TAIL_COUNT, @@ -1336,13 +1337,24 @@ function readTelemetryPromptId(payload: unknown): string | undefined { } function isUserPromptRecord(record: ChatRecord): boolean { - if (record.type !== 'user' || record.subtype === 'realtime_message') { + if ( + !isReplayTurnStartType(record.type, record.subtype) || + record.subtype === 'realtime_message' + ) { return false; } - return ( - record.message?.parts?.some( - (part) => typeof part.text === 'string' && part.text.trim().length > 0, - ) ?? false + const message = record.message; + if (!message?.parts || isSystemReminderContent(message)) return false; + if (message.parts.some((part) => 'functionResponse' in part)) return false; + if ( + message.parts.some( + (part) => 'text' in part && isTodoStopGuardPromptText(part.text), + ) + ) { + return false; + } + return message.parts.some( + (part) => typeof part.text === 'string' && part.text.trim().length > 0, ); } @@ -5331,6 +5343,10 @@ export class Session implements SessionContext { const { text, truncated } = truncateTurnText( extractTurnPromptText(params.prompt), ); + const metadata = params._meta as Record | undefined; + const continuesCurrentTurn = + metadata?.[DAEMON_RETRY_META_KEY] === true || + metadata?.[DAEMON_CONTINUE_META_KEY] === true; return { promptId: invocationContext.promptId, ...(invocationContext.originatorClientId !== undefined @@ -5338,6 +5354,11 @@ export class Session implements SessionContext { : {}), promptText: text, promptTextTruncated: truncated, + ...(continuesCurrentTurn + ? { + turnIndex: Math.max(0, this.getRewindableUserTurnCount() - 1), + } + : {}), resultSegments: new Map(), resultCapturedChars: 0, resultSegmentsTruncated: false, From 3778916030db0948ec1982923daf3953420cdb35 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Wed, 12 Aug 2026 21:53:37 +0800 Subject: [PATCH 20/25] fix(daemon): harden turn result teardown and rewind --- packages/acp-bridge/src/bridge.test.ts | 101 +++++++- packages/acp-bridge/src/bridge.ts | 35 +-- .../cli/src/acp-integration/acpAgent.test.ts | 63 ----- packages/cli/src/acp-integration/acpAgent.ts | 9 +- .../acp-integration/session/Session.test.ts | 243 ------------------ .../src/acp-integration/session/Session.ts | 64 ----- .../session-transcript-reader.test.ts | 48 ++++ 7 files changed, 151 insertions(+), 412 deletions(-) diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 869e0a72836..ac554b5e531 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -3887,24 +3887,35 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); - it('keeps terminal overlays retained by a successful transcript rewind', async () => { + it('uses the child active transcript after a successful rewind', async () => { + let rewound = false; const bridge = makeBridge({ channelFactory: async () => makeChannel({ promptImpl: () => ({ stopReason: 'end_turn' }), - extMethodImpl: (method) => { + extMethodImpl: (method, params) => { if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { - return { v: 1, sessionId: SESS_A, turnResult: null }; + const promptId = params['promptId'] as string | undefined; + return { + v: 1, + sessionId: SESS_A, + turnResult: + rewound && promptId !== 'prompt-before-rewind-c' + ? { + promptId, + state: 'completed', + stopReason: 'end_turn', + endedAt: 1, + } + : null, + }; } if (method === SERVE_CONTROL_EXT_METHODS.sessionRewind) { + rewound = true; return { targetTurnIndex: 2, filesChanged: [], filesFailed: [], - retainedTurnResultPromptIds: [ - 'prompt-before-rewind-a', - 'prompt-before-rewind-b', - ], }; } return {}; @@ -12588,7 +12599,7 @@ describe('createAcpSessionBridge', () => { }); it.each(['close', 'kill'] as const)( - 'keeps the session live and retries queued persistence before %s', + 'keeps the session live and retries newly cancelled persistence before %s', async (operation) => { let persistAvailable = false; const activePrompt = deferred(); @@ -12631,12 +12642,11 @@ describe('createAcpSessionBridge', () => { ); p2.catch(() => {}); - const teardown = + await expect( operation === 'close' ? bridge.closeSession(session.sessionId) - : bridge.killSession(session.sessionId); - await expect(teardown).rejects.toThrow(); - + : bridge.killSession(session.sessionId), + ).rejects.toThrow(); expect(bridge.sessionCount).toBe(1); expect(handle.killed).toBe(false); expect( @@ -12671,6 +12681,73 @@ describe('createAcpSessionBridge', () => { }, ); + it.each(['close', 'kill'] as const)( + 'does not leave the session unclosable after queued persistence permanently fails before %s', + async (operation) => { + const activePrompt = deferred(); + const handle = makeChannel({ + promptImpl: () => activePrompt.promise, + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + throw new Error('writer permanently unavailable'); + } + return method === SERVE_CONTROL_EXT_METHODS.sessionClose + ? { closed: true } + : {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const p1 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'active' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + await vi.waitFor(() => + expect(handle.agent.promptCalls).toHaveLength(1), + ); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued deadline' }], + }, + undefined, + { promptId: 'prompt-b', deadlineMs: 10 }, + ); + + await vi.waitFor(async () => { + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-b', + ), + ).resolves.toMatchObject({ + state: 'error', + error: { code: 'prompt_deadline_exceeded' }, + }); + }); + activePrompt.resolve({ stopReason: 'end_turn' }); + await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); + await expect(p2).rejects.toThrow(/deadline/i); + + await expect( + operation === 'close' + ? bridge.closeSession(session.sessionId) + : bridge.killSession(session.sessionId), + ).resolves.toBe(operation === 'close' ? undefined : true); + expect(bridge.sessionCount).toBe(0); + await bridge.shutdown(); + }, + ); + it('does not kill the channel when queued persistence times out before close', async () => { const activePrompt = deferred(); const handle = makeChannel({ diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 14baee71083..b5f728d0301 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -1940,14 +1940,19 @@ async function cancelQueuedPromptsBeforeTeardown( } const attempts = strictTerminalPersistences.get(entry); if (!attempts) return; - await Promise.all( - [...attempts.entries()].map(([promptId, current]) => + const newlyCancelled = new Set(queued.map(({ promptId }) => promptId)); + const required: Array> = []; + const previous: Array> = []; + for (const [promptId, current] of attempts) { + const persistence = current.state === 'pending' ? current.promise : startStrictTerminalPersistence(entry, promptId, current.turnResult) - .promise, - ), - ); + .promise; + (newlyCancelled.has(promptId) ? required : previous).push(persistence); + } + await Promise.allSettled(previous); + await Promise.all(required); } function hasControlCharacter(value: string): boolean { @@ -10547,23 +10552,9 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { throw err; } - const retainedTurnResultPromptIds = - response['retainedTurnResultPromptIds']; - if ( - Array.isArray(retainedTurnResultPromptIds) && - retainedTurnResultPromptIds.every( - (promptId): promptId is string => typeof promptId === 'string', - ) - ) { - const retained = new Set(retainedTurnResultPromptIds); - for (const promptId of entry.terminalTurnStatuses.keys()) { - if (!retained.has(promptId)) { - entry.terminalTurnStatuses.delete(promptId); - } - } - } else { - entry.terminalTurnStatuses.clear(); - } + // The child transcript reader owns rewind branch membership. Drop the + // bridge's ephemeral overlays so subsequent polls use that active branch. + entry.terminalTurnStatuses.clear(); const targetTurnIndex = (response['targetTurnIndex'] as number) ?? 0; const filesChanged = (response['filesChanged'] as string[]) ?? []; const filesFailed = (response['filesFailed'] as string[]) ?? []; diff --git a/packages/cli/src/acp-integration/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts index b3c395b87cf..b509486a8d9 100644 --- a/packages/cli/src/acp-integration/acpAgent.test.ts +++ b/packages/cli/src/acp-integration/acpAgent.test.ts @@ -1908,9 +1908,6 @@ describe('QwenAgent MCP SSE/HTTP support', () => { emitGoalStatus: ReturnType; restoreHistory: ReturnType; rewindToTurn: ReturnType; - getRetainedTurnResultPromptIds: ReturnType; - isTurnResultPromptIdRetained: ReturnType; - registerExternalTurnResultPromptId: ReturnType; getRewindableUserTurnCount: ReturnType; clearActiveTodoPlanRevision: ReturnType; clearTodoStopGuardTrust: ReturnType; @@ -3650,11 +3647,6 @@ describe('QwenAgent MCP SSE/HTTP support', () => { rewindToTurn: vi .fn() .mockReturnValue({ targetTurnIndex: 1, apiTruncateIndex: 2 }), - getRetainedTurnResultPromptIds: vi - .fn() - .mockReturnValue(['daemon-prompt-a']), - isTurnResultPromptIdRetained: vi.fn().mockReturnValue(true), - registerExternalTurnResultPromptId: vi.fn(), getRewindableUserTurnCount: vi.fn().mockReturnValue(1), clearActiveTodoPlanRevision: vi.fn(), clearTodoStopGuardTrust: vi.fn(), @@ -9230,60 +9222,6 @@ describe('QwenAgent MCP SSE/HTTP support', () => { await agentPromise; }); - it('does not return a turn_result from an abandoned rewind branch', async () => { - const sessionId = '11111111-1111-1111-1111-111111111111'; - await setupSessionMocks(sessionId); - const abandoned = { - promptId: 'prompt-abandoned', - state: 'completed', - stopReason: 'end_turn', - endedAt: 2000, - resultText: 'abandoned answer', - }; - const readPage = vi.fn().mockResolvedValue({ - sessionId, - records: [ - { type: 'system', subtype: 'turn_result', systemPayload: abandoned }, - ], - hasMore: false, - gaps: [], - startTime: 'start', - lastUpdated: 'end', - }); - vi.mocked(SessionTranscriptReader).mockImplementation( - () => - ({ - readPage, - }) as unknown as InstanceType, - ); - - const agentPromise = runAcpAgent( - mockConfig, - makeSessionSettings(), - mockArgv, - ); - await vi.waitFor(() => expect(capturedAgentFactory).toBeDefined()); - const agent = capturedAgentFactory!({ - get closed() { - return mockConnectionState.promise; - }, - }) as AgentLike; - - await agent.newSession({ cwd: '/tmp', mcpServers: [] }); - lastSessionMock?.isTurnResultPromptIdRetained.mockReturnValue(false); - const response = await agent.extMethod( - SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, - { - sessionId, - promptId: 'prompt-abandoned', - }, - ); - - mockConnectionState.resolve(); - await agentPromise; - expect(response).toEqual({ v: 1, sessionId, turnResult: null }); - }); - it('paginates bounded turn_result scans until the promptId matches', async () => { const sessionId = '11111111-1111-1111-1111-111111111111'; await setupSessionMocks(sessionId); @@ -13208,7 +13146,6 @@ describe('QwenAgent MCP SSE/HTTP support', () => { historyBeforeRewind: [{ role: 'user', parts: [{ text: 'before' }] }], targetTurnIndex: 1, apiTruncateIndex: 2, - retainedTurnResultPromptIds: ['daemon-prompt-a'], filesChanged: [], filesFailed: [], artifactSnapshot, diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index 2f75fd8822a..238dfcc9d36 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -412,7 +412,6 @@ async function findSettledTurnResult( sessionId: string, promptId: string | undefined, workspaceCwd: string, - isRetained: (promptId: string) => boolean, ): Promise { let cursor: string | undefined; for (let page = 0; page < TURN_STATUS_SCAN_MAX_PAGES; page++) { @@ -432,10 +431,7 @@ async function findSettledTurnResult( } const payload = record.systemPayload; if (!isTurnResultRecordPayload(payload)) continue; - if ( - isRetained(payload.promptId) && - (promptId === undefined || payload.promptId === promptId) - ) { + if (promptId === undefined || payload.promptId === promptId) { return payload; } } @@ -10656,7 +10652,6 @@ class QwenAgent implements Agent { ); } await recorder.recordTurnResultStrict(turnResult); - session.registerExternalTurnResultPromptId(turnResult.promptId); return { v: 1, sessionId }; } case SERVE_CONTROL_EXT_METHODS.sessionTurnStatus: { @@ -10701,7 +10696,6 @@ class QwenAgent implements Agent { sessionId, typeof rawPromptId === 'string' ? rawPromptId : undefined, cwd, - (promptId) => session.isTurnResultPromptIdRetained(promptId), ); return { v: 1, @@ -11155,7 +11149,6 @@ class QwenAgent implements Agent { success: true, historyBeforeRewind, ...rewindResult, - retainedTurnResultPromptIds: session.getRetainedTurnResultPromptIds(), filesChanged, filesFailed, ...(artifactSnapshot ? { artifactSnapshot } : {}), diff --git a/packages/cli/src/acp-integration/session/Session.test.ts b/packages/cli/src/acp-integration/session/Session.test.ts index b5908460a66..5631256fb9d 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -2584,206 +2584,6 @@ describe('Session', () => { }); describe('rewindToTurn', () => { - it('restores an admission result recorded before the first user turn', () => { - session.primeTurnFromHistory([ - { - uuid: 'turn-result-1', - parentUuid: null, - sessionId: 'test-session-id', - timestamp: new Date(0).toISOString(), - type: 'system', - subtype: 'turn_result', - cwd: '/tmp', - version: 'test', - systemPayload: { - promptId: 'admission-error-prompt', - state: 'error', - endedAt: 1, - error: { message: 'writer unavailable' }, - }, - }, - ]); - - expect(session.getRetainedTurnResultPromptIds()).toEqual([ - 'admission-error-prompt', - ]); - }); - - it('retains daemon prompt ids for user turns kept by rewind', async () => { - mockChat.sendMessageStream = vi - .fn() - .mockResolvedValue(createEmptyStream()); - const countSpy = vi - .spyOn(session, 'getRewindableUserTurnCount') - .mockReturnValueOnce(0) - .mockReturnValueOnce(1); - - await session.prompt( - { - sessionId: 'test-session-id', - prompt: [{ type: 'text', text: 'first' }], - }, - { - version: 1, - sessionId: 'test-session-id', - promptId: 'daemon-prompt-a', - }, - ); - await session.prompt( - { - sessionId: 'test-session-id', - prompt: [{ type: 'text', text: 'second' }], - }, - { - version: 1, - sessionId: 'test-session-id', - promptId: 'daemon-prompt-b', - }, - ); - countSpy.mockRestore(); - const history: Content[] = [ - { role: 'user', parts: [{ text: 'first' }] }, - { role: 'model', parts: [{ text: 'first reply' }] }, - { role: 'user', parts: [{ text: 'second' }] }, - { role: 'model', parts: [{ text: 'second reply' }] }, - ]; - vi.mocked(mockChat.getHistory).mockReturnValue(history); - vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history); - - session.rewindToTurn(1); - - expect(session.getRetainedTurnResultPromptIds()).toEqual([ - 'daemon-prompt-a', - ]); - }); - - it('does not count a mid-turn user record as a rewindable turn', () => { - session.primeTurnFromHistory([ - chatRecord({ - uuid: 'user-a', - message: { role: 'user', parts: [{ text: 'first' }] }, - }), - chatRecord({ - uuid: 'tool-result-a', - parentUuid: 'user-a', - type: 'tool_result', - message: { - role: 'user', - parts: [ - { - functionResponse: { - id: 'call-a', - name: 'read_file', - response: { output: 'contents' }, - }, - }, - ], - }, - }), - chatRecord({ - uuid: 'mid-turn-a', - parentUuid: 'tool-result-a', - subtype: 'mid_turn_user_message', - message: { - role: 'user', - parts: [{ text: 'also check tests' }], - }, - }), - chatRecord({ - uuid: 'turn-result-a', - parentUuid: 'mid-turn-a', - type: 'system', - subtype: 'turn_result', - systemPayload: { - promptId: 'daemon-prompt-a', - state: 'completed', - stopReason: 'end_turn', - endedAt: 1, - }, - }), - chatRecord({ - uuid: 'user-b', - parentUuid: 'turn-result-a', - message: { role: 'user', parts: [{ text: 'second' }] }, - }), - ]); - const history: Content[] = [ - { role: 'user', parts: [{ text: 'first' }] }, - { role: 'model', parts: [{ functionCall: { name: 'read_file' } }] }, - { - role: 'user', - parts: [ - { - functionResponse: { - id: 'call-a', - name: 'read_file', - response: { output: 'contents' }, - }, - }, - { text: 'also check tests' }, - ], - }, - { role: 'model', parts: [{ text: 'first reply' }] }, - { role: 'user', parts: [{ text: 'second' }] }, - { role: 'model', parts: [{ text: 'second reply' }] }, - ]; - vi.mocked(mockChat.getHistory).mockReturnValue(history); - vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history); - - session.rewindToTurn(1); - - expect(session.getRetainedTurnResultPromptIds()).toContain( - 'daemon-prompt-a', - ); - }); - - it('does not count a pure system reminder as a rewindable turn', () => { - session.primeTurnFromHistory([ - chatRecord({ - uuid: 'user-a', - message: { role: 'user', parts: [{ text: 'first' }] }, - }), - chatRecord({ - uuid: 'reminder-a', - parentUuid: 'user-a', - message: { - role: 'user', - parts: [ - { - text: `${SYSTEM_REMINDER_OPEN}structural${SYSTEM_REMINDER_CLOSE}`, - }, - ], - }, - }), - chatRecord({ - uuid: 'turn-result-a', - parentUuid: 'reminder-a', - type: 'system', - subtype: 'turn_result', - systemPayload: { - promptId: 'daemon-prompt-a', - state: 'completed', - stopReason: 'end_turn', - endedAt: 1, - }, - }), - ]); - const history: Content[] = [ - { role: 'user', parts: [{ text: 'first' }] }, - { role: 'model', parts: [{ text: 'first reply' }] }, - { role: 'user', parts: [{ text: 'second' }] }, - { role: 'model', parts: [{ text: 'second reply' }] }, - ]; - vi.mocked(mockChat.getHistory).mockReturnValue(history); - vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history); - - session.rewindToTurn(1); - - expect(session.getRetainedTurnResultPromptIds()).toContain( - 'daemon-prompt-a', - ); - }); - it('truncates model history before the requested user turn and records rewind', async () => { const history: Content[] = [ { role: 'user', parts: [{ text: 'first' }] }, @@ -5292,49 +5092,6 @@ describe('Session', () => { ).toBeUndefined(); }); - it.each([ - ['continue', 'qwen.daemon.continueLastTurn'], - ['retry', 'qwen.daemon.retry'], - ])( - 'keeps an early %s failure attached to the current turn', - async (_label, metadataKey) => { - const countSpy = vi - .spyOn(session, 'getRewindableUserTurnCount') - .mockReturnValue(2); - mockConfig.assertCanStartTurn = vi - .fn() - .mockRejectedValue(new Error('admission failed')); - const promptId = `early-${_label}-failure`; - - await expect( - session.prompt( - { - sessionId: 'test-session-id', - prompt: [{ type: 'text', text: '' }], - _meta: { [metadataKey]: true }, - }, - { ...trustedContext, promptId }, - ), - ).rejects.toThrow('admission failed'); - countSpy.mockRestore(); - - const history: Content[] = [ - { role: 'user', parts: [{ text: 'first' }] }, - { role: 'model', parts: [{ text: 'first reply' }] }, - { role: 'user', parts: [{ text: 'second' }] }, - { role: 'model', parts: [{ text: 'second reply' }] }, - { role: 'user', parts: [{ text: 'third' }] }, - { role: 'model', parts: [{ text: 'third reply' }] }, - ]; - vi.mocked(mockChat.getHistory).mockReturnValue(history); - vi.mocked(mockChat.getHistoryShallow).mockReturnValue(history); - - session.rewindToTurn(2); - - expect(session.getRetainedTurnResultPromptIds()).toContain(promptId); - }, - ); - it('records an error when awaited turn finalization fails', async () => { ( session as unknown as { diff --git a/packages/cli/src/acp-integration/session/Session.ts b/packages/cli/src/acp-integration/session/Session.ts index 03b758d2dd8..176982a5b80 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -176,7 +176,6 @@ import { approxBase64Bytes, TURN_RESULT_CODE_TEXT_TRUNCATED, TURN_RESULT_TEXT_MAX_CHARS, - isTurnResultRecordPayload, normalizeTurnResultError, runWithRuntimeContentGenerator, getInvocationContext, @@ -920,7 +919,6 @@ function extractTurnPromptText(content: ContentBlock[]): string { type InFlightTurnRecording = { promptId: string; - turnIndex?: number; originatorClientId?: string; startedAt?: number; promptText: string; @@ -1545,7 +1543,6 @@ export class Session implements SessionContext { * the transcript at turn end; `null` when no pollable turn is streaming. */ #turnRecording: InFlightTurnRecording | null = null; - readonly #turnResultTurnIndexes = new Map(); /** * Tracks the completion of the current prompt so that the next prompt * can await it. This prevents a new prompt from reading chat history @@ -2764,22 +2761,7 @@ export class Session implements SessionContext { * Delegates to HistoryReplayer for consistent event emission. */ primeTurnFromHistory(records: ChatRecord[]): void { - this.#turnResultTurnIndexes.clear(); - let turnIndex = -1; for (const record of records) { - if (isUserPromptRecord(record)) { - turnIndex += 1; - } - if ( - record.type === 'system' && - record.subtype === 'turn_result' && - isTurnResultRecordPayload(record.systemPayload) - ) { - this.#turnResultTurnIndexes.set( - record.systemPayload.promptId, - Math.max(0, turnIndex), - ); - } if (record.subtype !== 'notification') continue; const backgroundTask = ( record.systemPayload as @@ -2880,30 +2862,9 @@ export class Session implements SessionContext { void this.#drainNotificationQueue(); } - for (const [promptId, turnIndex] of this.#turnResultTurnIndexes) { - if (turnIndex >= targetTurnIndex) { - this.#turnResultTurnIndexes.delete(promptId); - } - } - return { targetTurnIndex, apiTruncateIndex }; } - getRetainedTurnResultPromptIds(): string[] { - return [...this.#turnResultTurnIndexes.keys()]; - } - - isTurnResultPromptIdRetained(promptId: string): boolean { - return this.#turnResultTurnIndexes.has(promptId); - } - - registerExternalTurnResultPromptId(promptId: string): void { - this.#turnResultTurnIndexes.set( - promptId, - Math.max(0, this.getRewindableUserTurnCount() - 1), - ); - } - captureHistorySnapshot(): Content[] { return this.config.getGeminiClient()!.getChat().getHistoryShallow(); } @@ -3256,7 +3217,6 @@ export class Session implements SessionContext { channelDeliveryCapture, invocationContext, modelPrompt, - turnRecording, ); const terminalError = getTerminalPromptAbortError(pendingSend.signal); settlement = @@ -3524,7 +3484,6 @@ export class Session implements SessionContext { channelDeliveryCapture?: ChannelDeliveryCapture, invocationContext?: InvocationContextV1, modelPrompt?: string, - turnRecording?: InFlightTurnRecording | null, ): Promise { const sessionId = this.config.getSessionId(); if ( @@ -3547,7 +3506,6 @@ export class Session implements SessionContext { pendingSend, channelDeliveryCapture, modelPrompt, - turnRecording, ), ), ); @@ -3558,7 +3516,6 @@ export class Session implements SessionContext { pendingSend: AbortController, channelDeliveryCapture?: ChannelDeliveryCapture, modelPrompt?: string, - turnRecording?: InFlightTurnRecording | null, ): Promise { return Storage.runWithRuntimeBaseDir( this.runtimeBaseDir, @@ -3649,14 +3606,6 @@ export class Session implements SessionContext { // — so hold it (and a push-count snapshot) to restore on that path. let strippedOrphanEntries: Content[] | null = null; let orphanPushCountSnapshot = 0; - if (turnRecording) { - const rewindableTurnCount = this.getRewindableUserTurnCount(); - turnRecording.turnIndex = - isContinue || isRetry - ? Math.max(0, rewindableTurnCount - 1) - : rewindableTurnCount; - } - if (isContinue) { const recoveryPlan = buildSessionRecoveryPlanFromApiHistory({ sessionId: this.sessionId, @@ -5343,10 +5292,6 @@ export class Session implements SessionContext { const { text, truncated } = truncateTurnText( extractTurnPromptText(params.prompt), ); - const metadata = params._meta as Record | undefined; - const continuesCurrentTurn = - metadata?.[DAEMON_RETRY_META_KEY] === true || - metadata?.[DAEMON_CONTINUE_META_KEY] === true; return { promptId: invocationContext.promptId, ...(invocationContext.originatorClientId !== undefined @@ -5354,11 +5299,6 @@ export class Session implements SessionContext { : {}), promptText: text, promptTextTruncated: truncated, - ...(continuesCurrentTurn - ? { - turnIndex: Math.max(0, this.getRewindableUserTurnCount() - 1), - } - : {}), resultSegments: new Map(), resultCapturedChars: 0, resultSegmentsTruncated: false, @@ -5469,10 +5409,6 @@ export class Session implements SessionContext { if (recording === null) { return; } - this.#turnResultTurnIndexes.set( - recording.promptId, - recording.turnIndex ?? this.getRewindableUserTurnCount(), - ); const selectedSegments = [...recording.resultSegments.values()].map( (segment) => ({ text: segment.rewrittenText ?? segment.rawText, diff --git a/packages/core/src/services/session-transcript-reader.test.ts b/packages/core/src/services/session-transcript-reader.test.ts index e7cf487f8c3..222b37560de 100644 --- a/packages/core/src/services/session-transcript-reader.test.ts +++ b/packages/core/src/services/session-transcript-reader.test.ts @@ -335,6 +335,54 @@ describe('SessionTranscriptReader', () => { expect(second.nextCursorState).toBeUndefined(); }); + it('keeps turn results on the active rewind branch and hides abandoned ones', async () => { + const turnResult = ( + uuid: string, + parentUuid: string | null, + promptId: string, + ): ChatRecord => ({ + ...record(uuid, parentUuid, ''), + type: 'system', + subtype: 'turn_result', + message: undefined, + systemPayload: { + promptId, + state: 'completed', + stopReason: 'end_turn', + endedAt: RECORD_BASE_MS, + }, + }); + const rewind = { + ...record('rewind', 'early-result', ''), + type: 'system' as const, + subtype: 'rewind' as const, + message: undefined, + systemPayload: { targetTurnIndex: 1, truncatedCount: 2 }, + }; + await writeRecords([ + turnResult('pre-first-result', null, 'pre-first'), + record('u1', 'pre-first-result', 'first prompt'), + record('a1', 'u1', 'first answer'), + turnResult('early-result', 'a1', 'early-pre-dispatch'), + record('u2', 'early-result', 'second prompt'), + record('a2', 'u2', 'second answer'), + turnResult('later-result', 'a2', 'later-abandoned'), + rewind, + ]); + + const page = await new SessionTranscriptReader(workspaceDir).readPage( + sessionId, + { direction: 'backward', limit: 100 }, + ); + const promptIds = page.records.flatMap((item) => + item.subtype === 'turn_result' + ? [(item.systemPayload as { promptId: string }).promptId] + : [], + ); + + expect(promptIds).toEqual(['pre-first', 'early-pre-dispatch']); + }); + it('pages backward before an exclusive active record boundary', async () => { await writeRecords([ record('u1', null, 'first prompt'), From 52dc4cf53944aea6b7ceadb1d7733ecf47e803a4 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Wed, 12 Aug 2026 22:38:46 +0800 Subject: [PATCH 21/25] fix(daemon): persist turn results after channel crashes --- packages/acp-bridge/src/bridge.test.ts | 123 +++++++++++++ packages/acp-bridge/src/bridge.ts | 212 ++++++++++++++++++++--- packages/acp-bridge/src/bridgeOptions.ts | 7 + packages/cli/src/serve/run-qwen-serve.ts | 3 + 4 files changed, 320 insertions(+), 25 deletions(-) diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 52f56ba58d7..22744e517f5 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -89,6 +89,8 @@ import { } from './bridgeTypes.js'; import { ApprovalMode, + SessionTranscriptReader, + Storage, SESSION_ARTIFACT_PERSISTENCE_VERSION, ShellExecutionService, stableSessionArtifactId, @@ -13105,6 +13107,127 @@ describe('createAcpSessionBridge', () => { expect(terminalsFor(events, 'prompt-b')).toHaveLength(1); await bridge.shutdown(); }); + + it('persists pending terminal results after the channel process exits', async () => { + const runtimeBaseDir = await fsp.mkdtemp( + path.join(os.tmpdir(), 'qwen-bridge-crash-result-'), + ); + const workspaceCwd = await fsp.mkdtemp( + path.join(os.tmpdir(), 'qwen-bridge-crash-workspace-'), + ); + const sessionId = 'aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee'; + const storage = new Storage(workspaceCwd, runtimeBaseDir); + const chatsDir = path.join(storage.getProjectDir(), 'chats'); + await fsp.mkdir(chatsDir, { recursive: true }); + await fsp.writeFile( + path.join(chatsDir, `${sessionId}.jsonl`), + `${JSON.stringify({ + uuid: 'seed-record', + parentUuid: null, + sessionId, + timestamp: new Date(0).toISOString(), + type: 'system', + subtype: 'agent_bootstrap', + provenance: 'system', + cwd: workspaceCwd, + version: 'test', + systemPayload: { kind: 'fork', history: [] }, + })}\n`, + ); + const handle = makeChannel({ + newSessionImpl: () => ({ sessionId }), + promptImpl: () => new Promise(() => {}), + }); + const bridge = makeBridge({ + boundWorkspace: workspaceCwd, + runtimeBaseDir, + maxPendingPromptsPerSession: 70, + channelFactory: async () => handle.channel, + }); + const stderrSpy = vi + .spyOn(process.stderr, 'write') + .mockImplementation(() => true); + try { + const session = await bridge.spawnOrAttach({ workspaceCwd }); + const active = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'active at crash' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + active.catch(() => {}); + const queuedPromptIds = Array.from( + { length: 65 }, + (_, index) => `prompt-${index + 1}`, + ); + for (const promptId of queuedPromptIds) { + bridge + .sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued at crash' }], + }, + undefined, + { promptId }, + ) + .catch(() => {}); + } + await new Promise((resolve) => setTimeout(resolve, 20)); + + handle.crash({ exitCode: 1, signalCode: null }); + await bridge.shutdown(); + + await vi.waitFor(async () => { + const page = await Storage.runWithResolvedRuntimeBaseDir( + runtimeBaseDir, + () => + new SessionTranscriptReader(workspaceCwd).readPage(sessionId, { + direction: 'backward', + limit: 100, + }), + ); + const results = page.records.flatMap((record) => + record.subtype === 'turn_result' + ? [ + record.systemPayload as { + promptId: string; + state: string; + error?: { code?: string }; + }, + ] + : [], + ); + expect(results).toHaveLength(66); + expect(results.map((result) => result.promptId)).toEqual([ + 'prompt-a', + ...queuedPromptIds, + ]); + expect(results).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + promptId: 'prompt-a', + state: 'error', + error: expect.objectContaining({ code: 'channel_closed' }), + }), + expect.objectContaining({ + promptId: 'prompt-65', + state: 'error', + error: expect.objectContaining({ code: 'channel_closed' }), + }), + ]), + ); + }); + } finally { + stderrSpy.mockRestore(); + await bridge.shutdown(); + await fsp.rm(runtimeBaseDir, { recursive: true, force: true }); + await fsp.rm(workspaceCwd, { recursive: true, force: true }); + } + }); }); describe('cancelSession', () => { diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 7670f9117ab..577118a8079 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -5,6 +5,7 @@ */ import { randomBytes, randomUUID } from 'node:crypto'; +import * as fs from 'node:fs/promises'; import * as path from 'node:path'; import { inspect } from 'node:util'; import { @@ -22,6 +23,7 @@ import type { } from '@agentclientprotocol/sdk'; import type { ApprovalMode, + ChatRecord, RebuiltSessionArtifactSnapshot, TurnResultRecordPayload, } from '@qwen-code/qwen-code-core'; @@ -36,7 +38,10 @@ import { TURN_RESULT_CODE_TEXT_TRUNCATED, TURN_RESULT_TEXT_MAX_CHARS, normalizeTurnResultError, + SessionTranscriptReader, + SessionWriterLease, TrustGateError, + Storage, normalizeSnapshotPayload, ShellExecutionService, type InvocationContextV1, @@ -1721,6 +1726,96 @@ function terminalStatusRecord( }; } +async function persistTerminalResultsAfterChannelExit( + entry: SessionEntry, + runtimeBaseDir: string, + turnResults: readonly TurnResultRecordPayload[], +): Promise { + if (turnResults.length === 0) return; + + const storage = new Storage(entry.workspaceCwd, runtimeBaseDir); + const transcriptPath = path.join( + storage.getProjectDir(), + 'chats', + `${entry.sessionId}.jsonl`, + ); + let lease: SessionWriterLease | undefined; + try { + try { + await fs.access(transcriptPath); + } catch (error) { + if ((error as NodeJS.ErrnoException).code === 'ENOENT') return; + throw error; + } + lease = await SessionWriterLease.acquire({ + runtimeBaseDir, + sessionId: entry.sessionId, + transcriptPath, + processKind: 'daemon', + reclaimPolicy: 'local', + }); + const { existingPromptIds, activeLeafUuid } = + await Storage.runWithResolvedRuntimeBaseDir(runtimeBaseDir, async () => { + const reader = new SessionTranscriptReader(entry.workspaceCwd); + const promptIds = new Set(); + let beforeRecordId: string | undefined; + let leafUuid: string | null = null; + for (let pageIndex = 0; pageIndex < 10; pageIndex++) { + const page = await reader.readPage(entry.sessionId, { + ...(beforeRecordId + ? { beforeRecordId } + : { direction: 'backward' as const }), + limit: 500, + }); + if (pageIndex === 0) leafUuid = page.records.at(-1)?.uuid ?? null; + for (const record of page.records) { + if ( + record.subtype === 'turn_result' && + record.systemPayload && + typeof (record.systemPayload as { promptId?: unknown }) + .promptId === 'string' + ) { + promptIds.add( + (record.systemPayload as TurnResultRecordPayload).promptId, + ); + } + } + if (!page.hasMore || page.records.length === 0) break; + beforeRecordId = page.records[0]!.uuid; + } + return { existingPromptIds: promptIds, activeLeafUuid: leafUuid }; + }); + let parentUuid = activeLeafUuid; + for (const turnResult of turnResults) { + if (existingPromptIds.has(turnResult.promptId)) continue; + const record: ChatRecord = { + uuid: randomUUID(), + parentUuid, + sessionId: entry.sessionId, + timestamp: new Date().toISOString(), + type: 'system', + subtype: 'turn_result', + provenance: 'system', + cwd: entry.effectiveCwd, + version: 'unknown', + systemPayload: turnResult, + }; + await lease.appendJsonLine(record); + parentUuid = record.uuid; + } + } catch (error) { + writeStderrLine( + `[turn-result] session=${entry.sessionId} action=crash_persist_failed error=${extractErrorMessage(error)}`, + ); + } finally { + await lease?.release().catch((error: unknown) => { + writeStderrLine( + `[turn-result] session=${entry.sessionId} action=crash_lease_release_failed error=${extractErrorMessage(error)}`, + ); + }); + } +} + interface StrictTerminalPersistence { promise: Promise; state: 'pending' | 'succeeded' | 'failed'; @@ -1762,7 +1857,7 @@ function publishPromptTerminal( pendingEntry: PendingPromptEntry, terminal: PromptTerminal, options?: { persistIfDispatched?: boolean }, -): void { +): BridgeTurnStatus | undefined { if (pendingEntry.terminalPublished) { // Dedup here is the designed steady state, not an anomaly: deadline // expiry, queued removal, and teardown flush each race the prompt's @@ -1771,7 +1866,7 @@ function publishPromptTerminal( `publishPromptTerminal: suppressed duplicate ${terminal.kind} terminal ` + `for prompt ${pendingEntry.promptId} (session ${entry.sessionId})`, ); - return; + return entry.terminalTurnStatuses.get(pendingEntry.promptId); } pendingEntry.terminalPublished = true; const status = rememberTerminalTurnStatus(entry, pendingEntry, terminal); @@ -1819,6 +1914,7 @@ function publishPromptTerminal( pendingEntry.state === 'running', ); } + return status; } function startStrictTerminalPersistence( @@ -1889,12 +1985,18 @@ function flushPromptTerminals( entry: SessionEntry, code: string, message: string, -): void { +): TurnResultRecordPayload[] { + const turnResults: TurnResultRecordPayload[] = []; + const includedPromptIds = new Set(); for (const pending of [...entry.pendingPromptList]) { - publishPromptTerminal(entry, pending, { + const status = publishPromptTerminal(entry, pending, { kind: 'error', err: { code, message }, }); + if (status) { + turnResults.push(terminalStatusRecord(status)); + includedPromptIds.add(pending.promptId); + } try { pending.abortController.abort( new DOMException('Prompt aborted', 'AbortError'), @@ -1903,6 +2005,11 @@ function flushPromptTerminals( /* listeners must not break teardown */ } } + for (const [promptId, attempt] of strictTerminalPersistences.get(entry) ?? + []) { + if (!includedPromptIds.has(promptId)) turnResults.push(attempt.turnResult); + } + return turnResults; } async function cancelQueuedPromptsBeforeTeardown( @@ -2405,6 +2512,9 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { ); } const boundWorkspace = opts.boundWorkspace; + const runtimeBaseDir = path.resolve( + opts.runtimeBaseDir ?? Storage.getRuntimeBaseDir(), + ); const persistApprovalMode = opts.persistApprovalMode; const telemetry = opts.telemetry ?? NOOP_BRIDGE_TELEMETRY; @@ -3104,6 +3214,8 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // `killAllSync` iterates THIS set to fire SIGKILL on every alive // child regardless of whether it's still the attach target. const aliveChannels = new Set(); + const channelExitCleanups = new Set>(); + const crashRecoveries = new Map>(); // Coalesces a concurrent second `ensureChannel()` call onto the // first one's spawn so we never create two children for the same // daemon. Cleared in the `finally` of the creator. @@ -3728,7 +3840,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // so `killAllSync` still has a reference to fire SIGKILL during // the SIGTERM grace window — even if a concurrent `spawnOrAttach` // has already reassigned `channelInfo` to a fresh channel. - void channel.exited.then((exitInfo) => { + const exitCleanup = channel.exited.then(async (exitInfo) => { clearInFlightExtensionRefreshes(info.connection); if (channelInfo === info) cancelIdleTimer(); if (info.workspaceMcpDiscoveryTimer) { @@ -3791,31 +3903,24 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { `qwen serve: channel exited (code=${exitInfo?.exitCode ?? 'none'}, signal=${exitInfo?.signalCode ?? 'none'}, transport=${info.transportFailed ? (info.transportFailureCode ?? 'failed') : 'ok'}, ${sessions.length} session(s) torn down)`, ); } - for (const sid of sessions) { - const sessEntry = byId.get(sid); - if (!sessEntry) continue; + const crashedSessions = sessions.flatMap((sid) => { + const entry = byId.get(sid); + return entry ? [{ sid, entry }] : []; + }); + const recoveries: Array<{ + sid: string; + entry: SessionEntry; + persistence: Promise; + }> = []; + for (const { sid, entry: sessEntry } of crashedSessions) { cancelPendingForSession(sid); // DAEMON-002/005: every still-pending prompt owes its formal // terminal before the bus closes below. - flushPromptTerminals( + const turnResults = flushPromptTerminals( sessEntry, 'channel_closed', 'agent channel exited before the prompt completed', ); - try { - sessEntry.events.publish({ - type: 'session_died', - data: { - sessionId: sid, - reason: 'channel_closed', - // BX9_P: thread exitCode/signalCode through. - exitCode: exitInfo?.exitCode ?? null, - signalCode: exitInfo?.signalCode ?? null, - }, - }); - } catch { - /* bus already closed */ - } if (sessEntry.promptActive) { sessEntry.promptActive = false; activePromptCounter--; @@ -3834,9 +3939,41 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // future load/resume of the same persisted session id. info.client.markSessionClosed(sid); if (defaultEntry === sessEntry) defaultEntry = undefined; + const persistence = persistTerminalResultsAfterChannelExit( + sessEntry, + runtimeBaseDir, + turnResults, + ); + crashRecoveries.set(sid, persistence); + recoveries.push({ sid, entry: sessEntry, persistence }); + } + await Promise.all(recoveries.map(({ persistence }) => persistence)); + for (const { sid, entry: sessEntry, persistence } of recoveries) { + if (crashRecoveries.get(sid) === persistence) { + crashRecoveries.delete(sid); + } + try { + sessEntry.events.publish({ + type: 'session_died', + data: { + sessionId: sid, + reason: 'channel_closed', + // BX9_P: thread exitCode/signalCode through. + exitCode: exitInfo?.exitCode ?? null, + signalCode: exitInfo?.signalCode ?? null, + }, + }); + } catch { + /* bus already closed */ + } sessEntry.events.close(); } }); + channelExitCleanups.add(exitCleanup); + void exitCleanup.then( + () => channelExitCleanups.delete(exitCleanup), + () => channelExitCleanups.delete(exitCleanup), + ); // Initialize handshake. The channel is already in // `aliveChannels` and the `channel.exited` handler above is @@ -5917,6 +6054,10 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { throw new Error('AcpSessionBridge is shutting down'); } const workspaceKey = resolveWorkspaceKey(req.workspaceCwd); + await crashRecoveries.get(req.sessionId); + if (shuttingDown) { + throw new Error('AcpSessionBridge is shutting down'); + } if ( req.approvalMode !== undefined && !KNOWN_APPROVAL_MODES.has(req.approvalMode) @@ -11242,6 +11383,9 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { shuttingDown = true; cancelIdleTimer(); stopSessionReaper(); + // Let an already-observed child exit claim its sessions before the + // shutdown snapshot labels remaining prompts as daemon_shutdown. + await Promise.resolve(); const entries = Array.from(byId.values()); // Snapshot every alive channel (typically 1; up to 2 during a // `killSession`-then-`spawnOrAttach` overlap) — entries are @@ -11261,6 +11405,10 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // `requestPermission` callers unwind. Each `forgetSession` // settles all matching pending as session_closed; the bridge's // per-entry index gets cleared alongside. + const shutdownTurnResults: Array<{ + entry: SessionEntry; + turnResults: TurnResultRecordPayload[]; + }> = []; for (const e of entries) { permissionMediator.forgetSession(e.sessionId); e.pendingPermissionIds.clear(); @@ -11285,11 +11433,12 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { }); // DAEMON-002/005: pending prompts owe their formal terminal // before the bus closes. - flushPromptTerminals( + const turnResults = flushPromptTerminals( e, 'daemon_shutdown', 'daemon shut down before the prompt completed', ); + shutdownTurnResults.push({ entry: e, turnResults }); try { e.events.publish({ type: 'session_died', @@ -11335,7 +11484,20 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { ...inFlightRestoreAwaits, inFlightChannelAwait, ]); - const teardownFailures = teardownResults.flatMap((result) => + const cleanupResults = await Promise.allSettled(channelExitCleanups); + await Promise.all( + shutdownTurnResults.map(({ entry, turnResults }) => + persistTerminalResultsAfterChannelExit( + entry, + runtimeBaseDir, + turnResults, + ), + ), + ); + const teardownFailures = [ + ...teardownResults, + ...cleanupResults, + ].flatMap((result) => result.status === 'rejected' ? [result.reason] : [], ); if (teardownFailures.length === 1) throw teardownFailures[0]; diff --git a/packages/acp-bridge/src/bridgeOptions.ts b/packages/acp-bridge/src/bridgeOptions.ts index af4235f6859..e3d7f9e1a33 100644 --- a/packages/acp-bridge/src/bridgeOptions.ts +++ b/packages/acp-bridge/src/bridgeOptions.ts @@ -176,6 +176,13 @@ export interface BridgeTelemetry { * strictly-required field. See per-field JSDoc for caller contract. */ export interface BridgeOptions { + /** + * Runtime output root owned by this workspace bridge. Used only for + * transcript recovery after the ACP child process has already exited. + * Production callers with per-workspace runtimes must pass the same root + * supplied to the child through `QWEN_RUNTIME_DIR`. + */ + runtimeBaseDir?: string; /** * `single` shares one session per workspace across HTTP * clients (live-collaboration default); `thread` gives each `spawnOrAttach` diff --git a/packages/cli/src/serve/run-qwen-serve.ts b/packages/cli/src/serve/run-qwen-serve.ts index dad1fbe4830..23b5fe79c36 100644 --- a/packages/cli/src/serve/run-qwen-serve.ts +++ b/packages/cli/src/serve/run-qwen-serve.ts @@ -4082,6 +4082,7 @@ async function runQwenServeImpl( const bridge = deps.bridge ?? runtime.createAcpSessionBridge({ + runtimeBaseDir: primarySessionRuntimeBaseDir, // Reverse tool channel: let `BridgeClient.extMethod` reach the WS // connection that hosts a named client MCP server (#5626). clientMcpSender: clientMcpSenderRegistry.lookup, @@ -4488,6 +4489,7 @@ async function runQwenServeImpl( ), }); const secondaryBridge = runtime.createAcpSessionBridge({ + runtimeBaseDir: secondaryEnv.sessionRuntimeBaseDir, clientMcpSender: secondaryClientMcpSenderRegistry.lookup, onCreateSubSession: secondarySubSessionLauncher.launch, onChannelDelivery: createBoundChannelDeliveryHandler( @@ -5044,6 +5046,7 @@ async function runQwenServeImpl( let wsBridge: ReturnType; try { wsBridge = runtime.createAcpSessionBridge({ + runtimeBaseDir: wsEnv.sessionRuntimeBaseDir, clientMcpSender: wsClientMcpRegistry.lookup, onCreateSubSession: wsSubSessionLauncher.launch, onChannelDelivery: createBoundChannelDeliveryHandler( From d69735683f2e7f9f6fd338e9f385f4bcd1ce134e Mon Sep 17 00:00:00 2001 From: hit_aran Date: Thu, 13 Aug 2026 00:40:10 +0800 Subject: [PATCH 22/25] fix(serve): preserve synchronous shutdown lifecycle --- packages/acp-bridge/src/bridge.ts | 33 ++++++++++++++++++------------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 577118a8079..1e7dca33b64 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -3927,13 +3927,15 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { touchActivity(); } byId.delete(sid); - telemetry.metrics?.sessionLifecycle('die'); - emitSessionLifecycle({ - type: 'removed', - sessionId: sid, - workspaceCwd: sessEntry.workspaceCwd, - reason: 'channel_closed', - }); + if (!shuttingDown) { + telemetry.metrics?.sessionLifecycle('die'); + emitSessionLifecycle({ + type: 'removed', + sessionId: sid, + workspaceCwd: sessEntry.workspaceCwd, + reason: 'channel_closed', + }); + } // Tombstone the id so any late `extNotification` from the // dying child can't leak into the early-event buffer for a // future load/resume of the same persisted session id. @@ -11383,6 +11385,16 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { shuttingDown = true; cancelIdleTimer(); stopSessionReaper(); + const lifecycleEntries = Array.from(byId.values()); + for (const entry of lifecycleEntries) { + telemetry.metrics?.sessionLifecycle('die'); + emitSessionLifecycle({ + type: 'removed', + sessionId: entry.sessionId, + workspaceCwd: entry.workspaceCwd, + reason: shutdownReason, + }); + } // Let an already-observed child exit claim its sessions before the // shutdown snapshot labels remaining prompts as daemon_shutdown. await Promise.resolve(); @@ -11424,13 +11436,6 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // `byId` (above), so the handler's `byId.get(...)` is undefined // and the automatic publish wouldn't fire. for (const e of entries) { - telemetry.metrics?.sessionLifecycle('die'); - emitSessionLifecycle({ - type: 'removed', - sessionId: e.sessionId, - workspaceCwd: e.workspaceCwd, - reason: shutdownReason, - }); // DAEMON-002/005: pending prompts owe their formal terminal // before the bus closes. const turnResults = flushPromptTerminals( From 38a63e7fff72dc65a268a5f0772f52d8d115d69d Mon Sep 17 00:00:00 2001 From: hit_aran Date: Thu, 13 Aug 2026 00:56:53 +0800 Subject: [PATCH 23/25] fix(serve): preserve restore admission ordering --- packages/acp-bridge/src/bridge.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 1e7dca33b64..4513c3feecd 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -6056,7 +6056,8 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { throw new Error('AcpSessionBridge is shutting down'); } const workspaceKey = resolveWorkspaceKey(req.workspaceCwd); - await crashRecoveries.get(req.sessionId); + const crashRecovery = crashRecoveries.get(req.sessionId); + if (crashRecovery) await crashRecovery; if (shuttingDown) { throw new Error('AcpSessionBridge is shutting down'); } From 6b443121b0b682538f26107852a44d68035fd278 Mon Sep 17 00:00:00 2001 From: hit_aran Date: Thu, 13 Aug 2026 01:17:16 +0800 Subject: [PATCH 24/25] fix(serve): remove blocking crash persistence --- packages/acp-bridge/src/bridge.test.ts | 123 ------------ packages/acp-bridge/src/bridge.ts | 240 ++++------------------- packages/acp-bridge/src/bridgeOptions.ts | 7 - packages/cli/src/serve/run-qwen-serve.ts | 3 - 4 files changed, 36 insertions(+), 337 deletions(-) diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 22744e517f5..52f56ba58d7 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -89,8 +89,6 @@ import { } from './bridgeTypes.js'; import { ApprovalMode, - SessionTranscriptReader, - Storage, SESSION_ARTIFACT_PERSISTENCE_VERSION, ShellExecutionService, stableSessionArtifactId, @@ -13107,127 +13105,6 @@ describe('createAcpSessionBridge', () => { expect(terminalsFor(events, 'prompt-b')).toHaveLength(1); await bridge.shutdown(); }); - - it('persists pending terminal results after the channel process exits', async () => { - const runtimeBaseDir = await fsp.mkdtemp( - path.join(os.tmpdir(), 'qwen-bridge-crash-result-'), - ); - const workspaceCwd = await fsp.mkdtemp( - path.join(os.tmpdir(), 'qwen-bridge-crash-workspace-'), - ); - const sessionId = 'aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee'; - const storage = new Storage(workspaceCwd, runtimeBaseDir); - const chatsDir = path.join(storage.getProjectDir(), 'chats'); - await fsp.mkdir(chatsDir, { recursive: true }); - await fsp.writeFile( - path.join(chatsDir, `${sessionId}.jsonl`), - `${JSON.stringify({ - uuid: 'seed-record', - parentUuid: null, - sessionId, - timestamp: new Date(0).toISOString(), - type: 'system', - subtype: 'agent_bootstrap', - provenance: 'system', - cwd: workspaceCwd, - version: 'test', - systemPayload: { kind: 'fork', history: [] }, - })}\n`, - ); - const handle = makeChannel({ - newSessionImpl: () => ({ sessionId }), - promptImpl: () => new Promise(() => {}), - }); - const bridge = makeBridge({ - boundWorkspace: workspaceCwd, - runtimeBaseDir, - maxPendingPromptsPerSession: 70, - channelFactory: async () => handle.channel, - }); - const stderrSpy = vi - .spyOn(process.stderr, 'write') - .mockImplementation(() => true); - try { - const session = await bridge.spawnOrAttach({ workspaceCwd }); - const active = bridge.sendPrompt( - session.sessionId, - { - sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'active at crash' }], - }, - undefined, - { promptId: 'prompt-a' }, - ); - active.catch(() => {}); - const queuedPromptIds = Array.from( - { length: 65 }, - (_, index) => `prompt-${index + 1}`, - ); - for (const promptId of queuedPromptIds) { - bridge - .sendPrompt( - session.sessionId, - { - sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'queued at crash' }], - }, - undefined, - { promptId }, - ) - .catch(() => {}); - } - await new Promise((resolve) => setTimeout(resolve, 20)); - - handle.crash({ exitCode: 1, signalCode: null }); - await bridge.shutdown(); - - await vi.waitFor(async () => { - const page = await Storage.runWithResolvedRuntimeBaseDir( - runtimeBaseDir, - () => - new SessionTranscriptReader(workspaceCwd).readPage(sessionId, { - direction: 'backward', - limit: 100, - }), - ); - const results = page.records.flatMap((record) => - record.subtype === 'turn_result' - ? [ - record.systemPayload as { - promptId: string; - state: string; - error?: { code?: string }; - }, - ] - : [], - ); - expect(results).toHaveLength(66); - expect(results.map((result) => result.promptId)).toEqual([ - 'prompt-a', - ...queuedPromptIds, - ]); - expect(results).toEqual( - expect.arrayContaining([ - expect.objectContaining({ - promptId: 'prompt-a', - state: 'error', - error: expect.objectContaining({ code: 'channel_closed' }), - }), - expect.objectContaining({ - promptId: 'prompt-65', - state: 'error', - error: expect.objectContaining({ code: 'channel_closed' }), - }), - ]), - ); - }); - } finally { - stderrSpy.mockRestore(); - await bridge.shutdown(); - await fsp.rm(runtimeBaseDir, { recursive: true, force: true }); - await fsp.rm(workspaceCwd, { recursive: true, force: true }); - } - }); }); describe('cancelSession', () => { diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 4513c3feecd..7670f9117ab 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -5,7 +5,6 @@ */ import { randomBytes, randomUUID } from 'node:crypto'; -import * as fs from 'node:fs/promises'; import * as path from 'node:path'; import { inspect } from 'node:util'; import { @@ -23,7 +22,6 @@ import type { } from '@agentclientprotocol/sdk'; import type { ApprovalMode, - ChatRecord, RebuiltSessionArtifactSnapshot, TurnResultRecordPayload, } from '@qwen-code/qwen-code-core'; @@ -38,10 +36,7 @@ import { TURN_RESULT_CODE_TEXT_TRUNCATED, TURN_RESULT_TEXT_MAX_CHARS, normalizeTurnResultError, - SessionTranscriptReader, - SessionWriterLease, TrustGateError, - Storage, normalizeSnapshotPayload, ShellExecutionService, type InvocationContextV1, @@ -1726,96 +1721,6 @@ function terminalStatusRecord( }; } -async function persistTerminalResultsAfterChannelExit( - entry: SessionEntry, - runtimeBaseDir: string, - turnResults: readonly TurnResultRecordPayload[], -): Promise { - if (turnResults.length === 0) return; - - const storage = new Storage(entry.workspaceCwd, runtimeBaseDir); - const transcriptPath = path.join( - storage.getProjectDir(), - 'chats', - `${entry.sessionId}.jsonl`, - ); - let lease: SessionWriterLease | undefined; - try { - try { - await fs.access(transcriptPath); - } catch (error) { - if ((error as NodeJS.ErrnoException).code === 'ENOENT') return; - throw error; - } - lease = await SessionWriterLease.acquire({ - runtimeBaseDir, - sessionId: entry.sessionId, - transcriptPath, - processKind: 'daemon', - reclaimPolicy: 'local', - }); - const { existingPromptIds, activeLeafUuid } = - await Storage.runWithResolvedRuntimeBaseDir(runtimeBaseDir, async () => { - const reader = new SessionTranscriptReader(entry.workspaceCwd); - const promptIds = new Set(); - let beforeRecordId: string | undefined; - let leafUuid: string | null = null; - for (let pageIndex = 0; pageIndex < 10; pageIndex++) { - const page = await reader.readPage(entry.sessionId, { - ...(beforeRecordId - ? { beforeRecordId } - : { direction: 'backward' as const }), - limit: 500, - }); - if (pageIndex === 0) leafUuid = page.records.at(-1)?.uuid ?? null; - for (const record of page.records) { - if ( - record.subtype === 'turn_result' && - record.systemPayload && - typeof (record.systemPayload as { promptId?: unknown }) - .promptId === 'string' - ) { - promptIds.add( - (record.systemPayload as TurnResultRecordPayload).promptId, - ); - } - } - if (!page.hasMore || page.records.length === 0) break; - beforeRecordId = page.records[0]!.uuid; - } - return { existingPromptIds: promptIds, activeLeafUuid: leafUuid }; - }); - let parentUuid = activeLeafUuid; - for (const turnResult of turnResults) { - if (existingPromptIds.has(turnResult.promptId)) continue; - const record: ChatRecord = { - uuid: randomUUID(), - parentUuid, - sessionId: entry.sessionId, - timestamp: new Date().toISOString(), - type: 'system', - subtype: 'turn_result', - provenance: 'system', - cwd: entry.effectiveCwd, - version: 'unknown', - systemPayload: turnResult, - }; - await lease.appendJsonLine(record); - parentUuid = record.uuid; - } - } catch (error) { - writeStderrLine( - `[turn-result] session=${entry.sessionId} action=crash_persist_failed error=${extractErrorMessage(error)}`, - ); - } finally { - await lease?.release().catch((error: unknown) => { - writeStderrLine( - `[turn-result] session=${entry.sessionId} action=crash_lease_release_failed error=${extractErrorMessage(error)}`, - ); - }); - } -} - interface StrictTerminalPersistence { promise: Promise; state: 'pending' | 'succeeded' | 'failed'; @@ -1857,7 +1762,7 @@ function publishPromptTerminal( pendingEntry: PendingPromptEntry, terminal: PromptTerminal, options?: { persistIfDispatched?: boolean }, -): BridgeTurnStatus | undefined { +): void { if (pendingEntry.terminalPublished) { // Dedup here is the designed steady state, not an anomaly: deadline // expiry, queued removal, and teardown flush each race the prompt's @@ -1866,7 +1771,7 @@ function publishPromptTerminal( `publishPromptTerminal: suppressed duplicate ${terminal.kind} terminal ` + `for prompt ${pendingEntry.promptId} (session ${entry.sessionId})`, ); - return entry.terminalTurnStatuses.get(pendingEntry.promptId); + return; } pendingEntry.terminalPublished = true; const status = rememberTerminalTurnStatus(entry, pendingEntry, terminal); @@ -1914,7 +1819,6 @@ function publishPromptTerminal( pendingEntry.state === 'running', ); } - return status; } function startStrictTerminalPersistence( @@ -1985,18 +1889,12 @@ function flushPromptTerminals( entry: SessionEntry, code: string, message: string, -): TurnResultRecordPayload[] { - const turnResults: TurnResultRecordPayload[] = []; - const includedPromptIds = new Set(); +): void { for (const pending of [...entry.pendingPromptList]) { - const status = publishPromptTerminal(entry, pending, { + publishPromptTerminal(entry, pending, { kind: 'error', err: { code, message }, }); - if (status) { - turnResults.push(terminalStatusRecord(status)); - includedPromptIds.add(pending.promptId); - } try { pending.abortController.abort( new DOMException('Prompt aborted', 'AbortError'), @@ -2005,11 +1903,6 @@ function flushPromptTerminals( /* listeners must not break teardown */ } } - for (const [promptId, attempt] of strictTerminalPersistences.get(entry) ?? - []) { - if (!includedPromptIds.has(promptId)) turnResults.push(attempt.turnResult); - } - return turnResults; } async function cancelQueuedPromptsBeforeTeardown( @@ -2512,9 +2405,6 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { ); } const boundWorkspace = opts.boundWorkspace; - const runtimeBaseDir = path.resolve( - opts.runtimeBaseDir ?? Storage.getRuntimeBaseDir(), - ); const persistApprovalMode = opts.persistApprovalMode; const telemetry = opts.telemetry ?? NOOP_BRIDGE_TELEMETRY; @@ -3214,8 +3104,6 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // `killAllSync` iterates THIS set to fire SIGKILL on every alive // child regardless of whether it's still the attach target. const aliveChannels = new Set(); - const channelExitCleanups = new Set>(); - const crashRecoveries = new Map>(); // Coalesces a concurrent second `ensureChannel()` call onto the // first one's spawn so we never create two children for the same // daemon. Cleared in the `finally` of the creator. @@ -3840,7 +3728,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // so `killAllSync` still has a reference to fire SIGKILL during // the SIGTERM grace window — even if a concurrent `spawnOrAttach` // has already reassigned `channelInfo` to a fresh channel. - const exitCleanup = channel.exited.then(async (exitInfo) => { + void channel.exited.then((exitInfo) => { clearInFlightExtensionRefreshes(info.connection); if (channelInfo === info) cancelIdleTimer(); if (info.workspaceMcpDiscoveryTimer) { @@ -3903,57 +3791,17 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { `qwen serve: channel exited (code=${exitInfo?.exitCode ?? 'none'}, signal=${exitInfo?.signalCode ?? 'none'}, transport=${info.transportFailed ? (info.transportFailureCode ?? 'failed') : 'ok'}, ${sessions.length} session(s) torn down)`, ); } - const crashedSessions = sessions.flatMap((sid) => { - const entry = byId.get(sid); - return entry ? [{ sid, entry }] : []; - }); - const recoveries: Array<{ - sid: string; - entry: SessionEntry; - persistence: Promise; - }> = []; - for (const { sid, entry: sessEntry } of crashedSessions) { + for (const sid of sessions) { + const sessEntry = byId.get(sid); + if (!sessEntry) continue; cancelPendingForSession(sid); // DAEMON-002/005: every still-pending prompt owes its formal // terminal before the bus closes below. - const turnResults = flushPromptTerminals( + flushPromptTerminals( sessEntry, 'channel_closed', 'agent channel exited before the prompt completed', ); - if (sessEntry.promptActive) { - sessEntry.promptActive = false; - activePromptCounter--; - touchActivity(); - } - byId.delete(sid); - if (!shuttingDown) { - telemetry.metrics?.sessionLifecycle('die'); - emitSessionLifecycle({ - type: 'removed', - sessionId: sid, - workspaceCwd: sessEntry.workspaceCwd, - reason: 'channel_closed', - }); - } - // Tombstone the id so any late `extNotification` from the - // dying child can't leak into the early-event buffer for a - // future load/resume of the same persisted session id. - info.client.markSessionClosed(sid); - if (defaultEntry === sessEntry) defaultEntry = undefined; - const persistence = persistTerminalResultsAfterChannelExit( - sessEntry, - runtimeBaseDir, - turnResults, - ); - crashRecoveries.set(sid, persistence); - recoveries.push({ sid, entry: sessEntry, persistence }); - } - await Promise.all(recoveries.map(({ persistence }) => persistence)); - for (const { sid, entry: sessEntry, persistence } of recoveries) { - if (crashRecoveries.get(sid) === persistence) { - crashRecoveries.delete(sid); - } try { sessEntry.events.publish({ type: 'session_died', @@ -3968,14 +3816,27 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { } catch { /* bus already closed */ } + if (sessEntry.promptActive) { + sessEntry.promptActive = false; + activePromptCounter--; + touchActivity(); + } + byId.delete(sid); + telemetry.metrics?.sessionLifecycle('die'); + emitSessionLifecycle({ + type: 'removed', + sessionId: sid, + workspaceCwd: sessEntry.workspaceCwd, + reason: 'channel_closed', + }); + // Tombstone the id so any late `extNotification` from the + // dying child can't leak into the early-event buffer for a + // future load/resume of the same persisted session id. + info.client.markSessionClosed(sid); + if (defaultEntry === sessEntry) defaultEntry = undefined; sessEntry.events.close(); } }); - channelExitCleanups.add(exitCleanup); - void exitCleanup.then( - () => channelExitCleanups.delete(exitCleanup), - () => channelExitCleanups.delete(exitCleanup), - ); // Initialize handshake. The channel is already in // `aliveChannels` and the `channel.exited` handler above is @@ -6056,11 +5917,6 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { throw new Error('AcpSessionBridge is shutting down'); } const workspaceKey = resolveWorkspaceKey(req.workspaceCwd); - const crashRecovery = crashRecoveries.get(req.sessionId); - if (crashRecovery) await crashRecovery; - if (shuttingDown) { - throw new Error('AcpSessionBridge is shutting down'); - } if ( req.approvalMode !== undefined && !KNOWN_APPROVAL_MODES.has(req.approvalMode) @@ -11386,19 +11242,6 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { shuttingDown = true; cancelIdleTimer(); stopSessionReaper(); - const lifecycleEntries = Array.from(byId.values()); - for (const entry of lifecycleEntries) { - telemetry.metrics?.sessionLifecycle('die'); - emitSessionLifecycle({ - type: 'removed', - sessionId: entry.sessionId, - workspaceCwd: entry.workspaceCwd, - reason: shutdownReason, - }); - } - // Let an already-observed child exit claim its sessions before the - // shutdown snapshot labels remaining prompts as daemon_shutdown. - await Promise.resolve(); const entries = Array.from(byId.values()); // Snapshot every alive channel (typically 1; up to 2 during a // `killSession`-then-`spawnOrAttach` overlap) — entries are @@ -11418,10 +11261,6 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // `requestPermission` callers unwind. Each `forgetSession` // settles all matching pending as session_closed; the bridge's // per-entry index gets cleared alongside. - const shutdownTurnResults: Array<{ - entry: SessionEntry; - turnResults: TurnResultRecordPayload[]; - }> = []; for (const e of entries) { permissionMediator.forgetSession(e.sessionId); e.pendingPermissionIds.clear(); @@ -11437,14 +11276,20 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { // `byId` (above), so the handler's `byId.get(...)` is undefined // and the automatic publish wouldn't fire. for (const e of entries) { + telemetry.metrics?.sessionLifecycle('die'); + emitSessionLifecycle({ + type: 'removed', + sessionId: e.sessionId, + workspaceCwd: e.workspaceCwd, + reason: shutdownReason, + }); // DAEMON-002/005: pending prompts owe their formal terminal // before the bus closes. - const turnResults = flushPromptTerminals( + flushPromptTerminals( e, 'daemon_shutdown', 'daemon shut down before the prompt completed', ); - shutdownTurnResults.push({ entry: e, turnResults }); try { e.events.publish({ type: 'session_died', @@ -11490,20 +11335,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { ...inFlightRestoreAwaits, inFlightChannelAwait, ]); - const cleanupResults = await Promise.allSettled(channelExitCleanups); - await Promise.all( - shutdownTurnResults.map(({ entry, turnResults }) => - persistTerminalResultsAfterChannelExit( - entry, - runtimeBaseDir, - turnResults, - ), - ), - ); - const teardownFailures = [ - ...teardownResults, - ...cleanupResults, - ].flatMap((result) => + const teardownFailures = teardownResults.flatMap((result) => result.status === 'rejected' ? [result.reason] : [], ); if (teardownFailures.length === 1) throw teardownFailures[0]; diff --git a/packages/acp-bridge/src/bridgeOptions.ts b/packages/acp-bridge/src/bridgeOptions.ts index e3d7f9e1a33..af4235f6859 100644 --- a/packages/acp-bridge/src/bridgeOptions.ts +++ b/packages/acp-bridge/src/bridgeOptions.ts @@ -176,13 +176,6 @@ export interface BridgeTelemetry { * strictly-required field. See per-field JSDoc for caller contract. */ export interface BridgeOptions { - /** - * Runtime output root owned by this workspace bridge. Used only for - * transcript recovery after the ACP child process has already exited. - * Production callers with per-workspace runtimes must pass the same root - * supplied to the child through `QWEN_RUNTIME_DIR`. - */ - runtimeBaseDir?: string; /** * `single` shares one session per workspace across HTTP * clients (live-collaboration default); `thread` gives each `spawnOrAttach` diff --git a/packages/cli/src/serve/run-qwen-serve.ts b/packages/cli/src/serve/run-qwen-serve.ts index 23b5fe79c36..dad1fbe4830 100644 --- a/packages/cli/src/serve/run-qwen-serve.ts +++ b/packages/cli/src/serve/run-qwen-serve.ts @@ -4082,7 +4082,6 @@ async function runQwenServeImpl( const bridge = deps.bridge ?? runtime.createAcpSessionBridge({ - runtimeBaseDir: primarySessionRuntimeBaseDir, // Reverse tool channel: let `BridgeClient.extMethod` reach the WS // connection that hosts a named client MCP server (#5626). clientMcpSender: clientMcpSenderRegistry.lookup, @@ -4489,7 +4488,6 @@ async function runQwenServeImpl( ), }); const secondaryBridge = runtime.createAcpSessionBridge({ - runtimeBaseDir: secondaryEnv.sessionRuntimeBaseDir, clientMcpSender: secondaryClientMcpSenderRegistry.lookup, onCreateSubSession: secondarySubSessionLauncher.launch, onChannelDelivery: createBoundChannelDeliveryHandler( @@ -5046,7 +5044,6 @@ async function runQwenServeImpl( let wsBridge: ReturnType; try { wsBridge = runtime.createAcpSessionBridge({ - runtimeBaseDir: wsEnv.sessionRuntimeBaseDir, clientMcpSender: wsClientMcpRegistry.lookup, onCreateSubSession: wsSubSessionLauncher.launch, onChannelDelivery: createBoundChannelDeliveryHandler( From 334af7940d5316e56a76b1e53f55e5a4d27abc0a Mon Sep 17 00:00:00 2001 From: hit_aran Date: Thu, 13 Aug 2026 10:56:35 +0800 Subject: [PATCH 25/25] fix(serve): unblock force kill and keep dispatched results single-sourced A forced kill could be preempted when strict queued-terminal persistence failed, leaving the child running, and an errored dispatched turn could append a thin bridge error record over the child's persisted main answer. Force kill now converges after a persistence failure while close keeps the strict retry contract, and dispatched terminals are written only by the owning child. Docs now state the bounded durability boundary: persistence across restarts requires successful recording, and rewind with recording disabled does not retain historical promptIds. --- docs/design/daemon-turn-status-endpoint.md | 11 +- docs/developers/qwen-serve-protocol.md | 2 +- packages/acp-bridge/src/bridge.test.ts | 233 +++++++++++++-------- packages/acp-bridge/src/bridge.ts | 21 +- packages/acp-bridge/src/status.ts | 5 +- 5 files changed, 168 insertions(+), 104 deletions(-) diff --git a/docs/design/daemon-turn-status-endpoint.md b/docs/design/daemon-turn-status-endpoint.md index 6f645ea6fd4..4b4d7279968 100644 --- a/docs/design/daemon-turn-status-endpoint.md +++ b/docs/design/daemon-turn-status-endpoint.md @@ -88,8 +88,8 @@ the corresponding value was truncated. ## Persistence and the terminal overlay -Settled outcomes survive daemon restarts by appending one -`turn_result` system record to the EXISTING session transcript JSONL +Settled outcomes that the owning session successfully records survive normal +daemon restarts by appending one `turn_result` system record to the EXISTING session transcript JSONL (`/chats/.jsonl`) through the existing `ChatRecordingService` append path — no new files, no new write machinery: @@ -114,6 +114,10 @@ Settled outcomes survive daemon restarts by appending one - Durable settled results require chat recording to be enabled for the session. Live queue state and the recent terminal overlay remain available while the daemon session is resident even when recording is unavailable. +- This endpoint is a bounded turn-status lookup, not an exactly-once result + store. An unexpected child exit before its record is appended, daemon hard + stop, disabled recording, or permanent storage failure does not gain a + cross-restart durability guarantee from the bridge. Reads go through the `qwen/control/session/turn_status` ext-method on the owning ACP child: it flushes the recording service (so a just-settled turn @@ -159,6 +163,9 @@ for a prompt admitted straight to running). daemon turn, or recording disabled/failed) can still return recent formal outcomes from the live daemon overlay. After restart or overlay eviction, an outcome that was never persisted yields `idle` / `prompt_not_found`. +- Rewind clears the process-local terminal overlay and then follows the + child's persisted active transcript branch. With recording disabled or + failed, historical promptIds are therefore not retained across rewind. - Removing either a queued or running prompt immediately publishes one authoritative `cancelled` terminal and makes it pollable. Later agent settlement or teardown cannot replace that outcome. diff --git a/docs/developers/qwen-serve-protocol.md b/docs/developers/qwen-serve-protocol.md index 3de87cd5e31..242dcfec1e9 100644 --- a/docs/developers/qwen-serve-protocol.md +++ b/docs/developers/qwen-serve-protocol.md @@ -261,7 +261,7 @@ registry. Clients **must** gate UI off `features`, not off `mode` (per design `session_status` advertises `GET /session/:id/status`, the live bridge summary for a single session by id. In addition to `clientCount` and `hasActivePrompt`, live sessions expose `isWaitingForPermission`, `isWaitingForUserQuestion`, `pendingInteractionCount`, and a retained `turnError` after a failed turn. The error clears when the next prompt actually starts. Both the single-session status response and workspace session lists include `turnError` and `pendingInteractions`: render-ready permission actions or `ask_user_question` questions plus the `requestId` and selectable options required by the existing permission vote routes. Each user question has an `answerKey`; vote with `answers`, for example `{ "0": "Polling" }`, keyed by that value. Persisted-only sessions omit runtime state because no runtime exists. Older daemons return `404`; pre-flight this tag before polling a single session's status instead of scanning the full session list. -`session_turn_status` advertises `GET /session/:id/turns/current` and `GET /session/:id/turns/:promptId`. The current route returns the running turn, queued FIFO head, latest settled outcome, or `{ "state": "idle" }`; the prompt-specific route returns that prompt's live or persisted outcome, including `resultText` for the final main answer shown to the user when available. A result exceeding the bounded response size carries `resultTruncated: true` and `resultCode: "RESULT_TEXT_TRUNCATED"`; consumers that require a complete answer must not deliver that result. States are `idle`, `queued`, `running`, `completed`, `cancelled`, or `error`. A supported prompt-specific lookup with no matching turn returns `404 prompt_not_found`; clients must pre-flight this tag to distinguish that result from an older daemon that lacks the routes. +`session_turn_status` advertises `GET /session/:id/turns/current` and `GET /session/:id/turns/:promptId`. The current route returns the running turn, queued FIFO head, latest settled outcome, or `{ "state": "idle" }`; the prompt-specific route returns that prompt's bounded live or persisted outcome, including `resultText` for the final main answer shown to the user when available. Persisted outcomes survive a normal daemon restart only when session recording successfully appended the result; the live overlay is process-local, and the endpoint is not an exactly-once result store. Rewind follows the persisted active transcript branch and clears the process-local overlay, so recording-disabled or failed sessions do not retain historical promptIds across rewind. A result exceeding the bounded response size carries `resultTruncated: true` and `resultCode: "RESULT_TEXT_TRUNCATED"`; consumers that require a complete answer must not deliver that result. States are `idle`, `queued`, `running`, `completed`, `cancelled`, or `error`. A supported prompt-specific lookup with no matching turn returns `404 prompt_not_found`; clients must pre-flight this tag to distinguish that result from an older daemon that lacks the routes. `session_info` advertises `GET /workspace/:id/session-info` and its `/workspaces/:workspace/session-info` twin. The response aggregates persisted active and archived session counts without hydrating list metadata. It is an explicit O(n) disk scan and must not be polled; clients should treat `truncated: true` as a lower-bound result. diff --git a/packages/acp-bridge/src/bridge.test.ts b/packages/acp-bridge/src/bridge.test.ts index 52f56ba58d7..2c131d90022 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -9867,6 +9867,19 @@ describe('createAcpSessionBridge', () => { promptImpl: async () => { throw new Error('forward boom'); }, + extMethodImpl: (method) => + method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus + ? { + v: 1, + sessionId: SESS_A, + turnResult: { + promptId: 'prompt-forward-failed', + state: 'error', + endedAt: 2, + resultText: 'partial visible answer', + }, + } + : {}, }); const cancelSpy = vi.spyOn(h.agent, 'cancel'); const factory: ChannelFactory = async () => h.channel; @@ -9904,15 +9917,21 @@ describe('createAcpSessionBridge', () => { const evt = await peerCancel; expect(evt.type).toBe('prompt_cancelled'); expect((evt.data as { reason?: string }).reason).toBe('forward_failed'); - expect(h.agent.extMethodCalls).toContainEqual({ - method: SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, - params: { - sessionId: session.sessionId, - turnResult: expect.objectContaining({ - promptId: 'prompt-forward-failed', - state: 'error', - }), - }, + expect( + h.agent.extMethodCalls.filter( + ({ method }) => + method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + ), + ).toHaveLength(0); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-forward-failed', + ), + ).resolves.toMatchObject({ + state: 'error', + resultText: 'partial visible answer', }); // A rejected prompt request has already settled in the child. Sending a // late session-scoped cancel here could hit the queued successor. @@ -12600,88 +12619,124 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); - it.each(['close', 'kill'] as const)( - 'keeps the session live and retries newly cancelled persistence before %s', - async (operation) => { - let persistAvailable = false; - const activePrompt = deferred(); - const handle = makeChannel({ - promptImpl: () => activePrompt.promise, - extMethodImpl: (method) => { - if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { - if (!persistAvailable) throw new Error('writer unavailable'); - return {}; - } - return method === SERVE_CONTROL_EXT_METHODS.sessionClose - ? { closed: true } - : {}; - }, - }); - const bridge = makeBridge({ - channelFactory: async () => handle.channel, - }); - const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); - const p1 = bridge.sendPrompt( - session.sessionId, - { - sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'active' }], - }, - undefined, - { promptId: 'prompt-a' }, - ); - await vi.waitFor(() => - expect(handle.agent.promptCalls).toHaveLength(1), - ); - const p2 = bridge.sendPrompt( - session.sessionId, - { - sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'queued' }], - }, - undefined, - { promptId: 'prompt-b' }, - ); - p2.catch(() => {}); + it('keeps the session live and retries newly cancelled persistence before close', async () => { + let persistAvailable = false; + const activePrompt = deferred(); + const handle = makeChannel({ + promptImpl: () => activePrompt.promise, + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + if (!persistAvailable) throw new Error('writer unavailable'); + return {}; + } + return method === SERVE_CONTROL_EXT_METHODS.sessionClose + ? { closed: true } + : {}; + }, + }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const p1 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'active' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(1)); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-b' }, + ); + p2.catch(() => {}); - await expect( - operation === 'close' - ? bridge.closeSession(session.sessionId) - : bridge.killSession(session.sessionId), - ).rejects.toThrow(); - expect(bridge.sessionCount).toBe(1); - expect(handle.killed).toBe(false); - expect( - handle.agent.extMethodCalls.filter( - ({ method }) => method === SERVE_CONTROL_EXT_METHODS.sessionClose, - ), - ).toHaveLength(0); - await expect( - bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-b'), - ).resolves.toMatchObject({ - state: 'cancelled', - stopReason: 'cancelled', - }); + await expect(bridge.closeSession(session.sessionId)).rejects.toThrow(); + expect(bridge.sessionCount).toBe(1); + expect(handle.killed).toBe(false); + expect( + handle.agent.extMethodCalls.filter( + ({ method }) => method === SERVE_CONTROL_EXT_METHODS.sessionClose, + ), + ).toHaveLength(0); + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-b'), + ).resolves.toMatchObject({ + state: 'cancelled', + stopReason: 'cancelled', + }); - activePrompt.resolve({ stopReason: 'end_turn' }); - await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); - await expect(p2).rejects.toMatchObject({ name: 'AbortError' }); - persistAvailable = true; - await expect( - operation === 'close' - ? bridge.closeSession(session.sessionId) - : bridge.killSession(session.sessionId), - ).resolves.toBe(operation === 'close' ? undefined : true); - expect( - handle.agent.extMethodCalls.filter( - ({ method }) => - method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, - ), - ).toHaveLength(2); - expect(bridge.sessionCount).toBe(0); - await bridge.shutdown(); - }, - ); + activePrompt.resolve({ stopReason: 'end_turn' }); + await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); + await expect(p2).rejects.toMatchObject({ name: 'AbortError' }); + persistAvailable = true; + await expect( + bridge.closeSession(session.sessionId), + ).resolves.toBeUndefined(); + expect( + handle.agent.extMethodCalls.filter( + ({ method }) => + method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + ), + ).toHaveLength(2); + expect(bridge.sessionCount).toBe(0); + await bridge.shutdown(); + }); + + it('force-kills the channel when newly cancelled persistence fails before kill', async () => { + const activePrompt = deferred(); + const handle = makeChannel({ + promptImpl: () => activePrompt.promise, + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + throw new Error('writer unavailable'); + } + return {}; + }, + }); + const bridge = makeBridge({ channelFactory: async () => handle.channel }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const running = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'active' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + running.catch(() => {}); + await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(1)); + const queued = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued' }], + }, + undefined, + { promptId: 'prompt-b' }, + ); + queued.catch(() => {}); + + const outcome = await bridge.killSession(session.sessionId).then( + (value) => ({ value }), + (error: unknown) => ({ error }), + ); + activePrompt.resolve({ stopReason: 'end_turn' }); + await Promise.allSettled([running, queued]); + await bridge.shutdown(); + + expect(outcome).toEqual({ value: true }); + expect(handle.killed).toBe(true); + }); it.each(['close', 'kill'] as const)( 'does not leave the session unclosable after queued persistence permanently fails before %s', diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 7670f9117ab..edfebf9b465 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -1761,7 +1761,6 @@ function publishPromptTerminal( entry: SessionEntry, pendingEntry: PendingPromptEntry, terminal: PromptTerminal, - options?: { persistIfDispatched?: boolean }, ): void { if (pendingEntry.terminalPublished) { // Dedup here is the designed steady state, not an anomaly: deadline @@ -1776,7 +1775,7 @@ function publishPromptTerminal( pendingEntry.terminalPublished = true; const status = rememberTerminalTurnStatus(entry, pendingEntry, terminal); if ( - (!pendingEntry.dispatched || options?.persistIfDispatched === true) && + !pendingEntry.dispatched && pendingEntry.terminalPersistence === undefined ) { startStrictTerminalPersistence( @@ -7973,12 +7972,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { publishPromptTerminal(entry, pendingEntry, { kind: 'cancelled' }); return; } - publishPromptTerminal( - entry, - pendingEntry, - { kind: 'error', err }, - { persistIfDispatched: true }, - ); + publishPromptTerminal(entry, pendingEntry, { kind: 'error', err }); }, ); // Tail swallows failures so subsequent prompts still run. The caller @@ -9862,8 +9856,8 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { if (queuedHead) return liveTurnStatus(sessionId, queuedHead); } - // Settled state is durable: read the agent's persisted `turn_result` - // records. This survives daemon restarts (the pending list does not). + // Read any persisted `turn_result` records from the agent. Persisted + // records survive daemon restarts (the pending list does not). const terminalBeforeRead = promptId !== undefined ? entry.terminalTurnStatuses.get(promptId) @@ -11060,6 +11054,13 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { try { await cancelQueuedPromptsBeforeTeardown(entry); } catch (error) { + if (ci) { + await killChannelWithLog( + ci, + `force kill session ${JSON.stringify(sessionId)} after queued terminal persistence failed`, + ); + return true; + } entry.closing = false; throw error; } diff --git a/packages/acp-bridge/src/status.ts b/packages/acp-bridge/src/status.ts index 67c01c4e183..98bf8f09dce 100644 --- a/packages/acp-bridge/src/status.ts +++ b/packages/acp-bridge/src/status.ts @@ -186,8 +186,9 @@ export const SERVE_CONTROL_EXT_METHODS = { /** * Read a settled turn's persisted `turn_result` record from the session * transcript. Live queued/running state comes from the bridge's pending - * prompt list instead; this is the durable source for completed / - * cancelled / error outcomes. Params: `{ sessionId, promptId? }`; result: + * prompt list instead; this reads persisted completed / cancelled / error + * outcomes when recording succeeded. Params: `{ sessionId, promptId? }`; + * result: * `{ v: 1, sessionId, turnResult: TurnResultRecordPayload | null }` where * `null` means no matching settled turn was found. */