π OpenHands: AI-Driven Development
fix(streaming): render final event authoritatively and dedupe reconnect side-effects (#1865)
Vasco Schiavobbbcc856fb5b
diff --git a/__tests__/components/conversation-events/chat/duplicate-streamed-message.test.tsx b/__tests__/components/conversation-events/chat/duplicate-streamed-message.test.tsxindex b6ae6f522a..36f3506662 100644--- a/__tests__/components/conversation-events/chat/duplicate-streamed-message.test.tsx+++ b/__tests__/components/conversation-events/chat/duplicate-streamed-message.test.tsx@@ -155,7 +155,7 @@ describe("issue #1534 β streamed intermediate message duplication", () => {expect(countOccurrences(container.textContent ?? "", THOUGHT)).toBe(1);});- it("still renders a final agent message exactly once (unchanged)", () => {+ it("renders the canonical final message and its metadata exactly once", () => {const finalMessage: MessageEvent = {id: "agent-msg-1",timestamp: "2026-06-12T12:00:02Z",@@ -166,10 +166,50 @@ describe("issue #1534 β streamed intermediate message duplication", () => {},activated_microagents: [],extended_content: [],+ critic_result: {+ score: 0.72,+ message: null,+ metadata: null,+ },};const allEvents = [userMessage, streamingDelta, finalMessage];const uiEvents = reduce(allEvents);+ expect(uiEvents.at(-1)).toBe(finalMessage);++ const { container } = renderWithProviders(+ <Messages messages={uiEvents} allEvents={allEvents} />,+ );++ expect(countOccurrences(container.textContent ?? "", THOUGHT)).toBe(1);+ expect(screen.getByLabelText("Score: 72.0%")).toBeInTheDocument();+ fireEvent.click(screen.getByTestId("collapsible-thinking-toggle"));+ expect(+ screen.getByTestId("collapsible-thinking-content"),+ ).toHaveTextContent("Considering the request before acting.");+ });++ it("renders once when streamed text has leading whitespace", () => {+ const leadingWhitespaceDelta: StreamingDeltaEvent = {+ ...streamingDelta,+ content: `\n${THOUGHT}`,+ };+ const finalMessage: MessageEvent = {+ id: "agent-msg-leading-whitespace",+ timestamp: "2026-06-12T12:00:02Z",+ source: "agent",+ llm_message: {+ role: "assistant",+ content: [{ type: "text", text: THOUGHT }],+ },+ activated_microagents: [],+ extended_content: [],+ };+ const allEvents = [userMessage, leadingWhitespaceDelta, finalMessage];+ const uiEvents = reduce(allEvents);++ expect(uiEvents.at(-1)).toBe(finalMessage);+const { container } = renderWithProviders(<Messages messages={uiEvents} allEvents={allEvents} />,);diff --git a/__tests__/contexts/conversation-websocket-context.test.tsx b/__tests__/contexts/conversation-websocket-context.test.tsxindex 72210000bc..1dcc4502fb 100644--- a/__tests__/contexts/conversation-websocket-context.test.tsx+++ b/__tests__/contexts/conversation-websocket-context.test.tsx@@ -6,6 +6,8 @@ import { ConversationWebSocketProvider } from "#/contexts/conversation-websocketimport { useEventStore } from "#/stores/use-event-store";import { useOptimisticUserMessageStore } from "#/stores/optimistic-user-message-store";import { useBrowserStore } from "#/stores/browser-store";+import { useCommandStore } from "#/stores/command-store";+import { useErrorMessageStore } from "#/stores/error-message-store";import { useUserConversation } from "#/hooks/query/use-user-conversation";import EventService from "#/api/event-service/event-service.api";import {@@ -87,6 +89,8 @@ describe("ConversationWebSocketProvider β conversation-scoped event store", ()});useOptimisticUserMessageStore.setState({ pendingMessages: [] });useBrowserStore.getState().reset();+ useCommandStore.setState({ commands: [] });+ useErrorMessageStore.getState().removeErrorMessage();vi.mocked(useUserConversation).mockReturnValue({data: { conversation_url: "http://localhost/api", session_api_key: null },@@ -191,6 +195,134 @@ describe("ConversationWebSocketProvider β conversation-scoped event store", ()]);});+ // On reconnect the backlog is replayed; non-idempotent side-effects must not+ // fire again for events already processed (#1656).+ describe("reconnect replay does not re-run non-idempotent side-effects", () => {+ const makeBashAction = (id: string, command: string) => ({+ id,+ timestamp: new Date().toISOString(),+ source: "agent",+ thought: [],+ thinking_blocks: [],+ action: {+ kind: "ExecuteBashAction",+ command,+ is_input: false,+ timeout: null,+ reset: false,+ },+ tool_name: "execute_bash",+ tool_call_id: `call-${id}`,+ tool_call: {+ id: `call-${id}`,+ type: "function",+ function: {+ name: "execute_bash",+ arguments: JSON.stringify({ command }),+ },+ },+ llm_response_id: `resp-${id}`,+ security_risk: "UNKNOWN",+ });++ const makeBashObservation = (+ id: string,+ actionId: string,+ text: string,+ ) => ({+ id,+ timestamp: new Date().toISOString(),+ source: "environment",+ action_id: actionId,+ tool_name: "execute_bash",+ tool_call_id: `call-${actionId}`,+ observation: {+ kind: "ExecuteBashObservation",+ content: [{ type: "text", text }],+ command: "run",+ exit_code: 0,+ error: false,+ timeout: false,+ metadata: {+ exit_code: 0,+ pid: 1,+ username: "u",+ hostname: "h",+ working_dir: "/",+ py_interpreter_path: null,+ prefix: "",+ suffix: "",+ },+ },+ });++ const makeConversationError = (id: string, detail: string) => ({+ id,+ timestamp: new Date().toISOString(),+ source: "environment",+ kind: "ConversationErrorEvent",+ detail,+ code: "SomeError",+ });++ const renderCaptured = async () => {+ render(+ <QueryClientProvider client={queryClient}>+ <ConversationWebSocketProvider+ conversationId="conv-reconnect"+ conversationUrl="http://localhost/api"+ >+ <div />+ </ConversationWebSocketProvider>+ </QueryClientProvider>,+ );+ await waitFor(() => expect(wsCapture.mainOnMessage).not.toBeNull());+ };++ const deliver = (event: unknown) =>+ act(() => {+ wsCapture.mainOnMessage!({ data: JSON.stringify(event) });+ });++ it("does not re-append terminal input/output for replayed bash events", async () => {+ await renderCaptured();++ const action = makeBashAction("bash-action-1", "echo hi");+ const observation = makeBashObservation(+ "bash-obs-1",+ "bash-action-1",+ "hi\n",+ );++ // First delivery, then a reconnect replay of the same two events.+ deliver(action);+ deliver(observation);+ deliver(action);+ deliver(observation);++ expect(useCommandStore.getState().commands).toEqual([+ { content: "echo hi", type: "input" },+ { content: "hi\n", type: "output" },+ ]);+ });++ it("does not re-raise a dismissed error banner when the error event is replayed", async () => {+ await renderCaptured();++ const errorEvent = makeConversationError("conv-error-1", "Boom");++ // Show the banner, dismiss it, then replay the error on reconnect.+ deliver(errorEvent);+ expect(useErrorMessageStore.getState().errorMessage).toBe("Boom");+ act(() => useErrorMessageStore.getState().removeErrorMessage());+ expect(useErrorMessageStore.getState().errorMessage).toBeNull();++ // It must stay dismissed.+ deliver(errorEvent);+ expect(useErrorMessageStore.getState().errorMessage).toBeNull();+ });+ });+it("clears the previous conversation's events when switching conversations", async () => {// Arrange + Act: open conversation A.const { rerender } = renderProvider("conv-a");diff --git a/__tests__/stores/use-event-store.test.ts b/__tests__/stores/use-event-store.test.tsindex 1e8d36cb1f..69dc6fd18a 100644--- a/__tests__/stores/use-event-store.test.ts+++ b/__tests__/stores/use-event-store.test.ts@@ -200,6 +200,23 @@ describe("useEventStore", () => {expect(result.current.eventIds.has("delta-2")).toBe(true);});+ it("should not compact streaming deltas from different senders (#1656)", () => {+ const { result } = renderHook(() => useEventStore());+ const mainDelta = makeStreamingDeltaEvent("delta-1", "main ");+ const planningDelta = {+ ...makeStreamingDeltaEvent("delta-2", "planning"),+ isFromPlanningAgent: true,+ };++ // A planning-agent delta after a main-agent delta must not concatenate.+ act(() => {+ result.current.addEvent(mainDelta);+ result.current.addEvent(planningDelta);+ });++ expect(result.current.events).toEqual([mainDelta, planningDelta]);+ });+it("should apply action-to-observation UI replacement during bulk add", () => {const { result } = renderHook(() => useEventStore());diff --git a/__tests__/utils/handle-event-for-ui.test.ts b/__tests__/utils/handle-event-for-ui.test.tsindex 30948afa0d..80298aeb28 100644--- a/__tests__/utils/handle-event-for-ui.test.ts+++ b/__tests__/utils/handle-event-for-ui.test.ts@@ -310,7 +310,7 @@ describe("handleEventForUI", () => {]);});- it("finalizes streamed deltas in place when finish arrives", () => {+ it("keeps the canonical finish event after streamed content", () => {const first = makeStreamingDelta("delta-1", "I'll start ");const second = makeStreamingDelta("delta-2", "working on that.");const streamedDelta = handleEventForUI(@@ -321,16 +321,11 @@ describe("handleEventForUI", () => {const result = handleEventForUI(mockFinishActionEvent, uiEvents);- expect(result).toEqual([- mockMessageEvent,- {- ...streamedDelta,- content: "I'll start working on that. Done.",- },- ]);+ expect(result).toEqual([mockMessageEvent, mockFinishActionEvent]);+ expect(result.at(-1)).toBe(mockFinishActionEvent);});- it("finalizes streamed deltas in place when an agent message arrives", () => {+ it("keeps the canonical agent message after streamed content", () => {const first = makeStreamingDelta("delta-1", "I'll start ");const second = makeStreamingDelta("delta-2", "working on that.");const streamedDelta = handleEventForUI(@@ -341,16 +336,11 @@ describe("handleEventForUI", () => {const result = handleEventForUI(mockAgentMessageEvent, uiEvents);- expect(result).toEqual([- mockMessageEvent,- {- ...streamedDelta,- content: "I'll start working on that. Done.",- },- ]);+ expect(result).toEqual([mockMessageEvent, mockAgentMessageEvent]);+ expect(result.at(-1)).toBe(mockAgentMessageEvent);});- it("keeps streamed deltas in their original locations when the final message aggregates them", () => {+ it("replaces aggregated streamed content with the canonical final message", () => {const first = makeStreamingDelta("delta-1","I'll start working on that.",@@ -379,13 +369,12 @@ describe("handleEventForUI", () => {expect(result).toEqual([mockMessageEvent,- first,mockObservationEvent,- second,+ aggregateAgentMessage,]);});- it("appends unstreamed suffix to the last content-bearing delta", () => {+ it("uses canonical final content while retaining reasoning-only deltas", () => {const contentDelta = makeStreamingDelta("delta-content","I'll start working on that.",@@ -420,16 +409,28 @@ describe("handleEventForUI", () => {expect(result).toEqual([mockMessageEvent,- {- ...contentDelta,- content: "I'll start working on that. Done.",- },mockObservationEvent,reasoningDelta,+ finalMessage,]);});- it("appends a distinct final message that does not match streamed text", () => {+ it("keeps the canonical final message after leading streamed whitespace", () => {+ const streamedDelta = makeStreamingDelta(+ "delta-1",+ "\nI'll start working on that. Done.",+ );++ const result = handleEventForUI(mockAgentMessageEvent, [+ mockMessageEvent,+ streamedDelta,+ ]);++ expect(result).toEqual([mockMessageEvent, mockAgentMessageEvent]);+ expect(result.at(-1)).toBe(mockAgentMessageEvent);+ });++ it("replaces unmatched streamed text with the canonical final message", () => {const streamedDelta = makeStreamingDelta("delta-1","I'll start working on that.",@@ -447,7 +448,58 @@ describe("handleEventForUI", () => {streamedDelta,]);- expect(result).toEqual([mockMessageEvent, streamedDelta, finalMessage]);+ expect(result).toEqual([mockMessageEvent, finalMessage]);+ });++ it("preserves streamed reasoning when the final message replaces unmatched text", () => {+ const streamedDelta: StreamingDeltaEvent = {+ ...makeStreamingDelta("delta-1", "Stale partial text"),+ reasoning_content: "Reasoning available only in the stream",+ };+ const finalMessage: MessageEvent = {+ ...mockAgentMessageEvent,+ llm_message: {+ role: "assistant",+ content: [{ type: "text", text: "Canonical final text" }],+ },+ };++ const result = handleEventForUI(finalMessage, [+ mockMessageEvent,+ streamedDelta,+ ]);++ expect(result).toEqual([+ mockMessageEvent,+ { ...streamedDelta, content: null },+ finalMessage,+ ]);+ });++ it("drops streamed reasoning when the final message renders it inline", () => {+ const streamedDelta: StreamingDeltaEvent = {+ ...makeStreamingDelta("delta-1", "Canonical final text"),+ reasoning_content: "Reasoning rendered by the final message",+ };+ const finalMessage: MessageEvent = {+ ...mockAgentMessageEvent,+ llm_message: {+ role: "assistant",+ content: [+ {+ type: "text",+ text: "<think>Reasoning rendered by the final message</think>Canonical final text",+ },+ ],+ },+ };++ const result = handleEventForUI(finalMessage, [+ mockMessageEvent,+ streamedDelta,+ ]);++ expect(result).toEqual([mockMessageEvent, finalMessage]);});it("keeps deltas from older turns when a later turn finishes", () => {@@ -480,7 +532,6 @@ describe("handleEventForUI", () => {oldUserMessage,oldDelta,nextUserMessage,- currentDelta,mockFinishActionEvent,]);});@@ -507,6 +558,93 @@ describe("handleEventForUI", () => {mockAgentMessageEvent,]);});++ it("does not merge deltas from different senders into one bubble (#1656)", () => {+ // A planning-agent delta must not concatenate onto a main-agent delta;+ // they stay separate bubbles.+ const mainDelta = makeStreamingDelta("delta-main", "Main agent says ");+ const planningDelta = {+ ...makeStreamingDelta("delta-planning", "planning agent says"),+ isFromPlanningAgent: true,+ };++ const result = handleEventForUI(planningDelta, [+ mockMessageEvent,+ mainDelta,+ ]);++ expect(result).toEqual([mockMessageEvent, mainDelta, planningDelta]);+ });++ it("still merges consecutive deltas from the same sender", () => {+ const first = {+ ...makeStreamingDelta("delta-1", "planning "),+ isFromPlanningAgent: true,+ };+ const second = {+ ...makeStreamingDelta("delta-2", "continues"),+ isFromPlanningAgent: true,+ };++ const result = handleEventForUI(second, [mockMessageEvent, first]);++ expect(result).toEqual([+ mockMessageEvent,+ { ...first, content: "planning continues", reasoning_content: null },+ ]);+ });++ it("planning final preserves a still-live main-agent delta (#1656)", () => {+ // Main and planning sockets share this event store. A planning-agent+ // final must supersede only the planning stream; the main agent's live+ // delta must survive.+ const mainDelta = makeStreamingDelta("delta-main", "Main still typing");+ const planningDelta = {+ ...makeStreamingDelta("delta-planning", "Planning says hello"),+ isFromPlanningAgent: true,+ };+ const planningFinal = {+ ...mockAgentMessageEvent,+ id: "planning-final",+ isFromPlanningAgent: true,+ llm_message: {+ role: "assistant" as const,+ content: [{ type: "text" as const, text: "Planning says hello" }],+ },+ };++ const result = handleEventForUI(planningFinal, [+ mockMessageEvent,+ mainDelta,+ planningDelta,+ ]);++ expect(result).toEqual([mockMessageEvent, mainDelta, planningFinal]);+ });++ it("main final preserves a still-live planning-agent delta (#1656)", () => {+ const mainDelta = makeStreamingDelta("delta-main", "Main says hello");+ const planningDelta = {+ ...makeStreamingDelta("delta-planning", "Planning still typing"),+ isFromPlanningAgent: true,+ };+ const mainFinal = {+ ...mockAgentMessageEvent,+ id: "main-final",+ llm_message: {+ role: "assistant" as const,+ content: [{ type: "text" as const, text: "Main says hello" }],+ },+ };++ const result = handleEventForUI(mainFinal, [+ mockMessageEvent,+ mainDelta,+ planningDelta,+ ]);++ expect(result).toEqual([mockMessageEvent, planningDelta, mainFinal]);+ });});it("should NOT add ThinkObservation even when ThinkAction is not found", () => {diff --git a/src/contexts/conversation-websocket-context.tsx b/src/contexts/conversation-websocket-context.tsxindex dae60aaceb..483867eb00 100644--- a/src/contexts/conversation-websocket-context.tsx+++ b/src/contexts/conversation-websocket-context.tsx@@ -477,14 +477,19 @@ export function ConversationWebSocketProvider({// Use type guard to validate v1 event structureif (isAgentServerEvent(event)) {+ // A reconnect replays the backlog from a stale anchor. The store+ // dedups by id, but the side-effects below aren't idempotent, so skip+ // them for replayed events (#1656).const isDuplicateEvent = useEventStore.getState().eventIds.has(event.id);- const switchLLMObservation =- !isDuplicateEvent && isSwitchLLMObservationEvent(event)- ? event- : null;+ const switchLLMObservation = isSwitchLLMObservationEvent(event)+ ? event+ : null;addEvent(event);+ if (isDuplicateEvent) {+ return;+ }// Handle displayable error events - show error banner// AgentErrorEvent errors are displayed inline in the chat, not as banners@@ -678,12 +683,20 @@ export function ConversationWebSocketProvider({// Use type guard to validate v1 event structureif (isAgentServerEvent(event)) {+ // Skip non-idempotent side-effects for replayed events, as in the+ // main handler (#1656).+ const isDuplicateEvent = useEventStore+ .getState()+ .eventIds.has(event.id);// Mark this event as coming from the planning agentconst eventWithPlanningFlag = {...event,isFromPlanningAgent: true,};addEvent(eventWithPlanningFlag);+ if (isDuplicateEvent) {+ return;+ }// Handle displayable error events - show error banner// AgentErrorEvent errors are displayed inline in the chat, not as bannersdiff --git a/src/stores/use-event-store.ts b/src/stores/use-event-store.tsindex 7c89e51893..ca4132d173 100644--- a/src/stores/use-event-store.ts+++ b/src/stores/use-event-store.ts@@ -2,6 +2,7 @@ import { create } from "zustand";import { OpenHandsEvent } from "#/types/agent-server/core";import {handleEventForUI,+ isSameStreamingSender,mergeStreamingDeltaEvent,} from "#/utils/handle-event-for-ui";import { isStreamingDeltaEvent } from "#/types/agent-server/type-guards";@@ -105,7 +106,8 @@ const appendEvent = (state: EventState, event: OHEvent): EventState => {const shouldMergeStreamingDelta =lastEvent &&isStreamingDeltaEvent(event) &&- isStreamingDeltaEvent(lastEvent);+ isStreamingDeltaEvent(lastEvent) &&+ isSameStreamingSender(event, lastEvent);const events = [...state.events];if (shouldMergeStreamingDelta) {events[lastEventIndex] = mergeStreamingDeltaEvent(event, lastEvent);@@ -173,7 +175,8 @@ export const useEventStore = create<EventState>()((set) => ({if (lastEvent &&isStreamingDeltaEvent(event) &&- isStreamingDeltaEvent(lastEvent)+ isStreamingDeltaEvent(lastEvent) &&+ isSameStreamingSender(event, lastEvent)) {events[lastEventIndex] = mergeStreamingDeltaEvent(event, lastEvent);} else {diff --git a/src/utils/handle-event-for-ui.ts b/src/utils/handle-event-for-ui.tsindex 19af184074..2da846047a 100644--- a/src/utils/handle-event-for-ui.ts+++ b/src/utils/handle-event-for-ui.ts@@ -12,7 +12,10 @@ import {isStreamingDeltaEvent,} from "#/types/agent-server/type-guards";import { StreamingDeltaEvent } from "#/types/agent-server/core/events/streaming-delta-event";-import { getReasoningContent } from "#/components/conversation-events/chat/event-thought-helpers";+import {+ getReasoningContent,+ splitInlineThink,+} from "#/components/conversation-events/chat/event-thought-helpers";export const mergeStreamingDeltaEvent = (incoming: StreamingDeltaEvent,@@ -25,13 +28,13 @@ export const mergeStreamingDeltaEvent = (null,});-const appendContentToStreamingDeltaEvent = (- existing: StreamingDeltaEvent,- content: string,-): StreamingDeltaEvent => ({- ...existing,- content: `${existing.content ?? ""}${content}` || null,-});+// Deltas only merge into one bubble when they share a sender; the planning flag+// is the only discriminator (every delta has `source: "agent"`). Prevents a+// planning-agent delta concatenating onto a main-agent one, misattributed (#1656).+export const isSameStreamingSender = (+ a: OpenHandsEvent & { isFromPlanningAgent?: boolean },+ b: OpenHandsEvent & { isFromPlanningAgent?: boolean },+): boolean => Boolean(a.isFromPlanningAgent) === Boolean(b.isFromPlanningAgent);const findLastUserMessageIndex = (events: OpenHandsEvent[]): number => {for (let index = events.length - 1; index >= 0; index -= 1) {@@ -53,18 +56,6 @@ const joinTextBlocks = (blocks: (TextContent | ImageContent)[]): string =>.map((block) => block.text).join("");-const getFinalAgentText = (event: OpenHandsEvent): string | null => {- if (isActionEvent(event) && event.action.kind === "FinishAction") {- return event.action.message;- }-- if (isMessageEvent(event) && event.source === "agent") {- return joinTextBlocks(event.llm_message.content);- }-- return null;-};-const findTextSegmentsInOrder = (text: string,segments: string[],@@ -85,10 +76,14 @@ const findTextSegmentsInOrder = (};// Content-bearing streaming deltas of the current turn (after the last user-// message). Reasoning-only deltas are excluded: reasoning renders in its own-// collapsed bubble and never overlaps the message text being reconciled.+// message) that share the final event's sender. Reasoning-only deltas are+// excluded: reasoning renders in its own collapsed bubble and never overlaps+// the message text being reconciled. Sender scoping matters because the main+// and planning sockets share this event store β without it, one agent's final+// event would strip the other agent's still-live streamed deltas (#1656).const getCurrentTurnContentDeltas = (uiEvents: OpenHandsEvent[],+ finalEvent: OpenHandsEvent,): { event: StreamingDeltaEvent; index: number }[] => {const lastUserMessageIndex = findLastUserMessageIndex(uiEvents);return uiEvents@@ -97,7 +92,8 @@ const getCurrentTurnContentDeltas = ((item): item is { event: StreamingDeltaEvent; index: number } =>item.index > lastUserMessageIndex &&isStreamingDeltaEvent(item.event) &&- (item.event.content?.length ?? 0) > 0,+ (item.event.content?.length ?? 0) > 0 &&+ isSameStreamingSender(finalEvent, item.event),);};@@ -120,17 +116,47 @@ const getTrailingContentDeltas = (return deltas;};+// 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+// reconciliation paths.+const supersedeStreamingContent = (+ uiEvents: OpenHandsEvent[],+ contentDeltas: { event: StreamingDeltaEvent; index: number }[],+ replacementRendersReasoning: boolean,+): OpenHandsEvent[] => {+ const indexesToStrip = new Set(contentDeltas.map(({ index }) => index));+ const nextUiEvents: OpenHandsEvent[] = [];+ uiEvents.forEach((event, index) => {+ if (!indexesToStrip.has(index) || !isStreamingDeltaEvent(event)) {+ nextUiEvents.push(event);+ return;+ }++ // Keep the delta only to render reasoning the replacement itself lacks.+ if (!replacementRendersReasoning && event.reasoning_content) {+ nextUiEvents.push({ ...event, content: null });+ }+ });+ return nextUiEvents;+};+// Whether the streamed `segments` (in order) reconcile against `targetText`.// `lastMatchEnd` is the offset past the matched text, so callers can recover-// any not-yet-streamed suffix. The SDK strips the finalized text, so it may-// lack trailing whitespace the model streamed; the match tolerates that by-// also trying the trailing-trimmed streamed text.+// any not-yet-streamed suffix. The SDK strips the finalized text, so tolerate+// leading and trailing whitespace that appeared only in the stream.const matchStreamedSegments = (targetText: string,segments: string[],): { matched: boolean; lastMatchEnd: number } => {const streamedText = segments.join("");- for (const candidate of [streamedText, streamedText.trimEnd()]) {+ const candidates = new Set([+ streamedText,+ streamedText.trimEnd(),+ streamedText.trimStart(),+ streamedText.trim(),+ ]);+ for (const candidate of candidates) {if (candidate && targetText.startsWith(candidate)) {return { matched: true, lastMatchEnd: candidate.length };}@@ -144,54 +170,49 @@ const matchStreamedSegments = (return findTextSegmentsInOrder(targetText, searchSegments);};+// Whether the finalized event renders its own reasoning: an ActionEvent via+// reasoning_content/thinking_blocks, an agent MessageEvent via an inline+// <think> block in its content. Decides if a replaced delta's reasoning must+// be preserved separately.+const eventRendersReasoning = (event: OpenHandsEvent): boolean => {+ if (isActionEvent(event)) {+ return getReasoningContent(event).trim().length > 0;+ }++ if (isMessageEvent(event) && event.source === "agent") {+ return (+ splitInlineThink(joinTextBlocks(event.llm_message.content)).reasoning+ .length > 0+ );+ }++ return false;+};++// The final MessageEvent/FinishAction is authoritative for the turn's text. Drop+// the provisional streamed deltas and render the canonical final event instead,+// so the message is rendered exactly once (never holey or duplicated) and its+// metadata β critic_result, activated_microagents β renders too. Stream-only+// reasoning is preserved. Returns null when there is no streamed content to+// reconcile, leaving the caller to append the final event normally.const finalizeStreamingDeltasInPlace = (finalEvent: OpenHandsEvent,uiEvents: OpenHandsEvent[],): OpenHandsEvent[] | null => {- const contentStreamingDeltas = getCurrentTurnContentDeltas(uiEvents);+ const contentStreamingDeltas = getCurrentTurnContentDeltas(+ uiEvents,+ finalEvent,+ );if (contentStreamingDeltas.length === 0) {return null;}- const finalText = getFinalAgentText(finalEvent);- if (!finalText) {- return null;- }-- const streamingSegments = contentStreamingDeltas.map(- ({ event }) => event.content ?? "",- );- const { matched, lastMatchEnd } = matchStreamedSegments(- finalText,- streamingSegments,+ const nextUiEvents = supersedeStreamingContent(+ uiEvents,+ contentStreamingDeltas,+ eventRendersReasoning(finalEvent),);- if (!matched) {- return null;- }-- const nextUiEvents = [...uiEvents];- const unstreamedSuffix = finalText.slice(lastMatchEnd);-- const lastDeltaIndex = contentStreamingDeltas.at(-1)?.index;- const lastDelta =- lastDeltaIndex === undefined ? undefined : nextUiEvents[lastDeltaIndex];- if (- unstreamedSuffix &&- lastDeltaIndex !== undefined &&- lastDelta &&- isStreamingDeltaEvent(lastDelta)- ) {- nextUiEvents[lastDeltaIndex] = appendContentToStreamingDeltaEvent(- lastDelta,- unstreamedSuffix,- );- }-- // Intentionally return nextUiEvents WITHOUT appending finalEvent.- // The last content-bearing streaming delta (possibly extended with- // unstreamedSuffix above) becomes the canonical final rendered bubble for- // this turn. Appending finalEvent here would display the assistant message- // twice.+ nextUiEvents.push(finalEvent);return nextUiEvents;};@@ -202,11 +223,10 @@ const finalizeStreamingDeltasInPlace = (* `thought` repeats it and the chat hoists that into its own message (see* `group-events.ts`), so the text would render twice (issue #1534).*- * Unlike `finalizeStreamingDeltasInPlace` (which drops the final event and- * keeps the delta), the action must stay β it owns the tool call. So the- * streamed text is cleared from the delta instead, and the delta is kept only- * to carry reasoning the action itself lacks (for many models the delta is the- * sole reasoning carrier), otherwise dropped.+ * The action must stay because it owns the tool call. The streamed text is+ * cleared from the delta, and the delta is kept only to carry reasoning the+ * action itself lacks (for many models the delta is the sole reasoning+ * carrier), otherwise dropped.** Only the current step's trailing delta run is considered. Returns the updated* array, or `null` when there is nothing to reconcile.@@ -235,21 +255,11 @@ const supersedeStreamedThoughtWithAction = (}// Keeping the delta's reasoning would duplicate the action's own "Thinking".- const actionRendersReasoning = getReasoningContent(action).trim().length > 0;- const indexesToStrip = new Set(contentDeltas.map(({ index }) => index));- const nextUiEvents: OpenHandsEvent[] = [];- uiEvents.forEach((event, index) => {- if (!indexesToStrip.has(index) || !isStreamingDeltaEvent(event)) {- nextUiEvents.push(event);- return;- }- // Keep the delta only to render reasoning the action itself lacks.- if (!actionRendersReasoning && event.reasoning_content) {- nextUiEvents.push({ ...event, content: null });- }- });-- return nextUiEvents;+ return supersedeStreamingContent(+ uiEvents,+ contentDeltas,+ getReasoningContent(action).trim().length > 0,+ );};/**@@ -277,7 +287,11 @@ export const handleEventForUI = (const lastIndex = newUiEvents.length - 1;const lastEvent = newUiEvents[lastIndex];- if (lastEvent && isStreamingDeltaEvent(lastEvent)) {+ if (+ lastEvent &&+ isStreamingDeltaEvent(lastEvent) &&+ isSameStreamingSender(event, lastEvent)+ ) {newUiEvents[lastIndex] = mergeStreamingDeltaEvent(event, lastEvent);return newUiEvents;}@@ -295,11 +309,6 @@ export const handleEventForUI = (newUiEvents,);if (finalizedUiEvents) {- // The reconciled streaming delta intentionally replaces this final event- // for rendering. Today streamed agent responses only render text and- // reasoning content; if final-event metadata such as activated- // microagents becomes meaningful for streamed responses, add a rendered- // wrapper that carries both the stable delta identity and that metadata.return finalizedUiEvents;}}