Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🧶 fix: Render Solo Agent Groups as Sequential Content (#15574)

Danny Avila374ed8df14dc
diff --git a/client/src/components/Chat/Messages/Content/ContentParts.tsx b/client/src/components/Chat/Messages/Content/ContentParts.tsx
index acf419dd9e..361b029fd4 100644
--- a/client/src/components/Chat/Messages/Content/ContentParts.tsx
+++ b/client/src/components/Chat/Messages/Content/ContentParts.tsx
@@ -26,6 +26,7 @@ import WorkspaceChanges, { partitionWorkspaceChanges } from './Parts/WorkspaceCh
import { ParallelContentRenderer, type PartWithIndex } from './ParallelContent';
import { MediaContext, MessageContext, SearchContext } from '~/Providers';
import MemoryArtifacts, { hasMemoryArtifacts } from './MemoryArtifacts';
+import { hasParallelLanes, parallelLaneGroups } from '~/utils/lanes';
import PendingSkillCall from './Parts/PendingSkillCall';
import ActivityPhaseGroup from './ActivityPhaseGroup';
import { hasPendingApprovalInPart } from '~/utils';
@@ -234,6 +235,9 @@ type ContentPartsProps = {
contentIndexOffset?: number;
/** Absolute transcript index for each compacted sparse segment entry. */
contentIndices?: ReadonlyArray<number>;
+ /** Message-wide lane cardinality retained across nested phase segments, so a
+ * slice holding one agent of a real two-agent group keeps its columns. */
+ laneGroups?: ReadonlySet<number>;
/** Message-wide steer attribution retained across nested phase segments. */
resumeAuthors?: ReadonlyMap<number, string | undefined>;
/** Message-wide tool-group expansion overrides retained across phase slices. */
@@ -274,6 +278,7 @@ const ContentPartsBody = memo(function ContentPartsBody({
workspaceAttachmentsPartitioned = false,
contentIndexOffset = 0,
contentIndices,
+ laneGroups,
resumeAuthors,
toolGroupExpansionState,
toolGroupOccurrenceByIndex,
@@ -343,9 +348,16 @@ const ContentPartsBody = memo(function ContentPartsBody({
/** Hoisted above the early returns to feed the entrance-detection hook
* below, so it is memoized rather than re-walked on every unrelated
* re-render of a message that has no phases at all. */
+ /** Resolved once over the whole message and handed to every slice below —
+ * and to `groupActivityPhases`, so a streamed delta scans content once. */
+ const messageLaneGroups = useMemo(
+ () => laneGroups ?? parallelLaneGroups(content),
+ [laneGroups, content],
+ );
+
const phaseSegments = useMemo(
- () => (nestedActivityPhase ? undefined : groupActivityPhases(content)),
- [nestedActivityPhase, content],
+ () => (nestedActivityPhase ? undefined : groupActivityPhases(content, messageLaneGroups)),
+ [nestedActivityPhase, content, messageLaneGroups],
);
/** Every file a phase's parts produced, in transcript order, deduplicated
* across parts that share a tool call. */
@@ -804,6 +816,7 @@ const ContentPartsBody = memo(function ContentPartsBody({
workspaceAttachmentsPartitioned
contentIndexOffset={segmentStartIndex}
contentIndices={segmentIndices}
+ laneGroups={messageLaneGroups}
resumeAuthors={postSteerAuthors}
toolGroupExpansionState={expansionState}
toolGroupOccurrenceByIndex={resolvedToolGroupOccurrences}
@@ -811,7 +824,7 @@ const ContentPartsBody = memo(function ContentPartsBody({
/>
);
};
- const hasParallelContent = content?.some((part) => part?.groupId != null) === true;
+ const hasParallelContent = hasParallelLanes(content, messageLaneGroups);
return (
<ApprovalProvider>
<SearchContext.Provider value={{ searchResults }}>
@@ -960,8 +973,9 @@ const ContentPartsBody = memo(function ContentPartsBody({
const relativeLastContentIdx = lastCursorContentIdx(safeContent);
const lastContentIdx = relativeLastContentIdx < 0 ? -1 : absoluteIndexAt(relativeLastContentIdx);
- // Parallel content: use dedicated renderer with columns (TMessageContentParts includes ContentMetadata)
- const hasParallelContent = safeContent.some((part) => part?.groupId != null);
+ /** Columns only when at least two agents share a group — a lone group
+ * renders here, where tool grouping and activity labels apply. */
+ const hasParallelContent = hasParallelLanes(safeContent, messageLaneGroups);
if (hasParallelContent) {
const parallelContent = (
<>
@@ -979,6 +993,7 @@ const ContentPartsBody = memo(function ContentPartsBody({
showDecorations={!nestedActivityPhase}
contentIndexOffset={contentIndexOffset}
contentIndices={contentIndices}
+ laneGroups={messageLaneGroups}
/>
{!nestedActivityPhase && <WorkspaceChanges attachments={workspaceChanges} />}
</>
diff --git a/client/src/components/Chat/Messages/Content/ParallelContent.tsx b/client/src/components/Chat/Messages/Content/ParallelContent.tsx
index 27b961a3df..5a156db3d8 100644
--- a/client/src/components/Chat/Messages/Content/ParallelContent.tsx
+++ b/client/src/components/Chat/Messages/Content/ParallelContent.tsx
@@ -1,4 +1,4 @@
-import { memo, useMemo } from 'react';
+import { memo, useMemo, Fragment } from 'react';
import { ContentTypes } from 'librechat-data-provider';
import type { TMessageContentParts, SearchResultData, TAttachment } from 'librechat-data-provider';
import {
@@ -6,6 +6,7 @@ import {
getActivityLabelText,
lastCursorContentIdx,
} from '~/utils/activityLabels';
+import { MIN_PARALLEL_LANES, UNATTRIBUTED_LANE, isLaneMarkerPart } from '~/utils/lanes';
import MemoryArtifacts from './MemoryArtifacts';
import Sources from '~/components/Web/Sources';
import { cn, getPartKeyIndex } from '~/utils';
@@ -37,6 +38,7 @@ export function groupParallelContent(
content: Array<TMessageContentParts | undefined> | undefined,
contentIndexOffset = 0,
contentIndices?: ReadonlyArray<number>,
+ laneGroups?: ReadonlySet<number>,
): { parallelSections: ParallelSection[]; sequentialParts: PartWithIndex[] } {
if (!content) {
return { parallelSections: [], sequentialParts: [] };
@@ -89,7 +91,7 @@ export function groupParallelContent(
for (const { part, idx } of parts) {
// Read agentId directly from content part (TMessageContentParts includes ContentMetadata)
- const agentId = part.agentId ?? 'unknown';
+ const agentId = part.agentId ?? UNATTRIBUTED_LANE;
if (!columnMap.has(agentId)) {
columnMap.set(agentId, []);
@@ -127,6 +129,31 @@ export function groupParallelContent(
parts: columnMap.get(agentId)!,
}));
+ /** Which columns are an agent's own output, mirroring `laneAgentsByGroup`:
+ * the sentinel column belongs to no agent, and a column holding only a
+ * handoff marker is nothing to compare against. A placeholder column has
+ * no parts at all and still claims its lane — that is how a dual run
+ * shows both agents from the first render. */
+ const claimedColumns = columns.filter(
+ ({ agentId, parts }) =>
+ agentId !== UNATTRIBUTED_LANE &&
+ (parts.length === 0 || parts.some(({ part }) => !isLaneMarkerPart(part))),
+ ).length;
+
+ /** One column is not a comparison. Its parts rejoin the sequential flow,
+ * where tool grouping, activity-label headers and phase folds apply and
+ * the message's own author header is the only attribution shown.
+ *
+ * `laneGroups` is the message-level verdict: a phase slice holding one
+ * agent of a real two-agent group keeps its columns, because the group
+ * is a comparison even where this slice cannot show it. */
+ if (claimedColumns < MIN_PARALLEL_LANES && laneGroups?.has(groupId) !== true) {
+ for (const column of columns) {
+ noGroup.push(...column.parts);
+ }
+ continue;
+ }
+
sections.push({ groupId, columns });
}
@@ -139,6 +166,10 @@ export function groupParallelContent(
return aMin - bMin;
});
+ /** Demoted lane parts are appended after the parts that preceded them, so
+ * restore transcript order before the before/after split reads indexes. */
+ noGroup.sort((a, b) => a.idx - b.idx);
+
return { parallelSections: sections, sequentialParts: noGroup };
}
@@ -241,6 +272,8 @@ type ParallelContentRendererProps = {
contentIndexOffset?: number;
/** Absolute transcript index for each compacted sparse segment entry. */
contentIndices?: ReadonlyArray<number>;
+ /** Message-level lane cardinality, so a phase slice does not recount. */
+ laneGroups?: ReadonlySet<number>;
};
/**
@@ -260,10 +293,11 @@ export const ParallelContentRenderer = memo(function ParallelContentRenderer({
showDecorations = true,
contentIndexOffset = 0,
contentIndices,
+ laneGroups,
}: ParallelContentRendererProps) {
const { parallelSections, sequentialParts } = useMemo(
- () => groupParallelContent(content, contentIndexOffset, contentIndices),
- [content, contentIndexOffset, contentIndices],
+ () => groupParallelContent(content, contentIndexOffset, contentIndices, laneGroups),
+ [content, contentIndexOffset, contentIndices, laneGroups],
);
/** Same walk-back as `ContentParts`: a trailing BLANK label reservation is
@@ -275,24 +309,37 @@ export const ParallelContentRenderer = memo(function ParallelContentRenderer({
? -1
: (contentIndices?.[relativeLastContentIdx] ?? relativeLastContentIdx + contentIndexOffset);
- // Split sequential parts into before/after parallel sections
- const { before, after } = useMemo(() => {
- if (parallelSections.length === 0) {
- return { before: sequentialParts, after: [] };
+ /** Sequential parts are laid out AROUND each section rather than split once
+ * around all of them: two groups with ordinary content between them would
+ * otherwise render both groups first and the intervening part last.
+ *
+ * A part landing between a section's own first and last index has no column
+ * and no slot inside one, so it falls to the next block — after the lanes it
+ * interleaves with. Bounding it by the last lane index instead dropped it
+ * from the message entirely, and a placeholder-only section made
+ * `Math.min(...[])` Infinity, which rendered every part twice. */
+ const { blocks, trailing } = useMemo(() => {
+ const laid: Array<{ leading: PartWithIndex[]; section: ParallelSection }> = [];
+ let cursor = 0;
+ for (const section of parallelSections) {
+ const indices = section.columns.flatMap((column) => column.parts.map((part) => part.idx));
+ const sectionStart = indices.length > 0 ? Math.min(...indices) : Infinity;
+ const leading: PartWithIndex[] = [];
+ while (cursor < sequentialParts.length && sequentialParts[cursor].idx < sectionStart) {
+ leading.push(sequentialParts[cursor]);
+ cursor += 1;
+ }
+ laid.push({ leading, section });
}
-
- const allParallelIndices = parallelSections.flatMap((s) =>
- s.columns.flatMap((c) => c.parts.map((p) => p.idx)),
- );
- const minParallelIdx = Math.min(...allParallelIndices);
- const maxParallelIdx = Math.max(...allParallelIndices);
-
- return {
- before: sequentialParts.filter(({ idx }) => idx < minParallelIdx),
- after: sequentialParts.filter(({ idx }) => idx > maxParallelIdx),
- };
+ return { blocks: laid, trailing: sequentialParts.slice(cursor) };
}, [parallelSections, sequentialParts]);
+ const renderSequential = ({ part, idx }: PartWithIndex) => {
+ const attribution = renderResumeAttribution?.(idx, getPartKeyIndex(part, idx));
+ const rendered = renderPart(part, idx, idx === lastContentIdx);
+ return attribution != null ? [attribution, rendered] : [rendered];
+ };
+
return (
<SearchContext.Provider value={{ searchResults }}>
{showDecorations && <MemoryArtifacts attachments={attachments} />}
@@ -300,34 +347,25 @@ export const ParallelContentRenderer = memo(function ParallelContentRenderer({
<Sources messageId={messageId} conversationId={conversationId || undefined} />
)}
- {/* Sequential content BEFORE parallel sections */}
- {before.flatMap(({ part, idx }) => {
- const attribution = renderResumeAttribution?.(idx, getPartKeyIndex(part, idx));
- const rendered = renderPart(part, idx, false);
- return attribution != null ? [attribution, rendered] : [rendered];
- })}
-
- {/* Parallel sections - each group renders as columns */}
- {parallelSections.map(({ groupId, columns }) => (
- <ParallelColumns
- key={`parallel-group-${messageId}-${groupId}`}
- columns={columns}
- groupId={groupId}
- messageId={messageId}
- createdAt={createdAt}
- renderPart={renderPart}
- isSubmitting={isSubmitting}
- conversationId={conversationId}
- lastContentIdx={lastContentIdx}
- />
+ {/* Each section preceded by the sequential content that runs up to it */}
+ {blocks.map(({ leading, section: { groupId, columns } }) => (
+ <Fragment key={`parallel-block-${messageId}-${groupId}`}>
+ {leading.flatMap(renderSequential)}
+ <ParallelColumns
+ columns={columns}
+ groupId={groupId}
+ messageId={messageId}
+ createdAt={createdAt}
+ renderPart={renderPart}
+ isSubmitting={isSubmitting}
+ conversationId={conversationId}
+ lastContentIdx={lastContentIdx}
+ />
+ </Fragment>
))}
- {/* Sequential content AFTER parallel sections */}
- {after.flatMap(({ part, idx }) => {
- const attribution = renderResumeAttribution?.(idx, getPartKeyIndex(part, idx));
- const rendered = renderPart(part, idx, idx === lastContentIdx);
- return attribution != null ? [attribution, rendered] : [rendered];
- })}
+ {/* Sequential content after the last section */}
+ {trailing.flatMap(renderSequential)}
</SearchContext.Provider>
);
});
diff --git a/client/src/components/Chat/Messages/Content/__tests__/ContentParts.integration.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ContentParts.integration.test.tsx
index cbae29dd16..5f4ea691f9 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/ContentParts.integration.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/ContentParts.integration.test.tsx
@@ -121,6 +121,13 @@ jest.mock('../Container', () => ({
default: ({ children }: { children?: React.ReactNode }) => <div>{children}</div>,
}));
+jest.mock('../SiblingHeader', () => ({
+ __esModule: true,
+ default: ({ agentId }: { agentId?: string }) => (
+ <div data-testid="sibling-header" data-agent-id={agentId} />
+ ),
+}));
+
jest.mock('~/utils', () => {
const actual = jest.requireActual('~/utils');
return {
@@ -914,3 +921,106 @@ describe('ContentParts integration: phase media row', () => {
expect(screen.queryByTestId('attachment-group')).toBeNull();
});
});
+
+describe('ContentParts integration: lane groups backed by one agent', () => {
+ const baseProps = {
+ messageId: 'msg-lane',
+ isCreatedByUser: false,
+ isLast: true,
+ isSubmitting: false,
+ isLatestMessage: true,
+ };
+
+ const inLane = (part: TMessageContentParts, agentId: string, groupId = 1): TMessageContentParts =>
+ ({ ...(part as object), agentId, groupId }) as unknown as TMessageContentParts;
+
+ it('renders no lane header when a phase marker splits a single-agent group', () => {
+ /** The reported shape: a multi-agent graph stamped a group id on the
+ * primary agent's own output, and a phase marker ending mid-group split
+ * it — so one lane rendered as TWO bordered cards, each repeating the
+ * message's own author, and the answer read as a separate message. */
+ const answer = 'Monitoring the pull requests for the next hour.';
+ const content = [
+ makeMcpToolCall('t1'),
+ makeMcpToolCall('t2'),
+ inLane(makeMcpToolCall('t3'), 'agent_a'),
+ inLane(makeTextPart(answer), 'agent_a'),
+ makePhasePart(0, 3, 'Planned the monitoring run'),
+ ];
+
+ renderContentParts({ ...baseProps, content });
+ /** The card mounts collapsed and its body is lazy, so open it — the split
+ * drew one header inside the card and one after it. */
+ fireEvent.click(screen.getByRole('button', { name: 'Planned the monitoring run' }));
+
+ expect(screen.queryAllByTestId('sibling-header')).toHaveLength(0);
+ expect(screen.getAllByText(answer)).toHaveLength(1);
+ });
+
+ it('groups the tool calls of a single-agent group, which lanes never do', () => {
+ const content = [
+ inLane(makeMcpToolCall('t1'), 'agent_a'),
+ inLane(makeMcpToolCall('t2'), 'agent_a'),
+ ];
+
+ renderContentParts({ ...baseProps, content });
+
+ expect(screen.getByRole('button', { name: 'Used 2 tools' })).toBeInTheDocument();
+ });
+
+ it('still renders columns once a second agent shares the group', () => {
+ const content = [
+ inLane(makeTextPart('primary answer'), 'agent_a'),
+ inLane(makeTextPart('added answer'), 'agent_b____1'),
+ ];
+
+ renderContentParts({ ...baseProps, content });
+
+ const headers = screen.getAllByTestId('sibling-header');
+ expect(headers.map((header) => header.getAttribute('data-agent-id'))).toEqual([
+ 'agent_a',
+ 'agent_b____1',
+ ]);
+ });
+
+ it('keeps lane attribution when a phase marker leaves one agent per slice', () => {
+ /** Lane cardinality belongs to the MESSAGE. A marker that puts each agent
+ * of a real two-agent group in a different slice would otherwise demote
+ * both, and the added agent's answer would read as the primary's. */
+ const content = [
+ inLane(makeTextPart('primary answer'), 'agent_a'),
+ inLane(makeTextPart('added answer'), 'agent_b____1'),
+ makePhasePart(0, 1, 'Ran both agents'),
+ ];
+
+ renderContentParts({ ...baseProps, content });
+ fireEvent.click(screen.getByRole('button', { name: 'Ran both agents' }));
+
+ const agentIds = screen
+ .getAllByTestId('sibling-header')
+ .map((header) => header.getAttribute('data-agent-id'));
+ expect(agentIds).toContain('agent_a');
+ expect(agentIds).toContain('agent_b____1');
+ });
+
+ it('keeps content that runs between two lane groups in transcript order', () => {
+ const content = [
+ inLane(makeTextPart('first wave primary'), 'agent_a', 1),
+ inLane(makeTextPart('first wave added'), 'agent_b____1', 1),
+ makeTextPart('handover note between the waves'),
+ inLane(makeTextPart('second wave primary'), 'agent_a', 2),
+ inLane(makeTextPart('second wave added'), 'agent_b____1', 2),
+ ];
+
+ renderContentParts({ ...baseProps, content });
+
+ const transcript = document.body.textContent ?? '';
+ expect(transcript).toContain('handover note between the waves');
+ expect(transcript.indexOf('handover note between the waves')).toBeGreaterThan(
+ transcript.indexOf('first wave primary'),
+ );
+ expect(transcript.indexOf('handover note between the waves')).toBeLessThan(
+ transcript.indexOf('second wave primary'),
+ );
+ });
+});
diff --git a/client/src/components/Chat/Messages/Content/__tests__/ContentParts.test.tsx b/client/src/components/Chat/Messages/Content/__tests__/ContentParts.test.tsx
index 08d1ec900c..7e3e96c855 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/ContentParts.test.tsx
+++ b/client/src/components/Chat/Messages/Content/__tests__/ContentParts.test.tsx
@@ -265,11 +265,19 @@ describe('ContentParts — interim skill cards', () => {
});
it('renders pending skill cards above parallel content', () => {
+ /** Two agents, so the group renders as columns at all. */
const parallelContent: TMessageContentParts[] = [
{
type: ContentTypes.TEXT,
- text: 'parallel',
- groupId: 'group-1',
+ text: 'primary',
+ agentId: 'agent_a',
+ groupId: 1,
+ } as unknown as TMessageContentParts,
+ {
+ type: ContentTypes.TEXT,
+ text: 'added',
+ agentId: 'agent_b____1',
+ groupId: 1,
} as unknown as TMessageContentParts,
];
render(<ContentParts {...baseProps} content={parallelContent} manualSkills={['pptx']} />);
@@ -421,15 +429,17 @@ describe('ContentParts — post-steer author re-attribution', () => {
});
it('provides resume attribution to the parallel renderer for its sequential stretches', () => {
- const parallelText = {
- type: ContentTypes.TEXT,
- text: 'column',
- groupId: 1,
- } as unknown as TMessageContentParts;
+ const laneText = (agentId: string) =>
+ ({
+ type: ContentTypes.TEXT,
+ text: `column ${agentId}`,
+ agentId,
+ groupId: 1,
+ }) as unknown as TMessageContentParts;
render(
<ContentParts
{...baseProps}
- content={[parallelText, steerPart, textPart('resumed')]}
+ content={[laneText('agent_a'), laneText('agent_b____1'), steerPart, textPart('resumed')]}
authorHeader={header}
/>,
);
@@ -563,18 +573,21 @@ describe('ContentParts — activity phase state', () => {
activity_count: 2,
pending: false,
} as unknown as TMessageContentParts;
- const parallel = {
- type: ContentTypes.TEXT,
- text: 'lane result',
- groupId: 1,
- } as unknown as TMessageContentParts;
+ const lane = (agentId: string) =>
+ ({
+ type: ContentTypes.TEXT,
+ text: `lane result ${agentId}`,
+ agentId,
+ groupId: 1,
+ }) as unknown as TMessageContentParts;
render(
<ContentParts
{...baseProps}
content={[
{ type: ContentTypes.TEXT, text: 'before' } as unknown as TMessageContentParts,
- parallel,
+ lane('agent_a'),
+ lane('agent_b____1'),
phase,
]}
/>,
diff --git a/client/src/components/Chat/Messages/Content/__tests__/ParallelContent.test.ts b/client/src/components/Chat/Messages/Content/__tests__/ParallelContent.test.ts
index ec1b821bfb..95488955ed 100644
--- a/client/src/components/Chat/Messages/Content/__tests__/ParallelContent.test.ts
+++ b/client/src/components/Chat/Messages/Content/__tests__/ParallelContent.test.ts
@@ -3,42 +3,162 @@ import type { TMessageContentParts } from 'librechat-data-provider';
import { groupParallelContent, lastParallelColumnCursorIdx } from '../ParallelContent';
describe('groupParallelContent', () => {
- test('reports absolute indices for a dense phase segment', () => {
- const sequential = {
- type: ContentTypes.TEXT,
- text: 'before lanes',
- } as unknown as TMessageContentParts;
- const parallel = {
+ const sequentialPart = {
+ type: ContentTypes.TEXT,
+ text: 'before lanes',
+ } as unknown as TMessageContentParts;
+
+ /** Two agents, so the group renders as columns at all — see the lane
+ * demotion suite below. */
+ const lanePart = (agentId: string) =>
+ ({
type: ContentTypes.TEXT,
- text: 'lane result',
+ text: `${agentId} result`,
groupId: 1,
- agentId: 'agent-1',
- } as unknown as TMessageContentParts;
+ agentId,
+ }) as unknown as TMessageContentParts;
- const grouped = groupParallelContent([sequential, parallel], 4);
+ test('reports absolute indices for a dense phase segment', () => {
+ const first = lanePart('agent-1');
+ const second = lanePart('agent-2');
- expect(grouped.sequentialParts).toEqual([{ part: sequential, idx: 4 }]);
- expect(grouped.parallelSections[0]?.columns[0]?.parts).toEqual([{ part: parallel, idx: 5 }]);
+ const grouped = groupParallelContent([sequentialPart, first, second], 4);
+
+ expect(grouped.sequentialParts).toEqual([{ part: sequentialPart, idx: 4 }]);
+ expect(grouped.parallelSections[0]?.columns[0]?.parts).toEqual([{ part: first, idx: 5 }]);
+ expect(grouped.parallelSections[0]?.columns[1]?.parts).toEqual([{ part: second, idx: 6 }]);
});
test('preserves absolute indices for a compacted sparse phase segment', () => {
- const sequential = {
+ const first = lanePart('agent-1');
+ const second = lanePart('agent-2');
+
+ const grouped = groupParallelContent([sequentialPart, first, second], 0, [2, 10_000, 10_001]);
+
+ expect(grouped.sequentialParts).toEqual([{ part: sequentialPart, idx: 2 }]);
+ expect(grouped.parallelSections[0]?.columns[0]?.parts).toEqual([{ part: first, idx: 10_000 }]);
+ expect(grouped.parallelSections[0]?.columns[1]?.parts).toEqual([{ part: second, idx: 10_001 }]);
+ });
+});
+
+describe('groupParallelContent — lane demotion', () => {
+ const lanePart = (agentId: string, text: string, groupId = 1): TMessageContentParts =>
+ ({ type: ContentTypes.TEXT, text, agentId, groupId }) as unknown as TMessageContentParts;
+
+ const plainPart = (text: string): TMessageContentParts =>
+ ({ type: ContentTypes.TEXT, text }) as unknown as TMessageContentParts;
+
+ it('renders a group backed by one agent sequentially', () => {
+ /** A multi-agent graph stamps a group id on every starting node, so an
+ * agent that merely has subagents available carries one on its own
+ * output. One column is not a comparison — a lane there would draw a
+ * second author header and opt the parts out of tool grouping. */
+ const thinking = lanePart('agent_a', 'thinking');
+ const answer = lanePart('agent_a', 'answer');
+
+ const grouped = groupParallelContent([thinking, answer]);
+
+ expect(grouped.parallelSections).toEqual([]);
+ expect(grouped.sequentialParts).toEqual([
+ { part: thinking, idx: 0 },
+ { part: answer, idx: 1 },
+ ]);
+ });
+
+ it('keeps columns once a second agent shares the group', () => {
+ const primary = lanePart('agent_a', 'primary answer');
+ const added = lanePart('agent_b____1', 'added answer');
+
+ const grouped = groupParallelContent([primary, added]);
+
+ expect(grouped.parallelSections).toHaveLength(1);
+ expect(grouped.parallelSections[0]?.columns.map((column) => column.agentId)).toEqual([
+ 'agent_a',
+ 'agent_b____1',
+ ]);
+ expect(grouped.sequentialParts).toEqual([]);
+ });
+
+ it('restores transcript order after demoting a lone group', () => {
+ const preface = plainPart('preface');
+ const lane = lanePart('agent_a', 'lane output');
+ const closing = plainPart('closing');
+
+ const grouped = groupParallelContent([preface, lane, closing]);
+
+ expect(grouped.sequentialParts.map(({ idx }) => idx)).toEqual([0, 1, 2]);
+ });
+
+ it('demotes a lone group beside a real one without dropping its parts', () => {
+ const primary = lanePart('agent_a', 'primary answer');
+ const added = lanePart('agent_b____1', 'added answer');
+ const lone = lanePart('agent_c', 'handoff output', 2);
+
+ const grouped = groupParallelContent([primary, lone, added]);
+
+ expect(grouped.parallelSections).toHaveLength(1);
+ expect(grouped.parallelSections[0]?.groupId).toBe(1);
+ expect(grouped.sequentialParts).toEqual([{ part: lone, idx: 1 }]);
+ });
+
+ it('demotes a group whose only second column is unattributed', () => {
+ const attributed = lanePart('agent_a', 'primary answer');
+ const unattributed = {
type: ContentTypes.TEXT,
- text: 'before lanes',
+ text: 'server sent no agent id',
+ groupId: 1,
} as unknown as TMessageContentParts;
- const parallel = {
- type: ContentTypes.TEXT,
- text: 'lane result',
+
+ const grouped = groupParallelContent([attributed, unattributed]);
+
+ expect(grouped.parallelSections).toEqual([]);
+ expect(grouped.sequentialParts.map(({ idx }) => idx)).toEqual([0, 1]);
+ });
+
+ it('demotes a group whose second column is only a handoff marker', () => {
+ const output = lanePart('agent_a', 'primary answer');
+ const handoff = {
+ type: ContentTypes.AGENT_UPDATE,
+ [ContentTypes.AGENT_UPDATE]: { agentId: 'agent_b' },
+ agentId: 'agent_b',
+ groupId: 1,
+ } as unknown as TMessageContentParts;
+
+ const grouped = groupParallelContent([output, handoff]);
+
+ expect(grouped.parallelSections).toEqual([]);
+ expect(grouped.sequentialParts.map(({ idx }) => idx)).toEqual([0, 1]);
+ });
+
+ it('keeps columns when a real dual run also carries a handoff marker', () => {
+ const primary = lanePart('agent_a', 'primary answer');
+ const added = lanePart('agent_b____1', 'added answer');
+ const handoff = {
+ type: ContentTypes.AGENT_UPDATE,
+ [ContentTypes.AGENT_UPDATE]: { agentId: 'agent_c' },
+ agentId: 'agent_c',
groupId: 1,
- agentId: 'agent-1',
} as unknown as TMessageContentParts;
- const grouped = groupParallelContent([sequential, parallel], 0, [2, 10_000]);
+ const grouped = groupParallelContent([primary, added, handoff]);
+
+ expect(grouped.parallelSections).toHaveLength(1);
+ expect(grouped.sequentialParts).toEqual([]);
+ });
+
+ it('keeps a slice column when the message says the group has two agents', () => {
+ /** A phase marker can hand this slice one agent of a real two-agent group.
+ * Counting the slice alone would demote it and strip the attribution the
+ * sibling slice still shows, so the message-level verdict wins. */
+ const primaryOnly = lanePart('agent_a', 'primary answer');
+
+ const grouped = groupParallelContent([primaryOnly], 0, undefined, new Set([1]));
- expect(grouped.sequentialParts).toEqual([{ part: sequential, idx: 2 }]);
- expect(grouped.parallelSections[0]?.columns[0]?.parts).toEqual([
- { part: parallel, idx: 10_000 },
+ expect(grouped.parallelSections).toHaveLength(1);
+ expect(grouped.parallelSections[0]?.columns.map((column) => column.agentId)).toEqual([
+ 'agent_a',
]);
+ expect(grouped.sequentialParts).toEqual([]);
});
});
diff --git a/client/src/components/Chat/Messages/MultiMessage.tsx b/client/src/components/Chat/Messages/MultiMessage.tsx
index 5af59b7fa9..5a2d8aa67f 100644
--- a/client/src/components/Chat/Messages/MultiMessage.tsx
+++ b/client/src/components/Chat/Messages/MultiMessage.tsx
@@ -7,6 +7,7 @@ import type { TMessageProps } from '~/common';
import EventSubagentActivityGroup from '~/components/Chat/Subagents/EventSubagentActivityGroup';
import MessageContent from '~/components/Messages/MessageContent';
import { useRowMountWindow } from '~/hooks/Messages';
+import { hasParallelLanes } from '~/utils/lanes';
import MessageParts from './MessageParts';
import Message from './Message';
import store from '~/store';
@@ -199,8 +200,7 @@ function MultiMessage({
}
const isEditingActivityAnchor =
typeof currentEditId === 'string' && activityParentMessageIds.includes(currentEditId);
- const hasParallelContent =
- !message.isCreatedByUser && message.content?.some((part) => part?.groupId != null) === true;
+ const hasParallelContent = !message.isCreatedByUser && hasParallelLanes(message.content);
/**
* The child recursion is a sibling of the row (not rendered inside it), so a
diff --git a/client/src/components/Chat/Messages/__tests__/MultiMessage.spec.tsx b/client/src/components/Chat/Messages/__tests__/MultiMessage.spec.tsx
index 7933482fd8..d5bf5ce960 100644
--- a/client/src/components/Chat/Messages/__tests__/MultiMessage.spec.tsx
+++ b/client/src/components/Chat/Messages/__tests__/MultiMessage.spec.tsx
@@ -170,7 +170,11 @@ describe('MultiMessage sibling selection', () => {
it('matches the wider layout of a parallel assistant response', () => {
const assistant = {
...msg('assistant'),
- content: [{ type: 'text', text: 'answer', groupId: 'parallel-group' }],
+ /** Two agents, so the response really does lay out columns. */
+ content: [
+ { type: 'text', text: 'primary', agentId: 'agent_a', groupId: 1 },
+ { type: 'text', text: 'added', agentId: 'agent_b____1', groupId: 1 },
+ ],
} as unknown as TMessage;
render(
@@ -190,6 +194,35 @@ describe('MultiMessage sibling selection', () => {
);
});
+ it('keeps the standard width when a group is backed by one agent', () => {
+ /** A multi-agent graph stamps a group id on every starting node, so an
+ * ordinary agent that merely has subagents available carries one on its
+ * OWN output. Widening for columns that never arrive is the regression. */
+ const assistant = {
+ ...msg('assistant'),
+ content: [
+ { type: 'text', text: 'thinking', agentId: 'agent_a', groupId: 1 },
+ { type: 'text', text: 'answer', agentId: 'agent_a', groupId: 1 },
+ ],
+ } as unknown as TMessage;
+
+ render(
+ <RecoilRoot>
+ <MultiMessage
+ messageId="parent-1"
+ messagesTree={[assistant]}
+ currentEditId={null}
+ setCurrentEditId={jest.fn()}
+ />
+ </RecoilRoot>,
+ );
+
+ expect(screen.getByTestId('event-subagent-activity')).toHaveAttribute(
+ 'data-has-parallel-content',
+ 'false',
+ );
+ });
+
it('renders assistant content containing an undefined streaming placeholder', () => {
const assistant = {
...msg('assistant'),
diff --git a/client/src/hooks/Messages/useContentMetadata.ts b/client/src/hooks/Messages/useContentMetadata.ts
index 117ac97874..6387514e6a 100644
--- a/client/src/hooks/Messages/useContentMetadata.ts
+++ b/client/src/hooks/Messages/useContentMetadata.ts
@@ -1,14 +1,16 @@
import { useMemo } from 'react';
import type { TMessage } from 'librechat-data-provider';
+import { hasParallelLanes } from '~/utils/lanes';
export type ContentMetadataResult = {
- /** Whether the message has parallel content (content with groupId) */
+ /** Whether the message renders agent columns side by side */
hasParallelContent: boolean;
};
/**
- * Hook to check if a message has parallel content.
- * Returns whether any content part has a groupId.
+ * Hook to check if a message has parallel content — content the renderer lays
+ * out as columns. Widens the message row, so it asks the same question the
+ * renderer does: a group id backed by a single agent is not parallel content.
*
* @param message - The message to check
* @returns ContentMetadataResult with hasParallelContent boolean
@@ -22,9 +24,6 @@ export default function useContentMetadata(
return { hasParallelContent: false };
}
- // Check if any content part has a groupId (TMessageContentParts now includes ContentMetadata)
- const hasParallelContent = content.some((part) => part?.groupId != null);
-
- return { hasParallelContent };
+ return { hasParallelContent: hasParallelLanes(content) };
}, [message?.content]);
}
diff --git a/client/src/utils/__tests__/activityLabels.spec.ts b/client/src/utils/__tests__/activityLabels.spec.ts
index fd4be7b3fd..9c526ee26c 100644
--- a/client/src/utils/__tests__/activityLabels.spec.ts
+++ b/client/src/utils/__tests__/activityLabels.spec.ts
@@ -653,22 +653,48 @@ describe('groupActivityPhases — synthesized folds', () => {
expect(foldOf(failed)?.labelPart.status).toBe('failed');
});
- it('stands down when the message carries parallel content', () => {
- const parallel = {
- ...(toolPart('t2') as object),
- groupId: 'g1',
- } as unknown as TMessageContentParts;
+ const inLane = (part: TMessageContentParts, agentId: string): TMessageContentParts =>
+ ({ ...(part as object), agentId, groupId: 1 }) as unknown as TMessageContentParts;
+ it('stands down when the message carries parallel content', () => {
expect(
groupActivityPhases([
- toolPart('t1'),
- childLabel('Read the config'),
- parallel,
- childLabel('Checked the callers'),
+ inLane(toolPart('t1'), 'agent_a'),
+ inLane(childLabel('Read the config'), 'agent_a'),
+ inLane(toolPart('t2'), 'agent_b'),
+ inLane(childLabel('Checked the callers'), 'agent_b'),
]),
).toBeUndefined();
});
+ it('folds a labeled run whose group id is backed by one agent', () => {
+ /** A multi-agent graph stamps a group id on every starting node, so an
+ * agent that merely has subagents available carries one on its own
+ * output. It renders sequentially, so it folds like any other run. */
+ const segments = groupActivityPhases([
+ inLane(toolPart('t1'), 'agent_a'),
+ inLane(childLabel('Read the config'), 'agent_a'),
+ inLane(toolPart('t2'), 'agent_a'),
+ inLane(childLabel('Checked the callers'), 'agent_a'),
+ ]);
+
+ expect(foldOf(segments)).toMatchObject({ synthesized: true, contentIndices: [0, 1, 2, 3] });
+ });
+
+ it("takes the caller's lane scan instead of repeating it", () => {
+ /** `ContentParts` already scans the message for lanes; passing the answer
+ * keeps a streamed delta to one pass, and must decide identically. */
+ const run = [
+ inLane(toolPart('t1'), 'agent_a'),
+ inLane(childLabel('Read the config'), 'agent_a'),
+ inLane(toolPart('t2'), 'agent_a'),
+ inLane(childLabel('Checked the callers'), 'agent_a'),
+ ];
+
+ expect(foldOf(groupActivityPhases(run, new Set()))).toMatchObject({ synthesized: true });
+ expect(groupActivityPhases(run, new Set([1]))).toBeUndefined();
+ });
+
it('never folds a span a server marker already claims', () => {
const phase = labelPart({ activity_label: 'Reviewed the release paths', pending: false });
Object.assign(phase, {
diff --git a/client/src/utils/__tests__/lanes.spec.ts b/client/src/utils/__tests__/lanes.spec.ts
new file mode 100644
index 0000000000..4297d1084a
--- /dev/null
+++ b/client/src/utils/__tests__/lanes.spec.ts
@@ -0,0 +1,112 @@
+import { ContentTypes } from 'librechat-data-provider';
+import type { TMessageContentParts } from 'librechat-data-provider';
+import { hasParallelLanes, laneAgentsByGroup, parallelLaneGroups } from '../lanes';
+
+const lanePart = (agentId?: string, groupId?: number, text = 'output'): TMessageContentParts =>
+ ({
+ type: ContentTypes.TEXT,
+ text,
+ ...(agentId == null ? {} : { agentId }),
+ ...(groupId == null ? {} : { groupId }),
+ }) as unknown as TMessageContentParts;
+
+const placeholder = (agentId: string, groupId: number): TMessageContentParts =>
+ ({ type: '', agentId, groupId }) as unknown as TMessageContentParts;
+
+describe('hasParallelLanes', () => {
+ it('is false without any group id', () => {
+ expect(hasParallelLanes([lanePart('agent_a'), lanePart('agent_a')])).toBe(false);
+ });
+
+ it('is false for a group backed by one agent', () => {
+ /** A multi-agent graph assigns a group id to every starting node, so an
+ * agent that merely has subagents available carries one on its OWN
+ * output — with no second column it is not parallel content. */
+ expect(hasParallelLanes([lanePart('agent_a', 1), lanePart('agent_a', 1)])).toBe(false);
+ });
+
+ it('is true once a second agent shares the group', () => {
+ expect(hasParallelLanes([lanePart('agent_a', 1), lanePart('agent_b', 1)])).toBe(true);
+ });
+
+ it('counts placeholder columns, which a dual run seeds before any content', () => {
+ expect(hasParallelLanes([placeholder('agent_a', 1), placeholder('agent_b____1', 1)])).toBe(
+ true,
+ );
+ });
+
+ it('shares one column across parts that carry no agent id', () => {
+ expect(hasParallelLanes([lanePart(undefined, 1), lanePart(undefined, 1)])).toBe(false);
+ });
+
+ it('ignores holes in a sparse in-run content array', () => {
+ const sparse: Array<TMessageContentParts | undefined> = [];
+ sparse[0] = lanePart('agent_a', 1);
+ sparse[4] = lanePart('agent_b', 1);
+ expect(hasParallelLanes(sparse)).toBe(true);
+ expect(laneAgentsByGroup(sparse).get(1)?.size).toBe(2);
+ });
+
+ it('separates lanes by group id', () => {
+ const lanes = laneAgentsByGroup([
+ lanePart('agent_a', 1),
+ lanePart('agent_b', 1),
+ lanePart('agent_c', 2),
+ ]);
+ expect(lanes.get(1)?.size).toBe(2);
+ expect(lanes.get(2)?.size).toBe(1);
+ });
+
+ it('collects only the group ids that render as columns', () => {
+ const groups = parallelLaneGroups([
+ lanePart('agent_a', 1),
+ lanePart('agent_b', 1),
+ lanePart('agent_c', 2),
+ ]);
+ expect([...groups]).toEqual([1]);
+ });
+
+ it('does not count a part with no agent id as a second lane', () => {
+ /** `agentId` and `groupId` are independently optional on a run step, so a
+ * group can hold a part the server never attributed. It shares the
+ * unattributed column, but it is not another agent to compare against. */
+ const content = [lanePart('agent_a', 1), lanePart(undefined, 1)];
+ expect(hasParallelLanes(content)).toBe(false);
+ expect([...parallelLaneGroups(content)]).toEqual([]);
+ expect(laneAgentsByGroup(content).get(1)?.size).toBe(2);
+ });
+
+ it('does not let a sequential handoff marker claim a lane', () => {
+ /** `useStepHandler` stamps an agent update with the CURRENT group id even
+ * when the destination's own run steps carry none, so the marker names a
+ * second agent inside a single-lane group. Counting it split one run into
+ * columns at the handoff. */
+ const handoff = {
+ type: ContentTypes.AGENT_UPDATE,
+ [ContentTypes.AGENT_UPDATE]: { agentId: 'agent_b' },
+ agentId: 'agent_b',
+ groupId: 1,
+ } as unknown as TMessageContentParts;
+ const content = [lanePart('agent_a', 1), handoff];
+
+ expect(hasParallelLanes(content)).toBe(false);
+ expect(laneAgentsByGroup(content).get(1)?.size).toBe(1);
+ });
+
+ it('scans a content array once, and a new array afresh', () => {
+ /** One message is scanned by `MultiMessage`, `useContentMetadata` and
+ * `ContentParts` in a single render pass. */
+ const content = [lanePart('agent_a', 1), lanePart('agent_b', 1)];
+
+ expect(laneAgentsByGroup(content)).toBe(laneAgentsByGroup(content));
+ expect(laneAgentsByGroup([...content])).not.toBe(laneAgentsByGroup(content));
+ });
+
+ it('answers for a slice from the message-level groups it is given', () => {
+ /** The slice holds one agent of group 1; the message knows better. */
+ const slice = [lanePart('agent_a', 1)];
+ expect(hasParallelLanes(slice)).toBe(false);
+ expect(hasParallelLanes(slice, new Set([1]))).toBe(true);
+ expect(hasParallelLanes(slice, new Set([2]))).toBe(false);
+ });
+});
diff --git a/client/src/utils/activityLabels.ts b/client/src/utils/activityLabels.ts
index 49d49d8d74..25b215dd93 100644
--- a/client/src/utils/activityLabels.ts
+++ b/client/src/utils/activityLabels.ts
@@ -1,5 +1,6 @@
import { Constants, ContentTypes } from 'librechat-data-provider';
import type { TMessage, TActivityLabelEvent, TMessageContentParts } from 'librechat-data-provider';
+import { hasParallelLanes } from '~/utils/lanes';
type ActivityLabelPart = Extract<TMessageContentParts, { type: ContentTypes.ACTIVITY_LABEL }> & {
activity_label_type?: 'phase';
@@ -412,6 +413,7 @@ function synthesizeActivityFolds(
*/
export function groupActivityPhases(
content: Array<TMessageContentParts | undefined> | undefined,
+ laneGroups?: ReadonlySet<number>,
): ActivityPhaseSegment[] | undefined {
if (!content) {
return undefined;
@@ -420,10 +422,14 @@ export function groupActivityPhases(
/** Parallel columns lay their own activity out and are rendered by
* `ParallelContentRenderer`, which a synthesized card would pull onto the
* phase path. Server markers may still claim parallel spans; only the
- * client-built folds stand down. */
- const foldable = !definedIndices.some(
- (index) => (content[index] as { groupId?: string } | undefined)?.groupId != null,
- );
+ * client-built folds stand down. A group id alone is not enough: one that
+ * resolves to a single agent renders sequentially, so it folds like any
+ * other run.
+ *
+ * `laneGroups` is the caller's own lane scan over this same content, and
+ * content is rewritten on every streamed delta — taking the answer rather
+ * than repeating the scan keeps a render to one pass. */
+ const foldable = laneGroups != null ? laneGroups.size === 0 : !hasParallelLanes(content);
const completed = definedIndices
.map((index) => ({ part: getActivityLabelPart(content[index]), index }))
.filter(
diff --git a/client/src/utils/lanes.ts b/client/src/utils/lanes.ts
new file mode 100644
index 0000000000..78a83603a2
--- /dev/null
+++ b/client/src/utils/lanes.ts
@@ -0,0 +1,127 @@
+import { ContentTypes } from 'librechat-data-provider';
+import type { TMessageContentParts } from 'librechat-data-provider';
+
+/** Column key for a lane part that carries no agent id of its own. */
+export const UNATTRIBUTED_LANE = 'unknown';
+
+/**
+ * Lanes an agent actually claims. `agentId` and `groupId` are independently
+ * optional on a run step, so a group can hold a part with no agent of its
+ * own; it shares the unattributed column, but it is NOT a second agent —
+ * counting the sentinel would let one agent plus one metadata-less part
+ * masquerade as a comparison.
+ */
+export function attributedLaneCount(agents: ReadonlySet<string>): number {
+ return agents.has(UNATTRIBUTED_LANE) ? agents.size - 1 : agents.size;
+}
+
+/**
+ * An agent update is a transition marker, not lane content: it names the agent
+ * the run hands off TO. `useStepHandler` stamps it with the current group id
+ * even when the destination's own steps carry none, so counting it would read
+ * a sequential handoff as a second lane and split one run into columns.
+ */
+export function isLaneMarkerPart(part: TMessageContentParts | undefined): boolean {
+ return part?.type === ContentTypes.AGENT_UPDATE;
+}
+
+/**
+ * Columns a lane group needs before it renders as columns.
+ *
+ * `groupId` marks content the server ran as one wave, but a wave is only ever
+ * shown as a side-by-side COMPARISON — the added-conversation feature seeds a
+ * placeholder per agent so both columns exist from the first render. A group
+ * that resolves to one agent has nothing to compare against, and rendering it
+ * as a lane costs more than a redundant border: lanes draw their own author
+ * header and branch control (restating the message's own sender) and they
+ * render raw parts, which opts those parts out of tool grouping, activity
+ * label headers and phase folds, while the message row widens for columns
+ * that never arrive.
+ *
+ * A lone group is not exotic. A multi-agent graph assigns a group id to every
+ * starting node, so an ordinary agent that merely has subagents available
+ * carries one on its OWN output.
+ */
+export const MIN_PARALLEL_LANES = 2;
+
+/**
+ * Distinct lane agents per group id. Mirrors the column derivation in
+ * `groupParallelContent`: a placeholder (empty `type`) establishes its agent's
+ * column without contributing content, and a part with no agent id of its own
+ * shares the single unattributed column.
+ */
+const laneAgentsCache = new WeakMap<object, ReadonlyMap<number, ReadonlySet<string>>>();
+
+export function laneAgentsByGroup(
+ content: ReadonlyArray<TMessageContentParts | undefined> | undefined,
+): ReadonlyMap<number, ReadonlySet<string>> {
+ if (content == null) {
+ return new Map();
+ }
+ /** One message is scanned by `MultiMessage`, `useContentMetadata` and
+ * `ContentParts` in a single render pass. Keying on the array itself
+ * collapses those to one traversal and is exactly as fresh as the render:
+ * every streamed delta rebuilds `content` (`[...(message.content || [])]`
+ * in `useStepHandler`), and an update that kept the identity would not
+ * re-render either. Entries die with the array they key. */
+ const cached = laneAgentsCache.get(content);
+ if (cached != null) {
+ return cached;
+ }
+ const lanes = new Map<number, Set<string>>();
+ content.forEach((part) => {
+ if (part?.groupId == null || isLaneMarkerPart(part)) {
+ return;
+ }
+ const agents = lanes.get(part.groupId) ?? new Set<string>();
+ agents.add(part.agentId ?? UNATTRIBUTED_LANE);
+ lanes.set(part.groupId, agents);
+ });
+ laneAgentsCache.set(content, lanes);
+ return lanes;
+}
+
+/**
+ * The group ids that render as columns, resolved over WHOLE message content.
+ *
+ * Lane cardinality is a property of the message, not of the slice in front of
+ * you: a phase marker can partition a real two-agent group so that one slice
+ * holds a single agent's parts. Counting that slice on its own would demote it
+ * and drop the per-agent attribution its sibling slice still shows, so every
+ * slice asks this set instead of recounting.
+ */
+export function parallelLaneGroups(
+ content: ReadonlyArray<TMessageContentParts | undefined> | undefined,
+): Set<number> {
+ const groups = new Set<number>();
+ for (const [groupId, agents] of laneAgentsByGroup(content)) {
+ if (attributedLaneCount(agents) >= MIN_PARALLEL_LANES) {
+ groups.add(groupId);
+ }
+ }
+ return groups;
+}
+
+/**
+ * True when some group is backed by enough distinct agents to render as
+ * columns. The predicate every consumer of "does this message have parallel
+ * content" asks, so a lone group renders exactly like content with no group
+ * id at all.
+ *
+ * `laneGroups` carries the message-level answer into a phase slice; without it
+ * the content passed in is counted on its own.
+ */
+export function hasParallelLanes(
+ content: ReadonlyArray<TMessageContentParts | undefined> | undefined,
+ laneGroups?: ReadonlySet<number>,
+): boolean {
+ if (laneGroups != null) {
+ return content?.some((part) => part?.groupId != null && laneGroups.has(part.groupId)) === true;
+ }
+ for (const agents of laneAgentsByGroup(content).values()) {
+ if (attributedLaneCount(agents) >= MIN_PARALLEL_LANES) {
+ return true;
+ }
+ }
+ return false;
+}