Skip to content

πŸ™Œ 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.tsx
index 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.tsx
index 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-websocket
import { 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.ts
index 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.ts
index 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.tsx
index 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 structure
if (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 structure
if (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 agent
const 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 banners
diff --git a/src/stores/use-event-store.ts b/src/stores/use-event-store.ts
index 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.ts
index 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;
}
}