diff --git a/docs/architecture/task-lifecycle-model.md b/docs/architecture/task-lifecycle-model.md index 081cd96a0c..a6fc40494d 100644 --- a/docs/architecture/task-lifecycle-model.md +++ b/docs/architecture/task-lifecycle-model.md @@ -140,6 +140,12 @@ Merged PR #1625 changed the confirmed downstream readers: `getEnvironmentDetails `scripts/check-delegated-mode-readers.ts` does not execute `getEnvironmentDetails`, `presentAssistantMessage`, or `validateToolUse`. It checks the production handoff selector and a pure built-in-mode permission divergence, establishing that the wrong source is observable. It is refinement support, not exhaustive reader coverage. Other mode-sensitive consumers remain an explicit inventory gap, and this suite does not claim universal task-local reader isolation. +## Queue ask landing model + +`scripts/check-queue-ask-landing.ts` is a bounded model of where a queued message lands after `MessageQueueService` drains it. It imports the real `MessageQueueService` and the `nextRunState` kernel. The `askResponse` slot and the `setTimeout(0)` hop in `Task.ts` are model abstractions, because `Task.ts` needs VS Code. + +The invariant is that every added message is queued, in flight, in the slot, or consumed. Nothing is dropped. The production policy sets the slot with no ask pending, and the next `ask()` resets it. The model keeps this gap as a known witness (#2421). The requeue policy is the proposed fix and must stay clean. Remove the witness when production changes. + ## Task fan-out protocol model `scripts/check-task-fanout-protocol.ts` is a separate, optional bounded protocol model for the #369/#372 fan-out safety contract. It explores a live parent with two sibling slots, a two-permit scheduler, independent result readiness, explicit child-to-parent delivery, parent loss, orphan cancellation, and permit release. It checks scheduler capacity and exact permit ownership, one writer and at-most-once delivery per child, readiness before delivery, and no result routing after parent loss. Named landmarks require concurrent siblings beneath a live parent, out-of-order result delivery, single-writer results, parent loss while work is running, and complete orphan cleanup to remain reachable. Injected unsafe states confirm those invariants reject wrong writers, early and duplicate delivery, post-parent-loss routing, and scheduler over-allocation. diff --git a/docs/architecture/tla/AGENTS.md b/docs/architecture/tla/AGENTS.md index da7e901774..377ab0938a 100644 --- a/docs/architecture/tla/AGENTS.md +++ b/docs/architecture/tla/AGENTS.md @@ -38,7 +38,7 @@ Write the unit tests and do the review as usual. The spec does not replace them. | replay | Run a counterexample on the real code. It shows if the counterexample is real. | | sabotage check | Remove a guard on purpose. The invariant must fail. If not, the invariant is vacuous. | | vacuous | True in all states because of the model, not because of the code. | -| gate | The check an agent runs by hand on each commit. No script or CI step runs it yet. | +| gate | The check an agent runs on each commit. `check.sh` runs it. No CI step runs it yet. | ## Procedure @@ -53,7 +53,7 @@ Write the unit tests and do the review as usual. The spec does not replace them. 9. Run TLC on the fixed code. The invariant must hold. 10. Write a property test from the same invariant sentence. Run it on the real code. 11. Simplify the spec. Use the questions below. -12. Run each TLC config and the property test by hand on each fix commit. Write the result in the spec header. +12. On each fix commit, run `TLA_JAR= ./check.sh ` for each spec you changed, and the property test. Run `./check.sh all` only for a release or a change to `check.sh`. `Spec.cfg` must pass. Each `Spec.Variant.cfg` must fail. Write the result in the spec header. ## Review ratchet diff --git a/docs/architecture/tla/MentionOrigin.Code.cfg b/docs/architecture/tla/MentionOrigin.Code.cfg new file mode 100644 index 0000000000..795158c286 --- /dev/null +++ b/docs/architecture/tla/MentionOrigin.Code.cfg @@ -0,0 +1,12 @@ +SPECIFICATION Spec +CONSTANTS + Alphabet = {"a", "b"} + MaxLen = 2 + MaxInit = 2 + MaxRepl = 2 + Retagger = "Code" + HistoryRestore = "Saved" + UndoRestore = "AllGenerated" + QueueEdit = "PerEvent" +INVARIANTS TypeOK NoGeneratedTagged +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/MentionOrigin.History.cfg b/docs/architecture/tla/MentionOrigin.History.cfg new file mode 100644 index 0000000000..e1c701e152 --- /dev/null +++ b/docs/architecture/tla/MentionOrigin.History.cfg @@ -0,0 +1,12 @@ +SPECIFICATION Spec +CONSTANTS + Alphabet = {"a", "b"} + MaxLen = 2 + MaxInit = 2 + MaxRepl = 2 + Retagger = "Both" + HistoryRestore = "AsEdit" + UndoRestore = "AllGenerated" + QueueEdit = "PerEvent" +INVARIANTS TypeOK NoGeneratedTagged +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/MentionOrigin.Queue.cfg b/docs/architecture/tla/MentionOrigin.Queue.cfg new file mode 100644 index 0000000000..066b58d1f4 --- /dev/null +++ b/docs/architecture/tla/MentionOrigin.Queue.cfg @@ -0,0 +1,12 @@ +SPECIFICATION Spec +CONSTANTS + Alphabet = {"a", "b"} + MaxLen = 3 + MaxInit = 3 + MaxRepl = 2 + Retagger = "Both" + HistoryRestore = "Saved" + UndoRestore = "AllGenerated" + QueueEdit = "Batch" +INVARIANTS TypeOK NoGeneratedTagged +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/MentionOrigin.Retained.cfg b/docs/architecture/tla/MentionOrigin.Retained.cfg new file mode 100644 index 0000000000..741cd1b58e --- /dev/null +++ b/docs/architecture/tla/MentionOrigin.Retained.cfg @@ -0,0 +1,12 @@ +SPECIFICATION Spec +CONSTANTS + Alphabet = {"a", "b"} + MaxLen = 2 + MaxInit = 2 + MaxRepl = 2 + Retagger = "Both" + HistoryRestore = "Saved" + UndoRestore = "Retained" + QueueEdit = "PerEvent" +INVARIANTS TypeOK NoGeneratedTagged +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/MentionOrigin.Undo.cfg b/docs/architecture/tla/MentionOrigin.Undo.cfg new file mode 100644 index 0000000000..2aced92827 --- /dev/null +++ b/docs/architecture/tla/MentionOrigin.Undo.cfg @@ -0,0 +1,12 @@ +SPECIFICATION Spec +CONSTANTS + Alphabet = {"a", "b"} + MaxLen = 2 + MaxInit = 2 + MaxRepl = 2 + Retagger = "Both" + HistoryRestore = "Saved" + UndoRestore = "AsEdit" + QueueEdit = "PerEvent" +INVARIANTS TypeOK NoGeneratedTagged +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/MentionOrigin.cfg b/docs/architecture/tla/MentionOrigin.cfg new file mode 100644 index 0000000000..5b4b5ae732 --- /dev/null +++ b/docs/architecture/tla/MentionOrigin.cfg @@ -0,0 +1,12 @@ +SPECIFICATION Spec +CONSTANTS + Alphabet = {"a", "b"} + MaxLen = 2 + MaxInit = 2 + MaxRepl = 2 + Retagger = "Both" + HistoryRestore = "Saved" + UndoRestore = "AllGenerated" + QueueEdit = "PerEvent" +INVARIANTS TypeOK NoGeneratedTagged +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/MentionOrigin.tla b/docs/architecture/tla/MentionOrigin.tla new file mode 100644 index 0000000000..d619ed120d --- /dev/null +++ b/docs/architecture/tla/MentionOrigin.tla @@ -0,0 +1,148 @@ +---- MODULE MentionOrigin ---- +\* Models applyEdit in src/shared/mentionSegments.ts. The webview calls it on each input event. +\* Source: text typed by the user. Sink: expandUserMentions expands each user-tagged letter. +\* Failure: a letter the user did not type is tagged user. Generated text then expands. +\* Invariant: NoGeneratedTagged. A letter tagged user is a letter the user typed. +\* It replaces a count check (user tags <= typed letters). This form implies the count check. +\* Expected before the run: the edits hold. A change of two ranges would fail with generated text between them. +\* Failure 2 (PR 2421 review 2): the queue editor saves only the final text. QueueSave models two edits, then one save. +\* Replay: paste "@/x" before generated "@/x", then replace the first typed "@". The generated copy turns user. +\* The fix runs the diff from both ends and keeps "u" only where both agree. The webview retags each input event. +\* The server only checks the segments. Property test: mentionSegments.spec.ts, "never tags a generated letter user". +\* Actions: Change (typing), Load (ArrowUp), HistoryRestoreAct (ArrowDown), UndoAct, QueueSave (Batch only). +\* nav is the history navigation state. Load saves the draft only when nav is false. +\* | Config | Variant | Verdict | +\* | MentionOrigin.cfg | Both, Saved, AllGenerated | holds (71,225 states at MaxLen 3) | +\* | MentionOrigin.Code.cfg | retagger of the old code | fails in 2 states | +\* | MentionOrigin.History.cfg | restore through applyEdit | fails in 3 states | +\* | MentionOrigin.Undo.cfg | undo through applyEdit | fails in 2 states | +\* | MentionOrigin.Retained.cfg| undo keeps old tags | fails in 3 states | +\* | MentionOrigin.Queue.cfg | one retag at queue save (Batch) | fails in 3 states | +\* Cost of AllGenerated: after an undo or redo the user must retype a mention that was in the draft. +\* Not modeled: normalizeSegments, merge, trim and the host expansion. Tests: QueuedMessages.spec.tsx, ChatTextArea.spec.tsx. +\* Cost: each run takes under 30 seconds. Agent time is not measured. +\* Review: 0 covered, 8 added, 0 gap (PR 2421). TLC found the equal-letter failure. No review thread named it. +\* Null result: the spec has no action for the send sites. ChatView tests and a mutation check cover them. +\* The first version came after the code and the reviews. It is not an independent first pass. + +EXTENDS Naturals, Sequences, FiniteSets + +CONSTANTS Alphabet, MaxLen, MaxInit, MaxRepl, Retagger, HistoryRestore, UndoRestore, QueueEdit +\* QueueEdit: "Batch" or "PerEvent". MaxRepl: the longest typed replacement in one edit. +\* Retagger: "Code" or "Both". HistoryRestore: "Saved" or "AsEdit". +\* UndoRestore: "AllGenerated", "Retained" or "AsEdit". + +VARIABLES text, tags, snap, nav \* text: letters with true origin. tags: the "u" or "g" flag per letter. + +vars == <> + +Origins == {"u", "g"} +Cell == [c : Alphabet, o : Origins] +Letters(s) == [p \in 1..Len(s) |-> s[p].c] +Seqs(S, n) == UNION {[1..k -> S] : k \in 0..n} +Min2(x, y) == IF x < y THEN x ELSE y + +\* Longest common prefix and suffix of two letter lists. The suffix cannot overlap the prefix. +Pre(a, b) == CHOOSE k \in 0..Min2(Len(a), Len(b)) : + /\ \A p \in 1..k : a[p] = b[p] + /\ k = Min2(Len(a), Len(b)) \/ a[k+1] # b[k+1] +Suf(a, b, k) == CHOOSE m \in 0..(Min2(Len(a), Len(b)) - k) : + /\ \A p \in 1..m : a[Len(a)-p+1] = b[Len(b)-p+1] + /\ m = Min2(Len(a), Len(b)) - k \/ a[Len(a)-m] # b[Len(b)-m] + +\* Tags for a diff. k letters keep their tags at the front. m letters keep their tags at the back. +\* The new letters in the middle get the tag f. +TagsFor(oldT, newL, k, m, f) == + SubSeq(oldT, 1, k) + \o [p \in 1..(Len(newL) - k - m) |-> f] + \o SubSeq(oldT, Len(oldT) - m + 1, Len(oldT)) + +\* Suffix first. The prefix cannot overlap the suffix. +SufAll(a, b) == Suf(a, b, 0) +PreS(a, b, m) == CHOOSE k \in 0..(Min2(Len(a), Len(b)) - m) : + /\ \A p \in 1..k : a[p] = b[p] + /\ k = Min2(Len(a), Len(b)) - m \/ a[k+1] # b[k+1] + +\* The code of applyEdit takes the prefix first. "Both" also takes the suffix first. It tags a letter +\* "u" only if both diffs agree. +Retag(oldL, oldT, newL, f) == + LET k == Pre(oldL, newL) + A == TagsFor(oldT, newL, k, Suf(oldL, newL, k), f) + m2 == SufAll(oldL, newL) + B == TagsFor(oldT, newL, PreS(oldL, newL, m2), m2, f) + IN IF Retagger = "Code" THEN A + ELSE [p \in 1..Len(A) |-> IF A[p] = "u" /\ B[p] = "u" THEN "u" ELSE "g"] + +\* One edit replaces the range i+1..j with the typed letters r. Kept cells keep their origin. +Replace(s, i, j, r) == + SubSeq(s, 1, i) \o [p \in 1..Len(r) |-> [c |-> r[p], o |-> "u"]] \o SubSeq(s, j+1, Len(s)) + +Rs == Seqs(Alphabet, MaxRepl) +One(s) == UNION {UNION {{Replace(s, i, j, r) : r \in Rs} : j \in i..Len(s)} : i \in 0..Len(s)} +Edits(s) == {t \in One(s) : Len(t) <= MaxLen} + +Init == \E g \in Seqs(Alphabet, MaxInit) : + /\ text = [p \in 1..Len(g) |-> [c |-> g[p], o |-> "g"]] + /\ tags = [p \in 1..Len(g) |-> "g"] + /\ snap = <<>> + /\ nav = FALSE + +Now == [t |-> text, g |-> tags] + +\* The user types. Typing ends history navigation (resetOnInputChange). +Change == \E t \in Edits(text) : + /\ text' = t + /\ tags' = Retag(Letters(text), tags, Letters(t), "u") + /\ nav' = FALSE + /\ UNCHANGED snap + +\* ArrowUp loads a stored prompt as generated text. It can have the draft's letters. +\* It saves the draft only when navigation starts. Later loads keep the first snapshot. +Load == \E g \in Seqs(Alphabet, MaxLen) : + /\ text' = [p \in 1..Len(g) |-> [c |-> g[p], o |-> "g"]] + /\ tags' = [p \in 1..Len(g) |-> "g"] + /\ snap' = IF nav THEN snap ELSE Now + /\ nav' = TRUE + +\* ArrowDown restores the saved draft and ends navigation. "AsEdit" sends the restore through applyEdit. +\* The letters can match the stored prompt, so there is no guard on them. +HistoryRestoreAct == + /\ nav + /\ text' = snap.t + /\ tags' = IF HistoryRestore = "Saved" THEN snap.g + ELSE Retag(Letters(text), tags, Letters(snap.t), "u") + /\ nav' = FALSE + /\ UNCHANGED snap + +\* Native undo or redo restores any other text. This covers every older state in the undo stack. +\* The browser sends no event with the old origins, so each letter can have either origin. +\* The input event ends history navigation (ChatTextArea calls resetOnInputChange). +UndoAct == \E t \in Seqs(Cell, MaxLen) : + /\ Letters(t) # Letters(text) + /\ text' = t + /\ tags' = CASE UndoRestore = "AllGenerated" -> [p \in 1..Len(t) |-> "g"] + [] UndoRestore = "Retained" -> Retag(Letters(text), tags, Letters(t), "g") + [] OTHER -> Retag(Letters(text), tags, Letters(t), "u") + /\ nav' = FALSE + /\ UNCHANGED snap + +\* "Batch": the queue editor holds two edits and retags the net change at save. "PerEvent" is two Change steps. +\* So only "Batch" adds an action. It is the old server behavior. +QueueSave == \E t1 \in Edits(text) : \E t \in Edits(t1) : + /\ QueueEdit = "Batch" + /\ text' = t + /\ tags' = Retag(Letters(text), tags, Letters(t), "u") + /\ nav' = FALSE + /\ UNCHANGED snap + +Next == Change \/ Load \/ HistoryRestoreAct \/ UndoAct \/ QueueSave + +Spec == Init /\ [][Next]_vars + +Saved == {<<>>} \cup [t : Seqs(Cell, MaxLen), g : Seqs(Origins, MaxLen)] +TypeOK == snap \in Saved /\ nav \in BOOLEAN /\ text \in Seqs(Cell, MaxLen) /\ tags \in Seqs(Origins, MaxLen) /\ Len(tags) = Len(text) + +\* Safety: a generated letter is never tagged user. The bot thread on PR 2421 asked for this per-position form. +NoGeneratedTagged == \A p \in 1..Len(tags) : tags[p] = "u" => text[p].o = "u" + +==== diff --git a/docs/architecture/tla/MentionRequestOrder.HistoryOff.cfg b/docs/architecture/tla/MentionRequestOrder.HistoryOff.cfg new file mode 100644 index 0000000000..8a12871b2e --- /dev/null +++ b/docs/architecture/tla/MentionRequestOrder.HistoryOff.cfg @@ -0,0 +1,6 @@ +SPECIFICATION Spec +CONSTANTS + HistoryGuard = "Off" + Guard = "On" + Order = "RowFirst" +INVARIANTS TypeOK NoSwitchAfterCancel NoSpinnerGap NoStaleReplacement diff --git a/docs/architecture/tla/MentionRequestOrder.NoGuard.cfg b/docs/architecture/tla/MentionRequestOrder.NoGuard.cfg new file mode 100644 index 0000000000..7080e16be5 --- /dev/null +++ b/docs/architecture/tla/MentionRequestOrder.NoGuard.cfg @@ -0,0 +1,6 @@ +SPECIFICATION Spec +CONSTANTS + HistoryGuard = "On" + Guard = "Off" + Order = "RowFirst" +INVARIANTS TypeOK NoSwitchAfterCancel NoSpinnerGap NoStaleReplacement diff --git a/docs/architecture/tla/MentionRequestOrder.WaitFirst.cfg b/docs/architecture/tla/MentionRequestOrder.WaitFirst.cfg new file mode 100644 index 0000000000..0191253546 --- /dev/null +++ b/docs/architecture/tla/MentionRequestOrder.WaitFirst.cfg @@ -0,0 +1,6 @@ +SPECIFICATION Spec +CONSTANTS + HistoryGuard = "On" + Guard = "On" + Order = "WaitFirst" +INVARIANTS TypeOK NoSwitchAfterCancel NoSpinnerGap NoStaleReplacement diff --git a/docs/architecture/tla/MentionRequestOrder.cfg b/docs/architecture/tla/MentionRequestOrder.cfg new file mode 100644 index 0000000000..8bc47ae46f --- /dev/null +++ b/docs/architecture/tla/MentionRequestOrder.cfg @@ -0,0 +1,6 @@ +SPECIFICATION Spec +CONSTANTS + HistoryGuard = "On" + Guard = "On" + Order = "RowFirst" +INVARIANTS TypeOK NoSwitchAfterCancel NoSpinnerGap NoStaleReplacement diff --git a/docs/architecture/tla/MentionRequestOrder.tla b/docs/architecture/tla/MentionRequestOrder.tla new file mode 100644 index 0000000000..ad46482cc4 --- /dev/null +++ b/docs/architecture/tla/MentionRequestOrder.tla @@ -0,0 +1,98 @@ +---- MODULE MentionRequestOrder ---- +\* Models startTask, userInputContent and the loop in src/core/task/Task.ts. +\* Source: startTask starts userInputContent without a wait. Sink: handleModeSwitch. +\* Failure 1: a slash command switches the mode of a task that the user cancelled. +\* Failure 2: the loop waits for the content before it shows the api_req_started row. +\* Invariants: NoSwitchAfterCancel and NoSpinnerGap. +\* Expected before the run: Guard On and RowFirst hold. Guard Off fails in 4 states. WaitFirst fails in 2. +\* Result: the fixed config holds in 60 states. NoGuard fails in 7 states. WaitFirst fails in 5 states. +\* Replay: Task.spec.ts "slash command mode switch". One test cancels from a TaskStarted listener while parseMentions waits. +\* The other tests cancel first. All of them fail without the guard. +\* The guard and the handleModeSwitch call run in one turn, so a cancel cannot fall between them. +\* Out of scope: a cancel inside handleModeSwitch itself, cross-host writes already in progress. +\* Cost: four TLC configs take about 4 seconds. Agent time is not measured. +\* Review: 0 covered, 2 added (bot thread on Task.ts, mode switch after cancel, PR 2421), 0 gap. +\* The first version came after the thread. It is not an independent first pass. + +\* Review ratchet: PR 2421 discussion_r4607106857 adds NoStaleReplacement. +\* Source: resumeTaskFromHistory starts expansion. Sink: overwriteApiConversationHistory. +\* Failure: a cancelled preparation replaces the history of a newer run. +\* Expected: the ownership guard blocks replacement. HistoryOff must fail. +\* Result: HistoryOff fails in 21 states. The fixed model finds no new failure. +\* Replay: Task.persistence.spec.ts tests cancel, dispose, abandon and generation changes. +\* All four tests fail when the callback guard is removed. No false alarm was retained. +\* The first history invariant follows the review. It is not independent. +VARIABLES aborted, content, row, loop, switchedAfterCancel, + revoked, newerHistory, preparation, staleReplacement + +CONSTANTS HistoryGuard, Guard, Order \* Guard: "On" or "Off". Order: "RowFirst" or "WaitFirst". + +historyVars == <> +vars == <> + +TypeOK == + /\ revoked \in BOOLEAN /\ newerHistory \in BOOLEAN + /\ preparation \in {"pending", "done"} /\ staleReplacement \in BOOLEAN + /\ aborted \in BOOLEAN + /\ content \in {"pending", "done"} + /\ row \in {"none", "shown"} + /\ loop \in {"idle", "waiting"} + /\ switchedAfterCancel \in BOOLEAN + +Init == + /\ revoked = FALSE /\ newerHistory = FALSE + /\ preparation = "pending" /\ staleReplacement = FALSE + /\ aborted = FALSE + /\ content = "pending" + /\ row = "none" + /\ loop = "idle" + /\ switchedAfterCancel = FALSE + +\* The user cancels the task at any time. A TaskStarted listener can do it. +Cancel == /\ aborted' = TRUE /\ revoked' = TRUE + /\ UNCHANGED <> + +\* The expansion ends. A command with a mode runs handleModeSwitch. The guard reads aborted. +Expand == + /\ content = "pending" + /\ content' = "done" + /\ switchedAfterCancel' = (switchedAfterCancel \/ (aborted /\ Guard = "Off")) + /\ UNCHANGED <> + +\* The loop shows the row, then waits. The loop does not run after a cancel. +ShowRow == + /\ ~aborted /\ row = "none" + /\ row' = "shown" + /\ UNCHANGED <> + +Wait == + /\ ~aborted /\ loop = "idle" + /\ \/ Order = "WaitFirst" + \/ row = "shown" + /\ loop' = "waiting" + /\ UNCHANGED <> + +\* Disposal or a generation change revokes the preparation without an abort flag. +Revoke == /\ revoked' = TRUE + /\ UNCHANGED <> + +SaveNewer == /\ revoked /\ newerHistory' = TRUE + /\ UNCHANGED <> + +\* The callback checks ownership before it calls the replacement sink. +Replace == /\ preparation = "pending" /\ preparation' = "done" + /\ staleReplacement' = (staleReplacement \/ + (newerHistory /\ (HistoryGuard = "Off" \/ ~revoked))) + /\ UNCHANGED <> + +Next == Cancel \/ Expand \/ ShowRow \/ Wait \/ Revoke \/ SaveNewer \/ Replace \/ UNCHANGED vars +NoStaleReplacement == ~staleReplacement +Spec == Init /\ [][Next]_vars + +\* Safety 1: no mode switch runs after the cancel. +NoSwitchAfterCancel == ~switchedAfterCancel + +\* Safety 2: the loop waits only after the row shows. +NoSpinnerGap == loop = "waiting" => row = "shown" + +==== diff --git a/docs/architecture/tla/QueueDrainRetry.Count.cfg b/docs/architecture/tla/QueueDrainRetry.Count.cfg new file mode 100644 index 0000000000..abecff587b --- /dev/null +++ b/docs/architecture/tla/QueueDrainRetry.Count.cfg @@ -0,0 +1,8 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "Count" + MaxMsgs = 2 + MaxCalls = 2 + MaxLate = 1 +INVARIANTS TypeOK NoEarlySend NoStranded +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueDrainRetry.Flag.cfg b/docs/architecture/tla/QueueDrainRetry.Flag.cfg new file mode 100644 index 0000000000..bdce9c9b87 --- /dev/null +++ b/docs/architecture/tla/QueueDrainRetry.Flag.cfg @@ -0,0 +1,8 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "Flag" + MaxMsgs = 2 + MaxCalls = 2 + MaxLate = 1 +INVARIANTS TypeOK NoEarlySend NoStranded +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueDrainRetry.FlagStranded.cfg b/docs/architecture/tla/QueueDrainRetry.FlagStranded.cfg new file mode 100644 index 0000000000..3eddf27c94 --- /dev/null +++ b/docs/architecture/tla/QueueDrainRetry.FlagStranded.cfg @@ -0,0 +1,8 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "Flag" + MaxMsgs = 2 + MaxCalls = 2 + MaxLate = 1 +INVARIANTS TypeOK NoStranded +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueDrainRetry.Global.cfg b/docs/architecture/tla/QueueDrainRetry.Global.cfg new file mode 100644 index 0000000000..57c8717bf3 --- /dev/null +++ b/docs/architecture/tla/QueueDrainRetry.Global.cfg @@ -0,0 +1,8 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "Global" + MaxMsgs = 2 + MaxCalls = 2 + MaxLate = 1 +INVARIANTS TypeOK NoEarlySend NoStranded +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueDrainRetry.None.cfg b/docs/architecture/tla/QueueDrainRetry.None.cfg new file mode 100644 index 0000000000..23abff4e45 --- /dev/null +++ b/docs/architecture/tla/QueueDrainRetry.None.cfg @@ -0,0 +1,8 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "None" + MaxMsgs = 2 + MaxCalls = 2 + MaxLate = 1 +INVARIANTS TypeOK NoEarlySend NoStranded +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueDrainRetry.cfg b/docs/architecture/tla/QueueDrainRetry.cfg new file mode 100644 index 0000000000..3efe73657a --- /dev/null +++ b/docs/architecture/tla/QueueDrainRetry.cfg @@ -0,0 +1,8 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "Snap" + MaxMsgs = 2 + MaxCalls = 2 + MaxLate = 1 +INVARIANTS TypeOK NoEarlySend NoStranded +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueDrainRetry.tla b/docs/architecture/tla/QueueDrainRetry.tla new file mode 100644 index 0000000000..ffa1ffb7ba --- /dev/null +++ b/docs/architecture/tla/QueueDrainRetry.tla @@ -0,0 +1,129 @@ +---- MODULE QueueDrainRetry ---- +\* Models processQueuedMessages and the stateChanged handler in src/core/task/Task.ts. +\* Source: a drain call finds every queued message held by an edit. Sink: commitEdit or a removal ends a hold. +\* Rule: a drain call can send only a message that was in the queue when the call ran. One call sends one message. +\* Failure 1: a blocked drain is lost, and a queued message waits with no drain owed to it. +\* Failure 2: a retry sends a message that arrived after every drain call. +\* Invariant NoStranded: a blocked call has a held message to wait for, or no queued message of its own. +\* Invariant NoEarlySend: each sent message was in the queue at some call, and sends do not exceed calls. +\* A message is queued (q), held by an edit (h), claimed by a consumer such as the ask loop (c), sent, or gone. +\* A call is blocked when no message is queued and an edit holds one. It keeps the ids that edits hold. +\* Modes: None (no retry), Flag (one retry), Count (one retry per blocked call), +\* Global (keeps ids, but sends the first queued message), Snap (keeps ids and sends a message from them). +\* Expected before the run: None and Flag fail NoStranded. Count fails NoEarlySend. Global fails NoStranded. Snap holds. +\* Result: QueueDrainRetry.cfg (Snap) holds. The None, Flag, Count and Global configs fail (see check.sh). +\* Review: PR 2421, CodeRabbit thread 1. Round 3 (lost drain) and round 4 (merged drains) were gaps in QueueEditRace. +\* Round 5 (a surplus retry takes a later message) is the Count failure. All three are one class: a retry count with no owner. +\* FlagStranded checks NoStranded alone. It fails on the merged drains: two calls, one send (PR 2421, bot comment on this spec). +\* Round 6 (a released consumer claim is sent before the edited message) is the Global failure. +\* Not modeled: the message text, the image scan, an edit that never commits and an edit of a late message. +\* Code check (step 10): MessageQueueService.interleavings.spec.ts runs both invariants on the real service in every order. +\* Cost: each run takes under 5 seconds. Agent time is not measured. +\* Why a second module: the variables differ from QueueEditRace, and joining them multiplies the states. + +EXTENDS Naturals, Sequences, FiniteSets + +CONSTANTS Mode, MaxMsgs, MaxCalls, MaxLate + +\* st: the state of each message. bl: the snapshots that the Snap mode keeps. blocked: the count of the other modes. +\* bg: the same snapshots as ghost data. A snapshot is the set of held messages when a call was blocked. +\* U: the messages that were in the queue at some call. +Ids == 1..(MaxMsgs + MaxLate) +VARIABLES st, bl, blocked, bg, U, calls +vars == <> + +Held(s) == {i \in Ids : s[i] = "h"} +Queued(s) == {i \in Ids : s[i] = "q"} +Taken(s) == {i \in Ids : s[i] \in {"h", "c"}} +FirstOf(s, S) == CHOOSE i \in S : \A j \in S : i <= j +SendFirst(s) == [s EXCEPT ![FirstOf(s, Queued(s))] = "sent"] +SendFrom(s, S) == [s EXCEPT ![FirstOf(s, Queued(s) \cap S)] = "sent"] + +\* Apply SendFirst n times, or until the queue is empty. +RECURSIVE SendN(_, _) +SendN(s, n) == IF n = 0 \/ Queued(s) = {} THEN s ELSE SendN(SendFirst(s), n - 1) + +\* The handler visits each snapshot in order. It drops a snapshot with no live message. +\* It sends once if a live message of the snapshot is queued. Otherwise it keeps the snapshot. +\* Snap sends a message of the snapshot. Global sends the first queued message. +RECURSIVE Proc(_, _, _) +Proc(s, rest, kept) == + IF rest = <<>> THEN <> + ELSE LET S == Head(rest) + live == {i \in S : s[i] \in {"q", "h", "c"}} + IN IF live = {} THEN Proc(s, Tail(rest), kept) + ELSE IF \E i \in live : s[i] = "q" + THEN Proc(IF Mode = "Snap" THEN SendFrom(s, S) ELSE SendFirst(s), Tail(rest), kept) + ELSE Proc(s, Tail(rest), Append(kept, S)) + +\* Each send retires one ghost snapshot: the first one that holds the sent message. +\* A ghost snapshot also ends when all of its messages are gone. +RECURSIVE Retire(_, _) +Retire(g, sentNow) == + IF sentNow = {} THEN g + ELSE LET i == CHOOSE j \in sentNow : \A m \in sentNow : j <= m + ks == {k \in 1..Len(g) : i \in g[k]} + k1 == CHOOSE k \in ks : \A m \in ks : k <= m + IN Retire(IF ks = {} THEN g ELSE SubSeq(g, 1, k1 - 1) \o SubSeq(g, k1 + 1, Len(g)), sentNow \ {i}) +Gone(S, s) == ~(\E i \in S : s[i] \in {"q", "h", "c"}) +\* old and new are the states before and after the sends. +Prune(g, old, new) == SelectSeq(Retire(g, {i \in Ids : new[i] = "sent" /\ old[i] # "sent"}), LAMBDA S : ~Gone(S, new)) + +\* The handler runs after each change of the queue state. s is the state before the retry. +Settle(s) == + CASE Mode = "None" -> [st |-> s, bl |-> bl, blocked |-> blocked] + [] Mode \in {"Snap", "Global"} -> LET r == Proc(s, bl, <<>>) IN [st |-> r[1], bl |-> r[2], blocked |-> blocked] + [] OTHER -> IF blocked > 0 /\ Held(s) = {} + THEN [st |-> SendN(s, IF Mode = "Flag" THEN 1 ELSE blocked), bl |-> bl, blocked |-> 0] + ELSE [st |-> s, bl |-> bl, blocked |-> blocked] + +Init == st = [i \in Ids |-> IF i <= MaxMsgs THEN "q" ELSE "new"] + /\ bl = <<>> /\ blocked = 0 /\ bg = <<>> /\ U = {} /\ calls = 0 + +Late(i) == /\ st[i] = "new" /\ (i = 1 \/ st[i-1] # "new") + /\ st' = [st EXCEPT ![i] = "q"] + /\ UNCHANGED <> + +Begin(i) == /\ st[i] = "q" + /\ st' = [st EXCEPT ![i] = "h"] + /\ UNCHANGED <> + +\* A consumer claims a queued message. +Claim(i) == /\ st[i] = "q" + /\ st' = [st EXCEPT ![i] = "c"] + /\ UNCHANGED <> + +\* A hold ends. The message returns to the queue (commit or release) or leaves it (remove or consume). Then the handler runs. +End(i, to) == + LET r == Settle([st EXCEPT ![i] = to]) + IN /\ st[i] \in {"h", "c"} + /\ st' = r.st /\ bl' = r.bl /\ blocked' = r.blocked + /\ bg' = Prune(bg, [st EXCEPT ![i] = to], r.st) + /\ UNCHANGED <> + +\* A drain call sends the first queued message. If every message is held, the call is blocked. +Call == /\ calls < MaxCalls + /\ calls' = calls + 1 + /\ U' = U \cup {i \in Ids : st[i] \in {"q", "h", "c"}} + /\ IF Queued(st) # {} + THEN /\ st' = SendFirst(st) /\ bg' = Prune(bg, st, SendFirst(st)) /\ UNCHANGED <> + ELSE /\ st' = st + /\ IF Held(st) = {} THEN UNCHANGED <> + ELSE /\ bg' = Append(bg, Held(st)) + /\ bl' = IF Mode \in {"Snap", "Global"} THEN Append(bl, Held(st)) ELSE bl + /\ blocked' = CASE Mode = "Flag" -> 1 + [] Mode = "Count" -> blocked + 1 + [] OTHER -> blocked + +Next == \/ \E i \in Ids : Late(i) \/ Begin(i) \/ Claim(i) \/ End(i, "q") \/ End(i, "gone") + \/ Call + +Spec == Init /\ [][Next]_vars + +TypeOK == /\ st \in [Ids -> {"new", "q", "h", "c", "sent", "gone"}] /\ Len(bl) <= MaxCalls /\ Len(bg) <= MaxCalls + /\ blocked \in 0..MaxCalls /\ calls \in 0..MaxCalls /\ U \subseteq Ids + +NoStranded == \A k \in 1..Len(bg) : (\E i \in bg[k] : st[i] \in {"h", "c"}) \/ ~(\E i \in bg[k] : st[i] = "q") +NoEarlySend == LET sent == {i \in Ids : st[i] = "sent"} IN sent \subseteq U /\ Cardinality(sent) <= calls + +==== diff --git a/docs/architecture/tla/QueueEditRace.Await.cfg b/docs/architecture/tla/QueueEditRace.Await.cfg new file mode 100644 index 0000000000..509d2cfba9 --- /dev/null +++ b/docs/architecture/tla/QueueEditRace.Await.cfg @@ -0,0 +1,7 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "Await" + MaxEdits = 2 +INVARIANTS TypeOK DrainedWhole +PROPERTIES Monotone +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueEditRace.Monotone.cfg b/docs/architecture/tla/QueueEditRace.Monotone.cfg new file mode 100644 index 0000000000..93a2647970 --- /dev/null +++ b/docs/architecture/tla/QueueEditRace.Monotone.cfg @@ -0,0 +1,6 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "Await" + MaxEdits = 2 +PROPERTIES Monotone +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueEditRace.Text.cfg b/docs/architecture/tla/QueueEditRace.Text.cfg new file mode 100644 index 0000000000..2849c9f67c --- /dev/null +++ b/docs/architecture/tla/QueueEditRace.Text.cfg @@ -0,0 +1,7 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "Text" + MaxEdits = 2 +INVARIANTS TypeOK DrainedWhole +PROPERTIES Monotone +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueEditRace.cfg b/docs/architecture/tla/QueueEditRace.cfg new file mode 100644 index 0000000000..d4bfbbd873 --- /dev/null +++ b/docs/architecture/tla/QueueEditRace.cfg @@ -0,0 +1,7 @@ +SPECIFICATION Spec +CONSTANTS + Mode = "Claim" + MaxEdits = 3 +INVARIANTS TypeOK DrainedWhole +PROPERTIES Monotone +CHECK_DEADLOCK FALSE diff --git a/docs/architecture/tla/QueueEditRace.tla b/docs/architecture/tla/QueueEditRace.tla new file mode 100644 index 0000000000..ba9f2ec77a --- /dev/null +++ b/docs/architecture/tla/QueueEditRace.tla @@ -0,0 +1,64 @@ +---- MODULE QueueEditRace ---- +\* Models editQueuedMessage in src/core/webview/webviewMessageHandler.ts and MessageQueueService. +\* Source: an edit arrives while a queue drain can run. Sink: dequeueMessage sends the text it holds. +\* Failure: a drain sends the text from before an edit, or the edited text without its image. +\* Invariant DrainedWhole: the drained source and image both belong to the latest edit begun before the drain. +\* Property Monotone: a late image resolve never replaces a newer source or newer images. +\* All edits have the same text. A text check cannot tell them apart. Only the source version can. +\* Modes: Await (update after the image scan), Text (update at once, attach images if the text is unchanged), +\* Claim (hold the message and commit text, source and images together, only for the latest edit). +\* First version (PR 2421, CodeRabbit thread 1): edits had distinct text. It hid the same-text case. +\* Result: "Await" fails DrainedWhole in 6 states. "Text" fails DrainedWhole in 6 states. "Claim" holds. +\* Review: 0 covered, 2 added (the await before the update; the same-text edit and the drained image), 3 gap. +\* The 3 gaps are the lost drain, the merged drains and the surplus retry. QueueDrainRetry.tla models them. +\* Not modeled: the image content, a failed scan (the handler then keeps the old images), and the webview. +\* Configs: QueueEditRace.cfg (Claim) must pass. Must fail: .Await, .Text (DrainedWhole) and .Monotone (Await, Monotone only). +\* Cost: each run takes under 5 seconds. Agent time is not measured. + +EXTENDS Naturals + +CONSTANTS Mode, MaxEdits + +VARIABLES present, src, imgs, began, latest, pend, claimed, drained +vars == <> + +Init == /\ present = TRUE /\ src = 0 /\ imgs = 0 /\ began = 0 /\ latest = 0 + /\ pend = {} /\ claimed = FALSE /\ drained = <<>> + +\* The handler receives edit v. A refused edit (message gone) is not counted. "Claim" holds the message. +Begin == /\ began < MaxEdits /\ present + /\ began' = began + 1 + /\ latest' = began + 1 + /\ pend' = pend \cup {began + 1} + /\ src' = IF Mode = "Text" THEN began + 1 ELSE src + /\ claimed' = (Mode = "Claim") + /\ UNCHANGED <> + +\* The scan for edit v ends. "Claim" commits only the latest edit and then lets the message go. +Resolve(v) == + /\ v \in pend + /\ pend' = pend \ {v} + /\ IF ~present THEN UNCHANGED <> + ELSE CASE Mode = "Await" -> /\ src' = v /\ imgs' = v /\ UNCHANGED claimed + [] Mode = "Text" -> /\ imgs' = v /\ UNCHANGED <> + [] OTHER -> IF v = latest THEN /\ src' = v /\ imgs' = v /\ claimed' = FALSE + ELSE UNCHANGED <> + /\ UNCHANGED <> + +\* The drain skips a claimed message. It removes the message and sends the source and images it holds. +Drain == /\ present /\ ~claimed + /\ present' = FALSE + /\ drained' = <> + /\ UNCHANGED <> + +Next == Begin \/ (\E v \in 1..MaxEdits : Resolve(v)) \/ Drain + +Spec == Init /\ [][Next]_vars + +TypeOK == /\ present \in BOOLEAN /\ claimed \in BOOLEAN /\ pend \subseteq 1..MaxEdits + /\ {src, imgs, began, latest} \subseteq 0..MaxEdits /\ (drained = <<>> \/ \E a, b, c \in 0..MaxEdits : drained = <>) + +DrainedWhole == drained # <<>> => drained[1] = drained[3] /\ drained[2] = drained[3] +Monotone == [][src' >= src /\ imgs' >= imgs]_vars + +==== diff --git a/docs/architecture/tla/check.sh b/docs/architecture/tla/check.sh new file mode 100755 index 0000000000..46cc6ee738 --- /dev/null +++ b/docs/architecture/tla/check.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash +# Runs every TLC config here. Spec.cfg must pass. Each Spec.Variant.cfg must fail. +# Usage: TLA_JAR=/path/to/tla2tools.jar ./check.sh Spec [Spec ...] +# TLA_JAR=/path/to/tla2tools.jar ./check.sh all (every spec, for a release or a change to this script) +set -u +cd "$(dirname "$0")" +: "${TLA_JAR:?set TLA_JAR to the tla2tools.jar path}" +meta=$(mktemp -d) +trap 'rm -rf "$meta"' EXIT +[ $# -gt 0 ] || { echo "name a spec, or use: all"; exit 2; } +specs="$*" +all=0 +[ "$specs" != all ] || { all=1; specs=$(ls *.tla | sed 's/\.tla$//'); } +bad=0 +for spec in $specs; do + [ -f "$spec.tla" ] || { echo "WRONG $spec.tla is missing"; bad=1; continue; } + if [ ! -f "$spec.cfg" ]; then + # A helper module has no configs. Under "all" it is not an error. + if [ $all = 1 ] && ! ls "$spec".*.cfg >/dev/null 2>&1; then continue; fi + echo "WRONG $spec.cfg is missing"; bad=1; continue + fi + for cfg in "$spec".cfg "$spec".*.cfg; do + [ -f "$cfg" ] || continue + want=pass + [ "$cfg" = "$spec.cfg" ] || want=fail + java -XX:+UseParallelGC -cp "$TLA_JAR" tlc2.TLC -metadir "$(mktemp -d -p "$meta")/s" -config "$cfg" "$spec.tla" >"$meta/out" 2>&1 + got=unknown + grep -q "No error has been found" "$meta/out" && got=pass + grep -q "violated" "$meta/out" && got=fail + states=$(grep -o '[0-9,]* distinct states found' "$meta/out" | head -1) + if [ "$got" = "$want" ]; then echo "ok $cfg ($want, $states)"; else echo "WRONG $cfg (want $want, got $got)"; bad=1; fi + done +done +exit $bad diff --git a/package.json b/package.json index 886f3886ff..f438decdbd 100644 --- a/package.json +++ b/package.json @@ -20,7 +20,7 @@ "test:agent-evals:unit": "node --import tsx --test scripts/agent-evals/*.test.ts", "agent-evals:check-types": "tsc -p scripts/agent-evals/tsconfig.json", "test:mutation-ci": "node --test scripts/stryker-diff.test.mjs", - "lifecycle:model-check": "tsx scripts/check-task-lifecycle.ts && tsx scripts/check-task-store-concurrency.ts && tsx scripts/check-provider-handoff-scheduler.ts && pnpm cleanup-protocol:model-check && pnpm parser-scope:model-check && tsx scripts/check-completion-persistence.ts && tsx scripts/check-file-replacement-restart.ts && tsx scripts/check-delegated-mode-readers.ts && pnpm tool-turn:model-check", + "lifecycle:model-check": "tsx scripts/check-task-lifecycle.ts && tsx scripts/check-task-store-concurrency.ts && tsx scripts/check-provider-handoff-scheduler.ts && pnpm cleanup-protocol:model-check && pnpm parser-scope:model-check && tsx scripts/check-completion-persistence.ts && tsx scripts/check-file-replacement-restart.ts && tsx scripts/check-delegated-mode-readers.ts && pnpm tool-turn:model-check && tsx scripts/check-queue-ask-landing.ts", "webview-recovery:model-check": "node --import tsx scripts/check-webview-recovery.ts", "webview-recovery:check-types": "tsc -p scripts/tsconfig.webview-recovery.json", "fanout-protocol:model-check": "tsx scripts/check-task-fanout-protocol.ts", diff --git a/packages/types/src/message.ts b/packages/types/src/message.ts index 6f5162544d..f50142602d 100644 --- a/packages/types/src/message.ts +++ b/packages/types/src/message.ts @@ -367,6 +367,18 @@ export const tokenUsageSchema = z.object({ export type TokenUsage = z.infer +/** + * MentionSegment + */ + +/** A part of a message with a known origin. Only `user` parts may have mentions expanded. */ +export const mentionSegmentSchema = z.object({ + text: z.string(), + source: z.enum(["user", "generated"]), +}) + +export type MentionSegment = z.infer + /** * QueuedMessage */ @@ -376,6 +388,8 @@ export const queuedMessageSchema = z.object({ id: z.string(), text: z.string(), images: z.array(z.string()).optional(), + /** Origin of each part of `text`. Absent means all generated. */ + segments: z.array(mentionSegmentSchema).optional(), }) export type QueuedMessage = z.infer diff --git a/packages/types/src/vscode-extension-host.ts b/packages/types/src/vscode-extension-host.ts index 3e23a7934c..2e9ea7ccb8 100644 --- a/packages/types/src/vscode-extension-host.ts +++ b/packages/types/src/vscode-extension-host.ts @@ -5,7 +5,7 @@ import type { ProviderSettings, ProviderSettingsEntry } from "./provider-setting import type { HistoryItem } from "./history.js" import type { ModeConfig, PromptComponent } from "./mode.js" import type { Experiments } from "./experiment.js" -import type { ClineMessage, QueuedMessage } from "./message.js" +import type { ClineMessage, MentionSegment, QueuedMessage } from "./message.js" import type { MarketplaceItem, MarketplaceInstalledMetadata, InstallMarketplaceItemOptions } from "./marketplace.js" import type { TodoItem } from "./todo.js" import type { CloudUserInfo, CloudOrganizationMembership, OrganizationAllowList, ShareVisibility } from "./cloud.js" @@ -163,6 +163,8 @@ export interface ExtensionMessage { | "switchTab" | "toggleAutoApprove" invoke?: "newChat" | "sendMessage" | "primaryButtonClick" | "secondaryButtonClick" | "setChatBoxMessage" + /** With `invoke: "setChatBoxMessage"`: origin of each part of `text`. Absent means all generated. */ + segments?: MentionSegment[] /** * Partial state updates are allowed to reduce message size (e.g. omit large fields like taskHistory). * The webview is responsible for merging. @@ -544,7 +546,15 @@ export interface UpdateTodoListPayload { todos: any[] } -export type EditQueuedMessagePayload = Pick +// Segments stay unknown. normalizeSegments fails closed on a bad list. +export const editQueuedMessagePayloadSchema = z.object({ + id: z.string(), + text: z.string(), + images: z.array(z.string()).optional(), + segments: z.unknown().optional(), +}) + +export type EditQueuedMessagePayload = z.infer export interface WebviewMessage { type: @@ -850,6 +860,8 @@ export interface WebviewMessage { updatedSettings?: RooCodeSettings /** Task configuration applied via `createTask()`. */ taskConfiguration?: RooCodeSettings + /** Origin of each part of `text`. Absent or not matching `text` means all generated. */ + segments?: MentionSegment[] // Worktree properties worktreePath?: string worktreeBranch?: string diff --git a/scripts/check-queue-ask-landing.ts b/scripts/check-queue-ask-landing.ts new file mode 100644 index 0000000000..4ea409d012 --- /dev/null +++ b/scripts/check-queue-ask-landing.ts @@ -0,0 +1,266 @@ +import assert from "node:assert/strict" + +import { MessageQueueService } from "../src/core/message-queue/MessageQueueService" +import { initialRunState, nextRunState, type RunEvent, type RunState } from "../src/core/task/run-state/runState" + +// Bounded model of where a queued message lands after the queue hands it to the task (#2421, finding V2). +// Real code: MessageQueueService (drain, beginEdit, commitEdit, claimNextMessage, the "drained" event) and +// the run-state kernel nextRunState (ask pending or not). +// Model abstractions, not imported code, because Task.ts needs VS Code: +// - the askResponse slot: Task.handleWebviewAskResponse sets it with no check for a pending ask, +// and every Task.ask() start resets it (Task.ts around L2063-2116); +// - the setTimeout(0) between a drain and Task.submitUserMessage, kept as an in-flight list. +// The queue is replayed from the action list for each state, because the service is mutable. +// Command policy, protected asks, message text and aborted tasks are outside this model. + +type Action = "add-a" | "add-b" | "edit-a" | "commit-a" | "drain" | "deliver" | "ask" | "consume" + +interface Policy { + name: string + // How Task.submitQueuedMessage lands a message that reaches the slot. + land: "always-set" | "set-if-ask-pending" | "requeue-unless-ask-and-empty-slot" +} + +const production: Policy = { name: "production", land: "always-set" } +// Proposed fix: set the slot only when an ask waits and the slot is empty. Otherwise keep the message queued. +const requeue: Policy = { name: "requeue-unless-ask-and-empty-slot", land: "requeue-unless-ask-and-empty-slot" } +// Injected unsafe fix: checks the ask but not the slot, so a second message overwrites the first. +const askOnly: Policy = { name: "set-if-ask-pending", land: "set-if-ask-pending" } + +const MAX_DEPTH = 10 +const MAX_STATES = 50_000 +const ACTIONS: Action[] = ["add-a", "add-b", "edit-a", "commit-a", "drain", "deliver", "ask", "consume"] + +class World { + readonly queue = new MessageQueueService() + run: RunState = initialRunState + slot: string | undefined + readonly inflight: string[] = [] + readonly consumed: string[] = [] + readonly lost: string[] = [] + readonly added: string[] = [] + private token: number | undefined + private askTs = 0 + readonly tags = new Set() + + constructor(private readonly policy: Policy) { + this.event({ tag: "initialized" }) + this.queue.on("drained", (message) => { + this.tags.add("drained-event") + this.inflight.push(message.text) + }) + } + + private event(event: RunEvent): void { + const result = nextRunState(this.run, event) + assert.ok("ok" in result, `run-state rejected ${event.tag}`) + this.run = result.ok + } + + private askPending(): boolean { + return this.run.ask.tag !== "none" + } + + private text(id: string): string | undefined { + return this.queue.messages.find((message) => message.id === id)?.text + } + + private idOf(text: string): string | undefined { + return this.queue.messages.find((message) => message.text === text)?.id + } + + // Task.handleWebviewAskResponse after submitUserMessage. + private land(text: string): void { + const { land } = this.policy + const askPending = this.askPending() + const slotFull = this.slot !== undefined + if (land === "requeue-unless-ask-and-empty-slot" && (!askPending || slotFull)) { + this.queue.addMessage(text) + this.tags.add(askPending ? "requeued-slot-full" : "requeued-no-ask") + return + } + if (land === "set-if-ask-pending" && !askPending) { + this.queue.addMessage(text) + return + } + if (this.slot !== undefined) { + this.lost.push(this.slot) + } + this.slot = text + } + + enabled(action: Action): boolean { + switch (action) { + case "add-a": + return !this.added.includes("a") + case "add-b": + return !this.added.includes("b") + case "edit-a": + return this.idOf("a") !== undefined && this.token === undefined + case "commit-a": + return this.token !== undefined + case "drain": + return !this.queue.isEmpty() + case "deliver": + return this.inflight.length > 0 + case "ask": + return !this.askPending() && this.askTs < 2 + case "consume": + return this.askPending() && this.slot !== undefined + } + } + + apply(action: Action): void { + switch (action) { + case "add-a": + case "add-b": { + const text = action.slice(-1) + this.added.push(text) + this.queue.addMessage(text) + return + } + case "edit-a": + this.token = this.queue.beginEdit(this.idOf("a")!) + return + case "commit-a": { + const id = this.idOf("a") + if (id !== undefined && this.token !== undefined) this.queue.commitEdit(id, this.token, "a") + this.token = undefined + return + } + case "drain": { + // Task.processQueuedMessages: drain, then submitQueuedMessage defers through setTimeout(0). + const message = this.queue.drain() + if (message) this.inflight.push(message.text) + return + } + case "deliver": + this.land(this.inflight.shift()!) + return + case "ask": { + // Task.ask() resets the slot, then the ask loop claims a queued message. + if (this.slot !== undefined) { + this.lost.push(this.slot) + this.slot = undefined + } + this.askTs += 1 + this.event({ tag: "askStarted", ask: { tag: "other", askTs: this.askTs } }) + const claimed = this.queue.claimNextMessage() + if (claimed) { + this.queue.removeMessage(claimed.id) + this.consumed.push(claimed.text) + this.event({ tag: "askSettled", askTs: this.askTs }) + } + return + } + case "consume": { + this.consumed.push(this.slot!) + this.slot = undefined + this.event({ tag: "askSettled", askTs: this.askTs }) + return + } + } + } + + violation(): string | undefined { + if (this.lost.length > 0) return `message ${this.lost[0]} was dropped` + const places = [ + ...this.queue.messages.map((message) => message.text), + ...(this.slot === undefined ? [] : [this.slot]), + ...this.inflight, + ...this.consumed, + ] + for (const text of this.added) { + const count = places.filter((place) => place === text).length + if (count === 0) return `message ${text} is nowhere` + if (count > 1) return `message ${text} is in ${count} places` + } + return undefined + } + + canonical(): string { + return JSON.stringify({ + queue: this.queue.messages.map((message) => message.text), + claimed: [...(this.queue["claimedMessageIds"] as Set)].map((id) => this.text(id) ?? "?").sort(), + edits: [...(this.queue["editTokens"] as Map).keys()].map((id) => this.text(id) ?? "?"), + blocked: (this.queue["blockedDrains"] as string[][]).map((ids) => ids.map((id) => this.text(id) ?? "?")), + slot: this.slot, + inflight: this.inflight, + consumed: this.consumed, + ask: this.run.ask.tag, + added: this.added, + editing: this.token !== undefined, + asks: this.askTs, + // Landmarks stay in the key, so a path that reaches one is not merged with a path that does not. + tags: [...this.tags].sort(), + }) + } +} + +function replay(policy: Policy, trace: Action[]): World { + const world = new World(policy) + for (const action of trace) world.apply(action) + return world +} + +interface Exploration { + violation?: { message: string; trace: Action[] } + states: number + tags: Set +} + +function explore(policy: Policy): Exploration { + const queue: Action[][] = [[]] + const visited = new Set([new World(policy).canonical()]) + const tags = new Set() + for (let index = 0; index < queue.length; index++) { + const trace = queue[index]! + const world = replay(policy, trace) + world.tags.forEach((tag) => tags.add(tag)) + const found = world.violation() + if (found) return { violation: { message: found, trace }, states: visited.size, tags } + if (trace.length === MAX_DEPTH) continue + for (const action of ACTIONS) { + if (!world.enabled(action)) continue + const next = [...trace, action] + const key = replay(policy, next).canonical() + if (visited.has(key)) continue + visited.add(key) + queue.push(next) + if (visited.size > MAX_STATES) throw new Error(`Queue landing model exceeded ${MAX_STATES} states`) + } + } + return { states: visited.size, tags } +} + +const format = (trace: Action[]): string => trace.map((action, index) => `${index + 1}. ${action}`).join("\n") + +// The proposed fix must be clean, with every landmark reachable. +const fixed = explore(requeue) +assert.equal( + fixed.violation, + undefined, + `Queue landing invariant failed under ${requeue.name}: ${fixed.violation?.message}\n${format(fixed.violation?.trace ?? [])}`, +) +const landmarks = ["drained-event", "requeued-no-ask"] +const missing = landmarks.filter((tag) => !fixed.tags.has(tag)) +assert.deepEqual(missing, [], `Queue landing model has unreachable landmarks: ${missing.join(", ")}`) + +// Injected unsafe policy: it must fail, so the invariant can see an overwrite. +const unsafe = explore(askOnly) +assert.ok(unsafe.violation, `Injected policy ${askOnly.name} must violate the invariant`) + +// Known gap (#2421 finding V2): production sets the slot with no ask pending, and the next ask() drops it. +// The requeue policy above is the proposed fix. This witness keeps the gap visible until production changes. +const gap = explore(production) +assert.ok(gap.violation, "Known queue landing gap no longer reproduces: update the model and the document") + +console.log( + `Queue landing model check passed: ${fixed.states} reachable states under ${requeue.name}, ${landmarks.length}/${landmarks.length} landmarks, depth <= ${MAX_DEPTH}`, +) +console.log( + `Known-unsafe witness: ${askOnly.name} (${unsafe.violation!.trace.length} steps: ${unsafe.violation!.message})`, +) +console.log( + `Known gap (message sent with no ask pending): ${gap.violation!.message} after ${gap.violation!.trace.length} steps\n${format(gap.violation!.trace)}`, +) diff --git a/src/core/assistant-message/__tests__/presentAssistantMessage-images.spec.ts b/src/core/assistant-message/__tests__/presentAssistantMessage-images.spec.ts index 74949a8742..de2735b2f4 100644 --- a/src/core/assistant-message/__tests__/presentAssistantMessage-images.spec.ts +++ b/src/core/assistant-message/__tests__/presentAssistantMessage-images.spec.ts @@ -64,6 +64,9 @@ describe("presentAssistantMessage - Image Handling in Native Tool Calling", () = currentStreamingContentIndex: 0, assistantMessageContent: [], userMessageContent: [], + userInputContent: vi.fn(async (text: string) => [ + { type: "text", text: `\n${text}\n` }, + ]), didCompleteReadingStream: false, didRejectTool: false, didAlreadyUseTool: false, @@ -381,13 +384,15 @@ describe("presentAssistantMessage - Image Handling in Native Tool Calling", () = await presentAssistantMessage(mockTask, baseSnapshot) - // Anthropic rejects user messages where image blocks sit between - // tool_result blocks, so images from both tools must be grouped - // after the last tool_result instead of interleaved. + // Images must come after all tool_result blocks (#1307). Feedback + // text blocks join the tail in push order. No image may appear + // before the second tool_result. expect(mockTask.userMessageContent.map((block: UserContentBlock) => block.type)).toEqual([ "tool_result", "tool_result", + "text", "image", + "text", "image", ]) expect( @@ -442,10 +447,14 @@ describe("presentAssistantMessage - Image Handling in Native Tool Calling", () = await presentAssistantMessage(mockTask, baseSnapshot) + // The image must come after the last tool_result (#1307), never + // between tool_result blocks. Feedback text joins the tail. expect(mockTask.userMessageContent.map((block: UserContentBlock) => block.type)).toEqual([ "tool_result", "tool_result", + "text", "image", + "text", ]) expect( mockTask.userMessageContent diff --git a/src/core/mentions/__tests__/processUserContentMentions.spec.ts b/src/core/mentions/__tests__/processUserContentMentions.spec.ts index 1995c36bc0..0f9fc03e8d 100644 --- a/src/core/mentions/__tests__/processUserContentMentions.spec.ts +++ b/src/core/mentions/__tests__/processUserContentMentions.spec.ts @@ -1,345 +1,127 @@ -// npx vitest core/mentions/__tests__/processUserContentMentions.spec.ts - -import { processUserContentMentions } from "../processUserContentMentions" +import type { MentionSegment } from "@roo-code/types" +import { expandUserMentions, wrapUserMessage } from "../processUserContentMentions" import { parseMentions } from "../index" import { FileContextTracker } from "../../context-tracking/FileContextTracker" -// Mock the parseMentions function -vi.mock("../index", () => ({ - parseMentions: vi.fn(), -})) +vi.mock("../index", () => ({ parseMentions: vi.fn() })) -describe("processUserContentMentions", () => { - let mockFileContextTracker: FileContextTracker +const user = (text: string): MentionSegment => ({ text, source: "user" }) +const gen = (text: string): MentionSegment => ({ text, source: "generated" }) +describe("expandUserMentions authorization", () => { beforeEach(() => { vi.clearAllMocks() - - mockFileContextTracker = {} as FileContextTracker - - // Default mock implementation - returns ParseMentionsResult object vi.mocked(parseMentions).mockImplementation(async (text) => ({ text: `parsed: ${text}`, - mode: undefined, - contentBlocks: [], + contentBlocks: [{ type: "file", path: "allowed", content: "file contents" }], + mode: "code", + slashCommandHelp: "command help", })) }) - describe("content processing", () => { - it("should process text blocks with tags", async () => { - const userContent = [ - { - type: "text" as const, - text: "Do something", - }, - ] - - const result = await processUserContentMentions({ - userContent, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - }) - - expect(parseMentions).toHaveBeenCalled() - expect(result.content[0]).toEqual({ - type: "text", - text: "parsed: Do something", - }) - expect(result.mode).toBeUndefined() - }) - - it("should not process text blocks without user_message tags", async () => { - const userContent = [ - { - type: "text" as const, - text: "Regular text without special tags", - }, - ] - - const result = await processUserContentMentions({ - userContent, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - }) - - expect(parseMentions).not.toHaveBeenCalled() - expect(result.content[0]).toEqual(userContent[0]) - expect(result.mode).toBeUndefined() - }) - - it("should process tool_result blocks with string content", async () => { - const userContent = [ - { - type: "tool_result" as const, - tool_use_id: "123", - content: "Tool feedback", - }, - ] - - const result = await processUserContentMentions({ - userContent, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - }) - - expect(parseMentions).toHaveBeenCalled() - // String content is now converted to array format to support content blocks - expect(result.content[0]).toEqual({ - type: "tool_result", - tool_use_id: "123", - content: [ - { - type: "text", - text: "parsed: Tool feedback", - }, - ], - }) - expect(result.mode).toBeUndefined() - }) - - it("should process tool_result blocks with array content", async () => { - const userContent = [ - { - type: "tool_result" as const, - tool_use_id: "123", - content: [ - { - type: "text" as const, - text: "Array task", - }, - { - type: "text" as const, - text: "Regular text", - }, - ], - }, - ] - - const result = await processUserContentMentions({ - userContent, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - }) - - expect(parseMentions).toHaveBeenCalledTimes(1) - expect(result.content[0]).toEqual({ - type: "tool_result", - tool_use_id: "123", - content: [ - { - type: "text", - text: "parsed: Array task", - }, - { - type: "text", - text: "Regular text", - }, - ], - }) - expect(result.mode).toBeUndefined() - }) - - it("should handle mixed content types (text + image)", async () => { - const userContent = [ - { - type: "text" as const, - text: "First task", - }, - { - type: "image" as const, - image: "base64data", - mediaType: "image/png", - }, - ] - - const result = await processUserContentMentions({ - userContent: userContent as any, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - }) - - expect(parseMentions).toHaveBeenCalledTimes(1) - expect(result.content).toHaveLength(2) - expect(result.content[0]).toEqual({ - type: "text", - text: "parsed: First task", - }) - expect(result.content[1]).toEqual(userContent[1]) // Image block unchanged - expect(result.mode).toBeUndefined() + const expand = (segments: MentionSegment[]) => + expandUserMentions({ segments, cwd: "/test", fileContextTracker: {} as FileContextTracker }) + + it("expands explicit user input without requiring a textual marker", async () => { + const result = await expand([user("@/allowed")]) + expect(parseMentions).toHaveBeenCalledWith( + "@/allowed", + "/test", + expect.anything(), + undefined, + false, + true, + 50, + undefined, + "code", + ) + expect(result).toEqual({ + content: [ + { type: "text", text: "parsed: @/allowed" }, + { type: "text", text: "file contents" }, + { type: "text", text: "command help" }, + ], + mode: "code", }) }) - describe("showRooIgnoredFiles parameter", () => { - it("should default showRooIgnoredFiles to false", async () => { - const userContent = [ - { - type: "text" as const, - text: "Test default", - }, - ] - - await processUserContentMentions({ - userContent, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - }) - - expect(parseMentions).toHaveBeenCalledWith( - "Test default", - "/test", - mockFileContextTracker, - undefined, - false, // showRooIgnoredFiles should default to false - true, // includeDiagnosticMessages - 50, // maxDiagnosticMessages - undefined, - "code", - ) - }) - - it("should respect showRooIgnoredFiles when explicitly set to false", async () => { - const userContent = [ - { - type: "text" as const, - text: "Test explicit false", - }, - ] - - await processUserContentMentions({ - userContent, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - showRooIgnoredFiles: false, - }) - - expect(parseMentions).toHaveBeenCalledWith( - "Test explicit false", - "/test", - mockFileContextTracker, - undefined, - false, - true, // includeDiagnosticMessages - 50, // maxDiagnosticMessages - undefined, - "code", - ) - }) + it("expands only the user segments of a support prompt", async () => { + const context = "@/secret @terminal" + const result = await expand([user("@/allowed"), gen(`\n${context}`)]) + expect(vi.mocked(parseMentions).mock.calls.map(([text]) => text)).toEqual(["@/allowed"]) + expect(result.content[0]).toEqual({ type: "text", text: `parsed: @/allowed\n${context}` }) }) - describe("slash command content processing", () => { - it("should separate slash command content into a new block", async () => { - vi.mocked(parseMentions).mockResolvedValueOnce({ - text: "parsed text", - slashCommandHelp: "command help", - mode: undefined, - contentBlocks: [], - }) + it("expands each user segment on its own and leaves generated segments unchanged", async () => { + const result = await expand([gen("a @/x "), user("@/one"), gen(" b @/y "), user("@/two")]) + expect(vi.mocked(parseMentions).mock.calls.map(([text]) => text)).toEqual(["@/one", "@/two"]) + expect(result.content[0]).toEqual({ type: "text", text: "a @/x parsed: @/one b @/y parsed: @/two" }) + }) - const userContent = [ - { - type: "text" as const, - text: "Run command", - }, - ] + it("expands the same text only where it is a user segment", async () => { + const result = await expand([gen("@/same "), user("@/same")]) + expect(vi.mocked(parseMentions).mock.calls.map(([text]) => text)).toEqual(["@/same"]) + expect(result.content[0]).toEqual({ type: "text", text: "@/same parsed: @/same" }) + }) - const result = await processUserContentMentions({ - userContent, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - }) + it.each([ + { label: "all generated", segments: [gen("@/secret")], text: "@/secret" }, + { label: "empty", segments: [], text: "" }, + ])("does not expand $label segments", async ({ segments, text }) => { + const result = await expand(segments) + expect(parseMentions).not.toHaveBeenCalled() + expect(result).toEqual({ content: [{ type: "text", text }], mode: undefined }) + }) - expect(result.content).toHaveLength(2) - expect(result.content[0]).toEqual({ - type: "text", - text: "parsed text", - }) - expect(result.content[1]).toEqual({ - type: "text", - text: "command help", - }) + it("wraps segments in tags that stay generated", async () => { + const result = await expand(wrapUserMessage([user("@/allowed")])) + expect(vi.mocked(parseMentions).mock.calls.map(([text]) => text)).toEqual(["@/allowed"]) + expect(result.content[0]).toEqual({ + type: "text", + text: "\nparsed: @/allowed\n", }) + }) - it("should include slash command content in tool_result string content", async () => { - vi.mocked(parseMentions).mockResolvedValueOnce({ - text: "parsed tool output", - slashCommandHelp: "command help", - mode: undefined, - contentBlocks: [], - }) - - const userContent = [ - { - type: "tool_result" as const, - tool_use_id: "123", - content: "Tool output", - }, - ] - - const result = await processUserContentMentions({ - userContent, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - }) - - expect(result.content).toHaveLength(1) - expect(result.content[0]).toEqual({ - type: "tool_result", - tool_use_id: "123", - content: [ - { - type: "text", - text: "parsed tool output", - }, - { - type: "text", - text: "command help", - }, - ], - }) + it.each([ + { showRooIgnoredFiles: true, includeDiagnosticMessages: false, maxDiagnosticMessages: 3, currentMode: "ask" }, + { showRooIgnoredFiles: false, includeDiagnosticMessages: true, maxDiagnosticMessages: 50, currentMode: "code" }, + ])("passes the flags to parseMentions: %o", async (flags) => { + await expandUserMentions({ + segments: [user("@/allowed")], + cwd: "/test", + fileContextTracker: {} as FileContextTracker, + ...flags, }) + expect(parseMentions).toHaveBeenCalledWith( + "@/allowed", + "/test", + expect.anything(), + undefined, + flags.showRooIgnoredFiles, + flags.includeDiagnosticMessages, + flags.maxDiagnosticMessages, + undefined, + flags.currentMode, + ) + }) - it("should include slash command content in tool_result array content", async () => { - vi.mocked(parseMentions).mockResolvedValueOnce({ - text: "parsed array item", - slashCommandHelp: "command help", - mode: undefined, - contentBlocks: [], - }) - - const userContent = [ - { - type: "tool_result" as const, - tool_use_id: "123", - content: [ - { - type: "text" as const, - text: "Array item", - }, - ], - }, - ] - - const result = await processUserContentMentions({ - userContent, - cwd: "/test", - fileContextTracker: mockFileContextTracker, - }) + it("keeps the mode of the first slash command", async () => { + vi.mocked(parseMentions) + .mockResolvedValueOnce({ text: "one", contentBlocks: [], mode: "architect" }) + .mockResolvedValueOnce({ text: "two", contentBlocks: [], mode: "debug" }) + const result = await expand([user("/a"), gen(" "), user("/b")]) + expect(result.mode).toBe("architect") + }) - expect(result.content).toHaveLength(1) - expect(result.content[0]).toEqual({ - type: "tool_result", - tool_use_id: "123", - content: [ - { - type: "text", - text: "parsed array item", - }, - { - type: "text", - text: "command help", - }, - ], - }) - }) + it("orders the extra blocks by segment after the text block", async () => { + vi.mocked(parseMentions) + .mockResolvedValueOnce({ text: "one", contentBlocks: [{ type: "file", path: "a", content: "A" }] }) + .mockResolvedValueOnce({ text: "two", contentBlocks: [{ type: "file", path: "b", content: "B" }] }) + const result = await expand([user("@/a"), gen(" "), user("@/b")]) + expect(result.content).toEqual([ + { type: "text", text: "one two" }, + { type: "text", text: "A" }, + { type: "text", text: "B" }, + ]) }) }) diff --git a/src/core/mentions/__tests__/resolveImageMentions.spec.ts b/src/core/mentions/__tests__/resolveImageMentions.spec.ts index c0c57d3f63..56000fe70d 100644 --- a/src/core/mentions/__tests__/resolveImageMentions.spec.ts +++ b/src/core/mentions/__tests__/resolveImageMentions.spec.ts @@ -237,6 +237,38 @@ describe("resolveImageMentions", () => { expect(result.images).toHaveLength(1) }) + it("should not let a kept mention take the last slot from a new mention", async () => { + const url = (name: string) => `data:image/png;base64,${Buffer.from(name).toString("base64")}` + const existing = [url("a.png"), ...Array.from({ length: 18 }, (_, i) => url(`pasted-${i}`))] + mockReadImageAsDataUrl.mockImplementation(async (file) => { + const dataUrl = url(path.basename(file)) + return { dataUrl, buffer: Buffer.from(dataUrl) } + }) + + const result = await resolveImageMentions({ + text: "@/a.png and @/b.png", + images: existing, + cwd: "/workspace", + }) + + expect(result.images).toEqual([...existing, url("b.png")]) + }) + + it("should validate and read a repeated mention path once", async () => { + const dataUrl = `data:image/png;base64,${Buffer.from("png-bytes").toString("base64")}` + mockReadImageAsDataUrl.mockResolvedValue({ dataUrl, buffer: Buffer.from("png-bytes") }) + + const result = await resolveImageMentions({ + text: Array.from({ length: 50 }, () => "@/a.png").join(" "), + images: [], + cwd: "/workspace", + }) + + expect(mockReadImageAsDataUrl).toHaveBeenCalledTimes(1) + expect(mockValidateImage).toHaveBeenCalledTimes(1) + expect(result.images).toEqual([dataUrl]) + }) + it("should skip images when supportsImages is false", async () => { const dataUrl = `data:image/png;base64,${Buffer.from("png-bytes").toString("base64")}` mockReadImageAsDataUrl.mockResolvedValue({ dataUrl, buffer: Buffer.from("png-bytes") }) diff --git a/src/core/mentions/index.ts b/src/core/mentions/index.ts index 23a27f39b5..7fcfac241b 100644 --- a/src/core/mentions/index.ts +++ b/src/core/mentions/index.ts @@ -456,6 +456,6 @@ export async function getLatestTerminalOutput(): Promise { } } -// Export processUserContentMentions from its own file -export { processUserContentMentions } from "./processUserContentMentions" -export type { ProcessUserContentMentionsResult } from "./processUserContentMentions" +// Export expandUserMentions from its own file +export { expandUserMentions } from "./processUserContentMentions" +export type { ExpandUserMentionsResult } from "./processUserContentMentions" diff --git a/src/core/mentions/processUserContentMentions.ts b/src/core/mentions/processUserContentMentions.ts index 0a8ad40dfa..dde0ddd2b2 100644 --- a/src/core/mentions/processUserContentMentions.ts +++ b/src/core/mentions/processUserContentMentions.ts @@ -1,15 +1,23 @@ import Anthropic from "@anthropic-ai/sdk" +import type { MentionSegment } from "@roo-code/types" import { parseMentions, MentionContentBlock } from "./index" import { FileContextTracker } from "../context-tracking/FileContextTracker" import type { SkillLookup } from "../../services/skills/skillInvocation" -// Internal aliases for the Anthropic content block subtypes used during processing. type TextPart = Anthropic.Messages.TextBlockParam -type ImagePart = Anthropic.Messages.ImageBlockParam -export interface ProcessUserContentMentionsResult { - content: Anthropic.Messages.ContentBlockParam[] +/** Wraps segments in the `` tags. The tags are generated text. */ +export function wrapUserMessage(segments: MentionSegment[]): MentionSegment[] { + return [ + { text: "\n", source: "generated" }, + ...segments, + { text: "\n", source: "generated" }, + ] +} + +export interface ExpandUserMentionsResult { + content: TextPart[] mode?: string // Mode from the first slash command that has one } @@ -26,14 +34,11 @@ function contentBlocksToTextParts(contentBlocks: MentionContentBlock[]): TextPar } /** - * Process mentions in user content, specifically within task and feedback tags. - * - * File/folder @ mentions are now returned as separate text blocks that - * look like read_file tool results, making it clear to the model that - * the file has already been read. + * Expand mentions in the user segments only. Call it where user input enters the task. + * Generated segments pass through unchanged. */ -export async function processUserContentMentions({ - userContent, +export async function expandUserMentions({ + segments, cwd, fileContextTracker, rooIgnoreController, @@ -43,7 +48,7 @@ export async function processUserContentMentions({ skillsManager, currentMode = "code", }: { - userContent: Anthropic.Messages.ContentBlockParam[] + segments: MentionSegment[] cwd: string fileContextTracker: FileContextTracker rooIgnoreController?: any @@ -52,173 +57,38 @@ export async function processUserContentMentions({ maxDiagnosticMessages?: number skillsManager?: SkillLookup currentMode?: string -}): Promise { - // Track the first mode found from slash commands +}): Promise { let commandMode: string | undefined - - // Process userContent array, which contains text and image parts. - // We need to apply parseMentions() to TextPart's text that contains "". - const content = ( - await Promise.all( - userContent.map(async (block) => { - const shouldProcessMentions = (text: string) => text.includes("") - - if (block.type === "text") { - if (shouldProcessMentions(block.text)) { - const result = await parseMentions( - block.text, - cwd, - fileContextTracker, - rooIgnoreController, - showRooIgnoredFiles, - includeDiagnosticMessages, - maxDiagnosticMessages, - skillsManager, - currentMode, - ) - // Capture the first mode found - if (!commandMode && result.mode) { - commandMode = result.mode - } - - // Build the blocks array: - // 1. User's text (with @ mentions replaced by clean paths) - // 2. File/folder content blocks (formatted like read_file results) - // 3. Slash command help (if any) - const blocks: Array = [ - { - ...block, - text: result.text, - }, - ] - - // Add file/folder content as separate blocks - if (result.contentBlocks.length > 0) { - blocks.push(...contentBlocksToTextParts(result.contentBlocks)) - } - - if (result.slashCommandHelp) { - blocks.push({ - type: "text" as const, - text: result.slashCommandHelp, - }) - } - return blocks - } - - return block - } else if (block.type === "tool_result") { - if (typeof block.content === "string") { - if (shouldProcessMentions(block.content)) { - const result = await parseMentions( - block.content, - cwd, - fileContextTracker, - rooIgnoreController, - showRooIgnoredFiles, - includeDiagnosticMessages, - maxDiagnosticMessages, - skillsManager, - currentMode, - ) - // Capture the first mode found - if (!commandMode && result.mode) { - commandMode = result.mode - } - - // Build content array with file blocks included - const contentParts: Array<{ type: "text"; text: string }> = [ - { - type: "text" as const, - text: result.text, - }, - ] - - // Add file/folder content blocks - for (const contentBlock of result.contentBlocks) { - contentParts.push({ - type: "text" as const, - text: contentBlock.content, - }) - } - - if (result.slashCommandHelp) { - contentParts.push({ - type: "text" as const, - text: result.slashCommandHelp, - }) - } - - return { - ...block, - content: contentParts, - } - } - - return block - } else if (Array.isArray(block.content)) { - const parsedContent = ( - await Promise.all( - block.content.map(async (contentBlock) => { - if (contentBlock.type === "text" && shouldProcessMentions(contentBlock.text)) { - const result = await parseMentions( - contentBlock.text, - cwd, - fileContextTracker, - rooIgnoreController, - showRooIgnoredFiles, - includeDiagnosticMessages, - maxDiagnosticMessages, - skillsManager, - currentMode, - ) - // Capture the first mode found - if (!commandMode && result.mode) { - commandMode = result.mode - } - - // Build blocks array with file content - const blocks: Array<{ type: "text"; text: string }> = [ - { - ...contentBlock, - text: result.text, - }, - ] - - // Add file/folder content blocks - for (const cb of result.contentBlocks) { - blocks.push({ - type: "text" as const, - text: cb.content, - }) - } - - if (result.slashCommandHelp) { - blocks.push({ - type: "text" as const, - text: result.slashCommandHelp, - }) - } - return blocks - } - - return contentBlock - }), - ) - ).flat() - - return { ...block, content: parsedContent } - } - - return block - } - - // Legacy backward compat: tool_result / tool-result blocks from older formats - // are passed through unchanged (tool results are now in separate RooToolMessages). - return block - }), + let text = "" + const extra: TextPart[] = [] + + for (const segment of segments) { + if (segment.source !== "user") { + text += segment.text + continue + } + const result = await parseMentions( + segment.text, + cwd, + fileContextTracker, + rooIgnoreController, + showRooIgnoredFiles, + includeDiagnosticMessages, + maxDiagnosticMessages, + skillsManager, + currentMode, ) - ).flat() - - return { content: content as Anthropic.Messages.ContentBlockParam[], mode: commandMode } + // Capture the first mode found + if (!commandMode && result.mode) { + commandMode = result.mode + } + text += result.text + // File/folder content as separate blocks (formatted like read_file results) + extra.push(...contentBlocksToTextParts(result.contentBlocks)) + if (result.slashCommandHelp) { + extra.push({ type: "text", text: result.slashCommandHelp }) + } + } + + return { content: [{ type: "text", text }, ...extra], mode: commandMode } } diff --git a/src/core/mentions/resolveImageMentions.ts b/src/core/mentions/resolveImageMentions.ts index b4b905c5c2..c240cb87a2 100644 --- a/src/core/mentions/resolveImageMentions.ts +++ b/src/core/mentions/resolveImageMentions.ts @@ -70,7 +70,7 @@ export async function resolveImageMentions({ maxImageFileSize = DEFAULT_MAX_IMAGE_FILE_SIZE_MB, maxTotalImageSize = DEFAULT_MAX_TOTAL_IMAGE_SIZE_MB, }: ResolveImageMentionsOptions): Promise { - const existingImages = Array.isArray(images) ? images : [] + const existingImages = Array.isArray(images) ? dedupePreserveOrder(images) : [] if (existingImages.length >= MAX_IMAGES_PER_MESSAGE) { return { text, images: existingImages.slice(0, MAX_IMAGES_PER_MESSAGE) } } @@ -100,6 +100,7 @@ export async function resolveImageMentions({ const imageMemoryTracker = new ImageMemoryTracker() const newImages: string[] = [] + const seenPaths = new Set() for (const mention of imageMentions) { if (existingImages.length + newImages.length >= MAX_IMAGES_PER_MESSAGE) { @@ -108,6 +109,11 @@ export async function resolveImageMentions({ const relPath = unescapeSpaces(mention.slice(1)) const absPath = path.resolve(cwd, relPath) + // A repeated path is read once. Check it before the validation and the read. + if (seenPaths.has(absPath)) { + continue + } + seenPaths.add(absPath) if (!isPathWithinCwd(absPath, cwd)) { continue } @@ -136,6 +142,10 @@ export async function resolveImageMentions({ // Fail-soft: skip formats unsupported by the shared image-block contract. continue } + // An image that is already attached takes no slot, so a kept mention cannot crowd out a new one. + if (existingImages.includes(dataUrl) || newImages.includes(dataUrl)) { + continue + } newImages.push(dataUrl) // Track memory usage diff --git a/src/core/message-queue/MessageQueueService.ts b/src/core/message-queue/MessageQueueService.ts index 340fad6087..d9604fdf5b 100644 --- a/src/core/message-queue/MessageQueueService.ts +++ b/src/core/message-queue/MessageQueueService.ts @@ -2,15 +2,23 @@ import { EventEmitter } from "events" import { v4 as uuidv4 } from "uuid" -import { QueuedMessage } from "@roo-code/types" +import type { MentionSegment, QueuedMessage } from "@roo-code/types" + +import { normalizeSegments } from "../../shared/mentionSegments" export interface QueueEvents { stateChanged: [messages: QueuedMessage[]] + /** A blocked drain found a message. The consumer sends it. */ + drained: [message: QueuedMessage] } export class MessageQueueService extends EventEmitter { private _messages: QueuedMessage[] private claimedMessageIds = new Set() + private editTokens = new Map() + private editSeq = 0 + // Each blocked drain keeps the ids that edits held. See docs/architecture/tla/QueueDrainRetry.tla. + private blockedDrains: string[][] = [] constructor() { super() @@ -28,7 +36,7 @@ export class MessageQueueService extends EventEmitter { return { index, message: this._messages[index] } } - public addMessage(text: string, images?: string[]): QueuedMessage | undefined { + public addMessage(text: string, images?: string[], segments?: MentionSegment[]): QueuedMessage | undefined { if (!text && !images?.length) { return undefined } @@ -38,6 +46,7 @@ export class MessageQueueService extends EventEmitter { id: uuidv4(), text, images, + segments, } this._messages.push(message) @@ -55,21 +64,47 @@ export class MessageQueueService extends EventEmitter { this._messages.splice(index, 1) this.claimedMessageIds.delete(id) + this.editTokens.delete(id) this.emit("stateChanged", this._messages) + this.serveBlockedDrains() return true } - public updateMessage(id: string, text: string, images?: string[]): boolean { + /** + * An edit holds the message, so a drain skips it until the edit commits. A newer edit replaces an older + * one, and only the newest commits. Returns no token if the message is gone or a consumer holds it. + * See docs/architecture/tla/QueueEditRace.tla. + */ + public beginEdit(id: string): number | undefined { const { message } = this.findMessage(id) - if (!message) { + if (!message || (this.claimedMessageIds.has(id) && !this.editTokens.has(id))) { + return undefined + } + + this.claimedMessageIds.add(id) + const token = ++this.editSeq + this.editTokens.set(id, token) + return token + } + + /** Sets text, segments and images together for the newest edit, then lets the message go. */ + public commitEdit(id: string, token: number, text: string, images?: string[], segments?: unknown): boolean { + const { message } = this.findMessage(id) + + if (!message || this.editTokens.get(id) !== token) { return false } + // The editor tags each input event. A diff of the saved text would tag generated text user. + message.segments = normalizeSegments(text, segments) message.timestamp = Date.now() message.text = text message.images = images + this.editTokens.delete(id) + this.claimedMessageIds.delete(id) this.emit("stateChanged", this._messages) + this.serveBlockedDrains() return true } @@ -83,6 +118,38 @@ export class MessageQueueService extends EventEmitter { return message } + /** + * One drain call. It returns the next message. If edits hold every message, the call waits. + * The "drained" event then sends one of the held messages when its edit ends. + */ + public drain(): QueuedMessage | undefined { + const message = this.dequeueMessage() + if (!message && this.editTokens.size > 0) { + this.blockedDrains.push([...this.editTokens.keys()]) + } + return message + } + + // A blocked drain sends one message of its own ids. It ends when all of them are gone. + private serveBlockedDrains(): void { + const pending = this.blockedDrains + this.blockedDrains = [] + for (const ids of pending) { + const live = this._messages.filter((message) => ids.includes(message.id)) + if (live.length === 0) { + continue + } + const next = live.find((message) => !this.claimedMessageIds.has(message.id)) + if (!next) { + this.blockedDrains.push(ids) + continue + } + this._messages.splice(this._messages.indexOf(next), 1) + this.emit("stateChanged", this._messages) + this.emit("drained", next) + } + } + public claimNextMessage(): QueuedMessage | undefined { const message = this._messages.find((candidate) => !this.claimedMessageIds.has(candidate.id)) if (message) { @@ -96,7 +163,11 @@ export class MessageQueueService extends EventEmitter { * Durable consumers must use removeMessage() only after their persistence write succeeds. */ public releaseMessage(messageId: string): boolean { - return this.claimedMessageIds.delete(messageId) + const released = this.claimedMessageIds.delete(messageId) + if (released) { + this.serveBlockedDrains() + } + return released } public get messages(): QueuedMessage[] { @@ -123,6 +194,8 @@ export class MessageQueueService extends EventEmitter { public dispose(): void { this._messages = [] this.claimedMessageIds.clear() + this.editTokens.clear() + this.blockedDrains = [] this.removeAllListeners() } } diff --git a/src/core/message-queue/__tests__/MessageQueueService.interleavings.spec.ts b/src/core/message-queue/__tests__/MessageQueueService.interleavings.spec.ts new file mode 100644 index 0000000000..23177b4c26 --- /dev/null +++ b/src/core/message-queue/__tests__/MessageQueueService.interleavings.spec.ts @@ -0,0 +1,217 @@ +import type { QueuedMessage } from "@roo-code/types" + +import { MessageQueueService } from "../MessageQueueService" + +// Explores every order of edits, consumer claims, late messages and drain calls on the real service. +// It checks the invariants of docs/architecture/tla/QueueDrainRetry.tla. The model is an abstraction. +// This test runs the code. +const INITIAL = 2 +const TOTAL = 3 +const MAX_CALLS = 2 + +type Action = + | { kind: "late" } + | { kind: "call" } + | { kind: "claim" } + | { kind: "begin" | "commit" | "remove" | "release" | "consume"; i: number } + +class World { + service = new MessageQueueService() + ids: string[] = [] + editing = new Map() + consumerHeld = new Set() + sent = new Set() + seen = new Set() + calls = 0 + ghost: Set[] = [] + retired = new Set() + + constructor() { + for (let i = 0; i < INITIAL; i++) this.ids.push(this.service.addMessage(`m${i}`)!.id) + this.service.on("drained", (message: QueuedMessage) => this.sent.add(message.id)) + } + + private alive(id: string) { + return this.service.messages.some((message) => message.id === id) + } + + private queued(id: string) { + return this.alive(id) && !this.editing.has(id) && !this.consumerHeld.has(id) + } + + apply(action: Action): boolean { + const id = "i" in action ? this.ids[action.i] : undefined + switch (action.kind) { + case "late": + if (this.ids.length >= TOTAL) return false + this.ids.push(this.service.addMessage("late")!.id) + return true + case "begin": { + if (!id) return false + const token = this.service.beginEdit(id) + if (token === undefined) return false + this.editing.set(id, token) + return true + } + case "commit": { + if (!id || !this.editing.has(id)) return false + this.service.commitEdit(id, this.editing.get(id)!, "edited") + this.editing.delete(id) + return true + } + case "remove": { + if (!id || !this.alive(id)) return false + this.service.removeMessage(id) + this.editing.delete(id) + this.consumerHeld.delete(id) + return true + } + case "claim": { + const message = this.service.claimNextMessage() + if (!message) return false + this.consumerHeld.add(message.id) + return true + } + case "release": + case "consume": { + if (!id || !this.consumerHeld.has(id)) return false + this.consumerHeld.delete(id) + if (action.kind === "release") this.service.releaseMessage(id) + else this.service.removeMessage(id) + return true + } + case "call": { + if (this.calls >= MAX_CALLS) return false + this.calls++ + for (const message of this.service.messages) this.seen.add(message.id) + const message = this.service.drain() + if (message) this.sent.add(message.id) + else if (this.editing.size > 0) this.ghost.push(new Set(this.editing.keys())) + return true + } + } + } + + // Each send retires the first snapshot that holds the sent message. A snapshot also ends when all its messages are gone. + violation(): string | undefined { + for (const id of this.sent) if (!this.seen.has(id)) return `sent ${id} that no call saw` + if (this.sent.size > this.calls) return "more sends than calls" + for (const id of this.sent) { + if (this.retired.has(id)) continue + this.retired.add(id) + const k = this.ghost.findIndex((s) => s.has(id)) + if (k !== -1) this.ghost.splice(k, 1) + } + this.ghost = this.ghost.filter((s) => [...s].some((id) => this.alive(id))) + for (const s of this.ghost) { + const waiting = [...s].some((id) => this.editing.has(id) || this.consumerHeld.has(id)) + if (!waiting && [...s].some((id) => this.queued(id))) return "a blocked drain left its message queued" + } + return undefined + } + + // Random ids differ on each replay. The key uses the message index. + key(): string { + const q = this.service + const ix = (id: string) => this.ids.indexOf(id) + const sorted = (ids: Iterable) => [...ids].map(ix).sort() + return JSON.stringify([ + q.messages.map((m) => ix(m.id)), + sorted(q["claimedMessageIds"]), + sorted(q["editTokens"].keys()), + q["blockedDrains"].map((ids) => sorted(ids)), + this.ids.length, + sorted(this.consumerHeld), + sorted(this.sent), + sorted(this.seen), + this.calls, + this.ghost.map((s) => sorted(s)), + sorted(this.retired), + ]) + } +} + +const actions = (): Action[] => [ + { kind: "late" }, + { kind: "call" }, + { kind: "claim" }, + ...(["begin", "commit", "remove", "release", "consume"] as const).flatMap((kind) => + Array.from({ length: TOTAL }, (_, i) => ({ kind, i })), + ), +] + +function replay(path: Action[]): World { + const world = new World() + for (const action of path) world.apply(action) + return world +} + +// Breadth-first over distinct states. Each state is rebuilt by replay, so it uses only the public API. +function explore(): { states: number; failure?: { path: Action[]; why: string } } { + const seen = new Set([new World().key()]) + let frontier: Action[][] = [[]] + while (frontier.length > 0) { + const next: Action[][] = [] + for (const path of frontier) { + for (const action of actions()) { + const world = replay(path) + if (!world.apply(action)) continue + const why = world.violation() + if (why) return { states: seen.size, failure: { path: [...path, action], why } } + const key = world.key() + if (!seen.has(key)) { + seen.add(key) + next.push([...path, action]) + } + } + } + frontier = next + } + return { states: seen.size } +} + +describe("MessageQueueService drain interleavings", () => { + it("keeps both invariants in every order", () => { + const result = explore() + expect(result.failure).toBeUndefined() + expect(result.states).toBeGreaterThan(500) + }) + + it("finds the failure when two blocked drains share one retry", () => { + const proto = MessageQueueService.prototype + const original = proto.drain + proto.drain = function (this: MessageQueueService) { + const message = original.call(this) + if (!message) this["blockedDrains"] = this["blockedDrains"].slice(0, 1) + return message + } + try { + expect(explore().failure?.why).toBe("a blocked drain left its message queued") + } finally { + proto.drain = original + } + }) + + it("finds the failure when a retry sends the first queued message", () => { + const proto = MessageQueueService.prototype + const original = proto["serveBlockedDrains"] + proto["serveBlockedDrains"] = function (this: MessageQueueService) { + const pending = this["blockedDrains"] + this["blockedDrains"] = [] + for (const ids of pending) { + const live = this.messages.filter((m) => ids.includes(m.id)) + if (live.length === 0) continue + if (live.every((m) => this["claimedMessageIds"].has(m.id))) this["blockedDrains"].push(ids) + else { + const next = this.dequeueMessage() + if (next) this.emit("drained", next) + } + } + } + try { + expect(explore().failure?.why).toBe("a blocked drain left its message queued") + } finally { + proto["serveBlockedDrains"] = original + } + }) +}) diff --git a/src/core/message-queue/__tests__/MessageQueueService.spec.ts b/src/core/message-queue/__tests__/MessageQueueService.spec.ts index 567dca314b..55d195b2e3 100644 --- a/src/core/message-queue/__tests__/MessageQueueService.spec.ts +++ b/src/core/message-queue/__tests__/MessageQueueService.spec.ts @@ -68,3 +68,127 @@ describe("MessageQueueService claims", () => { expect(queue.hasUnclaimed()).toBe(true) }) }) + +// Runs one whole edit the way the handler does. +const edit = (queue: MessageQueueService, id: string, text: string, images?: string[], segments?: unknown) => + queue.commitEdit(id, queue.beginEdit(id)!, text, images, segments) + +describe("MessageQueueService segments", () => { + it("stores the segments with the message", () => { + const queue = new MessageQueueService() + const segments = [ + { text: "ctx ", source: "generated" as const }, + { text: "mine", source: "user" as const }, + ] + expect(queue.addMessage("ctx mine", undefined, segments)?.segments).toEqual(segments) + }) + + // Mirrors docs/architecture/tla/MentionOrigin.tla, QueueSave. The editor tags each input event. + it("keeps the segments the editor sends", () => { + const queue = new MessageQueueService() + const message = queue.addMessage("ctx @/x", undefined, [{ text: "ctx @/x", source: "generated" }])! + const segments = [ + { text: "ctx @/x", source: "generated" as const }, + { text: " mine", source: "user" as const }, + ] + + edit(queue, message.id, "ctx @/x mine", undefined, segments) + + expect(queue.messages[0]?.segments).toEqual(segments) + }) + + it.each([ + { label: "omitted", segments: undefined }, + { label: "not a list", segments: "user" }, + { label: "a text mismatch", segments: [{ text: "other", source: "user" }] }, + ])("fails closed when the edit segments are $label", ({ segments }) => { + const queue = new MessageQueueService() + const message = queue.addMessage("ctx @/x", undefined, [{ text: "ctx @/x", source: "generated" }])! + + edit(queue, message.id, "@/x", undefined, segments) + + expect(queue.messages[0]?.segments).toEqual([{ text: "@/x", source: "generated" }]) + }) + + // Mirrors docs/architecture/tla/QueueEditRace.tla, mode Claim. + describe("edits", () => { + const queued = () => { + const queue = new MessageQueueService() + const message = queue.addMessage( + "see @/a.png", + ["data:old"], + [{ text: "see @/a.png", source: "generated" }], + )! + return { queue, id: message.id } + } + + it("commits text, segments and images together", () => { + const { queue, id } = queued() + const token = queue.beginEdit(id)! + const segments = [{ text: "see @/b.png", source: "user" as const }] + + expect(queue.commitEdit(id, token, "see @/b.png", ["data:b"], segments)).toBe(true) + expect(queue.messages[0]).toMatchObject({ text: "see @/b.png", images: ["data:b"], segments }) + }) + + it("keeps the message from a drain until the edit commits", () => { + const { queue, id } = queued() + const token = queue.beginEdit(id)! + + expect(queue.dequeueMessage()).toBeUndefined() + expect(queue.hasUnclaimed()).toBe(false) + + queue.commitEdit(id, token, "see @/b.png", []) + expect(queue.dequeueMessage()).toMatchObject({ text: "see @/b.png" }) + }) + + it("emits a state change on commit so a waiting consumer sees the message again", () => { + const { queue, id } = queued() + const token = queue.beginEdit(id)! + const changed = vi.fn() + queue.on("stateChanged", changed) + + queue.commitEdit(id, token, "see @/b.png", []) + expect(changed).toHaveBeenCalledTimes(1) + expect(queue.hasUnclaimed()).toBe(true) + }) + + it("lets only the newest edit commit, even when the text is the same", () => { + const { queue, id } = queued() + const first = queue.beginEdit(id)! + const second = queue.beginEdit(id)! + const asUser = [{ text: "same", source: "user" as const }] + const asGenerated = [{ text: "same", source: "generated" as const }] + + expect(queue.commitEdit(id, second, "same", ["data:second"], asGenerated)).toBe(true) + expect(queue.commitEdit(id, first, "same", ["data:first"], asUser)).toBe(false) + expect(queue.messages[0]).toMatchObject({ images: ["data:second"], segments: asGenerated }) + }) + + it("ignores an older edit that ends first, and holds the message for the newer one", () => { + const { queue, id } = queued() + const first = queue.beginEdit(id)! + queue.beginEdit(id) + + expect(queue.commitEdit(id, first, "late", [])).toBe(false) + expect(queue.dequeueMessage()).toBeUndefined() + }) + + it("gives no token when the message is gone or a consumer holds it", () => { + const { queue, id } = queued() + queue.claimNextMessage() + expect(queue.beginEdit(id)).toBeUndefined() + + queue.removeMessage(id) + expect(queue.beginEdit(id)).toBeUndefined() + }) + + it("fails a commit after the message was removed", () => { + const { queue, id } = queued() + const token = queue.beginEdit(id)! + queue.removeMessage(id) + + expect(queue.commitEdit(id, token, "late", [])).toBe(false) + }) + }) +}) diff --git a/src/core/task/Task.ts b/src/core/task/Task.ts index 77a1333b39..19f15e3868 100644 --- a/src/core/task/Task.ts +++ b/src/core/task/Task.ts @@ -57,6 +57,7 @@ import { MAX_MCP_TOOLS_THRESHOLD, countEnabledMcpTools, providerIdentifiers, + type MentionSegment, } from "@roo-code/types" import { TelemetryService } from "@roo-code/telemetry" import { CloudService } from "@roo-code/cloud" @@ -135,7 +136,8 @@ import { checkpointRestore, checkpointDiff, } from "../checkpoints" -import { processUserContentMentions } from "../mentions/processUserContentMentions" +import { joinSegments, normalizeSegments, trimSegments } from "../../shared/mentionSegments" +import { expandUserMentions, wrapUserMessage } from "../mentions/processUserContentMentions" import { getMessagesSinceLastSummary, summarizeConversation, getEffectiveApiHistory } from "../condense" import { MessageQueueService } from "../message-queue/MessageQueueService" import { type AutoDenyDetail, AutoApprovalHandler, checkAutoApproval } from "../auto-approval" @@ -255,6 +257,8 @@ export interface TaskOptions extends CreateTaskOptions { checkpointTimeout?: number consecutiveMistakeLimit?: number task?: string + /** Origin of each part of `task`. Absent means all generated, so no mention expands. */ + segments?: MentionSegment[] images?: string[] historyItem?: HistoryItem experiments?: Record @@ -460,6 +464,7 @@ export class Task extends EventEmitter implements TaskLike { private askResponse?: ClineAskResponse private askResponseText?: string private askResponseImages?: string[] + private askResponseSegments?: MentionSegment[] /** * Structured detail of the automatic denial that resolved the current ask, * set when `checkAutoApproval` denies via policy (denylist, blanket @@ -703,7 +708,10 @@ export class Task extends EventEmitter implements TaskLike { // MessageManager for high-level message operations (lazy initialized) private _messageManager?: MessageManager + private readonly segments?: MentionSegment[] + constructor({ + segments, provider, apiConfiguration, enableCheckpoints = true, @@ -728,6 +736,8 @@ export class Task extends EventEmitter implements TaskLike { handoffExecutionContext, }: TaskOptions) { super() + this.segments = segments + this.resetAssistantMessagePersistence() if (startTask && !task && !images && !historyItem) { @@ -837,6 +847,7 @@ export class Task extends EventEmitter implements TaskLike { } this.messageQueueService.on("stateChanged", this.messageQueueStateChangedHandler) + this.messageQueueService.on("drained", (queued) => this.submitQueuedMessage(queued)) // Set up diff strategy this.diffStrategy = new MultiSearchReplaceDiffStrategy(diffFuzzyThreshold) @@ -1261,7 +1272,7 @@ export class Task extends EventEmitter implements TaskLike { } private handleQueuedAskResponse(message: QueuedMessage, resolution: QueuedAskResolution): string | undefined { - this.handleWebviewAskResponse(resolution.response, message.text, message.images) + this.handleWebviewAskResponse(resolution.response, message.text, message.images, message.segments) if (resolution.requiresDurableAck) { return message.id } @@ -1931,6 +1942,8 @@ export class Task extends EventEmitter implements TaskLike { response: ClineAskResponse text?: string images?: string[] + /** Origin of each part of `text`. */ + segments?: MentionSegment[] queuedMessageId?: string /** * Present when the ask was resolved by an automatic (policy) denial @@ -2449,12 +2462,14 @@ export class Task extends EventEmitter implements TaskLike { response: this.askResponse!, text: this.askResponseText, images: this.askResponseImages, + segments: this.askResponseSegments, queuedMessageId, autoDenyDetail: this.pendingAutoDenyDetail, } this.askResponse = undefined this.askResponseText = undefined this.askResponseImages = undefined + this.askResponseSegments = undefined this.pendingAutoDenyDetail = undefined // Switch back to an active state. @@ -2477,13 +2492,19 @@ export class Task extends EventEmitter implements TaskLike { } } - handleWebviewAskResponse(askResponse: ClineAskResponse, text?: string, images?: string[]) { + handleWebviewAskResponse( + askResponse: ClineAskResponse, + text?: string, + images?: string[], + segments?: MentionSegment[], + ) { // Clear any pending auto-approval timeout when user responds this.cancelAutoApprovalTimeout() this.askResponse = askResponse this.askResponseText = text this.askResponseImages = images + this.askResponseSegments = segments // Create a checkpoint whenever the user sends a message. // Use allowEmpty=true to ensure a checkpoint is recorded even if there are no file changes. @@ -2624,9 +2645,12 @@ export class Task extends EventEmitter implements TaskLike { images?: string[], mode?: string, providerProfile?: string, + segments?: MentionSegment[], ): Promise { try { - text = (text ?? "").trim() + // Trim the text and its segments together so they stay equal. + const trimmed = trimSegments(normalizeSegments(text ?? "", segments)) + text = joinSegments(trimmed) images = images ?? [] if (text.length === 0 && images.length === 0) { @@ -2658,7 +2682,7 @@ export class Task extends EventEmitter implements TaskLike { // Handle the message directly instead of routing through the webview. // This avoids a race condition where the webview's message state hasn't // hydrated yet, causing it to interpret the message as a new task request. - this.handleWebviewAskResponse("messageResponse", text, images) + this.handleWebviewAskResponse("messageResponse", text, images, trimmed) } else { console.error("[Task#submitUserMessage] Provider reference lost") } @@ -3167,13 +3191,11 @@ export class Task extends EventEmitter implements TaskLike { const imageBlocks: Anthropic.ImageBlockParam[] = formatResponse.imageBlocks(images) // Task starting - await this.initiateTaskLoop([ - { - type: "text", - text: `\n${task}\n`, - }, - ...imageBlocks, - ]).catch((error) => { + // Task text can carry generated context. Without segments + // nothing expands. The loop waits for the content after it shows the request row. + await this.initiateTaskLoop( + this.userInputContent(task ?? "", this.segments).then((content) => [...content, ...imageBlocks]), + ).catch((error) => { // Swallow loop rejection when the task was intentionally abandoned/aborted // during delegation or user cancellation to prevent unhandled rejections. if (this.abandoned === true || this.abortReason === "user_cancelled") { @@ -3311,7 +3333,7 @@ export class Task extends EventEmitter implements TaskLike { this.markInitialized() - const { response, text, images } = await this.ask(askType) // Calls `postStateToWebview`. + const { response, text, images, segments } = await this.ask(askType) // Calls `postStateToWebview`. let responseText: string | undefined let responseImages: string[] | undefined @@ -3430,29 +3452,33 @@ export class Task extends EventEmitter implements TaskLike { throw new Error("Unexpected: No existing API conversation history") } - const newUserContent: Anthropic.Messages.ContentBlockParam[] = [...modifiedOldUserContent] - - if (responseText) { - newUserContent.push({ - type: "text", - text: `\n${responseText}\n`, - }) - } + // Only user segments expand. + const preparationGeneration = this.cancellationGeneration + const expanded = responseText ? this.userInputContent(responseText, segments) : Promise.resolve([]) + const newUserContent = expanded.then(async (content) => { + // A cancelled preparation must not replace history from a newer run. + if (this.abort || this.abandoned || this.cancellationGeneration !== preparationGeneration) { + throw new Error(`[Task#resumeTaskFromHistory] task ${this.taskId}.${this.instanceId} aborted`) + } + // Replace history before the loop appends the combined user content. + await this.overwriteApiConversationHistory(modifiedApiConversationHistory) + const blocks: Anthropic.Messages.ContentBlockParam[] = [...modifiedOldUserContent, ...content] - if (responseImages && responseImages.length > 0) { - newUserContent.push(...formatResponse.imageBlocks(responseImages)) - } + if (responseImages && responseImages.length > 0) { + blocks.push(...formatResponse.imageBlocks(responseImages)) + } - // Ensure we have at least some content to send to the API. - // If newUserContent is empty, add a minimal resumption message. - if (newUserContent.length === 0) { - newUserContent.push({ - type: "text", - text: "[TASK RESUMPTION] Resuming task...", - }) - } + // Ensure we have at least some content to send to the API. + // If blocks is empty, add a minimal resumption message. + if (blocks.length === 0) { + blocks.push({ + type: "text", + text: "[TASK RESUMPTION] Resuming task...", + }) + } - await this.overwriteApiConversationHistory(modifiedApiConversationHistory) + return blocks + }) // Task resuming from history item. await this.initiateTaskLoop(newUserContent) @@ -3922,7 +3948,40 @@ export class Task extends EventEmitter implements TaskLike { // Task Loop - private async initiateTaskLoop(userContent: Anthropic.Messages.ContentBlockParam[]): Promise { + /** + * Builds the content blocks for user input. Only user segments expand mentions. + * A slash command in the input can switch the mode. + */ + public async userInputContent(text: string, segments?: MentionSegment[]): Promise { + const provider = this.providerRef.deref() + const state = provider ? await provider.getState() : undefined + + const { content, mode } = await expandUserMentions({ + segments: wrapUserMessage(normalizeSegments(text, segments)), + cwd: this.cwd, + fileContextTracker: this.fileContextTracker, + rooIgnoreController: this.rooIgnoreController, + showRooIgnoredFiles: state?.showRooIgnoredFiles ?? false, + includeDiagnosticMessages: state?.includeDiagnosticMessages ?? true, + maxDiagnosticMessages: state?.maxDiagnosticMessages ?? 50, + skillsManager: provider?.getSkillsManager(), + currentMode: await this.getTaskMode(), + }) + + // A cancelled task must not switch the mode. A listener can cancel while the content loads. + if (this.abort || this.abandoned) return content + + // Switch mode if specified in a slash command's frontmatter + if (mode && provider && getModeBySlug(mode, state?.customModes)) { + await provider.handleModeSwitch(mode, null) + } + + return content + } + + private async initiateTaskLoop( + userContent: Anthropic.Messages.ContentBlockParam[] | Promise, + ): Promise { // Kicks off the checkpoints initialization process in the background. // `getCheckpointService` wraps its full body in a try/catch and returns // `undefined` on failure (see src/core/checkpoints/index.ts), so the @@ -3930,6 +3989,10 @@ export class Task extends EventEmitter implements TaskLike { // arm needed. void getCheckpointService(this) + // The loop awaits a pending value later. Mark it handled so an early rejection + // does not reach the process as unhandled. + if (!Array.isArray(userContent)) userContent.catch(() => {}) + let nextUserContent = userContent let includeFileDetails = true @@ -3961,17 +4024,22 @@ export class Task extends EventEmitter implements TaskLike { } public async recursivelyMakeClineRequests( - userContent: Anthropic.Messages.ContentBlockParam[], + userContent: Anthropic.Messages.ContentBlockParam[] | Promise, includeFileDetails: boolean = false, ): Promise { interface StackItem { userContent: Anthropic.Messages.ContentBlockParam[] + pendingContent?: Promise // Resolved after the request row shows includeFileDetails: boolean retryAttempt?: number userMessageWasRemoved?: boolean // Track if user message was removed due to empty response } - const stack: StackItem[] = [{ userContent, includeFileDetails, retryAttempt: 0 }] + const stack: StackItem[] = [ + Array.isArray(userContent) + ? { userContent, includeFileDetails, retryAttempt: 0 } + : { userContent: [], pendingContent: userContent, includeFileDetails, retryAttempt: 0 }, + ] while (stack.length > 0) { const currentItem = stack.pop()! @@ -4043,36 +4111,9 @@ export class Task extends EventEmitter implements TaskLike { }), ) - const provider = this.providerRef.deref() - const state = provider ? await provider.getState() : undefined - - const showRooIgnoredFiles = state?.showRooIgnoredFiles ?? false - const includeDiagnosticMessages = state?.includeDiagnosticMessages ?? true - const maxDiagnosticMessages = state?.maxDiagnosticMessages ?? 50 - const currentMode = await this.getTaskMode() - - const { content: parsedUserContent, mode: slashCommandMode } = await processUserContentMentions({ - userContent: currentUserContent, - cwd: this.cwd, - fileContextTracker: this.fileContextTracker, - rooIgnoreController: this.rooIgnoreController, - showRooIgnoredFiles, - includeDiagnosticMessages, - maxDiagnosticMessages, - skillsManager: provider?.getSkillsManager(), - currentMode, - }) - - // Switch mode if specified in a slash command's frontmatter - if (slashCommandMode) { - const provider = this.providerRef.deref() - if (provider) { - const state = await provider.getState() - const targetMode = getModeBySlug(slashCommandMode, state?.customModes) - if (targetMode) { - await provider.handleModeSwitch(slashCommandMode, null) - } - } + // Mention expansion can take time. The request row already shows. + if (currentItem.pendingContent) { + currentUserContent.push(...(await currentItem.pendingContent)) } const environmentDetails = await getEnvironmentDetails(this, currentIncludeFileDetails) @@ -4082,7 +4123,7 @@ export class Task extends EventEmitter implements TaskLike { // where the old user message content may already contain environment details from the previous session. // We check for both opening and closing tags to ensure we're matching complete environment detail blocks, // not just mentions of the tag in regular content. - const contentWithoutEnvDetails = parsedUserContent.filter((block) => { + const contentWithoutEnvDetails = currentUserContent.filter((block) => { if (block.type === "text" && typeof block.text === "string") { // Check if this text block is a complete environment_details block // by verifying it starts with the opening tag and ends with the closing tag @@ -6547,6 +6588,14 @@ export class Task extends EventEmitter implements TaskLike { return this._messageManager } + private submitQueuedMessage(queued: QueuedMessage): void { + setTimeout(() => { + this.submitUserMessage(queued.text, queued.images, undefined, undefined, queued.segments).catch((err) => + console.error(`[Task] Failed to submit queued message:`, err), + ) + }, 0) + } + /** * Process any queued messages by dequeuing and submitting them. * This ensures that queued user messages are sent when appropriate, @@ -6557,13 +6606,9 @@ export class Task extends EventEmitter implements TaskLike { public processQueuedMessages(): void { try { if (!this.messageQueueService.isEmpty()) { - const queued = this.messageQueueService.dequeueMessage() + const queued = this.messageQueueService.drain() if (queued) { - setTimeout(() => { - this.submitUserMessage(queued.text, queued.images).catch((err) => - console.error(`[Task] Failed to submit queued message:`, err), - ) - }, 0) + this.submitQueuedMessage(queued) } } } catch (e) { diff --git a/src/core/task/__tests__/Task.abort-reason-race.spec.ts b/src/core/task/__tests__/Task.abort-reason-race.spec.ts index be7101b70a..5730b98db5 100644 --- a/src/core/task/__tests__/Task.abort-reason-race.spec.ts +++ b/src/core/task/__tests__/Task.abort-reason-race.spec.ts @@ -53,13 +53,6 @@ vi.mock("../../mentions", () => ({ getLatestTerminalOutput: vi.fn(), })) -vi.mock("../../mentions/processUserContentMentions", () => ({ - processUserContentMentions: vi.fn().mockImplementation(async ({ userContent }: { userContent: unknown[] }) => ({ - content: userContent, - mode: undefined, - })), -})) - vi.mock("../../../integrations/misc/extract-text", () => ({ extractTextFromFile: vi.fn().mockResolvedValue(""), })) diff --git a/src/core/task/__tests__/Task.ignored-disabled-tools-notice.spec.ts b/src/core/task/__tests__/Task.ignored-disabled-tools-notice.spec.ts index a83586122a..5e1e8ee0ee 100644 --- a/src/core/task/__tests__/Task.ignored-disabled-tools-notice.spec.ts +++ b/src/core/task/__tests__/Task.ignored-disabled-tools-notice.spec.ts @@ -129,6 +129,7 @@ function createMockProvider(disabledTools: string[] | undefined): ClineProvider globalStorageUri: { fsPath: "/test/storage" }, }, getState: vi.fn().mockResolvedValue(providerState), + getSkillsManager: vi.fn(), log: vi.fn(), on: vi.fn(), off: vi.fn(), @@ -200,6 +201,8 @@ async function startTaskWithFailingStateRead() { startTask: false, }) + // Mention expansion also reads the state. This test covers the notice read only. + vi.spyOn(task, "userInputContent").mockResolvedValue([]) const saySpy = vi.spyOn(task, "say").mockResolvedValue(undefined) const taskAccess = getStartTaskAccess(task) vi.spyOn(taskAccess, "getEnabledMcpToolsCount").mockResolvedValue({ diff --git a/src/core/task/__tests__/Task.persistence.spec.ts b/src/core/task/__tests__/Task.persistence.spec.ts index b7c97a357e..86df5615db 100644 --- a/src/core/task/__tests__/Task.persistence.spec.ts +++ b/src/core/task/__tests__/Task.persistence.spec.ts @@ -16,6 +16,7 @@ import { TelemetryService } from "@roo-code/telemetry" import type { Anthropic } from "@anthropic-ai/sdk" import { PendingActionSettlementError, Task } from "../Task" +import { parseMentions } from "../../mentions" import { ClineProvider } from "../../webview/ClineProvider" import { ContextProxy } from "../../config/ContextProxy" import { providerIdentifiers } from "@roo-code/types/provider-identifiers" @@ -31,7 +32,9 @@ type TaskPersistenceAccess = { resumeTaskFromHistory: () => Promise resumePendingTaskAction: (action: PendingTaskAction) => Promise saveClineMessages: () => Promise - initiateTaskLoop: (userContent: Anthropic.Messages.ContentBlockParam[]) => Promise + initiateTaskLoop: ( + userContent: Anthropic.Messages.ContentBlockParam[] | Promise, + ) => Promise } function getTaskPersistenceAccess(task: Task): TaskPersistenceAccess { @@ -1257,7 +1260,7 @@ describe("Task persistence", () => { await getTaskPersistenceAccess(task).resumeTaskFromHistory() expect(initiateTaskLoopSpy).toHaveBeenCalledTimes(1) - const newUserContent = initiateTaskLoopSpy.mock.calls[0][0] + const newUserContent = await initiateTaskLoopSpy.mock.calls[0][0] const toolResults = newUserContent.filter((block) => block.type === "tool_result") // The synthetic tool_result must be recorded as an error so the history // cannot be misread as a successful completion of the interrupted call. @@ -1329,7 +1332,7 @@ describe("Task persistence", () => { await getTaskPersistenceAccess(task).resumeTaskFromHistory() expect(initiateTaskLoopSpy).toHaveBeenCalledTimes(1) - const newUserContent = initiateTaskLoopSpy.mock.calls[0][0] + const newUserContent = await initiateTaskLoopSpy.mock.calls[0][0] const toolResults = newUserContent.filter((block) => block.type === "tool_result") // The pre-existing result is preserved untouched; the synthesized one // for the unanswered tool call is marked as an error. @@ -2203,7 +2206,10 @@ describe("Task persistence", () => { const initiate = vi .spyOn(getTaskPersistenceAccess(task), "initiateTaskLoop") .mockImplementation(async (content) => { - await getTaskPersistenceAccess(task).addToApiConversationHistory({ role: "user", content }) + await getTaskPersistenceAccess(task).addToApiConversationHistory({ + role: "user", + content: await content, + }) }) await getTaskPersistenceAccess(task).resumePendingTaskAction(lifecycleAction) @@ -2219,6 +2225,195 @@ describe("Task persistence", () => { }) }) + describe("resumeTaskFromHistory response mentions", () => { + const resumeWith = async (response: { text: string; segments?: unknown; images?: string[] }) => { + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + historyItem: { + id: "resume-mentions", + number: 1, + ts: Date.now(), + task: "Resumed task", + tokensIn: 10, + tokensOut: 5, + totalCost: 0.001, + }, + startTask: false, + initialStatus: "interrupted", + }) + const initiate = vi.spyOn(getTaskPersistenceAccess(task), "initiateTaskLoop").mockResolvedValue(undefined) + vi.spyOn(task, "ask").mockResolvedValue({ response: "messageResponse", ...response } as never) + mockReadApiMessages.mockResolvedValue([{ role: "assistant", content: [{ type: "text", text: "Hi" }] }]) + mockProvider.taskHistoryStore.get = vi + .fn() + .mockReturnValue({ id: "resume-mentions", status: "interrupted" }) + + vi.mocked(parseMentions).mockClear() + await getTaskPersistenceAccess(task).resumeTaskFromHistory() + + return { + processed: { content: await initiate.mock.calls[0][0] }, + parsed: vi.mocked(parseMentions).mock.calls.map((call) => call[0]), + } + } + + it("expands a user segment and keeps the wrapper", async () => { + const text = "read @/allowed please" + const { processed, parsed } = await resumeWith({ text, segments: [{ text, source: "user" }] }) + + expect(parsed).toEqual([text]) + expect(processed.content).toContainEqual({ + type: "text", + text: `\nprocessed: ${text}\n`, + }) + }) + + it("expands only the user segments of an interleaved answer", async () => { + const text = "@/a @/secret @/b" + const { processed, parsed } = await resumeWith({ + text, + segments: [ + { text: "@/a ", source: "user" }, + { text: "@/secret ", source: "generated" }, + { text: "@/b", source: "user" }, + ], + }) + + expect(parsed).toEqual(["@/a ", "@/b"]) + expect(processed.content).toContainEqual({ + type: "text", + text: "\nprocessed: @/a @/secret processed: @/b\n", + }) + }) + + it.each([ + { label: "omitted", segments: undefined }, + { label: "not matching the text", segments: [{ text: "other", source: "user" }] }, + { label: "matching but generated only", segments: [{ text: "read @/secret", source: "generated" }] }, + { label: "matching but of an invalid source", segments: [{ text: "read @/secret", source: "system" }] }, + ])("expands nothing when the segments are $label", async ({ segments }) => { + const { processed, parsed } = await resumeWith({ text: "read @/secret", segments }) + + expect(parsed).toEqual([]) + expect(processed.content).toContainEqual({ + type: "text", + text: "\nread @/secret\n", + }) + }) + + it("keeps the images of an empty-text response and expands nothing", async () => { + const { processed, parsed } = await resumeWith({ text: "", images: ["data:image/png;base64,AA"] }) + + expect(parsed).toEqual([]) + expect(processed.content).toContainEqual({ + type: "image", + source: { type: "base64", media_type: "image/png", data: "AA" }, + }) + expect(JSON.stringify(processed.content)).not.toContain("") + }) + + it("writes the history only after the expansion ends, and not when it fails", async () => { + const text = "read @/allowed please" + const segments = [{ text, source: "user" }] + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + historyItem: { + id: "resume-order", + number: 1, + ts: Date.now(), + task: "t", + tokensIn: 1, + tokensOut: 1, + totalCost: 0, + }, + startTask: false, + initialStatus: "interrupted", + }) + const initiate = vi.spyOn(getTaskPersistenceAccess(task), "initiateTaskLoop").mockResolvedValue(undefined) + const overwrite = vi.spyOn(task, "overwriteApiConversationHistory").mockResolvedValue(undefined) + vi.spyOn(task, "ask").mockResolvedValue({ response: "messageResponse", text, segments } as never) + mockReadApiMessages.mockResolvedValue([{ role: "assistant", content: [{ type: "text", text: "Hi" }] }]) + mockProvider.taskHistoryStore.get = vi.fn().mockReturnValue({ id: "resume-order", status: "interrupted" }) + + let finish: (value: never[]) => void = () => {} + vi.spyOn(task, "userInputContent").mockReturnValueOnce(new Promise((resolve) => (finish = resolve))) + await getTaskPersistenceAccess(task).resumeTaskFromHistory() + expect(overwrite).not.toHaveBeenCalled() + finish([]) + await initiate.mock.calls[0][0] + expect(overwrite).toHaveBeenCalledTimes(1) + + overwrite.mockClear() + vi.spyOn(task, "userInputContent").mockRejectedValueOnce(new Error("state")) + await getTaskPersistenceAccess(task).resumeTaskFromHistory() + await expect(initiate.mock.calls[1][0]).rejects.toThrow("state") + expect(overwrite).not.toHaveBeenCalled() + }) + + it.each(["cancel", "dispose", "generation", "abandon"] as const)( + "preserves newer history when pending preparation loses ownership through %s", + async (change) => { + const text = "read @/allowed please" + const segments = [{ text, source: "user" }] + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + historyItem: { + id: "resume-order", + number: 1, + ts: Date.now(), + task: "t", + tokensIn: 1, + tokensOut: 1, + totalCost: 0, + }, + startTask: false, + initialStatus: "interrupted", + }) + const initiate = vi + .spyOn(getTaskPersistenceAccess(task), "initiateTaskLoop") + .mockResolvedValue(undefined) + const overwrite = vi.spyOn(task, "overwriteApiConversationHistory") + vi.spyOn(task, "ask").mockResolvedValue({ response: "messageResponse", text, segments } as never) + mockReadApiMessages.mockResolvedValue([{ role: "user", content: [{ type: "text", text: "old turn" }] }]) + mockProvider.taskHistoryStore.get = vi + .fn() + .mockReturnValue({ id: "resume-order", status: "interrupted" }) + + let finish: (value: Anthropic.Messages.TextBlockParam[]) => void = () => {} + vi.spyOn(task, "userInputContent").mockReturnValueOnce(new Promise((resolve) => (finish = resolve))) + await getTaskPersistenceAccess(task).resumeTaskFromHistory() + const pending = Promise.resolve(initiate.mock.calls[0][0]) + const rejected = expect(pending).rejects.toThrow( + `[Task#resumeTaskFromHistory] task ${task.taskId}.${task.instanceId} aborted`, + ) + if (change === "cancel") task.requestAbort(false) + else if (change === "dispose") task.requestDispose() + else if (change === "abandon") task.requestAbandon() + else task.cancellationGeneration++ + + const newerHistory: typeof task.apiConversationHistory = [{ role: "user", content: "new continuation" }] + await task.overwriteApiConversationHistory(newerHistory) + overwrite.mockClear() + mockSaveApiMessages.mockClear() + finish([]) + await rejected + expect(overwrite).not.toHaveBeenCalled() + expect(mockSaveApiMessages).not.toHaveBeenCalled() + expect(task.apiConversationHistory).toEqual(newerHistory) + }, + ) + + it("pushes no response block for an empty response", async () => { + const { processed, parsed } = await resumeWith({ text: "" }) + + expect(parsed).toEqual([]) + expect(JSON.stringify(processed.content)).not.toContain("") + }) + }) + describe("resumeTaskFromHistory", () => { it.each(["not_found", "invalid", "io_error"] as const)( "does not persist when hydration fails with %s", diff --git a/src/core/task/__tests__/Task.spec.ts b/src/core/task/__tests__/Task.spec.ts index 765dd1b2b6..739b7418a2 100644 --- a/src/core/task/__tests__/Task.spec.ts +++ b/src/core/task/__tests__/Task.spec.ts @@ -32,7 +32,7 @@ import { ClineProvider } from "../../webview/ClineProvider" import { ApiStreamChunk } from "../../../api/transform/stream" import { OutputTokenLimitError } from "../../../api/providers/utils/output-token-limit-error" import { ContextProxy } from "../../config/ContextProxy" -import { processUserContentMentions } from "../../mentions/processUserContentMentions" +import { parseMentions } from "../../mentions" import { MultiSearchReplaceDiffStrategy } from "../../diff/strategies/multi-search-replace" import type { ApiMessage } from "../../task-persistence" import type { RequestPolicySnapshot } from "../../prompts/tools/effective-tool-policy" @@ -46,7 +46,9 @@ type TaskTestAccess = { getSystemPrompt: (requestState: ProviderState | undefined, requestModelInfo?: ModelInfo) => Promise handleContextWindowExceededError: (requestModelInfo: ModelInfo) => Promise getEnabledMcpToolsCount: () => Promise<{ enabledToolCount: number; enabledServerCount: number }> - initiateTaskLoop: (userContent: Anthropic.Messages.ContentBlockParam[]) => Promise + initiateTaskLoop: ( + userContent: Anthropic.Messages.ContentBlockParam[] | Promise, + ) => Promise startTask: (task?: string, images?: string[]) => Promise resumeTaskFromHistory: () => Promise presentAssistantMessageSafe: () => void @@ -242,14 +244,6 @@ vi.mock("../../environment/getEnvironmentDetails", () => ({ getEnvironmentDetails: vi.fn().mockResolvedValue(""), })) -vi.mock("../../mentions/processUserContentMentions", async (importOriginal) => { - const actual = await importOriginal() - return { - ...actual, - processUserContentMentions: vi.fn().mockImplementation(actual.processUserContentMentions), - } -}) - vi.mock("../../ignore/RooIgnoreController") vi.mock("../../../i18n", () => { @@ -3510,79 +3504,67 @@ describe("Cline", () => { ]) }) - describe("processUserContentMentions", () => { - it("should process mentions in user_message tags", async () => { - const [cline, task] = Task.create({ + describe("user input mentions", () => { + beforeEach(() => { + vi.clearAllMocks() + }) + + it.each([ + { + label: "all generated", + segments: [{ text: "read '@/secret' please", source: "generated" as const }], + }, + { label: "omitted", segments: undefined }, + { label: "not matching the text", segments: [{ text: "other", source: "user" as const }] }, + ])("does not expand task text when segments are $label", async ({ segments }) => { + const task = new Task({ provider: mockProvider, apiConfiguration: mockApiConfig, - task: "test task", + task: "read '@/secret' please", + startTask: false, }) - const userContent = [ - { - type: "text", - text: "Regular text with 'some/path' (see below for file content)", - } as const, - { - type: "text", - text: "Text with 'some/path' (see below for file content) in user_message tags", - } as const, - { - type: "tool_result", - tool_use_id: "test-id", - content: [ - { - type: "text", - text: "Check 'some/path' (see below for file content)", - }, - ], - } as Anthropic.ToolResultBlockParam, - { - type: "tool_result", - tool_use_id: "test-id-2", - content: [ - { - type: "text", - text: "Regular tool result with 'path' (see below for file content)", - }, - ], - } as Anthropic.ToolResultBlockParam, - ] + const content = await task.userInputContent("read '@/secret' please", segments) - const { content: processedContent } = await processUserContentMentions({ - userContent, - cwd: cline.cwd, - fileContextTracker: cline.fileContextTracker, - }) + expect(parseMentions).not.toHaveBeenCalled() + expect(content).toEqual([ + { type: "text", text: "\nread '@/secret' please\n" }, + ]) + }) - // Regular text should not be processed - expect((processedContent[0] as Anthropic.TextBlockParam).text).toBe( - "Regular text with 'some/path' (see below for file content)", - ) + it("expands the task text when the start authorizes it", async () => { + const taskText = "read '@/secret' please" + const [cline, task] = Task.create({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + task: taskText, + segments: [{ text: taskText, source: "user" }], + }) - // Text within user_message tags should be processed - expect((processedContent[1] as Anthropic.TextBlockParam).text).toContain("processed:") - expect((processedContent[1] as Anthropic.TextBlockParam).text).toContain( - "Text with 'some/path' (see below for file content) in user_message tags", - ) + await vi.waitFor(() => expect(parseMentions).toHaveBeenCalled()) + await cline.abortTask(true) + await task.catch(() => {}) - // user_message tag content should be processed - const toolResult1 = processedContent[2] as Anthropic.ToolResultBlockParam - const content1 = Array.isArray(toolResult1.content) ? toolResult1.content[0] : toolResult1.content - expect((content1 as Anthropic.TextBlockParam).text).toContain("processed:") - expect((content1 as Anthropic.TextBlockParam).text).toContain( - "Check 'some/path' (see below for file content)", - ) + expect(vi.mocked(parseMentions).mock.calls[0]?.[0]).toBe(taskText) + }) - // Regular tool result should not be processed - const toolResult2 = processedContent[3] as Anthropic.ToolResultBlockParam - const content2 = Array.isArray(toolResult2.content) ? toolResult2.content[0] : toolResult2.content - expect((content2 as Anthropic.TextBlockParam).text).toBe( - "Regular tool result with 'path' (see below for file content)", - ) + it("expands only the authorized substring of generated task text", async () => { + const [cline, task] = Task.create({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + task: "context @/context.txt\nchosen @/chosen.txt", + segments: [ + { text: "context @/context.txt\n", source: "generated" }, + { text: "chosen @/chosen.txt", source: "user" }, + ], + }) + await vi.waitFor(() => expect(parseMentions).toHaveBeenCalled()) await cline.abortTask(true) await task.catch(() => {}) + + const texts = vi.mocked(parseMentions).mock.calls.map(([text]) => text) + expect(texts).toEqual(["chosen @/chosen.txt"]) }) }) }) @@ -3596,40 +3578,77 @@ describe("Cline", () => { startTask: false, }) - const ensureModelFetched = vi.fn().mockResolvedValue(undefined) - Object.assign(task.api, { ensureModelFetched }) - vi.spyOn(task.api, "getModel").mockReturnValue({ - id: mockApiConfig.apiModelId!, - info: { - supportsImages: false, - supportsPromptCache: true, - contextWindow: 200_000, - maxTokens: 4096, - } as ModelInfo, - }) - vi.mocked(processUserContentMentions).mockResolvedValueOnce({ - content: [{ type: "text", text: "run /commit" }], + vi.mocked(parseMentions).mockResolvedValueOnce({ + text: "run /commit", + contentBlocks: [], mode: "code", }) - vi.spyOn(getTaskTestAccess(task), "saveClineMessages").mockResolvedValue(true) - vi.spyOn(task.diffViewProvider, "reset").mockResolvedValue(undefined as never) - vi.spyOn(getTaskTestAccess(task), "addToApiConversationHistory").mockResolvedValue(undefined) - task.clineMessages = [{ ts: Date.now(), type: "say", say: "api_req_started", text: "{}" }] - vi.spyOn(task, "say").mockImplementation(async (type) => { - if (type === "api_req_started") { - task.clineMessages.push({ ts: Date.now(), type: "say", say: "api_req_started", text: "{}" }) - } - return undefined as never + + const handleModeSwitchSpy = vi.spyOn(mockProvider, "handleModeSwitch").mockResolvedValue(undefined) + + await task.userInputContent("run /commit", [{ text: "run /commit", source: "user" }]) + + expect(handleModeSwitchSpy).toHaveBeenCalledWith("code", null) + }) + + it("does not switch the mode when a TaskStarted listener cancels while the content loads", async () => { + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + task: "test task", + startTask: false, }) - vi.spyOn(task, "attemptApiRequest").mockImplementation(() => { - throw new Error("stop after mode switch") + let release: () => void = () => {} + const gate = new Promise((resolve) => (release = resolve)) + vi.mocked(parseMentions).mockImplementationOnce(async () => { + await gate + return { text: "run /commit", contentBlocks: [], mode: "code" } }) + const handleModeSwitchSpy = vi.spyOn(mockProvider, "handleModeSwitch").mockResolvedValue(undefined) + task.on(RooCodeEventName.TaskStarted, () => void task.abortTask()) + + // startTask starts the content first, then the loop emits TaskStarted. + const pending = task.userInputContent("run /commit", [{ text: "run /commit", source: "user" }]) + await getTaskTestAccess(task) + .initiateTaskLoop(pending) + .catch(() => {}) + release() + await pending + expect(task.abort).toBe(true) + expect(handleModeSwitchSpy).not.toHaveBeenCalled() + }) + + it.each([ + { + label: "aborted", + cancel: (t: Task) => t.abortTask(), + }, + { + label: "abandoned", + cancel: async (t: Task) => { + t.abandoned = true + }, + }, + ])("does not switch the mode after the task is cancelled ($label)", async ({ cancel }) => { + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + task: "test task", + startTask: false, + }) + vi.mocked(parseMentions).mockResolvedValueOnce({ + text: "run /commit", + contentBlocks: [], + mode: "code", + }) const handleModeSwitchSpy = vi.spyOn(mockProvider, "handleModeSwitch").mockResolvedValue(undefined) + await cancel(task) - await task.recursivelyMakeClineRequests([{ type: "text", text: "run /commit" }]).catch(() => {}) + const content = await task.userInputContent("run /commit", [{ text: "run /commit", source: "user" }]) - expect(handleModeSwitchSpy).toHaveBeenCalledWith("code", null) + expect(handleModeSwitchSpy).not.toHaveBeenCalled() + expect(content).toEqual([{ type: "text", text: "\nrun /commit\n" }]) }) }) @@ -4204,11 +4223,55 @@ describe("Cline", () => { await task.submitUserMessage("test message", ["image1.png"]) // Verify handleWebviewAskResponse was called directly (not webview) - expect(handleResponseSpy).toHaveBeenCalledWith("messageResponse", "test message", ["image1.png"]) + expect(handleResponseSpy).toHaveBeenCalledWith( + "messageResponse", + "test message", + ["image1.png"], + [{ text: "test message", source: "generated" }], + ) // Should NOT route through webview anymore expect(mockProvider.postMessageToWebview).not.toHaveBeenCalled() }) + it("forwards the segments to the ask response", async () => { + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + task: "initial task", + startTask: false, + }) + const handleResponseSpy = vi.spyOn(task, "handleWebviewAskResponse") + + const segments = [ + { text: "a @/x ", source: "generated" as const }, + { text: "b", source: "user" as const }, + ] + await task.submitUserMessage("a @/x b", [], undefined, undefined, segments) + + expect(handleResponseSpy).toHaveBeenCalledWith("messageResponse", "a @/x b", [], segments) + }) + + it("trims the segments the same way as the text", async () => { + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + task: "initial task", + startTask: false, + }) + const handleResponseSpy = vi.spyOn(task, "handleWebviewAskResponse") + + await task.submitUserMessage(" @/chosen.txt ", [], undefined, undefined, [ + { text: " @/chosen.txt ", source: "user" }, + ]) + + expect(handleResponseSpy).toHaveBeenCalledWith( + "messageResponse", + "@/chosen.txt", + [], + [{ text: "@/chosen.txt", source: "user" }], + ) + }) + it("uses a mode selected through submitUserMessage in the next API request", async () => { vi.spyOn(mockProvider, "getState").mockResolvedValue(providerStateWith({ mode: "ask" })) vi.spyOn(mockProvider, "setMode").mockResolvedValue(undefined) @@ -4299,7 +4362,12 @@ describe("Cline", () => { task.clineMessages = [] await task.submitUserMessage("new task", ["image1.png"]) - expect(handleResponseSpy).toHaveBeenCalledWith("messageResponse", "new task", ["image1.png"]) + expect(handleResponseSpy).toHaveBeenCalledWith( + "messageResponse", + "new task", + ["image1.png"], + [{ text: "new task", source: "generated" }], + ) // Clear mock handleResponseSpy.mockClear() @@ -4315,7 +4383,12 @@ describe("Cline", () => { ] await task.submitUserMessage("follow-up message", ["image2.png"]) - expect(handleResponseSpy).toHaveBeenCalledWith("messageResponse", "follow-up message", ["image2.png"]) + expect(handleResponseSpy).toHaveBeenCalledWith( + "messageResponse", + "follow-up message", + ["image2.png"], + [{ text: "follow-up message", source: "generated" }], + ) }) it("should handle undefined provider gracefully", async () => { @@ -6686,6 +6759,45 @@ describe("Cline", () => { expect(errorSpy).toHaveBeenCalled() }) + it("shows the request row before pending user content resolves", async () => { + const task = new Task({ + provider: mockProvider, + apiConfiguration: mockApiConfig, + task: "test task", + startTask: false, + }) + Object.assign(task.api, { ensureModelFetched: vi.fn().mockResolvedValue(undefined) }) + const addToHistory = vi.spyOn(getTaskTestAccess(task), "addToApiConversationHistory").mockResolvedValue() + vi.spyOn(getTaskTestAccess(task), "saveClineMessages").mockResolvedValue(true) + vi.spyOn(task.diffViewProvider, "reset").mockResolvedValue(undefined as never) + vi.spyOn(task, "attemptApiRequest").mockImplementation(() => { + throw new Error("stop after history") + }) + task.clineMessages = [{ ts: Date.now(), type: "say", say: "api_req_started", text: "{}" }] + const saySpy = vi.spyOn(task, "say").mockImplementation(async (type) => { + if (type === "api_req_started") { + task.clineMessages.push({ ts: Date.now(), type: "say", say: "api_req_started", text: "{}" }) + } + return undefined as never + }) + + let resolveContent: (content: Anthropic.TextBlockParam[]) => void = () => {} + const pending = new Promise((resolve) => (resolveContent = resolve)) + const run = task.recursivelyMakeClineRequests(pending, false).catch(() => {}) + + await vi.waitFor(() => expect(saySpy).toHaveBeenCalledWith("api_req_started", expect.any(String))) + expect(addToHistory).not.toHaveBeenCalled() + + resolveContent([{ type: "text", text: "expanded input" }]) + await run + + expect(addToHistory).toHaveBeenCalledWith( + expect.objectContaining({ + content: expect.arrayContaining([{ type: "text", text: "expanded input" }]), + }), + ) + }) + it("fetches model metadata before caching the streaming model", async () => { const task = new Task({ provider: mockProvider, @@ -6705,10 +6817,6 @@ describe("Cline", () => { maxTokens: 4096, } as ModelInfo, }) - vi.mocked(processUserContentMentions).mockResolvedValueOnce({ - content: [{ type: "text", text: "hello" }], - mode: undefined, - }) const safeSpy = vi.spyOn(getTaskTestAccess(task), "safeEnsureModelFetched") const resetPersistenceSpy = vi.spyOn(getTaskTestAccess(task), "resetAssistantMessagePersistence") const attemptApiRequestSpy = vi.spyOn(task, "attemptApiRequest").mockImplementation(() => { @@ -8161,7 +8269,7 @@ describe("Queued message processing after condense", () => { const submitSpy = vi.spyOn(task, "submitUserMessage").mockResolvedValue(undefined) // Queue a message during condensing - task.messageQueueService.addMessage("queued text", ["img1.png"]) + task.messageQueueService.addMessage("queued text", ["img1.png"], [{ text: "queued text", source: "user" }]) // Use fake timers to capture setTimeout(0) in processQueuedMessages vi.useFakeTimers() @@ -8171,10 +8279,182 @@ describe("Queued message processing after condense", () => { vi.runAllTimers() vi.useRealTimers() - expect(submitSpy).toHaveBeenCalledWith("queued text", ["img1.png"]) + expect(submitSpy).toHaveBeenCalledWith("queued text", ["img1.png"], undefined, undefined, [ + { text: "queued text", source: "user" }, + ]) expect(task.messageQueueService.isEmpty()).toBe(true) }) + it("retries a drain that an edit blocked, once the edit commits", async () => { + const task = new Task({ + provider: createProvider(), + apiConfiguration: apiConfig, + task: "initial task", + startTask: false, + }) + const submitSpy = vi.spyOn(task, "submitUserMessage").mockResolvedValue(undefined) + const queue = task.messageQueueService + const id = queue.addMessage("old")!.id + const token = queue.beginEdit(id)! + + vi.useFakeTimers() + task.processQueuedMessages() + vi.runAllTimers() + expect(submitSpy).not.toHaveBeenCalled() + + queue.commitEdit(id, token, "edited", ["data:b"], [{ text: "edited", source: "user" }]) + vi.runAllTimers() + vi.useRealTimers() + + expect(submitSpy).toHaveBeenCalledWith("edited", ["data:b"], undefined, undefined, [ + { text: "edited", source: "user" }, + ]) + expect(queue.isEmpty()).toBe(true) + }) + + it("retries each drain that edits blocked, one per held message", async () => { + const task = new Task({ + provider: createProvider(), + apiConfiguration: apiConfig, + task: "initial task", + startTask: false, + }) + const submitSpy = vi.spyOn(task, "submitUserMessage").mockResolvedValue(undefined) + const queue = task.messageQueueService + const first = queue.addMessage("one")!.id + const second = queue.addMessage("two")!.id + const tokens = [queue.beginEdit(first)!, queue.beginEdit(second)!] + + vi.useFakeTimers() + task.processQueuedMessages() + task.processQueuedMessages() + queue.commitEdit(first, tokens[0], "one edited") + queue.commitEdit(second, tokens[1], "two edited") + vi.runAllTimers() + vi.useRealTimers() + + expect(submitSpy.mock.calls.map((call) => call[0])).toEqual(["one edited", "two edited"]) + expect(queue.isEmpty()).toBe(true) + }) + + it("does not let a surplus blocked drain send a message that arrived later", async () => { + const task = new Task({ + provider: createProvider(), + apiConfiguration: apiConfig, + task: "initial task", + startTask: false, + }) + const submitSpy = vi.spyOn(task, "submitUserMessage").mockResolvedValue(undefined) + const queue = task.messageQueueService + const id = queue.addMessage("old")!.id + const token = queue.beginEdit(id)! + + vi.useFakeTimers() + task.processQueuedMessages() + task.processQueuedMessages() + queue.addMessage("later") + queue.commitEdit(id, token, "edited") + vi.runAllTimers() + vi.useRealTimers() + + expect(submitSpy.mock.calls.map((call) => call[0])).toEqual(["edited"]) + expect(queue.messages.map((m) => m.text)).toEqual(["later"]) + }) + + it("serves a blocked drain when the first of two held messages commits", async () => { + const task = new Task({ + provider: createProvider(), + apiConfiguration: apiConfig, + task: "initial task", + startTask: false, + }) + const submitSpy = vi.spyOn(task, "submitUserMessage").mockResolvedValue(undefined) + const queue = task.messageQueueService + const a = queue.addMessage("a")!.id + const b = queue.addMessage("b")!.id + const tokenA = queue.beginEdit(a)! + queue.beginEdit(b) + + vi.useFakeTimers() + task.processQueuedMessages() + queue.commitEdit(a, tokenA, "a edited") + vi.runAllTimers() + vi.useRealTimers() + + expect(submitSpy.mock.calls.map((call) => call[0])).toEqual(["a edited"]) + }) + + it("keeps a blocked drain when one of its held messages is removed, then serves it", async () => { + const task = new Task({ + provider: createProvider(), + apiConfiguration: apiConfig, + task: "initial task", + startTask: false, + }) + const submitSpy = vi.spyOn(task, "submitUserMessage").mockResolvedValue(undefined) + const queue = task.messageQueueService + const a = queue.addMessage("a")!.id + const b = queue.addMessage("b")!.id + const tokenA = queue.beginEdit(a)! + queue.beginEdit(b) + + vi.useFakeTimers() + task.processQueuedMessages() + queue.removeMessage(b) + vi.runAllTimers() + expect(submitSpy).not.toHaveBeenCalled() + + queue.commitEdit(a, tokenA, "a edited") + vi.runAllTimers() + vi.useRealTimers() + + expect(submitSpy.mock.calls.map((call) => call[0])).toEqual(["a edited"]) + }) + + it("sends the edited message, not a consumer's released message, for a blocked drain", async () => { + const task = new Task({ + provider: createProvider(), + apiConfiguration: apiConfig, + task: "initial task", + startTask: false, + }) + const submitSpy = vi.spyOn(task, "submitUserMessage").mockResolvedValue(undefined) + const queue = task.messageQueueService + queue.addMessage("x") + const x = queue.claimNextMessage()! + const a = queue.addMessage("a")!.id + const token = queue.beginEdit(a)! + + vi.useFakeTimers() + task.processQueuedMessages() + queue.releaseMessage(x.id) + queue.commitEdit(a, token, "a edited") + vi.runAllTimers() + vi.useRealTimers() + + expect(submitSpy.mock.calls.map((call) => call[0])).toEqual(["a edited"]) + expect(queue.messages.map((m) => m.text)).toEqual(["x"]) + }) + + it("does not retry a drain that no edit blocked", async () => { + const task = new Task({ + provider: createProvider(), + apiConfiguration: apiConfig, + task: "initial task", + startTask: false, + }) + const submitSpy = vi.spyOn(task, "submitUserMessage").mockResolvedValue(undefined) + const queue = task.messageQueueService + + vi.useFakeTimers() + task.processQueuedMessages() + queue.addMessage("later") + vi.runAllTimers() + vi.useRealTimers() + + expect(submitSpy).not.toHaveBeenCalled() + }) + it("does not cross-drain queues between separate tasks", async () => { const providerA = createProvider() const providerB = createProvider() @@ -8207,7 +8487,7 @@ describe("Queued message processing after condense", () => { vi.runAllTimers() vi.useRealTimers() - expect(spyA).toHaveBeenCalledWith("A message", undefined) + expect(spyA).toHaveBeenCalledWith("A message", undefined, undefined, undefined, undefined) expect(spyB).not.toHaveBeenCalled() expect(taskB.messageQueueService.isEmpty()).toBe(false) @@ -8217,7 +8497,7 @@ describe("Queued message processing after condense", () => { vi.runAllTimers() vi.useRealTimers() - expect(spyB).toHaveBeenCalledWith("B message", undefined) + expect(spyB).toHaveBeenCalledWith("B message", undefined, undefined, undefined, undefined) expect(taskB.messageQueueService.isEmpty()).toBe(true) }) }) diff --git a/src/core/task/__tests__/ask-queued-message-drain.spec.ts b/src/core/task/__tests__/ask-queued-message-drain.spec.ts index 16fbb1c93e..a0b4ac91fa 100644 --- a/src/core/task/__tests__/ask-queued-message-drain.spec.ts +++ b/src/core/task/__tests__/ask-queued-message-drain.spec.ts @@ -53,6 +53,17 @@ describe("Task.ask queued message drain", () => { expect(result.text).toBe("picked answer") }) + it("forwards the queued message segments to the ask response", async () => { + const task = await createTask() + const segments = [{ text: "@/a", source: "user" as const }] + + const askPromise = task.ask("followup", "Q?", false) + task.messageQueueService.addMessage("@/a", undefined, segments) + + const result = await askPromise + expect(result.segments).toEqual(segments) + }) + it("does not consume queued messages for command_output asks", async () => { const task = await createTask() diff --git a/src/core/tools/AskFollowupQuestionTool.ts b/src/core/tools/AskFollowupQuestionTool.ts index 8581d71871..6a298da573 100644 --- a/src/core/tools/AskFollowupQuestionTool.ts +++ b/src/core/tools/AskFollowupQuestionTool.ts @@ -73,9 +73,11 @@ export class AskFollowupQuestionTool extends BaseTool<"ask_followup_question"> { } task.consecutiveMistakeCount = 0 - const { text, images } = await task.ask("followup", JSON.stringify(follow_up_json), false) + const { text, images, segments } = await task.ask("followup", JSON.stringify(follow_up_json), false) const safeText = text ?? "" await task.say("user_feedback", safeText, images) + // Only user segments expand. The tool result repeats the text by design. + task.userMessageContent.push(...(await task.userInputContent(safeText, segments))) pushToolResult(formatResponse.toolResult(`\n${safeText}\n`, images)) } catch (error) { await handleError("asking question", error as Error) diff --git a/src/core/tools/AttemptCompletionTool.ts b/src/core/tools/AttemptCompletionTool.ts index 4fe03ce94c..3114e753c5 100644 --- a/src/core/tools/AttemptCompletionTool.ts +++ b/src/core/tools/AttemptCompletionTool.ts @@ -218,7 +218,7 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> { task.flushTelemetryInstallment("attempt_completion") } - const { response, text, images, queuedMessageId } = await task.ask("completion_result", "", false) + const { response, text, images, queuedMessageId, segments } = await task.ask("completion_result", "", false) if (response === "yesButtonClicked") { // A stale history replay reruns this handler on a fresh Task instance for a @@ -245,6 +245,8 @@ export class AttemptCompletionTool extends BaseTool<"attempt_completion"> { } const feedbackText = `\n${text}\n` + // Only user segments expand. The tool result repeats the text by design. + task.userMessageContent.push(...(await task.userInputContent(text ?? "", segments))) pushToolResult(formatResponse.toolResult(feedbackText, images)) } catch (error) { await handleError("inspecting site", error as Error) diff --git a/src/core/tools/__tests__/askFollowupQuestionTool.spec.ts b/src/core/tools/__tests__/askFollowupQuestionTool.spec.ts index e5b1257654..a736a2a1ab 100644 --- a/src/core/tools/__tests__/askFollowupQuestionTool.spec.ts +++ b/src/core/tools/__tests__/askFollowupQuestionTool.spec.ts @@ -11,19 +11,26 @@ describe("AskFollowupQuestionTool", () => { let tool: AskFollowupQuestionTool let mockTask: Task let mockCallbacks: ToolCallbacks + // Kept outside the Task double so tests can re-stub answers without casts. + let askMock: ReturnType + let userInputContent: ReturnType + const expandedContent = [{ type: "text", text: "expanded" }] beforeEach(() => { vi.clearAllMocks() - tool = new AskFollowupQuestionTool() + askMock = vi.fn().mockResolvedValue({ text: "User answer", images: [] }) + userInputContent = vi.fn().mockResolvedValue(expandedContent) mockTask = { + userMessageContent: [], consecutiveMistakeCount: 0, recordToolError: vi.fn(), didToolFailInCurrentTurn: false, sayAndCreateMissingParamError: vi.fn().mockResolvedValue("Missing parameter error"), - ask: vi.fn().mockResolvedValue({ text: "User answer", images: [] }), + ask: askMock, say: vi.fn().mockResolvedValue(undefined), + userInputContent, } as unknown as Task mockCallbacks = { @@ -211,6 +218,28 @@ describe("AskFollowupQuestionTool", () => { ) }) + it.each([ + { label: "user segments", text: "@/allowed", segments: [{ text: "@/allowed", source: "user" }] }, + { + label: "mixed segments", + text: "@/secret @/mine", + segments: [ + { text: "@/secret ", source: "generated" }, + { text: "@/mine", source: "user" }, + ], + }, + { label: "missing segments", text: "@/secret", segments: undefined }, + { label: "a null answer", text: null, segments: undefined }, + ])("hands the answer with $label to Task.userInputContent", async ({ text, segments }) => { + const params = { question: "What?", follow_up: [{ text: "A" }] } + askMock.mockResolvedValue({ text, images: [], segments }) + + await tool.execute(params, mockTask, mockCallbacks) + + expect(userInputContent).toHaveBeenCalledWith(text ?? "", segments) + expect(mockTask.userMessageContent).toEqual(expandedContent) + }) + it("should pass images from user response to toolResult", async () => { const params = { question: "Look at this?", diff --git a/src/core/tools/__tests__/attemptCompletionTool.spec.ts b/src/core/tools/__tests__/attemptCompletionTool.spec.ts index 29580ef203..691a0c6c83 100644 --- a/src/core/tools/__tests__/attemptCompletionTool.spec.ts +++ b/src/core/tools/__tests__/attemptCompletionTool.spec.ts @@ -33,6 +33,7 @@ import { AskApproval, HandleError, PushToolResult } from "../../../shared/tools" import * as vscode from "vscode" describe("attemptCompletionTool", () => { + const expandedContent = [{ type: "text" as const, text: "expanded" }] let mockTask: Partial let mockPushToolResult: ReturnType> let mockAskApproval: ReturnType> @@ -60,6 +61,8 @@ describe("attemptCompletionTool", () => { vi.mocked(vscode.workspace.getConfiguration).mockImplementation(mockGetConfiguration) mockTask = { + userMessageContent: [], + userInputContent: vi.fn().mockResolvedValue(expandedContent), consecutiveMistakeCount: 0, recordToolError: vi.fn(), todoList: undefined, @@ -1161,6 +1164,41 @@ describe("attemptCompletionTool", () => { expect(mockPushToolResult).toHaveBeenCalledTimes(1) }) + it.each([ + { label: "user segments", text: "@/allowed", segments: [{ text: "@/allowed", source: "user" }] }, + { + label: "mixed segments", + text: "@/secret @/mine", + segments: [ + { text: "@/secret ", source: "generated" }, + { text: "@/mine", source: "user" }, + ], + }, + { label: "missing segments", text: "@/secret", segments: undefined }, + { label: "undefined feedback", text: undefined, segments: undefined }, + ])("hands the feedback with $label to Task.userInputContent", async ({ text, segments }) => { + const block: ToolUse<"attempt_completion"> = { + type: "tool_use", + name: "attempt_completion", + params: { result: "Done" }, + nativeArgs: { result: "Done" }, + partial: false, + } + mockTask.ask = vi.fn().mockResolvedValue({ response: "messageResponse", text, images: [], segments }) + + await attemptCompletionTool.handle(mockTask as Task, block, { + askApproval: mockAskApproval, + handleError: mockHandleError, + pushToolResult: mockPushToolResult, + toolCallId: "", + askFinishSubTaskApproval: mockAskFinishSubTaskApproval, + toolDescription: mockToolDescription, + }) + + expect(mockTask.userInputContent).toHaveBeenCalledWith(text ?? "", segments) + expect(mockTask.userMessageContent).toEqual(expandedContent) + }) + it("does not clear pending metadata when stale delegation continues without an action id", async () => { const block: ToolUse<"attempt_completion"> = { type: "tool_use", diff --git a/src/core/webview/ClineProvider.ts b/src/core/webview/ClineProvider.ts index 6c9182fcfb..f19b686b32 100644 --- a/src/core/webview/ClineProvider.ts +++ b/src/core/webview/ClineProvider.ts @@ -91,6 +91,7 @@ import { CloudService, getRooCodeApiUrl } from "@roo-code/cloud" import { Package } from "../../shared/package" import { findLast } from "../../shared/array" import { supportPrompt } from "../../shared/support-prompt" +import { generatedSegments, joinSegments } from "../../shared/mentionSegments" import { GlobalFileNames } from "../../shared/globalFileNames" import { Mode, defaultModeSlug, getModeBySlug } from "../../shared/modes" import { experimentDefault } from "../../shared/experiments" @@ -139,7 +140,7 @@ import { PendingActionSettlementError, Task } from "../task/Task" import { webviewMessageHandler } from "./webviewMessageHandler" import type { WebviewFocusTracker } from "./WebviewFocusTracker" -import type { ClineMessage, TodoItem } from "@roo-code/types" +import type { ClineMessage, MentionSegment, TodoItem } from "@roo-code/types" import { type ApiMessage, readApiMessages, @@ -1128,19 +1129,22 @@ export class ClineProvider const { customSupportPrompts } = await this.getState() // TODO: Improve type safety for promptType. - const prompt = supportPrompt.create(promptType, params, customSupportPrompts) + // Only the typed input is a user segment. The template and its other params are generated. + const segments = supportPrompt.createSegments(promptType, params, customSupportPrompts) + const prompt = joinSegments(segments) if (command === "addToContext") { await this.postMessageToWebview({ type: "invoke", invoke: "setChatBoxMessage", text: `${prompt}\n\n`, + segments: [...segments, ...generatedSegments("\n\n")], }) await this.postMessageToWebview({ type: "action", action: "focusInput" }) return } - await this.createTask(prompt) + await this.createTask(prompt, undefined, undefined, { segments }) } public static async handleTerminalAction( @@ -1157,20 +1161,22 @@ export class ClineProvider } const { customSupportPrompts } = await visibleProvider.getState() - const prompt = supportPrompt.create(promptType, params, customSupportPrompts) + const segments = supportPrompt.createSegments(promptType, params, customSupportPrompts) + const prompt = joinSegments(segments) if (command === "terminalAddToContext") { await visibleProvider.postMessageToWebview({ type: "invoke", invoke: "setChatBoxMessage", text: `${prompt}\n\n`, + segments: [...segments, ...generatedSegments("\n\n")], }) await visibleProvider.postMessageToWebview({ type: "action", action: "focusInput" }) return } try { - await visibleProvider.createTask(prompt) + await visibleProvider.createTask(prompt, undefined, undefined, { segments }) } catch (error) { if (error instanceof OrganizationAllowListViolationError) { // Errors from terminal commands seem to get swallowed / ignored. @@ -4366,7 +4372,10 @@ export class ClineProvider text?: string, images?: string[], parentTask?: Task, - options: CreateTaskOptions & { handoffExecutionContext?: DelegatedChildContext } = {}, + options: CreateTaskOptions & { + handoffExecutionContext?: DelegatedChildContext + segments?: MentionSegment[] + } = {}, configuration: RooCodeSettings = {}, ): Promise { if (configuration) { diff --git a/src/core/webview/__tests__/ClineProvider.spec.ts b/src/core/webview/__tests__/ClineProvider.spec.ts index 67b1e00853..f0f8c26ef0 100644 --- a/src/core/webview/__tests__/ClineProvider.spec.ts +++ b/src/core/webview/__tests__/ClineProvider.spec.ts @@ -28,6 +28,8 @@ import { import { TelemetryService } from "@roo-code/telemetry" import { defaultModeSlug } from "../../../shared/modes" +import { joinSegments } from "../../../shared/mentionSegments" +import type { MentionSegment } from "@roo-code/types" import { experimentDefault } from "../../../shared/experiments" import { setTtsEnabled } from "../../../utils/tts" import { ContextProxy } from "../../config/ContextProxy" @@ -428,6 +430,25 @@ afterAll(() => { vi.restoreAllMocks() }) +// Matches a non-empty segment list that holds only generated text. +const noUserSegments = { + asymmetricMatch: (value: unknown) => + Array.isArray(value) && value.length > 0 && value.every((segment) => segment?.source === "generated"), + toString: () => "onlyGeneratedSegments", +} + +// The text equals the joined parts, and only the typed input is a user part. +// The generated context holds a mention and stays generated. +function expectMixedPayload(call: unknown[], context: string, sources: MentionSegment["source"][]) { + const [text, , , options] = call as [string, unknown, unknown, { segments: MentionSegment[] }] + const { segments } = options + expect(joinSegments(segments)).toBe(text) + expect(segments.map((s) => s.source)).toEqual(sources) + expect(segments.filter((s) => s.source === "user")).toEqual([{ text: "@/allowed", source: "user" }]) + expect(segments.filter((s) => s.source === "generated").some((s) => s.text.includes(context))).toBe(true) + expect(segments.filter((s) => s.source === "user").some((s) => s.text.includes("@/generated"))).toBe(false) +} + describe("ClineProvider", () => { beforeAll(() => { vi.mocked(Task).mockImplementation(function (options: any) { @@ -748,6 +769,8 @@ describe("ClineProvider", () => { type: "invoke", invoke: "setChatBoxMessage", text: expect.stringContaining("selected code"), + // Generated context has no user segment. + segments: noUserSegments, }) expect(sidebar.postMessage).toHaveBeenCalledWith({ type: "action", action: "focusInput" }) expect(tab.postMessage).not.toHaveBeenCalled() @@ -938,6 +961,8 @@ describe("ClineProvider", () => { type: "invoke", invoke: "setChatBoxMessage", text: expect.stringContaining("selected code"), + // Generated context is never the authorized substring. + segments: noUserSegments, }) expect(visible.postMessage).toHaveBeenCalledWith({ type: "action", action: "focusInput" }) expect(vscode.commands.executeCommand).not.toHaveBeenCalled() @@ -966,6 +991,8 @@ describe("ClineProvider", () => { type: "invoke", invoke: "setChatBoxMessage", text: expect.stringContaining("selected code"), + // Generated context is never the authorized substring. + segments: noUserSegments, }) expect(tab.postMessage).not.toHaveBeenCalled() expect(panel.reveal).not.toHaveBeenCalled() @@ -1022,7 +1049,12 @@ describe("ClineProvider", () => { const target = provider.webviewFocusTracker.getLastActiveProvider()! await target.handleCodeAction(command, promptType, { selectedText: "selected code" }) expect(sidebarTask).toHaveBeenCalledOnce() - expect(sidebarTask).toHaveBeenCalledWith(expect.stringContaining("selected code")) + expect(sidebarTask).toHaveBeenCalledWith( + expect.stringContaining("selected code"), + undefined, + undefined, + { segments: noUserSegments }, + ) expect(tabTask).not.toHaveBeenCalled() } finally { sidebarTask.mockRestore() @@ -1041,6 +1073,51 @@ describe("ClineProvider", () => { sidebarTask.mockRestore() tabTask.mockRestore() }) + + test.each([ + ["explainCode", "EXPLAIN"], + ["fixCode", "FIX"], + ["improveCode", "IMPROVE"], + ] as const)( + "forwards user-authored code action input as a user segment for %s", + async (command, promptType) => { + const task = new Task(defaultTaskOptions) + const createTask = vi.spyOn(provider, "createTask").mockResolvedValue(task) + try { + await provider.handleCodeAction(command, promptType, { + selectedText: "selected @/generated", + userInput: "@/allowed", + }) + expectMixedPayload(createTask.mock.calls[0], "selected @/generated", [ + "generated", + "user", + "generated", + ]) + } finally { + createTask.mockRestore() + } + }, + ) + + test("forwards user-authored terminal action input as a user segment", async () => { + const task = new Task(defaultTaskOptions) + const sidebarTask = vi.spyOn(provider, "createTask").mockResolvedValue(task) + const tabTask = vi.spyOn(tabProvider, "createTask").mockResolvedValue(task) + try { + // No chat focus fired, so the last registered visible provider + // (the tab) receives the task, as in the fallback test above. + await ClineProvider.handleTerminalAction("terminalFixCommand", "TERMINAL_FIX", { + terminalContent: "output @/generated", + userInput: "@/allowed", + }) + expect(tabTask).toHaveBeenCalledOnce() + expectMixedPayload(tabTask.mock.calls[0], "output @/generated", ["user", "generated"]) + expect(sidebarTask).not.toHaveBeenCalled() + } finally { + sidebarTask.mockRestore() + tabTask.mockRestore() + } + }) }) test("loads full model details when preparing an LM Studio task", async () => { @@ -7486,7 +7563,13 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { expect(mockCline.overwriteClineMessages).toHaveBeenCalledWith([mockMessages[0]]) expect(mockCline.overwriteApiConversationHistory).toHaveBeenCalledWith([{ ts: 1000 }]) // Verify submitUserMessage was called with the edited content - expect(mockCline.submitUserMessage).toHaveBeenCalledWith("Edited message with preserved images", []) + expect(mockCline.submitUserMessage).toHaveBeenCalledWith( + "Edited message with preserved images", + [], + undefined, + undefined, + [{ text: "Edited message with preserved images", source: "generated" }], + ) }) test("handles editing messages with file attachments", async () => { @@ -7539,7 +7622,13 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { }) expect(mockCline.overwriteClineMessages).toHaveBeenCalled() - expect(mockCline.submitUserMessage).toHaveBeenCalledWith("Edited message with file attachment", []) + expect(mockCline.submitUserMessage).toHaveBeenCalledWith( + "Edited message with file attachment", + [], + undefined, + undefined, + [{ text: "Edited message with file attachment", source: "generated" }], + ) }) }) @@ -8070,7 +8159,9 @@ describe("ClineProvider - Comprehensive Edit/Delete Edge Cases", () => { await messageHandler({ type: "editMessageConfirm", messageTs: 2000, text: largeEditedContent }) expect(mockCline.overwriteClineMessages).toHaveBeenCalled() - expect(mockCline.submitUserMessage).toHaveBeenCalledWith(largeEditedContent, []) + expect(mockCline.submitUserMessage).toHaveBeenCalledWith(largeEditedContent, [], undefined, undefined, [ + { text: largeEditedContent, source: "generated" }, + ]) }) test("handles deleting messages with large payloads", async () => { diff --git a/src/core/webview/__tests__/webviewMessageHandler.newTask.spec.ts b/src/core/webview/__tests__/webviewMessageHandler.newTask.spec.ts new file mode 100644 index 0000000000..a6715f70e6 --- /dev/null +++ b/src/core/webview/__tests__/webviewMessageHandler.newTask.spec.ts @@ -0,0 +1,243 @@ +import { describe, it, expect, beforeEach, vi } from "vitest" +import { webviewMessageHandler } from "../webviewMessageHandler" +import type { ClineProvider } from "../ClineProvider" +import type { MentionSegment } from "@roo-code/types" +import type { WebviewMessage } from "../../../shared/WebviewMessage" + +vi.mock("../../../i18n", () => ({ + t: vi.fn((key: string) => key), + changeLanguage: vi.fn(), +})) + +vi.mock("vscode", () => ({ + window: { + showErrorMessage: vi.fn(), + showWarningMessage: vi.fn(), + showInformationMessage: vi.fn(), + }, + workspace: { + workspaceFolders: undefined, + getConfiguration: vi.fn(() => ({ + get: vi.fn(), + update: vi.fn(), + })), + }, + ConfigurationTarget: { Global: 1, Workspace: 2, WorkspaceFolder: 3 }, + Uri: { + parse: vi.fn((str: string) => ({ toString: () => str })), + file: vi.fn((path: string) => ({ fsPath: path })), + }, + env: { openExternal: vi.fn() }, + commands: { executeCommand: vi.fn() }, +})) + +const { resolveImageMentions } = vi.hoisted(() => ({ + resolveImageMentions: vi.fn(async ({ images }: { images?: string[] }) => ({ text: "", images: images ?? [] })), +})) +vi.mock("../../mentions/resolveImageMentions", () => ({ resolveImageMentions })) + +vi.mock("../../task-persistence", async (importOriginal) => ({ + ...(await importOriginal()), + saveTaskMessages: vi.fn(), +})) + +const generated = (text: string): MentionSegment => ({ text, source: "generated" }) +const user = (text: string): MentionSegment => ({ text, source: "user" }) + +describe("webviewMessageHandler mention segment forwarding", () => { + // Narrow double: the handler under test only touches these members. + // The single cast at construction keeps every use site type-checked. + let provider: { + createTask: ReturnType + postMessageToWebview: ReturnType + getCurrentTask: ReturnType + getState: ReturnType + postStateToWebview: ReturnType + log: ReturnType + contextProxy: { globalStorageUri: { fsPath: string } } + } + let providerAsClineProvider: ClineProvider + let currentTask: { + handleWebviewAskResponse: ReturnType + messageQueueService: { + addMessage: ReturnType + beginEdit: ReturnType + commitEdit: ReturnType + } + } + + beforeEach(() => { + vi.clearAllMocks() + currentTask = { + handleWebviewAskResponse: vi.fn(), + messageQueueService: { + addMessage: vi.fn(), + beginEdit: vi.fn(() => 7), + commitEdit: vi.fn(() => true), + }, + } + provider = { + createTask: vi.fn().mockResolvedValue({ taskId: "task-1" }), + postMessageToWebview: vi.fn().mockResolvedValue(undefined), + getCurrentTask: vi.fn(() => currentTask), + getState: vi.fn().mockResolvedValue({ maxImageFileSize: 5, maxTotalImageSize: 20 }), + postStateToWebview: vi.fn().mockResolvedValue(undefined), + log: vi.fn(), + contextProxy: { globalStorageUri: { fsPath: "/tmp/storage" } }, + } + providerAsClineProvider = provider as unknown as ClineProvider + }) + + const text = "context @/secret\nuser line" + const segments = [generated("context @/secret\n"), user("user line")] + // Segments that the handler must replace with all generated text. + const rejected = [ + { label: "omitted", segments: undefined }, + { label: "not matching the text", segments: [user("other")] }, + { label: "invalid", segments: [{ text, source: "system" }] }, + ] + + describe.each([ + { + type: "newTask" as const, + read: () => provider.createTask.mock.calls[0], + segmentsOf: (call: unknown[]) => (call[3] as { segments: MentionSegment[] }).segments, + }, + { + type: "askResponse" as const, + read: () => currentTask.handleWebviewAskResponse.mock.calls[0], + segmentsOf: (call: unknown[]) => call[3] as MentionSegment[], + }, + { + type: "queueMessage" as const, + read: () => currentTask.messageQueueService.addMessage.mock.calls[0], + segmentsOf: (call: unknown[]) => call[2] as MentionSegment[], + }, + ])("$type", ({ type, read, segmentsOf }) => { + const send = (extra: Record) => + webviewMessageHandler(providerAsClineProvider, { + type, + askResponse: "messageResponse", + ...extra, + } as WebviewMessage) + + it("forwards matching segments", async () => { + await send({ text, segments }) + expect(segmentsOf(read()!)).toEqual(segments) + }) + + it.each(rejected)("treats segments that are $label as all generated", async ({ segments: bad }) => { + await send({ text, segments: bad }) + expect(segmentsOf(read()!)).toEqual([generated(text)]) + }) + + it.each([ + { label: "user segment", segments: [user("see @/a.png")], expected: "see @/a.png" }, + { label: "generated segment", segments: [generated("see @/a.png")], expected: "" }, + ])("scans only user text for images with a $label", async ({ segments: given, expected }) => { + await send({ text: "see @/a.png", segments: given }) + expect(resolveImageMentions).toHaveBeenCalledWith(expect.objectContaining({ text: expected })) + }) + }) + + it("keeps the original text and images when it forwards", async () => { + const message: WebviewMessage = { type: "newTask", text, segments } + await webviewMessageHandler(providerAsClineProvider, message) + + expect(provider.createTask).toHaveBeenCalledWith(text, [], undefined, expect.anything(), undefined) + }) + + it("authorizes nothing in an edited message", async () => { + const submitUserMessage = vi.fn() + const editTask = { + taskId: "task-1", + clineMessages: [{ ts: 1, type: "say", say: "user_feedback", text: "old" }], + apiConversationHistory: [], + overwriteClineMessages: vi.fn(), + overwriteApiConversationHistory: vi.fn(), + submitUserMessage, + messageManager: { rewindToTimestamp: vi.fn() }, + } + provider.getCurrentTask.mockReturnValue(editTask) + const message: WebviewMessage = { type: "editMessageConfirm", messageTs: 1, text: "see @/a.png" } + await webviewMessageHandler(providerAsClineProvider, message) + + expect(resolveImageMentions).toHaveBeenCalledWith(expect.objectContaining({ text: "" })) + expect(submitUserMessage).toHaveBeenCalledWith("see @/a.png", expect.anything(), undefined, undefined, [ + generated("see @/a.png"), + ]) + }) + + describe("editQueuedMessage", () => { + const edit = (payload: unknown) => + webviewMessageHandler(providerAsClineProvider, { type: "editQueuedMessage", payload } as WebviewMessage) + + it("commits a valid edit with its segments and the resolved images", async () => { + resolveImageMentions.mockResolvedValueOnce({ text: "", images: ["data:resolved"] }) + await edit({ id: "q1", text, images: ["data:old"], segments }) + expect(currentTask.messageQueueService.beginEdit).toHaveBeenCalledWith("q1") + expect(currentTask.messageQueueService.commitEdit).toHaveBeenCalledWith( + "q1", + 7, + text, + ["data:resolved"], + segments, + ) + }) + + it.each([ + { label: "user segment", segs: [user("see @/a.png")], scanned: "see @/a.png" }, + { label: "generated segment", segs: [generated("see @/a.png")], scanned: "" }, + ])("scans only user text for images in an edit with a $label", async ({ segs, scanned }) => { + await edit({ id: "q1", text: "see @/a.png", segments: segs }) + expect(resolveImageMentions).toHaveBeenCalledWith(expect.objectContaining({ text: scanned })) + }) + + // Mirrors docs/architecture/tla/QueueEditRace.tla, mode Claim. + it("holds the message during the image scan and commits once, after the scan", async () => { + let finish: (value: { text: string; images: string[] }) => void = () => {} + resolveImageMentions.mockReturnValueOnce(new Promise((resolve) => (finish = resolve))) + const pending = edit({ id: "q1", text, segments }) + + await vi.waitFor(() => expect(resolveImageMentions).toHaveBeenCalled()) + expect(currentTask.messageQueueService.beginEdit).toHaveBeenCalledTimes(1) + expect(currentTask.messageQueueService.commitEdit).not.toHaveBeenCalled() + + finish({ text: "", images: ["data:b"] }) + await pending + expect(currentTask.messageQueueService.commitEdit).toHaveBeenCalledWith("q1", 7, text, ["data:b"], segments) + }) + + it("keeps the old images and still commits when the image scan fails", async () => { + resolveImageMentions.mockRejectedValueOnce(new Error("disk")) + await edit({ id: "q1", text, images: ["data:old"], segments }) + expect(currentTask.messageQueueService.commitEdit).toHaveBeenCalledWith( + "q1", + 7, + text, + ["data:old"], + segments, + ) + }) + + it("scans nothing and logs when the message has left the queue", async () => { + currentTask.messageQueueService.beginEdit.mockReturnValueOnce(undefined) + resolveImageMentions.mockClear() + await edit({ id: "q1", text, segments }) + expect(resolveImageMentions).not.toHaveBeenCalled() + expect(currentTask.messageQueueService.commitEdit).not.toHaveBeenCalled() + expect(provider.log).toHaveBeenCalledWith(expect.stringContaining("Edit dropped")) + }) + + it.each([ + { label: "missing", payload: undefined }, + { label: "not an object", payload: "q1" }, + { label: "missing an id", payload: { text } }, + { label: "a non-string text", payload: { id: "q1", text: 1 } }, + { label: "a non-list images field", payload: { id: "q1", text, images: "x" } }, + ])("ignores a payload that is $label", async ({ payload }) => { + await edit(payload) + expect(currentTask.messageQueueService.beginEdit).not.toHaveBeenCalled() + }) + }) +}) diff --git a/src/core/webview/__tests__/webviewMessageHandler.spec.ts b/src/core/webview/__tests__/webviewMessageHandler.spec.ts index 98c306a4f3..d49a9f9c1a 100644 --- a/src/core/webview/__tests__/webviewMessageHandler.spec.ts +++ b/src/core/webview/__tests__/webviewMessageHandler.spec.ts @@ -964,9 +964,13 @@ describe("webviewMessageHandler - image mentions", () => { }) expect(vi.mocked(resolveImageMentions)).toHaveBeenCalled() - expect(mockHandleWebviewAskResponse).toHaveBeenCalledWith("messageResponse", "See @/img.png", [ - "data:image/png;base64,from-mention", - ]) + // Omitted segments fail closed, so the text is all generated. + expect(mockHandleWebviewAskResponse).toHaveBeenCalledWith( + "messageResponse", + "See @/img.png", + ["data:image/png;base64,from-mention"], + [{ text: "See @/img.png", source: "generated" }], + ) }) }) diff --git a/src/core/webview/webviewMessageHandler.ts b/src/core/webview/webviewMessageHandler.ts index cf9d209191..d20efcb9db 100644 --- a/src/core/webview/webviewMessageHandler.ts +++ b/src/core/webview/webviewMessageHandler.ts @@ -15,11 +15,11 @@ import { type ProviderSettings, type Command as SlashCommand, type WebviewMessage, - type EditQueuedMessagePayload, TelemetryEventName, RooCodeSettings, ExperimentId, checkoutDiffPayloadSchema, + editQueuedMessagePayloadSchema, checkoutRestorePayloadSchema, getCompletionCheckpoint, providerIdentifiers, @@ -30,6 +30,7 @@ import { RouterModelsMessageType, VsCodeLmModelsMessageType, isTelemetryOptedIn, + type MentionSegment, } from "@roo-code/types" import { handleRequestProviderInfo } from "./providerInfoHandler" import { customToolRegistry } from "@roo-code/core" @@ -91,6 +92,7 @@ import { openGitHubAccountManagement, } from "../../api/providers/github-copilot" import { openMention } from "../mentions" +import { generatedSegments, normalizeSegments, userText } from "../../shared/mentionSegments" import { resolveImageMentions } from "../mentions/resolveImageMentions" import { RooIgnoreController } from "../ignore/RooIgnoreController" import { getWorkspacePath } from "../../utils/path" @@ -227,21 +229,25 @@ export const webviewMessageHandler = async ( * Resolves image file mentions in incoming messages. * Matches read_file behavior: respects size limits and model capabilities. */ - const resolveIncomingImages = async (payload: { text?: string; images?: string[] }) => { + const resolveIncomingImages = async (payload: { text?: string; images?: string[]; segments: MentionSegment[] }) => { const text = payload.text ?? "" const images = payload.images const currentTask = provider.getCurrentTask() const state = await provider.getState() + // Scan only user segments, so generated mentions attach no images. const resolved = await resolveImageMentions({ - text, + text: userText(payload.segments), images, cwd: getCurrentCwd(), rooIgnoreController: currentTask?.rooIgnoreController, maxImageFileSize: state.maxImageFileSize, maxTotalImageSize: state.maxTotalImageSize, }) - return resolved + return { text, images: resolved.images } } + // Fails closed: segments that are missing or do not match the text are all generated. + const segmentsOf = (message: { text?: string; segments?: unknown }) => + normalizeSegments(message.text ?? "", message.segments) /** * Shared utility to find message indices based on timestamp. * When multiple messages share the same timestamp (e.g., after condense), @@ -438,6 +444,7 @@ export const webviewMessageHandler = async ( editedContent: string, restoreCheckpoint?: boolean, images?: string[], + segments?: MentionSegment[], ): Promise => { const currentCline = provider.getCurrentTask() if (!currentCline) { @@ -557,7 +564,7 @@ export const webviewMessageHandler = async ( // Update the UI to reflect the deletion await provider.postStateToWebview() - await currentCline.submitUserMessage(editedContent, images) + await currentCline.submitUserMessage(editedContent, images, undefined, undefined, segments) } catch (error) { console.error("Error in edit message:", error) vscode.window.showErrorMessage( @@ -712,12 +719,19 @@ export const webviewMessageHandler = async ( // agentically running promises in old instance don't affect our new // task. This essentially creates a fresh slate for the new task. try { - const resolved = await resolveIncomingImages({ text: message.text, images: message.images }) + const resolved = await resolveIncomingImages({ + text: message.text, + images: message.images, + segments: segmentsOf(message), + }) await provider.createTask( resolved.text, resolved.images, undefined, - { taskId: message.taskId }, + { + taskId: message.taskId, + segments: segmentsOf(message), + }, message.taskConfiguration, ) // Task created successfully - notify the UI to reset @@ -737,10 +751,15 @@ export const webviewMessageHandler = async ( case "askResponse": { - const resolved = await resolveIncomingImages({ text: message.text, images: message.images }) + const segments = segmentsOf(message) + const resolved = await resolveIncomingImages({ + text: message.text, + images: message.images, + segments, + }) provider .getCurrentTask() - ?.handleWebviewAskResponse(message.askResponse!, resolved.text, resolved.images) + ?.handleWebviewAskResponse(message.askResponse!, resolved.text, resolved.images, segments) } break @@ -2616,12 +2635,19 @@ export const webviewMessageHandler = async ( break case "editMessageConfirm": if (message.messageTs && message.text) { - const resolved = await resolveIncomingImages({ text: message.text, images: message.images }) + // Stored messages carry no segments, so fail closed: nothing is expanded. + const editSegments = generatedSegments(message.text) + const resolved = await resolveIncomingImages({ + text: message.text, + images: message.images, + segments: editSegments, + }) await handleEditMessageConfirm( message.messageTs, resolved.text, message.restoreCheckpoint, resolved.images, + editSegments, ) } break @@ -4030,8 +4056,9 @@ export const webviewMessageHandler = async ( */ case "queueMessage": { - const resolved = await resolveIncomingImages({ text: message.text, images: message.images }) - provider.getCurrentTask()?.messageQueueService.addMessage(resolved.text, resolved.images) + const segments = segmentsOf(message) + const resolved = await resolveIncomingImages({ text: message.text, images: message.images, segments }) + provider.getCurrentTask()?.messageQueueService.addMessage(resolved.text, resolved.images, segments) break } case "removeQueuedMessage": { @@ -4039,9 +4066,23 @@ export const webviewMessageHandler = async ( break } case "editQueuedMessage": { - if (message.payload) { - const { id, text, images } = message.payload as EditQueuedMessagePayload - provider.getCurrentTask()?.messageQueueService.updateMessage(id, text, images) + const edit = editQueuedMessagePayloadSchema.safeParse(message.payload) + if (edit.success) { + const { id, text, segments: given } = edit.data + const queue = provider.getCurrentTask()?.messageQueueService + // The edit holds the message during the image scan, so a drain cannot send the old text. + const token = queue?.beginEdit(id) + if (queue && token !== undefined) { + let images = edit.data.images + try { + images = (await resolveIncomingImages({ text, images, segments: segmentsOf(edit.data) })).images + } catch (error) { + provider.log(`[editQueuedMessage] Image scan failed: ${error}`) + } + queue.commitEdit(id, token, text, images, given) + } else { + provider.log("[editQueuedMessage] Edit dropped: the message already left the queue.") + } } break diff --git a/src/eslint-suppressions.json b/src/eslint-suppressions.json index d5b845997a..4e010d814f 100644 --- a/src/eslint-suppressions.json +++ b/src/eslint-suppressions.json @@ -589,11 +589,6 @@ "count": 1 } }, - "core/mentions/__tests__/processUserContentMentions.spec.ts": { - "@typescript-eslint/no-explicit-any": { - "count": 1 - } - }, "core/mentions/index.ts": { "@typescript-eslint/no-explicit-any": { "count": 1 diff --git a/src/extension/__tests__/api-send-message.spec.ts b/src/extension/__tests__/api-send-message.spec.ts index dc51d06445..1804315c85 100644 --- a/src/extension/__tests__/api-send-message.spec.ts +++ b/src/extension/__tests__/api-send-message.spec.ts @@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach } from "vitest" import * as vscode from "vscode" import { API } from "../api" +import { userSegments } from "../../shared/mentionSegments" import { ClineProvider } from "../../core/webview/ClineProvider" import { makeClineProviderFactory } from "../../test-utils/provider" @@ -53,6 +54,7 @@ describe("API - SendMessage Command", () => { invoke: "sendMessage", text: messageText, images: undefined, + segments: userSegments(messageText ?? ""), }) }) @@ -72,6 +74,7 @@ describe("API - SendMessage Command", () => { invoke: "sendMessage", text: messageText, images, + segments: userSegments(messageText ?? ""), }) }) @@ -90,6 +93,7 @@ describe("API - SendMessage Command", () => { invoke: "sendMessage", text: undefined, images, + segments: userSegments(""), }) }) @@ -103,6 +107,7 @@ describe("API - SendMessage Command", () => { invoke: "sendMessage", text: undefined, images: undefined, + segments: userSegments(""), }) }) @@ -129,6 +134,7 @@ describe("API - SendMessage Command", () => { invoke: "sendMessage", text: messageText, images: undefined, + segments: userSegments(messageText ?? ""), }) }) @@ -150,7 +156,38 @@ describe("API - SendMessage Command", () => { invoke: "sendMessage", text: messageText, images, + segments: userSegments(messageText ?? ""), }) expect(mockPostMessageToWebview).toHaveBeenCalledTimes(1) }) + + describe("when the webview is not launched", () => { + const user = (text: string) => ({ text, source: "user" as const }) + + it.each([ + { label: "text and images", text: "see @/file.ts", images: ["img"], expected: [user("see @/file.ts")] }, + { label: "empty text", text: "", images: undefined, expected: [] }, + { label: "missing text", text: undefined, images: undefined, expected: [] }, + ])("submits the user text directly with $label", async ({ text, images, expected }) => { + const submitUserMessage = vi.fn().mockResolvedValue(undefined) + Object.assign(mockProvider, { + viewLaunched: false, + getCurrentTask: vi.fn().mockReturnValue({ submitUserMessage }), + }) + + await api.sendMessage(text, images) + + expect(submitUserMessage).toHaveBeenCalledWith(text ?? "", images, undefined, undefined, expected) + expect(mockPostMessageToWebview).not.toHaveBeenCalled() + }) + + it("logs and drops the message when there is no current task", async () => { + Object.assign(mockProvider, { viewLaunched: false }) + + await api.sendMessage("see @/file.ts") + + expect(mockLog).toHaveBeenCalledWith(expect.stringContaining("no current task")) + expect(mockPostMessageToWebview).not.toHaveBeenCalled() + }) + }) }) diff --git a/src/extension/__tests__/api-start-new-task.spec.ts b/src/extension/__tests__/api-start-new-task.spec.ts index e33f2b3553..d1a473d1d0 100644 --- a/src/extension/__tests__/api-start-new-task.spec.ts +++ b/src/extension/__tests__/api-start-new-task.spec.ts @@ -86,7 +86,11 @@ describe("API - startNewTask routing", () => { "new task", images, undefined, - { consecutiveMistakeLimit: Number.MAX_SAFE_INTEGER, toolRepetitionSoftLimit: 0 }, + { + consecutiveMistakeLimit: Number.MAX_SAFE_INTEGER, + toolRepetitionSoftLimit: 0, + segments: [{ text: "new task", source: "user" }], + }, configuration, ) expect(taskId).toBe(newTab ? "editor-task" : "sidebar-task") diff --git a/src/extension/api.ts b/src/extension/api.ts index 15be22d774..ccb9dce199 100644 --- a/src/extension/api.ts +++ b/src/extension/api.ts @@ -24,9 +24,11 @@ import { IpcMessageType, TASK_START_FAILURE_ERROR_CODE, TASK_START_FAILURE_ERROR_MESSAGE, + type MentionSegment, } from "@roo-code/types" import { IpcServer } from "@roo-code/ipc" +import { userSegments } from "../shared/mentionSegments" import { Package } from "../shared/package" import type { Mode } from "../shared/modes" @@ -250,9 +252,11 @@ export class API extends EventEmitter implements RooCodeAPI { // effectively unlimited. The soft repetition tier is disabled too: // without a reachable hard stop it would reject every identical call // with no escalation. - const options: CreateTaskOptions = { + const options: CreateTaskOptions & { segments?: MentionSegment[] } = { consecutiveMistakeLimit: Number.MAX_SAFE_INTEGER, toolRepetitionSoftLimit: 0, + // The API caller authored the task text. + segments: userSegments(text ?? ""), } const task = await provider.createTask(text, images, undefined, options, configuration) @@ -409,11 +413,17 @@ export class API extends EventEmitter implements RooCodeAPI { return } - await currentTask.submitUserMessage(text ?? "", images) + await currentTask.submitUserMessage(text ?? "", images, undefined, undefined, userSegments(text ?? "")) return } - await this.sidebarProvider.postMessageToWebview({ type: "invoke", invoke: "sendMessage", text, images }) + await this.sidebarProvider.postMessageToWebview({ + type: "invoke", + invoke: "sendMessage", + text, + images, + segments: userSegments(text ?? ""), + }) } public deleteQueuedMessage(messageId: string) { diff --git a/src/shared/__tests__/mentionSegments.spec.ts b/src/shared/__tests__/mentionSegments.spec.ts new file mode 100644 index 0000000000..c23bc87629 --- /dev/null +++ b/src/shared/__tests__/mentionSegments.spec.ts @@ -0,0 +1,137 @@ +import type { MentionSegment } from "@roo-code/types" + +import { + applyEdit, + generatedSegments, + joinSegments, + normalizeSegments, + trimSegments, + userSegments, + userText, +} from "../mentionSegments" + +const user = (text: string): MentionSegment => ({ text, source: "user" }) +const gen = (text: string): MentionSegment => ({ text, source: "generated" }) + +describe("mentionSegments", () => { + describe("normalizeSegments", () => { + it("keeps valid segments that match the text", () => { + expect(normalizeSegments("ab", [gen("a"), user("b")])).toEqual([gen("a"), user("b")]) + }) + + it.each([ + { label: "omitted", segments: undefined }, + { label: "not a list", segments: "user" }, + { label: "bad source", segments: [{ text: "ab", source: "system" }] }, + { label: "text mismatch", segments: [user("abc")] }, + ])("fails closed when segments are $label", ({ segments }) => { + expect(normalizeSegments("ab", segments)).toEqual([gen("ab")]) + }) + + it("returns no segments for empty text", () => { + expect(normalizeSegments("", undefined)).toEqual([]) + }) + }) + + it("joins text and selects only user text", () => { + const segments = [gen("a @/x "), user("b @/y"), gen(" c"), user("d")] + expect(joinSegments(segments)).toBe("a @/x b @/y cd") + expect(userText(segments)).toBe("b @/y\nd") + }) + + it("trims both ends across segments", () => { + expect(trimSegments([gen(" "), user(" a "), gen(" b ")])).toEqual([user("a "), gen(" b")]) + }) + + describe("applyEdit", () => { + it("marks inserted text as user and keeps the rest", () => { + expect(applyEdit([gen("context @/s")], "context @/s", "context @/s mine")).toEqual([ + gen("context @/s"), + user(" mine"), + ]) + }) + + it("marks text inserted in the middle as user and keeps both sides generated", () => { + expect(applyEdit([gen("ab")], "ab", "aXb")).toEqual([gen("a"), user("X"), gen("b")]) + }) + + it("removes deleted text and keeps its neighbors", () => { + expect(applyEdit([user("ab"), gen("cd")], "abcd", "acd")).toEqual([user("a"), gen("cd")]) + }) + + it("marks replaced generated text as user", () => { + expect(applyEdit([gen("abc")], "abc", "aZc")).toEqual([gen("a"), user("Z"), gen("c")]) + }) + + it("keeps all user text user", () => { + expect(applyEdit(userSegments("ab"), "ab", "abc")).toEqual([user("abc")]) + }) + + it("fails closed when the segments do not match the old value", () => { + expect(applyEdit([gen("x")], "ab", "abc")).toEqual(generatedSegments("abc")) + }) + + it.each([ + ["aa", "aaa"], + ["aaa", "aa"], + ["abab", "ab"], + ["ab", "abab"], + ])("keeps the joined text equal to the new value for %s -> %s", (oldValue, newValue) => { + const result = applyEdit([gen(oldValue)], oldValue, newValue) + expect(joinSegments(result)).toBe(newValue) + }) + + it("keeps generated text generated after a repeated edit next to an equal letter", () => { + const once = applyEdit([gen("@/x")], "@/x", "@/x@/x") + const twice = applyEdit(once, "@/x@/x", "x/x@/x") + expect(twice.filter((s) => s.source === "user").map((s) => s.text)).toEqual(["x"]) + }) + + // Mirrors docs/architecture/tla/MentionOrigin.tla: a letter tagged user is a letter the user typed. + it("never tags a generated letter user, for every single edit of up to two steps", () => { + type Cell = { c: string; o: "user" | "generated" } + const letters = ["a", "b"] + const words = (n: number): string[] => + n === 0 + ? [""] + : words(n - 1) + .flatMap((w) => [w, ...letters.map((l) => w + l)]) + .filter((w, i, all) => all.indexOf(w) === i) + const small = words(2) + const edits = (cells: Cell[]) => + Array.from({ length: cells.length + 1 }, (_, i) => i).flatMap((i) => + Array.from({ length: cells.length - i + 1 }, (_, k) => i + k).flatMap((j) => + small.map((r) => [ + ...cells.slice(0, i), + ...Array.from(r, (c): Cell => ({ c, o: "user" })), + ...cells.slice(j), + ]), + ), + ) + const toText = (cells: Cell[]) => cells.map((x) => x.c).join("") + const check = (cells: Cell[], segments: MentionSegment[], depth: number) => { + const sources = segments.flatMap((s) => Array.from(s.text, () => s.source)) + expect(sources).toHaveLength(cells.length) + sources.forEach((source, i) => { + if (source === "user") expect(cells[i]!.o).toBe("user") + }) + if (depth === 0) return + for (const next of edits(cells).filter((c) => c.length <= 5)) { + check(next, applyEdit(segments, toText(cells), toText(next)), depth - 1) + } + } + for (const start of words(3)) { + check( + Array.from(start, (c): Cell => ({ c, o: "generated" })), + generatedSegments(start), + 2, + ) + } + }) + + it("does not authorize a generated mention after an unrelated edit", () => { + const result = applyEdit([gen("see @/secret")], "see @/secret", "see @/secret now") + expect(userText(result)).toBe(" now") + }) + }) +}) diff --git a/src/shared/__tests__/support-prompts.spec.ts b/src/shared/__tests__/support-prompts.spec.ts index ea6a193d5a..2a003eb662 100644 --- a/src/shared/__tests__/support-prompts.spec.ts +++ b/src/shared/__tests__/support-prompts.spec.ts @@ -265,3 +265,27 @@ describe("Code Action Prompts", () => { }) }) }) + +describe("createSegments", () => { + it("marks only the user input as a user segment and matches create()", () => { + const params = { filePath: "a.ts", selectedText: "code @/secret", userInput: "mine @/ok" } + const segments = supportPrompt.createSegments("EXPLAIN", params) + + expect(segments.map((s) => s.text).join("")).toBe(supportPrompt.create("EXPLAIN", params)) + expect(segments.filter((s) => s.source === "user")).toEqual([{ text: "mine @/ok", source: "user" }]) + expect(segments.filter((s) => s.source === "generated").some((s) => s.text.includes("@/secret"))).toBe(true) + }) + + it("has no user segment without user input", () => { + const params = { filePath: "a.ts", selectedText: "code @/secret" } + const segments = supportPrompt.createSegments("EXPLAIN", params) + + expect(segments.some((s) => s.source === "user")).toBe(false) + expect(segments.map((s) => s.text).join("")).toBe(supportPrompt.create("EXPLAIN", params)) + }) + + it("does not treat a parameter that holds user-like text as a user segment", () => { + const segments = supportPrompt.createSegments("EXPLAIN", { selectedText: "@/secret", userInput: "" }) + expect(segments.some((s) => s.source === "user")).toBe(false) + }) +}) diff --git a/src/shared/mentionSegments.ts b/src/shared/mentionSegments.ts new file mode 100644 index 0000000000..3e748ac4da --- /dev/null +++ b/src/shared/mentionSegments.ts @@ -0,0 +1,113 @@ +import { mentionSegmentSchema, type MentionSegment } from "@roo-code/types" + +const segmentsSchema = mentionSegmentSchema.array() + +export const joinSegments = (segments: MentionSegment[]): string => segments.map((s) => s.text).join("") + +/** The text that may have mentions expanded, one user part per line. */ +export const userText = (segments: MentionSegment[]): string => + segments + .filter((s) => s.source === "user") + .map((s) => s.text) + .join("\n") + +export const userSegments = (text: string): MentionSegment[] => (text ? [{ text, source: "user" }] : []) + +export const generatedSegments = (text: string): MentionSegment[] => (text ? [{ text, source: "generated" }] : []) + +/** Drops empty parts and joins neighbors that have the same source. */ +const merge = (segments: MentionSegment[]): MentionSegment[] => { + const result: MentionSegment[] = [] + for (const segment of segments) { + if (!segment.text) continue + const last = result[result.length - 1] + if (last?.source === segment.source) { + last.text += segment.text + } else { + result.push({ ...segment }) + } + } + return result +} + +/** + * Checks segments that arrive from outside. Fails closed: anything that is + * not a valid list whose text matches `text` becomes all generated. + */ +export const normalizeSegments = (text: string, segments: unknown): MentionSegment[] => { + const parsed = segmentsSchema.safeParse(segments) + return parsed.success && joinSegments(parsed.data) === text ? merge(parsed.data) : generatedSegments(text) +} + +export const trimSegments = (segments: MentionSegment[]): MentionSegment[] => { + const result = merge(segments) + while (result.length > 0) { + const first = result[0]! + first.text = first.text.trimStart() + if (first.text) break + result.shift() + } + while (result.length > 0) { + const last = result[result.length - 1]! + last.text = last.text.trimEnd() + if (last.text) break + result.pop() + } + return result +} + +const slice = (segments: MentionSegment[], start: number, end: number): MentionSegment[] => { + const result: MentionSegment[] = [] + let offset = 0 + for (const segment of segments) { + const from = Math.max(start - offset, 0) + const to = Math.min(end - offset, segment.text.length) + if (from < to) result.push({ text: segment.text.slice(from, to), source: segment.source }) + offset += segment.text.length + } + return result +} + +const sourcesOf = (segments: MentionSegment[]): MentionSegment["source"][] => + segments.flatMap((s) => Array.from({ length: s.text.length }, () => s.source)) + +/** + * Records a manual edit. The changed range is the part between the common + * prefix and the common suffix. The new text there is `user`. The rest keeps + * its source. An equal letter next to the edit makes the range ambiguous, so + * the diff runs from both ends and a letter stays `user` only if both agree. + * If the segments do not match `oldValue`, the result is all generated. + */ +export const applyEdit = (segments: MentionSegment[], oldValue: string, newValue: string): MentionSegment[] => { + if (joinSegments(segments) !== oldValue) return generatedSegments(newValue) + + const max = Math.min(oldValue.length, newValue.length) + const prefixOf = (limit: number) => { + let n = 0 + while (n < limit && oldValue[n] === newValue[n]) n++ + return n + } + const suffixOf = (limit: number) => { + let n = 0 + while (n < limit && oldValue[oldValue.length - 1 - n] === newValue[newValue.length - 1 - n]) n++ + return n + } + const retag = (prefix: number, suffix: number) => + sourcesOf([ + ...slice(segments, 0, prefix), + ...userSegments(newValue.slice(prefix, newValue.length - suffix)), + ...slice(segments, oldValue.length - suffix, oldValue.length), + ]) + + const prefixFirst = prefixOf(max) + const a = retag(prefixFirst, suffixOf(max - prefixFirst)) + const suffixFirst = suffixOf(max) + const b = retag(prefixOf(max - suffixFirst), suffixFirst) + + return merge( + Array.from({ length: newValue.length }, (_, i) => ({ + text: newValue[i]!, + source: a[i] === "user" && b[i] === "user" ? "user" : "generated", + })), + ) +} diff --git a/src/shared/support-prompt.ts b/src/shared/support-prompt.ts index 8201705292..f958a53c9d 100644 --- a/src/shared/support-prompt.ts +++ b/src/shared/support-prompt.ts @@ -1,3 +1,5 @@ +import type { MentionSegment } from "@roo-code/types" + // Support prompts type PromptDiagnostic = { source?: string @@ -268,6 +270,26 @@ export const supportPrompt = { const template = supportPrompt.get(customSupportPrompts, type) return createPrompt(template, params) }, + /** + * Builds the prompt as segments. Only the `userInput` parameter is `user`. + * Every other part of the template and its parameters is `generated`. + */ + createSegments: ( + type: SupportPromptType, + params: PromptParams, + customSupportPrompts?: Record, + ): MentionSegment[] => { + const template = supportPrompt.get(customSupportPrompts, type) + const mark = `\u0000${globalThis.crypto.randomUUID()}\u0000` + const userInput = typeof params["userInput"] === "string" ? params["userInput"] : "" + const parts = createPrompt(template, { ...params, userInput: mark }).split(mark) + const segments: MentionSegment[] = [] + parts.forEach((part, index) => { + if (part) segments.push({ text: part, source: "generated" }) + if (index < parts.length - 1 && userInput) segments.push({ text: userInput, source: "user" }) + }) + return segments + }, } as const export type { SupportPromptType } diff --git a/webview-ui/src/components/chat/ChatTextArea.tsx b/webview-ui/src/components/chat/ChatTextArea.tsx index 8ba0df7ab2..8aac0b53af 100644 --- a/webview-ui/src/components/chat/ChatTextArea.tsx +++ b/webview-ui/src/components/chat/ChatTextArea.tsx @@ -3,7 +3,8 @@ import { useEvent } from "react-use" import DynamicTextArea from "react-textarea-autosize" import { VolumeX, Image, WandSparkles, SendHorizontal, X, ListEnd, Square } from "lucide-react" -import type { ExtensionMessage } from "@roo-code/types" +import type { ExtensionMessage, MentionSegment } from "@roo-code/types" +import { generatedSegments } from "@roo/mentionSegments" import { mentionRegex, mentionRegexGlobal, commandRegexGlobal, unescapeSpaces } from "@roo/context-mentions" import { WebviewMessage } from "@roo/WebviewMessage" @@ -59,6 +60,13 @@ const isFileDrag = (dataTransfer: DataTransfer): boolean => interface ChatTextAreaProps { inputValue: string setInputValue: (value: string) => void + /** Programmatic updates preserve the chat box authorization scope. */ + /** Sets generated text, such as an enhanced prompt. Falls back to `setInputValue`. */ + setInputValueGenerated?: (value: string) => void + /** Reads the draft's segments. Null means all user text. */ + getInputSegments?: () => MentionSegment[] | null + /** Sets the value with its segments, for prompt history. */ + setInputValueWithSegments?: (value: string, segments: MentionSegment[] | null) => void sendingDisabled: boolean selectApiConfigDisabled: boolean placeholderText: string @@ -85,6 +93,9 @@ export const ChatTextArea = forwardRef( { inputValue, setInputValue, + setInputValueGenerated, + getInputSegments, + setInputValueWithSegments, selectApiConfigDisabled, placeholderText, selectedImages, @@ -155,6 +166,11 @@ export const ChatTextArea = forwardRef( return () => document.removeEventListener("mousedown", handleClickOutside) }, [showDropdown]) + // Generated text routes through this setter so it is never marked as user text. + const setInputValueProgrammatic = setInputValueGenerated ?? setInputValue + + const programmaticInsertRef = useRef(false) + // Handle enhanced prompt response and search results. useEffect(() => { const messageHandler = (event: MessageEvent) => { @@ -173,12 +189,18 @@ export const ChatTextArea = forwardRef( // Select all text first textarea.select() - document.execCommand("insertText", false, message.text) + programmaticInsertRef.current = true + if (!document.execCommand("insertText", false, message.text)) { + // No input event follows, so the flag would tag the next keystroke generated. + programmaticInsertRef.current = false + setInputValueProgrammatic(message.text) + } } else { - setInputValue(message.text) + setInputValueProgrammatic(message.text) } } catch { - setInputValue(message.text) + programmaticInsertRef.current = false + setInputValueProgrammatic(message.text) } } @@ -202,6 +224,7 @@ export const ChatTextArea = forwardRef( message.text + " " + currentValue.slice(cursorPos) + // The user chose this text, so it is a normal edit. setInputValue(newValue) // Set cursor position after the inserted text @@ -233,7 +256,7 @@ export const ChatTextArea = forwardRef( window.addEventListener("message", messageHandler) return () => window.removeEventListener("message", messageHandler) - }, [setInputValue, searchRequestId, normalizedInputValue]) + }, [setInputValue, setInputValueProgrammatic, searchRequestId, normalizedInputValue]) const [isDraggingOver, setIsDraggingOver] = useState(false) const [textAreaBaseHeight, setTextAreaBaseHeight] = useState(undefined) @@ -258,6 +281,8 @@ export const ChatTextArea = forwardRef( cwd, inputValue: normalizedInputValue, setInputValue, + getSegments: getInputSegments, + setInputValueWithSegments, }) // Fetch git commits when Git is selected or when typing a hash. @@ -278,9 +303,9 @@ export const ChatTextArea = forwardRef( setIsEnhancingPrompt(true) vscode.postMessage({ type: "enhancePrompt" as const, text: trimmedInput }) } else { - setInputValue(t("chat:enhancePromptDescription")) + setInputValueProgrammatic(t("chat:enhancePromptDescription")) } - }, [normalizedInputValue, setInputValue, t]) + }, [normalizedInputValue, setInputValueProgrammatic, t]) const allModes = useMemo(() => getAllModes(customModes), [customModes]) @@ -613,7 +638,16 @@ export const ChatTextArea = forwardRef( const handleInputChange = useCallback( (e: React.ChangeEvent) => { const newValue = e.target.value - setInputValue(newValue) + const inputType = e.nativeEvent instanceof InputEvent ? e.nativeEvent.inputType : "" + if (setInputValueWithSegments && inputType.startsWith("history")) { + // Undo and redo bring back older text with unknown origin. The whole draft is generated. + setInputValueWithSegments(newValue, generatedSegments(newValue)) + } else if (programmaticInsertRef.current) { + programmaticInsertRef.current = false + setInputValueProgrammatic(newValue) + } else { + setInputValue(newValue) + } // Reset history navigation when user types resetOnInputChange() @@ -675,7 +709,15 @@ export const ChatTextArea = forwardRef( setFileSearchResults([]) // Clear file search results. } }, - [setInputValue, setSearchRequestId, setFileSearchResults, setSearchLoading, resetOnInputChange], + [ + setInputValue, + setInputValueProgrammatic, + setInputValueWithSegments, + setSearchRequestId, + setFileSearchResults, + setSearchLoading, + resetOnInputChange, + ], ) useEffect(() => { diff --git a/webview-ui/src/components/chat/ChatView.tsx b/webview-ui/src/components/chat/ChatView.tsx index cf08a220ed..5e586e1d12 100644 --- a/webview-ui/src/components/chat/ChatView.tsx +++ b/webview-ui/src/components/chat/ChatView.tsx @@ -20,10 +20,27 @@ import { getCostBreakdownIfNeeded } from "@src/utils/costFormatting" import { batchNearby } from "@src/utils/batchNearby" import { isBoundary, isIgnorableBetweenTargets } from "@src/utils/chatBatchingPredicates" -import type { ClineAsk, ClineSayTool, ClineMessage, ExtensionMessage, AudioType, SuggestionItem } from "@roo-code/types" +import type { + ClineAsk, + ClineSayTool, + ClineMessage, + ExtensionMessage, + AudioType, + SuggestionItem, + MentionSegment, + ClineAskResponse, +} from "@roo-code/types" import { getCompletionCheckpoint, getSuggestionMode, hasUsableAnswer, isRetiredProvider } from "@roo-code/types" import { findLast } from "@roo/array" +import { + applyEdit, + generatedSegments, + joinSegments, + normalizeSegments, + trimSegments, + userSegments, +} from "@roo/mentionSegments" import { combineApiRequests } from "@roo/combineApiRequests" import { combineCommandSequences } from "@roo/combineCommandSequences" import { getApiMetrics } from "@roo/getApiMetrics" @@ -205,6 +222,13 @@ const ChatViewComponent: React.ForwardRefRenderFunction(null) const userRespondedRef = useRef(false) + // Origin of each part of the chat box value. Null means all of it is user text. + const segmentsRef = useRef(null) + // Trimmed chat box segments for the text. A value that does not match the text is all generated. + const segmentsFor = useCallback((text: string) => { + const trimmed = segmentsRef.current ? trimSegments(segmentsRef.current) : userSegments(text) + return joinSegments(trimmed) === text ? trimmed : generatedSegments(text) + }, []) const [currentFollowUpTs, setCurrentFollowUpTs] = useState(null) const [aggregatedCostsMap, setAggregatedCostsMap] = useState< Map< @@ -632,19 +656,40 @@ const ChatViewComponent: React.ForwardRefRenderFunction { + vscode.postMessage({ ...message, text, images: images ?? [], segments }) + segmentsRef.current = null + setInputValue("") + setSelectedImages([]) + }, + [segmentsFor], + ) + /** * Handles sending messages to the extension * @param text - The message text to send * @param images - Array of image data URLs to send with the message */ const handleSendMessage = useCallback( - (text: string, images: string[]) => { + (text: string, images: string[], segmentsOverride?: MentionSegment[]) => { text = text.trim() + const segments = segmentsOverride ? trimSegments(segmentsOverride) : segmentsFor(text) if (text || images.length > 0) { // Intercept when the active provider is retired — show a @@ -667,9 +712,7 @@ const ChatViewComponent: React.ForwardRefRenderFunction { - // Avoid nested template literals by breaking down the logic - let newValue = text - - if (inputValue !== "") { - newValue = inputValue + " " + text + (text: string, images: string[], inserted?: MentionSegment[]) => { + // Segments that are missing or do not match the text are all generated. + const insertedSegments = normalizeSegments(text, inserted) + if (inputValue === "") { + segmentsRef.current = insertedSegments + setInputValue(text) + } else { + segmentsRef.current = [ + ...(segmentsRef.current ?? userSegments(inputValue)), + ...generatedSegments(" "), + ...insertedSegments, + ] + setInputValue(inputValue + " " + text) } - - setInputValue(newValue) setSelectedImages([...selectedImages, ...images]) }, [inputValue, selectedImages], @@ -748,6 +811,35 @@ const ChatViewComponent: React.ForwardRefRenderFunction string)) => { + const previous = inputValueRef.current + const next = typeof value === "function" ? value(previous) : value + if (segmentsRef.current) { + segmentsRef.current = applyEdit(segmentsRef.current, previous, next) + } + inputValueRef.current = next + setInputValue(next) + }, + [setInputValue], + ) + + // Generated text replaces the whole value and authorizes nothing. + const setInputValueGenerated = useCallback((value: string) => { + segmentsRef.current = generatedSegments(value) + inputValueRef.current = value + setInputValue(value) + }, []) + + // Prompt history restores a draft together with its segments. + const getInputSegments = useCallback(() => segmentsRef.current, []) + const setInputValueWithSegments = useCallback((value: string, segments: MentionSegment[] | null) => { + segmentsRef.current = segments + inputValueRef.current = value + setInputValue(value) + }, []) + // Handle stop button click from textarea const handleStopTask = useCallback(() => { vscode.postMessage({ type: "cancelTask" }) @@ -758,15 +850,9 @@ const ChatViewComponent: React.ForwardRefRenderFunction { const text = inputValue.trim() if (text || selectedImages.length > 0) { - vscode.postMessage({ - type: "queueMessage", - text, - images: selectedImages, - }) - setInputValue("") - setSelectedImages([]) + postDraft({ type: "queueMessage" }, text, selectedImages) } - }, [inputValue, selectedImages]) + }, [inputValue, selectedImages, postDraft]) // Resets the approval button UI to its hidden/disabled state. Shared by the // manual click handlers and by the backend-driven clearApprovalButtons @@ -798,15 +884,7 @@ const ChatViewComponent: React.ForwardRefRenderFunction 0)) { - vscode.postMessage({ - type: "askResponse", - askResponse: "yesButtonClicked", - text: trimmedInput, - images: images, - }) - // Clear input state after sending - setInputValue("") - setSelectedImages([]) + postDraft({ type: "askResponse", askResponse: "yesButtonClicked" }, trimmedInput ?? "", images) } else { vscode.postMessage({ type: "askResponse", askResponse: "yesButtonClicked" }) } @@ -824,15 +902,11 @@ const ChatViewComponent: React.ForwardRefRenderFunction 0)) { - vscode.postMessage({ - type: "askResponse", - askResponse: "yesButtonClicked", - text: trimmedInput, - images: images, - }) - // Clear input state after sending - setInputValue("") - setSelectedImages([]) + postDraft( + { type: "askResponse", askResponse: "yesButtonClicked" }, + trimmedInput ?? "", + images, + ) } else { vscode.postMessage({ type: "askResponse", askResponse: "yesButtonClicked" }) } @@ -852,7 +926,7 @@ const ChatViewComponent: React.ForwardRefRenderFunction 0)) { - vscode.postMessage({ - type: "askResponse", - askResponse: "noButtonClicked", - text: trimmedInput, - images: images, - }) - // Clear input state after sending - setInputValue("") - setSelectedImages([]) + postDraft({ type: "askResponse", askResponse: "noButtonClicked" }, trimmedInput ?? "", images) } else { // Responds to the API with a "This operation failed" and lets it try again vscode.postMessage({ type: "askResponse", askResponse: "noButtonClicked" }) @@ -899,7 +965,7 @@ const ChatViewComponent: React.ForwardRefRenderFunction { - return currentValue !== "" ? `${currentValue} \n${answer}` : answer - }) + // Always append to existing text, don't overwrite. + // The suggestion is model text, so it stays generated. + const currentValue = inputValueRef.current + const separator = currentValue !== "" ? " \n" : "" + segmentsRef.current = [ + ...(segmentsRef.current ?? userSegments(currentValue)), + ...generatedSegments(separator + answer), + ] + inputValueRef.current = currentValue + separator + answer + setInputValue(inputValueRef.current) } else { // Don't clear the input value when sending a follow-up choice // The message should be sent but the text area should preserve what the user typed const preservedInput = inputValueRef.current - handleSendMessage(answer, []) - // Restore the input value after sending + const preservedSegments = segmentsRef.current + // A suggestion is model text, so it is generated. + handleSendMessage(answer, [], generatedSegments(answer)) + // Restore the input value and its segments after sending setInputValue(preservedInput) + segmentsRef.current = preservedSegments } }, [handleSendMessage, setInputValue, switchToMode, alwaysAllowModeSwitch, clineAsk, markFollowUpAsAnswered], @@ -1629,9 +1708,8 @@ const ChatViewComponent: React.ForwardRefRenderFunction { + onUpdate={(index, newText, segments) => { if (messageQueue[index]) { vscode.postMessage({ type: "editQueuedMessage", - payload: { id: messageQueue[index].id, text: newText, images: messageQueue[index].images }, + payload: { + id: messageQueue[index].id, + text: newText, + images: messageQueue[index].images, + segments, + }, }) } }} @@ -1875,7 +1958,11 @@ const ChatViewComponent: React.ForwardRefRenderFunction void - onUpdate: (index: number, newText: string) => void + onUpdate: (index: number, newText: string, segments: MentionSegment[]) => void } +type EditState = { isEditing: boolean; value: string; segments: MentionSegment[] } + export const QueuedMessages = ({ queue, onRemove, onUpdate }: QueuedMessagesProps) => { const { t } = useAppTranslation() - const [editingStates, setEditingStates] = useState>({}) + const [editingStates, setEditingStates] = useState>({}) if (queue.length === 0) { return null } - const getEditState = (messageId: string, currentText: string) => { - return editingStates[messageId] || { isEditing: false, value: currentText } + const getEditState = (message: QueuedMessage): EditState => + editingStates[message.id] || { + isEditing: false, + value: message.text, + segments: normalizeSegments(message.text, message.segments), + } + + const setEditState = (message: QueuedMessage, isEditing: boolean, value: string, segments: MentionSegment[]) => { + setEditingStates((prev) => ({ ...prev, [message.id]: { isEditing, value, segments } })) } - const setEditState = (messageId: string, isEditing: boolean, value?: string) => { - setEditingStates((prev) => ({ - ...prev, - [messageId]: { isEditing, value: value ?? prev[messageId]?.value ?? "" }, - })) + // Tag each input event here. The saved text alone cannot show which parts the user typed. + const handleChange = (message: QueuedMessage, previous: EditState, e: React.ChangeEvent) => { + const value = e.target.value + const inputType = e.nativeEvent instanceof InputEvent ? e.nativeEvent.inputType : "" + // Undo and redo bring back older text with unknown origin. The whole text is generated. + const segments = inputType.startsWith("history") + ? generatedSegments(value) + : applyEdit(previous.segments, previous.value, value) + setEditState(message, true, value, segments) } - const handleSaveEdit = (index: number, messageId: string, newValue: string) => { - onUpdate(index, newValue) - setEditState(messageId, false) + const handleSaveEdit = (index: number, message: QueuedMessage, state: EditState) => { + onUpdate(index, state.value, state.segments) + setEditState(message, false, state.value, state.segments) } return ( @@ -44,7 +58,7 @@ export const QueuedMessages = ({ queue, onRemove, onUpdate }: QueuedMessagesProp
{t("chat:queuedMessages.title")}
{queue.map((message, index) => { - const editState = getEditState(message.id, message.text) + const editState = getEditState(message) return (
setEditState(message.id, true, e.target.value)} - onBlur={() => handleSaveEdit(index, message.id, editState.value)} + onChange={(e) => handleChange(message, editState, e)} + onBlur={() => handleSaveEdit(index, message, editState)} onKeyDown={(e) => { if (e.key === "Enter" && !e.shiftKey) { e.preventDefault() - handleSaveEdit(index, message.id, editState.value) + handleSaveEdit(index, message, editState) } if (e.key === "Escape") { - setEditState(message.id, false, message.text) + setEditState( + message, + false, + message.text, + normalizeSegments(message.text, message.segments), + ) } }} className="w-full bg-vscode-input-background text-vscode-input-foreground border border-vscode-input-border rounded px-2 py-1 resize-none focus:outline-0 focus:ring-1 focus:ring-vscode-focusBorder" @@ -82,7 +101,14 @@ export const QueuedMessages = ({ queue, onRemove, onUpdate }: QueuedMessagesProp /> ) : (
setEditState(message.id, true, message.text)} + onClick={() => + setEditState( + message, + true, + message.text, + normalizeSegments(message.text, message.segments), + ) + } className="cursor-pointer hover:bg-vscode-list-hoverBackground px-1 py-0.5 -mx-1 -my-0.5 rounded transition-colors" title={t("chat:queuedMessages.clickToEdit")}> diff --git a/webview-ui/src/components/chat/__tests__/ChatTextArea.spec.tsx b/webview-ui/src/components/chat/__tests__/ChatTextArea.spec.tsx index 7cacd4034b..f74b41a770 100644 --- a/webview-ui/src/components/chat/__tests__/ChatTextArea.spec.tsx +++ b/webview-ui/src/components/chat/__tests__/ChatTextArea.spec.tsx @@ -282,6 +282,68 @@ describe("ChatTextArea", () => { expect(setInputValue).toHaveBeenCalledWith("Enhanced test prompt") }) + it("routes the enhanced prompt through the generated-text setter when provided", () => { + const setInputValue = vi.fn() + const setInputValueGenerated = vi.fn() + Object.defineProperty(document, "execCommand", { value: undefined, writable: true }) + + render( + , + ) + + window.dispatchEvent( + new MessageEvent("message", { data: { type: "enhancedPrompt", text: "Enhanced test prompt" } }), + ) + + expect(setInputValueGenerated).toHaveBeenCalledWith("Enhanced test prompt") + expect(setInputValue).not.toHaveBeenCalled() + }) + + it("routes the native enhanced-prompt input event through the generated-text setter, then manual edits through setInputValue", () => { + const setInputValue = vi.fn() + const setInputValueGenerated = vi.fn() + // Mimic the browser: execCommand fires an input event on the textarea. + const target: { el?: HTMLTextAreaElement } = {} + Object.defineProperty(document, "execCommand", { + value: vi.fn((_cmd: string, _ui: boolean, value: string) => { + if (target.el) { + fireEvent.input(target.el, { target: { value } }) + } + return true + }), + writable: true, + }) + + const { container } = render( + , + ) + const textarea = container.querySelector("textarea")! + target.el = textarea + + act(() => { + window.dispatchEvent( + new MessageEvent("message", { data: { type: "enhancedPrompt", text: "Enhanced test prompt" } }), + ) + }) + + expect(setInputValueGenerated).toHaveBeenCalledWith("Enhanced test prompt") + expect(setInputValue).not.toHaveBeenCalled() + + fireEvent.change(textarea, { target: { value: "typed by hand" } }) + + expect(setInputValue).toHaveBeenCalledWith("typed by hand") + }) + it("should not crash when textarea ref is not available", () => { const setInputValue = vi.fn() @@ -624,6 +686,59 @@ describe("ChatTextArea", () => { expect(setInputValue).toHaveBeenCalledWith("Third prompt") }) + it("restores the draft with its segments after history navigation", () => { + const draft = [{ text: "ctx @/a", source: "generated" as const }] + const setInputValueWithSegments = vi.fn() + const { container } = render( + draft} + setInputValueWithSegments={setInputValueWithSegments} + />, + ) + const textarea = container.querySelector("textarea")! + textarea.setSelectionRange(0, 0) + + fireEvent.keyDown(textarea, { key: "ArrowUp" }) + expect(setInputValueWithSegments).toHaveBeenLastCalledWith("Third prompt", [ + { text: "Third prompt", source: "generated" }, + ]) + + fireEvent.keyDown(textarea, { key: "ArrowDown" }) + expect(setInputValueWithSegments).toHaveBeenLastCalledWith("ctx @/a", draft) + }) + + it.each([ + { inputType: "historyUndo", generated: true }, + { inputType: "historyRedo", generated: true }, + { inputType: "insertText", generated: false }, + ])("marks the draft generated only for $inputType: $generated", ({ inputType, generated }) => { + const setInputValue = vi.fn() + const setInputValueWithSegments = vi.fn() + const { container } = render( + , + ) + const textarea = container.querySelector("textarea")! + + fireEvent.input(textarea, { target: { value: "ctx @/secret" }, inputType }) + + if (generated) { + expect(setInputValueWithSegments).toHaveBeenCalledWith("ctx @/secret", [ + { text: "ctx @/secret", source: "generated" }, + ]) + expect(setInputValue).not.toHaveBeenCalled() + } else { + expect(setInputValue).toHaveBeenCalledWith("ctx @/secret") + expect(setInputValueWithSegments).not.toHaveBeenCalled() + } + }) + it("should navigate through history with multiple arrow up presses", () => { const setInputValue = vi.fn() const { container } = render( diff --git a/webview-ui/src/components/chat/__tests__/ChatView.add-to-context-authorization.spec.tsx b/webview-ui/src/components/chat/__tests__/ChatView.add-to-context-authorization.spec.tsx new file mode 100644 index 0000000000..163eeba235 --- /dev/null +++ b/webview-ui/src/components/chat/__tests__/ChatView.add-to-context-authorization.spec.tsx @@ -0,0 +1,322 @@ +// npx vitest run src/components/chat/__tests__/ChatView.add-to-context-authorization.spec.tsx + +import React from "react" +import { describe, it, expect, vi, beforeEach } from "vitest" +import { renderWithExtensionState, waitFor, act, fireEvent } from "@/utils/test-utils" + +import ChatView, { ChatViewProps, ChatViewRef } from "../ChatView" + +// Mock vscode API +const { mockPostMessage } = vi.hoisted(() => ({ mockPostMessage: vi.fn() })) +vi.mock("@src/utils/vscode", () => ({ + vscode: { + postMessage: mockPostMessage, + }, +})) + +vi.mock("use-sound", () => ({ + default: vi.fn(() => [vi.fn()]), +})) + +vi.mock("../ChatRow", () => ({ + default: () => null, +})) + +vi.mock("../TaskHeader", () => ({ + default: () => null, +})) + +vi.mock("../AutoApproveMenu", () => ({ + default: () => null, +})) + +vi.mock("react-virtuoso", () => ({ + Virtuoso: () =>
, +})) + +vi.mock("../../common/VersionIndicator", () => ({ + default: () => null, +})) + +vi.mock("../Announcement", () => ({ + default: () => null, +})) + +vi.mock("../QueuedMessages", () => ({ + QueuedMessages: () => null, +})) + +vi.mock("@src/components/welcome/RooTips", () => ({ + default: () => null, +})) + +vi.mock("@src/components/welcome/RooHero", () => ({ + default: () => null, +})) + +vi.mock("../common/TelemetryBanner", () => ({ + default: () => null, +})) + +vi.mock("react-i18next", () => ({ + useTranslation: () => ({ t: (key: string) => key }), + initReactI18next: { type: "3rdParty", init: () => {} }, + Trans: ({ children }: { children?: React.ReactNode }) => <>{children}, +})) + +// Narrow subset of the real ChatTextArea props the double consumes. +interface MockChatTextAreaProps { + onSend: () => void + inputValue?: string + setInputValue?: (value: string) => void + setInputValueGenerated?: (value: string) => void +} + +// ChatTextArea double: an input whose Enter triggers onSend and whose +// changes flow through the provided setInputValue. Programmatic updates +// mirror the real component and keep the authorization scope. +vi.mock("../ChatTextArea", async () => { + const React = await import("react") + + const ChatTextAreaComponent = React.forwardRef(function MockChatTextArea( + props: MockChatTextAreaProps, + _ref: unknown, + ) { + React.useEffect(() => { + const listener = (event: MessageEvent) => { + if (event.data?.type === "enhancedPrompt" && typeof event.data.text === "string") { + const update = props.setInputValueGenerated ?? props.setInputValue + update?.(event.data.text) + } + } + window.addEventListener("message", listener) + return () => window.removeEventListener("message", listener) + }, [props]) + + return ( +
+ ) => props.setInputValue?.(e.target.value)} + onKeyDown={(e: React.KeyboardEvent) => { + if (e.key === "Enter" && !e.shiftKey) { + e.preventDefault() + props.onSend() + } + }} + /> +
+ ) + }) + + return { default: ChatTextAreaComponent, ChatTextArea: ChatTextAreaComponent } +}) + +vi.mock("@vscode/webview-ui-toolkit/react", () => ({ + VSCodeButton: ({ children, onClick }: { children: React.ReactNode; onClick?: () => void }) => ( + + ), + VSCodeCheckbox: ({ + children, + checked, + onChange, + }: { + children?: React.ReactNode + checked?: boolean + onChange?: (event: React.ChangeEvent) => void + }) => ( + + ), + VSCodeTextField: ({ + value, + onInput, + placeholder, + }: { + value?: string + onInput?: (e: { target: { value: string } }) => void + placeholder?: string + }) => ( + onInput?.({ target: { value: e.target.value } })} + placeholder={placeholder} + /> + ), + VSCodeLink: ({ children, href }: { children: React.ReactNode; href?: string }) => {children}, + VSCodeTag: ({ children }: { children: React.ReactNode }) => {children}, +})) + +const defaultProps: ChatViewProps = { + isHidden: false, + showAnnouncement: false, + hideAnnouncement: () => {}, +} + +const renderChatView = () => renderWithExtensionState() + +const sendNewTask = async (getByTestId: (id: string) => HTMLElement) => { + await act(async () => { + fireEvent.keyDown(getByTestId("chat-textarea").querySelector("input")!, { key: "Enter" }) + }) + await waitFor(() => expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "newTask" }))) + return mockPostMessage.mock.calls.find(([m]) => m.type === "newTask")?.[0] +} + +const addGeneratedContext = async (payload: Record) => { + await act(async () => { + window.postMessage( + { type: "invoke", invoke: "setChatBoxMessage", text: "context with @/secret code", ...payload }, + "*", + ) + }) + await waitFor(() => { + expect(getChatBoxValue()).toBe("context with @/secret code") + }) +} + +const getChatBoxValue = () => { + const input = document.querySelector('[data-testid="chat-textarea"] input') as HTMLInputElement | null + return input?.value ?? "" +} + +const generated = (text: string) => ({ text, source: "generated" as const }) +const user = (text: string) => ({ text, source: "user" as const }) + +describe("ChatView - add-to-context mention segments", () => { + beforeEach(() => { + vi.clearAllMocks() + }) + + it("sends all generated segments when add-to-context carries no user input", async () => { + const { getByTestId } = renderChatView() + + await addGeneratedContext({ segments: [generated("context with @/secret code")] }) + const message = await sendNewTask(getByTestId) + + expect(message).toMatchObject({ + text: "context with @/secret code", + segments: [generated("context with @/secret code")], + }) + }) + + it("keeps the user segment the extension named", async () => { + const { getByTestId } = renderChatView() + + await addGeneratedContext({ segments: [generated("context with @/secret "), user("code")] }) + const message = await sendNewTask(getByTestId) + + expect(message).toMatchObject({ segments: [generated("context with @/secret "), user("code")] }) + }) + + it("treats text as generated when the sender omits segments", async () => { + const { getByTestId } = renderChatView() + + await addGeneratedContext({}) + const message = await sendNewTask(getByTestId) + + expect(message).toMatchObject({ segments: [generated("context with @/secret code")] }) + }) + + it("treats text as generated when the segments do not match it", async () => { + const { getByTestId } = renderChatView() + + await addGeneratedContext({ segments: [user("something else")] }) + const message = await sendNewTask(getByTestId) + + expect(message).toMatchObject({ segments: [generated("context with @/secret code")] }) + }) + + it("marks only the typed text as user text after a manual edit", async () => { + const { getByTestId } = renderChatView() + + await addGeneratedContext({ segments: [generated("context with @/secret code")] }) + + const input = getByTestId("chat-textarea").querySelector("input")! + await act(async () => { + fireEvent.change(input, { target: { value: "context with @/secret code and @/ok" } }) + }) + + const message = await sendNewTask(getByTestId) + expect(message).toMatchObject({ + segments: [generated("context with @/secret code"), user(" and @/ok")], + }) + }) + + it("keeps all text user text when nothing generated was added", async () => { + const { getByTestId } = renderChatView() + + const input = getByTestId("chat-textarea").querySelector("input")! + await act(async () => { + fireEvent.change(input, { target: { value: "my own task with @/ok" } }) + }) + + const message = await sendNewTask(getByTestId) + expect(message).toMatchObject({ segments: [user("my own task with @/ok")] }) + }) + + it("appends inserted segments after typed text", async () => { + const { getByTestId } = renderChatView() + + const input = getByTestId("chat-textarea").querySelector("input")! + await act(async () => { + fireEvent.change(input, { target: { value: "mine" } }) + }) + await act(async () => { + window.postMessage( + { + type: "invoke", + invoke: "setChatBoxMessage", + text: "ctx @/secret", + segments: [generated("ctx @/secret")], + }, + "*", + ) + }) + await waitFor(() => { + expect(getChatBoxValue()).toBe("mine ctx @/secret") + }) + + const message = await sendNewTask(getByTestId) + expect(message).toMatchObject({ segments: [user("mine"), generated(" ctx @/secret")] }) + }) + + it("makes an enhanced prompt all generated, even over a typed draft", async () => { + const { getByTestId } = renderChatView() + + const input = getByTestId("chat-textarea").querySelector("input")! + await act(async () => { + fireEvent.change(input, { target: { value: "my draft" } }) + }) + await act(async () => { + window.postMessage({ type: "enhancedPrompt", text: "enhanced with @/secret" }, "*") + }) + await waitFor(() => { + expect(getChatBoxValue()).toBe("enhanced with @/secret") + }) + + const message = await sendNewTask(getByTestId) + expect(message).toMatchObject({ + text: "enhanced with @/secret", + segments: [generated("enhanced with @/secret")], + }) + }) + + it("sends generated segments when the imperative acceptInput submits", async () => { + const ref = React.createRef() + renderWithExtensionState() + + await addGeneratedContext({ segments: [generated("context with @/secret code")] }) + await act(async () => { + ref.current!.acceptInput() + }) + await waitFor(() => expect(mockPostMessage).toHaveBeenCalledWith(expect.objectContaining({ type: "newTask" }))) + + const message = mockPostMessage.mock.calls.find(([m]) => m.type === "newTask")?.[0] + expect(message).toMatchObject({ segments: [generated("context with @/secret code")] }) + }) +}) diff --git a/webview-ui/src/components/chat/__tests__/ChatView.clear-approval-buttons.spec.tsx b/webview-ui/src/components/chat/__tests__/ChatView.clear-approval-buttons.spec.tsx index 03a2da93de..c2048b0194 100644 --- a/webview-ui/src/components/chat/__tests__/ChatView.clear-approval-buttons.spec.tsx +++ b/webview-ui/src/components/chat/__tests__/ChatView.clear-approval-buttons.spec.tsx @@ -1,11 +1,11 @@ // pnpm --filter @roo-code/vscode-webview test src/components/chat/__tests__/ChatView.clear-approval-buttons.spec.tsx import React from "react" -import { renderWithExtensionState, waitFor, act, fireEvent } from "@/utils/test-utils" +import { renderWithExtensionState, waitFor, act, fireEvent, screen } from "@/utils/test-utils" import { vscode } from "@src/utils/vscode" -import ChatView, { ChatViewProps } from "../ChatView" +import ChatView, { ChatViewProps, ChatViewRef } from "../ChatView" interface ClineMessage { type: "say" | "ask" @@ -106,6 +106,7 @@ vi.mock("react-i18next", () => ({ const RUN_BUTTON_LABEL = "chat:runCommand.title" const DENY_BUTTON_LABEL = "chat:reject.title" +const RESUME_BUTTON_LABEL = "chat:resumeTask.title" const START_NEW_TASK_BUTTON_LABEL = "chat:startNewTask.title" const SEE_NEW_CHANGES_BUTTON_LABEL = "chat:seeNewChanges.title" const RESTORE_CHANGES_BUTTON_LABEL = "chat:restoreChanges.title" @@ -138,11 +139,13 @@ const defaultProps: ChatViewProps = { const renderChatView = (props: Partial = {}) => renderWithExtensionState() -const commandAsk = (): ClineMessage[] => [ +const askMessages = (ask: string): ClineMessage[] => [ { type: "say", say: "task", ts: 1, text: "Initial task" }, - { type: "ask", ask: "command", ts: 2, text: "echo hi", partial: false }, + { type: "ask", ask, ts: 2, text: "echo hi", partial: false }, ] +const commandAsk = (): ClineMessage[] => askMessages("command") + const autoApprovedCommandAsk = (): ClineMessage[] => [ { type: "say", say: "task", ts: 1, text: "Initial task" }, { type: "ask", ask: "command", ts: 2, text: "echo hi", partial: false, isAnswered: true }, @@ -181,6 +184,61 @@ const askOnlyCompletionWithCheckpoint = (): ClineMessage[] => [ describe("ChatView approval button behavior", () => { beforeEach(() => vi.clearAllMocks()) + describe("queued message segments", () => { + const streaming = (): ClineMessage[] => [ + { type: "say", say: "task", ts: 1, text: "Initial task" }, + { type: "say", say: "text", ts: 2, text: "working", partial: true }, + ] + const fills = [ + { + label: "generated", + fill: () => + window.postMessage({ type: "invoke", invoke: "setChatBoxMessage", text: "ctx @/secret" }, "*"), + value: "ctx @/secret", + source: "generated", + }, + { + label: "typed", + fill: () => fireEvent.input(screen.getByRole("textbox"), { target: { value: "use @/ok" } }), + value: "use @/ok", + source: "user", + }, + ] as const + const queued = () => vi.mocked(vscode.postMessage).mock.calls.find(([m]) => m.type === "queueMessage")?.[0] + + it.each(fills)("the enqueue button sends $label text with its source", async ({ fill, value, source }) => { + renderChatView() + await act(async () => hydrateState(streaming())) + await act(async () => { + fill() + }) + await waitFor(() => expect(screen.getByRole("textbox")).toHaveValue(value)) + await act(async () => { + fireEvent.click(await screen.findByRole("button", { name: "chat:enqueueMessage" })) + }) + + expect(queued()).toMatchObject({ text: value, segments: [{ text: value, source }] }) + }) + + it.each(fills)( + "acceptInput during command_output sends $label text with its source", + async ({ fill, value, source }) => { + const ref = React.createRef() + renderWithExtensionState() + await act(async () => hydrateState(askMessages("command_output"))) + await act(async () => { + fill() + }) + await waitFor(() => expect(screen.getByRole("textbox")).toHaveValue(value)) + await act(async () => { + ref.current!.acceptInput() + }) + + expect(queued()).toMatchObject({ text: value, segments: [{ text: value, source }] }) + }, + ) + }) + it("shows Run/Deny buttons for a command ask that requires manual approval", async () => { const { queryByText } = renderChatView() @@ -194,6 +252,109 @@ describe("ChatView approval button behavior", () => { }) }) + describe("approval feedback segments", () => { + const typed = async (input: HTMLElement) => { + fireEvent.input(input, { target: { value: "use @/ok" } }) + } + // The extension fills the box with text that has no user segments. + const generated = async () => { + window.postMessage({ type: "invoke", invoke: "setChatBoxMessage", text: "ctx @/secret" }, "*") + } + + it.each([ + { ask: "command", button: RUN_BUTTON_LABEL, askResponse: "yesButtonClicked" }, + { ask: "command", button: DENY_BUTTON_LABEL, askResponse: "noButtonClicked" }, + { ask: "resume_task", button: RESUME_BUTTON_LABEL, askResponse: "yesButtonClicked" }, + ])("sends user segments for typed text with $ask $askResponse", async ({ ask, button, askResponse }) => { + const { getByText, getByRole } = renderChatView() + + await act(async () => { + hydrateState(askMessages(ask)) + }) + await waitFor(() => expect(getByText(button)).toBeInTheDocument()) + + await act(async () => { + await typed(getByRole("textbox")) + }) + await act(async () => { + fireEvent.click(getByText(button)) + }) + + expect(vscode.postMessage).toHaveBeenCalledWith( + expect.objectContaining({ + type: "askResponse", + askResponse, + text: "use @/ok", + segments: [{ text: "use @/ok", source: "user" }], + }), + ) + }) + + it.each([ + { ask: "command", button: RUN_BUTTON_LABEL, askResponse: "yesButtonClicked" }, + { ask: "command", button: DENY_BUTTON_LABEL, askResponse: "noButtonClicked" }, + { ask: "resume_task", button: RESUME_BUTTON_LABEL, askResponse: "yesButtonClicked" }, + ])("keeps generated text generated with $ask $askResponse", async ({ ask, button, askResponse }) => { + const { getByText, getByRole } = renderChatView() + + await act(async () => { + hydrateState(askMessages(ask)) + }) + await waitFor(() => expect(getByText(button)).toBeInTheDocument()) + + await act(async () => { + await generated() + }) + await waitFor(() => expect(getByRole("textbox")).toHaveValue("ctx @/secret")) + await act(async () => { + fireEvent.click(getByText(button)) + }) + + expect(vscode.postMessage).toHaveBeenCalledWith( + expect.objectContaining({ + type: "askResponse", + askResponse, + text: "ctx @/secret", + segments: [{ text: "ctx @/secret", source: "generated" }], + }), + ) + }) + + it("keeps generated text generated after the user deletes it and undoes", async () => { + const { getByText, getByRole } = renderChatView() + + await act(async () => { + hydrateState(askMessages("command")) + }) + await waitFor(() => expect(getByText(RUN_BUTTON_LABEL)).toBeInTheDocument()) + + await act(async () => { + await generated() + }) + await waitFor(() => expect(getByRole("textbox")).toHaveValue("ctx @/secret")) + await act(async () => { + fireEvent.input(getByRole("textbox"), { target: { value: "" }, inputType: "deleteContentBackward" }) + }) + await act(async () => { + fireEvent.input(getByRole("textbox"), { + target: { value: "ctx @/secret" }, + inputType: "historyUndo", + }) + }) + await act(async () => { + fireEvent.click(getByText(RUN_BUTTON_LABEL)) + }) + + expect(vscode.postMessage).toHaveBeenCalledWith( + expect.objectContaining({ + type: "askResponse", + text: "ctx @/secret", + segments: [{ text: "ctx @/secret", source: "generated" }], + }), + ) + }) + }) + it("never shows Run/Deny buttons when the command ask is already answered (auto-approved)", async () => { const { queryByText } = renderChatView() diff --git a/webview-ui/src/components/chat/__tests__/ChatView.spec.tsx b/webview-ui/src/components/chat/__tests__/ChatView.spec.tsx index 165b33bca4..8cff48c539 100644 --- a/webview-ui/src/components/chat/__tests__/ChatView.spec.tsx +++ b/webview-ui/src/components/chat/__tests__/ChatView.spec.tsx @@ -1242,6 +1242,7 @@ describe("ChatView - Message Queueing Tests", () => { type: "queueMessage", text: "follow-up question during spinner", images: [], + segments: [{ text: "follow-up question during spinner", source: "user" }], }) }) @@ -1313,6 +1314,7 @@ describe("ChatView - Message Queueing Tests", () => { askResponse: "messageResponse", text: "follow-up after completion", images: [], + segments: [{ text: "follow-up after completion", source: "user" }], }) }) @@ -1372,6 +1374,7 @@ describe("ChatView - Message Queueing Tests", () => { type: "queueMessage", text: "message during queue drain", images: [], + segments: [{ text: "message during queue drain", source: "user" }], }) }) @@ -1435,6 +1438,7 @@ describe("ChatView - Message Queueing Tests", () => { type: "queueMessage", text: "message during command execution", images: [], + segments: [{ text: "message during command execution", source: "user" }], }) }) @@ -1555,6 +1559,52 @@ describe("ChatView - Follow-up Suggestions", () => { askResponse: "messageResponse", text: "Use code mode", images: [], + segments: [{ text: "Use code mode", source: "generated" }], + }) + }) + + it("keeps a shift-clicked suggestion generated and the typed draft user text", async () => { + const { getByRole, getByTestId } = renderChatView() + + mockPostMessage({ + mode: "ask", + customModes: [], + clineMessages: [ + { type: "say", say: "task", ts: Date.now() - 1000, text: "Initial task" }, + { + type: "ask", + ask: "followup", + ts: Date.now(), + text: JSON.stringify({ question: "Next?", suggest: [{ answer: "Use @/secret" }] }), + partial: false, + }, + ], + }) + + const suggestion = await waitFor(() => getByRole("button", { name: "Use @/secret" })) + const input = getByTestId("chat-textarea").querySelector("input")! as HTMLInputElement + await act(async () => { + fireEvent.change(input, { target: { value: "mine" } }) + }) + vscodePostMessageMock.cleanup() + + await act(async () => { + fireEvent.click(suggestion, { shiftKey: true }) + }) + await act(async () => { + fireEvent.keyDown(input, { key: "Enter", code: "Enter" }) + }) + + await waitFor(() => { + expect(vscode.postMessage).toHaveBeenCalledWith( + expect.objectContaining({ + type: "askResponse", + segments: [ + { text: "mine", source: "user" }, + { text: " \nUse @/secret", source: "generated" }, + ], + }), + ) }) }) @@ -1595,6 +1645,7 @@ describe("ChatView - Follow-up Suggestions", () => { askResponse: "messageResponse", text: "Use invalid mode", images: [], + segments: [{ text: "Use invalid mode", source: "generated" }], }) }) expect(vscode.postMessage).not.toHaveBeenCalledWith(expect.objectContaining({ type: "mode" })) @@ -1655,6 +1706,7 @@ describe("ChatView - Follow-up Suggestions", () => { askResponse: "messageResponse", text: "Valid answer", images: [], + segments: [{ text: "Valid answer", source: "generated" }], }) }) }) diff --git a/webview-ui/src/components/chat/__tests__/QueuedMessages.spec.tsx b/webview-ui/src/components/chat/__tests__/QueuedMessages.spec.tsx new file mode 100644 index 0000000000..2259b2726d --- /dev/null +++ b/webview-ui/src/components/chat/__tests__/QueuedMessages.spec.tsx @@ -0,0 +1,85 @@ +// npx vitest run src/components/chat/__tests__/QueuedMessages.spec.tsx + +import { describe, it, expect, vi } from "vitest" +import { render, screen, fireEvent } from "@testing-library/react" +import type { MentionSegment, QueuedMessage } from "@roo-code/types" + +import { QueuedMessages } from "../QueuedMessages" + +vi.mock("@src/i18n/TranslationContext", () => ({ useAppTranslation: () => ({ t: (key: string) => key }) })) +vi.mock("../Mention", () => ({ Mention: ({ text }: { text: string }) => {text} })) +vi.mock("../../common/Thumbnails", () => ({ default: () => null })) + +const user = (text: string): MentionSegment => ({ text, source: "user" }) +const gen = (text: string): MentionSegment => ({ text, source: "generated" }) + +// Mirrors docs/architecture/tla/MentionOrigin.tla, QueueSave: the editor tags each input event. +describe("QueuedMessages editing", () => { + const edit = (message: QueuedMessage, steps: Array) => { + const onUpdate = vi.fn() + render() + fireEvent.click(screen.getByTitle("chat:queuedMessages.clickToEdit")) + const textarea = screen.getByRole("textbox") as HTMLTextAreaElement + for (const step of steps) { + const { value, inputType } = typeof step === "string" ? { value: step, inputType: "" } : step + if (inputType) { + // Set the value like the browser does, then send the typed input event. + const setter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, "value")!.set! + setter.call(textarea, value) + textarea.dispatchEvent(new InputEvent("input", { inputType, bubbles: true })) + } else { + fireEvent.change(textarea, { target: { value } }) + } + } + fireEvent.blur(textarea) + return onUpdate + } + + const queued = (text: string, segments?: MentionSegment[]): QueuedMessage => ({ + id: "q1", + timestamp: 1, + text, + segments, + }) + + it.each([ + { + label: "two edits that trim both ends of generated text", + message: queued("X @/etc/passwd Y", [gen("X @/etc/passwd Y")]), + steps: ["X @/etc/passwd ", " @/etc/passwd ", "@/etc/passwd "], + text: "@/etc/passwd ", + segments: [gen("@/etc/passwd ")], + }, + { + label: "two insertions around one generated letter", + message: queued("a", [gen("a")]), + steps: ["aa", "aaa"], + text: "aaa", + segments: [gen("aaa")], + }, + { + label: "an appended typed word", + message: queued("ctx @/x", [gen("ctx @/x")]), + steps: ["ctx @/x m", "ctx @/x mine"], + text: "ctx @/x mine", + segments: [gen("ctx @/x"), user(" mine")], + }, + { + label: "a message with no segments", + message: queued("old @/x"), + steps: ["old @/x!"], + text: "old @/x!", + segments: [gen("old @/x"), user("!")], + }, + { + label: "an undo", + message: queued("ctx", [user("ctx")]), + steps: ["ctx m", { value: "ctx", inputType: "historyUndo" }], + text: "ctx", + segments: [gen("ctx")], + }, + ])("sends the right segments after $label", ({ message, steps, text, segments }) => { + const onUpdate = edit(message, steps) + expect(onUpdate).toHaveBeenCalledWith(0, text, segments) + }) +}) diff --git a/webview-ui/src/components/chat/hooks/usePromptHistory.ts b/webview-ui/src/components/chat/hooks/usePromptHistory.ts index 402538182a..576edd788a 100644 --- a/webview-ui/src/components/chat/hooks/usePromptHistory.ts +++ b/webview-ui/src/components/chat/hooks/usePromptHistory.ts @@ -1,5 +1,6 @@ -import { ClineMessage, HistoryItem } from "@roo-code/types" -import { useCallback, useEffect, useMemo, useState } from "react" +import { ClineMessage, HistoryItem, MentionSegment } from "@roo-code/types" +import { generatedSegments } from "@roo/mentionSegments" +import { useCallback, useEffect, useMemo, useRef, useState } from "react" interface UsePromptHistoryProps { clineMessages: ClineMessage[] | undefined @@ -7,6 +8,10 @@ interface UsePromptHistoryProps { cwd: string | undefined inputValue: string setInputValue: (value: string) => void + /** Reads the draft's segments. Null means all user text. */ + getSegments?: () => MentionSegment[] | null + /** Sets the value with its segments. Falls back to `setInputValue`. */ + setInputValueWithSegments?: (value: string, segments: MentionSegment[] | null) => void } export interface UsePromptHistoryReturn { @@ -30,6 +35,8 @@ export const usePromptHistory = ({ cwd, inputValue, setInputValue, + getSegments, + setInputValueWithSegments, }: UsePromptHistoryProps): UsePromptHistoryReturn => { // Maximum number of prompts to keep in history for memory management const MAX_PROMPT_HISTORY_SIZE = 100 @@ -37,6 +44,8 @@ export const usePromptHistory = ({ // Prompt history navigation state const [historyIndex, setHistoryIndex] = useState(-1) const [tempInput, setTempInput] = useState("") + // Segments of the draft that history navigation replaced. + const tempSegmentsRef = useRef(null) const [promptHistory, setPromptHistory] = useState([]) // Initialize prompt history with hybrid approach: conversation messages if in task, otherwise task history @@ -111,22 +120,31 @@ export const usePromptHistory = ({ if (!historicalPrompt) return false setHistoryIndex(newIndex) - setInputValue(historicalPrompt) + // Stored prompts carry no segments, so they authorize nothing. + if (setInputValueWithSegments) { + setInputValueWithSegments(historicalPrompt, generatedSegments(historicalPrompt)) + } else { + setInputValue(historicalPrompt) + } setCursorPosition(textarea, cursorPos, historicalPrompt.length) return true }, - [promptHistory, setInputValue, setCursorPosition], + [promptHistory, setInputValue, setInputValueWithSegments, setCursorPosition], ) // Helper to return to current input const returnToCurrentInput = useCallback( (textarea: HTMLTextAreaElement, cursorPos: "start" | "end" = "end") => { setHistoryIndex(-1) - setInputValue(tempInput) + if (setInputValueWithSegments) { + setInputValueWithSegments(tempInput, tempSegmentsRef.current) + } else { + setInputValue(tempInput) + } setCursorPosition(textarea, cursorPos, tempInput.length) }, - [tempInput, setInputValue, setCursorPosition], + [tempInput, setInputValue, setInputValueWithSegments, setCursorPosition], ) const handleHistoryNavigation = useCallback( @@ -147,6 +165,7 @@ export const usePromptHistory = ({ // Save current input if starting navigation if (historyIndex === -1) { setTempInput(inputValue) + tempSegmentsRef.current = getSegments?.() ?? null } return navigateToHistory(historyIndex + 1, textarea, "start") } @@ -167,7 +186,7 @@ export const usePromptHistory = ({ } return false }, - [promptHistory, historyIndex, inputValue, navigateToHistory, returnToCurrentInput], + [promptHistory, historyIndex, inputValue, getSegments, navigateToHistory, returnToCurrentInput], ) const resetHistoryNavigation = useCallback(() => {