diff --git a/docs/design/daemon-turn-status-endpoint.md b/docs/design/daemon-turn-status-endpoint.md new file mode 100644 index 00000000000..4b4d7279968 --- /dev/null +++ b/docs/design/daemon-turn-status-endpoint.md @@ -0,0 +1,179 @@ +# 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 + 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. + +## Response shape + +```json +{ + "sessionId": "session-id", + "state": "completed", + "promptId": "prompt-id", + "promptText": "Summarize the build failure", + "startedAt": 1786152000000, + "endedAt": 1786152012000, + "stopReason": "end_turn", + "resultText": "The build failed because the route catalog assertion is stale." +} +``` + +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`. A truncated result +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 + 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` 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. 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. 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 + 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. + +## Persistence and the terminal overlay + +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: + +- `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 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 + 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. +- 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 +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 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 has a fixed limit of 64 entries, +independently of `eventRingSize`; eviction only removes the transient overlay, +so persisted records remain queryable. + +## 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 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). + +## 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) 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. +- 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. diff --git a/docs/developers/qwen-serve-protocol.md b/docs/developers/qwen-serve-protocol.md index 03070d181aa..c283761f00c 100644 --- a/docs/developers/qwen-serve-protocol.md +++ b/docs/developers/qwen-serve-protocol.md @@ -189,7 +189,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', @@ -262,6 +262,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 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. `session_approval_mode_control`, `workspace_tool_toggle`, `workspace_skill_toggle`, `workspace_skill_batch_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. @@ -1141,6 +1143,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` @@ -2404,7 +2407,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`, `GET /session/:id/mid-turn-messages`, `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`, `GET /session/:id/mid-turn-messages`, `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/docs/plans/daemon-turn-status-blocker-fixes.md b/docs/plans/daemon-turn-status-blocker-fixes.md new file mode 100644 index 00000000000..004a392adf8 --- /dev/null +++ b/docs/plans/daemon-turn-status-blocker-fixes.md @@ -0,0 +1,175 @@ +# 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:** Make exact `sessionId + promptId` polling reliable for every active-history turn inside the existing bounded transcript scan window. + +**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, real daemon integration tests. + +## Global Constraints + +- 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. +- 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: Fix deterministic capability CI failure + +**Files:** + +- Modify: `integration-tests/cli/qwen-serve-routes.test.ts` + +**Interfaces:** + +- Consumes: `SERVE_CAPABILITY_REGISTRY` order. +- Produces: integration baseline containing `session_turn_status` immediately after `session_status`. + +- [ ] 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: 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: 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 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 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: `Session.test.ts` and `MessageRewriteMiddleware.test.ts`. + +**Interfaces:** + +- 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 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 6: Keep fork and rewind identities consistent + +**Files:** + +- Modify: `packages/core/src/services/sessionService.ts` +- Modify: `packages/acp-bridge/src/bridge.ts` +- Test: `sessionService.test.ts` and `bridge.test.ts`. + +**Interfaces:** + +- 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 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 7: Full verification and review + +**Files:** + +- Review every changed and untracked file. + +**Interfaces:** + +- Consumes: all green task groups. +- Produces: a verified commit and non-force push after explicit user authorization. + +- [ ] 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. + +### 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/integration-tests/cli/qwen-serve-routes.test.ts b/integration-tests/cli/qwen-serve-routes.test.ts index be731880170..4f84cb8c0b1 100644 --- a/integration-tests/cli/qwen-serve-routes.test.ts +++ b/integration-tests/cli/qwen-serve-routes.test.ts @@ -349,6 +349,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 19e26af6d03..d0b1010010b 100644 --- a/integration-tests/cli/qwen-serve-streaming.test.ts +++ b/integration-tests/cli/qwen-serve-streaming.test.ts @@ -48,7 +48,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 { @@ -165,10 +168,123 @@ let pendingReadSentinel = ''; let pendingExternalWritePath = ''; let pendingExternalWriteMarker = ''; let pendingExternalWriteSentinel = ''; +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( + options: { promptDeadlineMs?: number } = {}, +): 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, + ...(options.promptDeadlineMs !== undefined + ? ['--prompt-deadline-ms', String(options.promptDeadlineMs)] + : []), + ], + { + 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"'); @@ -194,6 +310,76 @@ 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 (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: [ @@ -266,92 +452,18 @@ 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', - }, - }, + writeFileSync( + path.join(workspaceDir, 'turn-final-answer-boundary.txt'), + '42', ); - 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 }); @@ -389,6 +501,133 @@ async function* sseFrames( yield* parseSseStream(res.body!, opts.signal); } +describePOSIX('qwen serve — turn result polling', () => { + it('returns the completed turn result by promptId', async () => { + const session = await client.createOrAttachSession({ + workspaceCwd: workspaceDir, + }); + + try { + const accepted = asAccepted( + await client.promptNonBlocking(session.sessionId, { + prompt: [ + { + type: 'text', + text: 'return the fake response for turn polling', + }, + ], + }), + ); + expect(accepted).toBeDefined(); + if (!accepted) return; + + await expect + .poll( + async () => { + const response = await fetch( + `${base}/session/${session.sessionId}/turns/${accepted.promptId}`, + { headers: { Authorization: `Bearer ${TOKEN}` } }, + ); + if (!response.ok) return { status: response.status }; + return response.json(); + }, + { timeout: 30_000 }, + ) + .toMatchObject({ + sessionId: session.sessionId, + promptId: accepted.promptId, + state: 'completed', + resultText: 'fake response complete', + }); + } finally { + await client.cancel(session.sessionId).catch(() => undefined); + 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)', () => { it('publishes session_died after the qwen --acp child is SIGKILL-ed', async () => { const session = await client.createOrAttachSession({ @@ -1016,3 +1255,398 @@ describePOSIX('qwen serve — daemon Todo Stop Guard replay', () => { ); }, 60_000); }); + +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, + 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('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; + 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 5053f187ba9..886226843ba 100644 --- a/packages/acp-bridge/src/bridge.test.ts +++ b/packages/acp-bridge/src/bridge.test.ts @@ -97,6 +97,7 @@ import { ShellExecutionService, stableSessionArtifactId, ToolNames, + TURN_RESULT_TEXT_MAX_CHARS, } from '@qwen-code/qwen-code-core'; import { FakeAgent, @@ -3925,6 +3926,84 @@ describe('createAcpSessionBridge', () => { await bridge.shutdown(); }); + 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, params) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnStatus) { + 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: [], + }; + } + return {}; + }, + }).channel, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + 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-a', + ), + ).resolves.toMatchObject({ state: 'completed' }); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-before-rewind-b', + ), + ).resolves.toMatchObject({ state: 'completed' }); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-before-rewind-c', + ), + ).resolves.toBeUndefined(); + await bridge.shutdown(); + }); + it('keeps durable artifacts when rewind cannot rebuild an artifact snapshot', async () => { const persistedSnapshots: unknown[] = []; const bridge = makeBridge({ @@ -11006,6 +11085,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; @@ -11031,7 +11123,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. @@ -11040,6 +11135,22 @@ 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.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. expect(cancelSpy).not.toHaveBeenCalled(); @@ -11376,9 +11487,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, { @@ -11858,12 +11969,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, @@ -11954,7 +12065,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(() => { @@ -11977,7 +12091,7 @@ describe('createAcpSessionBridge', () => { stderrSpy.mockRestore(); } - const again = bridge.removePendingPrompt( + const again = await bridge.removePendingPrompt( session.sessionId, 'nonexistent', ); @@ -12106,7 +12220,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. @@ -12164,9 +12281,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, @@ -12185,11 +12302,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', () => { @@ -12200,168 +12317,1178 @@ describe('createAcpSessionBridge', () => { }); }); - describe('prompt terminal exactly-once (DAEMON-002/003/004/005)', () => { - /** All formal turn terminals published for one promptId. */ - const terminalsFor = (events: BridgeEvent[], promptId: string) => - events.filter( - (e) => - (e.type === 'turn_complete' || e.type === 'turn_error') && - e.promptId === promptId, - ); - - /** Fake agent: prompts whose first text block is 'wedge' hang forever - * (agent ignores cancel — FakeAgent's cancel only records the call). */ - const wedgeChannel = () => - makeChannel({ - promptImpl: async (req: PromptRequest) => { - if ((req.prompt[0] as { text?: string }).text === 'wedge') { - await new Promise(() => {}); - } - return { stopReason: 'end_turn' } as PromptResponse; - }, - }); - - const subscribe = ( - bridge: ReturnType, - sessionId: string, - events: BridgeEvent[], - ) => { - const sub = (async () => { - for await (const ev of bridge.subscribeEvents(sessionId)) { - events.push(ev); - } - })(); - sub.catch(() => {}); - return sub; - }; - - it('publishes exactly one cancelled terminal when a queued prompt is removed (DAEMON-004)', async () => { - let releaseFirst: (() => void) | undefined; - const firstDone = new Promise((r) => { - releaseFirst = r; + 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 (req: PromptRequest) => { - if ((req.prompt[0] as { text?: string }).text === 'blocker') { - await firstDone; - } + promptImpl: async () => { + await turnGate; return { stopReason: 'end_turn' } as PromptResponse; }, }); - const bridge = makeBridge({ channelFactory: async () => handle.channel }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); - const events: BridgeEvent[] = []; - subscribe(bridge, session.sessionId, events); - - const p1 = bridge.sendPrompt( + const promptPromise = bridge.sendPrompt( session.sessionId, { sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'blocker' }], + prompt: [{ type: 'text', text: 'live turn' }], }, undefined, - { promptId: 'prompt-a' }, + { promptId: 'prompt-live' }, ); - const p2 = bridge.sendPrompt( + + 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: 'queued victim' }], + prompt: [{ type: 'text', text: longText }], }, undefined, - { promptId: 'prompt-b' }, + { promptId: 'prompt-long' }, ); - await new Promise((r) => setTimeout(r, 20)); - expect(bridge.removePendingPrompt(session.sessionId, 'prompt-b')).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(() => { - const terms = terminalsFor(events, 'prompt-b'); - expect(terms).toHaveLength(1); - expect(terms[0]?.type).toBe('turn_complete'); - expect((terms[0]?.data as { stopReason?: string }).stopReason).toBe( - 'cancelled', - ); + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(1); }); - // The pending_prompt_completed{removed} bookkeeping event is unchanged. - expect( - events.some( - (e) => - e.type === 'pending_prompt_completed' && - (e.data as { state?: string }).state === 'removed', - ), - ).toBe(true); - releaseFirst!(); - await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); - // Caller-facing rejection semantics are unchanged. - await expect(p2).rejects.toMatchObject({ name: 'AbortError' }); - // B's FIFO node reached the head and threw AbortError — the latch - // must have swallowed the would-be second terminal. - await new Promise((r) => setTimeout(r, 20)); - expect(terminalsFor(events, 'prompt-b')).toHaveLength(1); - expect(terminalsFor(events, 'prompt-a')).toHaveLength(1); - expect(terminalsFor(events, 'prompt-a')[0]?.type).toBe('turn_complete'); + 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('publishes a deadline turn_error, unlocks the FIFO, and clears active state when the agent wedges (DAEMON-003)', async () => { - let markFollowupStarted!: () => void; - const followupStarted = new Promise((resolve) => { - markFollowupStarted = resolve; + it('rejects a foreign clientId like /prompt does', async () => { + const bridge = makeBridge({ + channelFactory: async () => makeChannel().channel, }); - let releaseFollowup!: () => void; - const followupGate = new Promise((resolve) => { - releaseFollowup = resolve; + 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 (request) => { - const text = (request.prompt[0] as { text?: string }).text; - if (text === 'wedge') { - return new Promise(() => {}); + promptImpl: async (req: PromptRequest) => { + if ((req.prompt[0] as { text?: string }).text === 'blocking') { + await firstGate; } - markFollowupStarted(); - await followupGate; - return { stopReason: 'end_turn' }; + return { stopReason: 'end_turn' } as PromptResponse; }, - cancelImpl: () => new Promise(() => {}), }); - const bridge = makeBridge({ channelFactory: async () => handle.channel }); + const bridge = makeBridge({ + channelFactory: async () => handle.channel, + }); const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); - const events: BridgeEvent[] = []; - subscribe(bridge, session.sessionId, events); - const p1 = bridge.sendPrompt( session.sessionId, { sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'wedge' }], + prompt: [{ type: 'text', text: 'blocking' }], }, undefined, - { promptId: 'prompt-wedged', deadlineMs: 50 }, + { promptId: 'prompt-first' }, + ); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'waiting' }], + }, + undefined, + { promptId: 'prompt-second' }, ); - await expect(p1).rejects.toBeInstanceOf(PromptDeadlineExceededError); await vi.waitFor(() => { - const terms = terminalsFor(events, 'prompt-wedged'); - expect(terms).toHaveLength(1); - expect(terms[0]?.type).toBe('turn_error'); - expect((terms[0]?.data as { code?: string }).code).toBe( - 'prompt_deadline_exceeded', - ); + expect(bridge.getPendingPrompts(session.sessionId)).toHaveLength(2); }); - // Active-prompt bookkeeping cleared even though the agent never - // settled — otherwise the reaper would skip this session forever. - expect(bridge.getSessionSummary(session.sessionId).hasActivePrompt).toBe( + + // 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('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('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' }), + 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('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('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) => { + 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); + }); + await expect( + bridge.removePendingPrompt(session.sessionId, 'prompt-remove-queued'), + ).resolves.toEqual({ removed: true }); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-remove-queued', + ), + ).resolves.toMatchObject({ + state: 'cancelled', + stopReason: 'cancelled', + }); + + await expect( + bridge.removePendingPrompt(session.sessionId, 'prompt-remove-running'), + ).resolves.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('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('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({ + 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', + }); + 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 independently of 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: 100_000, + }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + + for (let index = 0; index < 65; index++) { + const promptId = `prompt-${index}`; + await bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: promptId }], + }, + undefined, + { promptId }, + ); + } + + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-0'), + ).resolves.toBeUndefined(); + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-1'), + ).resolves.toMatchObject({ state: 'completed' }); + await expect( + bridge.getSessionTurnStatus(session.sessionId, undefined, 'prompt-64'), + ).resolves.toMatchObject({ state: 'completed' }); + 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) => + events.filter( + (e) => + (e.type === 'turn_complete' || e.type === 'turn_error') && + e.promptId === promptId, + ); + + /** Fake agent: prompts whose first text block is 'wedge' hang forever + * (agent ignores cancel — FakeAgent's cancel only records the call). */ + const wedgeChannel = () => + makeChannel({ + promptImpl: async (req: PromptRequest) => { + if ((req.prompt[0] as { text?: string }).text === 'wedge') { + await new Promise(() => {}); + } + return { stopReason: 'end_turn' } as PromptResponse; + }, + 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 = ( + bridge: ReturnType, + sessionId: string, + events: BridgeEvent[], + ) => { + const sub = (async () => { + for await (const ev of bridge.subscribeEvents(sessionId)) { + events.push(ev); + } + })(); + sub.catch(() => {}); + return sub; + }; + + it('publishes exactly one cancelled terminal when a queued prompt is removed (DAEMON-004)', async () => { + let releaseFirst: (() => void) | undefined; + const firstDone = new Promise((r) => { + releaseFirst = r; + }); + const handle = makeChannel({ + promptImpl: async (req: PromptRequest) => { + if ((req.prompt[0] as { text?: string }).text === 'blocker') { + await firstDone; + } + return { stopReason: 'end_turn' } as PromptResponse; + }, + }); + const bridge = makeBridge({ channelFactory: async () => handle.channel }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const events: BridgeEvent[] = []; + subscribe(bridge, session.sessionId, events); + + const p1 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'blocker' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued victim' }], + }, + undefined, + { promptId: 'prompt-b' }, + ); + await new Promise((r) => setTimeout(r, 20)); + + 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(() => { + const terms = terminalsFor(events, 'prompt-b'); + expect(terms).toHaveLength(1); + expect(terms[0]?.type).toBe('turn_complete'); + expect((terms[0]?.data as { stopReason?: string }).stopReason).toBe( + 'cancelled', + ); + }); + // The pending_prompt_completed{removed} bookkeeping event is unchanged. + expect( + events.some( + (e) => + e.type === 'pending_prompt_completed' && + (e.data as { state?: string }).state === 'removed', + ), + ).toBe(true); + + releaseFirst!(); + await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); + // Caller-facing rejection semantics are unchanged. + await expect(p2).rejects.toMatchObject({ name: 'AbortError' }); + // B's FIFO node reached the head and threw AbortError — the latch + // must have swallowed the would-be second terminal. + await new Promise((r) => setTimeout(r, 20)); + expect(terminalsFor(events, 'prompt-b')).toHaveLength(1); + expect(terminalsFor(events, 'prompt-a')).toHaveLength(1); + expect(terminalsFor(events, 'prompt-a')[0]?.type).toBe('turn_complete'); + await bridge.shutdown(); + }); + + it('publishes a deadline turn_error, unlocks the FIFO, and clears active state when the agent wedges (DAEMON-003)', async () => { + let markFollowupStarted!: () => void; + const followupStarted = new Promise((resolve) => { + markFollowupStarted = resolve; + }); + let releaseFollowup!: () => void; + const followupGate = new Promise((resolve) => { + releaseFollowup = resolve; + }); + const handle = makeChannel({ + promptImpl: async (request) => { + const text = (request.prompt[0] as { text?: string }).text; + if (text === 'wedge') { + return new Promise(() => {}); + } + markFollowupStarted(); + await followupGate; + return { stopReason: 'end_turn' }; + }, + cancelImpl: () => new Promise(() => {}), + }); + const bridge = makeBridge({ channelFactory: async () => handle.channel }); + const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); + const events: BridgeEvent[] = []; + subscribe(bridge, session.sessionId, events); + + const p1 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'wedge' }], + }, + undefined, + { promptId: 'prompt-wedged', deadlineMs: 50 }, + ); + await expect(p1).rejects.toBeInstanceOf(PromptDeadlineExceededError); + + await vi.waitFor(() => { + const terms = terminalsFor(events, 'prompt-wedged'); + expect(terms).toHaveLength(1); + expect(terms[0]?.type).toBe('turn_error'); + expect((terms[0]?.data as { code?: string }).code).toBe( + 'prompt_deadline_exceeded', + ); + }); + // Active-prompt bookkeeping cleared even though the agent never + // settled — otherwise the reaper would skip this session forever. + expect(bridge.getSessionSummary(session.sessionId).hasActivePrompt).toBe( false, ); // Best-effort cancel reached the (uncooperative) agent. 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, @@ -12391,6 +13518,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)); + await expect( + bridge.removePendingPrompt(session.sessionId, 'prompt-removed-wedge'), + ).resolves.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' }), @@ -12429,163 +13597,500 @@ describe('createAcpSessionBridge', () => { session.sessionId, { sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'wedge' }], + prompt: [{ type: 'text', text: 'wedge' }], + }, + undefined, + { promptId: 'prompt-head' }, + ); + p1.catch(() => {}); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'never dispatches' }], + }, + undefined, + { promptId: 'prompt-queued-deadline', deadlineMs: 50 }, + ); + p2.catch(() => {}); + + await vi.waitFor(() => { + const terms = terminalsFor(events, 'prompt-queued-deadline'); + expect(terms).toHaveLength(1); + expect(terms[0]?.type).toBe('turn_error'); + expect((terms[0]?.data as { code?: string }).code).toBe( + 'prompt_deadline_exceeded', + ); + }); + await expect( + bridge.getSessionTurnStatus( + session.sessionId, + undefined, + 'prompt-queued-deadline', + ), + ).resolves.toMatchObject({ + 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); + + // A queued prompt never ran, so its deadline terminal must not + // advertise a session-level turnError nor arm the retry path — those + // belong to the ACTIVE turn only. + expect( + bridge.getSessionSummary(session.sessionId).turnError, + ).toBeUndefined(); + + await bridge.shutdown(); + // Shutdown flushed the still-wedged head prompt exactly once, and the + // queued prompt's residual FIFO abort stayed latched. + expect(terminalsFor(events, 'prompt-queued-deadline')).toHaveLength(1); + const headTerms = terminalsFor(events, 'prompt-head'); + expect(headTerms).toHaveLength(1); + expect(headTerms[0]?.type).toBe('turn_error'); + expect((headTerms[0]?.data as { code?: string }).code).toBe( + 'daemon_shutdown', + ); + // The caller sees the same typed rejection as a running-prompt expiry + // — the pre-dispatch abort check (reached once shutdown released the + // wedged head) propagates the deadline reason instead of a generic + // AbortError. + await expect(p2).rejects.toBeInstanceOf(PromptDeadlineExceededError); + }); + + it('keeps a detached session draining until the last pending prompt settles (DAEMON-005)', async () => { + let releaseFirst: (() => void) | undefined; + const firstDone = new Promise((r) => { + releaseFirst = r; + }); + const handle = makeChannel({ + promptImpl: async (req: PromptRequest) => { + if ((req.prompt[0] as { text?: string }).text === 'blocker') { + await firstDone; + } + 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: 'blocker' }], + }, + undefined, + { promptId: 'prompt-a' }, + ); + const p2 = bridge.sendPrompt( + session.sessionId, + { + sessionId: session.sessionId, + prompt: [{ type: 'text', text: 'queued successor' }], + }, + undefined, + { promptId: 'prompt-b' }, + ); + await new Promise((r) => setTimeout(r, 20)); + + // Sole client leaves while A runs and B is queued — the session must + // keep draining instead of closing (close would abort B). + await bridge.detachClient(session.sessionId, session.clientId); + expect(bridge.getSessionSummary(session.sessionId)).toBeDefined(); + + releaseFirst!(); + await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); + // B completing proves the session survived the drain window. + await expect(p2).resolves.toEqual({ stopReason: 'end_turn' }); + // …and only then does the deferred close-on-prompt-complete fire. + await vi.waitFor(() => { + expect(() => bridge.getSessionSummary(session.sessionId)).toThrow( + SessionNotFoundError, + ); + }); + await bridge.shutdown(); + }); + + 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 }); + const events: BridgeEvent[] = []; + subscribe(bridge, session.sessionId, events); + + 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 at close' }], + }, + undefined, + { promptId: 'prompt-b' }, + ); + p2.catch(() => {}); + await new Promise((r) => setTimeout(r, 20)); + + 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); + 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); + } + 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('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-head' }, + { promptId: 'prompt-a' }, ); - p1.catch(() => {}); + await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(1)); const p2 = bridge.sendPrompt( session.sessionId, { sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'never dispatches' }], + prompt: [{ type: 'text', text: 'queued' }], }, undefined, - { promptId: 'prompt-queued-deadline', deadlineMs: 50 }, + { promptId: 'prompt-b' }, ); p2.catch(() => {}); - await vi.waitFor(() => { - const terms = terminalsFor(events, 'prompt-queued-deadline'); - expect(terms).toHaveLength(1); - expect(terms[0]?.type).toBe('turn_error'); - expect((terms[0]?.data as { code?: string }).code).toBe( - 'prompt_deadline_exceeded', - ); - }); - await new Promise((r) => setTimeout(r, 60)); - expect(terminalsFor(events, 'prompt-queued-deadline')).toHaveLength(1); + await expect(bridge.closeSession(session.sessionId)).rejects.toThrow(); + expect(bridge.sessionCount).toBe(1); + expect(handle.killed).toBe(false); expect( - bridge.getSessionSummary(session.sessionId).turnError, - ).toBeUndefined(); + 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', + }); - // A queued prompt never ran, so its deadline terminal must not - // advertise a session-level turnError nor arm the retry path — those - // belong to the ACTIVE turn only. + 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( - bridge.getSessionSummary(session.sessionId).turnError, - ).toBeUndefined(); - + handle.agent.extMethodCalls.filter( + ({ method }) => + method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord, + ), + ).toHaveLength(2); + expect(bridge.sessionCount).toBe(0); await bridge.shutdown(); - // Shutdown flushed the still-wedged head prompt exactly once, and the - // queued prompt's residual FIFO abort stayed latched. - expect(terminalsFor(events, 'prompt-queued-deadline')).toHaveLength(1); - const headTerms = terminalsFor(events, 'prompt-head'); - expect(headTerms).toHaveLength(1); - expect(headTerms[0]?.type).toBe('turn_error'); - expect((headTerms[0]?.data as { code?: string }).code).toBe( - 'daemon_shutdown', - ); - // The caller sees the same typed rejection as a running-prompt expiry - // — the pre-dispatch abort check (reached once shutdown released the - // wedged head) propagates the deadline reason instead of a generic - // AbortError. - await expect(p2).rejects.toBeInstanceOf(PromptDeadlineExceededError); }); - it('keeps a detached session draining until the last pending prompt settles (DAEMON-005)', async () => { - let releaseFirst: (() => void) | undefined; - const firstDone = new Promise((r) => { - releaseFirst = r; - }); + it('force-kills the channel when newly cancelled persistence fails before kill', async () => { + const activePrompt = deferred(); const handle = makeChannel({ - promptImpl: async (req: PromptRequest) => { - if ((req.prompt[0] as { text?: string }).text === 'blocker') { - await firstDone; + promptImpl: () => activePrompt.promise, + extMethodImpl: (method) => { + if (method === SERVE_CONTROL_EXT_METHODS.sessionTurnResultRecord) { + throw new Error('writer unavailable'); } - return { stopReason: 'end_turn' } as PromptResponse; + return {}; }, }); const bridge = makeBridge({ channelFactory: async () => handle.channel }); const session = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); - - const p1 = bridge.sendPrompt( + const running = bridge.sendPrompt( session.sessionId, { sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'blocker' }], + prompt: [{ type: 'text', text: 'active' }], }, undefined, { promptId: 'prompt-a' }, ); - const p2 = bridge.sendPrompt( + 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 successor' }], + prompt: [{ type: 'text', text: 'queued' }], }, undefined, { promptId: 'prompt-b' }, ); - await new Promise((r) => setTimeout(r, 20)); - - // Sole client leaves while A runs and B is queued — the session must - // keep draining instead of closing (close would abort B). - await bridge.detachClient(session.sessionId, session.clientId); - expect(bridge.getSessionSummary(session.sessionId)).toBeDefined(); + queued.catch(() => {}); - releaseFirst!(); - await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); - // B completing proves the session survived the drain window. - await expect(p2).resolves.toEqual({ stopReason: 'end_turn' }); - // …and only then does the deferred close-on-prompt-complete fire. - await vi.waitFor(() => { - expect(() => bridge.getSessionSummary(session.sessionId)).toThrow( - SessionNotFoundError, - ); - }); + 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('flushes error terminals for active and queued prompts before session_closed (DAEMON-005)', 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); + 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({ + 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: 'wedge' }], + prompt: [{ type: 'text', text: 'active' }], }, undefined, { promptId: 'prompt-a' }, ); - p1.catch(() => {}); + await vi.waitFor(() => expect(handle.agent.promptCalls).toHaveLength(1)); const p2 = bridge.sendPrompt( session.sessionId, { sessionId: session.sessionId, - prompt: [{ type: 'text', text: 'queued at close' }], + prompt: [{ type: 'text', text: 'queued' }], }, undefined, { promptId: 'prompt-b' }, ); p2.catch(() => {}); - await new Promise((r) => setTimeout(r, 20)); - await bridge.closeSession(session.sessionId); + 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); - 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', - ); - // 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); - } + activePrompt.resolve({ stopReason: 'end_turn' }); + await expect(p1).resolves.toEqual({ stopReason: 'end_turn' }); + await expect(p2).rejects.toMatchObject({ name: 'AbortError' }); 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 }); @@ -12604,30 +14109,35 @@ 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. - expect( + // Remove the RUNNING prompt — the wedged agent ignores the cancel, but + // removal itself is already the authoritative cancelled outcome. + 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 }); - expect(terminalsFor(events, 'prompt-removed-running')).toHaveLength(0); + ).resolves.toEqual({ removed: false }); + 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(); }); @@ -12693,9 +14203,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!(); @@ -12724,7 +14234,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 }); @@ -12755,15 +14265,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); @@ -12803,7 +14332,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); @@ -15461,7 +16990,9 @@ describe('createAcpSessionBridge', () => { if (method === SERVE_CONTROL_EXT_METHODS.sessionSource) { return { persisted: true }; } - return {}; + return method === 'qwen/control/session/close' + ? { closed: true } + : {}; }, resumeSessionImpl: () => ({}), }); @@ -20213,19 +21744,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, { @@ -20233,8 +21794,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, @@ -20248,12 +21812,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, @@ -23979,14 +25574,22 @@ describe('createAcpSessionBridge — mid-turn message queue (enqueueMidTurnMessa }); const attached = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); expect( - bridge.removeMidTurnMessage(session.sessionId, admission.messageId!, { - clientId: attached.clientId, - }), + await bridge.removeMidTurnMessage( + session.sessionId, + admission.messageId!, + { + clientId: attached.clientId, + }, + ), ).toEqual({ removed: true }); expect( - bridge.removeMidTurnMessage(session.sessionId, admission.messageId!, { - clientId: session.clientId, - }), + await bridge.removeMidTurnMessage( + session.sessionId, + admission.messageId!, + { + clientId: session.clientId, + }, + ), ).toEqual({ removed: false }); release(); @@ -24030,7 +25633,7 @@ describe('createAcpSessionBridge — mid-turn message queue (enqueueMidTurnMessa ).toEqual({ accepted: true, messageId: 'stable-deleted' }); const attached = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); expect( - bridge.removeMidTurnMessage(session.sessionId, 'stable-deleted', { + await bridge.removeMidTurnMessage(session.sessionId, 'stable-deleted', { clientId: attached.clientId, }), ).toEqual({ removed: true }); @@ -24109,19 +25712,19 @@ describe('createAcpSessionBridge — mid-turn message queue (enqueueMidTurnMessa expect(first.messageId).not.toBe(second.messageId); expect( - bridge.removeMidTurnMessage(session.sessionId, second.messageId!, { + await bridge.removeMidTurnMessage(session.sessionId, second.messageId!, { clientId: session.clientId, }), ).toEqual({ removed: true }); // The first entry survives its sibling's removal and is independently // removable by its own id. expect( - bridge.removeMidTurnMessage(session.sessionId, first.messageId!, { + await bridge.removeMidTurnMessage(session.sessionId, first.messageId!, { clientId: session.clientId, }), ).toEqual({ removed: true }); expect( - bridge.removeMidTurnMessage(session.sessionId, first.messageId!, { + await bridge.removeMidTurnMessage(session.sessionId, first.messageId!, { clientId: session.clientId, }), ).toEqual({ removed: false }); @@ -24337,7 +25940,7 @@ describe('createAcpSessionBridge — mid-turn message queue (enqueueMidTurnMessa await vi.waitFor(() => expect(prompts).toEqual(['first', 'follow up'])); const attached = await bridge.spawnOrAttach({ workspaceCwd: WS_A }); expect( - bridge.removeMidTurnMessage(session.sessionId, 'promoted-delete', { + await bridge.removeMidTurnMessage(session.sessionId, 'promoted-delete', { clientId: attached.clientId, }), ).toEqual({ removed: true }); @@ -24382,7 +25985,7 @@ describe('createAcpSessionBridge — mid-turn message queue (enqueueMidTurnMessa ); expect( - bridge.removeMidTurnMessage(session.sessionId, 'ordinary-pending', { + await bridge.removeMidTurnMessage(session.sessionId, 'ordinary-pending', { clientId: session.clientId, }), ).toEqual({ removed: false }); @@ -24628,9 +26231,13 @@ describe('createAcpSessionBridge — mid-turn message queue (enqueueMidTurnMessa messageIds: [admission.messageId], }); expect( - bridge.removeMidTurnMessage(session.sessionId, admission.messageId!, { - clientId: session.clientId, - }), + await bridge.removeMidTurnMessage( + session.sessionId, + admission.messageId!, + { + clientId: session.clientId, + }, + ), ).toEqual({ removed: false }); abort.abort(); @@ -24678,7 +26285,7 @@ describe('createAcpSessionBridge — mid-turn message queue (enqueueMidTurnMessa ).toEqual({ accepted: false }); for (const messageId of acceptedIds) { - bridge.removeMidTurnMessage(session.sessionId, messageId); + await bridge.removeMidTurnMessage(session.sessionId, messageId); } release(); await promptPromise; @@ -25046,7 +26653,7 @@ describe('createAcpSessionBridge — mid-turn message queue (enqueueMidTurnMessa ).accepted, ).toBe(true); expect( - bridge.removeMidTurnMessage(session.sessionId, `ring-${i}`, { + await bridge.removeMidTurnMessage(session.sessionId, `ring-${i}`, { clientId: session.clientId, }), ).toEqual({ removed: true }); diff --git a/packages/acp-bridge/src/bridge.ts b/packages/acp-bridge/src/bridge.ts index 669a35db71c..9576973f8b9 100644 --- a/packages/acp-bridge/src/bridge.ts +++ b/packages/acp-bridge/src/bridge.ts @@ -25,6 +25,7 @@ import type { import type { ApprovalMode, RebuiltSessionArtifactSnapshot, + TurnResultRecordPayload, } from '@qwen-code/qwen-code-core'; import { DAEMON_TRACEPARENT_META_KEY, @@ -34,6 +35,9 @@ import { PRIVATE_PARENT_CAPABILITY_META_KEY, SESSION_ARTIFACT_PERSISTENCE_VERSION, SESSION_TRANSCRIPT_MAX_LIMIT, + TURN_RESULT_CODE_TEXT_TRUNCATED, + TURN_RESULT_TEXT_MAX_CHARS, + normalizeTurnResultError, TrustGateError, normalizeSnapshotPayload, ShellExecutionService, @@ -144,6 +148,7 @@ import { LOAD_REPLAY_VERSION, MID_TURN_RECONCILIATION_RING_SIZE, PROMPT_CANCEL_METHOD, + type PromptCancelRequest, REQUESTED_SESSION_ID_META_KEY, TODO_STOP_GUARD_QUEUE_RELEASE_METHOD, WORKTREE_MCP_DEFER_META_KEY, @@ -157,6 +162,7 @@ import type { BridgeRestoredSession, BridgeSessionGoal, BridgeSessionSummary, + BridgeTurnStatus, BridgePendingInteraction, BridgeClientRequestContext, CloseSessionOpts, @@ -981,6 +987,15 @@ 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; + /** 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; /** @@ -1664,6 +1679,123 @@ 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, +): BridgeTurnStatus { + 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 { + status = { + ...shared, + state: 'error', + error: normalizeTurnResultError(terminal.err), + }; + } + entry.terminalTurnStatuses.set(pendingEntry.promptId, status); + 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 } + : {}), + }; +} + +interface StrictTerminalPersistence { + promise: Promise; + state: 'pending' | 'succeeded' | 'failed'; + turnResult: TurnResultRecordPayload; +} + +const strictTerminalPersistences = new WeakMap< + SessionEntry, + Map +>(); + +/** Reuse one channel-unavailable rejection instead of one per call. */ +function getTransportClosedReject(entry: SessionEntry): Promise { + if (!entry.transportClosedReject) { + const unavailable = entry.channel.transportFailed + ? Promise.race([entry.channel.exited, entry.channel.transportFailed]) + : entry.channel.exited; + const reject = () => { + throw new BridgeChannelClosedError( + `mid-request (session ${entry.sessionId})`, + ); + }; + entry.transportClosedReject = unavailable.then(reject, reject); + } + return entry.transportClosedReject; +} + /** * Publish the formal terminal event for an accepted prompt exactly once. * All terminal paths (agent settle, queued removal, deadline, session @@ -1689,6 +1821,18 @@ function publishPromptTerminal( return; } pendingEntry.terminalPublished = true; + const status = rememberTerminalTurnStatus(entry, pendingEntry, terminal); + if ( + !pendingEntry.dispatched && + pendingEntry.terminalPersistence === undefined + ) { + startStrictTerminalPersistence( + entry, + pendingEntry.promptId, + terminalStatusRecord(status), + pendingEntry, + ); + } const originatorClientId = pendingEntry.originatorClientId; if (terminal.kind === 'complete') { broadcastTurnComplete( @@ -1724,6 +1868,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 @@ -1756,6 +1952,56 @@ 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; + 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; + (newlyCancelled.has(promptId) ? required : previous).push(persistence); + } + await Promise.allSettled(previous); + await Promise.all(required); +} + function hasControlCharacter(value: string): boolean { for (let i = 0; i < value.length; i += 1) { const code = value.charCodeAt(i); @@ -1791,8 +2037,132 @@ 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 promptText = truncateTurnText(pending.text); + return { + sessionId, + state: pending.state === 'running' ? 'running' : 'queued', + promptId: pending.promptId, + promptText: promptText.text, + ...(promptText.truncated ? { 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.resultTruncated === true + ? { + resultCode: record.resultCode ?? TURN_RESULT_CODE_TEXT_TRUNCATED, + } + : {}), + ...(record.originatorClientId !== undefined + ? { originatorClientId: record.originatorClientId } + : {}), + }; +} + +/** + * 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 } + : {}), + ...(persisted.resultCode !== undefined + ? { resultCode: persisted.resultCode } + : {}), + ...(terminal.originatorClientId === undefined && + persisted.originatorClientId !== undefined + ? { originatorClientId: persisted.originatorClientId } + : {}), + }; +} + +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 { + 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; +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`). @@ -2810,6 +3180,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { entry: SessionEntry, pending: PendingPromptEntry, notification: CancelNotification, + terminalError?: PromptCancelRequest['terminalError'], ): Promise => { if (pending.cancelForwardInitial) { return pending.cancelForwardInitial; @@ -2817,7 +3188,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, @@ -4380,27 +4754,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 unavailable race is attached to the channel - * 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 = channelUnavailableReject( - entry.channel, - `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 @@ -5162,6 +5515,8 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { pendingPromptCount: 0, pendingAgentNotificationCount: 0, pendingPromptList: [], + terminalTurnStatuses: new Map(), + terminalPersistenceTimeoutMs: initTimeoutMs, midTurnMessageQueue: [], settledMidTurnMessageIds: [], promotedMidTurnMessageIds: [], @@ -6588,6 +6943,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, @@ -7352,6 +7713,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { text: pendingText, abortController: pendingAbort, state: isQueued ? 'queued' : 'running', + ...(!isQueued ? { startedAt: Date.now() } : {}), }; entry.pendingPromptList.push(pendingEntry); try { @@ -7397,7 +7759,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 ` + @@ -7494,6 +7861,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { if (pendingEntry.state === 'queued') { delete entry.todoStopGuardAwaitingQueuedPromptOwnerPromptId; pendingEntry.state = 'running'; + pendingEntry.startedAt = Date.now(); } entry.events.publish({ type: 'pending_prompt_started', @@ -7726,9 +8094,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)}`, ); @@ -7869,7 +8248,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) { @@ -9655,7 +10043,94 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { })); }, - removePendingPrompt(sessionId, promptId, context) { + 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 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); + } 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); + } + + // 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) + : latestTerminalTurnStatus(entry); + let result: { + v: number; + sessionId: string; + turnResult: TurnResultRecordPayload | null; + }; + try { + result = await requestSessionStatus( + sessionId, + SERVE_CONTROL_EXT_METHODS.sessionTurnStatus, + { ...(promptId !== undefined ? { promptId } : {}) }, + ); + } catch (error) { + 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 terminalPersisted + ? persisted + : enrichTerminalTurnStatus(terminal, persisted); + } + if (terminal) return terminal; + if (persisted) return persisted; + } else { + if (terminal && persisted && persisted.promptId === terminal.promptId) { + return terminalPersisted + ? persisted + : 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. + return undefined; + } + // No live prompt and no settled outcome on record: idle. + return { sessionId, state: 'idle' as const }; + }, + + async removePendingPrompt(sessionId, promptId, context) { const entry = byId.get(sessionId); if (!entry) throw new SessionNotFoundError(sessionId); // Authorize the caller BEFORE performing any mutation. @@ -9707,14 +10182,11 @@ 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' }); + await target.terminalPersistence; return { removed: true }; }, @@ -9843,7 +10315,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { return { accepted: true, messageId }; }, - removeMidTurnMessage(sessionId, messageId, context) { + async removeMidTurnMessage(sessionId, messageId, context) { const entry = byId.get(sessionId); if (!entry) throw new SessionNotFoundError(sessionId); resolveTrustedClientId(entry, context?.clientId); @@ -9861,7 +10333,7 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { ); return { removed: false }; } - const promoted = bridgeApi.removePendingPrompt( + const promoted = await bridgeApi.removePendingPrompt( sessionId, messageId, context, @@ -10286,6 +10758,9 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { throw err; } + // 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[]) ?? []; @@ -10785,6 +11260,19 @@ export function createAcpSessionBridge(opts: BridgeOptions): AcpSessionBridge { permissionMediator.forgetSession(sessionId); entry.pendingPermissionIds.clear(); entry.pendingInteractions.clear(); + 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; + } try { await notifyAgentSessionClose(entry, ci, 'killSession', { throwOnFailure: true, diff --git a/packages/acp-bridge/src/bridgeTypes.ts b/packages/acp-bridge/src/bridgeTypes.ts index 0966b85d658..f4bed629555 100644 --- a/packages/acp-bridge/src/bridgeTypes.ts +++ b/packages/acp-bridge/src/bridgeTypes.ts @@ -8,6 +8,8 @@ import type { ApprovalMode, GoalSnapshotV2, SessionGroupPresetColor, + TurnResultCode, + TurnResultErrorPayload, } from '@qwen-code/qwen-code-core'; import type { CancelNotification, @@ -811,6 +813,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 @@ -866,6 +872,8 @@ export interface BridgeMidTurnMessagesSnapshot { export interface PendingPromptEntry { promptId: string; queuedAt: number; + /** Wallclock ms the entry was dispatched on the FIFO (running start). */ + startedAt?: number; originatorClientId?: string; promotedMidTurn?: true; text: string; @@ -877,6 +885,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. */ @@ -907,6 +917,30 @@ export interface PendingPromptSummary { originatorClientId?: string; } +/** + * Pollable snapshot of one admitted prompt's turn, returned by + * `getSessionTurnStatus`. `queued` / `running` mirror the live + * `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; + state: 'idle' | 'queued' | 'running' | 'completed' | 'cancelled' | 'error'; + promptId?: string; + promptText?: string; + promptTextTruncated?: boolean; + queuedAt?: number; + startedAt?: number; + endedAt?: number; + stopReason?: string; + error?: TurnResultErrorPayload; + resultText?: string; + resultTruncated?: boolean; + resultCode?: TurnResultCode; + originatorClientId?: string; +} + export interface BridgeDaemonStatusLimits { maxSessions: number | null; maxPendingPromptsPerSession: number | null; @@ -1198,6 +1232,22 @@ 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 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( + 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 @@ -1209,7 +1259,7 @@ export interface AcpSessionBridge { sessionId: string, promptId: string, context?: BridgeClientRequestContext, - ): { removed: boolean }; + ): Promise<{ removed: boolean }>; /** * Cancel the in-flight prompt on the session. Throws @@ -1707,7 +1757,7 @@ export interface AcpSessionBridge { sessionId: string, messageId: string, context?: BridgeClientRequestContext, - ): { removed: boolean }; + ): Promise<{ removed: boolean }>; /** * Queue a daemon-owned worker completion in its live parent session. The diff --git a/packages/acp-bridge/src/status.ts b/packages/acp-bridge/src/status.ts index c88b3cfee35..98bf8f09dce 100644 --- a/packages/acp-bridge/src/status.ts +++ b/packages/acp-bridge/src/status.ts @@ -183,6 +183,17 @@ 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 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. + */ + 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/channels/base/src/AcpBridge.test.ts b/packages/channels/base/src/AcpBridge.test.ts index d2994f2ac01..0627688dd39 100644 --- a/packages/channels/base/src/AcpBridge.test.ts +++ b/packages/channels/base/src/AcpBridge.test.ts @@ -588,6 +588,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 8fd41a2441b..535968dec71 100644 --- a/packages/channels/base/src/AcpBridge.ts +++ b/packages/channels/base/src/AcpBridge.ts @@ -403,6 +403,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 d32e4e89e26..2af6c225fc8 100644 --- a/packages/channels/base/src/DaemonChannelBridge.test.ts +++ b/packages/channels/base/src/DaemonChannelBridge.test.ts @@ -700,6 +700,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 b036b533f10..786d7c96817 100644 --- a/packages/channels/base/src/DaemonChannelBridge.ts +++ b/packages/channels/base/src/DaemonChannelBridge.ts @@ -737,6 +737,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/acpAgent.test.ts b/packages/cli/src/acp-integration/acpAgent.test.ts index e9ae574f6c1..581a0d7ff97 100644 --- a/packages/cli/src/acp-integration/acpAgent.test.ts +++ b/packages/cli/src/acp-integration/acpAgent.test.ts @@ -202,6 +202,10 @@ vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => ({ (await importOriginal()) .parseInvocationContext, ), + isTurnResultRecordPayload: vi.fn( + (await importOriginal()) + .isTurnResultRecordPayload, + ), SESSION_ARTIFACT_PERSISTENCE_VERSION: 2, GOAL_STATE_VERSION: 2, // The real helper: the goal get/clear fallbacks return its exact shape and @@ -910,6 +914,7 @@ import { SessionTranscriptSnapshotUnavailableError, SessionTranscriptTooLargeError, SessionTranscriptPageTooLargeError, + SESSION_TRANSCRIPT_MAX_PAGE_BYTES, encodeSessionTranscriptCursor, unregisterGoalHook, getActiveGoal, @@ -4022,6 +4027,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); @@ -9430,6 +9474,679 @@ 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); + 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 }); + 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('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); + 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.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); + 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('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.toMatchObject({ + code: -32010, + data: { + errorKind: 'transcript_snapshot_unavailable', + sessionId, + }, + }); + } 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); + + 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 60b514ee277..628af7c6942 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -88,6 +88,7 @@ import { SESSION_ARTIFACT_PERSISTENCE_VERSION, normalizeEventPayload, normalizeSnapshotPayload, + isTurnResultRecordPayload, startEventLoopLagMonitor, refreshMemoryInstruction, applyReasoningEffort, @@ -123,6 +124,7 @@ import { type SessionArtifactSnapshotRecordPayload, type WorkspaceRememberContextMode, type ChatRecord, + type TurnResultRecordPayload, type ToolInvocationGuard, } from '@qwen-code/qwen-code-core'; import { randomUUID, timingSafeEqual } from 'node:crypto'; @@ -352,6 +354,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, @@ -407,6 +410,58 @@ const ACP_REASONING_EFFORT_NAMES: Record = { // 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, + maxBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES, + }); + // 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; + if (!isTurnResultRecordPayload(payload)) continue; + if (promptId === undefined || payload.promptId === promptId) { + return payload; + } + } + if (!result.hasMore || result.nextCursorState === undefined) { + return undefined; + } + cursor = encodeSessionTranscriptCursor( + result.nextCursorState, + workspaceCwd, + ); + } + return undefined; +} + type AcpSessionProfileStage = | 'settings_load' | 'live_restore' @@ -8128,7 +8183,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, @@ -8148,7 +8203,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 }; } @@ -10835,6 +10909,134 @@ 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)) { + 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. + } + let reader: SessionTranscriptReader | undefined; + try { + 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 }; + } + 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 }; + } + } + } + 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; + } + }); + } case SERVE_CONTROL_EXT_METHODS.sessionContinue: { const sessionId = params['sessionId']; if (typeof sessionId !== 'string' || sessionId.length === 0) { @@ -12474,6 +12676,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 9def7d5189d..5b6cf6b1320 100644 --- a/packages/cli/src/acp-integration/session/Session.test.ts +++ b/packages/cli/src/acp-integration/session/Session.test.ts @@ -392,6 +392,7 @@ describe('Session', () => { let switchModelSpy: ReturnType; let getAvailableCommandsSpy: ReturnType; let mockChatRecordingService: { + recordTurnResult: ReturnType; recordUserMessage: ReturnType; recordGoalRuntimeMessage: ReturnType; recordMidTurnUserMessage: ReturnType; @@ -651,6 +652,7 @@ describe('Session', () => { }; mockChatRecordingService = { + recordTurnResult: vi.fn(), recordUserMessage: vi.fn(), recordGoalRuntimeMessage: vi.fn(), recordMidTurnUserMessage: vi.fn(), @@ -4115,6 +4117,1508 @@ 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('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* () { + 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: 'r'.repeat(core.TURN_RESULT_TEXT_MAX_CHARS * 3), + }, + ], + }, + }, + ], + usageMetadata: { + promptTokenCount: 1, + candidatesTokenCount: 1, + totalTokenCount: 2, + }, + }, + }, + ]), + ); + + 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('rewritten answer'); + 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 () => { + ( + 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, + 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(); + expect(rewrite).toHaveBeenCalled(); + expect(agentMessageChunks()).toContain('rewritten diagnostic'); + }); + + 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, { + 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 = { + 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'))], + ])('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('falls back to raw text when rewritten delivery fails', 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; + 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( + 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.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('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([ + { + 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); + expect(payload.resultCode).toBe('RESULT_TEXT_TRUNCATED'); + }); + + it('captures streamed chunks until the character cap', 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(257)); + expect(payload.resultTruncated).toBeUndefined(); + }); + + 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', + }), + ); + 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 () => { + 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('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.', () => { + void session.cancelPendingPrompt(); + }), + ); + + await expect( + session.prompt( + { + sessionId: 'test-session-id', + prompt: [{ type: 'text', text: 'cancel me' }], + }, + trustedContext, + ), + ).resolves.toEqual({ stopReason: 'cancelled' }); + + expect(mockChatRecordingService.recordTurnResult).toHaveBeenCalledWith( + expect.objectContaining({ + promptId: 'daemon-prompt-id', + state: 'cancelled', + }), + ); + }); + + 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( + (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() + .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 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 + // 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, @@ -4134,6 +5638,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 () => { @@ -5618,6 +7123,7 @@ describe('Session', () => { const waitForPendingRewrites = vi.fn().mockResolvedValue(undefined); const interceptUpdate = vi.fn().mockResolvedValue(undefined); session.messageRewriter = { + discardTurn: vi.fn(), interceptUpdate, flushTurn, waitForPendingRewrites, @@ -8818,10 +10324,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); @@ -8867,6 +10380,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(); } @@ -9294,6 +10813,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -9324,6 +10847,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -9433,6 +10960,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -9720,6 +11251,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -11220,6 +12755,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -11420,6 +12959,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -14197,6 +15740,10 @@ describe('Session', () => { sessionId: 'test-session-id', update: { sessionUpdate: 'agent_message_chunk', + _meta: { + source: 'diagnostic', + qwenDiscreteMessage: true, + }, content: { type: 'text', text: @@ -14213,6 +15760,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.', @@ -19139,6 +20690,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.', @@ -19187,6 +20742,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.', @@ -20523,13 +22082,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, @@ -20611,6 +22172,7 @@ describe('Session', () => { const waitForPendingRewrites = vi .fn() .mockResolvedValueOnce(undefined) + .mockResolvedValueOnce(undefined) .mockImplementationOnce( () => new Promise((resolve) => { @@ -20618,6 +22180,7 @@ describe('Session', () => { }), ); session.messageRewriter = { + discardTurn: vi.fn(), interceptUpdate: vi.fn().mockResolvedValue(undefined), flushTurn: vi.fn().mockResolvedValue(undefined), waitForPendingRewrites, @@ -20639,7 +22202,7 @@ describe('Session', () => { }); await vi.waitFor(() => { - expect(waitForPendingRewrites).toHaveBeenCalledTimes(2); + expect(waitForPendingRewrites).toHaveBeenCalledTimes(3); }); const internals = session as unknown as { @@ -25902,6 +27465,7 @@ describe('Session', () => { releaseWait = resolve; }); session.messageRewriter = { + discardTurn: vi.fn(), interceptUpdate: vi.fn().mockResolvedValue(undefined), waitForPendingRewrites: vi.fn(async () => { enterWait(); @@ -29275,6 +30839,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 68ffeef4767..1f4212421da 100644 --- a/packages/cli/src/acp-integration/session/Session.ts +++ b/packages/cli/src/acp-integration/session/Session.ts @@ -49,6 +49,7 @@ import type { MemoryWriteCandidate, CronTaskDelivery, InvocationContextV1, + TurnResultRecordPayload, WorkflowApproval, } from '@qwen-code/qwen-code-core'; import { @@ -177,6 +178,9 @@ import { getFullTurnVisionModelSelector, splitImageParts, approxBase64Bytes, + TURN_RESULT_CODE_TEXT_TRUNCATED, + TURN_RESULT_TEXT_MAX_CHARS, + normalizeTurnResultError, runWithRuntimeContentGenerator, getInvocationContext, runWithInvocationContext, @@ -316,6 +320,7 @@ import { import { MessageRewriteMiddleware, loadRewriteConfig, + type MessageRewriteEmissionContext, } from './rewrite/index.js'; import { DaemonTodoStopGuard, @@ -341,6 +346,28 @@ const permissionRequestTails = new WeakMap< const USER_CANCEL_ABORT_REASON = 'qwen:user-cancel'; const NEW_PROMPT_ABORT_REASON = 'qwen:new-prompt'; const SESSION_DISPOSE_ABORT_REASON = 'qwen:session-dispose'; + +function isControlledPromptAbort(signal: AbortSignal): boolean { + return ( + signal.aborted && + (signal.reason === USER_CANCEL_ABORT_REASON || + signal.reason === NEW_PROMPT_ABORT_REASON || + signal.reason === SESSION_DISPOSE_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] '; @@ -966,6 +993,58 @@ 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; + resultSegments: Map< + string, + { + rawText: string; + rawTruncated?: boolean; + rewrittenText?: string; + rewrittenTruncated?: boolean; + } + >; + resultCapturedChars: number; + resultSegmentsTruncated: boolean; +}; + +// 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; +} { + 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 capMidTurnDrainItems(items: T[], fieldName: string): T[] { if (items.length <= MAX_MID_TURN_DRAIN_ITEMS) return items; @@ -1487,6 +1566,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 @@ -3072,7 +3159,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, ); } } @@ -3359,7 +3447,7 @@ export class Session implements SessionContext { const summary = scheduler.getExitSummary(); this.#stopCronSchedulerInRuntime(); if (summary) { - await this.messageEmitter.emitAgentMessage(summary); + await this.#emitAgentDiagnosticMessage(summary); } } } @@ -3371,33 +3459,67 @@ export class Session implements SessionContext { modelPrompt?: string, scheduledGoalTurn?: AcpGoalTurn, ): 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) { + const terminalError = getTerminalPromptAbortError(admissionCancellation); + if (terminalError !== undefined) { + this.#settleTurnRecording( + 'error', + turnRecording, + undefined, + terminalError, + ); + throw terminalError; + } + this.#settleTurnRecording('cancelled', turnRecording); return { stopReason: 'cancelled' }; } const todoStopGuardPreparation = @@ -3434,7 +3556,11 @@ export class Session implements SessionContext { // targets us. A cancel during admission cannot target this pending prompt. this.pendingPrompt?.abort(NEW_PROMPT_ABORT_REASON); const pendingSend = goalTurn?.controller ?? 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, @@ -3499,6 +3625,8 @@ export class Session implements SessionContext { } } + this.messageRewriter?.discardTurn?.(); + if (reservedGoalRuntime && reservedGoalTurnKey) { try { const permit = await claimGoalTurn( @@ -3556,6 +3684,17 @@ export class Session implements SessionContext { } 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' }; } @@ -3577,8 +3716,26 @@ 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. + 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 promptFailed = false; + let promptFailure: unknown; + let didPromptFail = false; + let finalizationError: unknown; + let didFinalizationFail = false; try { const result = await this.#executePrompt( params, @@ -3588,6 +3745,15 @@ export class Session implements SessionContext { modelPrompt, goalTurn, ); + 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 @@ -3606,15 +3772,26 @@ export class Session implements SessionContext { promptId: channelDelivery.deliveryId, }); } - return result; } catch (error) { - promptFailed = true; + // 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 abort reason instead of the error shape. + const controlledCancellation = isControlledPromptAbort( + pendingSend.signal, + ); + const terminalError = getTerminalPromptAbortError(pendingSend.signal); + settlement = { + state: controlledCancellation ? 'cancelled' : 'error', + error: terminalError ?? 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(); @@ -3632,7 +3809,7 @@ export class Session implements SessionContext { void this.#drainNotificationQueue(); } if (goalTurn) { - await this.#settleGoalTurn(goalTurn, promptResult, promptFailed); + await this.#settleGoalTurn(goalTurn, promptResult, didPromptFail); } else if (reservedGoalRuntime && reservedGoalTurnKey) { await reservedGoalRuntime.releaseTurn(reservedGoalTurnKey); } @@ -3642,11 +3819,38 @@ 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; void this.#drainGoalQueue(); - await this.#consumeLiveEndInstruction(); } + if (didFinalizationFail) throw finalizationError; + if (didPromptFail) throw promptFailure; + return promptResult as PromptResponse; } /** @@ -4123,7 +4327,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' }; @@ -4317,6 +4521,7 @@ export class Session implements SessionContext { nextMessage = null; channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock(channelDeliveryCapture); + this.#beginTurnResultResponseBlock(); const channelDeliveryCheckpoint = channelDeliveryResponseBlock?.length ?? 0; @@ -4339,7 +4544,7 @@ export class Session implements SessionContext { continue; } - this.messageEmitter.emitMessage( + await this.messageEmitter.emitMessage( part.text, 'assistant', part.thought, @@ -4377,6 +4582,8 @@ export class Session implements SessionContext { channelDeliveryResponseBlock.length = channelDeliveryCheckpoint; } + this.#beginTurnResultResponseBlock(); + this.messageRewriter?.discardBufferedTurn(); } await finalizeToolCallPreparations( preparationTracker, @@ -4414,14 +4621,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' }; @@ -4475,6 +4681,7 @@ export class Session implements SessionContext { channelDeliveryResponseBlock, functionCalls.length > 0, ); + this.#commitTurnResultResponseBlock(functionCalls.length > 0); if (usageMetadata) { this.#recordPromptTokenCount(usageMetadata); @@ -4795,7 +5002,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 ( @@ -4850,7 +5057,7 @@ export class Session implements SessionContext { await this.#pauseGoalForStopHookCap(); } this.todoStopGuard.suspend(); - await this.messageEmitter.emitAgentMessage(warning); + await this.#emitAgentDiagnosticMessage(warning); debugLogger.warn(warning); return { stopReason: 'end_turn' }; } @@ -5296,6 +5503,7 @@ export class Session implements SessionContext { channelDeliveryResponseBlock = beginChannelDeliveryResponseBlock( options.channelDeliveryCapture, ); + this.#beginTurnResultResponseBlock(); const channelDeliveryCheckpoint = channelDeliveryResponseBlock?.length ?? 0; initialSend = false; @@ -5331,7 +5539,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, @@ -5367,6 +5575,8 @@ export class Session implements SessionContext { if (channelDeliveryResponseBlock) { channelDeliveryResponseBlock.length = channelDeliveryCheckpoint; } + this.#beginTurnResultResponseBlock(); + this.messageRewriter?.discardBufferedTurn(); } await finalizeToolCallPreparations( preparationTracker, @@ -5392,10 +5602,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 { @@ -5447,6 +5656,7 @@ export class Session implements SessionContext { channelDeliveryResponseBlock, functionCalls.length > 0, ); + this.#commitTurnResultResponseBlock(functionCalls.length > 0); if (usageMetadata) { this.#recordPromptTokenCount(usageMetadata); @@ -5599,6 +5809,14 @@ export class Session implements SessionContext { } async sendUpdate(update: SessionUpdate): Promise { + await this.#deliverUpdate(update); + } + + async #deliverUpdate( + update: SessionUpdate, + rewriteContext?: MessageRewriteEmissionContext, + captureResultText = true, + ): Promise { const params: SessionNotification = { sessionId: this.sessionId, update: projectAcpToolResultUpdate(update), @@ -5611,6 +5829,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); } @@ -5656,6 +5877,189 @@ export class Session implements SessionContext { timer.unref(); } + /** + * 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 } + : {}), + promptText: text, + promptTextTruncated: truncated, + resultSegments: new Map(), + resultCapturedChars: 0, + resultSegmentsTruncated: false, + }; + } + + /** + * 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, + rewriteContext?: MessageRewriteEmissionContext, + ): 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; + } + const meta = update._meta; + if ( + meta?.['parentToolCallId'] !== undefined || + meta?.['qwenDiscreteMessage'] === true || + meta?.['source'] === 'slash_command' + ) { + return; + } + if ( + rewriteContext !== undefined && + rewriteContext.ownerPromptId !== recording.promptId + ) { + return; + } + + if (rewriteContext?.rewritten && !rewriteContext.replacesMessageText) { + return; + } + + const segmentKey = rewriteContext?.replacesMessageText + ? `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; + return; + } + segment = { rawText: '' }; + recording.resultSegments.set(segmentKey, segment); + } + if (rewriteContext?.rewritten) { + 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; + } + 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; + } + + #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 + * 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 selectedSegments = [...recording.resultSegments.values()].map( + (segment) => ({ + text: segment.rewrittenText ?? segment.rawText, + truncated: + segment.rewrittenText !== undefined + ? segment.rewrittenTruncated === true + : segment.rawTruncated === true, + }), + ); + 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, + ...(response?.stopReason !== undefined + ? { stopReason: response.stopReason } + : {}), + ...(state === 'error' ? { error: normalizeTurnResultError(error) } : {}), + ...(recording.startedAt !== undefined + ? { startedAt: recording.startedAt } + : {}), + endedAt: Date.now(), + promptText: recording.promptText, + ...(recording.promptTextTruncated ? { promptTextTruncated: true } : {}), + ...(selectedResult.text.length > 0 + ? { resultText: selectedResult.text } + : {}), + ...(resultTruncated + ? { + resultTruncated: true, + resultCode: TURN_RESULT_CODE_TEXT_TRUNCATED, + } + : {}), + ...(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(); } @@ -6026,7 +6430,7 @@ export class Session implements SessionContext { { recordToQwenLogger: false }, ); try { - await this.messageEmitter.emitAgentMessage( + await this.#emitAgentDiagnosticMessage( REPEATED_TOOL_FAILURE_STOP_MESSAGE, ); } catch (error) { @@ -6146,10 +6550,18 @@ export class Session implements SessionContext { } async #emitAgentDiagnosticMessage(text: string): Promise { - await this.sendUpdate({ + 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( @@ -9923,7 +10335,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) { @@ -10351,7 +10763,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', @@ -11050,7 +11462,7 @@ export class Session implements SessionContext { ); if (selected) { try { - await this.messageEmitter.emitAgentMessage( + await this.#emitAgentDiagnosticMessage( formatFullTurnVisionNotice(fullTurnModel), ); } catch (error) { @@ -11084,7 +11496,7 @@ export class Session implements SessionContext { if (bridgeResult.status !== 'skipped' || bridgeResult.egressOccurred) { try { - await this.messageEmitter.emitAgentMessage( + await this.#emitAgentDiagnosticMessage( formatVisionBridgeNotice(bridgeResult), ); } catch (error) { @@ -11204,7 +11616,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/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 de03503d627..eeff6789ba4 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(), })), })); @@ -33,12 +34,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 +71,11 @@ describe('MessageRewriteMiddleware', () => { } as unknown as SessionUpdate; await middleware.interceptUpdate(msgUpdate); - expect(mockSendUpdate).toHaveBeenCalledWith(msgUpdate); + expect(mockSendUpdate).toHaveBeenCalledWith(msgUpdate, { + turnIndex: 1, + rewritten: false, + replacesMessageText: true, + }); }); }); @@ -91,11 +98,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, replacesMessageText: true }, + ); const { LlmRewriter } = await import('./LlmRewriter.js'); const rewriter = vi.mocked(LlmRewriter).mock.results[0]?.value as { @@ -170,7 +181,188 @@ 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), + ); + }); + + 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(); + const rewriteSignal = rewriter.rewrite.mock.calls[0][1] as AbortSignal; + middleware.discardTurn(); + expect(rewriteSignal.aborted).toBe(true); + resolveRewrite('late automatic rewrite'); + await middleware.waitForPendingRewrites(); + + expect(mockSendUpdate).toHaveBeenCalledTimes(1); + }); + }); + + 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'); + 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'); + 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(); @@ -219,6 +411,47 @@ 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, + replacesMessageText: true, + }, + ], + [ + { + sessionUpdate: 'agent_message_chunk', + content: { type: 'text', text: 'rewritten text' }, + _meta: { rewritten: true, turnIndex: 1 }, + }, + { + ownerPromptId: 'prompt-a', + turnIndex: 1, + rewritten: true, + replacesMessageText: true, + }, + ], + ]); + }); + it('should emit rewritten message with _meta.rewritten=true', async () => { const { middleware, mockSendUpdate } = createMiddleware(); @@ -287,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 5edb0daa754..b30325e6171 100644 --- a/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts +++ b/packages/cli/src/acp-integration/session/rewrite/MessageRewriteMiddleware.ts @@ -35,18 +35,33 @@ 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; + replacesMessageText: boolean; +} + export class MessageRewriteMiddleware { private readonly turnBuffer: TurnBuffer; private readonly rewriter: LlmRewriter; private readonly target: MessageRewriteConfig['target']; private readonly timeoutMs: number; private turnIndex = 0; + private generation = 0; + private generationAbortController = new AbortController(); 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,15 +99,29 @@ export class MessageRewriteMiddleware { | Record | 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); + await this.sendUpdate(update, { + ...(ownerPromptId !== undefined ? { ownerPromptId } : {}), + turnIndex: this.turnIndex + 1, + rewritten: false, + replacesMessageText: + updateType === 'agent_message_chunk' && + (this.target === 'message' || this.target === 'all'), + }); if ( updateType === 'agent_message_chunk' && - (updateRecord['_meta'] as Record | undefined)?.[ - 'source' - ] === 'slash_command' + meta?.['source'] === 'slash_command' ) { return; } @@ -113,6 +142,7 @@ export class MessageRewriteMiddleware { if (didAccumulate) { this.captureTurnMeta(updateRecord); + this.turnOwnerPromptId ??= ownerPromptId; } } @@ -132,17 +162,22 @@ 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++; 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); - const rewriteSignal = signal - ? AbortSignal.any([signal, timeoutSignal]) - : timeoutSignal; + const rewriteSignal = AbortSignal.any([ + ...(signal ? [signal] : []), + timeoutSignal, + this.generationAbortController.signal, + ]); this.pendingRewrites.push( (async () => { @@ -152,21 +187,32 @@ export class MessageRewriteMiddleware { debugLogger.info(`Turn ${turnIdx}: no rewrite output`); return; } + if (generation !== this.generation || rewriteSignal.aborted) return; debugLogger.info( `Turn ${turnIdx}: rewritten ${rewritten.length} chars`, ); // 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, + replacesMessageText: content.messages.length > 0, }, - } as SessionUpdate); + ); + if (generation !== this.generation || rewriteSignal.aborted) return; + this.rewriter.commitOutput(rewritten); } catch (error) { debugLogger.warn( `Turn ${turnIdx}: rewrite failed: ${error instanceof Error ? error.message : String(error)}`, @@ -176,6 +222,19 @@ export class MessageRewriteMiddleware { ); } + discardTurn(): void { + this.generationAbortController.abort(); + this.generationAbortController = new AbortController(); + this.generation++; + this.discardBufferedTurn(); + } + + discardBufferedTurn(): 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; 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'; diff --git a/packages/cli/src/serve/acp-session-bridge.ts b/packages/cli/src/serve/acp-session-bridge.ts index 0144b4c830a..ff4feda9618 100644 --- a/packages/cli/src/serve/acp-session-bridge.ts +++ b/packages/cli/src/serve/acp-session-bridge.ts @@ -83,6 +83,7 @@ export type { BridgeGenerationStreamEvent, BridgeWorkspaceGenerationStreamEvent, BridgeSessionSummary, + BridgeTurnStatus, SessionMetadataUpdate, BridgeClientRequestContext, BridgeHeartbeatResult, diff --git a/packages/cli/src/serve/capabilities.ts b/packages/cli/src/serve/capabilities.ts index 39a60718cbf..1d0297bcd7b 100644 --- a/packages/cli/src/serve/capabilities.ts +++ b/packages/cli/src/serve/capabilities.ts @@ -112,6 +112,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/multi-workspace-sessions.test.ts b/packages/cli/src/serve/multi-workspace-sessions.test.ts index 0b715f2e386..69bf61fdda2 100644 --- a/packages/cli/src/serve/multi-workspace-sessions.test.ts +++ b/packages/cli/src/serve/multi-workspace-sessions.test.ts @@ -659,7 +659,7 @@ function makeBridge( promotedMessageIds: [], }; }, - removeMidTurnMessage( + async removeMidTurnMessage( sessionId: string, messageId: string, context?: BridgeClientRequestContext, diff --git a/packages/cli/src/serve/routes/session.ts b/packages/cli/src/serve/routes/session.ts index 8ccd647dd80..c81dab2f38c 100644 --- a/packages/cli/src/serve/routes/session.ts +++ b/packages/cli/src/serve/routes/session.ts @@ -4783,7 +4783,7 @@ export function registerSessionRoutes( mutate(), withOwnerMutableSession( 'DELETE /session/:id/mid-turn-messages/:messageId', - (req, res, sessionId, runtime) => { + async (req, res, sessionId, runtime) => { const clientId = parseClientIdHeader(req, res); if (clientId === null) return; const messageId = req.params['messageId']; @@ -4793,7 +4793,7 @@ export function registerSessionRoutes( .json({ error: '`messageId` route parameter is required' }); return; } - const result = runtime.bridge.removeMidTurnMessage( + const result = await runtime.bridge.removeMidTurnMessage( sessionId, messageId, clientId !== undefined ? { clientId } : undefined, @@ -4857,7 +4857,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']; @@ -4867,7 +4867,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, @@ -4877,6 +4877,81 @@ 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 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; + 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 c01e70ae27a..c93ded02286 100644 --- a/packages/cli/src/serve/server.test.ts +++ b/packages/cli/src/serve/server.test.ts @@ -111,6 +111,7 @@ import { type BridgeDaemonStatusSnapshot, type BridgeRestoredSession, type BridgeClientRequestContext, + type BridgeTurnStatus, type BridgeRestoreSessionRequest, type BridgeSession, type BridgeSessionSummary, @@ -476,6 +477,7 @@ const EXPECTED_STAGE1_FEATURES = [ 'session_stats', 'session_lsp', 'session_status', + 'session_turn_status', 'session_close', 'session_archive', 'session_metadata', @@ -715,6 +717,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, @@ -974,6 +981,11 @@ interface FakeBridge extends AcpSessionBridge { NonNullable >[0]; calls: BridgeSpawnRequest[]; + getSessionTurnStatusCalls: Array<{ + sessionId: string; + context?: BridgeClientRequestContext; + promptId?: string; + }>; loadCalls: BridgeRestoreSessionRequest[]; resumeCalls: BridgeRestoreSessionRequest[]; promptCalls: Array<{ @@ -1223,6 +1235,13 @@ function fakeBridge(opts: FakeBridgeOpts = {}): FakeBridge { }> = []; const removePendingPromptImpl = opts.removePendingPromptImpl ?? (() => ({ removed: true })); + const getSessionTurnStatusCalls: Array<{ + sessionId: string; + context?: BridgeClientRequestContext; + promptId?: string; + }> = []; + const getSessionTurnStatusImpl = + opts.getSessionTurnStatusImpl ?? (async () => undefined); const permissionVotes: FakeBridge['permissionVotes'] = []; const sessionPermissionVotes: FakeBridge['sessionPermissionVotes'] = []; const listCalls: string[] = []; @@ -1804,6 +1823,7 @@ function fakeBridge(opts: FakeBridgeOpts = {}): FakeBridge { liveSpeakToUserHandler = handler; }, calls, + getSessionTurnStatusCalls, loadCalls, resumeCalls, promptCalls, @@ -2210,7 +2230,7 @@ function fakeBridge(opts: FakeBridgeOpts = {}): FakeBridge { }); return enqueueMidTurnImpl(sessionId, message, context, messageId); }, - removeMidTurnMessage(sessionId, messageId, context) { + async removeMidTurnMessage(sessionId, messageId, context) { removeMidTurnCalls.push({ sessionId, messageId, @@ -2233,6 +2253,14 @@ function fakeBridge(opts: FakeBridgeOpts = {}): FakeBridge { removePendingPromptCalls.push({ sessionId, promptId }); return removePendingPromptImpl(sessionId, promptId); }, + async getSessionTurnStatus(sessionId, context, promptId) { + getSessionTurnStatusCalls.push({ + sessionId, + ...(context !== undefined ? { context } : {}), + ...(promptId !== undefined ? { promptId } : {}), + }); + return getSessionTurnStatusImpl(sessionId, context, promptId); + }, async executeShellCommand(sessionId, command, signal, context) { shellCalls.push({ sessionId, @@ -9648,6 +9676,129 @@ 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') + .set('X-Qwen-Client-Id', 'client-1'); + expect(res.status).toBe(200); + expect(res.body).toMatchObject({ + sessionId: 's-1', + state: 'completed', + promptId: 'p-1', + 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 () => { + 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 3c0a192f488..3c2cbcd55f5 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(54); + expect(registered).toHaveLength(56); 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 2cd66082597..d8404e64a6e 100644 --- a/packages/cli/src/serve/server/telemetry.test.ts +++ b/packages/cli/src/serve/server/telemetry.test.ts @@ -812,17 +812,17 @@ describe('daemonTelemetryMiddleware — recordRequest seam', () => { }); describe('legacy session telemetry route catalog', () => { - it('contains 54 unique routes with the audited 47/7 attribution split', () => { + it('contains 56 unique routes with the audited 49/7 attribution split', () => { const keys = legacySessionTelemetryRoutes.map( ({ method, path }) => `${method} ${path}`, ); - expect(keys).toHaveLength(54); - expect(new Set(keys).size).toBe(54); + expect(keys).toHaveLength(56); + expect(new Set(keys).size).toBe(56); expect( legacySessionTelemetryRoutes.filter( ({ attribution }) => attribution === 'handler_resolved', ), - ).toHaveLength(47); + ).toHaveLength(49); expect( legacySessionTelemetryRoutes.filter( ({ attribution }) => attribution === 'pre_resolved', diff --git a/packages/cli/src/serve/server/telemetry.ts b/packages/cli/src/serve/server/telemetry.ts index 6fa40f10441..30d39929e4c 100644 --- a/packages/cli/src/serve/server/telemetry.ts +++ b/packages/cli/src/serve/server/telemetry.ts @@ -299,6 +299,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 83558f351b8..788af75cde8 100644 --- a/packages/core/src/services/chatRecordingService.test.ts +++ b/packages/core/src/services/chatRecordingService.test.ts @@ -12,8 +12,13 @@ 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, 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'; @@ -865,6 +870,128 @@ 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(); + }); + + 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('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( + {}, + { + 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', () => { 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 96c2e89ac3b..3633e1ed765 100644 --- a/packages/core/src/services/chatRecordingService.ts +++ b/packages/core/src/services/chatRecordingService.ts @@ -299,6 +299,7 @@ export interface ChatRecord { | 'user_text_elements' | 'session_artifact_event' | 'session_artifact_snapshot' + | 'turn_result' | 'goal_state' | 'goal_runtime' | 'realtime_message'; @@ -360,6 +361,7 @@ export interface ChatRecord { | UserTextElementsRecordPayload | SessionArtifactEventRecordPayload | SessionArtifactSnapshotRecordPayload + | TurnResultRecordPayload | GoalStateRecordPayloadV2; /** Background subagent that produced this record (e.g. "explore-7f3c"). */ @@ -572,6 +574,175 @@ 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; +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 + * 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?: TurnResultErrorPayload; + /** 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; + 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 { + 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') || + (payload['resultCode'] !== undefined && + (payload['resultCode'] !== TURN_RESULT_CODE_TEXT_TRUNCATED || + payload['resultTruncated'] !== true)) || + !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; @@ -2209,6 +2380,37 @@ 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); + } + } + + 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/session-transcript-reader.test.ts b/packages/core/src/services/session-transcript-reader.test.ts index bebf4a0389e..93b2a44f87d 100644 --- a/packages/core/src/services/session-transcript-reader.test.ts +++ b/packages/core/src/services/session-transcript-reader.test.ts @@ -357,6 +357,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'), diff --git a/packages/core/src/services/sessionService.test.ts b/packages/core/src/services/sessionService.test.ts index 4f8cc5144fc..3ea8e33a097 100644 --- a/packages/core/src/services/sessionService.test.ts +++ b/packages/core/src/services/sessionService.test.ts @@ -3516,6 +3516,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 dd22d2eeab1..2873b2a948d 100644 --- a/packages/core/src/services/sessionService.ts +++ b/packages/core/src/services/sessionService.ts @@ -1818,6 +1818,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')) ), ); diff --git a/packages/core/src/utils/transcript-records.ts b/packages/core/src/utils/transcript-records.ts index 2c7c9a15579..300870671ef 100644 --- a/packages/core/src/utils/transcript-records.ts +++ b/packages/core/src/utils/transcript-records.ts @@ -126,6 +126,7 @@ const KNOWN_RECORD_SUBTYPES = new Set([ 'agent_retry', 'file_history_snapshot', 'session_source', + 'turn_result', 'goal_state', 'goal_runtime', ...ARTIFACT_RECORD_SUBTYPES,