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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🛋️ feat: Open Subagents Directly from Background Tasks (#17020)
lia-by-librechat[bot]147aa2980752
diff --git a/client/src/components/Chat/BackgroundTasks/Button.tsx b/client/src/components/Chat/BackgroundTasks/Button.tsxindex ace336d4ee..9739557b90 100644--- a/client/src/components/Chat/BackgroundTasks/Button.tsx+++ b/client/src/components/Chat/BackgroundTasks/Button.tsx@@ -3,6 +3,9 @@ import * as Ariakit from '@ariakit/react';import { Button, IconButton, TooltipAnchor } from '@librechat/client';import { ListTodo, Maximize2, Minimize2, Square, X } from 'lucide-react';import type { TaskRow } from './rows';+import { useParentSubagents } from '~/components/Chat/Subagents/ParentSubagentsProvider';+import { durableSubagentSelection } from '~/components/Chat/Subagents/eventSelection';+import { useOpenSubagentPanel } from '~/components/Chat/Subagents/surface';import { RECENT_SUBAGENT_WINDOW_MS } from './rows';import useBackgroundTasks from './useTasks';import { useLocalize } from '~/hooks';@@ -24,6 +27,8 @@ function BackgroundTasksButton({isSubmitting: boolean;}) {const localize = useLocalize();+ const openSubagentPanel = useOpenSubagentPanel();+ const parent = useParentSubagents();const popover = Ariakit.usePopoverStore({ placement: 'bottom-end' });const open = Ariakit.useStoreState(popover, 'open');const disclosureRef = useRef<HTMLButtonElement>(null);@@ -85,35 +90,23 @@ function BackgroundTasksButton({stopAllLabel = localize('com_ui_background_tasks_stop_available');}const jumpToTool = (row: TaskRow): boolean => {- if (row.eventOrigin && row.threadId != null) {- const events = Array.from(- document.querySelectorAll<HTMLElement>(- '[data-event-subagent-conversation] [data-subagent-thread]',- ),- ).filter(- (element) =>- element.dataset.subagentThread === row.threadId &&- element.dataset.subagentParentMessage === row.messageId &&- element.closest<HTMLElement>('[data-event-subagent-conversation]')?.dataset- .eventSubagentConversation === conversationId,- );- if (events.length !== 1) return false;- const target = events[0];- if (target.matches(':disabled')) return false;- const group = target.closest('[data-event-subagent-conversation]');- group?.querySelector<HTMLButtonElement>('button[aria-expanded="false"]')?.click();+ if (row.kind === 'subagent') {+ if (+ openSubagentPanel == null ||+ parent.conversationId !== conversationId ||+ row.threadId == null ||+ row.taskId == null+ ) {+ return false;+ }+ const child = parent.byThreadId.get(row.threadId);+ if (child == null) return false;+ const selection = durableSubagentSelection(conversationId, child, row.taskId);+ if (selection == null) return false;finalFocusRef.current = null;+ disclosureRef.current?.focus({ preventScroll: true });popover.hide();- window.requestAnimationFrame(() => {- if (!target.isConnected || popover.getState().open) return;- target.focus({ preventScroll: true });- target.scrollIntoView?.({- block: 'center',- behavior: window.matchMedia?.('(prefers-reduced-motion: reduce)').matches- ? 'instant'- : 'smooth',- });- });+ openSubagentPanel({ ...selection, isSubmitting: false });return true;}if (row.messageId == null) return false;diff --git a/client/src/components/Chat/BackgroundTasks/Card.tsx b/client/src/components/Chat/BackgroundTasks/Card.tsxindex 4987da9641..6653924bff 100644--- a/client/src/components/Chat/BackgroundTasks/Card.tsx+++ b/client/src/components/Chat/BackgroundTasks/Card.tsx@@ -66,6 +66,11 @@ function TaskCard({: undefined;const stopLabel = localize('com_ui_background_tasks_stop');const expandable = row.detail != null;+ const openLabel = localize(+ row.kind === 'subagent'+ ? 'com_ui_background_tasks_open_subagent'+ : 'com_ui_background_tasks_go_to_tool',+ );return (<li className="bg-surface-tertiary rounded-lg px-3 py-2" data-testid="background-task-row">@@ -125,14 +130,14 @@ function TaskCard({</p></div><TooltipAnchor- description={localize('com_ui_background_tasks_go_to_tool')}+ description={openLabel}portalElement={portalElement}render={<IconButtonvariant="ghost"size="xs"shape="inset"- label={`${localize('com_ui_background_tasks_go_to_tool')}: ${title}`}+ label={`${openLabel}: ${title}`}onClick={() => setJumpUnavailable(!onJump(row))}><ArrowUpRight className="size-3.5" aria-hidden="true" />@@ -174,7 +179,11 @@ function TaskCard({)}{jumpUnavailable && (<p role="status" className="text-text-secondary mt-1 text-xs">- {localize('com_ui_background_tasks_tool_unavailable')}+ {localize(+ row.kind === 'subagent'+ ? 'com_ui_background_tasks_subagent_unavailable'+ : 'com_ui_background_tasks_tool_unavailable',+ )}</p>)}</li>diff --git a/client/src/components/Chat/BackgroundTasks/__tests__/Button.test.tsx b/client/src/components/Chat/BackgroundTasks/__tests__/Button.test.tsxindex 6a3e8afacc..260587d593 100644--- a/client/src/components/Chat/BackgroundTasks/__tests__/Button.test.tsx+++ b/client/src/components/Chat/BackgroundTasks/__tests__/Button.test.tsx@@ -5,7 +5,10 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query';import { act, render, screen, waitFor, within } from '@testing-library/react';import { ContentTypes, QueryKeys, dataService } from 'librechat-data-provider';import type { ParentSubagentSummary, BackgroundTaskIndex, TMessage } from 'librechat-data-provider';+import type { JotaiStore } from 'test/harness';import { ParentSubagentsProvider } from '~/components/Chat/Subagents/ParentSubagentsProvider';+import { activeSubagentPanel } from '~/components/Chat/Subagents/state';+import { ChatSurfaceHarness } from 'test/harness';import BackgroundTasksButton from '../Button';jest.mock('librechat-data-provider', () => {@@ -89,16 +92,23 @@ const renderButton = (children: ParentSubagentSummary[] = [], initialMessages =children,childrenTruncated: false,});+ let atoms!: JotaiStore;const rendered = render(- <RecoilRoot>- <QueryClientProvider client={queryClient}>- <ParentSubagentsProvider conversationId={conversationId} enabled>- <BackgroundTasksButton conversationId={conversationId} isSubmitting={false} />- </ParentSubagentsProvider>- </QueryClientProvider>- </RecoilRoot>,+ <ChatSurfaceHarness+ seed={(store) => {+ atoms = store;+ }}+ >+ <RecoilRoot>+ <QueryClientProvider client={queryClient}>+ <ParentSubagentsProvider conversationId={conversationId} enabled>+ <BackgroundTasksButton conversationId={conversationId} isSubmitting={false} />+ </ParentSubagentsProvider>+ </QueryClientProvider>+ </RecoilRoot>+ </ChatSurfaceHarness>,);- return { ...rendered, queryClient };+ return { ...rendered, queryClient, getSelection: () => atoms.get(activeSubagentPanel) };};afterEach(() => jest.restoreAllMocks());@@ -420,13 +430,16 @@ describe('BackgroundTasksButton', () => {expect(screen.getByText('npx jest tasks.spec.ts').closest('[inert]')).not.toBeNull();});- it('provides a tool destination action on every task', async () => {+ it('provides the appropriate open action for each task kind', async () => {jest.spyOn(dataService, 'getBackgroundTasks').mockResolvedValue(index());renderButton([runningChild]);await userEvent.click(await screen.findByTestId('header-background-tasks-button'));expect(await screen.findAllByRole('button', { name: /^com_ui_background_tasks_go_to_tool:/ }),- ).toHaveLength(3);+ ).toHaveLength(2);+ expect(+ screen.getAllByRole('button', { name: /^com_ui_background_tasks_open_subagent:/ }),+ ).toHaveLength(1);});it('renders tool navigation as an icon without visible button text', async () => {@@ -470,32 +483,69 @@ describe('BackgroundTasksButton', () => {expect(row.querySelector('[inert]')).not.toBeNull();});- it('prioritizes the exact subagent thread over a reused call id', async () => {- jest.spyOn(dataService, 'getBackgroundTasks').mockResolvedValue(index({ tasks: [] }));- renderButton([runningChild]);- const message = document.createElement('section');- message.id = 'parent-message';- const targets = ['thread-1', 'other-thread'].map((thread) => {- const wrapper = document.createElement('div');- wrapper.dataset.taskToolCall = 'call-subagent';- const target = document.createElement('button');- target.dataset.subagentThread = thread;- target.dataset.subagentToolCall = 'call-subagent';- target.scrollIntoView = jest.fn();- wrapper.append(target);- message.append(wrapper);- return target;- });- document.body.append(message);- try {- await userEvent.click(await screen.findByTestId('header-background-tasks-button'));+ it.each(['running', 'completed', 'failed', 'cancelled'] as const)(+ 'opens a %s subagent without needing its originating message',+ async (status) => {+ jest.spyOn(dataService, 'getBackgroundTasks').mockResolvedValue(index({ tasks: [] }));+ const before = window.location.href;+ const { getSelection } = renderButton([+ {+ ...runningChild,+ status,+ tasks: [{ taskId: 'sub-task-1', status, createdAt: startedAt }],+ updatedAt: new Date().toISOString(),+ },+ ]);+ const trigger = await screen.findByTestId('header-background-tasks-button');+ await userEvent.click(trigger);await userEvent.click(- await screen.findByRole('button', { name: /^com_ui_background_tasks_go_to_tool:/ }),+ await screen.findByRole('button', { name: /^com_ui_background_tasks_open_subagent:/ }),);- expect(targets[0].scrollIntoView).toHaveBeenCalled();- } finally {- message.remove();- }+ expect(getSelection()).toMatchObject({+ parentConversationId: conversationId,+ parentMessageId: 'parent-message',+ toolCallId: 'call-subagent',+ isSubmitting: false,+ durable: { threadId: 'thread-1', taskId: 'sub-task-1' },+ });+ expect(window.location.href).toBe(before);+ expect(document.getElementById('parent-message')).toBeNull();+ await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());+ expect(trigger).toHaveFocus();+ },+ );++ it('opens the exact thread when provider call ids are reused', async () => {+ jest.spyOn(dataService, 'getBackgroundTasks').mockResolvedValue(index({ tasks: [] }));+ const { getSelection } = renderButton([+ runningChild,+ { ...runningChild, threadId: 'other-thread', title: 'Other researcher' },+ ]);+ await userEvent.click(await screen.findByTestId('header-background-tasks-button'));+ await userEvent.click(+ await screen.findByRole('button', {+ name: 'com_ui_background_tasks_open_subagent: Other researcher',+ }),+ );+ expect(getSelection()).toMatchObject({+ durable: { threadId: 'other-thread', taskId: 'sub-task-1' },+ });+ });++ it('explains an unaddressable subagent without falling back to a tool jump', async () => {+ jest.spyOn(dataService, 'getBackgroundTasks').mockResolvedValue(index({ tasks: [] }));+ const { getSelection } = renderButton([+ { ...runningChild, latestTaskId: undefined, tasks: [] },+ ]);+ await userEvent.click(await screen.findByTestId('header-background-tasks-button'));+ await userEvent.click(+ await screen.findByRole('button', { name: /^com_ui_background_tasks_open_subagent:/ }),+ );+ expect(getSelection()).toBeNull();+ expect(screen.getByRole('status')).toHaveTextContent(+ 'com_ui_background_tasks_subagent_unavailable',+ );+ expect(screen.getByRole('dialog')).toBeInTheDocument();});it('rejects identity-less durable completions even when a visible call id matches', async () => {@@ -517,30 +567,21 @@ describe('BackgroundTasksButton', () => {}});- it('reveals an event activity destination outside its parent message', async () => {+ it('opens event subagents with the actor timeline pinned to the requested task', async () => {jest.spyOn(dataService, 'getBackgroundTasks').mockResolvedValue(index({ tasks: [] }));- renderButton([{ ...runningChild, origin: 'event', parentToolCallId: undefined }]);- const group = document.createElement('section');- group.dataset.eventSubagentConversation = conversationId;- const header = document.createElement('button');- header.setAttribute('aria-expanded', 'false');- const target = document.createElement('button');- target.dataset.subagentThread = 'thread-1';- target.dataset.subagentParentMessage = 'parent-message';- target.scrollIntoView = jest.fn();- header.onclick = () => header.setAttribute('aria-expanded', 'true');- group.append(header, target);- document.body.append(group);- try {- await userEvent.click(await screen.findByTestId('header-background-tasks-button'));- await userEvent.click(- await screen.findByRole('button', { name: /^com_ui_background_tasks_go_to_tool:/ }),- );- expect(header).toHaveAttribute('aria-expanded', 'true');- await waitFor(() => expect(target.scrollIntoView).toHaveBeenCalled());- } finally {- group.remove();- }+ const { getSelection } = renderButton([+ { ...runningChild, origin: 'event', actorId: 'actor-1', parentToolCallId: undefined },+ ]);+ await userEvent.click(await screen.findByTestId('header-background-tasks-button'));+ await userEvent.click(+ await screen.findByRole('button', { name: /^com_ui_background_tasks_open_subagent:/ }),+ );+ expect(getSelection()).toMatchObject({+ durable: { threadId: 'thread-1', taskId: 'sub-task-1' },+ event: { actorId: 'actor-1', pinnedTask: true },+ isSubmitting: false,+ });+ await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull());});it('keeps the panel open when its exact destination is inert', async () => {diff --git a/client/src/components/Chat/BackgroundTasks/__tests__/rows.test.ts b/client/src/components/Chat/BackgroundTasks/__tests__/rows.test.tsindex 8ff2ecb313..b1535b2ea7 100644--- a/client/src/components/Chat/BackgroundTasks/__tests__/rows.test.ts+++ b/client/src/components/Chat/BackgroundTasks/__tests__/rows.test.ts@@ -116,6 +116,7 @@ describe('buildTaskRows', () => {]);expect(rows[0].subagent).toEqual({ threadId: 'running-child', taskId: 'task' });expect(rows[3].subagent).toBeUndefined();+ expect(rows[3].taskId).toBe('task');});});diff --git a/client/src/components/Chat/BackgroundTasks/rows.ts b/client/src/components/Chat/BackgroundTasks/rows.tsindex bedf32706c..0ef17c7cc5 100644--- a/client/src/components/Chat/BackgroundTasks/rows.ts+++ b/client/src/components/Chat/BackgroundTasks/rows.ts@@ -131,6 +131,7 @@ const subagentRow = (child: ParentSubagentSummary, stopping: ReadonlySet<string>id: `subagent:${subagentTaskKey(child.threadId, taskId)}`,kind: 'subagent',name: child.title,+ taskId,messageId: child.parentMessageId,toolCallId: child.parentToolCallId,threadId: child.threadId,diff --git a/client/src/components/Chat/Messages/Content/Parts/SubagentCall.tsx b/client/src/components/Chat/Messages/Content/Parts/SubagentCall.tsxindex 09f474ccda..fb8932da1c 100644--- a/client/src/components/Chat/Messages/Content/Parts/SubagentCall.tsx+++ b/client/src/components/Chat/Messages/Content/Parts/SubagentCall.tsx@@ -386,13 +386,26 @@ export default function SubagentCall({useEffect(() => {setSelectedSubagent((current) =>- current?.parentMessageId === parentMessageId &&+ current?.host === panelSelection.host &&+ current.shareId === panelSelection.shareId &&+ current.parentConversationId === parentConversationId &&+ current.parentMessageId === parentMessageId &¤t.toolCallId === toolCallId &&- current.partIndex === partIndex+ current.partIndex === partIndex &&+ (current.durable == null ||+ (current.durable.threadId === panelSelection.durable?.threadId &&+ current.durable.taskId === panelSelection.durable?.taskId))? panelSelection: current,);- }, [panelSelection, parentMessageId, partIndex, setSelectedSubagent, toolCallId]);+ }, [+ panelSelection,+ parentConversationId,+ parentMessageId,+ partIndex,+ setSelectedSubagent,+ toolCallId,+ ]);const openDetails = useCallback(() => {if (!canOpenDetails || openPanel == null) return;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.tsxindex f1c981b3dd..538f1badf7 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@@ -140,6 +140,7 @@ function renderWithState(args: {toolArgs?: Record<string, unknown>;subagentIdentity?: SubagentIdentity;runStepStatus?: PartMetadata['runStepStatus'];+ selection?: ActiveSubagentPanel;}) {const setter = { current: null as null | ((next: SubagentProgress | null) => void) };let selection: ActiveSubagentPanel | null = null;@@ -158,7 +159,7 @@ function renderWithState(args: {};const tree = (tick: number) => (<MemoryRouter>- <ChatSurfaceHarness>+ <ChatSurfaceHarness seed={(store) => store.set(activeSubagentPanel, args.selection ?? null)}><RecoilRoot><SeedHelper /><SelectionObserver />@@ -493,6 +494,38 @@ describe('SubagentCall', () => {expect((selection as ActiveSubagentPanel | null)?.durable).toBeUndefined();});+ it.each([+ { threadId: 'child-thread-1', taskId: 'task-2', parentConversationId: 'parent-conversation' },+ { threadId: 'child-thread-2', taskId: 'task-1', parentConversationId: 'parent-conversation' },+ { threadId: 'child-thread-1', taskId: 'task-1', parentConversationId: 'other-conversation' },+ ])('does not replace a retained task on dispatch remount: %p', (identity) => {+ const retained: ActiveSubagentPanel = {+ host: 'conversation',+ parentConversationId: identity.parentConversationId,+ parentMessageId: 'parent-message',+ toolCallId: 'detached-call',+ partIndex: 0,+ subagentType: 'self',+ initialProgress: 0,+ isSubmitting: false,+ durable: { threadId: identity.threadId, taskId: identity.taskId },+ };+ const rendered = renderWithState({+ toolCallId: 'detached-call',+ initialProgress: 1,+ output: JSON.stringify({+ background_task_id: 'task-1',+ subagent_thread_id: 'child-thread-1',+ tool: 'subagent',+ subagent_type: 'self',+ status: 'running',+ }),+ toolArgs: { subagent_type: 'self', run_in_background: true },+ selection: retained,+ });+ expect(rendered.getSelection()).toBe(retained);+ });+it('opens an exact host-issued detached invocation in the same panel', () => {const output = JSON.stringify({background_task_id: 'task-1',diff --git a/client/src/components/Chat/Presentation.test.tsx b/client/src/components/Chat/Presentation.test.tsxindex d68713382a..536f33e5d0 100644--- a/client/src/components/Chat/Presentation.test.tsx+++ b/client/src/components/Chat/Presentation.test.tsx@@ -5,6 +5,7 @@ import { isSubmittingFamily } from '@librechat/chat/react';import { QueryClient, QueryClientProvider } from '@tanstack/react-query';import { fireEvent, render, screen, waitFor } from '@testing-library/react';import type { TConversation } from 'librechat-data-provider';+import type { JotaiStore } from 'test/harness';import type { Artifact } from '~/common';import { prepareUndockedDocument } from '~/components/Artifacts/undockedWindow';import { activeSubagentPanel } from '~/components/Chat/Subagents/state';@@ -48,10 +49,24 @@ jest.mock('~/components/Artifacts/Artifacts', () => {};});-jest.mock('~/components/Chat/Subagents/SubagentThreadPanel', () => ({- __esModule: true,- default: () => <aside>{mockChildPanelLabel}</aside>,-}));+jest.mock('~/components/Chat/Subagents/SubagentThreadPanel', () => {+ const { useParentSubagents } = jest.requireActual<+ typeof import('~/components/Chat/Subagents/ParentSubagentsProvider')+ >('~/components/Chat/Subagents/ParentSubagentsProvider');+ return {+ __esModule: true,+ default: function MockSubagentThreadPanel() {+ const parent = useParentSubagents();+ return (+ <aside>+ {mockChildPanelLabel}+ <span data-testid="panel-parent">{parent.conversationId}</span>+ <input aria-label="Panel draft" />+ </aside>+ );+ },+ };+});jest.mock('~/components/Chat/Input/Files/DragDropWrapper', () => ({__esModule: true,@@ -117,7 +132,7 @@ const OpenArtifactPanel = () => {);};-const OpenSubagentPanel = () => {+const OpenSubagentPanel = ({ durable = true }: { durable?: boolean }) => {const setConversation = useSetRecoilState(store.conversationByIndex(0));const setSelection = useSetAtom(activeSubagentPanel);const open = () => {@@ -131,10 +146,7 @@ const OpenSubagentPanel = () => {subagentType: 'researcher',initialProgress: 1,isSubmitting: false,- durable: {- threadId: 'child-thread',- taskId: 'background-task',- },+ durable: durable ? { threadId: 'child-thread', taskId: 'background-task' } : undefined,});};return (@@ -223,6 +235,66 @@ describe('Presentation Artifact loading', () => {);});+ it('keeps durable activity and its draft bound to the original parent after navigation', async () => {+ renderPresentation(+ <ChatSurfaceHarness>+ <RecoilRoot>+ <Presentation>+ <OpenSubagentPanel />+ <SelectAgentConversation />+ </Presentation>+ </RecoilRoot>+ </ChatSurfaceHarness>,+ );+ fireEvent.click(screen.getByRole('button', { name: mockOpenChildLabel }));+ expect(await screen.findByText(mockChildPanelLabel)).toBeInTheDocument();+ const draft = screen.getByLabelText('Panel draft');+ fireEvent.change(draft, { target: { value: 'Keep this guidance.' } });+ fireEvent.click(screen.getByRole('button', { name: mockSelectAgentConversationLabel }));+ expect(screen.getByText(mockChildPanelLabel)).toBeInTheDocument();+ expect(screen.getByTestId('panel-parent')).toHaveTextContent('parent-conversation');+ expect(screen.getByLabelText('Panel draft')).toBe(draft);+ expect(draft).toHaveValue('Keep this guidance.');+ });++ it('clears the durable selection when its authenticated chat host unmounts', async () => {+ let atoms: JotaiStore;+ const view = renderPresentation(+ <ChatSurfaceHarness+ seed={(store) => {+ atoms = store;+ }}+ >+ <RecoilRoot>+ <Presentation>+ <OpenSubagentPanel />+ </Presentation>+ </RecoilRoot>+ </ChatSurfaceHarness>,+ );+ fireEvent.click(screen.getByRole('button', { name: mockOpenChildLabel }));+ expect(await screen.findByText(mockChildPanelLabel)).toBeInTheDocument();+ view.unmount();+ expect(atoms!.get(activeSubagentPanel)).toBeNull();+ });++ it('still closes non-durable activity when leaving its parent chat', async () => {+ renderPresentation(+ <ChatSurfaceHarness>+ <RecoilRoot>+ <Presentation>+ <OpenSubagentPanel durable={false} />+ <SelectAgentConversation />+ </Presentation>+ </RecoilRoot>+ </ChatSurfaceHarness>,+ );+ fireEvent.click(screen.getByRole('button', { name: mockOpenChildLabel }));+ expect(await screen.findByText(mockChildPanelLabel)).toBeInTheDocument();+ fireEvent.click(screen.getByRole('button', { name: mockSelectAgentConversationLabel }));+ expect(screen.queryByText(mockChildPanelLabel)).not.toBeInTheDocument();+ });+it('uses one panel slot and lets an opened artifact replace child activity', async () => {renderPresentation(<ChatSurfaceHarness>diff --git a/client/src/components/Chat/Presentation.tsx b/client/src/components/Chat/Presentation.tsxindex f1da81f9d6..e8c9e14963 100644--- a/client/src/components/Chat/Presentation.tsx+++ b/client/src/components/Chat/Presentation.tsx@@ -54,12 +54,20 @@ export default function Presentation({useArtifactsRegistryLifetime(conversationId);+ useEffect(+ () => () =>+ setSelectedSubagent((current) => (current?.host === 'conversation' ? null : current)),+ [setSelectedSubagent],+ );+useEffect(() => {const previous = previousConversationIdRef.current;const next = conversationId ?? null;previousConversationIdRef.current = next;- if (previous != null && previous !== next) resetSelectedSubagent();- }, [conversationId, resetSelectedSubagent]);+ if (previous != null && previous !== next) {+ setSelectedSubagent((current) => (current?.durable == null ? null : current));+ }+ }, [conversationId, setSelectedSubagent]);const setFilesToDelete = useSetFilesToDelete();@@ -153,14 +161,16 @@ export default function Presentation({if (selectedSubagent == null ||selectedSubagent.host !== 'conversation' ||- selectedSubagent.parentConversationId !== conversationId+ (selectedSubagent.durable == null && selectedSubagent.parentConversationId !== conversationId)) {return null;}return (- <Suspense fallback={null}>- <SubagentThreadPanel selection={selectedSubagent} />- </Suspense>+ <ParentSubagentsProvider conversationId={selectedSubagent.parentConversationId} enabled>+ <Suspense fallback={null}>+ <SubagentThreadPanel selection={selectedSubagent} />+ </Suspense>+ </ParentSubagentsProvider>);}, [conversationId, selectedSubagent]);diff --git a/client/src/components/Chat/Subagents/EventSubagentActivityGroup.test.tsx b/client/src/components/Chat/Subagents/EventSubagentActivityGroup.test.tsxindex 05b059b35e..40f607c236 100644--- a/client/src/components/Chat/Subagents/EventSubagentActivityGroup.test.tsx+++ b/client/src/components/Chat/Subagents/EventSubagentActivityGroup.test.tsx@@ -5,6 +5,7 @@ import type { ParentSubagentSummary } from 'librechat-data-provider';import type { ActiveSubagentPanel } from './state';import EventSubagentActivityGroup from './EventSubagentActivityGroup';import { ChatSurfaceHarness, testChatSurface } from 'test/harness';+import { durableSubagentSelection } from './eventSelection';import { activeSubagentPanel } from './state';const mockRefresh = jest.fn().mockResolvedValue(undefined);@@ -259,6 +260,56 @@ describe('EventSubagentActivityGroup', () => {expect(completed.firstElementChild).not.toHaveClass('shimmer');});+ it('keeps a pinned task when an earlier row refresh finishes', async () => {+ let selection: ActiveSubagentPanel | null = null;+ let resolveRefresh!: (value: { children: ParentSubagentSummary[] }) => void;+ mockRefresh.mockReturnValueOnce(+ new Promise((resolve) => {+ resolveRefresh = resolve;+ }),+ );+ const Observer = () => {+ selection = useAtomValue(activeSubagentPanel);+ return null;+ };+ const PinTask = () => {+ const setSelection = useSetAtom(activeSubagentPanel);+ return (+ <button+ type="button"+ data-testid="pin-task"+ onClick={() =>+ setSelection(durableSubagentSelection('parent-conversation', mockChild, 'task-1'))+ }+ />+ );+ };+ render(+ <ChatSurfaceHarness>+ <Observer />+ <PinTask />+ <EventSubagentActivityGroup+ conversationId="parent-conversation"+ parentMessageIds={['parent-message']}+ />+ </ChatSurfaceHarness>,+ );+ fireEvent.click(screen.getByRole('button', { name: /com_ui_subagent_activity/ }));+ fireEvent.click(screen.getByRole('button', { name: /Visible Agent/ }));+ fireEvent.click(screen.getByTestId('pin-task'));+ await act(async () => {+ resolveRefresh({+ children: [{ ...mockChild, latestTaskId: 'task-2' }],+ });+ });+ expect(selection).toEqual(+ expect.objectContaining({+ durable: { threadId: 'event-thread', taskId: 'task-1' },+ event: expect.objectContaining({ pinnedTask: true }),+ }),+ );+ });+it('does not reopen a child after the user closes it while refresh is pending', async () => {let selection: ActiveSubagentPanel | null = null;let resolveRefresh!: (value: unknown) => void;diff --git a/client/src/components/Chat/Subagents/EventSubagentActivityGroup.tsx b/client/src/components/Chat/Subagents/EventSubagentActivityGroup.tsxindex a64a3a5123..cd65b3d209 100644--- a/client/src/components/Chat/Subagents/EventSubagentActivityGroup.tsx+++ b/client/src/components/Chat/Subagents/EventSubagentActivityGroup.tsx@@ -130,6 +130,7 @@ function EventSubagentRows({if (freshSelection != null) {setSelected((current) => {if (+ current?.event?.pinnedTask === true ||current?.durable?.threadId !== selection.durable?.threadId ||current?.durable?.taskId !== selection.durable?.taskId) {diff --git a/client/src/components/Chat/Subagents/ParentSubagentsProvider.test.tsx b/client/src/components/Chat/Subagents/ParentSubagentsProvider.test.tsxindex 58c5221b60..8f56715f36 100644--- a/client/src/components/Chat/Subagents/ParentSubagentsProvider.test.tsx+++ b/client/src/components/Chat/Subagents/ParentSubagentsProvider.test.tsx@@ -82,6 +82,51 @@ describe('ParentSubagentsProvider', () => {expect(result).toEqual(refreshed);});+ it('reuses its parent index while chats match and owns discovery after navigation', () => {+ mockUseParentSubagentsQuery.mockImplementation((conversationId: string) => ({+ data: {+ parentConversationId: conversationId,+ children: conversationId === 'parent-conversation' ? [eventChild] : [],+ childrenTruncated: false,+ },+ refetch: jest.fn(),+ }));+ let outer: ReturnType<typeof useParentSubagents> | undefined;+ let panel: ReturnType<typeof useParentSubagents> | undefined;+ const OuterProbe = () => {+ outer = useParentSubagents();+ return null;+ };+ const PanelProbe = () => {+ panel = useParentSubagents();+ return null;+ };+ const tree = (visibleConversation: string) => (+ <ParentSubagentsProvider conversationId={visibleConversation} enabled>+ <OuterProbe />+ <ParentSubagentsProvider conversationId="parent-conversation" enabled>+ <PanelProbe />+ </ParentSubagentsProvider>+ </ParentSubagentsProvider>+ );+ const view = renderProvider(tree('parent-conversation'));+ expect(panel).toBe(outer);+ expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(+ 'parent-conversation',+ { enabled: false },+ false,+ );+ view.rerender(tree('other-conversation'));+ expect(panel?.conversationId).toBe('parent-conversation');+ expect(panel?.byThreadId.get('event-thread')).toEqual(eventChild);+ expect(outer?.conversationId).toBe('other-conversation');+ expect(mockUseParentSubagentsQuery).toHaveBeenLastCalledWith(+ 'parent-conversation',+ { enabled: true },+ false,+ );+ });+it('marks an active parent run for prompt discovery', () => {mockUseParentSubagentsQuery.mockReturnValue({ data: undefined, refetch: jest.fn() });renderProvider(diff --git a/client/src/components/Chat/Subagents/ParentSubagentsProvider.tsx b/client/src/components/Chat/Subagents/ParentSubagentsProvider.tsxindex 4f7172aeef..7e10bc1bdf 100644--- a/client/src/components/Chat/Subagents/ParentSubagentsProvider.tsx+++ b/client/src/components/Chat/Subagents/ParentSubagentsProvider.tsx@@ -43,6 +43,9 @@ export function ParentSubagentsProvider({children: React.ReactNode;}) {const queryClient = useQueryClient();+ const parent = useContext(ParentSubagentsContext);+ const inherited =+ parent.conversationId === conversationId && parent.discoveryEnabled ? parent : null;// Observe already-loaded history without fetching it or rerendering on streamed text.const { data: hasAgentHistory = false } = useQuery<TMessage[], unknown, boolean>([QueryKeys.messages, conversationId],@@ -70,7 +73,7 @@ export function ParentSubagentsProvider({}const { data, refetch, isError } = useParentSubagentsQuery(conversationId,- { enabled: discoveryEnabled },+ { enabled: discoveryEnabled && inherited == null },isSubmitting,);const refresh = useCallback(async () => {@@ -78,6 +81,7 @@ export function ParentSubagentsProvider({return result.data;}, [refetch]);const value = useMemo<ParentSubagentsContextValue>(() => {+ if (inherited != null) return inherited;const byMessageId = new Map<string, ParentSubagentSummary[]>();const byThreadId = new Map<string, ParentSubagentSummary>();for (const child of data?.children ?? []) {@@ -94,7 +98,7 @@ export function ParentSubagentsProvider({});}return { conversationId, byMessageId, byThreadId, refresh, isError, discoveryEnabled };- }, [conversationId, data, refresh, isError, discoveryEnabled]);+ }, [conversationId, data, refresh, isError, discoveryEnabled, inherited]);return (<ParentSubagentsContext.Provider value={value}>{children}</ParentSubagentsContext.Provider>diff --git a/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx b/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsxindex 120bebc4e7..ac52400615 100644--- a/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx+++ b/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx@@ -15,6 +15,7 @@ import { activeSubagentPanel, subagentProgressByToolCallId, subagentProgressKeyimport { initSubagentAggregatorState, initSubagentTickerState } from '~/utils/subagentContent';import { ChatSurfaceHarness, testChatSurface } from 'test/harness';import SubagentThreadPanel from './SubagentThreadPanel';+import { useOpenSubagentPanel } from './surface';import { getDraft } from '~/utils';const mockUseSubagentThreadQuery = jest.fn();@@ -30,6 +31,7 @@ const mockUseSubagentActivityStream = jest.fn();const mockForkMutate = jest.fn();const mockControlMutate = jest.fn();const mockNavigateToConvo = jest.fn();+const mockNavigate = jest.fn();const mockShowToast = jest.fn();const mockGetSubagentThread = jest.fn();const mockApprovalProviderMounted = jest.fn();@@ -74,6 +76,11 @@ function Root({);}+jest.mock('react-router-dom', () => ({+ ...jest.requireActual('react-router-dom'),+ useNavigate: () => mockNavigate,+}));+jest.mock('librechat-data-provider', () => {const actual = jest.requireActual('librechat-data-provider');return {@@ -444,6 +451,7 @@ jest.mock('@librechat/client', () => ({jest.mock('lucide-react', () => ({AlertCircle: () => null,+ ArrowUpRight: () => null,CornerUpLeft: () => null,CheckCircle2: () => null,Clock: () => null,@@ -525,6 +533,7 @@ describe('SubagentThreadPanel', () => {mockForkMutate.mockClear();mockControlMutate.mockClear();mockNavigateToConvo.mockClear();+ mockNavigate.mockClear();mockShowToast.mockClear();mockGetSubagentThread.mockReset();mockRefreshParentChildren.mockClear();@@ -1208,6 +1217,254 @@ describe('SubagentThreadPanel', () => {},);+ it('focuses the panel when the same task is explicitly reopened', () => {+ mockUseSubagentThreadQuery.mockReturnValue({+ data: completedView,+ isLoading: false,+ isError: false,+ isReadinessPending: false,+ });+ const openTaskLabel = 'Open task';+ const OpenPanel = () => {+ const open = useOpenSubagentPanel();+ return (+ <button type="button" onClick={() => open?.(selection)}>+ {openTaskLabel}+ </button>+ );+ };+ render(+ <Root>+ <input aria-label="Main chat draft" />+ <OpenPanel />+ <SubagentThreadPanel selection={selection} />+ </Root>,+ );+ screen.getByLabelText('Main chat draft').focus();+ fireEvent.click(screen.getByRole('button', { name: 'Open task' }));+ expect(screen.getByRole('region', { name: 'com_ui_subagent_thread_panel' })).toHaveFocus();+ });++ it.each(['same', 'different'] as const)(+ 'returns focus to the latest opener after explicitly opening the %s task',+ async (target) => {+ mockUseSubagentThreadQuery.mockReturnValue({+ data: completedView,+ isLoading: false,+ isError: false,+ isReadinessPending: false,+ });+ const firstOpener = document.createElement('button');+ const latestOpener = document.createElement('button');+ firstOpener.id = 'first-opener';+ latestOpener.id = 'latest-opener';+ document.body.append(firstOpener, latestOpener);+ firstOpener.focus();+ const nextSelection: ActiveSubagentPanel =+ target === 'same'+ ? selection+ : {+ ...selection,+ parentMessageId: 'unloaded-message',+ toolCallId: 'other-call',+ durable: { threadId: 'other-thread', taskId: 'other-task' },+ };+ const openTaskLabel = 'Open task';+ const PanelHost = () => {+ const selected = useAtomValue(activeSubagentPanel);+ const open = useOpenSubagentPanel();+ return (+ <>+ <button+ type="button"+ onClick={() => {+ latestOpener.focus();+ open?.(nextSelection);+ }}+ >+ {openTaskLabel}+ </button>+ {selected != null && <SubagentThreadPanel selection={selected} />}+ </>+ );+ };+ try {+ render(+ <Root seed={(store) => store.set(activeSubagentPanel, selection)}>+ <PanelHost />+ </Root>,+ );+ const panel = screen.getByRole('region', { name: 'com_ui_subagent_thread_panel' });+ expect(panel).toHaveFocus();+ fireEvent.click(screen.getByRole('button', { name: openTaskLabel }));+ expect(screen.getByRole('region', { name: 'com_ui_subagent_thread_panel' })).toBe(panel);+ expect(panel).toHaveFocus();+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_close' }));+ await waitFor(() => expect(latestOpener).toHaveFocus());+ expect(firstOpener).not.toHaveFocus();+ } finally {+ firstOpener.remove();+ latestOpener.remove();+ }+ },+ );++ describe.each([false, true])('focus return with mobile = %s', (mobile) => {+ it.each([+ 'available',+ 'hidden',+ 'inert',+ 'aria-hidden',+ 'aria-disabled',+ 'disabled',+ 'removed',+ ])(+ 'prefers the explicit opener when it is %s, otherwise falls back to the message card',+ async (openerState) => {+ mockIsMobile = mobile;+ mockUseSubagentThreadQuery.mockReturnValue({+ data: completedView,+ isLoading: false,+ isError: false,+ isReadinessPending: false,+ });+ const disclosure = document.createElement('button');+ const messageCard = document.createElement('button');+ disclosure.id = 'popup-opener';+ disclosure.dataset.testid = 'header-background-tasks-button';+ messageCard.id = 'loaded-message-card';+ messageCard.dataset.subagentToolCall = selection.toolCallId;+ messageCard.dataset.subagentParentMessage = selection.parentMessageId;+ messageCard.dataset.subagentPartIndex = String(selection.partIndex);+ document.body.append(disclosure, messageCard);+ disclosure.focus();+ const PanelHost = () => {+ const selected = useAtomValue(activeSubagentPanel);+ return selected == null ? null : <SubagentThreadPanel selection={selected} />;+ };+ try {+ render(+ <Root seed={(store) => store.set(activeSubagentPanel, selection)}>+ <PanelHost />+ </Root>,+ );+ if (openerState === 'removed') disclosure.remove();+ else if (openerState === 'disabled') disclosure.disabled = true;+ else if (openerState !== 'available') {+ disclosure.setAttribute(openerState, openerState.startsWith('aria-') ? 'true' : '');+ }+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_close' }));+ const destination = openerState === 'available' ? disclosure : messageCard;+ await waitFor(() => expect(destination).toHaveFocus());+ } finally {+ disclosure.remove();+ messageCard.remove();+ }+ },+ );+ });++ it('does not steal main-chat focus when the selected task advances', () => {+ mockUseSubagentThreadQuery.mockReturnValue({+ data: completedView,+ isLoading: false,+ isError: false,+ isReadinessPending: false,+ });+ const tree = (taskId: string) => (+ <Root>+ <input aria-label="Main chat draft" />+ <SubagentThreadPanel+ selection={{ ...selection, durable: { threadId: 'child-thread', taskId } }}+ />+ </Root>+ );+ const view = render(tree('task'));+ const composer = screen.getByLabelText('Main chat draft');+ composer.focus();+ view.rerender(tree('next-task'));+ expect(composer).toHaveFocus();+ });++ it('only navigates to the parent chat when explicitly requested', () => {+ mockUseSubagentThreadQuery.mockReturnValue({+ data: completedView,+ isLoading: false,+ isError: false,+ isReadinessPending: false,+ });+ render(+ <Root>+ <SubagentThreadPanel selection={selection} />+ </Root>,+ );+ expect(screen.getByRole('region', { name: 'com_ui_subagent_thread_panel' })).toHaveFocus();+ expect(mockNavigate).not.toHaveBeenCalled();+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_go_to_parent' }));+ expect(mockNavigate).toHaveBeenCalledWith('/c/parent-conversation');+ });++ it('returns focus to the task disclosure when its originating call is not loaded', async () => {+ mockUseSubagentThreadQuery.mockReturnValue({+ data: completedView,+ isLoading: false,+ isError: false,+ isReadinessPending: false,+ });+ const disclosure = document.createElement('button');+ disclosure.dataset.testid = 'header-background-tasks-button';+ document.body.append(disclosure);+ disclosure.focus();+ try {+ render(+ <Root>+ <SubagentThreadPanel selection={selection} />+ </Root>,+ );+ expect(screen.getByRole('region', { name: 'com_ui_subagent_thread_panel' })).toHaveFocus();+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_close' }));+ await waitFor(() => expect(disclosure).toHaveFocus());+ expect(mockNavigateToConvo).not.toHaveBeenCalled();+ } finally {+ disclosure.remove();+ }+ });++ it.each(['hidden', 'inert', 'aria-hidden', 'disabled'])(+ 'skips an originating trigger blocked by %s when returning focus',+ async (blocked) => {+ mockUseSubagentThreadQuery.mockReturnValue({+ data: completedView,+ isLoading: false,+ isError: false,+ isReadinessPending: false,+ });+ const disclosure = document.createElement('button');+ const group = document.createElement('section');+ const trigger = document.createElement('button');+ trigger.dataset.subagentToolCall = 'tool-call';+ trigger.dataset.subagentParentMessage = 'parent-message';+ trigger.dataset.subagentPartIndex = '2';+ if (blocked === 'disabled') trigger.disabled = true;+ else group.setAttribute(blocked, blocked === 'aria-hidden' ? 'true' : '');+ group.append(trigger);+ document.body.append(disclosure, group);+ disclosure.focus();+ try {+ render(+ <Root>+ <SubagentThreadPanel selection={selection} />+ </Root>,+ );+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_close' }));+ await waitFor(() => expect(disclosure).toHaveFocus());+ } finally {+ disclosure.remove();+ group.remove();+ }+ },+ );+it('renders a bounded read-only activity timeline and closes its selection', async () => {mockUseSubagentThreadQuery.mockReturnValue({data: completedView,diff --git a/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx b/client/src/components/Chat/Subagents/SubagentThreadPanel.tsxindex 89aa688573..414b73aa99 100644--- a/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx+++ b/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx@@ -1,8 +1,9 @@import { useCallback, useEffect, useMemo, useRef, useState } from 'react';import { v4 } from 'uuid';-import { useAtom, useSetAtom, useStore } from 'jotai';-import { Clock, OctagonPause, X, Zap } from 'lucide-react';+import { useNavigate } from 'react-router-dom';import { dataService, ForkOptions } from 'librechat-data-provider';+import { useAtom, useAtomValue, useSetAtom, useStore } from 'jotai';+import { ArrowUpRight, Clock, OctagonPause, X, Zap } from 'lucide-react';import {Alert,Button,@@ -37,6 +38,14 @@ import {mergeChildConversationTurns,retainBoundedMovingWindowTurns,} from './adapters';+import {+ activeSubagentPanel,+ subagentPanelFocusRequest,+ subagentControlStateByTask,+ subagentControlStateKey,+ subagentProgressKey,+ useSubagentProgress,+} from './state';import {agentAuthor,resolveSubagentAuthor,@@ -45,13 +54,6 @@ import {readableSubagentType,useParentAuthor,} from './author';-import {- activeSubagentPanel,- subagentControlStateByTask,- subagentControlStateKey,- subagentProgressKey,- useSubagentProgress,-} from './state';import useSubagentActivityStream from '~/data-provider/Subagents/useSubagentActivityStream';import SubagentActivity, { SubagentActivityScrollSurface } from './SubagentActivity';import ApprovalProvider from '~/components/Chat/Messages/Content/ApprovalContext';@@ -127,9 +129,12 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSuconst clearsFooter = useConfiguredFooter();const localize = useLocalize();const panelStore = useStore();+ const focusRequest = useAtomValue(subagentPanelFocusRequest);const { showToast } = useToastContext();const { navigateToConvo } = useNavigateToConvo();+ const navigate = useNavigate();const panelRef = useRef<HTMLDivElement>(null);+ const returnFocusRef = useRef<HTMLElement | null>(null);const isMobile = useScaledMaxWidth(ARTIFACTS_SHEET_MAX_WIDTH);/** Two reasons the send control's action list cannot be used where it hangs.* Without hover, a tap on its anchor submits instead of opening it. And@@ -775,24 +780,51 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSuconst close = useCallback(() => {resetSelection();requestAnimationFrame(() => {+ const available = (element: HTMLElement | null | undefined) =>+ element != null &&+ element.isConnected &&+ !element.matches(':disabled, [aria-disabled="true"]') &&+ element.closest('[hidden], [inert], [aria-hidden="true"]') == null;const trigger = Array.from(document.querySelectorAll<HTMLElement>('[data-subagent-tool-call]'),).find((element) =>element.dataset.subagentToolCall === selection.toolCallId &&element.dataset.subagentParentMessage === selection.parentMessageId &&- element.dataset.subagentPartIndex === String(selection.partIndex),+ element.dataset.subagentPartIndex === String(selection.partIndex) &&+ available(element),+ );+ const disclosure = document.querySelector<HTMLElement>(+ '[data-testid="header-background-tasks-button"]',);- trigger?.focus();+ const destination =+ (available(returnFocusRef.current) ? returnFocusRef.current : null) ??+ trigger ??+ (available(disclosure) ? disclosure : null);+ destination?.focus({ preventScroll: true });});}, [resetSelection, selection.parentMessageId, selection.partIndex, selection.toolCallId]);+ useEffect(() => {+ const activeElement = document.activeElement;+ if (+ activeElement instanceof HTMLElement &&+ activeElement !== document.body &&+ !panelRef.current?.contains(activeElement)+ ) {+ returnFocusRef.current = activeElement;+ }+ }, [focusRequest]);+/** Escape is handled on the element rather than through the trap's own* native listener: that listener sits on this `aside`, so it runs BEFORE any* React handler inside it and would close the whole panel out from under a* nested popover that meant to dismiss only itself. As a React handler it* bubbles in DOM order, so an inner control can stop it or mark it handled. */useFocusTrap(panelRef, isMobile);+ useEffect(() => {+ if (!isMobile) panelRef.current?.focus({ preventScroll: true });+ }, [focusRequest, isMobile]);const handlePanelKeyDown = useCallback((event: ReactKeyboardEvent<HTMLElement>) => {if (!isMobile || event.key !== 'Escape' || event.defaultPrevented) return;@@ -1528,6 +1560,7 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSureturn (<asideref={panelRef}+ tabIndex={-1}role={isMobile ? 'dialog' : 'region'}aria-modal={isMobile || undefined}aria-label={localize('com_ui_subagent_thread_panel')}@@ -1587,6 +1620,17 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu</h2></>)}+ <Button+ type="button"+ variant="ghost"+ size="icon"+ onClick={() => navigate(`/c/${encodeURIComponent(selection.parentConversationId)}`)}+ aria-label={localize('com_ui_subagent_go_to_parent')}+ title={localize('com_ui_subagent_go_to_parent')}+ className="h-8 w-8 shrink-0"+ >+ <ArrowUpRight className="size-[1.0625rem]" aria-hidden="true" />+ </Button><Buttontype="button"variant="ghost"diff --git a/client/src/components/Chat/Subagents/state.spec.ts b/client/src/components/Chat/Subagents/state.spec.tsindex 4a54563c8e..2296be9a61 100644--- a/client/src/components/Chat/Subagents/state.spec.ts+++ b/client/src/components/Chat/Subagents/state.spec.ts@@ -465,6 +465,32 @@ describe('useSubagentProgress', () => {expect(subagentProgressByToolCallId(key)).not.toBe(held);});+ it('keeps retained readers and stream writers together after navigation', () => {+ const key = subagentProgressKey('retained-message', 'retained-call', 0);+ const store = createStore();+ const wrapper = ({ children }: { children: React.ReactNode }) =>+ React.createElement(JotaiProvider, { store }, children);+ const { result, unmount } = renderHook(() => useSubagentProgress(key), { wrapper });+ const held = subagentProgressByToolCallId(key);+ const streamOpen = subagentParentStreamOpenByToolCallId(key);+ registerSubagentProgressKey(key);+ act(() => {+ for (const drained of takeRegisteredSubagentProgressKeys()) {+ store.set(subagentProgressByToolCallId(drained), null);+ store.set(subagentParentStreamOpenByToolCallId(drained), false);+ removeSubagentProgressAtoms(drained);+ }+ });+ expect(subagentProgressByToolCallId(key)).toBe(held);+ expect(subagentParentStreamOpenByToolCallId(key)).toBe(streamOpen);+ act(() => store.set(held, reduceSubagentProgress(null, [update()])));+ expect(result.current?.contentParts).toEqual([{ type: ContentTypes.TEXT, text: 'Working.' }]);+ act(() => store.set(held, null));+ unmount();+ expect(subagentProgressByToolCallId(key)).not.toBe(held);+ expect(subagentParentStreamOpenByToolCallId(key)).not.toBe(streamOpen);+ });+/** The drain owns a streaming key; freeing it here would race that boundary. */it('leaves a key the stream registered to the drain', () => {const key = subagentProgressKey('live-message', 'live-call', 0);diff --git a/client/src/components/Chat/Subagents/state.ts b/client/src/components/Chat/Subagents/state.tsindex 7f648e067b..32408157c7 100644--- a/client/src/components/Chat/Subagents/state.ts+++ b/client/src/components/Chat/Subagents/state.ts@@ -327,6 +327,7 @@ export type ActiveSubagentPanel = {};export const activeSubagentPanel = atom<ActiveSubagentPanel | null>(null);+export const subagentPanelFocusRequest = atom(0);export type SubagentControlUiReceipt = Omit<SubagentControlReceipt, 'status'> & {status: SubagentControlReceipt['status'] | 'submitted';@@ -506,15 +507,9 @@ export function listRegisteredSubagentProgressKeys(): string[] {return [...registeredSubagentProgressKeys];}-/**- * Frees the family members held for one invocation. An `atomFamily` caches a- * member per key for the life of the tab, and every invocation key is unique,- * so the drain boundary has to release them or a long session accumulates two- * atom configurations per subagent call it ever saw. Callers clear the values- * first: `remove` drops the cached member without telling anything subscribed- * to it.- */+/** Frees idle invocation members; mounted readers retain their stream identity. */export function removeSubagentProgressAtoms(invocationKey: string): void {+ if (subagentProgressReaders.has(invocationKey)) return;subagentProgressByToolCallId.remove(invocationKey);subagentParentStreamOpenByToolCallId.remove(invocationKey);}diff --git a/client/src/components/Chat/Subagents/surface.tsx b/client/src/components/Chat/Subagents/surface.tsxindex 0e34d682ee..4bfddabd54 100644--- a/client/src/components/Chat/Subagents/surface.tsx+++ b/client/src/components/Chat/Subagents/surface.tsx@@ -3,7 +3,7 @@ import { useSetAtom } from 'jotai';import type { ReactNode } from 'react';import type { ComposerBindings } from '~/hooks/Input/useComposerBindings';import type { ActiveSubagentPanel } from './state';-import { activeSubagentPanel } from './state';+import { activeSubagentPanel, subagentPanelFocusRequest } from './state';/*** Everything this feature needs from the application hosting it, and nothing@@ -64,11 +64,13 @@ export function useOptionalChatSurface(): ChatSurface | null {export function useOpenSubagentPanel(): ((selection: ActiveSubagentPanel) => void) | null {const claimForeground = useOptionalChatSurface()?.claimForeground;const setSelection = useSetAtom(activeSubagentPanel);+ const requestFocus = useSetAtom(subagentPanelFocusRequest);return useMemo(() => {if (claimForeground == null) return null;return (selection: ActiveSubagentPanel) => {claimForeground();setSelection(selection);+ requestFocus((current) => current + 1);};- }, [claimForeground, setSelection]);+ }, [claimForeground, requestFocus, setSelection]);}diff --git a/client/src/hooks/SSE/__tests__/useEventHandlers.cancel.spec.tsx b/client/src/hooks/SSE/__tests__/useEventHandlers.cancel.spec.tsxindex ffa573bf45..6c9099f4df 100644--- a/client/src/hooks/SSE/__tests__/useEventHandlers.cancel.spec.tsx+++ b/client/src/hooks/SSE/__tests__/useEventHandlers.cancel.spec.tsx@@ -8,6 +8,10 @@ import type { ReactNode } from 'react';import { useIsReplacingConversationCodeEnvironment } from '~/data-provider/CodeEnvironments';import useEventHandlers from '../useEventHandlers';+let mockConversationId = 'saved';+const mockResetSubagentAtoms = jest.fn();+const mockResetPtcAtoms = jest.fn();+jest.mock('librechat-data-provider', () => {const actual = jest.requireActual('librechat-data-provider');return { ...actual, dataService: { ...actual.dataService, getConversationById: jest.fn() } };@@ -17,7 +21,7 @@ jest.mock('recoil', () => ({useRecoilCallback: () => jest.fn(),}));jest.mock('react-router-dom', () => ({- useParams: () => ({ conversationId: 'saved' }),+ useParams: () => ({ conversationId: mockConversationId }),useNavigate: () => jest.fn(),useLocation: () => ({ pathname: '/c/saved' }),}));@@ -37,8 +41,8 @@ jest.mock('../useAttachmentHandler', () => () => jest.fn());jest.mock('../useStepHandler', () => () => ({stepHandler: jest.fn(),clearStepMaps: jest.fn(),- resetSubagentAtoms: jest.fn(),- resetPtcAtoms: jest.fn(),+ resetSubagentAtoms: mockResetSubagentAtoms,+ resetPtcAtoms: mockResetPtcAtoms,prunePtcTraces: jest.fn(),syncStepMessage: jest.fn(),cancelPendingDeltaFlush: jest.fn(),@@ -102,9 +106,45 @@ const submission = {} as EventSubmission;describe('local cancellation decision reconciliation', () => {- beforeEach(() => jest.clearAllMocks());+ beforeEach(() => {+ jest.clearAllMocks();+ mockConversationId = 'saved';+ });afterEach(() => jest.restoreAllMocks());+ it('preserves the selected task only for navigation, not host teardown', () => {+ const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });+ const wrapper = ({ children }: { children: ReactNode }) =>+ createElement(+ Provider,+ null,+ createElement(QueryClientProvider, { client: queryClient }, children),+ );+ const { rerender, unmount } = renderHook(+ () =>+ useEventHandlers({+ getMessages: () => [],+ setMessages: jest.fn(),+ setCompleted: jest.fn(),+ setConversation: jest.fn(),+ setIsSubmitting: jest.fn(),+ setShowStopButton: jest.fn(),+ newConversation: jest.fn(),+ }),+ { wrapper },+ );+ expect(mockResetSubagentAtoms).not.toHaveBeenCalled();+ mockConversationId = 'other';+ rerender();+ expect(mockResetSubagentAtoms).toHaveBeenCalledTimes(1);+ expect(mockResetSubagentAtoms).toHaveBeenCalledWith({ preserveSelectedTask: true });+ expect(mockResetPtcAtoms).toHaveBeenCalledTimes(1);+ unmount();+ expect(mockResetSubagentAtoms).toHaveBeenCalledTimes(2);+ expect(mockResetSubagentAtoms).toHaveBeenLastCalledWith();+ expect(mockResetPtcAtoms).toHaveBeenCalledTimes(2);+ });+it.each(['streamed', 'minimal', 'navigated'])('does not use a synthetic %s cancel as evidence that the server settled',async (kind) => {diff --git a/client/src/hooks/SSE/__tests__/useStepHandler.spec.ts b/client/src/hooks/SSE/__tests__/useStepHandler.spec.tsindex c31ef1b3c1..9f6671d424 100644--- a/client/src/hooks/SSE/__tests__/useStepHandler.spec.ts+++ b/client/src/hooks/SSE/__tests__/useStepHandler.spec.ts@@ -20,8 +20,14 @@ import type {PtcToolCallEvent,Agents,} from 'librechat-data-provider';+import type { ActiveSubagentPanel } from '~/components/Chat/Subagents/state';import type { PtcTrace, PtcTraceEntry } from '~/common';import {+ activeSubagentPanel,+ listRegisteredSubagentProgressKeys,+ reduceSubagentProgress,+ registerSubagentProgressKey,+ subagentParentStreamOpenByToolCallId,subagentProgressByToolCallId,subagentProgressKey,} from '~/components/Chat/Subagents/state';@@ -3778,6 +3784,98 @@ describe('useStepHandler', () => {expect(subagentProgressByToolCallId(invocationKey)).not.toBe(held);});+ it.each(['tool', 'event'] as const)(+ 'keeps retained %s activity through navigation and releases it on host teardown',+ (origin) => {+ const { result } = renderHook(+ () => ({ ...useStepHandler(createHookParams()), store: useStore() }),+ { wrapper: subagentStoreWrapper },+ );+ const selected: ActiveSubagentPanel = {+ host: 'conversation',+ parentConversationId: 'conv-1',+ parentMessageId: 'response-msg-1',+ toolCallId: 'call_A',+ partIndex: 0,+ subagentType: 'self',+ initialProgress: 0,+ isSubmitting: false,+ durable: { threadId: 'child-thread', taskId: 'task' },+ ...(origin === 'event'+ ? { event: { actorId: 'actor', progressKey: 'event-task:child-thread:task' } }+ : {}),+ };+ const key = subagentProgressKey(+ selected.parentMessageId,+ selected.event?.progressKey ?? selected.toolCallId,+ selected.partIndex,+ );+ const otherKey = subagentProgressKey('other-message', 'call_B', 1);+ const store = result.current.store;+ const held = subagentProgressByToolCallId(key);+ const earlier = makeUpdate({+ phase: 'message_delta',+ activityEventId: 'earlier',+ activitySequence: 0,+ data: { delta: { content: [{ type: ContentTypes.TEXT, text: 'Earlier work.' }] } },+ });+ const tool = makeUpdate({+ phase: 'run_step',+ activityEventId: 'tool',+ activitySequence: 1,+ data: {+ stepDetails: {+ type: 'tool_calls',+ tool_calls: [{ id: 'inner-call', name: 'calculator', args: '{"value":4}' }],+ },+ },+ });+ act(() => {+ store.set(activeSubagentPanel, selected);+ registerSubagentProgressKey(key);+ registerSubagentProgressKey(otherKey);+ store.set(held, reduceSubagentProgress(null, [earlier, tool], 'parent', true));+ store.set(+ subagentProgressByToolCallId(otherKey),+ reduceSubagentProgress(null, [earlier]),+ );+ store.set(subagentParentStreamOpenByToolCallId(key), true);+ });+ const before = store.get(held)?.contentParts;+ act(() => result.current.resetSubagentAtoms({ preserveSelectedTask: true }));+ expect(store.get(held)?.contentParts).toEqual(before);+ expect(subagentProgressByToolCallId(key)).toBe(held);+ expect(store.get(subagentParentStreamOpenByToolCallId(key))).toBe(false);+ expect(listRegisteredSubagentProgressKeys()).toEqual([key]);+ expect(store.get(subagentProgressByToolCallId(otherKey))).toBeNull();+ act(() => {+ store.set(held, (progress) =>+ reduceSubagentProgress(+ progress,+ [+ makeUpdate({+ phase: 'message_delta',+ activityEventId: 'later',+ activitySequence: 2,+ data: { delta: { content: [{ type: ContentTypes.TEXT, text: 'Later work.' }] } },+ }),+ ],+ 'detached',+ false,+ ),+ );+ });+ expect(store.get(held)?.contentParts).toEqual([+ ...(before ?? []),+ { type: ContentTypes.TEXT, text: 'Later work.' },+ ]);+ act(() => result.current.resetSubagentAtoms());+ expect(store.get(held)).toBeNull();+ expect(subagentProgressByToolCallId(key)).not.toBe(held);+ expect(listRegisteredSubagentProgressKeys()).toEqual([]);+ },+ );+it('falls back to oldest-unclaimed tool call when parentToolCallId is absent', () => {const { result, getProgress } = renderStepHandlerWithReader();/** Two subagent tool calls seeded in creation order. Withoutdiff --git a/client/src/hooks/SSE/useEventHandlers.ts b/client/src/hooks/SSE/useEventHandlers.tsindex b5d1aa6f42..0b905a0c8c 100644--- a/client/src/hooks/SSE/useEventHandlers.ts+++ b/client/src/hooks/SSE/useEventHandlers.ts@@ -549,7 +549,7 @@ export default function useEventHandlers({if (shouldResetSubagentAtomsOnConversationChange(previous, paramId, preserveNewConversationId)) {- resetSubagentAtoms();+ resetSubagentAtoms({ preserveSelectedTask: true });/** PTC traces are live-only for the same reason and share the boundary:* keep them through a run so a finished program stays auditable, drop* them when the conversation changes. */diff --git a/client/src/hooks/SSE/useStepHandler.ts b/client/src/hooks/SSE/useStepHandler.tsindex ba0c5fe583..917ac47b96 100644--- a/client/src/hooks/SSE/useStepHandler.ts+++ b/client/src/hooks/SSE/useStepHandler.ts@@ -8,6 +8,7 @@ import {resetStreamState,syncStreamMessage,createStreamState,+ subagentProgressKey,} from '@librechat/chat';import type {TMessage,@@ -18,6 +19,7 @@ import type {import type { StepEvent, StepEffect, StepContext, StreamState } from '@librechat/chat';import type { AnnounceOptions } from '~/common';import {+ activeSubagentPanel,closeParentSubagentProgress,listRegisteredSubagentProgressKeys,reduceSubagentProgress,@@ -86,27 +88,34 @@ export default function useStepHandler({[subagentStore],);- /**- * Resets all accumulated subagent state. Kept for conversation-switch- * cleanup (see top-level hook usage) but NOT called from `clearStepMaps`:- * the collapsed SubagentCall ticker and its panel read from these atoms to- * render the child's content parts, and we want that history to remain- * visible after the stream ends so the user can reopen the panel for- * auditability. The atoms are bounded by aggregated structure and- * per-conversation (one atom per subagent spawn), so growth is proportional- * to messages: the same growth profile as the rest of the conversation- * state.- */- const resetSubagentAtoms = useCallback((): void => {- for (const invocationKey of takeRegisteredSubagentProgressKeys()) {- /** Clear before freeing: `remove` drops the cached family member but- * tells nothing still subscribed to it, so anything mounted at this- * boundary has to see the empty value first. */- subagentStore.set(subagentProgressByToolCallId(invocationKey), null);- subagentStore.set(subagentParentStreamOpenByToolCallId(invocationKey), false);- removeSubagentProgressAtoms(invocationKey);- }- }, [subagentStore]);+ /** Navigation retains the selected durable task; host teardown drains every invocation. */+ const resetSubagentAtoms = useCallback(+ ({ preserveSelectedTask = false }: { preserveSelectedTask?: boolean } = {}): void => {+ const selected = preserveSelectedTask ? subagentStore.get(activeSubagentPanel) : null;+ const retainedKey =+ selected?.host === 'conversation' && selected.durable != null+ ? subagentProgressKey(+ selected.parentMessageId,+ selected.event?.progressKey ?? selected.toolCallId,+ selected.partIndex,+ )+ : null;+ for (const invocationKey of takeRegisteredSubagentProgressKeys()) {+ subagentStore.set(subagentParentStreamOpenByToolCallId(invocationKey), false);+ if (invocationKey === retainedKey) {+ registerSubagentProgressKey(invocationKey);+ subagentStore.set(+ subagentProgressByToolCallId(invocationKey),+ closeParentSubagentProgress,+ );+ continue;+ }+ subagentStore.set(subagentProgressByToolCallId(invocationKey), null);+ removeSubagentProgressAtoms(invocationKey);+ }+ },+ [subagentStore],+ );const closeParentSubagentStreams = useCallback((): void => {for (const invocationKey of listRegisteredSubagentProgressKeys()) {diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.jsonindex 0826cd7331..0e3f3e8346 100644--- a/client/src/locales/en/translation.json+++ b/client/src/locales/en/translation.json@@ -46,6 +46,8 @@"com_ui_attachments": "Attachments","com_ui_no_schedules_match": "No schedules match your search","com_ui_background_tasks_go_to_tool": "Take me to that tool",+ "com_ui_background_tasks_open_subagent": "Open subagent",+ "com_ui_background_tasks_subagent_unavailable": "This subagent task is unavailable. Refresh the task list and try again.","com_ui_background_tasks_tool_unavailable": "This tool is not in the loaded messages. Load earlier messages to find it.","com_ui_background_tasks": "Background tasks","com_ui_background_tasks_cancel_disabled": "Stopping background tools is not enabled on this server",@@ -3145,6 +3147,7 @@"com_ui_storage": "Storage","com_ui_storage_filter_sort": "Filter and Sort by Storage","com_ui_subagent_back_to_parent": "Back to parent chat",+ "com_ui_subagent_go_to_parent": "Go to parent chat","com_ui_subagent_activity": "Agent activity","com_ui_subagent_progress": "Progress","com_ui_subagent_progress_counts": "Turns {{0}} · Tool calls {{1}} · Failed {{2}}",diff --git a/e2e/specs/mock/scenarios/unseen-replies.spec.ts b/e2e/specs/mock/scenarios/unseen-replies.spec.tsindex 366d676686..25cfea4c7b 100644--- a/e2e/specs/mock/scenarios/unseen-replies.spec.ts+++ b/e2e/specs/mock/scenarios/unseen-replies.spec.ts@@ -491,6 +491,7 @@ test.describe('unseen replies', () => {const id = conversationId();const title = `Withheld reply ${id.slice(0, 8)}`;const replyAt = new Date(Date.now() - 2_000);+ let completedReplyAt: Date;await page.addInitScript(() => {const constructions: string[] = [];const calls: string[] = [];@@ -506,8 +507,8 @@ test.describe('unseen replies', () => {}close() {}onclick: (() => void) | null = null;- constructor() {- constructions.push('notification');+ constructor(_title: string, options?: NotificationOptions) {+ constructions.push(options?.tag ?? '');}}Object.defineProperty(window, 'Notification', {@@ -569,11 +570,19 @@ test.describe('unseen replies', () => {await second.bringToFront();await unfocus(page);await sendMessageAndWaitForCompletion(second, `E2E_REPLY:withheld-${id.slice(0, 8)}`);- await restoreUnreadBaseline(id, now(), replyAt);+ const completed = await readConversation(id);+ if (completed?.lastResponseAt == null) throw new Error('Reply timestamp was not saved');+ completedReplyAt = new Date(completed.lastResponseAt);+ await restoreUnreadBaseline(id, completedReplyAt, replyAt);} finally {await second.evaluate(() => window.dispatchEvent(new Event('blur'))).catch(() => {});await second.close();}+ /* The reply tab may collapse the shared sidebar; observe the arrival before granting. */+ await openSidebar(page);+ await expect(row.locator('span[aria-hidden="true"].bg-status-info')).toBeVisible({+ timeout: 45_000,+ });await expect.poll(() =>page.evaluate(@@ -589,23 +598,19 @@ test.describe('unseen replies', () => {window as Window & { __grantNotificationPermission: () => void }).__grantNotificationPermission();});- await restoreUnreadBaseline(id, now(), replyAt);- /* `sidebarExpanded` is stored per browser, so the reply tab's own mobile shell closed this- list while it was open. Looking at the list again is what a reader does, and it is where- the dot has to show. */- await openSidebar(page);- await expect(row.locator('span[aria-hidden="true"].bg-status-info')).toBeVisible({- timeout: 45_000,- });+ await restoreUnreadBaseline(id, completedReplyAt, replyAt);+ /* Other scenarios leave unseen history for this user; only this reply must notify once. */await expect.poll(() =>page.evaluate(- () =>- (window as Window & { __notificationConstructions: string[] })- .__notificationConstructions,+ (conversationId) =>+ (+ window as Window & { __notificationConstructions: string[] }+ ).__notificationConstructions.filter((tag) => tag === conversationId),+ id,),)- .toEqual(['notification']);+ .toEqual([id]);} finally {await cleanup(id);}