AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.
fix(frontend/copilot): group consecutive reasoning blocks while streaming (#13369)
Ubbead8695d4506d
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsxindex fd4a41f12e..13b0f7da59 100644--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/ChatMessagesContainer.tsx@@ -37,6 +37,7 @@ import { CollapsedToolGroup } from "./components/CollapsedToolGroup";import { MessageAttachments } from "./components/MessageAttachments";import { MessagePartRenderer } from "./components/MessagePartRenderer";import { QueueBadge } from "./components/QueueBadge";+import { ReasoningGroup } from "./components/ReasoningGroup";import { StepsCollapse } from "./components/StepsCollapse";import { TaskListNotice } from "./components/TaskListNotice";import { ThinkingIndicator } from "./components/ThinkingIndicator";@@ -103,6 +104,14 @@ function renderSegments(if (seg.kind === "collapsed-group") {return <CollapsedToolGroup key={`group-${segIdx}`} parts={seg.parts} />;}+ if (seg.kind === "reasoning-group") {+ return (+ <ReasoningGroup+ key={`${messageID}-reasoning-${seg.index}`}+ parts={seg.parts}+ />+ );+ }return (<MessagePartRendererkey={`${messageID}-${seg.index}`}diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.tsindex ba211dc474..67ba5b0f64 100644--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/__tests__/helpers.test.ts@@ -26,6 +26,10 @@ function reasoningPart(text: string): MessagePart {return { type: "reasoning", text, state: "done" } as MessagePart;}+function stepStartPart(): MessagePart {+ return { type: "step-start" } as MessagePart;+}+function toolPart(toolName: string,state: string = "output-available",@@ -239,6 +243,92 @@ describe("buildRenderSegments", () => {expect(segments[0].index).toBe(5);}});++ it("collapses consecutive reasoning parts into one reasoning-group", () => {+ const parts = [+ reasoningPart("Thinking step 1"),+ reasoningPart("Thinking step 2"),+ reasoningPart("Thinking step 3"),+ ];+ const segments = buildRenderSegments(parts);+ expect(segments).toHaveLength(1);+ expect(segments[0].kind).toBe("reasoning-group");+ if (segments[0].kind === "reasoning-group") {+ expect(segments[0].parts).toHaveLength(3);+ }+ });++ it("wraps a single reasoning part in a reasoning-group for stable identity", () => {+ const parts = [reasoningPart("Lone thought")];+ const segments = buildRenderSegments(parts);+ expect(segments).toHaveLength(1);+ expect(segments[0].kind).toBe("reasoning-group");+ if (segments[0].kind === "reasoning-group") {+ expect(segments[0].parts).toHaveLength(1);+ }+ });++ it("breaks reasoning groups around interleaved text", () => {+ const parts = [+ reasoningPart("a"),+ reasoningPart("b"),+ textPart("Status update"),+ reasoningPart("c"),+ reasoningPart("d"),+ ];+ const segments = buildRenderSegments(parts);+ expect(segments).toHaveLength(3);+ expect(segments[0].kind).toBe("reasoning-group");+ expect(segments[1].kind).toBe("part");+ expect(segments[2].kind).toBe("reasoning-group");+ });++ it("does not merge reasoning parts and generic tools together", () => {+ const parts = [+ reasoningPart("a"),+ reasoningPart("b"),+ toolPart("generic_a", "output-available"),+ toolPart("generic_b", "output-available"),+ ];+ const segments = buildRenderSegments(parts);+ expect(segments).toHaveLength(2);+ expect(segments[0].kind).toBe("reasoning-group");+ expect(segments[1].kind).toBe("collapsed-group");+ });++ it("uses the first part's absolute index as the reasoning-group index", () => {+ const parts = [reasoningPart("a"), reasoningPart("b")];+ const segments = buildRenderSegments(parts, 3);+ expect(segments).toHaveLength(1);+ if (segments[0].kind === "reasoning-group") {+ expect(segments[0].index).toBe(3);+ }+ });++ it("treats step-start markers as transparent so reasoning stays grouped", () => {+ const parts = [+ reasoningPart("turn 1"),+ stepStartPart(),+ reasoningPart("turn 2"),+ ];+ const segments = buildRenderSegments(parts);+ expect(segments).toHaveLength(1);+ expect(segments[0].kind).toBe("reasoning-group");+ if (segments[0].kind === "reasoning-group") {+ expect(segments[0].parts).toHaveLength(2);+ }+ });++ it("treats step-start markers as transparent within tool groups", () => {+ const parts = [+ toolPart("generic_a", "output-available"),+ stepStartPart(),+ toolPart("generic_b", "output-available"),+ ];+ const segments = buildRenderSegments(parts);+ expect(segments).toHaveLength(1);+ expect(segments[0].kind).toBe("collapsed-group");+ });});describe("parseSpecialMarkers", () => {diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/ReasoningGroup.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/ReasoningGroup.tsxnew file mode 100644index 0000000000..bf6f26297a--- /dev/null+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/components/ReasoningGroup.tsx@@ -0,0 +1,32 @@+import type { MessagePart } from "../helpers";+import { ReasoningCollapse } from "./ReasoningCollapse";++interface Props {+ parts: MessagePart[];+}++function reasoningText(part: MessagePart): string {+ return "text" in part && typeof part.text === "string" ? part.text : "";+}++export function ReasoningGroup({ parts }: Props) {+ const texts = parts.map(reasoningText).filter((text) => text.trim());+ if (texts.length === 0) return null;++ // The group is still "thinking" while its most recent part streams — that+ // keeps the pulse going through the whole multi-turn reasoning run instead+ // of flickering off between turns.+ const lastPart = parts[parts.length - 1];+ const isActive =+ "state" in lastPart &&+ typeof lastPart.state === "string" &&+ lastPart.state === "streaming";++ return (+ <ReasoningCollapse isActive={isActive}>+ <pre className="whitespace-pre-wrap text-sm text-zinc-700">+ {texts.join("\n\n")}+ </pre>+ </ReasoningCollapse>+ );+}diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.tsindex a7e9b29958..b94b65de3e 100644--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/ChatMessagesContainer/helpers.ts@@ -29,7 +29,8 @@ export type MessagePart = UIMessage<export type RenderSegment =| { kind: "part"; part: MessagePart; index: number }- | { kind: "collapsed-group"; parts: ToolUIPart[] };+ | { kind: "collapsed-group"; parts: ToolUIPart[] }+ | { kind: "reasoning-group"; parts: MessagePart[]; index: number };const CUSTOM_TOOL_TYPES = new Set(["tool-ask_question",@@ -133,38 +134,71 @@ export function buildRenderSegments(baseIndex = 0,): RenderSegment[] {const segments: RenderSegment[] = [];- let pendingGroup: Array<{ part: ToolUIPart; index: number }> | null = null;+ let pendingTools: Array<{ part: ToolUIPart; index: number }> | null = null;+ let pendingReasoning: Array<{ part: MessagePart; index: number }> | null =+ null;- function flushGroup() {- if (!pendingGroup) return;- if (pendingGroup.length >= 2) {+ function flushTools() {+ if (!pendingTools) return;+ if (pendingTools.length >= 2) {segments.push({kind: "collapsed-group",- parts: pendingGroup.map((p) => p.part),+ parts: pendingTools.map((p) => p.part),});} else {- for (const p of pendingGroup) {+ for (const p of pendingTools) {segments.push({ kind: "part", part: p.part, index: p.index });}}- pendingGroup = null;+ pendingTools = null;+ }++ // Native reasoning parts (one per agentic turn) are always emitted as a+ // reasoning-group — including a lone part. This folds a multi-step task's+ // consecutive reasoning into one collapsed block instead of a stacked wall of+ // "Reasoning" accordions, and gives the run a single stable identity+ // (`reasoning-group` keyed by its first index) so a single block doesn't+ // remount — losing its open/closed state — the moment a second consecutive+ // block arrives and turns it into a group.+ function flushReasoning() {+ if (!pendingReasoning) return;+ segments.push({+ kind: "reasoning-group",+ parts: pendingReasoning.map((p) => p.part),+ index: pendingReasoning[0].index,+ });+ pendingReasoning = null;}parts.forEach((part, i) => {const absoluteIndex = baseIndex + i;++ // `step-start` markers delimit turns in multi-step agentic streams and+ // render as nothing. Treat them as transparent: skipping them (rather than+ // flushing) keeps the reasoning blocks on either side in a single run, which+ // is exactly the consecutive-reasoning case this grouping targets.+ if (part.type === "step-start") return;+const isGenericCompletedTool =isCompletedToolPart(part) && !CUSTOM_TOOL_TYPES.has(part.type);if (isGenericCompletedTool) {- if (!pendingGroup) pendingGroup = [];- pendingGroup.push({ part: part as ToolUIPart, index: absoluteIndex });+ flushReasoning();+ if (!pendingTools) pendingTools = [];+ pendingTools.push({ part: part as ToolUIPart, index: absoluteIndex });+ } else if (part.type === "reasoning") {+ flushTools();+ if (!pendingReasoning) pendingReasoning = [];+ pendingReasoning.push({ part, index: absoluteIndex });} else {- flushGroup();+ flushTools();+ flushReasoning();segments.push({ kind: "part", part, index: absoluteIndex });}});- flushGroup();+ flushTools();+ flushReasoning();return segments;}