Skip to content

πŸ™Œ 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.tsx
index 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.ts
index 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.ts
index 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;