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

🪪 feat: Name and Face Subagents Like Main Chat Turns (#16692)

Danny Aviladc375a8e1cc7
diff --git a/client/src/components/Chat/Messages/Content/Parts/SubagentCall.tsx b/client/src/components/Chat/Messages/Content/Parts/SubagentCall.tsx
index c5bef1a9c7..f7a38cb4c2 100644
--- a/client/src/components/Chat/Messages/Content/Parts/SubagentCall.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/SubagentCall.tsx
@@ -14,8 +14,11 @@ import {
subagentProgressKey,
useSubagentProgress,
} from '~/components/Chat/Subagents/state';
+import { useParentSubagents } from '~/components/Chat/Subagents/ParentSubagentsProvider';
+import { isSelfSpawn as isSelfSpawnType } from '~/components/Chat/Subagents/author';
import { adaptLivePersistedActivity } from '~/components/Chat/Subagents/adapters';
import { resolveSubagentAgentId } from '~/components/Chat/Subagents/identity';
+import { subagentStatusLabelKey } from '~/components/Chat/Subagents/status';
import { useOpenSubagentPanel } from '~/components/Chat/Subagents/surface';
import { MessageContext } from '~/Providers/MessageContext';
import { useShareContext } from '~/Providers/ShareContext';
@@ -193,7 +196,10 @@ export default function SubagentCall({
isSharedConvo !== true && backgroundHandle != null && parentConversationId !== '';
const subagentType = progress?.subagentType ?? extractSubagentType(args);
- const isSelfSpawn = subagentType === 'self';
+ const isSelfSpawn = isSelfSpawnType(
+ subagentType,
+ progress?.subagentKind ?? subagentIdentity?.subagentKind,
+ );
const subagentAgentId = resolveSubagentAgentId(progress, subagentIdentity);
const subagentAgent = subagentAgentId ? agentsMap?.[subagentAgentId] : undefined;
/**
@@ -280,12 +286,14 @@ export default function SubagentCall({
return localize('com_ui_subagent_complete');
};
const headerText = getHeaderText();
- /** Muted sub-label shown to the right of the base label: the
- * configured agent name for named subagents. Self-spawns omit it
- * (redundant — the header already says "agent") as do cases where
- * the name isn't resolvable (agent map miss). */
+ /** A named subagent leads with its own name and face, the way its turns read
+ * in main chat, and the verb or status follows it muted. Self-spawns keep
+ * the verb alone — the name would be the agent this card already sits
+ * under — as do agents the map cannot resolve. */
const subagentNameLabel = !isSelfSpawn && subagentAgent?.name ? subagentAgent.name : '';
+ const cardLabel = subagentNameLabel ? `${subagentNameLabel}: ${headerText}` : headerText;
+
const canOpenDetails = useMemo(() => {
const fallbackActivity = adaptLivePersistedActivity({
title: '',
@@ -410,9 +418,9 @@ export default function SubagentCall({
canOpenDetails ? 'group' : 'cursor-default opacity-80',
running && !detachedStatusUnknown && 'animate-pulse-slow',
)}
- aria-label={headerText}
+ aria-label={detachedStatusUnknown ? undefined : cardLabel}
>
- <div className="text-text-primary flex items-center gap-2 text-sm font-medium">
+ <div className="text-text-primary flex w-full min-w-0 items-center gap-2 text-sm font-medium">
<div
className={cn(
FOLD_GLYPH_CLASS,
@@ -435,18 +443,47 @@ export default function SubagentCall({
<Users size={14} />
)}
</div>
- <span className="min-w-0 truncate" title={headerText}>
- {headerText}
- </span>
{subagentNameLabel ? (
- <span
- className="text-text-secondary min-w-0 flex-1 truncate font-normal"
- title={subagentNameLabel}
- >
- {subagentNameLabel}
- </span>
+ <>
+ <span
+ className="max-w-[50%] min-w-0 shrink truncate font-semibold"
+ title={subagentNameLabel}
+ >
+ {subagentNameLabel}
+ </span>
+ <span
+ className="text-text-secondary min-w-0 flex-1 truncate font-normal"
+ title={detachedStatusUnknown ? undefined : headerText}
+ >
+ {detachedStatusUnknown && backgroundHandle != null ? (
+ <DetachedTaskStatus
+ threadId={backgroundHandle.subagent_thread_id}
+ taskId={backgroundHandle.background_task_id}
+ fallback={headerText}
+ />
+ ) : (
+ headerText
+ )}
+ </span>
+ </>
) : (
- <span className="flex-1" />
+ <>
+ <span
+ className="min-w-0 truncate"
+ title={detachedStatusUnknown ? undefined : headerText}
+ >
+ {detachedStatusUnknown && backgroundHandle != null ? (
+ <DetachedTaskStatus
+ threadId={backgroundHandle.subagent_thread_id}
+ taskId={backgroundHandle.background_task_id}
+ fallback={headerText}
+ />
+ ) : (
+ headerText
+ )}
+ </span>
+ <span className="flex-1" />
+ </>
)}
{canOpenDetails && (
<ChevronRight
@@ -474,6 +511,30 @@ export default function SubagentCall({
);
}
+/**
+ * A detached child's status as the parent's subagent index last reported it.
+ * Its own leaf so an index refresh re-renders this text alone, never the card
+ * or the message around it; with no indexed answer the card keeps its neutral
+ * label rather than guessing.
+ */
+function DetachedTaskStatus({
+ threadId,
+ taskId,
+ fallback,
+}: {
+ threadId: string;
+ taskId: string;
+ fallback: string;
+}) {
+ const localize = useLocalize();
+ const { byThreadId } = useParentSubagents();
+ const child = byThreadId.get(threadId);
+ const status =
+ child?.tasks.find((task) => task.taskId === taskId)?.status ??
+ (child?.latestTaskId === taskId ? child.status : undefined);
+ return <>{status == null ? fallback : localize(subagentStatusLabelKey(status))}</>;
+}
+
function extractSubagentType(args: SubagentCallProps['args']): string {
if (typeof args === 'string') {
try {
diff --git a/client/src/components/Chat/Messages/Content/Parts/__tests__/SubagentCall.test.tsx b/client/src/components/Chat/Messages/Content/Parts/__tests__/SubagentCall.test.tsx
index 9ab4124e92..f1c981b3dd 100644
--- a/client/src/components/Chat/Messages/Content/Parts/__tests__/SubagentCall.test.tsx
+++ b/client/src/components/Chat/Messages/Content/Parts/__tests__/SubagentCall.test.tsx
@@ -3,7 +3,12 @@ import { RecoilRoot } from 'recoil';
import { useAtomValue, useStore } from 'jotai';
import { MemoryRouter } from 'react-router-dom';
import { act, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
-import type { SubagentUpdateEvent, SubagentIdentity, PartMetadata } from 'librechat-data-provider';
+import type {
+ PartMetadata,
+ SubagentIdentity,
+ SubagentUpdateEvent,
+ ParentSubagentSummary,
+} from 'librechat-data-provider';
import type {
SubagentAggregatorState,
SubagentContentPart,
@@ -29,6 +34,7 @@ import { FOLD_GLYPH_SELECTOR } from '../../rows';
import { litFoldPath } from '../../rail';
const mockMCPServerNames: string[] = [];
+let mockIndexedChildren = new Map<string, ParentSubagentSummary>();
jest.mock('~/hooks', () => ({
useLocalize:
@@ -59,16 +65,24 @@ jest.mock('../Attachment', () => ({
jest.mock('lucide-react', () => ({
// eslint-disable-next-line i18next/no-literal-string
- ChevronRight: () => <span>chevron</span>,
+ ChevronRight: () => <span aria-hidden="true">chevron</span>,
// eslint-disable-next-line i18next/no-literal-string
- Users: () => <span>users</span>,
+ Users: () => <span aria-hidden="true">users</span>,
}));
jest.mock('~/Providers', () => ({
useAgentsMapContext: () => ({
'agent-1': { id: 'agent-1', name: 'Analyst One', avatar: { filepath: '/analyst.png' } },
+ agent_reviewer: {
+ id: 'agent_reviewer',
+ name: 'Code Reviewer',
+ avatar: { filepath: '/reviewer.png' },
+ },
}),
}));
+jest.mock('~/components/Chat/Subagents/ParentSubagentsProvider', () => ({
+ useParentSubagents: () => ({ byThreadId: mockIndexedChildren }),
+}));
jest.mock('~/components/Share/MessageIcon', () => ({
__esModule: true,
default: ({ agent }: { agent: { name: string; avatar: { filepath: string } } }) => (
@@ -85,6 +99,7 @@ jest.mock('~/utils', () => ({
afterEach(() => {
jest.useRealTimers();
mockMCPServerNames.length = 0;
+ mockIndexedChildren = new Map();
});
function foldEvents(events: SubagentUpdateEvent[]): {
@@ -505,6 +520,100 @@ describe('SubagentCall', () => {
expect(rendered.getSelection()?.legacyOutput).toBeUndefined();
});
+ it('leads a detached agent card with its name, face and the indexed task status', () => {
+ const output = JSON.stringify({
+ background_task_id: 'task-1',
+ subagent_thread_id: 'child-thread-1',
+ tool: 'subagent',
+ subagent_type: 'agent_reviewer',
+ status: 'running',
+ message:
+ 'Started subagent "agent_reviewer" background task. Poll the host background-task tool with background_task_id "task-1".',
+ });
+ mockIndexedChildren = new Map([
+ [
+ 'child-thread-1',
+ {
+ threadId: 'child-thread-1',
+ status: 'completed',
+ latestTaskId: 'task-1',
+ tasks: [{ taskId: 'task-1', status: 'completed' }],
+ } as ParentSubagentSummary,
+ ],
+ ]);
+ /** Saved identity disambiguates agent ids from graph aliases. */
+ renderWithState({
+ toolCallId: 'named-detached',
+ initialProgress: 1,
+ subagentIdentity: { subagentKind: 'agent', subagentAgentId: 'agent_reviewer' },
+ output,
+ toolArgs: { subagent_type: 'agent_reviewer', run_in_background: true },
+ });
+
+ const card = screen.getByRole('button', {
+ name: 'Code Reviewer com_ui_subagent_thread_status_completed',
+ });
+ expect(within(card).getByText('Code Reviewer')).toBeInTheDocument();
+ expect(within(card).getByRole('img', { hidden: true })).toHaveAttribute('src', '/reviewer.png');
+ expect(within(card).getByText('com_ui_subagent_thread_status_completed')).toBeInTheDocument();
+ expect(within(card).queryByText(/agent_reviewer/)).not.toBeInTheDocument();
+ });
+
+ it.each(['self', 'researcher', 'agent_missing'])(
+ 'exposes the indexed outcome for an unnamed detached %s child',
+ (subagentType) => {
+ mockIndexedChildren = new Map([
+ [
+ 'child-thread-1',
+ {
+ threadId: 'child-thread-1',
+ latestTaskId: 'task-1',
+ status: 'failed',
+ tasks: [{ taskId: 'task-1', status: 'failed' }],
+ } as ParentSubagentSummary,
+ ],
+ ]);
+ renderWithState({
+ toolCallId: 'unnamed-detached',
+ initialProgress: 1,
+ toolArgs: { subagent_type: subagentType, run_in_background: true },
+ output: JSON.stringify({
+ background_task_id: 'task-1',
+ subagent_thread_id: 'child-thread-1',
+ tool: 'subagent',
+ subagent_type: subagentType,
+ status: 'running',
+ message: 'Started subagent background task. Poll with background_task_id task-1.',
+ }),
+ });
+ expect(
+ screen.getByRole('button', { name: 'com_ui_subagent_thread_status_failed' }),
+ ).not.toHaveAttribute('aria-label');
+ },
+ );
+
+ it('keeps the neutral label for a detached child the index has not reported', () => {
+ const output = JSON.stringify({
+ background_task_id: 'task-1',
+ subagent_thread_id: 'child-thread-1',
+ tool: 'subagent',
+ subagent_type: 'agent_reviewer',
+ status: 'running',
+ message:
+ 'Started subagent "agent_reviewer" background task. Poll the host background-task tool with background_task_id "task-1".',
+ });
+ renderWithState({
+ toolCallId: 'unindexed-detached',
+ initialProgress: 1,
+ subagentIdentity: { subagentKind: 'agent', subagentAgentId: 'agent_reviewer' },
+ output,
+ toolArgs: { subagent_type: 'agent_reviewer', run_in_background: true },
+ });
+
+ const card = screen.getByRole('button', { name: 'Code Reviewer Agent activity' });
+ expect(within(card).getByText('Agent activity')).toBeInTheDocument();
+ });
+
it('disables an inaccessible nested detached drilldown without renderable activity', () => {
const output = JSON.stringify({
background_task_id: 'task-1',
diff --git a/client/src/components/Chat/Messages/Content/Parts/wakeup.ts b/client/src/components/Chat/Messages/Content/Parts/wakeup.ts
index 1b90e90ee6..b91106fce8 100644
--- a/client/src/components/Chat/Messages/Content/Parts/wakeup.ts
+++ b/client/src/components/Chat/Messages/Content/Parts/wakeup.ts
@@ -1,3 +1,5 @@
+import type { TMessage } from 'librechat-data-provider';
+
export type WakeupTaskStatus = 'completed' | 'error' | 'cancelled';
export type WakeupTask = {
@@ -123,3 +125,12 @@ export function parseWakeupText(text?: string | null): WakeupDisplay | null {
}
return { kind: 'background_tool', tasks: tasks as WakeupTask[] };
}
+
+/** User-submitted lookalikes are ordinary prompts. Older host wake-ups may omit
+ * provenance, so retain their existing strict header/payload compatibility. */
+export function parseWakeupMessage(
+ message: Pick<TMessage, 'text' | 'isCreatedByUser' | 'isUserSubmitted'> | undefined,
+): WakeupDisplay | null {
+ if (message?.isCreatedByUser !== true || message.isUserSubmitted === true) return null;
+ return parseWakeupText(message.text);
+}
diff --git a/client/src/components/Chat/Messages/Content/Wakeup.tsx b/client/src/components/Chat/Messages/Content/Wakeup.tsx
index b6345cd244..a918d656d8 100644
--- a/client/src/components/Chat/Messages/Content/Wakeup.tsx
+++ b/client/src/components/Chat/Messages/Content/Wakeup.tsx
@@ -1,5 +1,4 @@
import { memo, useCallback, useMemo, useState } from 'react';
-import { Users } from 'lucide-react';
import { useRecoilValue } from 'recoil';
import { Button } from '@librechat/client';
import type { WakeupDisplay, WakeupTask } from './Parts/wakeup';
@@ -27,6 +26,17 @@ const SUBAGENT_HEADER_KEYS = {
const threadStatus = (status: WakeupTask['status']) =>
status === 'error' ? ('failed' as const) : status;
+/** The outcome glyph, colored for success only: a failure already paints the
+ * header label with the warning role. */
+function SubagentOutcomeIcon({ status }: { status: ReturnType<typeof threadStatus> }) {
+ const StatusIcon = subagentStatusIcon(status);
+ return (
+ <SystemEventIcon>
+ <StatusIcon size={14} className={cn(status === 'completed' && 'text-status-success')} />
+ </SystemEventIcon>
+ );
+}
+
function WakeupTaskCard({
task,
conversationId,
@@ -47,7 +57,6 @@ function WakeupTaskCard({
const { selection, open: openActivity } = useSubagentTaskPanel(durableTask, conversationId);
const status = threadStatus(task.status);
const StatusIcon = subagentStatusIcon(status);
- const title = task.subagentType ?? '';
const hasResult = task.result.trim() !== '';
return (
@@ -58,7 +67,6 @@ function WakeupTaskCard({
aria-hidden
className={cn('shrink-0', status === 'failed' && 'text-status-error')}
/>
- {title !== '' && <span className="min-w-0 truncate font-medium">{title}</span>}
<span className="shrink-0">{localize(subagentStatusLabelKey(status))}</span>
{selection != null && openActivity != null && (
/** The trigger identity attributes let the panel's close handler
@@ -129,9 +137,11 @@ const Wakeup = memo(function Wakeup({
return localize('com_ui_wakeup_task_finished');
}, [display.kind, display.tasks, localize]);
+ /** A subagent's report is headed by the agent's own name and face on its row,
+ * so its header line carries only the outcome. */
const nameSummary = useMemo(() => {
if (display.kind === 'subagent') {
- return display.tasks[0]?.subagentType ?? '';
+ return '';
}
const seen = new Set<string>();
const labels: string[] = [];
@@ -167,9 +177,7 @@ const Wakeup = memo(function Wakeup({
live
icon={
display.kind === 'subagent' ? (
- <SystemEventIcon>
- <Users size={14} />
- </SystemEventIcon>
+ <SubagentOutcomeIcon status={threadStatus(display.tasks[0]?.status ?? 'completed')} />
) : (
<StackedToolIcons toolNames={toolIconNames} mcpIconMap={mcpIconMap} maxIcons={4} />
)
diff --git a/client/src/components/Chat/Messages/MessageIcon.tsx b/client/src/components/Chat/Messages/MessageIcon.tsx
index a5a395473f..83f2bc1dfe 100644
--- a/client/src/components/Chat/Messages/MessageIcon.tsx
+++ b/client/src/components/Chat/Messages/MessageIcon.tsx
@@ -3,6 +3,7 @@ import { getEndpointField } from 'librechat-data-provider';
import type { Assistant, Agent } from 'librechat-data-provider';
import type { TMessageIcon } from '~/common';
import ConvoIconURL from '~/components/Endpoints/ConvoIconURL';
+import { useShareContext } from '~/Providers/ShareContext';
import { useGetEndpointsQuery } from '~/data-provider';
import Icon from '~/components/Endpoints/Icon';
import { isImageURL } from '~/utils/icons';
@@ -41,7 +42,8 @@ export function arePropsEqual(prev: MessageIconProps, next: MessageIconProps): b
}
const MessageIcon = memo(({ iconData, assistant, agent }: MessageIconProps) => {
- const { data: endpointsConfig } = useGetEndpointsQuery();
+ const { isSharedConvo } = useShareContext();
+ const { data: endpointsConfig } = useGetEndpointsQuery({ enabled: isSharedConvo !== true });
const agentName = agent?.name ?? '';
const agentAvatar = agent?.avatar?.filepath ?? '';
diff --git a/client/src/components/Chat/Messages/MinimalHoverButtons.tsx b/client/src/components/Chat/Messages/MinimalHoverButtons.tsx
index ef5e6a73f9..6754727f48 100644
--- a/client/src/components/Chat/Messages/MinimalHoverButtons.tsx
+++ b/client/src/components/Chat/Messages/MinimalHoverButtons.tsx
@@ -3,7 +3,12 @@ import { Copy, Check } from 'lucide';
import { Button, MorphIcon, TooltipAnchor } from '@librechat/client';
import type { TMessage, SearchResultData } from 'librechat-data-provider';
import type { MarkdownVariant } from '~/utils/richtext';
-import { useLocalize, useCopyMessageToClipboard, hasCopyableText } from '~/hooks';
+import {
+ useLocalize,
+ useCopyMessageToClipboard,
+ getMessageClipboardSource,
+ hasCopyableText,
+} from '~/hooks';
import { revealOnRowHoverClasses } from './styles';
import { cn } from '~/utils';
@@ -17,17 +22,15 @@ type THoverButtons = {
export default function MinimalHoverButtons({ message, searchResults, variant }: THoverButtons) {
const localize = useLocalize();
const [isCopied, setIsCopied] = useState(false);
+ const clipboardSource = useMemo(() => getMessageClipboardSource(message), [message]);
const copyToClipboard = useCopyMessageToClipboard({
- text: message.text,
- content: message.content,
+ ...clipboardSource,
searchResults,
- isCreatedByUser: message.isCreatedByUser,
- error: message.error,
- variant,
+ variant: clipboardSource.variant ?? variant,
});
const canCopy = useMemo(
- () => hasCopyableText({ text: message.text, content: message.content, searchResults }),
- [message.text, message.content, searchResults],
+ () => hasCopyableText({ ...clipboardSource, searchResults }),
+ [clipboardSource, searchResults],
);
return (
diff --git a/client/src/components/Chat/Messages/ui/HeaderLabel.tsx b/client/src/components/Chat/Messages/ui/HeaderLabel.tsx
index 83167b40df..9eaa2d12f3 100644
--- a/client/src/components/Chat/Messages/ui/HeaderLabel.tsx
+++ b/client/src/components/Chat/Messages/ui/HeaderLabel.tsx
@@ -11,15 +11,16 @@ type HeaderLabelProps = {
* header. */
const DOCUMENT_ID_PREFIXES = ['agent_', 'asst_'];
+/** An agent or assistant document id: a storage key, never a name to show. */
+export const isDocumentId = (value: string): boolean =>
+ DOCUMENT_ID_PREFIXES.some((prefix) => value.startsWith(prefix));
+
/** Skip document ids so the hover label is a real model name. */
export function getHeaderModelName(
...candidates: Array<string | null | undefined>
): string | undefined {
return candidates.find(
- (value): value is string =>
- value != null &&
- value !== '' &&
- !DOCUMENT_ID_PREFIXES.some((prefix) => value.startsWith(prefix)),
+ (value): value is string => value != null && value !== '' && !isDocumentId(value),
);
}
diff --git a/client/src/components/Chat/Messages/ui/MessageRender.tsx b/client/src/components/Chat/Messages/ui/MessageRender.tsx
index 63f9dcf2ff..945a4d6c6c 100644
--- a/client/src/components/Chat/Messages/ui/MessageRender.tsx
+++ b/client/src/components/Chat/Messages/ui/MessageRender.tsx
@@ -10,7 +10,7 @@ import {
getHeaderPrefixForScreenReader,
} from '~/utils';
import { revealOnRowHoverClasses, messageFooterClasses } from '~/components/Chat/Messages/styles';
-import { parseWakeupText } from '~/components/Chat/Messages/Content/Parts/wakeup';
+import { parseWakeupMessage } from '~/components/Chat/Messages/Content/Parts/wakeup';
import Elapsed, { shouldShowElapsed } from '~/components/Chat/Messages/Elapsed';
import { getHeaderHoverLabel } from '~/components/Chat/Messages/ui/HeaderLabel';
import MessageContent from '~/components/Chat/Messages/Content/MessageContent';
@@ -23,6 +23,7 @@ import MessageIcon from '~/components/Chat/Messages/MessageIcon';
import Wakeup from '~/components/Chat/Messages/Content/Wakeup';
import SubRow from '~/components/Chat/Messages/SubRow';
import { MessageContext } from '~/Providers';
+import WakeupRow from './WakeupRow';
import store from '~/store';
type MessageRenderProps = {
@@ -139,10 +140,7 @@ const MessageRender = memo(function MessageRender({
);
const { hasParallelContent } = useContentMetadata(msg);
- const wakeupDisplay = useMemo(
- () => (msg?.isCreatedByUser === true ? parseWakeupText(msg.text) : null),
- [msg?.isCreatedByUser, msg?.text],
- );
+ const wakeupDisplay = useMemo(() => parseWakeupMessage(msg), [msg]);
const messageId = msg?.messageId ?? '';
const messageContextValue = useMemo(
() => ({
@@ -160,9 +158,14 @@ const MessageRender = memo(function MessageRender({
}
const showOwnerText = !edit && msg.isCreatedByUser && Boolean(msg.privacyRevision);
+ const subagentWakeup =
+ !edit && wakeupDisplay?.kind === 'subagent' ? wakeupDisplay.tasks[0] : undefined;
+ const Row = subagentWakeup == null ? MessageRow : WakeupRow;
return (
- <MessageRow
+ <Row
+ task={subagentWakeup}
+ conversationId={msg.conversationId ?? conversation?.conversationId ?? ''}
id={msg.messageId}
icon={<MessageIcon iconData={iconData} assistant={assistant} agent={agent} />}
label={messageLabel ?? ''}
@@ -180,7 +183,11 @@ const MessageRender = memo(function MessageRender({
hasParallelContent={hasParallelContent}
fullWidth={maximizeChatSpace}
isEditing={edit}
- systemLabel={wakeupDisplay != null && !edit ? localize('com_ui_system_event') : undefined}
+ systemLabel={
+ wakeupDisplay != null && subagentWakeup == null && !edit
+ ? localize('com_ui_system_event')
+ : undefined
+ }
footer={
<SubRow classes={cn(messageFooterClasses, msg.isCreatedByUser && 'justify-end')}>
{/* The reading holds the column start: it takes over the slot the streaming
@@ -249,7 +256,7 @@ const MessageRender = memo(function MessageRender({
/>
))}
</MessageContext.Provider>
- </MessageRow>
+ </Row>
);
}, areMessageRenderPropsEqual);
MessageRender.displayName = 'MessageRender';
diff --git a/client/src/components/Chat/Messages/ui/MessageRow.tsx b/client/src/components/Chat/Messages/ui/MessageRow.tsx
index 3ea142bf43..4971419f5e 100644
--- a/client/src/components/Chat/Messages/ui/MessageRow.tsx
+++ b/client/src/components/Chat/Messages/ui/MessageRow.tsx
@@ -18,13 +18,62 @@ type MessageRowProps = {
hasParallelContent?: boolean;
fullWidth?: boolean;
isEditing?: boolean;
- /** Marks a host-authored turn (wake-up results, subagent triggers): it keeps
- * the user's position and bubble shape, outlined instead of filled, under
- * this visible heading in place of the author's name. */
+ /** Marks a host-authored turn with no author to name (background-tool
+ * wake-ups, external events): it keeps the user's position and bubble shape,
+ * outlined instead of filled, under this visible heading. */
systemLabel?: string;
+ /** A user-side turn written by someone other than the reader — a parent agent
+ * briefing its subagent, a subagent reporting back. It keeps the user's
+ * position and bubble, under the same avatar-and-name header an agent turn
+ * carries. */
+ showAuthor?: boolean;
+ /** Outline the user-side bubble instead of filling it: content the host
+ * delivered rather than words someone typed. Implied by `systemLabel`. */
+ outlined?: boolean;
className?: string;
};
+/** `mb-1` keeps the name off its own first line of body text. Static per side:
+ * every agent row in a thread renders one, so it is never merged at runtime. */
+const authorHeaderClasses = {
+ start:
+ 'text-text-primary mb-1 flex min-h-7 w-full items-center gap-2 text-sm font-semibold select-none',
+ end: 'text-text-primary mb-1 flex min-h-7 items-center justify-end gap-2 text-sm font-semibold select-none',
+} as const;
+
+/** The author line every visible-author turn shares, so an agent's turn and an
+ * agent-written user-side turn cannot drift apart. A render helper rather than
+ * a component, so a main chat row's tree stays exactly as deep as before. */
+function renderAuthorHeader({
+ icon,
+ label,
+ hoverLabel,
+ headerPrefix,
+ timestamp,
+ align,
+}: Pick<MessageRowProps, 'icon' | 'label' | 'hoverLabel' | 'headerPrefix' | 'timestamp'> & {
+ align: 'start' | 'end';
+}) {
+ return (
+ <h2 className={authorHeaderClasses[align]}>
+ {align === 'end' && (
+ <MessageTimestamp value={timestamp} className="mr-auto shrink-0 font-normal" />
+ )}
+ <span
+ aria-hidden="true"
+ className="flex size-6 shrink-0 items-center justify-center overflow-hidden rounded-full"
+ >
+ {icon}
+ </span>
+ <span className="sr-only">{headerPrefix}</span>
+ <HeaderLabel label={label} hoverLabel={hoverLabel} />
+ {align === 'start' && (
+ <MessageTimestamp value={timestamp} className="ml-auto shrink-0 font-normal" />
+ )}
+ </h2>
+ );
+}
+
export function getMessageRowWidthClass({
fullWidth = false,
hasParallelContent = false,
@@ -53,6 +102,8 @@ export default function MessageRow({
fullWidth = false,
isEditing = false,
systemLabel,
+ showAuthor = false,
+ outlined = false,
}: MessageRowProps) {
// Same column as ChatForm: max-width plus `sm:px-2`, so the body lines
// up with the composer surface rather than the form's outer box.
@@ -93,28 +144,24 @@ export default function MessageRow({
</span>
</h2>
)}
+ {!hasParallelContent && !isSystem && isCreatedByUser && !showAuthor && (
+ <h2 className="sr-only">
+ {headerPrefix}
+ {label}
+ <MessageTimestamp value={timestamp} />
+ </h2>
+ )}
{!hasParallelContent &&
!isSystem &&
- (isCreatedByUser ? (
- <h2 className="sr-only">
- {headerPrefix}
- {label}
- <MessageTimestamp value={timestamp} />
- </h2>
- ) : (
- /** `mb-1` keeps the name off its own first line of body text. */
- <h2 className="text-text-primary mb-1 flex min-h-7 w-full items-center gap-2 text-sm font-semibold select-none">
- <span
- aria-hidden="true"
- className="flex size-6 shrink-0 items-center justify-center overflow-hidden rounded-full"
- >
- {icon}
- </span>
- <span className="sr-only">{headerPrefix}</span>
- <HeaderLabel label={label} hoverLabel={hoverLabel} />
- <MessageTimestamp value={timestamp} className="ml-auto shrink-0 font-normal" />
- </h2>
- ))}
+ (!isCreatedByUser || showAuthor) &&
+ renderAuthorHeader({
+ icon,
+ label,
+ hoverLabel,
+ headerPrefix,
+ timestamp,
+ align: isCreatedByUser ? 'end' : 'start',
+ })}
<div className={cn('flex w-full flex-col gap-1', isUserSide && 'items-end')}>
<div
@@ -123,7 +170,9 @@ export default function MessageRow({
isUserSide && !isEditing
? cn(
'rounded-theme-surface rounded-br-theme-control px-theme-normal w-fit',
- isSystem ? 'border-border-medium border py-1.5' : 'bg-surface-tertiary py-2.5',
+ isSystem || outlined
+ ? 'border-border-medium border py-1.5'
+ : 'bg-surface-tertiary py-2.5',
)
: 'w-full',
)}
diff --git a/client/src/components/Chat/Messages/ui/WakeupRow.tsx b/client/src/components/Chat/Messages/ui/WakeupRow.tsx
new file mode 100644
index 0000000000..a5f20039e6
--- /dev/null
+++ b/client/src/components/Chat/Messages/ui/WakeupRow.tsx
@@ -0,0 +1,91 @@
+import { useMemo } from 'react';
+import type { ComponentProps } from 'react';
+import type { WakeupTask } from '../Content/Parts/wakeup';
+import {
+ messageAuthor,
+ resolveSubagentAuthor,
+ findAgentAuthorMessage,
+ useParentAuthor,
+} from '~/components/Chat/Subagents/author';
+import { useParentSubagents } from '~/components/Chat/Subagents/ParentSubagentsProvider';
+import { useOptionalMessagesOperations } from '~/Providers/MessagesViewContext';
+import { findSubagentDispatch } from '~/components/Chat/Subagents/dispatch';
+import { useShareContext } from '~/Providers/ShareContext';
+import { useAgentsMapContext } from '~/Providers';
+import MessageRow from './MessageRow';
+import { useLocalize } from '~/hooks';
+
+/** Only wake-up rows observe the child index; ordinary rows keep their subscriptions. */
+export default function WakeupRow({
+ task,
+ conversationId,
+ ...props
+}: ComponentProps<typeof MessageRow> & { task?: WakeupTask; conversationId: string }) {
+ const localize = useLocalize();
+ const agentsMap = useAgentsMapContext();
+ const { isSharedConvo } = useShareContext();
+ const { getMessages } = useOptionalMessagesOperations();
+ const { byThreadId } = useParentSubagents();
+ const child = task?.threadId == null ? undefined : byThreadId.get(task.threadId);
+ const dispatch = useMemo(
+ () =>
+ child == null ? findSubagentDispatch(getMessages(conversationId), task?.threadId) : undefined,
+ [child, conversationId, getMessages, task?.threadId],
+ );
+ const parentMessageId = child?.parentMessageId ?? dispatch?.message.messageId ?? props.id ?? '';
+ const fallbackName = localize('com_ui_subagent_actor');
+ const privateParentAuthor = useParentAuthor(
+ conversationId,
+ isSharedConvo === true ? '' : parentMessageId,
+ fallbackName,
+ child?.parentToolCallId,
+ undefined,
+ isSharedConvo === true ? undefined : task?.threadId,
+ );
+ const parentAuthor = useMemo(
+ () =>
+ isSharedConvo === true
+ ? messageAuthor(
+ dispatch?.message ?? findAgentAuthorMessage(getMessages(), parentMessageId),
+ agentsMap,
+ fallbackName,
+ dispatch?.agentId,
+ )
+ : privateParentAuthor,
+ [
+ agentsMap,
+ fallbackName,
+ getMessages,
+ isSharedConvo,
+ parentMessageId,
+ privateParentAuthor,
+ dispatch,
+ ],
+ );
+ const author = useMemo(
+ () =>
+ resolveSubagentAuthor(
+ {
+ subagentType: child?.subagentType ?? dispatch?.subagentType ?? task?.subagentType,
+ subagentKind: child?.subagentKind ?? dispatch?.identity?.subagentKind,
+ agentId: child?.agentId ?? dispatch?.identity?.subagentAgentId,
+ title: child?.title,
+ },
+ parentAuthor,
+ agentsMap,
+ fallbackName,
+ ),
+ [agentsMap, child, dispatch, fallbackName, parentAuthor, task?.subagentType],
+ );
+ return (
+ <MessageRow
+ {...props}
+ icon={author.icon}
+ label={author.name}
+ hoverLabel={undefined}
+ headerPrefix={undefined}
+ showAuthor
+ outlined
+ />
+ );
+}
diff --git a/client/src/components/Chat/Messages/ui/__tests__/MessageRender.wakeup.spec.tsx b/client/src/components/Chat/Messages/ui/__tests__/MessageRender.wakeup.spec.tsx
new file mode 100644
index 0000000000..18a2163fd5
--- /dev/null
+++ b/client/src/components/Chat/Messages/ui/__tests__/MessageRender.wakeup.spec.tsx
@@ -0,0 +1,365 @@
+import { RecoilRoot } from 'recoil';
+import { render, screen } from '@testing-library/react';
+import { ContentTypes, QueryKeys } from 'librechat-data-provider';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { ParentSubagentSummary, TMessage } from 'librechat-data-provider';
+import type { TMessageChatContext } from '~/common';
+import { ShareMessagesProvider } from '~/components/Share/ShareMessagesProvider';
+import { ShareContext } from '~/Providers/ShareContext';
+import MessageRender from '../MessageRender';
+
+const mockAgentsMap = {
+ agent_reviewer: { id: 'agent_reviewer', name: 'Code Reviewer' },
+ agent_lia: { id: 'agent_lia', name: 'Lia' },
+};
+
+let mockChildren = new Map<string, ParentSubagentSummary>();
+jest.mock('~/components/Chat/Subagents/ParentSubagentsProvider', () => ({
+ useParentSubagents: () => ({ byThreadId: mockChildren }),
+}));
+
+jest.mock('~/Providers', () => ({
+ ...jest.requireActual('~/Providers/MessageContext'),
+ useAgentsMapContext: () => mockAgentsMap,
+}));
+
+jest.mock('~/hooks', () => ({
+ useLocalize: () => (key: string) => key,
+ useContentMetadata: () => ({ hasParallelContent: false }),
+ useMessageActions: ({ message }: { message: TMessage }) => ({
+ ask: jest.fn(),
+ edit: false,
+ index: 0,
+ agent: mockAgentsMap.agent_lia,
+ assistant: undefined,
+ enterEdit: jest.fn(),
+ conversation: { conversationId: 'conversation-1', endpoint: 'agents' },
+ messageLabel: message.isCreatedByUser ? 'Danny' : 'Lia',
+ handleFeedback: jest.fn(),
+ handleContinue: jest.fn(),
+ copyToClipboard: jest.fn(),
+ getCanCopy: () => true,
+ regenerateMessage: jest.fn(),
+ hasConfiguredSender: false,
+ }),
+}));
+
+/** The author glyph reduced to whose face it is. */
+jest.mock('~/components/Chat/Messages/MessageIcon', () => ({
+ __esModule: true,
+ default: ({ agent, iconData }: { agent?: { name?: string }; iconData: { iconURL?: string } }) => (
+ <span data-testid="author-face" data-agent={agent?.name ?? ''} data-icon={iconData.iconURL} />
+ ),
+}));
+jest.mock('~/components/Chat/Messages/Content/Wakeup', () => ({
+ __esModule: true,
+ default: () => <div data-testid="wakeup-card" />,
+}));
+jest.mock('~/components/Chat/Messages/Content/MessageContent', () => ({
+ __esModule: true,
+ default: () => <div data-testid="message-content" />,
+}));
+jest.mock('~/components/Chat/Messages/HoverButtons', () => ({
+ __esModule: true,
+ default: () => null,
+}));
+jest.mock('~/components/Chat/Messages/SiblingSwitch', () => ({
+ __esModule: true,
+ default: () => null,
+}));
+jest.mock('~/components/Chat/Messages/ui/MessageTimestamp', () => ({
+ __esModule: true,
+ default: () => null,
+}));
+
+const chatContext = { latestMessageId: 'wake' } as unknown as TMessageChatContext;
+
+const subagentWakeup = (subagentType: string) =>
+ [
+ 'A detached subagent task has completed. Continue the parent task using its durable result below.',
+ JSON.stringify({
+ background_task_id: 'task-1',
+ subagent_thread_id: 'thread-1',
+ subagent_type: subagentType,
+ status: 'completed',
+ result: 'One finding.',
+ }),
+ ].join('\n');
+
+const backgroundWakeup = [
+ 'A background tool task has finished. Continue using its durable result below.',
+ JSON.stringify([
+ {
+ background_task_id: 'task-2',
+ tool_call_id: 'call-1',
+ tool: 'bash',
+ status: 'completed',
+ result: 'ok',
+ },
+ ]),
+].join('\n');
+
+function renderMessage(
+ text: string,
+ parentModel = 'agent_lia',
+ shared = false,
+ submitted = false,
+ dispatch?: TMessage,
+) {
+ const queryClient = new QueryClient();
+ queryClient.setQueryData(
+ [QueryKeys.messages, 'conversation-1'],
+ [
+ dispatch ?? {
+ messageId: 'dispatch',
+ isCreatedByUser: false,
+ endpoint: 'agents',
+ model: parentModel,
+ sender: 'Historical Parent',
+ iconURL: '/historical.png',
+ },
+ ],
+ );
+ const message = {
+ messageId: 'wake',
+ parentMessageId: 'parent',
+ conversationId: 'conversation-1',
+ isCreatedByUser: true,
+ isUserSubmitted: submitted,
+ text,
+ } as unknown as TMessage;
+ const row = <MessageRender message={message} chatContext={chatContext} currentEditId={null} />;
+ const sharedReply: TMessage = {
+ messageId: 'shared-reply',
+ parentMessageId: 'wake',
+ conversationId: 'original-shared-conversation',
+ text: 'Parent continuation',
+ isCreatedByUser: false,
+ endpoint: 'agents',
+ model: parentModel,
+ sender: 'Shared Historical Parent',
+ iconURL: '/shared-historical.png',
+ };
+ return render(
+ <QueryClientProvider client={queryClient}>
+ <RecoilRoot>
+ {shared ? (
+ <ShareContext.Provider value={{ isSharedConvo: true, shareId: 'share-1' }}>
+ <ShareMessagesProvider messages={[message, sharedReply]}>{row}</ShareMessagesProvider>
+ </ShareContext.Provider>
+ ) : (
+ <ShareMessagesProvider
+ messages={
+ queryClient.getQueryData<TMessage[]>([QueryKeys.messages, 'conversation-1']) ?? []
+ }
+ >
+ {row}
+ </ShareMessagesProvider>
+ )}
+ </RecoilRoot>
+ </QueryClientProvider>,
+ );
+}
+
+describe('MessageRender wake-up rows', () => {
+ beforeEach(() => {
+ mockChildren = new Map([
+ [
+ 'thread-1',
+ {
+ threadId: 'thread-1',
+ parentMessageId: 'dispatch',
+ subagentType: 'agent_reviewer',
+ subagentKind: 'agent',
+ agentId: 'agent_reviewer',
+ title: 'Stored Reviewer',
+ } as ParentSubagentSummary,
+ ],
+ ]);
+ });
+ it('heads a subagent report with the subagent name and face instead of a system label', () => {
+ renderMessage(subagentWakeup('agent_reviewer'));
+
+ const heading = screen.getByRole('heading', { name: 'Code Reviewer' });
+ expect(heading).not.toHaveClass('sr-only');
+ expect(screen.getByTestId('author-face')).toHaveAttribute('data-agent', 'Code Reviewer');
+ expect(screen.queryByText('com_ui_system_event')).not.toBeInTheDocument();
+ expect(screen.queryByText(/agent_reviewer/)).not.toBeInTheDocument();
+ /** Delivered by the host, not typed: outlined, on the user's side. */
+ expect(screen.getByTestId('message-body')).toHaveClass('border', 'border-border-medium');
+ expect(screen.getByTestId('message-body')).not.toHaveClass('bg-surface-tertiary');
+ expect(screen.getByTestId('wakeup-card')).toBeInTheDocument();
+ });
+
+ it('names a self-spawned report after the agent it woke', () => {
+ mockChildren.set('thread-1', {
+ ...mockChildren.get('thread-1')!,
+ subagentType: 'self',
+ agentId: 'agent_lia',
+ });
+ renderMessage(subagentWakeup('self'));
+
+ expect(screen.getByRole('heading', { name: /Lia$/ })).toBeInTheDocument();
+ expect(screen.getByTestId('author-face')).toHaveAttribute('data-agent', 'Lia');
+ });
+
+ it('keeps historical self-spawn identity after switching the current agent', () => {
+ mockChildren.set('thread-1', { ...mockChildren.get('thread-1')!, subagentType: 'self' });
+ renderMessage(subagentWakeup('self'), 'agent_reviewer');
+ expect(screen.getByRole('heading', { name: 'Code Reviewer' })).toBeInTheDocument();
+ expect(screen.getByTestId('author-face')).toHaveAttribute('data-agent', 'Code Reviewer');
+ });
+
+ it('retains the historical avatar when the self-spawning agent is unavailable', () => {
+ mockChildren.set('thread-1', {
+ ...mockChildren.get('thread-1')!,
+ subagentType: 'self',
+ agentId: 'agent_deleted',
+ });
+ renderMessage(subagentWakeup('self'), 'agent_deleted');
+ expect(screen.getByRole('heading', { name: 'Historical Parent' })).toBeInTheDocument();
+ expect(screen.getByTestId('author-face')).toHaveAttribute('data-icon', '/historical.png');
+ });
+
+ it.each(['agent_reviewer', 'agent_deleted'])(
+ 'reads an unindexed public self wake-up author from the shared transcript (%s)',
+ (parentModel) => {
+ mockChildren.clear();
+ renderMessage(subagentWakeup('self'), parentModel, true);
+ const name = parentModel === 'agent_reviewer' ? 'Code Reviewer' : 'Shared Historical Parent';
+ expect(screen.getByRole('heading', { name })).toBeInTheDocument();
+ expect(screen.getByTestId('author-face')).toHaveAttribute(
+ 'data-icon',
+ '/shared-historical.png',
+ );
+ expect(screen.queryByRole('heading', { name: 'Lia' })).not.toBeInTheDocument();
+ },
+ );
+
+ it.each(['agent_reviewer', 'agent_research_team'])(
+ 'preserves the explicit graph alias %s without resolving a saved agent',
+ (subagentType) => {
+ mockChildren.set('thread-1', {
+ ...mockChildren.get('thread-1')!,
+ subagentType,
+ subagentKind: 'graph',
+ title: subagentType,
+ });
+ renderMessage(subagentWakeup(subagentType));
+ expect(screen.getByRole('heading', { name: subagentType })).toBeInTheDocument();
+ expect(screen.getByTestId('author-face')).toHaveAttribute('data-agent', '');
+ },
+ );
+
+ it('preserves an unindexed legacy alias without resolving a saved agent', () => {
+ mockChildren.clear();
+ renderMessage(subagentWakeup('agent_reviewer'));
+ expect(screen.getByRole('heading', { name: 'agent_reviewer' })).toBeInTheDocument();
+ expect(screen.getByTestId('author-face')).toHaveAttribute('data-agent', '');
+ });
+
+ it('names an unresolvable known agent generically, never by its id', () => {
+ mockChildren.set('thread-1', {
+ ...mockChildren.get('thread-1')!,
+ subagentKind: 'agent',
+ agentId: 'agent_unknown',
+ subagentType: 'agent_unknown',
+ title: 'agent_unknown',
+ });
+ renderMessage(subagentWakeup('agent_unknown'));
+
+ expect(screen.getByRole('heading', { name: /com_ui_subagent_actor$/ })).toBeInTheDocument();
+ expect(screen.queryByText(/agent_unknown/)).not.toBeInTheDocument();
+ });
+
+ it('keeps a background tool report a system turn, since no agent wrote it', () => {
+ renderMessage(backgroundWakeup);
+
+ expect(screen.getByRole('heading', { name: 'com_ui_system_event' })).toBeInTheDocument();
+ expect(screen.queryByTestId('author-face')).not.toBeInTheDocument();
+ });
+
+ it.each([
+ ['self', 'graph', 'self'],
+ ['agent_reviewer', 'agent', 'Code Reviewer'],
+ ['self', 'agent', 'Code Reviewer'],
+ ] as const)(
+ 'recovers a private child omitted from the bounded index (%s/%s)',
+ (alias, kind, label) => {
+ mockChildren.clear();
+ const dispatch: TMessage = {
+ messageId: 'old-dispatch',
+ parentMessageId: null,
+ conversationId: 'conversation-1',
+ isCreatedByUser: false,
+ text: '',
+ endpoint: 'agents',
+ model: 'agent_lia',
+ sender: 'Lia',
+ content: [
+ {
+ type: ContentTypes.TOOL_CALL,
+ tool_call: {
+ id: 'old-call',
+ name: 'subagent',
+ args: { run_in_background: true },
+ output: JSON.stringify({
+ background_task_id: 'task-1',
+ subagent_thread_id: 'thread-1',
+ tool: 'subagent',
+ subagent_type: alias,
+ status: 'running',
+ message: 'Poll using background_task_id task-1.',
+ }),
+ subagentIdentity: {
+ subagentKind: kind,
+ subagentAgentId: kind === 'graph' ? 'graph:self' : 'agent_reviewer',
+ },
+ },
+ },
+ ],
+ };
+ renderMessage(subagentWakeup(alias), 'agent_lia', false, false, dispatch);
+ expect(screen.getByRole('heading', { name: label })).toBeInTheDocument();
+ expect(screen.queryByRole('heading', { name: 'Lia' })).not.toBeInTheDocument();
+ },
+ );
+
+ it('preserves a graph title whose prefix resembles a legacy label', () => {
+ mockChildren.set('thread-1', {
+ ...mockChildren.get('thread-1')!,
+ subagentType: 'Subagent: research',
+ title: 'Subagent: research',
+ subagentKind: 'graph',
+ agentId: undefined,
+ });
+ renderMessage(subagentWakeup('Subagent: research'));
+ expect(screen.getByRole('heading', { name: 'Subagent: research' })).toBeInTheDocument();
+ });
+
+ it('leaves an ordinary user turn without a visible author', () => {
+ renderMessage('Hello there');
+
+ expect(screen.getByRole('heading', { hidden: true })).toHaveClass('sr-only');
+ expect(screen.getByTestId('message-body')).toHaveClass('bg-surface-tertiary');
+ });
+});
+
+it('keeps user-submitted wake-up lookalikes as ordinary chat prompts', () => {
+ const text = subagentWakeup('self');
+ renderMessage(text, 'agent_lia', false, true);
+ expect(screen.getByTestId('message-content')).toBeInTheDocument();
+ expect(screen.queryByTestId('wakeup-card')).not.toBeInTheDocument();
+ expect(screen.getByRole('heading', { hidden: true })).toHaveClass('sr-only');
+});
+
+it('uses the validated spawning lane for a private self wake-up', () => {
+ mockChildren.set('thread-1', {
+ ...mockChildren.get('thread-1')!,
+ subagentType: 'self',
+ agentId: 'agent_reviewer',
+ });
+ renderMessage(subagentWakeup('self'), 'agent_lia');
+ expect(screen.getByRole('heading', { name: 'Code Reviewer' })).toBeInTheDocument();
+ expect(screen.getByTestId('author-face')).toHaveAttribute('data-agent', 'Code Reviewer');
+});
diff --git a/client/src/components/Chat/Messages/ui/__tests__/MessageRow.spec.tsx b/client/src/components/Chat/Messages/ui/__tests__/MessageRow.spec.tsx
index b2f95dc25b..e6f5da2f12 100644
--- a/client/src/components/Chat/Messages/ui/__tests__/MessageRow.spec.tsx
+++ b/client/src/components/Chat/Messages/ui/__tests__/MessageRow.spec.tsx
@@ -16,12 +16,16 @@ const renderRow = ({
fullWidth = false,
isEditing = false,
systemLabel,
+ showAuthor,
+ outlined,
}: {
isCreatedByUser: boolean;
hasParallelContent?: boolean;
fullWidth?: boolean;
isEditing?: boolean;
systemLabel?: string;
+ showAuthor?: boolean;
+ outlined?: boolean;
}) =>
render(
<MessageRow
@@ -37,6 +41,8 @@ const renderRow = ({
fullWidth={fullWidth}
isEditing={isEditing}
systemLabel={systemLabel}
+ showAuthor={showAuthor}
+ outlined={outlined}
>
<p>{MESSAGE_BODY}</p>
</MessageRow>,
@@ -59,6 +65,35 @@ describe('MessageRow', () => {
expect(screen.getByTestId('message-actions')).toBeInTheDocument();
});
+ it('names another author of a user-side turn with the agent header, mirrored', () => {
+ renderRow({ isCreatedByUser: true, showAuthor: true });
+
+ const row = screen.getByLabelText('User message');
+ const heading = screen.getByRole('heading', { name: 'Message from You' });
+ const messageSurface = screen.getByText(MESSAGE_BODY).parentElement;
+
+ /** The user's position and filled bubble, under the same visible
+ * avatar-and-name line an agent turn carries — closed toward the bubble. */
+ expect(row).toHaveClass('justify-end');
+ expect(heading).not.toHaveClass('sr-only');
+ expect(heading).toHaveClass('justify-end', 'text-sm', 'font-semibold');
+ expect(heading).toContainElement(screen.getByTestId('message-icon'));
+ expect(screen.getByTestId('message-icon').parentElement).toHaveClass('size-6');
+ expect(heading.lastElementChild).toHaveTextContent('You');
+ expect(messageSurface).toHaveClass('bg-surface-tertiary');
+ expect(messageSurface).not.toHaveClass('border');
+ });
+
+ it('outlines a delivered user-side turn without a system heading', () => {
+ renderRow({ isCreatedByUser: true, showAuthor: true, outlined: true });
+
+ const messageSurface = screen.getByText(MESSAGE_BODY).parentElement;
+
+ expect(messageSurface).toHaveClass('border', 'border-border-medium');
+ expect(messageSurface).not.toHaveClass('bg-surface-tertiary');
+ expect(screen.getByRole('heading', { name: 'Message from You' })).toBeVisible();
+ });
+
it('renders user content as a right-aligned semantic surface without a visible avatar', () => {
renderRow({ isCreatedByUser: true });
diff --git a/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.test.tsx b/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.test.tsx
index db5310177b..de2a25e5e7 100644
--- a/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.test.tsx
+++ b/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.test.tsx
@@ -1,7 +1,7 @@
import React from 'react';
import { ContentTypes } from 'librechat-data-provider';
import { fireEvent, render, screen, waitFor } from '@testing-library/react';
-import type { TMessageContentParts } from 'librechat-data-provider';
+import type { TMessage, TMessageContentParts } from 'librechat-data-provider';
import SubagentCall from '~/components/Chat/Messages/Content/Parts/SubagentCall';
import SharedSubagentActivityDialog from './SharedSubagentActivityDialog';
import { MessageContext } from '~/Providers/MessageContext';
@@ -17,8 +17,7 @@ jest.mock('~/data-provider', () => ({
jest.mock('~/hooks', () => ({
useLocalize:
() =>
- (key: string, values?: Record<number, string>): string => {
- if (key === 'com_ui_subagent_dialog_title') return `Agent ${values?.[0] ?? ''}`;
+ (key: string): string => {
if (key === 'com_ui_subagent_complete') return 'Ran agent';
if (key === 'com_ui_subagent_activity') return 'Agent activity';
return key;
@@ -27,6 +26,12 @@ jest.mock('~/hooks', () => ({
jest.mock('~/Providers', () => ({ useAgentsMapContext: () => ({}) }));
jest.mock('~/components/Share/MessageIcon', () => ({ __esModule: true, default: () => null }));
+jest.mock('~/components/Chat/Messages/MessageIcon', () => ({
+ __esModule: true,
+ default: ({ iconData }: { iconData: { iconURL?: string } }) => (
+ <span data-testid="author-face" data-icon={iconData.iconURL} />
+ ),
+}));
jest.mock('~/hooks/MCP', () => ({ useMCPServerNames: () => [] }));
jest.mock('./SubagentActivity', () => ({
@@ -52,7 +57,11 @@ jest.mock('./SubagentConversation', () => ({
__esModule: true,
default: ({
turns,
+ author,
+ parentAuthor,
}: {
+ author: { name: string };
+ parentAuthor: { name: string };
turns: Array<{
taskId: string;
trigger: { summary: string };
@@ -63,7 +72,12 @@ jest.mock('./SubagentConversation', () => ({
return (
<MessageSurfaceContext.Consumer>
{(surface: string) => (
- <div data-testid="subagent-conversation" data-message-surface={surface}>
+ <div
+ data-testid="subagent-conversation"
+ data-message-surface={surface}
+ data-author={author.name}
+ data-parent-author={parentAuthor.name}
+ >
{turns.map((turn) => (
<div key={turn.taskId}>
{turn.trigger.summary}
@@ -93,10 +107,29 @@ const detachedOutput = JSON.stringify({
'Started subagent "researcher" background task. Poll the host background-task tool with background_task_id "task-1".',
});
+/** The shared thread as ShareView holds it: the agent that dispatched the child. */
+const sharedMessages = [
+ {
+ messageId: 'shared-parent',
+ parentMessageId: null,
+ conversationId: 'shared-conversation',
+ isCreatedByUser: false,
+ endpoint: 'agents',
+ model: 'agent_parent',
+ sender: 'Lia',
+ iconURL: '/lia.png',
+ text: '',
+ } as unknown as TMessage,
+];
+
function renderSharedCall(input: {
output?: string;
persistedContent?: TMessageContentParts[];
detached?: boolean;
+ partIndex?: number;
+ messages?: TMessage[];
+ subagentType?: string;
+ subagentIdentity?: { subagentKind: 'graph'; subagentAgentId: 'graph:self' };
}) {
return render(
<ChatSurfaceHarness>
@@ -105,6 +138,7 @@ function renderSharedCall(input: {
value={{
conversationId: 'shared-conversation',
messageId: 'shared-parent',
+ partIndex: input.partIndex,
isExpanded: false,
}}
>
@@ -112,14 +146,18 @@ function renderSharedCall(input: {
toolCallId="shared-call"
initialProgress={1}
args={{
- subagent_type: 'researcher',
+ subagent_type: input.subagentType ?? 'researcher',
description: 'Review the release.',
run_in_background: input.detached === true,
}}
output={input.output}
+ subagentIdentity={input.subagentIdentity}
persistedContent={input.persistedContent}
/>
- <SharedSubagentActivityDialog shareId="share-1" />
+ <SharedSubagentActivityDialog
+ shareId="share-1"
+ messages={input.messages ?? sharedMessages}
+ />
</MessageContext.Provider>
</ShareContext.Provider>
</ChatSurfaceHarness>,
@@ -144,10 +182,72 @@ describe('SharedSubagentActivityDialog', () => {
'bg-surface-dialog',
);
expect(screen.getByText('Shared review complete.')).toBeInTheDocument();
+ /** Named as main chat names them: the child by its readable type, the
+ * briefing by the shared agent that sent it. */
+ expect(screen.getByRole('heading', { name: 'researcher' })).toBeInTheDocument();
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-author',
+ 'researcher',
+ );
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-parent-author',
+ 'Lia',
+ );
fireEvent.click(screen.getByRole('button', { name: 'Close' }));
await waitFor(() => expect(trigger).toHaveFocus());
});
+ it('reuses the historical parent avatar for a shared self-spawn', () => {
+ renderSharedCall({ subagentType: 'self', persistedContent: persistedContent('Self work.') });
+ fireEvent.click(screen.getByRole('button', { name: 'Ran agent' }));
+ expect(screen.getByRole('heading', { name: 'Lia' })).toBeInTheDocument();
+ expect(screen.getByTestId('author-face')).toHaveAttribute('data-icon', '/lia.png');
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute('data-author', 'Lia');
+ });
+
+ it('uses the exact shared part when provider tool IDs repeat', () => {
+ renderSharedCall({
+ subagentType: 'self',
+ partIndex: 1,
+ persistedContent: persistedContent('Lane work.'),
+ messages: [
+ {
+ ...sharedMessages[0],
+ content: [
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'agent_parent',
+ tool_call: { id: 'shared-call', name: 'subagent', args: {} },
+ },
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'agent_missing_lane',
+ tool_call: { id: 'shared-call', name: 'subagent', args: {} },
+ },
+ ],
+ },
+ ],
+ });
+ fireEvent.click(screen.getByRole('button', { name: 'Ran agent' }));
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-parent-author',
+ 'com_ui_subagent_parent_agent',
+ );
+ expect(screen.queryByRole('heading', { name: 'Lia' })).not.toBeInTheDocument();
+ });
+
+ it('preserves a shared graph alias named self instead of the parent author', () => {
+ renderSharedCall({
+ subagentType: 'self',
+ subagentIdentity: { subagentKind: 'graph', subagentAgentId: 'graph:self' },
+ persistedContent: persistedContent('Graph work.'),
+ });
+ fireEvent.click(screen.getByRole('button', { name: 'Ran agent' }));
+ expect(screen.getByRole('heading', { name: 'self' })).toBeInTheDocument();
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute('data-author', 'self');
+ expect(screen.getByTestId('author-face')).not.toHaveAttribute('data-icon', '/lia.png');
+ });
+
it('renders detached persisted activity without performing the private durable query', () => {
renderSharedCall({
output: detachedOutput,
diff --git a/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.tsx b/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.tsx
index 823df45cd6..01c26a7ff4 100644
--- a/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.tsx
+++ b/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.tsx
@@ -1,25 +1,80 @@
import { useCallback, useEffect, useMemo, useRef } from 'react';
import { useAtom } from 'jotai';
import { OGDialog, OGDialogContent, OGDialogHeader, OGDialogTitle } from '@librechat/client';
+import type { TMessage } from 'librechat-data-provider';
+import {
+ isSelfSpawn as isSelfSpawnType,
+ messageAuthor,
+ findAgentLaneId,
+ resolveSubagentAuthor,
+ findAgentAuthorMessage,
+} from './author';
import { MessageSurfaceContext } from '~/components/Chat/Messages/ui/surface';
import { SubagentActivityScrollSurface } from './SubagentActivity';
import SubagentConversation from './SubagentConversation';
import { adaptLivePersistedActivity } from './adapters';
+import { resolveSubagentAgentId } from './identity';
+import { useAgentsMapContext } from '~/Providers';
import { activeSubagentPanel } from './state';
import { useLocalize } from '~/hooks';
/** Public-share fallback for subagent activity already embedded in the shared message payload. */
-export default function SharedSubagentActivityDialog({ shareId }: { shareId?: string }) {
+export default function SharedSubagentActivityDialog({
+ shareId,
+ messages,
+}: {
+ shareId?: string;
+ /** The shared thread, which names the agent that dispatched the child. */
+ messages?: TMessage[];
+}) {
const localize = useLocalize();
+ const agentsMap = useAgentsMapContext();
const [selected, setSelected] = useAtom(activeSubagentPanel);
const resetSelection = useCallback(() => setSelected(null), [setSelected]);
const selection = selected?.host === 'share' && selected.shareId === shareId ? selected : null;
const restoreSelectionRef = useRef(selection);
if (selection != null) restoreSelectionRef.current = selection;
- const title =
- selection?.subagentType === 'self'
- ? localize('com_ui_subagent_dialog_title_self')
- : localize('com_ui_subagent_dialog_title', { 0: selection?.subagentType ?? '' });
+ const parentMessageId = selection?.parentMessageId ?? '';
+ const parentFallback = localize('com_ui_subagent_parent_agent');
+ /** Resolved only while a child is open: the shared thread is never scanned for
+ * a dialog nobody is looking at. */
+ const parentAuthor = useMemo(() => {
+ const message =
+ parentMessageId === '' ? undefined : findAgentAuthorMessage(messages, parentMessageId);
+ return messageAuthor(
+ message,
+ agentsMap,
+ parentFallback,
+ findAgentLaneId(message, selection?.toolCallId, selection?.partIndex),
+ );
+ }, [
+ agentsMap,
+ messages,
+ parentFallback,
+ parentMessageId,
+ selection?.toolCallId,
+ selection?.partIndex,
+ ]);
+ const childAgentId = resolveSubagentAgentId(null, selection?.subagentIdentity);
+ const isSelfSpawn = isSelfSpawnType(
+ selection?.subagentType,
+ selection?.subagentIdentity?.subagentKind,
+ );
+ const childAuthor = useMemo(
+ () =>
+ resolveSubagentAuthor(
+ {
+ agentId: childAgentId,
+ subagentType: selection?.subagentType,
+ subagentKind: selection?.subagentIdentity?.subagentKind,
+ },
+ parentAuthor,
+ agentsMap,
+ localize('com_ui_subagent_actor'),
+ ),
+ [agentsMap, childAgentId, localize, parentAuthor, selection],
+ );
+ const title = childAuthor.name;
const activity = useMemo(
() =>
adaptLivePersistedActivity({
@@ -65,13 +120,23 @@ export default function SharedSubagentActivityDialog({ shareId }: { shareId?: st
onCloseAutoFocus={restoreTriggerFocus}
>
<OGDialogHeader className="border-border-light shrink-0 border-b px-5 py-4 pr-14">
- <OGDialogTitle className="truncate text-left text-base" title={activity.title}>
- {activity.title}
- </OGDialogTitle>
+ <div className="flex min-w-0 items-center gap-2">
+ <span
+ aria-hidden="true"
+ className="flex size-6 shrink-0 items-center justify-center overflow-hidden rounded-full"
+ >
+ {childAuthor.icon}
+ </span>
+ <OGDialogTitle className="truncate text-left text-base" title={title}>
+ {title}
+ </OGDialogTitle>
+ </div>
</OGDialogHeader>
<MessageSurfaceContext.Provider value="bg-surface-dialog">
<SubagentActivityScrollSurface padded={false}>
<SubagentConversation
+ author={childAuthor}
+ parentAuthor={isSelfSpawn ? childAuthor : parentAuthor}
turns={[
{
taskId:
diff --git a/client/src/components/Chat/Subagents/SubagentConversation.test.tsx b/client/src/components/Chat/Subagents/SubagentConversation.test.tsx
index 03bc4c93fc..c1a0f383e7 100644
--- a/client/src/components/Chat/Subagents/SubagentConversation.test.tsx
+++ b/client/src/components/Chat/Subagents/SubagentConversation.test.tsx
@@ -1,6 +1,7 @@
import React from 'react';
-import { fireEvent, render, screen } from '@testing-library/react';
+import { fireEvent, render, screen, within } from '@testing-library/react';
import type { ChildConversationTurn } from './adapters';
+import type { TurnAuthor } from './author';
import SubagentConversation from './SubagentConversation';
import { ChatSurfaceHarness } from 'test/harness';
@@ -62,6 +63,9 @@ jest.mock('lucide-react', () => ({
Zap: () => null,
}));
+const author: TurnAuthor = { name: 'Research child', icon: <span data-testid="child-face" /> };
+const parentAuthor: TurnAuthor = { name: 'Lia', icon: <span data-testid="parent-face" /> };
+
const turns: ChildConversationTurn[] = [
{
taskId: 'task-1',
@@ -107,16 +111,24 @@ const turns: ChildConversationTurn[] = [
];
describe('SubagentConversation', () => {
- it('renders host triggers and child activity through the main chat row and content modules', () => {
+ it('renders parent turns and child activity through the main chat row and content modules', () => {
const { container } = render(
<ChatSurfaceHarness>
- <SubagentConversation turns={turns} />
+ <SubagentConversation turns={turns} author={author} parentAuthor={parentAuthor} />
</ChatSurfaceHarness>,
);
- expect(screen.getByText('com_ui_subagent_trigger_parent_dispatch')).toBeInTheDocument();
+ /** The parent's briefing is a user turn in the parent's name, filled like
+ * one; only the external event, which no agent wrote, is a system turn. */
+ const briefing = screen.getByRole('group', { name: 'com_ui_subagent_trigger_parent_dispatch' });
+ expect(briefing).toHaveClass('justify-end');
+ expect(within(briefing).getByRole('heading', { name: /Lia$/ })).toBeInTheDocument();
+ expect(within(briefing).getByTestId('parent-face')).toBeInTheDocument();
+ expect(within(briefing).getByTestId('message-body')).toHaveClass('bg-surface-tertiary');
+ expect(screen.queryByText('com_ui_subagent_trigger_parent_dispatch')).not.toBeInTheDocument();
expect(screen.getByText('com_ui_subagent_trigger_external_event')).toBeInTheDocument();
- expect(screen.getAllByRole('heading', { name: /^com_ui_system_event/ })).toHaveLength(2);
+ expect(screen.getAllByRole('heading', { name: /^com_ui_system_event/ })).toHaveLength(1);
+ expect(screen.getAllByRole('heading', { name: 'Research child' })).toHaveLength(2);
expect(screen.getByText('Investigate the release.')).toBeInTheDocument();
expect(screen.getByText('Checked the constraints.')).toBeInTheDocument();
expect(screen.getByText('search')).toBeInTheDocument();
@@ -125,7 +137,7 @@ describe('SubagentConversation', () => {
expect(screen.queryByText('com_ui_subagent_thread_status_running')).not.toBeInTheDocument();
/** Both halves of the main chat author column: the shared glyph, and the
* streaming dot inset onto that glyph's axis the way main chat insets it. */
- expect(screen.getAllByTestId('message-icon')).toHaveLength(2);
+ expect(screen.getAllByTestId('child-face')).toHaveLength(2);
expect(screen.getByTestId('thinking-cursor')).toHaveAttribute('data-under-header-icon', 'true');
expect(container.querySelectorAll('.message-render')).toHaveLength(4);
expect(container.querySelectorAll('.user-turn')).toHaveLength(2);
@@ -150,6 +162,26 @@ describe('SubagentConversation', () => {
expect(screen.getByText('submit_move')).toBeInTheDocument();
});
+ it('names an empty parent follow-up instead of rendering a blank bubble', () => {
+ const followUp: ChildConversationTurn = {
+ ...turns[0],
+ taskId: 'task-4',
+ trigger: { kind: 'parent_continuation', summary: '' },
+ };
+ render(
+ <ChatSurfaceHarness>
+ <SubagentConversation turns={[followUp]} author={author} parentAuthor={parentAuthor} />
+ </ChatSurfaceHarness>,
+ );
+
+ const row = screen.getByRole('group', { name: 'com_ui_subagent_trigger_parent_continuation' });
+ expect(within(row).getByRole('heading', { name: /Lia$/ })).toBeInTheDocument();
+ expect(
+ within(row).getByText('com_ui_subagent_trigger_parent_continuation'),
+ ).toBeInTheDocument();
+ expect(within(row).queryByTestId('shared-content-parts')).not.toBeInTheDocument();
+ });
+
it('requests an exact bounded projection only when shortened turn activity is opened', () => {
const loadDetails = jest.fn();
const shortened = [
@@ -157,7 +189,12 @@ describe('SubagentConversation', () => {
];
render(
<ChatSurfaceHarness>
- <SubagentConversation turns={shortened} onLoadTurnDetails={loadDetails} />
+ <SubagentConversation
+ turns={shortened}
+ author={author}
+ parentAuthor={parentAuthor}
+ onLoadTurnDetails={loadDetails}
+ />
</ChatSurfaceHarness>,
);
@@ -182,7 +219,11 @@ describe('SubagentConversation', () => {
render(
<ChatSurfaceHarness>
- <SubagentConversation turns={[turns[1], secondEvent]} />
+ <SubagentConversation
+ turns={[turns[1], secondEvent]}
+ author={author}
+ parentAuthor={parentAuthor}
+ />
</ChatSurfaceHarness>,
);
diff --git a/client/src/components/Chat/Subagents/SubagentConversation.tsx b/client/src/components/Chat/Subagents/SubagentConversation.tsx
index 9ba061760f..76d56b31f0 100644
--- a/client/src/components/Chat/Subagents/SubagentConversation.tsx
+++ b/client/src/components/Chat/Subagents/SubagentConversation.tsx
@@ -1,12 +1,13 @@
import { useMemo, useState } from 'react';
import { useAtomValue } from 'jotai';
-import { CornerDownRight, Radio } from 'lucide-react';
-import { ContentTypes, EModelEndpoint } from 'librechat-data-provider';
+import { Radio } from 'lucide-react';
+import { ContentTypes } from 'librechat-data-provider';
import { Button, Collapsible, CollapsibleContent, CollapsibleTrigger } from '@librechat/client';
import type { TMessageContentParts } from 'librechat-data-provider';
import type { ReactNode } from 'react';
import type { ChildConversationTurn } from './adapters';
import type { TranslationKeys } from '~/hooks';
+import type { TurnAuthor } from './author';
import SystemEventHeader, {
SystemEventIcon,
systemEventHeaderClasses,
@@ -17,9 +18,7 @@ import { isAbnormalTerminalStatus, isLiveSubagentStatus } from './status';
import { messageFooterClasses } from '~/components/Chat/Messages/styles';
import MessageRow from '~/components/Chat/Messages/ui/MessageRow';
import { ElapsedTimer } from '~/components/Chat/Messages/Elapsed';
-import MessageIcon from '~/components/Chat/Messages/MessageIcon';
import { showThinkingAtom } from '~/store/showThinking';
-import { useAgentsMapContext } from '~/Providers';
import { useChatSurface } from './surface';
import { useLocalize } from '~/hooks';
import { cn } from '~/utils';
@@ -30,11 +29,10 @@ const TRIGGER_LABELS = {
external_event: 'com_ui_subagent_trigger_external_event',
} as const satisfies Record<ChildConversationTurn['trigger']['kind'], TranslationKeys>;
-function TriggerIcon({ kind }: { kind: ChildConversationTurn['trigger']['kind'] }) {
- const Icon = kind === 'external_event' ? Radio : CornerDownRight;
+function ExternalEventIcon() {
return (
<SystemEventIcon>
- <Icon size={14} />
+ <Radio size={14} />
</SystemEventIcon>
);
}
@@ -54,7 +52,7 @@ function ExternalEventTrigger({
if (details == null) {
body = (
<div className="text-text-secondary flex items-center gap-2 py-1 text-sm">
- <SystemEventHeader icon={<TriggerIcon kind="external_event" />} label={label} />
+ <SystemEventHeader icon={<ExternalEventIcon />} label={label} />
</div>
);
} else {
@@ -63,7 +61,7 @@ function ExternalEventTrigger({
<CollapsibleTrigger asChild>
<Button type="button" variant="ghost" className={systemEventHeaderClasses}>
<SystemEventHeader
- icon={<TriggerIcon kind="external_event" />}
+ icon={<ExternalEventIcon />}
label={label}
detail={`${details.eventType} · ${details.sourceType}`}
expanded={expanded}
@@ -95,7 +93,7 @@ function ExternalEventTrigger({
return (
<MessageRow
id={`${turn.taskId}:trigger`}
- icon={<TriggerIcon kind="external_event" />}
+ icon={<ExternalEventIcon />}
label={label}
footer={null}
timestamp={turn.trigger.createdAt ?? details?.occurredAt}
@@ -110,7 +108,19 @@ function ExternalEventTrigger({
);
}
-function TriggerMessage({ turn, fullWidth }: { turn: ChildConversationTurn; fullWidth: boolean }) {
+/** A parent agent's briefing or follow-up is the user side of this conversation
+ * with the parent as its author, so it is main chat's user turn under the
+ * parent's name and face. Only an external event, which no agent wrote, stays
+ * a system turn. */
+function TriggerMessage({
+ turn,
+ fullWidth,
+ parentAuthor,
+}: {
+ turn: ChildConversationTurn;
+ fullWidth: boolean;
+ parentAuthor: TurnAuthor;
+}) {
const showThinking = useAtomValue(showThinkingAtom);
const localize = useLocalize();
const label = localize(TRIGGER_LABELS[turn.trigger.kind]);
@@ -132,20 +142,17 @@ function TriggerMessage({ turn, fullWidth }: { turn: ChildConversationTurn; full
return (
<MessageRow
id={`${turn.taskId}:trigger`}
- icon={<TriggerIcon kind={turn.trigger.kind} />}
- label={label}
+ icon={parentAuthor.icon}
+ label={parentAuthor.name}
footer={null}
timestamp={turn.trigger.createdAt}
ariaLabel={label}
headerPrefix=""
isCreatedByUser={true}
- systemLabel={localize('com_ui_system_event')}
+ showAuthor
fullWidth={fullWidth}
>
- <div className="text-text-secondary flex items-center gap-2 py-1 text-sm">
- <SystemEventHeader icon={<TriggerIcon kind={turn.trigger.kind} />} label={label} />
- </div>
- {content.length > 0 && (
+ {content.length > 0 ? (
<ContentParts
content={content}
messageId={`${turn.taskId}:trigger`}
@@ -156,6 +163,8 @@ function TriggerMessage({ turn, fullWidth }: { turn: ChildConversationTurn; full
isSubmitting={false}
isLatestMessage={false}
/>
+ ) : (
+ <div className="text-text-secondary text-sm italic">{label}</div>
)}
{turn.trigger.summaryTruncated === true && (
<div className="text-text-secondary mt-1 text-xs italic">
@@ -169,7 +178,7 @@ function TriggerMessage({ turn, fullWidth }: { turn: ChildConversationTurn; full
function ChildMessage({
turn,
state,
- agentId,
+ author,
conversationId,
fullWidth,
onCancelControl,
@@ -178,7 +187,7 @@ function ChildMessage({
}: {
turn: ChildConversationTurn;
state: 'ready' | 'loading' | 'error';
- agentId?: string;
+ author: TurnAuthor;
conversationId?: string | null;
fullWidth: boolean;
onCancelControl?: (controlId: string) => void;
@@ -186,9 +195,6 @@ function ChildMessage({
onLoadDetails?: () => void;
}) {
const localize = useLocalize();
- const agentsMap = useAgentsMapContext();
- const agent = agentId == null ? undefined : agentsMap?.[agentId];
- const label = agent?.name ?? turn.activity.title;
const detailsLimited = turn.activity.activityTruncated === true;
let limitedNotice: ReactNode;
if (detailsLimited && onLoadDetails != null && detailState !== 'unavailable') {
@@ -217,21 +223,13 @@ function ChildMessage({
const footer = (
<div className={cn('mt-1 flex justify-start gap-3', messageFooterClasses)}>{footerContent}</div>
);
- const iconData = {
- endpoint: EModelEndpoint.agents,
- modelLabel: label,
- isCreatedByUser: false,
- };
return (
<MessageRow
id={`${turn.taskId}:assistant`}
- /** The main chat author glyph, unconditionally: with no resolved agent it
- * falls back to the endpoint icon there too, so an unresolved child does
- * not get a differently-inset placeholder of its own. */
- icon={<MessageIcon iconData={iconData} agent={agent} />}
- label={label}
+ icon={author.icon}
+ label={author.name}
footer={footer}
- ariaLabel={label}
+ ariaLabel={author.name}
headerPrefix=""
isCreatedByUser={false}
fullWidth={fullWidth}
@@ -259,7 +257,8 @@ function ChildMessage({
export default function SubagentConversation({
turns,
- agentId,
+ author,
+ parentAuthor,
conversationId,
stateByTask,
controllableTaskId,
@@ -268,7 +267,10 @@ export default function SubagentConversation({
onLoadTurnDetails,
}: {
turns: ChildConversationTurn[];
- agentId?: string;
+ /** The child agent: every assistant turn's header. */
+ author: TurnAuthor;
+ /** The agent that briefs the child: every parent-written turn's header. */
+ parentAuthor: TurnAuthor;
conversationId?: string | null;
stateByTask?: ReadonlyMap<string, 'ready' | 'loading' | 'error'>;
controllableTaskId?: string;
@@ -286,12 +288,12 @@ export default function SubagentConversation({
data-subagent-thread-turn={turn.taskId}
>
<div className="px-4">
- <TriggerMessage turn={turn} fullWidth={fullWidth} />
+ <TriggerMessage turn={turn} fullWidth={fullWidth} parentAuthor={parentAuthor} />
</div>
<div className="px-4">
<ChildMessage
turn={turn}
- agentId={agentId}
+ author={author}
conversationId={conversationId}
fullWidth={fullWidth}
state={stateByTask?.get(turn.taskId) ?? 'ready'}
diff --git a/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx b/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx
index ed45802e70..57e110b813 100644
--- a/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx
+++ b/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx
@@ -1,11 +1,13 @@
import React from 'react';
import { useAtomValue, useSetAtom } from 'jotai';
-import { ContentTypes, ForkOptions } from 'librechat-data-provider';
-import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import { ContentTypes, EModelEndpoint, ForkOptions, QueryKeys } from 'librechat-data-provider';
import type {
- ParentSubagentSummary,
+ TMessage,
SubagentThreadView,
TMessageContentParts,
+ ParentSubagentSummary,
} from 'librechat-data-provider';
import type { ActiveSubagentPanel } from './state';
import type { JotaiStore } from 'test/harness';
@@ -37,6 +39,9 @@ const mockRefreshParentChildren = jest.fn().mockResolvedValue(undefined);
let mockEnterToSend = true;
const mockClaimForeground = jest.fn();
const mockHandOffComposerText = jest.fn();
+/** Real, per test: the panel reads the dispatching message from the parent
+ * conversation's loaded thread, the cache main chat itself renders from. */
+let queryClient = new QueryClient();
function Root({
seed,
@@ -46,16 +51,18 @@ function Root({
children: React.ReactNode;
}) {
return (
- <ChatSurfaceHarness
- seed={seed}
- surface={testChatSurface({
- enterToSend: mockEnterToSend,
- claimForeground: mockClaimForeground,
- handOffComposerText: mockHandOffComposerText,
- })}
- >
- {children}
- </ChatSurfaceHarness>
+ <QueryClientProvider client={queryClient}>
+ <ChatSurfaceHarness
+ seed={seed}
+ surface={testChatSurface({
+ enterToSend: mockEnterToSend,
+ claimForeground: mockClaimForeground,
+ handOffComposerText: mockHandOffComposerText,
+ })}
+ >
+ {children}
+ </ChatSurfaceHarness>
+ </QueryClientProvider>
);
}
@@ -123,6 +130,26 @@ jest.mock('~/Providers', () => ({
}),
}));
+/** Main chat's author glyph, reduced to the face it draws: the agent's avatar
+ * when it has one. */
+jest.mock('~/components/Chat/Messages/MessageIcon', () => ({
+ __esModule: true,
+ default: ({
+ agent,
+ iconData,
+ }: {
+ agent?: { avatar?: { filepath?: string } };
+ iconData?: { iconURL?: string };
+ }) => {
+ const src = iconData?.iconURL ?? agent?.avatar?.filepath;
+ return src != null ? (
+ <img src={src} alt="" data-testid="author-face" />
+ ) : (
+ <span data-testid="author-face" />
+ );
+ },
+}));
+
jest.mock('./ParentSubagentsProvider', () => ({
useParentSubagents: () => ({
byMessageId: mockParentChildrenByMessage,
@@ -198,10 +225,14 @@ jest.mock('./SubagentConversation', () => ({
__esModule: true,
default: ({
turns,
+ author,
+ parentAuthor,
stateByTask,
detailStateByTask,
onLoadTurnDetails,
}: {
+ author: { name: string; icon: React.ReactNode };
+ parentAuthor: { name: string };
turns: Array<{
taskId: string;
trigger: { summary: string };
@@ -214,7 +245,10 @@ jest.mock('./SubagentConversation', () => ({
<div
data-testid="subagent-conversation"
data-state={turns[0] == null ? undefined : stateByTask?.get(turns[0].taskId)}
+ data-author={author.name}
+ data-parent-author={parentAuthor.name}
>
+ {author.icon}
{turns.map((turn) => (
<div key={turn.taskId} data-testid="conversation-turn">
{turn.trigger.summary}
@@ -455,8 +489,20 @@ const completedView: SubagentThreadView = {
],
};
+const completedTurns: SubagentThreadView['turns'] = [
+ {
+ taskId: 'task',
+ trigger: { kind: 'parent_dispatch', summary: 'Historical request.' },
+ status: 'completed',
+ activity: completedView.activity,
+ activityTruncated: false,
+ messages: completedView.messages,
+ },
+];
+
describe('SubagentThreadPanel', () => {
beforeEach(() => {
+ queryClient = new QueryClient();
window.sessionStorage.clear();
mockIsMobile = false;
mockCoarsePointer = false;
@@ -489,21 +535,645 @@ describe('SubagentThreadPanel', () => {
...selection,
durable: undefined,
subagentType,
- subagentIdentity: { subagentKind: 'agent' as const, subagentAgentId: subagentType },
+ subagentIdentity: {
+ subagentKind: 'agent' as const,
+ subagentAgentId: subagentType === 'self' ? 'agent-2' : subagentType,
+ },
};
- render(
+ /** The dispatching agent, as main chat holds it: a self-spawn is that
+ * agent working on its own behalf, so it takes the parent's name. */
+ queryClient.setQueryData<TMessage[]>(
+ [QueryKeys.messages, 'parent-conversation'],
+ [
+ {
+ messageId: 'parent-message',
+ parentMessageId: null,
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ endpoint: EModelEndpoint.agents,
+ model: 'agent-2',
+ sender: 'Analyst Two',
+ text: '',
+ } as unknown as TMessage,
+ ],
+ );
+ const { container } = render(
<Root>
<SubagentThreadPanel selection={foregroundSelection} />
</Root>,
);
- const title =
- subagentType === 'self'
- ? 'com_ui_subagent_dialog_title_self'
- : `com_ui_subagent_dialog_title: ${subagentType === 'agent-1' ? 'Analyst One' : subagentType}`;
- expect(screen.getByRole('heading', { name: title })).toBeInTheDocument();
+ const titles: Record<string, string> = {
+ 'agent-1': 'Analyst One',
+ 'missing-agent': 'com_ui_subagent_actor',
+ self: 'Analyst Two',
+ };
+ expect(screen.getByRole('heading', { name: titles[subagentType] })).toBeInTheDocument();
+ /** Never the id: an unresolvable agent is named generically. */
+ expect(screen.queryByText(/missing-agent/)).not.toBeInTheDocument();
if (subagentType === 'agent-1') {
- expect(screen.getByAltText('Analyst One avatar')).toHaveAttribute('src', '/analyst.png');
+ expect(container.querySelector('header img[src="/analyst.png"]')).toBeInTheDocument();
+ }
+ },
+ );
+
+ it('uses the durable title when the child agent is unavailable', () => {
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: { ...completedView, agentId: 'agent_deleted', title: 'Historical Reviewer' },
+ });
+ render(
+ <Root>
+ <SubagentThreadPanel selection={selection} />
+ </Root>,
+ );
+ expect(screen.getByRole('heading', { name: 'Historical Reviewer' })).toBeInTheDocument();
+ expect(screen.getByRole('textbox')).toHaveAttribute(
+ 'placeholder',
+ 'com_endpoint_message_new: Historical Reviewer',
+ );
+ });
+
+ it('restores a self-spawn with the complete historical parent author', () => {
+ queryClient.setQueryData<TMessage[]>(
+ [QueryKeys.messages, 'parent-conversation'],
+ [
+ {
+ messageId: 'parent-message',
+ parentMessageId: null,
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ endpoint: EModelEndpoint.agents,
+ model: 'agent_deleted',
+ sender: 'Historical Parent',
+ iconURL: '/historical-parent.png',
+ text: '',
+ },
+ ],
+ );
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: {
+ ...completedView,
+ subagentType: 'self',
+ agentId: 'agent_deleted',
+ turns: completedTurns,
+ },
+ });
+ const { container } = render(
+ <Root>
+ <SubagentThreadPanel
+ selection={{
+ ...selection,
+ subagentType: 'self',
+ }}
+ />
+ </Root>,
+ );
+ expect(screen.getByRole('heading', { name: 'Historical Parent' })).toBeInTheDocument();
+ expect(container.querySelector('header img[src="/historical-parent.png"]')).toBeInTheDocument();
+ const conversation = screen.getByTestId('subagent-conversation');
+ expect(conversation).toHaveAttribute('data-author', 'Historical Parent');
+ expect(within(conversation).getByRole('img', { hidden: true })).toHaveAttribute(
+ 'src',
+ '/historical-parent.png',
+ );
+ });
+
+ it.each(['selection', 'durable'])(
+ 'keeps a graph named self distinct from its parent (%s identity)',
+ (source) => {
+ queryClient.setQueryData<TMessage[]>(
+ [QueryKeys.messages, 'parent-conversation'],
+ [
+ {
+ messageId: 'parent-message',
+ parentMessageId: null,
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ endpoint: EModelEndpoint.agents,
+ model: 'agent_deleted',
+ sender: 'Historical Parent',
+ iconURL: '/historical-parent.png',
+ text: '',
+ },
+ ],
+ );
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: {
+ ...completedView,
+ agentId: undefined,
+ subagentType: 'self',
+ title: 'self',
+ subagentKind: source === 'durable' ? 'graph' : undefined,
+ turns: completedTurns,
+ },
+ });
+ const { container } = render(
+ <Root>
+ <SubagentThreadPanel
+ selection={{
+ ...selection,
+ subagentType: 'self',
+ subagentIdentity:
+ source === 'selection'
+ ? { subagentKind: 'graph', subagentAgentId: 'graph:self' }
+ : undefined,
+ }}
+ />
+ </Root>,
+ );
+ expect(screen.getByRole('heading', { name: 'self' })).toBeInTheDocument();
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute('data-author', 'self');
+ expect(container.querySelector('header img[src="/historical-parent.png"]')).toBeNull();
+ },
+ );
+
+ it.each([false, true])(
+ 'preserves indexed graph identity before query success (failed: %s)',
+ (failed) => {
+ const child: ParentSubagentSummary = {
+ threadId: 'child-thread',
+ parentMessageId: 'parent-message',
+ subagentType: 'self',
+ subagentKind: 'graph',
+ title: 'self',
+ origin: 'tool',
+ status: 'completed',
+ latestTaskId: 'task',
+ tasks: [{ taskId: 'task', status: 'completed' }],
+ tasksTruncated: false,
+ };
+ mockParentChildrenByThread.set(child.threadId, child);
+ queryClient.setQueryData<TMessage[]>(
+ [QueryKeys.messages, 'parent-conversation'],
+ [
+ {
+ messageId: 'parent-message',
+ parentMessageId: null,
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ endpoint: EModelEndpoint.agents,
+ model: 'agent_deleted',
+ sender: 'Historical Parent',
+ iconURL: '/historical-parent.png',
+ text: '',
+ },
+ ],
+ );
+ mockUseSubagentThreadQuery.mockReturnValue({ isLoading: !failed, isError: failed });
+ const { container } = render(
+ <Root>
+ <SubagentThreadPanel selection={{ ...selection, subagentType: 'self' }} />
+ </Root>,
+ );
+ expect(screen.getByRole('heading', { name: 'self' })).toBeInTheDocument();
+ expect(container.querySelector('header img[src="/historical-parent.png"]')).toBeNull();
+ },
+ );
+
+ it('refreshes dispatch-lane attribution when switching streamed tool calls in one parent turn', async () => {
+ const first: TMessage = {
+ messageId: 'parent-message',
+ parentMessageId: null,
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ text: '',
+ endpoint: EModelEndpoint.agents,
+ model: 'agent-2',
+ sender: 'Analyst Two',
+ content: [
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'agent-2',
+ tool_call: { id: 'first-call', name: 'subagent', args: {} },
+ },
+ ],
+ };
+ queryClient.setQueryData([QueryKeys.messages, 'parent-conversation'], [first]);
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: { ...completedView, turns: completedTurns },
+ });
+ const { rerender } = render(
+ <Root>
+ <SubagentThreadPanel selection={{ ...selection, toolCallId: 'first-call' }} />
+ </Root>,
+ );
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-parent-author',
+ 'Analyst Two',
+ );
+ await act(async () => {
+ queryClient.setQueryData(
+ [QueryKeys.messages, 'parent-conversation'],
+ [
+ {
+ ...first,
+ content: [
+ ...(first.content ?? []),
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'agent-1',
+ tool_call: { id: 'second-call', name: 'subagent', args: {} },
+ },
+ ],
+ },
+ ],
+ );
+ });
+ rerender(
+ <Root>
+ <SubagentThreadPanel selection={{ ...selection, toolCallId: 'second-call' }} />
+ </Root>,
+ );
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-parent-author',
+ 'Analyst One',
+ );
+ await act(async () => {
+ queryClient.setQueryData(
+ [QueryKeys.messages, 'parent-conversation'],
+ [{ ...first, sender: 'Changed snapshot', text: 'Later chunk' }],
+ );
+ });
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-parent-author',
+ 'Analyst One',
+ );
+ });
+
+ it('switches repeated provider IDs between parallel dispatch occurrences', async () => {
+ const first: TMessage = {
+ messageId: 'parent-message',
+ parentMessageId: null,
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ text: '',
+ endpoint: EModelEndpoint.agents,
+ model: 'agent-2',
+ sender: 'Analyst Two',
+ content: [
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'agent-2',
+ tool_call: { id: 'repeat', name: 'subagent', args: {} },
+ },
+ ],
+ };
+ queryClient.setQueryData([QueryKeys.messages, 'parent-conversation'], [first]);
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: { ...completedView, turns: completedTurns },
+ });
+ const { rerender } = render(
+ <Root>
+ <SubagentThreadPanel
+ selection={{ ...selection, durable: undefined, toolCallId: 'repeat', partIndex: 0 }}
+ />
+ </Root>,
+ );
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-parent-author',
+ 'Analyst Two',
+ );
+ await act(async () => {
+ queryClient.setQueryData(
+ [QueryKeys.messages, 'parent-conversation'],
+ [
+ {
+ ...first,
+ content: [
+ ...(first.content ?? []),
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'agent-1',
+ tool_call: { id: 'repeat', name: 'subagent', args: {} },
+ },
+ ],
+ },
+ ],
+ );
+ });
+ rerender(
+ <Root>
+ <SubagentThreadPanel
+ selection={{ ...selection, durable: undefined, toolCallId: 'repeat', partIndex: 1 }}
+ />
+ </Root>,
+ );
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-parent-author',
+ 'Analyst One',
+ );
+ });
+
+ it.each([false, true])(
+ 'retains an indexed saved agent while durable details are unavailable (failed: %s)',
+ (failed) => {
+ const child: ParentSubagentSummary = {
+ threadId: 'child-thread',
+ parentMessageId: 'parent-message',
+ subagentType: 'agent-2',
+ subagentKind: 'agent',
+ agentId: 'agent-2',
+ title: 'Analyst Two',
+ origin: 'tool',
+ status: 'completed',
+ latestTaskId: 'task',
+ tasks: [{ taskId: 'task', status: 'completed' }],
+ tasksTruncated: false,
+ };
+ mockParentChildrenByThread.set(child.threadId, child);
+ mockUseSubagentThreadQuery.mockReturnValue({ isLoading: !failed, isError: failed });
+ render(
+ <Root>
+ <SubagentThreadPanel
+ selection={{ ...selection, subagentType: 'agent-2', subagentIdentity: undefined }}
+ />
+ </Root>,
+ );
+ expect(screen.getByRole('heading', { name: 'Analyst Two' })).toBeInTheDocument();
+ },
+ );
+
+ it.each(
+ ['Historical Reviewer', 'Subagent: Reviewer', 'self', 'agent_research_team'].flatMap((title) =>
+ [false, true].map((failed) => ({ title, failed })),
+ ),
+ )('retains an unavailable indexed agent title $title (failed: $failed)', ({ title, failed }) => {
+ const child: ParentSubagentSummary = {
+ threadId: 'child-thread',
+ parentMessageId: 'parent-message',
+ subagentType: 'agent_deleted',
+ subagentKind: 'agent',
+ agentId: 'agent_deleted',
+ title,
+ origin: 'tool',
+ status: 'completed',
+ latestTaskId: 'task',
+ tasks: [{ taskId: 'task', status: 'completed' }],
+ tasksTruncated: false,
+ };
+ mockParentChildrenByThread.set(child.threadId, child);
+ mockUseSubagentThreadQuery.mockReturnValue({ isLoading: !failed, isError: failed });
+ const view = render(
+ <Root>
+ <SubagentThreadPanel
+ selection={{ ...selection, subagentType: 'agent_deleted', subagentIdentity: undefined }}
+ />
+ </Root>,
+ );
+ expect(screen.getByRole('heading', { name: title })).toBeInTheDocument();
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute('data-author', title);
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: { ...completedView, agentId: 'agent_deleted', title },
+ });
+ view.rerender(
+ <Root>
+ <SubagentThreadPanel
+ selection={{ ...selection, subagentType: 'agent_deleted', subagentIdentity: undefined }}
+ />
+ </Root>,
+ );
+ expect(screen.getByRole('heading', { name: title })).toBeInTheDocument();
+ expect(screen.getByRole('textbox')).toHaveAttribute(
+ 'placeholder',
+ `com_endpoint_message_new: ${title}`,
+ );
+ });
+
+ it('preserves a literal graph display title beginning with Subagent:', () => {
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: {
+ ...completedView,
+ agentId: undefined,
+ subagentKind: 'graph',
+ subagentType: 'Subagent: research',
+ title: 'Subagent: research',
+ turns: completedTurns,
+ },
+ });
+ render(
+ <Root>
+ <SubagentThreadPanel selection={{ ...selection, subagentType: 'Subagent: research' }} />
+ </Root>,
+ );
+ expect(screen.getByRole('heading', { name: 'Subagent: research' })).toBeInTheDocument();
+ });
+
+ it.each(['self', 'researcher'])(
+ 'resolves a restored %s dispatch by thread handle rather than its placeholder index',
+ (type) => {
+ const handle = (threadId: string) =>
+ JSON.stringify({
+ background_task_id: 'task',
+ subagent_thread_id: threadId,
+ tool: 'subagent',
+ subagent_type: type,
+ status: 'running',
+ message: 'Poll using background_task_id task.',
+ });
+ const dispatch: TMessage = {
+ messageId: 'parent-message',
+ parentMessageId: null,
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ text: '',
+ endpoint: EModelEndpoint.agents,
+ model: 'agent-2',
+ sender: 'Analyst Two',
+ content: [
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'agent-2',
+ tool_call: {
+ id: 'repeat',
+ name: 'subagent',
+ args: { run_in_background: true },
+ output: handle('first-child'),
+ },
+ },
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'agent-1',
+ tool_call: {
+ id: 'repeat',
+ name: 'subagent',
+ args: { run_in_background: true },
+ output: handle('child-thread'),
+ },
+ },
+ ],
+ };
+ queryClient.setQueryData([QueryKeys.messages, 'parent-conversation'], [dispatch]);
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: { ...completedView, subagentType: type, agentId: 'agent-1', turns: completedTurns },
+ });
+ render(
+ <Root>
+ <SubagentThreadPanel
+ selection={{ ...selection, subagentType: type, toolCallId: 'repeat', partIndex: 0 }}
+ />
+ </Root>,
+ );
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-parent-author',
+ 'Analyst One',
+ );
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-author',
+ 'Analyst One',
+ );
+ },
+ );
+
+ it('attributes restored parallel-lane self turns to the validated spawning agent', () => {
+ queryClient.setQueryData<TMessage[]>(
+ [QueryKeys.messages, 'parent-conversation'],
+ [
+ {
+ messageId: 'parent-message',
+ parentMessageId: null,
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ text: '',
+ endpoint: EModelEndpoint.agents,
+ model: 'agent-2',
+ sender: 'Analyst Two',
+ },
+ ],
+ );
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: { ...completedView, subagentType: 'self', agentId: 'agent-1', turns: completedTurns },
+ });
+ const { container } = render(
+ <Root>
+ <SubagentThreadPanel selection={{ ...selection, subagentType: 'self' }} />
+ </Root>,
+ );
+ expect(screen.getByRole('heading', { name: 'Analyst One' })).toBeInTheDocument();
+ expect(container.querySelector('header img[src="/analyst.png"]')).toBeInTheDocument();
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-author',
+ 'Analyst One',
+ );
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-parent-author',
+ 'Analyst One',
+ );
+ });
+
+ it('resolves a missing historical parent after its reply arrives and retains that author', async () => {
+ queryClient.setQueryData<TMessage[]>([QueryKeys.messages, 'parent-conversation'], []);
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: {
+ ...completedView,
+ agentId: 'agent_deleted',
+ subagentType: 'self',
+ turns: completedTurns,
+ },
+ });
+ const { container } = render(
+ <Root>
+ <SubagentThreadPanel selection={{ ...selection, subagentType: 'self' }} />
+ </Root>,
+ );
+ expect(
+ screen.getByRole('heading', { name: 'com_ui_subagent_parent_agent' }),
+ ).toBeInTheDocument();
+ const reply: TMessage = {
+ messageId: 'reply',
+ parentMessageId: 'parent-message',
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ endpoint: EModelEndpoint.agents,
+ model: 'agent_deleted',
+ sender: 'Late Parent',
+ iconURL: '/late.png',
+ text: '',
+ };
+ await act(async () => {
+ queryClient.setQueryData([QueryKeys.messages, 'parent-conversation'], [reply]);
+ });
+ expect(screen.getByRole('heading', { name: 'Late Parent' })).toBeInTheDocument();
+ expect(container.querySelector('header img[src="/late.png"]')).toBeInTheDocument();
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-author',
+ 'Late Parent',
+ );
+ await act(async () => {
+ queryClient.setQueryData(
+ [QueryKeys.messages, 'parent-conversation'],
+ [{ ...reply, sender: 'Changed snapshot', iconURL: '/changed.png', text: 'Next chunk' }],
+ );
+ });
+ expect(screen.getByRole('heading', { name: 'Late Parent' })).toBeInTheDocument();
+ expect(container.querySelector('header img[src="/late.png"]')).toBeInTheDocument();
+ });
+
+ it.each([true, false])(
+ 'names an unavailable event actor by its projected label (indexed: %s)',
+ (indexed) => {
+ const child: ParentSubagentSummary = {
+ threadId: 'child-thread',
+ parentMessageId: 'parent-message',
+ subagentType: 'agent_deleted',
+ subagentKind: 'agent',
+ agentId: 'agent_deleted',
+ title: 'Agent actor: reviewer',
+ origin: 'event',
+ actorId: 'reviewer',
+ status: 'completed',
+ latestTaskId: 'task',
+ tasks: [{ taskId: 'task', status: 'completed' }],
+ tasksTruncated: false,
+ };
+ if (indexed) {
+ mockParentChildrenByMessage = new Map([['parent-message', [child]]]);
+ mockParentChildrenByThread = new Map([[child.threadId, child]]);
}
+ mockUseSubagentThreadQuery.mockReturnValue({
+ isLoading: false,
+ isError: false,
+ data: {
+ ...completedView,
+ agentId: 'agent_deleted',
+ title: child.title,
+ turns: completedTurns,
+ },
+ });
+ render(
+ <Root>
+ <SubagentThreadPanel
+ selection={{
+ ...selection,
+ event: { actorId: 'reviewer', progressKey: 'event-task:child-thread:task' },
+ }}
+ />
+ </Root>,
+ );
+ expect(screen.getByTestId('subagent-conversation')).toHaveAttribute(
+ 'data-author',
+ 'reviewer',
+ );
+ expect(screen.getByRole('heading', { name: 'reviewer' })).toBeInTheDocument();
+ expect(screen.queryByText('Agent actor: reviewer')).not.toBeInTheDocument();
},
);
@@ -523,10 +1193,9 @@ describe('SubagentThreadPanel', () => {
/>
</Root>,
);
- expect(
- screen.getByRole('heading', { name: 'com_ui_subagent_dialog_title: agent-1' }),
- ).toBeInTheDocument();
- expect(screen.queryByAltText('Analyst One avatar')).not.toBeInTheDocument();
+ /** A non-agent type is a readable name of its own, not an agent to look up. */
+ expect(screen.getByRole('heading', { name: 'agent-1' })).toBeInTheDocument();
+ expect(document.querySelector('img[src="/analyst.png"]')).toBeNull();
},
);
@@ -641,13 +1310,33 @@ describe('SubagentThreadPanel', () => {
isReadinessPending: false,
});
+ queryClient.setQueryData<TMessage[]>(
+ [QueryKeys.messages, 'parent-conversation'],
+ [
+ {
+ messageId: 'parent-message',
+ parentMessageId: null,
+ conversationId: 'parent-conversation',
+ isCreatedByUser: false,
+ endpoint: EModelEndpoint.agents,
+ model: 'agent-2',
+ sender: 'Analyst Two',
+ text: '',
+ } as unknown as TMessage,
+ ],
+ );
render(
<Root>
<SubagentThreadPanel selection={selection} />
</Root>,
);
- expect(screen.getByTestId('subagent-conversation')).toBeInTheDocument();
+ /** One name for the child everywhere it appears, and the dispatching agent
+ * as the author of every briefing — never an id or a role. */
+ const conversation = screen.getByTestId('subagent-conversation');
+ expect(conversation).toHaveAttribute('data-author', 'Analyst One');
+ expect(conversation).toHaveAttribute('data-parent-author', 'Analyst Two');
+ expect(screen.getByRole('heading', { name: 'Analyst One' })).toBeInTheDocument();
expect(screen.getAllByTestId('conversation-turn')).toHaveLength(2);
expect(screen.getByText(/Initial request/)).toBeInTheDocument();
expect(screen.getByText(/Follow-up request/)).toBeInTheDocument();
@@ -703,6 +1392,8 @@ describe('SubagentThreadPanel', () => {
);
const composer = screen.getByLabelText('com_ui_message_input');
+ /** Addressed by name, as main chat's composer addresses its agent. */
+ expect(composer).toHaveAttribute('placeholder', 'com_endpoint_message_new: Analyst One');
fireEvent.change(composer, { target: { value: 'Check the primary source.' } });
fireEvent.keyDown(composer, { key: 'Enter' });
expect(mockControlMutate).not.toHaveBeenCalled();
diff --git a/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx b/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx
index 1f774d8b0b..fcbc10745d 100644
--- a/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx
+++ b/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx
@@ -36,6 +36,14 @@ import {
useSubagentControlMutation,
useSubagentThreadQuery,
} from '~/data-provider';
+import {
+ agentAuthor,
+ resolveSubagentAuthor,
+ isSelfSpawn as isSelfSpawnType,
+ resolveChildAgent,
+ readableSubagentType,
+ useParentAuthor,
+} from './author';
import {
activeSubagentPanel,
subagentControlStateByTask,
@@ -151,14 +159,14 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
selection.partIndex,
),
);
- const foregroundAgentId = resolveSubagentAgentId(progress, selection.subagentIdentity);
- const foregroundAgent = foregroundAgentId == null ? undefined : agentsMap?.[foregroundAgentId];
- const foregroundTitle =
- selection.subagentType === 'self'
- ? localize('com_ui_subagent_dialog_title_self')
- : localize('com_ui_subagent_dialog_title', {
- 0: foregroundAgent?.name || selection.subagentType,
- });
+ const parentAuthor = useParentAuthor(
+ selection.parentConversationId,
+ selection.parentMessageId,
+ localize('com_ui_subagent_parent_agent'),
+ selection.toolCallId,
+ selection.partIndex,
+ selection.durable?.threadId,
+ );
const threadId = selection.durable?.threadId ?? '';
const taskId = selection.durable?.taskId ?? '';
const controlIdentity = subagentControlStateKey(selection.parentConversationId, threadId, taskId);
@@ -213,13 +221,6 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
});
}, [byMessageId, selection.event, selection.parentMessageId]);
const selectedEventActor = eventSiblings.find((child) => child.threadId === threadId);
- const selectedEventActorName =
- (selectedEventActor?.agentId == null
- ? undefined
- : agentsMap?.[selectedEventActor.agentId]?.name) ??
- selectedEventActor?.actorId ??
- eventSummary?.actorId ??
- foregroundTitle;
const { data, isLoading, isError, isPreviousData, isReadinessPending, refetch } =
useSubagentThreadQuery(selection.parentConversationId, threadId, taskId, {
/** A new delivery re-keys this query to its task. Keeping the previous
@@ -234,6 +235,34 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
* task-scoped fields (selected activity, status, control receipts) must not
* be attributed to the newly selected task. */
const threadView = data?.threadId === threadId ? data : undefined;
+ const childKind =
+ threadView?.subagentKind ??
+ progress?.subagentKind ??
+ selection.subagentIdentity?.subagentKind ??
+ byThreadId.get(threadId)?.subagentKind;
+ const isSelfSpawn = isSelfSpawnType(selection.subagentType, childKind);
+ const foregroundAgentId =
+ childKind === 'graph'
+ ? undefined
+ : (resolveSubagentAgentId(progress, selection.subagentIdentity) ??
+ byThreadId.get(threadId)?.agentId);
+ const foregroundAgent = foregroundAgentId == null ? undefined : agentsMap?.[foregroundAgentId];
+ /** Named the way main chat names an agent turn — never by its id. A
+ * self-spawn is the parent agent working on its own behalf. */
+ const foregroundTitle =
+ foregroundAgent?.name ||
+ (isSelfSpawn
+ ? parentAuthor.name
+ : readableSubagentType(selection.subagentType, foregroundAgentId, childKind)) ||
+ localize('com_ui_subagent_actor');
+ const selectedEventActorName =
+ (selectedEventActor?.agentId == null
+ ? undefined
+ : agentsMap?.[selectedEventActor.agentId]?.name) ??
+ selectedEventActor?.actorId ??
+ eventSummary?.actorId ??
+ selection.event?.actorId ??
+ foregroundTitle;
const taskView = isPreviousData ? undefined : threadView;
const latestHistoryGeneration = JSON.stringify([
threadView?.nextCursor ?? null,
@@ -826,9 +855,48 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
}
return { ...merged, controls: [...(merged.controls ?? []), transientControl] };
}, [liveActivity, progress, selection.durable, taskView, transientControl]);
- const panelAgent = threadView?.agentId == null ? undefined : agentsMap?.[threadView.agentId];
- const panelTitle =
- selection.event == null ? panelAgent?.name || activity.title : selectedEventActorName;
+ const selectedActorAgentId =
+ selectedEventActor?.agentId ?? threadView?.agentId ?? foregroundAgentId;
+ const selectedActorAgent = resolveChildAgent(
+ selectedActorAgentId,
+ selection.subagentType,
+ parentAuthor.agent,
+ agentsMap,
+ childKind,
+ );
+ /** One author for the header, the composer and every child turn, so the three
+ * can never name the child differently. */
+ const childAuthor = useMemo(
+ () =>
+ selection.event != null
+ ? agentAuthor(selectedActorAgent, selectedEventActorName)
+ : resolveSubagentAuthor(
+ {
+ agentId: selectedActorAgentId,
+ subagentType: selection.subagentType,
+ subagentKind: childKind,
+ title: threadView?.title ?? byThreadId.get(threadId)?.title,
+ },
+ parentAuthor,
+ agentsMap,
+ localize('com_ui_subagent_actor'),
+ ),
+ [
+ agentsMap,
+ byThreadId,
+ childKind,
+ localize,
+ parentAuthor,
+ selectedActorAgent,
+ selectedActorAgentId,
+ selectedEventActorName,
+ selection.event,
+ selection.subagentType,
+ threadId,
+ threadView?.title,
+ ],
+ );
+ const panelTitle = childAuthor.name;
const actorOptions = useMemo<OptionWithIcon[]>(() => {
if (selection.event == null) return [];
return (
@@ -839,7 +907,11 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
.filter((child) => child.latestTaskId != null || child.threadId === threadId)
.map((child) => {
const agent = child.agentId == null ? undefined : agentsMap?.[child.agentId];
- const name = agent?.name || child.actorId || child.title;
+ const name =
+ agent?.name ||
+ child.actorId ||
+ readableSubagentType(child.subagentType, child.agentId, child.subagentKind) ||
+ localize('com_ui_subagent_actor');
return {
value: child.threadId,
label:
@@ -848,15 +920,14 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
};
})
);
- }, [agentsMap, eventSiblings, selection.event, threadId]);
+ }, [agentsMap, eventSiblings, localize, selection.event, threadId]);
const selectedActorLabel =
actorOptions.find((option) => option.value === threadId)?.label ?? panelTitle;
- const selectedActorAgentId =
- selectedEventActor?.agentId ?? threadView?.agentId ?? foregroundAgentId;
- const selectedActorIcon = renderAgentAvatar(
- selectedActorAgentId == null ? undefined : agentsMap?.[selectedActorAgentId],
- { size: 'icon', showBorder: false },
- );
+ /** The picker's own glyph, matching the rows it lists. */
+ const selectedActorIcon = renderAgentAvatar(selectedActorAgent, {
+ size: 'icon',
+ showBorder: false,
+ });
const latestConversationTurns = useMemo(
() => (threadView == null ? [] : adaptDurableThreadConversation(threadView)),
[threadView],
@@ -1353,7 +1424,8 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
)}
<SubagentConversation
turns={conversationTurns}
- agentId={threadView?.agentId}
+ author={childAuthor}
+ parentAuthor={isSelfSpawn && selection.event == null ? childAuthor : parentAuthor}
conversationId={threadId || selection.parentConversationId}
stateByTask={conversationStateByTask}
controllableTaskId={
@@ -1451,10 +1523,10 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
</div>
) : (
<>
- {/* The `MessageRow` author-glyph slot, one size up: no plate
- behind it, so an agent avatar reads as the avatar it is. */}
+ {/* The `MessageRow` author glyph, one size up: the same face the
+ child's turns below carry. */}
<div className="flex h-8 w-8 shrink-0 items-center justify-center overflow-hidden rounded-full">
- {selectedActorIcon}
+ {childAuthor.icon}
</div>
<h2 className="min-w-0 flex-1 truncate text-sm font-semibold" title={panelTitle}>
{panelTitle}
diff --git a/client/src/components/Chat/Subagents/author.public.test.tsx b/client/src/components/Chat/Subagents/author.public.test.tsx
new file mode 100644
index 0000000000..3d44030c3e
--- /dev/null
+++ b/client/src/components/Chat/Subagents/author.public.test.tsx
@@ -0,0 +1,56 @@
+import { RecoilRoot } from 'recoil';
+import { render, screen, waitFor } from '@testing-library/react';
+import { dataService, EModelEndpoint } from 'librechat-data-provider';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import type { TMessage } from 'librechat-data-provider';
+import { ShareContext } from '~/Providers/ShareContext';
+import { agentAuthor, messageAuthor } from './author';
+
+jest.mock('librechat-data-provider', () => {
+ const actual = jest.requireActual('librechat-data-provider');
+ return {
+ ...actual,
+ dataService: { ...actual.dataService, getAIEndpoints: jest.fn().mockResolvedValue({}) },
+ };
+});
+
+const historicalMessage: TMessage = {
+ messageId: 'parent',
+ parentMessageId: null,
+ conversationId: 'shared',
+ isCreatedByUser: false,
+ text: '',
+ sender: 'Historical Parent',
+ model: 'agent_deleted',
+ endpoint: EModelEndpoint.agents,
+ iconURL: '/historical.png',
+};
+
+it('draws public-share authors without private requests and enables them again in chat', async () => {
+ const getEndpoints = jest.mocked(dataService.getAIEndpoints);
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+ const child = agentAuthor(undefined, 'Agent');
+ const parent = messageAuthor(historicalMessage, undefined, 'Parent agent');
+ const tree = (isSharedConvo: boolean) => (
+ <RecoilRoot>
+ <QueryClientProvider client={queryClient}>
+ <ShareContext.Provider value={{ isSharedConvo }}>
+ {child.icon}
+ {parent.icon}
+ </ShareContext.Provider>
+ </QueryClientProvider>
+ </RecoilRoot>
+ );
+ const { rerender } = render(tree(true));
+
+ expect(screen.getByRole('img', { name: 'Historical Parent' })).toHaveAttribute(
+ 'src',
+ '/historical.png',
+ );
+ expect(queryClient.isFetching()).toBe(0);
+ expect(getEndpoints).not.toHaveBeenCalled();
+
+ rerender(tree(false));
+ await waitFor(() => expect(getEndpoints).toHaveBeenCalledTimes(1));
+ queryClient.clear();
+});
diff --git a/client/src/components/Chat/Subagents/author.test.ts b/client/src/components/Chat/Subagents/author.test.ts
new file mode 100644
index 0000000000..d0161b55c4
--- /dev/null
+++ b/client/src/components/Chat/Subagents/author.test.ts
@@ -0,0 +1,141 @@
+import { ContentTypes, EModelEndpoint } from 'librechat-data-provider';
+import type { TMessage } from 'librechat-data-provider';
+import {
+ isSelfSpawn,
+ messageAuthor,
+ resolveSelfAuthor,
+ resolveSubagentAuthor,
+ findAgentLaneId,
+ resolveChildAgent,
+ readableSubagentType,
+ readableSubagentTitle,
+ findAgentAuthorMessage,
+} from './author';
+
+function message(
+ messageId: string,
+ parentMessageId: string | null,
+ isCreatedByUser = false,
+): TMessage {
+ return {
+ messageId,
+ parentMessageId,
+ isCreatedByUser,
+ conversationId: 'parent',
+ text: '',
+ sender: messageId,
+ endpoint: EModelEndpoint.agents,
+ };
+}
+
+it('prefers the dispatch itself over an earlier reply and preserves the first agent reply', () => {
+ const firstReply = message('first', 'dispatch');
+ const dispatch = message('dispatch', null);
+ const messages = [
+ message('user', null, true),
+ firstReply,
+ dispatch,
+ message('second', 'dispatch'),
+ ];
+ expect(findAgentAuthorMessage(messages, 'dispatch')).toBe(dispatch);
+ expect(findAgentAuthorMessage(messages, 'missing')).toBeUndefined();
+ expect(findAgentAuthorMessage([firstReply, message('second', 'dispatch')], 'dispatch')).toBe(
+ firstReply,
+ );
+});
+
+it('shares one history traversal across multiple wake-up authors and indexes a new snapshot', () => {
+ const messages = Array.from({ length: 1000 }, (_, i) => message(`reply-${i}`, `wake-${i}`));
+ const traversal = jest.spyOn(messages, Symbol.iterator);
+ for (let i = 0; i < messages.length; i++) {
+ expect(findAgentAuthorMessage(messages, `wake-${i}`)).toBe(messages[i]);
+ }
+ expect(traversal).toHaveBeenCalledTimes(1);
+ const added = message('added', 'new-wake');
+ expect(findAgentAuthorMessage([...messages, added], 'new-wake')).toBe(added);
+ expect(findAgentAuthorMessage(messages, 'new-wake')).toBeUndefined();
+});
+
+it('preserves self as an explicit graph alias across author resolution', () => {
+ expect(isSelfSpawn('self', 'graph')).toBe(false);
+ expect(isSelfSpawn('self', 'agent')).toBe(true);
+ expect(isSelfSpawn('self')).toBe(true);
+ expect(readableSubagentType('self', undefined, 'graph')).toBe('self');
+ expect(readableSubagentType('self')).toBeUndefined();
+ expect(resolveChildAgent('agent-1', 'self', undefined, {}, 'graph')).toBeUndefined();
+});
+
+it('retains matching historical snapshots and never borrows an enclosing avatar for a missing lane', () => {
+ const snapshot = message('dispatch', null);
+ snapshot.model = 'agent_deleted';
+ snapshot.sender = 'Historical Parent';
+ snapshot.iconURL = '/historical.png';
+ const parent = messageAuthor(snapshot, undefined, 'Agent');
+ expect(resolveSelfAuthor(parent, 'agent_deleted', undefined, 'Agent')).toBe(parent);
+ expect(resolveSelfAuthor(parent, undefined, undefined, 'Agent')).toBe(parent);
+ expect(resolveSelfAuthor(parent, 'agent_missing_lane', undefined, 'Agent').name).toBe('Agent');
+ expect(messageAuthor(snapshot, undefined, 'Agent', 'agent_missing_lane').name).toBe('Agent');
+ expect(findAgentLaneId(snapshot, 'missing')).toBeUndefined();
+});
+
+it('retains legacy graph aliases while suppressing identities known to be agent IDs', () => {
+ expect(readableSubagentType('agent_research_team')).toBe('agent_research_team');
+ expect(readableSubagentType('agent_research_team', undefined, 'graph')).toBe(
+ 'agent_research_team',
+ );
+ expect(readableSubagentType('agent_deleted', 'agent_deleted')).toBeUndefined();
+ expect(readableSubagentType('agent_deleted', undefined, 'agent')).toBeUndefined();
+});
+
+it('resolves repeated tool IDs by their content-part occurrence and rejects ambiguous legacy matches', () => {
+ const dispatch = message('dispatch', null);
+ dispatch.content = [
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'first',
+ tool_call: { id: 'repeat', name: 'subagent', args: {} },
+ },
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'second',
+ tool_call: { id: 'repeat', name: 'subagent', args: {} },
+ },
+ ];
+ expect(findAgentLaneId(dispatch, 'repeat', 0)).toBe('first');
+ expect(findAgentLaneId(dispatch, 'repeat', 1)).toBe('second');
+ expect(findAgentLaneId(dispatch, 'repeat')).toBeUndefined();
+ expect(findAgentLaneId(dispatch, 'repeat', 9)).toBeUndefined();
+});
+
+it('preserves literal display titles while suppressing legacy storage keys', () => {
+ expect(readableSubagentTitle('Subagent: research', undefined, 'graph')).toBe(
+ 'Subagent: research',
+ );
+ expect(readableSubagentTitle('Subagent: Historical Agent', 'agent_deleted', 'agent')).toBe(
+ 'Subagent: Historical Agent',
+ );
+ expect(readableSubagentTitle('self', 'agent_deleted', 'agent')).toBe('self');
+ expect(readableSubagentTitle('agent_research_team', 'agent_deleted', 'agent')).toBe(
+ 'agent_research_team',
+ );
+ expect(
+ readableSubagentTitle('Subagent: agent_deleted', 'agent_deleted', 'agent'),
+ ).toBeUndefined();
+});
+
+it.each([
+ [{ subagentType: 'self' }, 'Historical Parent'],
+ [{ subagentType: 'self', agentId: 'agent_parent' }, 'Historical Parent'],
+ [{ subagentType: 'self', agentId: 'agent_missing_lane' }, 'Agent'],
+ [{ subagentType: 'self', subagentKind: 'graph' as const }, 'self'],
+ [{ subagentType: 'Subagent: research', subagentKind: 'graph' as const }, 'Subagent: research'],
+ [{ subagentType: 'agent_research_team' }, 'agent_research_team'],
+ [{ subagentType: 'agent_deleted', subagentKind: 'agent' as const }, 'Agent'],
+ [{ subagentType: 'agent_deleted', agentId: 'agent_deleted' }, 'Agent'],
+])('resolves child identity %j consistently across surfaces', (child, expectedName) => {
+ const snapshot = message('dispatch', null);
+ snapshot.model = 'agent_parent';
+ snapshot.sender = 'Historical Parent';
+ const parent = messageAuthor(snapshot, undefined, 'Agent');
+ expect(resolveSubagentAuthor(child, parent, undefined, 'Agent').name).toBe(expectedName);
+});
diff --git a/client/src/components/Chat/Subagents/author.tsx b/client/src/components/Chat/Subagents/author.tsx
new file mode 100644
index 0000000000..91971d541e
--- /dev/null
+++ b/client/src/components/Chat/Subagents/author.tsx
@@ -0,0 +1,270 @@
+import { useMemo, useSyncExternalStore } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { EModelEndpoint, QueryKeys, ContentTypes } from 'librechat-data-provider';
+import type { Agent, TMessage } from 'librechat-data-provider';
+import type { ReactNode } from 'react';
+import { isDocumentId } from '~/components/Chat/Messages/ui/HeaderLabel';
+import MessageIcon from '~/components/Chat/Messages/MessageIcon';
+import { useAgentsMapContext } from '~/Providers';
+import { findSubagentDispatch } from './dispatch';
+
+/** Who wrote a turn, in the form main chat's message header shows an author. */
+export type TurnAuthor = { name: string; icon: ReactNode; agent?: Agent; agentId?: string };
+
+/** Keep graph and legacy aliases readable. A prefix alone cannot prove a
+ * stored agent identity; suppress known agent IDs and the non-graph self alias. */
+export function readableSubagentType(
+ subagentType?: string | null,
+ agentId?: string,
+ kind?: 'agent' | 'graph',
+): string | undefined {
+ if (subagentType == null || subagentType === '') return undefined;
+ if (kind === 'graph') return subagentType;
+ if (subagentType === 'self') return undefined;
+ return subagentType === agentId || (kind === 'agent' && isDocumentId(subagentType))
+ ? undefined
+ : subagentType;
+}
+
+/** Stored display title, excluding legacy titles that contain storage keys. */
+export function readableSubagentTitle(
+ title: string | undefined,
+ agentId?: string,
+ kind?: 'agent' | 'graph',
+): string | undefined {
+ if (!title) return undefined;
+ if (kind === 'graph') return title;
+ const candidate = title.startsWith('Subagent: ') ? title.slice('Subagent: '.length) : title;
+ if (candidate === agentId) return undefined;
+ return title;
+}
+
+/** Explicit graph identity takes precedence over the legacy self alias. */
+export function isSelfSpawn(subagentType?: string | null, kind?: 'agent' | 'graph'): boolean {
+ return kind !== 'graph' && subagentType === 'self';
+}
+
+/** The agent a child runs as: its own saved agent, or — for a self-spawn,
+ * which records none — the agent that spawned it. */
+export function resolveChildAgent(
+ agentId: string | undefined,
+ subagentType: string | null | undefined,
+ spawningAgent: Agent | undefined,
+ agentsMap: Record<string, Agent | undefined> | undefined,
+ kind?: 'agent' | 'graph',
+): Agent | undefined {
+ if (kind === 'graph') return undefined;
+ if (agentId != null) return agentsMap?.[agentId];
+ return isSelfSpawn(subagentType, kind) ? spawningAgent : undefined;
+}
+
+/** Match the parallel lane that wrote the dispatch rather than its enclosing
+ * message's default author. */
+export function findAgentLaneId(
+ message: TMessage | undefined,
+ toolCallId?: string,
+ partIndex?: number,
+): string | undefined {
+ if (!toolCallId) return undefined;
+ const indexed = partIndex == null ? undefined : message?.content?.[partIndex];
+ if (indexed?.type === ContentTypes.TOOL_CALL && indexed.tool_call.id === toolCallId) {
+ return indexed.agentId;
+ }
+ /** Durable legacy selections may have no usable index. Only a unique call
+ * can identify their lane; repeated provider IDs are ambiguous. */
+ let laneId: string | undefined;
+ let found = false;
+ for (const part of message?.content ?? []) {
+ if (part?.type !== ContentTypes.TOOL_CALL || part.tool_call.id !== toolCallId) continue;
+ if (found) return undefined;
+ found = true;
+ laneId = part.agentId;
+ }
+ return laneId;
+}
+
+/** A validated self-child identity wins when it belongs to another lane;
+ * matching identities retain the historical name/avatar snapshot. */
+export function resolveSelfAuthor(
+ parent: TurnAuthor,
+ agentId: string | undefined,
+ agentsMap: Record<string, Agent | undefined> | undefined,
+ fallbackName: string,
+): TurnAuthor {
+ if (agentId == null || agentId === parent.agentId) return parent;
+ const agent = agentsMap?.[agentId];
+ if (parent.agentId == null && agent == null) return parent;
+ return agentAuthor(agent, fallbackName);
+}
+
+/** One display rule for live, restored and shared child tasks. Explicit graph
+ * aliases stay literal; self tasks retain the matching parent-turn snapshot. */
+export function resolveSubagentAuthor(
+ child: {
+ subagentType?: string | null;
+ subagentKind?: 'agent' | 'graph';
+ agentId?: string;
+ title?: string;
+ },
+ parent: TurnAuthor,
+ agentsMap: Record<string, Agent | undefined> | undefined,
+ fallbackName: string,
+): TurnAuthor {
+ if (isSelfSpawn(child.subagentType, child.subagentKind)) {
+ return resolveSelfAuthor(parent, child.agentId, agentsMap, fallbackName);
+ }
+ return agentAuthor(
+ resolveChildAgent(
+ child.agentId,
+ child.subagentType,
+ parent.agent,
+ agentsMap,
+ child.subagentKind,
+ ),
+ readableSubagentTitle(child.title, child.agentId, child.subagentKind) ??
+ readableSubagentType(child.subagentType, child.agentId, child.subagentKind) ??
+ fallbackName,
+ );
+}
+
+/** The author main chat draws for an agent turn: the agent's name and avatar,
+ * or the agents endpoint icon when it has none or is not resolvable. */
+export function agentAuthor(agent: Agent | undefined, fallbackName: string): TurnAuthor {
+ const name = agent?.name || fallbackName;
+ return {
+ agent,
+ agentId: agent?.id,
+ name,
+ icon: (
+ <MessageIcon
+ iconData={{ endpoint: EModelEndpoint.agents, modelLabel: name, isCreatedByUser: false }}
+ agent={agent}
+ />
+ ),
+ };
+}
+
+type AuthorIndex = {
+ byId: Map<string, TMessage>;
+ byParentId: Map<string, TMessage>;
+};
+
+/** React Query replaces loaded message arrays. Weak keys let streamed snapshots
+ * be collected, while every wake-up in one snapshot shares a single pass. */
+const authorIndexes = new WeakMap<TMessage[], AuthorIndex>();
+
+/** The dispatching agent message, or the first agent reply to a user turn. */
+export function findAgentAuthorMessage(
+ messages: TMessage[] | undefined,
+ messageId: string,
+): TMessage | undefined {
+ if (messages == null || messageId === '') return undefined;
+ let index = authorIndexes.get(messages);
+ if (index == null) {
+ index = { byId: new Map(), byParentId: new Map() };
+ for (const message of messages) {
+ if (message.isCreatedByUser === true) continue;
+ if (!index.byId.has(message.messageId)) index.byId.set(message.messageId, message);
+ if (message.parentMessageId != null && !index.byParentId.has(message.parentMessageId)) {
+ index.byParentId.set(message.parentMessageId, message);
+ }
+ }
+ authorIndexes.set(messages, index);
+ }
+ return index.byId.get(messageId) ?? index.byParentId.get(messageId);
+}
+
+/** The author main chat's own header shows for `message`. */
+export function messageAuthor(
+ message: TMessage | undefined,
+ agentsMap: Record<string, Agent | undefined> | undefined,
+ fallbackName: string,
+ laneId?: string,
+): TurnAuthor {
+ if (message == null) return agentAuthor(undefined, fallbackName);
+ const agentId = laneId ?? message.model ?? undefined;
+ const differentLane = laneId != null && laneId !== message.model;
+ const agent = agentId == null ? undefined : agentsMap?.[agentId];
+ const name = agent?.name || (differentLane ? undefined : message.sender) || fallbackName;
+ return {
+ agent,
+ agentId,
+ name,
+ icon: (
+ <MessageIcon
+ iconData={{
+ endpoint: message.endpoint,
+ model: agentId,
+ iconURL: differentLane ? undefined : message.iconURL,
+ modelLabel: name,
+ isCreatedByUser: false,
+ }}
+ agent={agent}
+ />
+ ),
+ };
+}
+
+/** Wait for a missing historical author, then retain its snapshot so streamed
+ * content updates do not rerender every wake-up or open activity panel. */
+export function useParentAuthor(
+ conversationId: string,
+ messageId: string,
+ fallbackName: string,
+ toolCallId?: string,
+ partIndex?: number,
+ threadId?: string,
+): TurnAuthor {
+ const queryClient = useQueryClient();
+ const agentsMap = useAgentsMapContext();
+ /** A different dispatch must read the latest message snapshot, even when
+ * both children belong to the same streamed parent turn. */
+ const source = useMemo(
+ () => ({ conversationId, messageId, toolCallId, partIndex, threadId }),
+ [conversationId, messageId, toolCallId, partIndex, threadId],
+ );
+ const store = useMemo(() => {
+ let snapshot: { message: TMessage; laneId?: string } | undefined;
+ const getSnapshot = () => {
+ if (snapshot != null) return snapshot;
+ const messages = queryClient.getQueryData<TMessage[]>([
+ QueryKeys.messages,
+ source.conversationId,
+ ]);
+ const dispatch = findSubagentDispatch(messages, source.threadId);
+ const message = dispatch?.message ?? findAgentAuthorMessage(messages, source.messageId);
+ if (message == null) return undefined;
+ /** Durable selections use a placeholder part index. A host-issued thread
+ * handle identifies the real occurrence; without it, accept only a unique ID. */
+ const laneId =
+ dispatch != null
+ ? dispatch.agentId
+ : findAgentLaneId(
+ message,
+ source.toolCallId,
+ source.threadId ? undefined : source.partIndex,
+ );
+ snapshot = { message, laneId };
+ return snapshot;
+ };
+ return {
+ getSnapshot,
+ subscribe: (onChange: () => void) => {
+ if (source.messageId === '' || getSnapshot() != null) return () => {};
+ const unsubscribe = queryClient.getQueryCache().subscribe((event) => {
+ const key = event.query.queryKey;
+ if (key[0] !== QueryKeys.messages || key[1] !== source.conversationId) return;
+ if (getSnapshot() == null) return;
+ unsubscribe();
+ onChange();
+ });
+ return unsubscribe;
+ },
+ };
+ }, [queryClient, source]);
+ const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
+ return useMemo(
+ () => messageAuthor(snapshot?.message, agentsMap, fallbackName, snapshot?.laneId),
+ [agentsMap, fallbackName, snapshot],
+ );
+}
diff --git a/client/src/components/Chat/Subagents/dispatch.test.ts b/client/src/components/Chat/Subagents/dispatch.test.ts
new file mode 100644
index 0000000000..dc1755ef6e
--- /dev/null
+++ b/client/src/components/Chat/Subagents/dispatch.test.ts
@@ -0,0 +1,68 @@
+import { ContentTypes } from 'librechat-data-provider';
+import type { TMessage } from 'librechat-data-provider';
+import { findSubagentDispatch } from './dispatch';
+
+const output = JSON.stringify({
+ background_task_id: 'task',
+ subagent_thread_id: 'thread',
+ tool: 'subagent',
+ subagent_type: 'self',
+ status: 'running',
+ message: 'Poll using background_task_id task.',
+});
+
+it.each([false, true])(
+ 'resolves historical dispatch metadata (function format: %s)',
+ (functional) => {
+ const identity = { subagentKind: 'graph' as const, subagentAgentId: 'graph:self' };
+ const message: TMessage = {
+ messageId: 'dispatch',
+ parentMessageId: null,
+ conversationId: 'parent',
+ isCreatedByUser: false,
+ text: '',
+ content: [
+ {
+ type: ContentTypes.TOOL_CALL,
+ tool_call: functional
+ ? {
+ id: 'call',
+ type: 'function',
+ function: { name: 'subagent', arguments: { run_in_background: true }, output },
+ subagentIdentity: identity,
+ }
+ : {
+ name: 'subagent',
+ args: { run_in_background: true },
+ output,
+ subagentIdentity: identity,
+ },
+ },
+ ],
+ };
+ const messages = [message];
+ const scan = jest.spyOn(messages, Symbol.iterator);
+ expect(findSubagentDispatch(messages, 'thread')).toEqual({
+ message,
+ identity,
+ subagentType: 'self',
+ });
+ expect(findSubagentDispatch(messages, 'thread')?.message).toBe(message);
+ expect(findSubagentDispatch(messages, 'absent')).toBeUndefined();
+ expect(scan).toHaveBeenCalledTimes(1);
+ expect(findSubagentDispatch([{ ...message, isCreatedByUser: true }], 'thread')).toBeUndefined();
+ expect(
+ findSubagentDispatch(
+ [
+ {
+ ...message,
+ content: [
+ { type: ContentTypes.TOOL_CALL, tool_call: { name: 'subagent', args: {}, output } },
+ ],
+ },
+ ],
+ 'thread',
+ ),
+ ).toBeUndefined();
+ },
+);
diff --git a/client/src/components/Chat/Subagents/dispatch.ts b/client/src/components/Chat/Subagents/dispatch.ts
new file mode 100644
index 0000000000..5aba5e0ef7
--- /dev/null
+++ b/client/src/components/Chat/Subagents/dispatch.ts
@@ -0,0 +1,55 @@
+import { Constants, ContentTypes } from 'librechat-data-provider';
+import type { SubagentIdentity, TMessage } from 'librechat-data-provider';
+import { parseSubagentBackgroundHandle } from '~/components/Chat/Messages/Content/Parts/handle';
+
+type Dispatch = {
+ message: TMessage;
+ subagentType: string;
+ identity?: SubagentIdentity;
+ agentId?: string;
+};
+
+const indexes = new WeakMap<TMessage[], Map<string, Dispatch>>();
+
+/** Public transcripts carry dispatch metadata instead of an authenticated child
+ * index. Match the host-issued handle, sharing one scan per transcript snapshot. */
+export function findSubagentDispatch(
+ messages: TMessage[] | undefined,
+ threadId: string | undefined,
+): Dispatch | undefined {
+ if (messages == null || !threadId) return undefined;
+ let index = indexes.get(messages);
+ if (index == null) {
+ index = new Map();
+ for (const message of messages) {
+ if (message.isCreatedByUser === true) continue;
+ for (const part of message.content ?? []) {
+ if (part?.type !== ContentTypes.TOOL_CALL) continue;
+ const call = part.tool_call;
+ if (!('name' in call) && !('function' in call)) continue;
+ const name = 'function' in call ? call.function.name : call.name;
+ if (name !== Constants.SUBAGENT) continue;
+ const output = 'function' in call ? call.function.output : call.output;
+ let args: Parameters<typeof parseSubagentBackgroundHandle>[1];
+ if ('function' in call) {
+ args =
+ typeof call.function.arguments === 'string'
+ ? call.function.arguments
+ : JSON.stringify(call.function.arguments);
+ } else {
+ args = call.args;
+ }
+ const handle = parseSubagentBackgroundHandle(output, args);
+ if (handle == null || index.has(handle.subagent_thread_id)) continue;
+ index.set(handle.subagent_thread_id, {
+ message,
+ subagentType: handle.subagent_type,
+ identity: call.subagentIdentity,
+ agentId: part.agentId,
+ });
+ }
+ }
+ indexes.set(messages, index);
+ }
+ return index.get(threadId);
+}
diff --git a/client/src/components/Chat/Subagents/identity.test.ts b/client/src/components/Chat/Subagents/identity.test.ts
index 17c000fbdb..0a93d64107 100644
--- a/client/src/components/Chat/Subagents/identity.test.ts
+++ b/client/src/components/Chat/Subagents/identity.test.ts
@@ -12,4 +12,8 @@ describe('resolveSubagentAgentId', () => {
expect(resolveSubagentAgentId(graph, agent)).toBeUndefined();
expect(resolveSubagentAgentId(null, graph)).toBeUndefined();
});
+ it('does not infer a saved agent when identity is absent', () => {
+ expect(resolveSubagentAgentId(null, undefined)).toBeUndefined();
+ expect(resolveSubagentAgentId({ subagentKind: 'graph' }, undefined)).toBeUndefined();
+ });
});
diff --git a/client/src/components/Chat/Subagents/identity.ts b/client/src/components/Chat/Subagents/identity.ts
index 3d272eba77..354198d1ae 100644
--- a/client/src/components/Chat/Subagents/identity.ts
+++ b/client/src/components/Chat/Subagents/identity.ts
@@ -1,10 +1,17 @@
import type { SubagentIdentity } from 'librechat-data-provider';
+/**
+ * The saved agent behind a child, from live progress, then its persisted
+ * identity. Types are aliases, not proof of a saved-agent identity.
+ */
export function resolveSubagentAgentId(
progress: Partial<SubagentIdentity> | null | undefined,
persisted: SubagentIdentity | undefined,
): string | undefined {
if (progress?.subagentKind === 'graph') return undefined;
if (progress?.subagentAgentId) return progress.subagentAgentId;
- return persisted?.subagentKind === 'agent' ? persisted.subagentAgentId : undefined;
+ if (persisted != null) {
+ return persisted.subagentKind === 'agent' ? persisted.subagentAgentId : undefined;
+ }
+ return undefined;
}
diff --git a/client/src/components/Share/Message.tsx b/client/src/components/Share/Message.tsx
index 825a58b421..81da6742c2 100644
--- a/client/src/components/Share/Message.tsx
+++ b/client/src/components/Share/Message.tsx
@@ -1,7 +1,9 @@
+import { useMemo } from 'react';
import type { TMessageProps } from '~/common';
import SearchContent, {
rendersMarkdownLite,
} from '~/components/Chat/Messages/Content/SearchContent';
+import { parseWakeupMessage } from '~/components/Chat/Messages/Content/Parts/wakeup';
import AuthorHeader from '~/components/Chat/Messages/Content/Parts/AuthorHeader';
import MinimalHoverButtons from '~/components/Chat/Messages/MinimalHoverButtons';
import { getHeaderHoverLabel } from '~/components/Chat/Messages/ui/HeaderLabel';
@@ -9,6 +11,8 @@ import MessageContent from '~/components/Chat/Messages/Content/MessageContent';
import { getHeaderPrefixForScreenReader, getMessageAriaLabel } from '~/utils';
import SiblingSwitch from '~/components/Chat/Messages/SiblingSwitch';
import MessageRow from '~/components/Chat/Messages/ui/MessageRow';
+import WakeupRow from '~/components/Chat/Messages/ui/WakeupRow';
+import Wakeup from '~/components/Chat/Messages/Content/Wakeup';
import { MessageContext, useShareContext } from '~/Providers';
import SubRow from '~/components/Chat/Messages/SubRow';
import { useAttachments, useLocalize } from '~/hooks';
@@ -32,6 +36,7 @@ export default function Message(props: TMessageProps) {
messageId: message?.messageId,
attachments: message?.attachments,
});
+ const wakeupDisplay = useMemo(() => parseWakeupMessage(message), [message]);
if (!message) {
return null;
@@ -51,12 +56,16 @@ export default function Message(props: TMessageProps) {
* view and wrong here: it is the screen-reader heading for the user turn, and it
* would credit every prompt the sharer wrote to the person reading the transcript. */
const messageLabel = isCreatedByUser ? localize('com_ui_user') : (message.sender ?? '');
+ const subagentWakeup = wakeupDisplay?.kind === 'subagent' ? wakeupDisplay.tasks[0] : undefined;
+ const Row = subagentWakeup == null ? MessageRow : WakeupRow;
return (
<>
- <div className="w-full border-0 bg-transparent text-text-primary">
+ <div className="text-text-primary w-full border-0 bg-transparent">
<div className="m-auto justify-center px-4 py-3 sm:px-0">
- <MessageRow
+ <Row
+ task={subagentWakeup}
+ conversationId={message.conversationId ?? conversation?.conversationId ?? ''}
id={messageId}
icon={<Icon message={message} conversation={conversation} />}
label={messageLabel}
@@ -65,6 +74,11 @@ export default function Message(props: TMessageProps) {
ariaLabel={getMessageAriaLabel(message, localize)}
headerPrefix={getHeaderPrefixForScreenReader(message, localize)}
isCreatedByUser={isCreatedByUser}
+ systemLabel={
+ wakeupDisplay != null && subagentWakeup == null
+ ? localize('com_ui_system_event')
+ : undefined
+ }
className="final-completion"
footer={
<SubRow classes={isCreatedByUser ? 'justify-end text-xs' : 'text-xs'}>
@@ -90,38 +104,42 @@ export default function Message(props: TMessageProps) {
isLatestMessage: false,
}}
>
- {message.content ? (
- <SearchContent
- message={message}
- attachments={attachments}
- searchResults={searchResults}
- authorHeader={
- isCreatedByUser ? undefined : (
- <AuthorHeader
- icon={<Icon message={message} conversation={conversation} />}
- label={messageLabel}
- />
- )
- }
- />
- ) : (
- <MessageContent
- edit={false}
- error={error}
- isLast={false}
- ask={() => {}}
- text={text || ''}
- message={message}
- isSubmitting={false}
- enterEdit={() => ({})}
- unfinished={unfinished}
- siblingIdx={siblingIdx ?? 0}
- isCreatedByUser={isCreatedByUser}
- setSiblingIdx={setSiblingIdx ?? (() => ({}))}
- />
+ {wakeupDisplay != null && (
+ <Wakeup display={wakeupDisplay} conversationId={message.conversationId} />
)}
+ {wakeupDisplay == null &&
+ (message.content ? (
+ <SearchContent
+ message={message}
+ attachments={attachments}
+ searchResults={searchResults}
+ authorHeader={
+ isCreatedByUser ? undefined : (
+ <AuthorHeader
+ icon={<Icon message={message} conversation={conversation} />}
+ label={messageLabel}
+ />
+ )
+ }
+ />
+ ) : (
+ <MessageContent
+ edit={false}
+ error={error}
+ isLast={false}
+ ask={() => {}}
+ text={text || ''}
+ message={message}
+ isSubmitting={false}
+ enterEdit={() => ({})}
+ unfinished={unfinished}
+ siblingIdx={siblingIdx ?? 0}
+ isCreatedByUser={isCreatedByUser}
+ setSiblingIdx={setSiblingIdx ?? (() => ({}))}
+ />
+ ))}
</MessageContext.Provider>
- </MessageRow>
+ </Row>
</div>
</div>
<MultiMessage
diff --git a/client/src/components/Share/Message.wakeup.spec.tsx b/client/src/components/Share/Message.wakeup.spec.tsx
new file mode 100644
index 0000000000..8b5831720f
--- /dev/null
+++ b/client/src/components/Share/Message.wakeup.spec.tsx
@@ -0,0 +1,306 @@
+import { Provider } from 'jotai';
+import { RecoilRoot } from 'recoil';
+import copy from 'copy-to-clipboard';
+import { fireEvent, render, screen } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { ContentTypes, dataService, EModelEndpoint } from 'librechat-data-provider';
+import type { TMessage, TAgentsMap } from 'librechat-data-provider';
+import { ShareMessagesProvider } from './ShareMessagesProvider';
+import { AgentsMapContext } from '~/Providers/AgentsMapContext';
+import { ShareContext } from '~/Providers/ShareContext';
+import MessagesView from './MessagesView';
+
+jest.mock('librechat-data-provider', () => {
+ const actual = jest.requireActual('librechat-data-provider');
+ return {
+ ...actual,
+ dataService: { ...actual.dataService, getAIEndpoints: jest.fn().mockResolvedValue({}) },
+ };
+});
+
+jest.mock('~/hooks', () => ({
+ useLocalize: () => (key: string) => key,
+ useAttachments: () => ({ attachments: [], searchResults: [] }),
+ useExpandCollapse: jest.requireActual('~/hooks/Messages/useExpandCollapse').default,
+ useLazyCollapseBody: jest.requireActual('~/hooks/Messages/useLazyCollapseBody').default,
+ ...jest.requireActual('~/hooks/Messages/useCopyToClipboard'),
+}));
+jest.mock('~/hooks/MCP', () => ({
+ useMCPIconMap: () => new Map(),
+ useMCPServerNames: () => [],
+}));
+jest.mock('copy-to-clipboard');
+jest.mock('~/components/Chat/Messages/Content/SearchContent', () => ({
+ __esModule: true,
+ default: ({ message }: { message: TMessage }) => <div>{message.text}</div>,
+ rendersMarkdownLite: () => false,
+}));
+jest.mock('~/components/Chat/Messages/Content/MessageContent', () => ({
+ __esModule: true,
+ default: ({ text }: { text: string }) => <div>{text}</div>,
+}));
+jest.mock('~/components/Chat/Messages/Content/MarkdownLite', () => ({
+ __esModule: true,
+ default: ({ content }: { content: string }) => <div>{content}</div>,
+}));
+jest.mock('~/components/Chat/Messages/Content/ToolOutput', () => ({
+ StackedToolIcons: () => null,
+ ToolIcon: () => null,
+ getToolIconType: () => '',
+ getMCPServerName: () => '',
+ OutputRenderer: ({ text }: { text: string }) => <div>{text}</div>,
+}));
+
+const prompt = (status = 'completed', subagentType = 'self') =>
+ `A detached subagent task has ${status}. Continue the parent task using its durable result below.\n${JSON.stringify(
+ {
+ background_task_id: 'task',
+ subagent_thread_id: 'thread',
+ subagent_type: subagentType,
+ status,
+ result: 'Shared durable result.',
+ },
+ )}`;
+
+function renderShared(
+ text: string,
+ content = false,
+ dispatch?: TMessage,
+ submitted = false,
+ agentsMap?: TAgentsMap,
+) {
+ const wake: TMessage = {
+ messageId: 'wake',
+ parentMessageId: null,
+ conversationId: 'original',
+ isCreatedByUser: true,
+ isUserSubmitted: submitted,
+ text,
+ ...(content ? { content: [{ type: ContentTypes.TEXT, text }] } : {}),
+ };
+ const reply: TMessage = {
+ messageId: 'reply',
+ parentMessageId: 'wake',
+ conversationId: 'original',
+ isCreatedByUser: false,
+ text: 'Parent continuation.',
+ sender: 'Historical Parent',
+ endpoint: EModelEndpoint.agents,
+ model: 'agent_deleted',
+ iconURL: '/historical.png',
+ };
+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+ render(
+ <QueryClientProvider client={queryClient}>
+ <Provider>
+ <RecoilRoot>
+ <ShareContext.Provider value={{ isSharedConvo: true, shareId: 'share' }}>
+ <AgentsMapContext.Provider value={agentsMap}>
+ <ShareMessagesProvider
+ messages={[...(dispatch == null ? [] : [dispatch]), wake, reply]}
+ >
+ <MessagesView messagesTree={[wake]} conversationId="shared-view" />
+ </ShareMessagesProvider>
+ </AgentsMapContext.Provider>
+ </ShareContext.Provider>
+ </RecoilRoot>
+ </Provider>
+ </QueryClientProvider>,
+ );
+ return queryClient;
+}
+
+beforeEach(() => jest.mocked(dataService.getAIEndpoints).mockClear());
+
+it.each([false, true])(
+ 'renders the actual public self wake-up author and task card (content: %s)',
+ (content) => {
+ const text = prompt();
+ const queryClient = renderShared(text, content);
+ expect(screen.getByRole('heading', { name: 'Historical Parent' })).toBeInTheDocument();
+ expect(screen.getByRole('img', { hidden: true })).toHaveAttribute('src', '/historical.png');
+ expect(screen.getByTestId('message-body')).toHaveClass('border', 'border-border-medium');
+ expect(screen.queryByText(text)).not.toBeInTheDocument();
+ const toggle = screen.getByRole('button', { name: 'com_ui_wakeup_subagent_completed' });
+ expect(toggle).toHaveAttribute('aria-expanded', 'false');
+ fireEvent.click(toggle);
+ expect(toggle).toHaveAttribute('aria-expanded', 'true');
+ expect(screen.getByText('Shared durable result.')).toBeInTheDocument();
+ expect(
+ screen.queryByRole('button', { name: 'com_ui_wakeup_view_activity' }),
+ ).not.toBeInTheDocument();
+ expect(dataService.getAIEndpoints).not.toHaveBeenCalled();
+ expect(queryClient.isFetching()).toBe(0);
+ },
+);
+
+it.each(['error', 'cancelled'])('renders a public subagent %s outcome', (status) => {
+ renderShared(prompt(status, 'reviewer'));
+ expect(screen.getByRole('heading', { name: 'reviewer' })).toBeInTheDocument();
+ expect(
+ screen.getByRole('button', {
+ name:
+ status === 'error' ? 'com_ui_wakeup_subagent_errored' : 'com_ui_wakeup_subagent_cancelled',
+ }),
+ ).toBeInTheDocument();
+});
+
+it('renders background-tool wake-ups as system task cards', () => {
+ const text = `A background tool task has finished. Continue using its durable result below.\n${JSON.stringify(
+ [
+ {
+ background_task_id: 'task',
+ tool_call_id: 'call',
+ tool: 'bash',
+ status: 'completed',
+ result: 'Tool result.',
+ },
+ ],
+ )}`;
+ renderShared(text);
+ expect(screen.getByRole('heading', { name: 'com_ui_system_event' })).toBeInTheDocument();
+ expect(screen.queryByText(text)).not.toBeInTheDocument();
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_wakeup_task_finished' }));
+ expect(screen.getByText('Tool result.')).toBeInTheDocument();
+});
+
+it.each([false, true])('keeps an ordinary public user message (content: %s)', (content) => {
+ renderShared('Ordinary shared prompt.', content);
+ expect(screen.getByText('Ordinary shared prompt.')).toBeInTheDocument();
+ expect(screen.queryByTestId('wakeup-panel')).not.toBeInTheDocument();
+ expect(
+ screen.getByRole('heading', { name: 'com_ui_prompt: com_ui_user', hidden: true }),
+ ).toHaveClass('sr-only');
+});
+
+it.each([
+ ['self', 'graph', 'self'],
+ ['agent_research_team', 'graph', 'agent_research_team'],
+ ['agent_research_team', undefined, 'agent_research_team'],
+ ['self', 'agent', 'Dispatch Parent'],
+] as const)('retains persisted shared alias %s with kind %s', (alias, kind, label) => {
+ const dispatch: TMessage = {
+ messageId: 'dispatch',
+ parentMessageId: null,
+ conversationId: 'original',
+ isCreatedByUser: false,
+ text: '',
+ sender: 'Dispatch Parent',
+ endpoint: EModelEndpoint.agents,
+ model: 'agent_deleted',
+ iconURL: '/dispatch.png',
+ content: [
+ {
+ type: ContentTypes.TOOL_CALL,
+ tool_call: {
+ name: 'subagent',
+ args: { run_in_background: true },
+ output: JSON.stringify({
+ background_task_id: 'task',
+ subagent_thread_id: 'thread',
+ tool: 'subagent',
+ subagent_type: alias,
+ status: 'running',
+ message: 'Poll with background_task_id task.',
+ }),
+ ...(kind == null
+ ? {}
+ : {
+ subagentIdentity: {
+ subagentKind: kind,
+ subagentAgentId: kind === 'graph' ? `graph:${alias}` : 'agent_deleted',
+ },
+ }),
+ },
+ },
+ ],
+ };
+ renderShared(prompt('completed', alias), false, dispatch);
+ expect(screen.getByRole('heading', { name: label })).toBeInTheDocument();
+ if (kind !== 'agent') {
+ expect(screen.queryByRole('heading', { name: 'Dispatch Parent' })).not.toBeInTheDocument();
+ } else {
+ expect(screen.getByRole('img', { hidden: true })).toHaveAttribute('src', '/dispatch.png');
+ }
+ expect(screen.queryByRole('heading', { name: 'Historical Parent' })).not.toBeInTheDocument();
+ expect(dataService.getAIEndpoints).not.toHaveBeenCalled();
+});
+
+it.each(['self', 'reviewer'])(
+ 'keeps a user-submitted %s wake-up lookalike as a prompt',
+ (alias) => {
+ const text = prompt('completed', alias);
+ renderShared(text, false, undefined, true);
+ expect(screen.getByTestId('message-body')).toHaveTextContent(text.replace(/\s+/g, ' '));
+ expect(screen.queryByTestId('wakeup-panel')).not.toBeInTheDocument();
+ expect(
+ screen.getByRole('heading', { name: 'com_ui_prompt: com_ui_user', hidden: true }),
+ ).toHaveClass('sr-only');
+ },
+);
+
+it('attributes a public parallel-lane self-spawn to its validated lane', () => {
+ const dispatch: TMessage = {
+ messageId: 'dispatch',
+ parentMessageId: null,
+ conversationId: 'original',
+ isCreatedByUser: false,
+ text: '',
+ sender: 'Outer Parent',
+ model: 'agent_outer',
+ endpoint: EModelEndpoint.agents,
+ iconURL: '/outer.png',
+ content: [
+ {
+ type: ContentTypes.TOOL_CALL,
+ agentId: 'agent_lane',
+ tool_call: {
+ id: 'call',
+ name: 'subagent',
+ args: { run_in_background: true },
+ output: JSON.stringify({
+ background_task_id: 'task',
+ subagent_thread_id: 'thread',
+ tool: 'subagent',
+ subagent_type: 'self',
+ status: 'running',
+ message: 'Poll with background_task_id task.',
+ }),
+ subagentIdentity: { subagentKind: 'agent', subagentAgentId: 'agent_lane' },
+ },
+ },
+ ],
+ };
+ renderShared(prompt(), false, dispatch, false, {
+ agent_lane: {
+ id: 'agent_lane',
+ name: 'Lane Parent',
+ description: null,
+ created_at: 0,
+ avatar: { filepath: '/lane.png', source: 'local' },
+ provider: EModelEndpoint.openAI,
+ model: 'test',
+ model_parameters: {
+ temperature: 1,
+ maxContextTokens: 4096,
+ max_context_tokens: 4096,
+ max_output_tokens: 1024,
+ top_p: 1,
+ frequency_penalty: 0,
+ presence_penalty: 0,
+ },
+ },
+ });
+ expect(screen.getByRole('heading', { name: 'Lane Parent' })).toBeInTheDocument();
+ expect(screen.queryByRole('heading', { name: 'Outer Parent' })).not.toBeInTheDocument();
+ expect(screen.getByRole('img', { hidden: true })).toHaveAttribute('src', '/lane.png');
+ expect(dataService.getAIEndpoints).not.toHaveBeenCalled();
+});
+
+it('copies only the visible public wake-up result through its real footer', () => {
+ const clipboard = jest.mocked(copy);
+ clipboard.mockReturnValue(true);
+ renderShared(prompt(), true);
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_copy_to_clipboard' }));
+ expect(clipboard).toHaveBeenCalledWith('Shared durable result.', expect.anything());
+});
diff --git a/client/src/components/Share/ShareView.tsx b/client/src/components/Share/ShareView.tsx
index 6ff8538151..6f8846de30 100644
--- a/client/src/components/Share/ShareView.tsx
+++ b/client/src/components/Share/ShareView.tsx
@@ -264,7 +264,7 @@ function SharedView() {
{artifactsContainer}
</main>
</div>
- <SharedSubagentActivityDialog shareId={shareId} />
+ <SharedSubagentActivityDialog shareId={shareId} messages={data?.messages} />
</AppChatSurface>
</ShareContext.Provider>
</CodeHighlightThrottleContext.Provider>
diff --git a/client/src/hooks/Messages/index.ts b/client/src/hooks/Messages/index.ts
index fa328cdffd..d5348991a3 100644
--- a/client/src/hooks/Messages/index.ts
+++ b/client/src/hooks/Messages/index.ts
@@ -27,7 +27,11 @@ export { default as useMemoizedChatContext } from './useMemoizedChatContext';
export { default as useMessageProcess } from './useMessageProcess';
export { default as useMessageHelpers } from './useMessageHelpers';
export { default as useCopyToClipboard } from './useCopyToClipboard';
-export { hasCopyableText, useCopyMessageToClipboard } from './useCopyToClipboard';
+export {
+ hasCopyableText,
+ getMessageClipboardSource,
+ useCopyMessageToClipboard,
+} from './useCopyToClipboard';
export { default as useContentMetadata } from './useContentMetadata';
export { default as useMessageScrolling } from './useMessageScrolling';
export { default as useScrollbarGutter, useScrollbarGutterSeed } from './useScrollbarGutter';
diff --git a/client/src/hooks/Messages/useCopyMessageToClipboard.spec.tsx b/client/src/hooks/Messages/useCopyMessageToClipboard.spec.tsx
index c188ed7336..ccc3e6e5a2 100644
--- a/client/src/hooks/Messages/useCopyMessageToClipboard.spec.tsx
+++ b/client/src/hooks/Messages/useCopyMessageToClipboard.spec.tsx
@@ -1,10 +1,15 @@
import { RecoilRoot } from 'recoil';
import copy from 'copy-to-clipboard';
import { renderHook, act } from '@testing-library/react';
+import type { TMessage } from 'librechat-data-provider';
import type { MutableSnapshot } from 'recoil';
import type { ReactNode } from 'react';
import type { MarkdownVariant } from '~/utils/richtext';
-import { useCopyMessageToClipboard } from '~/hooks/Messages/useCopyToClipboard';
+import {
+ useCopyMessageToClipboard,
+ getMessageClipboardSource,
+ hasCopyableText,
+} from '~/hooks/Messages/useCopyToClipboard';
import store from '~/store';
jest.mock('copy-to-clipboard');
@@ -53,6 +58,77 @@ describe('useCopyMessageToClipboard', () => {
return (clipboardData.setData.mock.calls[0]?.[1] ?? '') as string;
};
+ it.each([false, true])('copies rendered wake-up results with rich text %s', (rich) => {
+ const text = `A detached subagent task has completed. Continue the parent task using its durable result below.\n${JSON.stringify({ background_task_id: 'task', subagent_thread_id: 'thread', subagent_type: 'reviewer', status: 'completed', result: '**Visible result**', snapshot: 'private orchestration' })}`;
+ const message: TMessage = {
+ messageId: 'wake',
+ parentMessageId: null,
+ conversationId: 'parent',
+ isCreatedByUser: true,
+ isUserSubmitted: false,
+ text,
+ content: [],
+ };
+ const { result } = renderHook(
+ () => useCopyMessageToClipboard(getMessageClipboardSource(message)),
+ {
+ wrapper: ({ children }: { children: ReactNode }) => (
+ <RecoilRoot
+ initializeState={({ set }) => {
+ set(store.copyRichText, rich);
+ set(store.enableUserMsgMarkdown, false);
+ }}
+ >
+ {children}
+ </RecoilRoot>
+ ),
+ },
+ );
+ act(() => {
+ result.current(mockSetIsCopied);
+ });
+ expect(mockCopy.mock.calls[0][0]).toBe('**Visible result**');
+ if (rich) expect(copiedHtml()).toBe('<p><strong>Visible result</strong></p>');
+ expect(getMessageClipboardSource({ ...message, isUserSubmitted: true }).text).toBe(text);
+ const empty = { ...message, text: text.replace('**Visible result**', '') };
+ expect(hasCopyableText(getMessageClipboardSource(empty))).toBe(false);
+ });
+
+ it('copies all displayed background results without host metadata', () => {
+ const text = `2 background tool tasks have finished. Continue using their durable results below.\n${JSON.stringify(
+ [
+ {
+ background_task_id: 'first',
+ tool_call_id: 'call-1',
+ tool: 'tool',
+ status: 'completed',
+ result: 'First result',
+ },
+ {
+ background_task_id: 'second',
+ tool_call_id: 'call-2',
+ tool: 'tool',
+ status: 'error',
+ result: 'Second result',
+ },
+ ],
+ )}`;
+ const source = getMessageClipboardSource({
+ messageId: 'wake',
+ parentMessageId: null,
+ conversationId: 'parent',
+ isCreatedByUser: true,
+ text,
+ });
+ const { result } = renderHook(() => useCopyMessageToClipboard(source), {
+ wrapper: ({ children }: { children: ReactNode }) => <RecoilRoot>{children}</RecoilRoot>,
+ });
+ act(() => {
+ result.current(mockSetIsCopied);
+ });
+ expect(mockCopy.mock.calls[0][0]).toBe('First result\n\nSecond result');
+ });
+
it('copies an assistant message as html when the preference is on', () => {
const { result } = renderWithSettings(
{ copyRichText: true, enableUserMsgMarkdown: false },
diff --git a/client/src/hooks/Messages/useCopyToClipboard.ts b/client/src/hooks/Messages/useCopyToClipboard.ts
index ca68595e07..884125d342 100644
--- a/client/src/hooks/Messages/useCopyToClipboard.ts
+++ b/client/src/hooks/Messages/useCopyToClipboard.ts
@@ -11,6 +11,7 @@ import {
STANDALONE_PATTERN,
INVALID_CITATION_REGEX,
} from '~/utils/citations';
+import { parseWakeupMessage } from '~/components/Chat/Messages/Content/Parts/wakeup';
import { markdownToHtml } from '~/utils/richtext';
import store from '~/store';
@@ -221,6 +222,25 @@ type MessageClipboardSource = ClipboardSource &
variant?: MarkdownVariant;
};
+/** Mirror the rendered task results, never the hidden host prompt, when
+ * copying a wake-up. User-submitted lookalikes retain their original content. */
+export function getMessageClipboardSource(message?: TMessage | null): MessageClipboardSource {
+ const display = parseWakeupMessage(message ?? undefined);
+ if (display != null) {
+ return {
+ text: display.tasks.map((task) => task.result).join('\n\n'),
+ isCreatedByUser: false,
+ variant: 'lite',
+ };
+ }
+ return {
+ text: message?.text,
+ content: message?.content,
+ isCreatedByUser: message?.isCreatedByUser,
+ error: message?.error,
+ };
+}
+
/**
* Copies a message honoring the user's rich text preference. Kept apart from
* `useCopyToClipboard` so the plain copies (share links, API keys, callback
diff --git a/client/src/hooks/Messages/useMessageActions.tsx b/client/src/hooks/Messages/useMessageActions.tsx
index 9ac1f616d8..59a06493e9 100644
--- a/client/src/hooks/Messages/useMessageActions.tsx
+++ b/client/src/hooks/Messages/useMessageActions.tsx
@@ -13,7 +13,11 @@ import {
} from 'librechat-data-provider';
import type { TMessageChatContext } from '~/common/types';
import type { TMessageProps } from '~/common';
-import { useCopyMessageToClipboard, hasCopyableText } from './useCopyToClipboard';
+import {
+ useCopyMessageToClipboard,
+ getMessageClipboardSource,
+ hasCopyableText,
+} from './useCopyToClipboard';
import { useAssistantsMapContext, useAgentsMapContext } from '~/Providers';
import { useAuthContext } from '~/hooks/AuthContext';
import { useGetAddedConvo } from '~/hooks/Chat';
@@ -57,7 +61,7 @@ export default function useMessageActions(props: TMessageActions) {
const agentsMap = useAgentsMapContext();
const assistantMap = useAssistantsMapContext();
- const { text, content, messageId = null, isCreatedByUser } = message ?? {};
+ const { messageId = null, isCreatedByUser } = message ?? {};
const edit = useMemo(() => messageId === currentEditId, [messageId, currentEditId]);
const [feedback, setFeedback] = useState<TFeedback | undefined>(() => {
@@ -121,17 +125,15 @@ export default function useMessageActions(props: TMessageActions) {
regenerate(message, { addedConvo: getAddedConvo() });
}, [chatContext, isCreatedByUser, message, regenerate, getAddedConvo]);
+ const clipboardSource = useMemo(() => getMessageClipboardSource(message), [message]);
const copyToClipboard = useCopyMessageToClipboard({
- text,
- content,
+ ...clipboardSource,
searchResults,
- isCreatedByUser,
- error: message?.error,
});
const getCanCopy = useCallback(
- () => hasCopyableText({ text, content, searchResults }),
- [text, content, searchResults],
+ () => hasCopyableText({ ...clipboardSource, searchResults }),
+ [clipboardSource, searchResults],
);
const messageLabel = useMemo(() => {
diff --git a/client/src/hooks/Messages/useMessageHelpers.tsx b/client/src/hooks/Messages/useMessageHelpers.tsx
index b74113e3b6..4704f952c3 100644
--- a/client/src/hooks/Messages/useMessageHelpers.tsx
+++ b/client/src/hooks/Messages/useMessageHelpers.tsx
@@ -7,8 +7,12 @@ import {
} from 'librechat-data-provider';
import type { SearchResultData } from 'librechat-data-provider';
import type { TMessageProps } from '~/common';
+import {
+ useCopyMessageToClipboard,
+ getMessageClipboardSource,
+ hasCopyableText,
+} from './useCopyToClipboard';
import { useMessagesViewContext, useAssistantsMapContext, useAgentsMapContext } from '~/Providers';
-import { useCopyMessageToClipboard, hasCopyableText } from './useCopyToClipboard';
import { useGetAddedConvo } from '~/hooks/Chat';
import { logger } from '~/utils';
@@ -33,7 +37,7 @@ export default function useMessageHelpers(
const getAddedConvo = useGetAddedConvo();
- const { text, content, children, messageId = null, isCreatedByUser } = message ?? {};
+ const { children, messageId = null, isCreatedByUser } = message ?? {};
const edit = messageId === currentEditId;
const isLast = children?.length === 0 || children?.length === undefined;
@@ -89,17 +93,15 @@ export default function useMessageHelpers(
regenerate(message, { addedConvo: getAddedConvo() });
};
+ const clipboardSource = useMemo(() => getMessageClipboardSource(message), [message]);
const copyToClipboard = useCopyMessageToClipboard({
- text,
- content,
+ ...clipboardSource,
searchResults,
- isCreatedByUser,
- error: message?.error,
});
const getCanCopy = useCallback(
- () => hasCopyableText({ text, content, searchResults }),
- [text, content, searchResults],
+ () => hasCopyableText({ ...clipboardSource, searchResults }),
+ [clipboardSource, searchResults],
);
return {
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index 7f13fc8b3e..15b2897350 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -2896,10 +2896,9 @@
"com_ui_subagent_count_cancelled_one": "{{0}} cancelled",
"com_ui_subagent_count_cancelled_other": "{{0}} cancelled",
"com_ui_subagent_actor": "Agent",
+ "com_ui_subagent_parent_agent": "Parent agent",
"com_ui_subagent_cancelled": "Agent stopped",
"com_ui_subagent_complete": "Ran agent",
- "com_ui_subagent_dialog_title": "\"{{0}}\" agent",
- "com_ui_subagent_dialog_title_self": "Agent",
"com_ui_subagent_cancel_task": "Cancel task",
"com_ui_subagent_control_cancel": "Cancel task",
"com_ui_subagent_control_cancel_message": "Withdraw message",
@@ -2950,8 +2949,8 @@
"com_ui_subagent_thread_status_interrupted": "Interrupted",
"com_ui_subagent_thread_status_running": "Running",
"com_ui_subagent_trigger_external_event": "External event",
- "com_ui_subagent_trigger_parent_continuation": "Parent agent continuation",
- "com_ui_subagent_trigger_parent_dispatch": "Parent agent dispatch",
+ "com_ui_subagent_trigger_parent_continuation": "Followed up on the task",
+ "com_ui_subagent_trigger_parent_dispatch": "Assigned a task",
"com_ui_subagent_trigger_truncated": "Trigger summary shortened for display.",
"com_ui_subagent_turn": "Turn",
"com_ui_subagent_running": "Running agent",
@@ -3245,9 +3244,9 @@
"com_ui_via_server": "in {{0}}",
"com_ui_view_memory": "View Memory",
"com_ui_wakeup_explainer": "The agent continued with this result.",
- "com_ui_wakeup_subagent_cancelled": "Subagent task cancelled",
- "com_ui_wakeup_subagent_completed": "Subagent task completed",
- "com_ui_wakeup_subagent_errored": "Subagent task failed",
+ "com_ui_wakeup_subagent_cancelled": "Task cancelled",
+ "com_ui_wakeup_subagent_completed": "Task completed",
+ "com_ui_wakeup_subagent_errored": "Task failed",
"com_ui_wakeup_task_cancelled": "Background task cancelled",
"com_ui_wakeup_task_errored": "Background task failed",
"com_ui_wakeup_task_finished": "Background task finished",
diff --git a/client/src/utils/__tests__/messages.test.ts b/client/src/utils/__tests__/messages.test.ts
index 5f42bd0cc7..5537ad0ad6 100644
--- a/client/src/utils/__tests__/messages.test.ts
+++ b/client/src/utils/__tests__/messages.test.ts
@@ -376,6 +376,7 @@ const FIELD_MUTATIONS: Array<[string, Partial<TMessage>]> = [
['createdAt', { createdAt: '2026-07-02T00:00:00.000Z' }],
['depth', { depth: 3 }],
['isCreatedByUser', { isCreatedByUser: true }],
+ ['isUserSubmitted', { isUserSubmitted: true }],
['children length', { children: [makeFieldsMsg(), makeFieldsMsg()] }],
['content reference', { content: [] as TMessage['content'] }],
['model', { model: 'gpt-5' }],
diff --git a/client/src/utils/messages.ts b/client/src/utils/messages.ts
index b244a45197..fe5c6c3964 100644
--- a/client/src/utils/messages.ts
+++ b/client/src/utils/messages.ts
@@ -905,6 +905,7 @@ export function areMessageFieldsEqual(
prevMsg.createdAt === nextMsg.createdAt &&
prevMsg.depth === nextMsg.depth &&
prevMsg.isCreatedByUser === nextMsg.isCreatedByUser &&
+ prevMsg.isUserSubmitted === nextMsg.isUserSubmitted &&
(prevMsg.children?.length ?? 0) === (nextMsg.children?.length ?? 0) &&
prevMsg.content === nextMsg.content &&
prevMsg.model === nextMsg.model &&