π OpenHands: AI-Driven Development
fix(streaming): dedupe streamed reasoning against the action that renders it (#1896)
Vasco Schiavoa22bceb0d5d8
diff --git a/__tests__/components/conversation-events/chat/duplicate-streamed-message.test.tsx b/__tests__/components/conversation-events/chat/duplicate-streamed-message.test.tsxindex 36f3506662..1737983786 100644--- a/__tests__/components/conversation-events/chat/duplicate-streamed-message.test.tsx+++ b/__tests__/components/conversation-events/chat/duplicate-streamed-message.test.tsx@@ -217,3 +217,69 @@ describe("issue #1534 β streamed intermediate message duplication", () => {expect(countOccurrences(container.textContent ?? "", THOUGHT)).toBe(1);});});++// A model that streams its reasoning but whose action `thought` does not repeat+// that text used to render the delta's reasoning and the action's own reasoning+// as two identical "Thinking" bubbles.+describe("duplicate Thinking blocks", () => {+ const REASONING =+ "Let me read the full PRD to understand all the requirements. " ++ "I need to see sections that were clipped.";++ const reasoningOnlyDelta: StreamingDeltaEvent = {+ id: "delta-reasoning-only",+ kind: "StreamingDeltaEvent",+ timestamp: "2026-06-12T12:00:01Z",+ source: "agent",+ content: null,+ reasoning_content: REASONING,+ };++ const reasoningAction: ActionEvent = {+ ...action,+ thought: [],+ reasoning_content: REASONING,+ };++ it("renders the reasoning in a single Thinking section", () => {+ const allEvents = [+ userMessage,+ reasoningOnlyDelta,+ reasoningAction,+ observation,+ ];+ const uiEvents = reduce(allEvents);++ const { container } = renderWithProviders(+ <Messages messages={uiEvents} allEvents={allEvents} />,+ );++ expect(screen.getAllByTestId("collapsible-thinking")).toHaveLength(1);++ fireEvent.click(screen.getByTestId("collapsible-thinking-toggle"));+ expect(+ screen.getByTestId("collapsible-thinking-content"),+ ).toHaveTextContent(REASONING);+ expect(countOccurrences(container.textContent ?? "", REASONING)).toBe(1);+ });++ it("keeps the streamed reasoning when the action carries none", () => {+ const plainAction: ActionEvent = { ...action, thought: [] };+ const allEvents = [+ userMessage,+ reasoningOnlyDelta,+ plainAction,+ observation,+ ];+ const uiEvents = reduce(allEvents);++ renderWithProviders(<Messages messages={uiEvents} allEvents={allEvents} />);++ // The delta is the sole reasoning carrier, so its Thinking must survive.+ expect(screen.getAllByTestId("collapsible-thinking")).toHaveLength(1);+ fireEvent.click(screen.getByTestId("collapsible-thinking-toggle"));+ expect(+ screen.getByTestId("collapsible-thinking-content"),+ ).toHaveTextContent(REASONING);+ });+});diff --git a/__tests__/utils/handle-event-for-ui.test.ts b/__tests__/utils/handle-event-for-ui.test.tsindex 80298aeb28..1d598d599e 100644--- a/__tests__/utils/handle-event-for-ui.test.ts+++ b/__tests__/utils/handle-event-for-ui.test.ts@@ -850,4 +850,140 @@ describe("handleEventForUI", () => {expect(result).toEqual([mockMessageEvent, action]);});});++ describe("intermediate action / streamed reasoning reconciliation", () => {+ const REASONING = "Let me read the full PRD to understand all of it.";++ const makeReasoningAction = (thought: string[]): ActionEvent => ({+ ...mockActionEvent,+ id: "intermediate-1",+ tool_call_id: "call_intermediate_1",+ thought: thought.map((text) => ({ type: "text", text })),+ reasoning_content: REASONING,+ });++ it("drops a reasoning-only delta when the action has no thought", () => {+ const delta: StreamingDeltaEvent = {+ ...makeStreamingDelta("delta-1", null),+ reasoning_content: REASONING,+ };+ const action = makeReasoningAction([]);++ const result = handleEventForUI(action, [mockMessageEvent, delta]);++ expect(result).toEqual([mockMessageEvent, action]);+ });++ it("drops a reasoning-only delta when the thought does not match it", () => {+ const delta: StreamingDeltaEvent = {+ ...makeStreamingDelta("delta-1", null),+ reasoning_content: REASONING,+ };+ const action = makeReasoningAction(["Reading the PRD now."]);++ const result = handleEventForUI(action, [mockMessageEvent, delta]);++ expect(result).toEqual([mockMessageEvent, action]);+ });++ it("keeps unmatched streamed text while clearing the duplicated reasoning", () => {+ const delta: StreamingDeltaEvent = {+ ...makeStreamingDelta("delta-1", "some unrelated streamed text"),+ reasoning_content: REASONING,+ };+ const action = makeReasoningAction(["An unrelated thought."]);++ const result = handleEventForUI(action, [mockMessageEvent, delta]);++ expect(result).toEqual([+ mockMessageEvent,+ { ...delta, reasoning_content: null },+ action,+ ]);+ });++ it("leaves the delta untouched when the action carries no reasoning", () => {+ const delta: StreamingDeltaEvent = {+ ...makeStreamingDelta("delta-1", null),+ reasoning_content: REASONING,+ };+ const action: ActionEvent = {+ ...mockActionEvent,+ id: "intermediate-1",+ tool_call_id: "call_intermediate_1",+ thought: [],+ };++ const result = handleEventForUI(action, [mockMessageEvent, delta]);++ // The delta is the sole reasoning carrier, so it must survive.+ expect(result).toEqual([mockMessageEvent, delta, action]);+ });++ it("only reconciles the current step's trailing delta run", () => {+ const earlierDelta: StreamingDeltaEvent = {+ ...makeStreamingDelta("delta-earlier", null),+ reasoning_content: "an earlier step's reasoning",+ };+ const delta: StreamingDeltaEvent = {+ ...makeStreamingDelta("delta-1", null),+ reasoning_content: REASONING,+ };+ const action = makeReasoningAction([]);++ const result = handleEventForUI(action, [+ mockMessageEvent,+ earlierDelta,+ mockObservationEvent,+ delta,+ ]);++ expect(result).toEqual([+ mockMessageEvent,+ earlierDelta,+ mockObservationEvent,+ action,+ ]);+ });++ it("preserves a still-live planning-agent delta (#1656)", () => {+ // Main and planning sockets share this event store. A main-agent action+ // supersedes only the main agent's streamed reasoning; the planning+ // agent's live reasoning must survive.+ const planningDelta = {+ ...makeStreamingDelta("delta-planning", null),+ reasoning_content: "Planning agent is still reasoning",+ isFromPlanningAgent: true,+ };+ const mainDelta: StreamingDeltaEvent = {+ ...makeStreamingDelta("delta-main", null),+ reasoning_content: REASONING,+ };+ const action = makeReasoningAction([]);++ const result = handleEventForUI(action, [+ mockMessageEvent,+ planningDelta,+ mainDelta,+ ]);++ expect(result).toEqual([mockMessageEvent, planningDelta, action]);+ });++ it("leaves the planning agent's reasoning alone when only it streamed (#1656)", () => {+ const planningDelta = {+ ...makeStreamingDelta("delta-planning", null),+ reasoning_content: "Planning agent is still reasoning",+ isFromPlanningAgent: true,+ };+ const action = makeReasoningAction([]);++ const result = handleEventForUI(action, [+ mockMessageEvent,+ planningDelta,+ ]);++ expect(result).toEqual([mockMessageEvent, planningDelta, action]);+ });+ });});diff --git a/src/utils/handle-event-for-ui.ts b/src/utils/handle-event-for-ui.tsindex 2da846047a..dcdcc6fabc 100644--- a/src/utils/handle-event-for-ui.ts+++ b/src/utils/handle-event-for-ui.ts@@ -100,8 +100,9 @@ const getCurrentTurnContentDeltas = (// The current step's streaming delta(s): the trailing run at the end of// `uiEvents`. Earlier steps' deltas are separated by their observations, so// this never folds an earlier step's delta into the current one.-const getTrailingContentDeltas = (+const getTrailingDeltas = (uiEvents: OpenHandsEvent[],+ selects: (event: StreamingDeltaEvent) => boolean,): { event: StreamingDeltaEvent; index: number }[] => {const deltas: { event: StreamingDeltaEvent; index: number }[] = [];for (let index = uiEvents.length - 1; index >= 0; index -= 1) {@@ -109,13 +110,29 @@ const getTrailingContentDeltas = (if (!isStreamingDeltaEvent(event)) {break;}- if ((event.content?.length ?? 0) > 0) {+ if (selects(event)) {deltas.unshift({ event, index });}}return deltas;};+const getTrailingContentDeltas = (uiEvents: OpenHandsEvent[]) =>+ getTrailingDeltas(uiEvents, (event) => (event.content?.length ?? 0) > 0);++// Sender-scoped: the main and planning sockets share this event store, so a+// main-agent action must not strip the planning agent's live reasoning (#1656).+const getTrailingReasoningDeltas = (+ uiEvents: OpenHandsEvent[],+ finalEvent: OpenHandsEvent,+) =>+ getTrailingDeltas(+ uiEvents,+ (event) =>+ Boolean(event.reasoning_content) &&+ isSameStreamingSender(finalEvent, event),+ );+// Strip the streamed content deltas, keeping a delta only when it carries// reasoning the replacement itself won't render (many models stream reasoning// solely through the delta). Shared by the finalize and intermediate-action@@ -262,6 +279,39 @@ const supersedeStreamedThoughtWithAction = ();};+// Drop the current step's streamed reasoning when the action renders that+// reasoning itself, so "Thinking" renders once. Unlike+// `supersedeStreamedThoughtWithAction` this does not require the streamed text+// to match the thought, which models streaming reasoning-only deltas never do.+const supersedeStreamedReasoningWithAction = (+ action: ActionEvent,+ uiEvents: OpenHandsEvent[],+): OpenHandsEvent[] | null => {+ if (getReasoningContent(action).trim().length === 0) {+ return null;+ }++ const reasoningDeltas = getTrailingReasoningDeltas(uiEvents, action);+ if (reasoningDeltas.length === 0) {+ return null;+ }++ const indexesToStrip = new Set(reasoningDeltas.map(({ index }) => index));+ const nextUiEvents: OpenHandsEvent[] = [];+ uiEvents.forEach((event, index) => {+ if (!indexesToStrip.has(index) || !isStreamingDeltaEvent(event)) {+ nextUiEvents.push(event);+ return;+ }++ // Keep the delta only for streamed text the action itself lacks.+ if (event.content) {+ nextUiEvents.push({ ...event, reasoning_content: null });+ }+ });+ return nextUiEvents;+};+/*** Handles adding an event to the UI events array* Replaces actions with observations when they arrive (so UI shows observation instead of action)@@ -321,10 +371,9 @@ export const handleEventForUI = (event.action.kind !== "FinishAction" &&event.action.kind !== "ThinkAction") {- const reconciledUiEvents = supersedeStreamedThoughtWithAction(- event,- newUiEvents,- );+ const reconciledUiEvents =+ supersedeStreamedThoughtWithAction(event, newUiEvents) ??+ supersedeStreamedReasoningWithAction(event, newUiEvents);if (reconciledUiEvents) {reconciledUiEvents.push(event);return reconciledUiEvents;