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: Reveal Subagent Thread History and Event Detail on Demand (#15283)

Danny Avila41ba808e6fc6
diff --git a/api/app/clients/BaseClient.js b/api/app/clients/BaseClient.js
index 839a135aed..65b85d5971 100644
--- a/api/app/clients/BaseClient.js
+++ b/api/app/clients/BaseClient.js
@@ -490,6 +490,9 @@ class BaseClient {
sender: 'User',
text,
isCreatedByUser: true,
+ ...(this.options?.req?._agentEventTriggerProjection != null && {
+ subagentTriggerProjection: this.options.req._agentEventTriggerProjection,
+ }),
};
}
diff --git a/api/app/clients/specs/BaseClient.test.js b/api/app/clients/specs/BaseClient.test.js
index 3f4baa8528..139e9e9518 100644
--- a/api/app/clients/specs/BaseClient.test.js
+++ b/api/app/clients/specs/BaseClient.test.js
@@ -101,6 +101,26 @@ describe('BaseClient', () => {
});
});
+ test('persists only the host-authored external event display projection on the user turn', () => {
+ const projection = {
+ version: 1,
+ eventType: 'chess.turn.ready',
+ sourceType: 'speed-chess',
+ occurredAt: new Date('2026-08-21T12:00:00.000Z'),
+ expectedActionToolName: 'submit_move',
+ };
+ TestClient.options.req = { _agentEventTriggerProjection: projection };
+
+ expect(
+ TestClient.createUserMessage({
+ messageId: 'event:user',
+ parentMessageId: 'parent',
+ conversationId: 'event-thread',
+ text: 'Private event payload',
+ }),
+ ).toEqual(expect.objectContaining({ subagentTriggerProjection: projection }));
+ });
+
test('returns the input messages without instructions when addInstructions() is called with empty instructions', () => {
const messages = [{ content: 'Hello' }, { content: 'How are you?' }, { content: 'Goodbye' }];
const instructions = '';
diff --git a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
index 4c9b309263..f29d0427f9 100644
--- a/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
+++ b/api/server/controllers/agents/__tests__/request.resumeMetadata.spec.js
@@ -4021,9 +4021,9 @@ describe('ResumableAgentController resume metadata', () => {
});
const event = {
id: 'game-1:ply-8',
- type: 'chess.turn',
+ type: 'chess.\u202Eturn',
occurredAt: Date.now(),
- source: { id: 'speed-chess', type: 'mcp' },
+ source: { id: 'speed-chess', type: 'm\u2066cp' },
payload: { gameId: 'game-1', expectedPly: 8 },
};
const req = {
@@ -4037,7 +4037,7 @@ describe('ResumableAgentController resume metadata', () => {
deliveryKey: 'req-event-fork',
target: { bindingId: 'binding-1' },
event,
- expectedAction: { toolName: 'submit_move', argumentSubset: { expectedPly: 8 } },
+ expectedAction: { toolName: 'submit_\u200Fmove', argumentSubset: { expectedPly: 8 } },
},
},
config: {
@@ -4064,7 +4064,7 @@ describe('ResumableAgentController resume metadata', () => {
conversationId: 'child-conversation',
invocationId: 'req-event-fork',
event,
- expectedAction: { toolName: 'submit_move', argumentSubset: { expectedPly: 8 } },
+ expectedAction: { toolName: 'submit_\u200Fmove', argumentSubset: { expectedPly: 8 } },
}),
{
getSnapshot: expect.any(Function),
@@ -4079,6 +4079,13 @@ describe('ResumableAgentController resume metadata', () => {
},
);
expect(mockExecuteAgentEventActor.mock.calls[0][0]).not.toHaveProperty('tenantId');
+ expect(req._agentEventTriggerProjection).toEqual({
+ version: 1,
+ eventType: 'chess. turn',
+ sourceType: 'm cp',
+ occurredAt: new Date(event.occurredAt),
+ expectedActionToolName: 'submit_ move',
+ });
expect(client).toMatchObject({
checkpointNamespace: 'event-actor/fork',
eventActorCheckpointId: 'checkpoint-base',
diff --git a/api/server/controllers/agents/request.js b/api/server/controllers/agents/request.js
index e20087d6ea..f612ef57a6 100644
--- a/api/server/controllers/agents/request.js
+++ b/api/server/controllers/agents/request.js
@@ -140,6 +140,7 @@ function getPreliminaryResponseMessageId({ messageId, responseMessageId }) {
function getPreliminaryUserMessage(
{ messageId, parentMessageId, text, quotes, files, manualSkills, alwaysAppliedSkills },
conversationId,
+ subagentTriggerProjection,
) {
if (typeof messageId !== 'string' || messageId.length === 0) {
return null;
@@ -170,6 +171,36 @@ function getPreliminaryUserMessage(
...(Array.isArray(manualSkills) && manualSkills.length > 0 && { manualSkills }),
...(Array.isArray(alwaysAppliedSkills) &&
alwaysAppliedSkills.length > 0 && { alwaysAppliedSkills }),
+ ...(subagentTriggerProjection != null && { subagentTriggerProjection }),
+ };
+}
+
+const DISPLAY_IDENTITY_CONTROLS = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]+/gu;
+
+function sanitizeEventDisplayIdentity(value) {
+ if (typeof value !== 'string') return undefined;
+ const bounded = Array.from(value).slice(0, 512).join('');
+ const sanitized = bounded.normalize('NFC').replace(DISPLAY_IDENTITY_CONTROLS, ' ').trim();
+ return sanitized.length === 0 ? undefined : Array.from(sanitized).slice(0, 256).join('');
+}
+
+function getAgentEventTriggerProjection(agentEventDelivery) {
+ const event = agentEventDelivery?.event;
+ const occurredAt = new Date(event?.occurredAt);
+ const eventType = sanitizeEventDisplayIdentity(event?.type);
+ const sourceType = sanitizeEventDisplayIdentity(event?.source?.type);
+ if (eventType == null || sourceType == null || Number.isNaN(occurredAt.getTime())) {
+ return undefined;
+ }
+ const expectedActionToolName = sanitizeEventDisplayIdentity(
+ agentEventDelivery?.expectedAction?.toolName,
+ );
+ return {
+ version: 1,
+ eventType,
+ sourceType,
+ occurredAt,
+ ...(expectedActionToolName == null ? {} : { expectedActionToolName }),
};
}
@@ -271,7 +302,7 @@ async function saveErrorTurn(
alwaysAppliedSkills: req.body.alwaysAppliedSkills,
}),
}
- : getPreliminaryUserMessage(req.body, conversationId);
+ : getPreliminaryUserMessage(req.body, conversationId, req._agentEventTriggerProjection);
if (!userMessage) {
return;
}
@@ -1271,6 +1302,7 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
rawAgentEventDelivery.deliveryKey === clientRequestId
? rawAgentEventDelivery
: undefined;
+ req._agentEventTriggerProjection = getAgentEventTriggerProjection(agentEventDelivery);
try {
logger.debug(`[ResumableAgentController] Creating job`, {
@@ -1285,6 +1317,7 @@ const ResumableAgentController = async (req, res, next, initializeClient, addTit
const preliminaryUserMessage = getPreliminaryUserMessage(
{ ...req.body, messageId: preallocatedUserMessageId },
conversationId,
+ req._agentEventTriggerProjection,
);
const job = await GenerationJobManager.createJob(streamId, userId, conversationId, {
startupTelemetry,
diff --git a/client/src/components/Chat/Subagents/SubagentActivity.test.tsx b/client/src/components/Chat/Subagents/SubagentActivity.test.tsx
index 98e0af9671..7ab4a52815 100644
--- a/client/src/components/Chat/Subagents/SubagentActivity.test.tsx
+++ b/client/src/components/Chat/Subagents/SubagentActivity.test.tsx
@@ -208,7 +208,7 @@ const base: ChildActivity = {
};
describe('SubagentActivity', () => {
- it.each(['running', 'completed', 'failed', 'cancelled'] as const)(
+ it.each(['running', 'failed', 'cancelled'] as const)(
'renders the %s lifecycle through the shared view',
(status) => {
render(<SubagentActivity activity={{ ...base, status }} />);
@@ -216,6 +216,12 @@ describe('SubagentActivity', () => {
},
);
+ it('does not repeat the completed lifecycle in the conversation body', () => {
+ render(<SubagentActivity activity={base} />);
+
+ expect(screen.queryByText('com_ui_subagent_thread_status_completed')).not.toBeInTheDocument();
+ });
+
it('reports when the durable control history is bounded', () => {
render(<SubagentActivity activity={{ ...base, controlsTruncated: true }} />);
diff --git a/client/src/components/Chat/Subagents/SubagentActivity.tsx b/client/src/components/Chat/Subagents/SubagentActivity.tsx
index 832565fffd..350eda3536 100644
--- a/client/src/components/Chat/Subagents/SubagentActivity.tsx
+++ b/client/src/components/Chat/Subagents/SubagentActivity.tsx
@@ -357,11 +357,6 @@ export function SubagentActivityContent({
{localize('com_ui_subagent_control_history_truncated')}
</div>
)}
- {activity.activityTruncated === true && (
- <div className="mb-3 text-xs italic text-text-secondary">
- {localize('com_ui_subagent_thread_history_truncated')}
- </div>
- )}
{showDetailTruncationNotice && activityDetailsTruncated && (
<div className="mb-3 text-xs italic text-text-secondary">
{localize('com_ui_subagent_activity_details_truncated')}
@@ -406,11 +401,12 @@ export default function SubagentActivity({
showPrompt?: boolean;
onCancelControl?: (controlId: string) => void;
}) {
- const statusHeader = (
- <div className="shrink-0 border-b border-border-light px-4 py-2">
- <SubagentStatus activity={activity} />
- </div>
- );
+ const statusHeader =
+ activity.status === 'completed' ? null : (
+ <div className="shrink-0 border-b border-border-light px-4 py-2">
+ <SubagentStatus activity={activity} />
+ </div>
+ );
const content = (
<SubagentActivityContent
activity={activity}
diff --git a/client/src/components/Chat/Subagents/SubagentConversation.test.tsx b/client/src/components/Chat/Subagents/SubagentConversation.test.tsx
index c513f91c54..c2a49c2bff 100644
--- a/client/src/components/Chat/Subagents/SubagentConversation.test.tsx
+++ b/client/src/components/Chat/Subagents/SubagentConversation.test.tsx
@@ -1,6 +1,6 @@
import React from 'react';
import { RecoilRoot } from 'recoil';
-import { render, screen } from '@testing-library/react';
+import { fireEvent, render, screen } from '@testing-library/react';
import type { ChildConversationTurn } from './adapters';
import SubagentConversation from './SubagentConversation';
@@ -48,6 +48,7 @@ jest.mock('lucide-react', () => ({
Bot: () => null,
CheckCircle2: () => null,
Clock3: () => null,
+ ChevronDown: () => null,
CornerDownRight: () => null,
Radio: () => null,
XCircle: () => null,
@@ -81,7 +82,13 @@ const turns: ChildConversationTurn[] = [
taskId: 'task-2',
trigger: {
kind: 'external_event',
- summary: 'A deployment event arrived.',
+ summary: '',
+ externalEvent: {
+ eventType: 'chess.turn.ready',
+ sourceType: 'speed-chess',
+ occurredAt: '2026-08-25T12:01:00.000Z',
+ expectedActionToolName: 'submit_move',
+ },
},
activity: {
title: 'Research child',
@@ -100,7 +107,7 @@ describe('SubagentConversation', () => {
);
expect(screen.getAllByText('com_ui_subagent_trigger_parent_dispatch')).toHaveLength(2);
- expect(screen.getAllByText('com_ui_subagent_trigger_external_event')).toHaveLength(2);
+ expect(screen.getAllByText('com_ui_subagent_trigger_external_event')).toHaveLength(1);
expect(screen.getByText('Investigate the release.')).toBeInTheDocument();
expect(screen.getByText('Checked the constraints.')).toBeInTheDocument();
expect(screen.getByText('search')).toBeInTheDocument();
@@ -108,11 +115,71 @@ describe('SubagentConversation', () => {
expect(screen.queryByText('com_ui_subagent_thread_status_completed')).not.toBeInTheDocument();
expect(screen.getByText('com_ui_subagent_thread_status_running')).toBeInTheDocument();
expect(screen.getByTestId('thinking-cursor')).toBeInTheDocument();
- expect(container.querySelectorAll('.message-render')).toHaveLength(4);
- expect(container.querySelectorAll('.user-turn')).toHaveLength(2);
+ expect(container.querySelectorAll('.message-render')).toHaveLength(3);
+ expect(container.querySelectorAll('.user-turn')).toHaveLength(1);
expect(container.querySelectorAll('.agent-turn')).toHaveLength(2);
expect(container.querySelector('[data-subagent-conversation]')).toBeInTheDocument();
expect(screen.queryByText('com_ui_prompt')).not.toBeInTheDocument();
- expect(screen.getAllByText('com_ui_subagent_activity_details_truncated')).toHaveLength(1);
+ expect(
+ screen.queryByText('com_ui_subagent_activity_details_truncated'),
+ ).not.toBeInTheDocument();
+ expect(screen.getByText('com_ui_subagent_activity_details_unavailable')).toBeInTheDocument();
+
+ fireEvent.click(
+ screen.getByRole('button', {
+ name: /com_ui_subagent_trigger_external_event.*chess\.turn\.ready.*speed-chess/,
+ }),
+ );
+ expect(screen.getByText('chess.turn.ready')).toBeInTheDocument();
+ expect(screen.getByText('speed-chess')).toBeInTheDocument();
+ expect(screen.getByText('submit_move')).toBeInTheDocument();
+ });
+
+ it('requests an exact bounded projection only when shortened turn activity is opened', () => {
+ const loadDetails = jest.fn();
+ const shortened = [
+ { ...turns[0], activity: { ...turns[0].activity, activityTruncated: true } },
+ ];
+ render(
+ <RecoilRoot>
+ <SubagentConversation turns={shortened} onLoadTurnDetails={loadDetails} />
+ </RecoilRoot>,
+ );
+
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_show_full_activity' }));
+ expect(loadDetails).toHaveBeenCalledWith('task-1');
+ });
+
+ it('gives repeated external-event disclosures distinguishable accessible names', () => {
+ const secondEvent: ChildConversationTurn = {
+ ...turns[1],
+ taskId: 'task-3',
+ trigger: {
+ kind: 'external_event',
+ summary: '',
+ externalEvent: {
+ eventType: 'chess.turn.ready',
+ sourceType: 'speed-chess',
+ occurredAt: '2026-08-25T12:02:00.000Z',
+ },
+ },
+ };
+
+ render(
+ <RecoilRoot>
+ <SubagentConversation turns={[turns[1], secondEvent]} />
+ </RecoilRoot>,
+ );
+
+ expect(
+ screen.getByRole('button', {
+ name: /com_ui_subagent_trigger_external_event.*chess\.turn\.ready.*speed-chess.*2026-08-25T12:01:00.000Z/,
+ }),
+ ).toBeInTheDocument();
+ expect(
+ screen.getByRole('button', {
+ name: /com_ui_subagent_trigger_external_event.*chess\.turn\.ready.*speed-chess.*2026-08-25T12:02:00.000Z/,
+ }),
+ ).toBeInTheDocument();
});
});
diff --git a/client/src/components/Chat/Subagents/SubagentConversation.tsx b/client/src/components/Chat/Subagents/SubagentConversation.tsx
index ae2e61914e..cc841d4c66 100644
--- a/client/src/components/Chat/Subagents/SubagentConversation.tsx
+++ b/client/src/components/Chat/Subagents/SubagentConversation.tsx
@@ -1,7 +1,8 @@
-import { useMemo } from 'react';
+import { useMemo, useState } from 'react';
import { useRecoilValue } from 'recoil';
-import { Bot, CornerDownRight, Radio } from 'lucide-react';
import { ContentTypes, EModelEndpoint } from 'librechat-data-provider';
+import { Bot, ChevronDown, CornerDownRight, Radio } from 'lucide-react';
+import { Button, Collapsible, CollapsibleContent, CollapsibleTrigger } from '@librechat/client';
import type { TMessageContentParts } from 'librechat-data-provider';
import type { ChildConversationTurn } from './adapters';
import type { TranslationKeys } from '~/hooks';
@@ -32,6 +33,62 @@ function TriggerIcon({ kind }: { kind: ChildConversationTurn['trigger']['kind']
);
}
+function ExternalEventTrigger({ turn }: { turn: ChildConversationTurn }) {
+ const localize = useLocalize();
+ const [expanded, setExpanded] = useState(false);
+ const details = turn.trigger.externalEvent;
+ const label = localize('com_ui_subagent_trigger_external_event');
+ if (details == null) {
+ return (
+ <div className="flex min-h-9 items-center gap-2 text-sm text-text-secondary">
+ <TriggerIcon kind="external_event" />
+ <span className="font-medium">{label}</span>
+ </div>
+ );
+ }
+ return (
+ <Collapsible open={expanded} onOpenChange={setExpanded}>
+ <CollapsibleTrigger asChild>
+ <Button
+ type="button"
+ variant="ghost"
+ className="h-auto min-h-9 w-full justify-start gap-2 px-0 text-left text-sm text-text-secondary hover:bg-transparent hover:text-text-primary"
+ >
+ <TriggerIcon kind="external_event" />
+ <span className="font-medium">{label}</span>
+ <span className="min-w-0 truncate text-xs">
+ {details.eventType} · {details.sourceType}
+ </span>
+ <span className="sr-only">{details.occurredAt}</span>
+ <ChevronDown
+ size={15}
+ aria-hidden
+ className={`ml-auto shrink-0 transition-transform ${expanded ? 'rotate-180' : ''}`}
+ />
+ </Button>
+ </CollapsibleTrigger>
+ <CollapsibleContent className="ml-8 border-l border-border-light py-1 pl-3 text-xs text-text-secondary">
+ <dl className="grid grid-cols-[auto_1fr] gap-x-3 gap-y-1">
+ <dt>{localize('com_ui_subagent_event_type')}</dt>
+ <dd className="break-words text-text-primary">{details.eventType}</dd>
+ <dt>{localize('com_ui_subagent_event_source')}</dt>
+ <dd className="break-words text-text-primary">{details.sourceType}</dd>
+ <dt>{localize('com_ui_subagent_event_received')}</dt>
+ <dd className="break-words text-text-primary">
+ {new Date(details.occurredAt).toLocaleString()}
+ </dd>
+ {details.expectedActionToolName != null && (
+ <>
+ <dt>{localize('com_ui_subagent_event_expected_action')}</dt>
+ <dd className="break-words text-text-primary">{details.expectedActionToolName}</dd>
+ </>
+ )}
+ </dl>
+ </CollapsibleContent>
+ </Collapsible>
+ );
+}
+
function TriggerMessage({ turn, fullWidth }: { turn: ChildConversationTurn; fullWidth: boolean }) {
const localize = useLocalize();
const label = localize(TRIGGER_LABELS[turn.trigger.kind]);
@@ -47,6 +104,9 @@ function TriggerMessage({ turn, fullWidth }: { turn: ChildConversationTurn; full
],
[turn.trigger.summary],
);
+ if (turn.trigger.kind === 'external_event') {
+ return <ExternalEventTrigger turn={turn} />;
+ }
return (
<MessageRow
id={`${turn.taskId}:trigger`}
@@ -90,6 +150,8 @@ function ChildMessage({
conversationId,
fullWidth,
onCancelControl,
+ detailState,
+ onLoadDetails,
}: {
turn: ChildConversationTurn;
state: 'ready' | 'loading' | 'error';
@@ -97,10 +159,15 @@ function ChildMessage({
conversationId?: string | null;
fullWidth: boolean;
onCancelControl?: (controlId: string) => void;
+ detailState?: 'idle' | 'loading' | 'unavailable' | 'error';
+ 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 || hasTruncatedActivityDetails(turn.activity);
const iconData = {
endpoint: EModelEndpoint.agents,
modelLabel: label,
@@ -136,6 +203,26 @@ function ChildMessage({
conversationId={conversationId}
onCancelControl={onCancelControl}
/>
+ {detailsLimited && detailState !== 'loading' && (
+ <div className="mt-2 text-xs text-text-secondary">
+ {turn.activity.activityTruncated === true &&
+ onLoadDetails != null &&
+ detailState !== 'unavailable' ? (
+ <Button type="button" variant="ghost" size="sm" onClick={onLoadDetails}>
+ {detailState === 'error'
+ ? localize('com_ui_retry')
+ : localize('com_ui_subagent_show_full_activity')}
+ </Button>
+ ) : (
+ localize('com_ui_subagent_activity_details_unavailable')
+ )}
+ </div>
+ )}
+ {detailState === 'loading' && (
+ <div className="mt-2 text-xs text-text-secondary" aria-live="polite">
+ {localize('com_ui_loading')}
+ </div>
+ )}
</MessageRow>
);
}
@@ -147,6 +234,8 @@ export default function SubagentConversation({
stateByTask,
controllableTaskId,
onCancelControl,
+ detailStateByTask,
+ onLoadTurnDetails,
}: {
turns: ChildConversationTurn[];
agentId?: string;
@@ -154,17 +243,12 @@ export default function SubagentConversation({
stateByTask?: ReadonlyMap<string, 'ready' | 'loading' | 'error'>;
controllableTaskId?: string;
onCancelControl?: (taskId: string, controlId: string) => void;
+ detailStateByTask?: ReadonlyMap<string, 'idle' | 'loading' | 'unavailable' | 'error'>;
+ onLoadTurnDetails?: (taskId: string) => void;
}) {
- const localize = useLocalize();
const fullWidth = useRecoilValue(store.maximizeChatSpace);
- const hasShortenedDetails = turns.some((turn) => hasTruncatedActivityDetails(turn.activity));
return (
<div className="flex flex-col gap-6 py-4" data-subagent-conversation>
- {hasShortenedDetails && (
- <div className="px-4 text-xs italic text-text-secondary">
- {localize('com_ui_subagent_activity_details_truncated')}
- </div>
- )}
{turns.map((turn) => (
<section
key={turn.taskId}
@@ -186,6 +270,12 @@ export default function SubagentConversation({
? undefined
: (controlId) => onCancelControl(turn.taskId, controlId)
}
+ detailState={detailStateByTask?.get(turn.taskId)}
+ onLoadDetails={
+ turn.activity.activityTruncated !== true || onLoadTurnDetails == null
+ ? undefined
+ : () => onLoadTurnDetails(turn.taskId)
+ }
/>
</div>
</section>
diff --git a/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx b/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx
index b2a4459fc3..ba4177aaf6 100644
--- a/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx
+++ b/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx
@@ -22,6 +22,7 @@ const mockForkMutate = jest.fn();
const mockControlMutate = jest.fn();
const mockNavigateToConvo = jest.fn();
const mockShowToast = jest.fn();
+const mockGetSubagentThread = jest.fn();
const mockApprovalProviderMounted = jest.fn();
const mockApprovalProviderUnmounted = jest.fn();
let mockIsMobile = false;
@@ -29,6 +30,17 @@ let mockParentChildrenByMessage = new Map<string, ParentSubagentSummary[]>();
let mockParentChildrenByThread = new Map<string, ParentSubagentSummary>();
const mockRefreshParentChildren = jest.fn().mockResolvedValue(undefined);
+jest.mock('librechat-data-provider', () => {
+ const actual = jest.requireActual('librechat-data-provider');
+ return {
+ ...actual,
+ dataService: {
+ ...actual.dataService,
+ getSubagentThread: (...args: unknown[]) => mockGetSubagentThread(...args),
+ },
+ };
+});
+
jest.mock('~/data-provider', () => ({
ACTIVE_THREAD_REFRESH_MS: 2000,
useSubagentThreadQuery: (...args: unknown[]) => mockUseSubagentThreadQuery(...args),
@@ -151,13 +163,17 @@ jest.mock('./SubagentConversation', () => ({
default: ({
turns,
stateByTask,
+ detailStateByTask,
+ onLoadTurnDetails,
}: {
turns: Array<{
taskId: string;
trigger: { summary: string };
- activity: { items: Array<{ text?: string }> };
+ activity: { items: Array<{ text?: string }>; activityTruncated?: boolean };
}>;
stateByTask?: ReadonlyMap<string, string>;
+ detailStateByTask?: ReadonlyMap<string, string>;
+ onLoadTurnDetails?: (taskId: string) => void;
}) => (
<div
data-testid="subagent-conversation"
@@ -169,6 +185,12 @@ jest.mock('./SubagentConversation', () => ({
{turn.activity.items.map((item, index) => (
<span key={index}>{item.text}</span>
))}
+ {turn.activity.activityTruncated === true && onLoadTurnDetails != null && (
+ <button type="button" onClick={() => onLoadTurnDetails(turn.taskId)}>
+ {`load-${turn.taskId}`}
+ </button>
+ )}
+ {detailStateByTask?.get(turn.taskId)}
</div>
))}
</div>
@@ -289,11 +311,16 @@ describe('SubagentThreadPanel', () => {
mockControlMutate.mockClear();
mockNavigateToConvo.mockClear();
mockShowToast.mockClear();
+ mockGetSubagentThread.mockReset();
mockRefreshParentChildren.mockClear();
mockParentChildrenByMessage = new Map();
mockParentChildrenByThread = new Map();
});
+ afterEach(() => {
+ jest.restoreAllMocks();
+ });
+
it('renders a bounded read-only activity timeline and closes its selection', async () => {
mockUseSubagentThreadQuery.mockReturnValue({
data: completedView,
@@ -328,7 +355,7 @@ describe('SubagentThreadPanel', () => {
);
expect(mockUseSubagentActivityStream).toHaveBeenCalledWith(selection, false);
expect(screen.getByText('Research child')).toBeInTheDocument();
- expect(screen.getByText('com_ui_subagent_depth')).toBeInTheDocument();
+ expect(screen.queryByText('com_ui_subagent_depth')).not.toBeInTheDocument();
expect(screen.getByText('Investigate the release.')).toBeInTheDocument();
expect(screen.getByText('The release is ready.')).toBeInTheDocument();
expect(screen.getByTestId('shared-activity')).toHaveAttribute('data-status', 'completed');
@@ -369,7 +396,7 @@ describe('SubagentThreadPanel', () => {
</RecoilRoot>,
);
- fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_view_in_parent' }));
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_close' }));
expect(active).toBeNull();
await waitFor(() =>
@@ -1406,6 +1433,844 @@ describe('SubagentThreadPanel', () => {
expect(mockRefreshParentChildren).toHaveBeenCalled();
});
+ it('keeps a single event actor in the compact header without a duplicate selector', () => {
+ const eventChild: ParentSubagentSummary = {
+ threadId: 'child-thread',
+ parentMessageId: 'parent-message',
+ subagentType: 'agent-1',
+ subagentKind: 'agent',
+ agentId: 'agent-1',
+ title: 'First actor',
+ origin: 'event',
+ actorId: 'actor-1',
+ status: 'completed',
+ latestTaskId: 'task',
+ tasks: [{ taskId: 'task', status: 'completed' }],
+ tasksTruncated: false,
+ };
+ mockParentChildrenByMessage = new Map([['parent-message', [eventChild]]]);
+ mockParentChildrenByThread = new Map([[eventChild.threadId, eventChild]]);
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: completedView,
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+
+ render(
+ <RecoilRoot>
+ <SubagentThreadPanel
+ selection={{
+ ...selection,
+ event: { actorId: 'actor-1', progressKey: 'event-task:child-thread:task' },
+ }}
+ />
+ </RecoilRoot>,
+ );
+
+ expect(screen.getByRole('heading', { name: 'Analyst One' })).toBeInTheDocument();
+ expect(
+ screen.queryByRole('combobox', { name: 'com_ui_subagent_actor' }),
+ ).not.toBeInTheDocument();
+ expect(screen.queryByText('com_ui_subagent_depth')).not.toBeInTheDocument();
+ });
+
+ it('loads an exact older turn projection only after the local disclosure is opened', async () => {
+ const truncatedView: SubagentThreadView = {
+ ...completedView,
+ turns: [
+ {
+ taskId: 'task-old',
+ trigger: { kind: 'parent_dispatch', summary: 'Old prompt' },
+ status: 'completed',
+ activity: [],
+ activityTruncated: true,
+ messages: [],
+ },
+ {
+ taskId: 'task',
+ trigger: { kind: 'parent_continuation', summary: 'Current prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Current result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ };
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: truncatedView,
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+ mockGetSubagentThread.mockResolvedValue({
+ ...completedView,
+ activity: [{ type: 'writing', text: 'Loaded exact activity' }],
+ activityTruncated: false,
+ messages: [
+ {
+ messageId: 'task-old:assistant',
+ parentMessageId: 'task-old:user',
+ role: 'assistant',
+ text: 'Loaded exact activity',
+ },
+ ],
+ });
+
+ render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ expect(mockGetSubagentThread).not.toHaveBeenCalled();
+ fireEvent.click(screen.getByRole('button', { name: 'load-task-old' }));
+ await waitFor(() => expect(screen.getByText('Loaded exact activity')).toBeInTheDocument());
+ expect(mockGetSubagentThread).toHaveBeenCalledTimes(1);
+ expect(mockGetSubagentThread).toHaveBeenCalledWith(
+ 'parent-conversation',
+ 'child-thread',
+ 'task-old',
+ );
+ });
+
+ it('retains partial activity when an exact historical task has vanished', async () => {
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: {
+ ...completedView,
+ turns: [
+ {
+ taskId: 'task-old',
+ trigger: { kind: 'parent_dispatch', summary: 'Retained prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Retained partial result' }],
+ activityTruncated: true,
+ messages: [],
+ },
+ ],
+ },
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+ mockGetSubagentThread.mockResolvedValue({
+ ...completedView,
+ activity: [],
+ activityTruncated: false,
+ messages: [],
+ turns: [],
+ });
+
+ render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ fireEvent.click(screen.getByRole('button', { name: 'load-task-old' }));
+ await waitFor(() =>
+ expect(screen.getAllByTestId('conversation-turn')[1]).toHaveTextContent('unavailable'),
+ );
+ expect(screen.getByText('Retained partial result')).toBeInTheDocument();
+ });
+
+ it('prepends an older bounded page without adding it to live polling', async () => {
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: {
+ ...completedView,
+ nextCursor: 'older:assistant',
+ turns: [
+ {
+ taskId: 'task',
+ trigger: { kind: 'parent_dispatch', summary: 'Current prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Current result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ },
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+ mockGetSubagentThread.mockResolvedValue({
+ ...completedView,
+ activity: [],
+ messages: [],
+ historyTruncated: false,
+ turns: [
+ {
+ taskId: 'older',
+ trigger: { kind: 'parent_dispatch', summary: 'Older prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Older result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ });
+
+ render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+ await waitFor(() => expect(screen.getAllByTestId('conversation-turn')).toHaveLength(2));
+ expect(mockGetSubagentThread).toHaveBeenCalledWith(
+ 'parent-conversation',
+ 'child-thread',
+ undefined,
+ 'older:assistant',
+ );
+ expect(mockUseSubagentThreadQuery.mock.calls.every((call) => call[2] === 'task')).toBe(true);
+ });
+
+ it('discards an older-page response when the latest cursor generation advances', async () => {
+ let resolveOlderPage: (view: SubagentThreadView) => void = () => undefined;
+ const olderPage = new Promise<SubagentThreadView>((resolve) => {
+ resolveOlderPage = resolve;
+ });
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: {
+ ...completedView,
+ nextCursor: 'older-a:assistant',
+ turns: [
+ {
+ taskId: 'task',
+ trigger: { kind: 'parent_dispatch', summary: 'Current prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Current result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ },
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+ mockGetSubagentThread.mockReturnValueOnce(olderPage);
+
+ const { rerender } = render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: {
+ ...completedView,
+ nextCursor: 'older-b:assistant',
+ turns: [
+ {
+ taskId: 'task-new',
+ trigger: { kind: 'parent_continuation', summary: 'New prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'New result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ {
+ taskId: 'task',
+ trigger: { kind: 'parent_dispatch', summary: 'Current prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Current result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ },
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ await act(async () => {
+ resolveOlderPage({
+ ...completedView,
+ activity: [],
+ messages: [],
+ turns: [
+ {
+ taskId: 'older-a',
+ trigger: { kind: 'parent_dispatch', summary: 'Displaced prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Displaced result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ });
+ await olderPage;
+ });
+
+ expect(screen.queryByText('Displaced result')).not.toBeInTheDocument();
+ await waitFor(() =>
+ expect(
+ screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }),
+ ).toBeEnabled(),
+ );
+ });
+
+ it('shows only the retry control after an earlier-history request fails', async () => {
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: {
+ ...completedView,
+ nextCursor: 'older:assistant',
+ turns: [
+ {
+ taskId: 'task',
+ trigger: { kind: 'parent_dispatch', summary: 'Current prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Current result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ },
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+ mockGetSubagentThread.mockRejectedValueOnce(new Error('history unavailable'));
+
+ render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+ await waitFor(() => expect(screen.getByRole('button', { name: 'com_ui_retry' })).toBeEnabled());
+ expect(
+ screen.queryByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }),
+ ).not.toBeInTheDocument();
+ });
+
+ it('shows a compact inaccessible-history boundary when no recovery cursor exists', () => {
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: {
+ ...completedView,
+ historyTruncated: true,
+ turns: [
+ {
+ taskId: 'task',
+ trigger: { kind: 'parent_dispatch', summary: 'Current prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Current result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ },
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+
+ render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ expect(
+ screen.getByRole('status', { name: 'com_ui_subagent_thread_history_truncated' }),
+ ).toHaveTextContent('•••');
+ expect(
+ screen.queryByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }),
+ ).not.toBeInTheDocument();
+ });
+
+ it('preserves an unrecoverable boundary while loading later cursor pages', async () => {
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: {
+ ...completedView,
+ nextCursor: 'older:assistant',
+ turns: [],
+ },
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+ mockGetSubagentThread
+ .mockResolvedValueOnce({
+ ...completedView,
+ nextCursor: 'oldest:assistant',
+ historyTruncated: true,
+ historyUnavailable: true,
+ activity: [],
+ messages: [],
+ turns: [],
+ })
+ .mockResolvedValueOnce({
+ ...completedView,
+ historyTruncated: false,
+ activity: [],
+ messages: [],
+ turns: [],
+ });
+
+ render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+ await waitFor(() =>
+ expect(mockGetSubagentThread).toHaveBeenLastCalledWith(
+ 'parent-conversation',
+ 'child-thread',
+ undefined,
+ 'older:assistant',
+ ),
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+ await waitFor(() =>
+ expect(mockGetSubagentThread).toHaveBeenLastCalledWith(
+ 'parent-conversation',
+ 'child-thread',
+ undefined,
+ 'oldest:assistant',
+ ),
+ );
+
+ expect(
+ screen.getByRole('status', { name: 'com_ui_subagent_thread_history_truncated' }),
+ ).toHaveTextContent('•••');
+ });
+
+ it('preserves a cursorless truncated boundary after the latest polling window moves', async () => {
+ let latestView: SubagentThreadView = {
+ ...completedView,
+ historyTruncated: true,
+ historyUnavailable: undefined,
+ nextCursor: undefined,
+ turns: [],
+ };
+ mockUseSubagentThreadQuery.mockImplementation(() => ({
+ data: latestView,
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ }));
+
+ const { rerender } = render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+ expect(
+ screen.getByRole('status', { name: 'com_ui_subagent_thread_history_truncated' }),
+ ).toBeInTheDocument();
+
+ latestView = {
+ ...latestView,
+ historyTruncated: false,
+ nextCursor: 'new-boundary:assistant',
+ };
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ await waitFor(() =>
+ expect(
+ screen.getByRole('status', { name: 'com_ui_subagent_thread_history_truncated' }),
+ ).toBeInTheDocument(),
+ );
+ });
+
+ it('rejects stale exact-detail responses across an actor A-B-A switch', async () => {
+ let resolveStaleDetail: (view: SubagentThreadView) => void = () => undefined;
+ const staleDetail = new Promise<SubagentThreadView>((resolve) => {
+ resolveStaleDetail = resolve;
+ });
+ const viewFor = (threadId: string, taskId: string): SubagentThreadView => ({
+ ...completedView,
+ threadId,
+ activity: [],
+ activityTruncated: true,
+ messages: [],
+ turns: [
+ {
+ taskId,
+ trigger: { kind: 'parent_dispatch', summary: `${threadId} prompt` },
+ status: 'completed',
+ activity: [],
+ activityTruncated: true,
+ messages: [],
+ },
+ ],
+ });
+ mockUseSubagentThreadQuery.mockImplementation(
+ (_parentConversationId: string, requestedThreadId: string, requestedTaskId: string) => ({
+ data: viewFor(requestedThreadId, requestedTaskId),
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ }),
+ );
+ mockGetSubagentThread.mockReturnValueOnce(staleDetail).mockResolvedValueOnce({
+ ...completedView,
+ threadId: 'thread-a',
+ activity: [{ type: 'writing', text: 'Fresh detail' }],
+ activityTruncated: false,
+ messages: [
+ {
+ messageId: 'task-a:assistant',
+ parentMessageId: 'task-a:user',
+ role: 'assistant',
+ text: 'Fresh detail',
+ },
+ ],
+ });
+ const selectionA: ActiveSubagentPanel = {
+ ...selection,
+ durable: { threadId: 'thread-a', taskId: 'task-a' },
+ };
+ const selectionB: ActiveSubagentPanel = {
+ ...selection,
+ durable: { threadId: 'thread-b', taskId: 'task-b' },
+ };
+
+ const { rerender } = render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selectionA} />
+ </RecoilRoot>,
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'load-task-a' }));
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selectionB} />
+ </RecoilRoot>,
+ );
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selectionA} />
+ </RecoilRoot>,
+ );
+ await waitFor(() => expect(screen.getByRole('button', { name: 'load-task-a' })).toBeEnabled());
+ fireEvent.click(screen.getByRole('button', { name: 'load-task-a' }));
+ await waitFor(() => expect(screen.getByText('Fresh detail')).toBeInTheDocument());
+
+ await act(async () => {
+ resolveStaleDetail({
+ ...completedView,
+ threadId: 'thread-a',
+ activity: [{ type: 'writing', text: 'Stale detail' }],
+ activityTruncated: false,
+ messages: [],
+ });
+ await staleDetail;
+ });
+
+ expect(screen.getByText('Fresh detail')).toBeInTheDocument();
+ expect(screen.queryByText('Stale detail')).not.toBeInTheDocument();
+ });
+
+ it('rejects stale history responses across an actor A-B-A switch', async () => {
+ let resolveStaleHistory: (view: SubagentThreadView) => void = () => undefined;
+ const staleHistory = new Promise<SubagentThreadView>((resolve) => {
+ resolveStaleHistory = resolve;
+ });
+ const viewFor = (threadId: string, taskId: string): SubagentThreadView => ({
+ ...completedView,
+ threadId,
+ nextCursor: `${taskId}-older:assistant`,
+ activity: [{ type: 'writing', text: `${threadId} current` }],
+ turns: [
+ {
+ taskId,
+ trigger: { kind: 'parent_dispatch', summary: `${threadId} prompt` },
+ status: 'completed',
+ activity: [{ type: 'writing', text: `${threadId} current` }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ });
+ mockUseSubagentThreadQuery.mockImplementation(
+ (_parentConversationId: string, requestedThreadId: string, requestedTaskId: string) => ({
+ data: viewFor(requestedThreadId, requestedTaskId),
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ }),
+ );
+ mockGetSubagentThread.mockReturnValueOnce(staleHistory).mockResolvedValueOnce({
+ ...completedView,
+ threadId: 'thread-a',
+ activity: [],
+ messages: [],
+ turns: [
+ {
+ taskId: 'fresh-older',
+ trigger: { kind: 'parent_dispatch', summary: 'Fresh older prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Fresh older result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ });
+ const selectionA: ActiveSubagentPanel = {
+ ...selection,
+ durable: { threadId: 'thread-a', taskId: 'task-a' },
+ };
+ const selectionB: ActiveSubagentPanel = {
+ ...selection,
+ durable: { threadId: 'thread-b', taskId: 'task-b' },
+ };
+
+ const { rerender } = render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selectionA} />
+ </RecoilRoot>,
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selectionB} />
+ </RecoilRoot>,
+ );
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selectionA} />
+ </RecoilRoot>,
+ );
+ await waitFor(() =>
+ expect(
+ screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }),
+ ).toBeEnabled(),
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+ await waitFor(() => expect(screen.getByText('Fresh older result')).toBeInTheDocument());
+
+ await act(async () => {
+ resolveStaleHistory({
+ ...completedView,
+ threadId: 'thread-a',
+ activity: [],
+ messages: [],
+ turns: [
+ {
+ taskId: 'stale-older',
+ trigger: { kind: 'parent_dispatch', summary: 'Stale older prompt' },
+ status: 'completed',
+ activity: [{ type: 'writing', text: 'Stale older result' }],
+ activityTruncated: false,
+ messages: [],
+ },
+ ],
+ });
+ await staleHistory;
+ });
+
+ expect(screen.getByText('Fresh older result')).toBeInTheDocument();
+ expect(screen.queryByText('Stale older result')).not.toBeInTheDocument();
+ });
+
+ it('retains a latest-window turn displaced after older history has loaded', async () => {
+ const makeTurn = (taskId: string, text: string) => ({
+ taskId,
+ trigger: { kind: 'parent_dispatch' as const, summary: `${text} prompt` },
+ status: 'completed' as const,
+ activity: [{ type: 'writing' as const, text }],
+ activityTruncated: false,
+ messages: [],
+ });
+ let latestView: SubagentThreadView = {
+ ...completedView,
+ nextCursor: 'boundary:assistant',
+ activity: [{ type: 'writing', text: 'Current result' }],
+ turns: [makeTurn('boundary', 'Boundary result'), makeTurn('task', 'Current result')],
+ };
+ let resolveReconnect: (view: SubagentThreadView) => void = () => undefined;
+ const reconnectPage = new Promise<SubagentThreadView>((resolve) => {
+ resolveReconnect = resolve;
+ });
+ mockUseSubagentThreadQuery.mockImplementation(() => ({
+ data: latestView,
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ }));
+ mockGetSubagentThread
+ .mockResolvedValueOnce({
+ ...completedView,
+ nextCursor: 'very-old:assistant',
+ activity: [],
+ messages: [],
+ turns: [makeTurn('very-old', 'Very old result')],
+ })
+ .mockResolvedValueOnce({
+ ...completedView,
+ nextCursor: 'middle-older:assistant',
+ activity: [],
+ messages: [],
+ historyTruncated: true,
+ turns: [makeTurn('middle-newer', 'Newer middle result')],
+ })
+ .mockReturnValueOnce(reconnectPage);
+
+ const { rerender } = render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+ await waitFor(() => expect(screen.getAllByTestId('conversation-turn')).toHaveLength(3));
+
+ latestView = {
+ ...latestView,
+ nextCursor: 'middle:assistant',
+ turns: [makeTurn('task-new', 'New result'), makeTurn('task-newer', 'Newest result')],
+ };
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ await waitFor(() => expect(screen.getAllByTestId('conversation-turn')).toHaveLength(5));
+ expect(screen.getByText('Very old result')).toBeInTheDocument();
+ expect(screen.getByText('Boundary result')).toBeInTheDocument();
+ expect(screen.getByText('Current result')).toBeInTheDocument();
+ expect(screen.getByText('New result')).toBeInTheDocument();
+ expect(screen.getByText('Newest result')).toBeInTheDocument();
+
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+ await waitFor(() =>
+ expect(mockGetSubagentThread).toHaveBeenLastCalledWith(
+ 'parent-conversation',
+ 'child-thread',
+ undefined,
+ 'middle:assistant',
+ ),
+ );
+ await waitFor(() => expect(screen.getAllByTestId('conversation-turn')).toHaveLength(6));
+
+ latestView = {
+ ...latestView,
+ nextCursor: 'new-live-boundary:assistant',
+ turns: [makeTurn('task-final', 'Final live result')],
+ };
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+ await waitFor(() => expect(screen.getAllByTestId('conversation-turn')).toHaveLength(7));
+
+ fireEvent.click(screen.getByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }));
+ await waitFor(() =>
+ expect(mockGetSubagentThread).toHaveBeenLastCalledWith(
+ 'parent-conversation',
+ 'child-thread',
+ undefined,
+ 'middle-older:assistant',
+ ),
+ );
+
+ latestView = {
+ ...latestView,
+ nextCursor: 'ultimate-live-boundary:assistant',
+ turns: [makeTurn('task-ultimate', 'Ultimate live result')],
+ };
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+ await waitFor(() => expect(screen.getByText('Ultimate live result')).toBeInTheDocument());
+
+ await act(async () => {
+ resolveReconnect({
+ ...completedView,
+ activity: [],
+ messages: [],
+ historyTruncated: false,
+ turns: [
+ makeTurn('boundary', 'Boundary result'),
+ makeTurn('middle-older', 'Older middle result'),
+ ],
+ });
+ await reconnectPage;
+ });
+
+ await waitFor(() => expect(screen.getAllByTestId('conversation-turn')).toHaveLength(9));
+ expect(screen.getAllByTestId('conversation-turn').map((turn) => turn.textContent)).toEqual([
+ expect.stringContaining('Very old result'),
+ expect.stringContaining('Boundary result'),
+ expect.stringContaining('Current result'),
+ expect.stringContaining('Older middle result'),
+ expect.stringContaining('Newer middle result'),
+ expect.stringContaining('New result'),
+ expect.stringContaining('Newest result'),
+ expect.stringContaining('Final live result'),
+ expect.stringContaining('Ultimate live result'),
+ ]);
+ expect(
+ screen.queryByRole('button', { name: 'com_ui_subagent_load_earlier_activity' }),
+ ).not.toBeInTheDocument();
+ });
+
+ it('does not accumulate displaced latest-window turns before history is requested', async () => {
+ const makeTurn = (taskId: string, text: string) => ({
+ taskId,
+ trigger: { kind: 'parent_dispatch' as const, summary: `${text} prompt` },
+ status: 'completed' as const,
+ activity: [{ type: 'writing' as const, text }],
+ activityTruncated: false,
+ messages: [],
+ });
+ let latestView: SubagentThreadView = {
+ ...completedView,
+ nextCursor: 'old:assistant',
+ turns: [makeTurn('old', 'Old result'), makeTurn('task', 'Current result')],
+ };
+ mockUseSubagentThreadQuery.mockImplementation(() => ({
+ data: latestView,
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ }));
+
+ const { rerender } = render(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+ expect(screen.getByText('Old result')).toBeInTheDocument();
+
+ latestView = {
+ ...latestView,
+ nextCursor: 'task:assistant',
+ turns: [makeTurn('task', 'Current result'), makeTurn('new', 'New result')],
+ };
+ rerender(
+ <RecoilRoot>
+ <SubagentThreadPanel selection={selection} />
+ </RecoilRoot>,
+ );
+
+ await waitFor(() => expect(screen.queryByText('Old result')).not.toBeInTheDocument());
+ expect(screen.getByText('Current result prompt')).toBeInTheDocument();
+ expect(screen.getByText('New result')).toBeInTheDocument();
+ });
+
it('follows a newly appended latest turn while preserving the continuous history', async () => {
const eventChild: ParentSubagentSummary = {
threadId: 'child-thread',
@@ -1507,6 +2372,49 @@ describe('SubagentThreadPanel', () => {
expect(new Set(mockUseSubagentThreadQuery.mock.calls.map((call) => call[2]))).toEqual(
new Set(['task-5', 'task-4', 'task-3', 'task-2', 'task-1']),
);
- expect(screen.getByText('com_ui_subagent_thread_history_truncated')).toBeInTheDocument();
+ expect(
+ screen.getByRole('status', { name: 'com_ui_subagent_thread_history_truncated' }),
+ ).toHaveTextContent('•••');
+ });
+
+ it('marks a truncated one-task legacy event window as incomplete', () => {
+ const eventChild: ParentSubagentSummary = {
+ threadId: 'child-thread',
+ parentMessageId: 'parent-message',
+ subagentType: 'agent-1',
+ subagentKind: 'agent',
+ agentId: 'agent-1',
+ title: 'Actor',
+ origin: 'event',
+ actorId: 'actor-1',
+ status: 'completed',
+ latestTaskId: 'task',
+ tasks: [{ taskId: 'task', status: 'completed' }],
+ tasksTruncated: true,
+ };
+ mockParentChildrenByMessage = new Map([['parent-message', [eventChild]]]);
+ mockParentChildrenByThread = new Map([[eventChild.threadId, eventChild]]);
+ mockUseSubagentThreadQuery.mockReturnValue({
+ data: completedView,
+ isLoading: false,
+ isError: false,
+ isReadinessPending: false,
+ });
+
+ render(
+ <RecoilRoot>
+ <SubagentThreadPanel
+ selection={{
+ ...selection,
+ event: { actorId: 'actor-1', progressKey: 'event-task:child-thread:task' },
+ }}
+ />
+ </RecoilRoot>,
+ );
+
+ expect(screen.getAllByTestId('shared-activity')).toHaveLength(1);
+ expect(
+ screen.getByRole('status', { name: 'com_ui_subagent_thread_history_truncated' }),
+ ).toHaveTextContent('•••');
});
});
diff --git a/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx b/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx
index ae46f2c321..fcd0b732af 100644
--- a/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx
+++ b/client/src/components/Chat/Subagents/SubagentThreadPanel.tsx
@@ -1,16 +1,7 @@
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import { v4 } from 'uuid';
-import { ForkOptions } from 'librechat-data-provider';
-import {
- Bot,
- CornerDownRight,
- CornerUpLeft,
- ListEnd,
- MessagesSquare,
- OctagonX,
- X,
- Zap,
-} from 'lucide-react';
+import { dataService, ForkOptions } from 'librechat-data-provider';
+import { Bot, CornerDownRight, ListEnd, MessagesSquare, OctagonX, X, Zap } from 'lucide-react';
import {
useRecoilCallback,
useRecoilState,
@@ -38,6 +29,13 @@ import type {
} from 'librechat-data-provider';
import type { ReactNode } from 'react';
import type { ActiveSubagentPanel, SubagentControlUiState } from '~/store/subagents';
+import {
+ adaptDurableThreadActivity,
+ adaptDurableThreadConversation,
+ adaptLivePersistedActivity,
+ mergeChildConversationTurns,
+ retainBoundedMovingWindowTurns,
+} from './adapters';
import {
ACTIVE_THREAD_REFRESH_MS,
subagentThreadHasTaskEvidence,
@@ -52,11 +50,6 @@ import {
subagentProgressByToolCallId,
subagentProgressKey,
} from '~/store/subagents';
-import {
- adaptDurableThreadActivity,
- adaptDurableThreadConversation,
- adaptLivePersistedActivity,
-} from './adapters';
import useSubagentActivityStream from '~/data-provider/Subagents/useSubagentActivityStream';
import SubagentActivity, { SubagentActivityScrollSurface } from './SubagentActivity';
import ApprovalProvider from '~/components/Chat/Messages/Content/ApprovalContext';
@@ -186,12 +179,26 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
return true;
});
}, [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, isReadinessPending, refetch } = useSubagentThreadQuery(
selection.parentConversationId,
threadId,
taskId,
eventTaskRunning ? { refetchInterval: ACTIVE_THREAD_REFRESH_MS } : undefined,
);
+ const latestHistoryGeneration = JSON.stringify([
+ data?.nextCursor ?? null,
+ ...(data?.turns?.map((turn) => turn.taskId) ?? []),
+ ]);
+ const latestHistoryGenerationRef = useRef(latestHistoryGeneration);
+ latestHistoryGenerationRef.current = latestHistoryGeneration;
const durableTerminal =
subagentThreadHasTaskEvidence(data, taskId) &&
(data?.status === 'completed' ||
@@ -251,6 +258,42 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
},
});
const [controlMessage, setControlMessage] = useState('');
+ const [turnDetailOverrides, setTurnDetailOverrides] = useState(
+ () => new Map<string, ReturnType<typeof adaptDurableThreadActivity>>(),
+ );
+ const [turnDetailStates, setTurnDetailStates] = useState(
+ () => new Map<string, 'idle' | 'loading' | 'unavailable' | 'error'>(),
+ );
+ const [olderTurns, setOlderTurns] = useState<ReturnType<typeof adaptDurableThreadConversation>>(
+ [],
+ );
+ const [movingWindowTurns, setMovingWindowTurns] = useState<
+ ReturnType<typeof adaptDurableThreadConversation>
+ >([]);
+ const [rebaseTurns, setRebaseTurns] = useState<ReturnType<typeof adaptDurableThreadConversation>>(
+ [],
+ );
+ const [postRebaseTurns, setPostRebaseTurns] = useState<
+ ReturnType<typeof adaptDurableThreadConversation>
+ >([]);
+ const postRebaseTurnsRef = useRef(postRebaseTurns);
+ const [historyRebaseActive, setHistoryRebaseActive] = useState(false);
+ const historyRebaseActiveRef = useRef(historyRebaseActive);
+ const [historyCursor, setHistoryCursor] = useState<string | null | undefined>(undefined);
+ const [historyCursorGeneration, setHistoryCursorGeneration] = useState<string>();
+ const [historyState, setHistoryState] = useState<'idle' | 'loading' | 'error'>('idle');
+ const [historyBoundaryUnavailable, setHistoryBoundaryUnavailable] = useState(false);
+ const activeThreadRef = useRef(threadId);
+ const selectionThreadRef = useRef(threadId);
+ const selectionGenerationRef = useRef(0);
+ const turnDetailRequestsRef = useRef(new Set<string>());
+ const historyRequestRef = useRef<string | null>(null);
+ const historyHasLoadedRef = useRef(false);
+ if (selectionThreadRef.current !== threadId) {
+ selectionThreadRef.current = threadId;
+ selectionGenerationRef.current += 1;
+ }
+ activeThreadRef.current = threadId;
const [controlInaccessible, setControlInaccessible] = useState(false);
const [controlsClosed, setControlsClosed] = useState(false);
const controlInFlightRef = useRef(false);
@@ -266,6 +309,207 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
};
}, [controlIdentity]);
+ useEffect(() => {
+ setTurnDetailOverrides(new Map());
+ setTurnDetailStates(new Map());
+ setOlderTurns([]);
+ setMovingWindowTurns([]);
+ setRebaseTurns([]);
+ setPostRebaseTurns([]);
+ postRebaseTurnsRef.current = [];
+ setHistoryRebaseActive(false);
+ historyRebaseActiveRef.current = false;
+ setHistoryCursor(undefined);
+ setHistoryCursorGeneration(undefined);
+ setHistoryState('idle');
+ setHistoryBoundaryUnavailable(false);
+ turnDetailRequestsRef.current.clear();
+ historyRequestRef.current = null;
+ historyHasLoadedRef.current = false;
+ }, [threadId]);
+
+ useEffect(() => {
+ if (
+ data?.threadId === threadId &&
+ (data.historyUnavailable === true ||
+ (data.historyTruncated === true && data.nextCursor == null))
+ ) {
+ setHistoryBoundaryUnavailable(true);
+ }
+ }, [
+ data?.historyTruncated,
+ data?.historyUnavailable,
+ data?.nextCursor,
+ data?.threadId,
+ threadId,
+ ]);
+
+ const loadTurnDetails = useCallback(
+ async (detailTaskId: string) => {
+ const requestedThreadId = threadId;
+ const requestedGeneration = selectionGenerationRef.current;
+ const requestKey = `${requestedGeneration}\u0000${requestedThreadId}\u0000${detailTaskId}`;
+ if (
+ turnDetailStates.get(detailTaskId) === 'loading' ||
+ turnDetailRequestsRef.current.has(requestKey)
+ ) {
+ return;
+ }
+ turnDetailRequestsRef.current.add(requestKey);
+ setTurnDetailStates((current) => new Map(current).set(detailTaskId, 'loading'));
+ try {
+ const exact = await dataService.getSubagentThread(
+ selection.parentConversationId,
+ requestedThreadId,
+ detailTaskId,
+ );
+ if (
+ activeThreadRef.current !== requestedThreadId ||
+ selectionGenerationRef.current !== requestedGeneration
+ ) {
+ return;
+ }
+ if (!subagentThreadHasTaskEvidence(exact, detailTaskId)) {
+ setTurnDetailStates((current) => new Map(current).set(detailTaskId, 'unavailable'));
+ return;
+ }
+ const detail = adaptDurableThreadActivity(exact, detailTaskId);
+ setTurnDetailOverrides((current) => new Map(current).set(detailTaskId, detail));
+ setTurnDetailStates((current) =>
+ new Map(current).set(
+ detailTaskId,
+ detail.activityTruncated === true ? 'unavailable' : 'idle',
+ ),
+ );
+ } catch {
+ if (
+ activeThreadRef.current !== requestedThreadId ||
+ selectionGenerationRef.current !== requestedGeneration
+ ) {
+ return;
+ }
+ setTurnDetailStates((current) => new Map(current).set(detailTaskId, 'error'));
+ } finally {
+ turnDetailRequestsRef.current.delete(requestKey);
+ }
+ },
+ [selection.parentConversationId, threadId, turnDetailStates],
+ );
+ const loadEarlierHistory = useCallback(async () => {
+ const requestedThreadId = threadId;
+ const requestedSelectionGeneration = selectionGenerationRef.current;
+ const requestedGeneration = historyRebaseActive
+ ? (historyCursorGeneration ?? latestHistoryGeneration)
+ : latestHistoryGeneration;
+ const startsRebase =
+ !historyRebaseActive &&
+ historyCursor !== undefined &&
+ historyCursorGeneration !== requestedGeneration;
+ const recoveringRebase = startsRebase || historyRebaseActive;
+ const cursor = historyCursor === undefined || startsRebase ? data?.nextCursor : historyCursor;
+ const requestKey = `${requestedSelectionGeneration}\u0000${requestedThreadId}\u0000${cursor ?? ''}\u0000${requestedGeneration}`;
+ if (cursor == null || historyState === 'loading' || historyRequestRef.current != null) {
+ return;
+ }
+ historyRequestRef.current = requestKey;
+ setHistoryState('loading');
+ try {
+ const page = await dataService.getSubagentThread(
+ selection.parentConversationId,
+ requestedThreadId,
+ undefined,
+ cursor,
+ );
+ if (
+ activeThreadRef.current !== requestedThreadId ||
+ selectionGenerationRef.current !== requestedSelectionGeneration
+ ) {
+ return;
+ }
+ if (!historyRebaseActive && latestHistoryGenerationRef.current !== requestedGeneration) {
+ setHistoryState('idle');
+ return;
+ }
+ const pageTurns = adaptDurableThreadConversation(page);
+ let recoveryCompleted = false;
+ if (recoveringRebase) {
+ const bridgeTurns = startsRebase
+ ? retainBoundedMovingWindowTurns(movingWindowTurns, rebaseTurns)
+ : movingWindowTurns;
+ const nextRebaseTurns = mergeChildConversationTurns(
+ pageTurns,
+ startsRebase ? [] : rebaseTurns,
+ );
+ const retainedTaskIds = new Set(
+ mergeChildConversationTurns(olderTurns, bridgeTurns, postRebaseTurnsRef.current).map(
+ (turn) => turn.taskId,
+ ),
+ );
+ const reconnected = pageTurns.some((turn) => retainedTaskIds.has(turn.taskId));
+ const recoveryComplete = reconnected || page.nextCursor == null;
+ if (recoveryComplete) {
+ recoveryCompleted = true;
+ const retainedPostRebaseTurns = postRebaseTurnsRef.current;
+ postRebaseTurnsRef.current = [];
+ setOlderTurns((current) =>
+ mergeChildConversationTurns(
+ current,
+ bridgeTurns,
+ nextRebaseTurns,
+ retainedPostRebaseTurns,
+ ),
+ );
+ setMovingWindowTurns([]);
+ setRebaseTurns([]);
+ setPostRebaseTurns([]);
+ setHistoryRebaseActive(false);
+ historyRebaseActiveRef.current = false;
+ } else {
+ if (startsRebase) setMovingWindowTurns(bridgeTurns);
+ setRebaseTurns(nextRebaseTurns);
+ setHistoryRebaseActive(true);
+ historyRebaseActiveRef.current = true;
+ }
+ } else {
+ setOlderTurns((current) => mergeChildConversationTurns(pageTurns, current));
+ }
+ historyHasLoadedRef.current = true;
+ setHistoryCursor(page.nextCursor ?? null);
+ setHistoryCursorGeneration(
+ recoveryCompleted ? latestHistoryGenerationRef.current : requestedGeneration,
+ );
+ setHistoryBoundaryUnavailable(
+ (current) =>
+ current ||
+ page.historyUnavailable === true ||
+ (page.historyTruncated && page.nextCursor == null),
+ );
+ setHistoryState('idle');
+ } catch {
+ if (
+ activeThreadRef.current !== requestedThreadId ||
+ selectionGenerationRef.current !== requestedSelectionGeneration
+ ) {
+ return;
+ }
+ setHistoryState('error');
+ } finally {
+ if (historyRequestRef.current === requestKey) historyRequestRef.current = null;
+ }
+ }, [
+ data?.nextCursor,
+ historyCursor,
+ historyCursorGeneration,
+ historyRebaseActive,
+ historyState,
+ latestHistoryGeneration,
+ movingWindowTurns,
+ olderTurns,
+ rebaseTurns,
+ selection.parentConversationId,
+ threadId,
+ ]);
+
const controlTask = useSubagentControlMutation({
onSuccess: ({ receipt }, variables) => {
const submittedSelection = subagentControlStateKey(
@@ -488,19 +732,59 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
}
return { ...merged, controls: [...(merged.controls ?? []), transientControl] };
}, [data, liveActivity, progress, selection.durable, transientControl]);
+ const panelTitle = selection.event == null ? activity.title : selectedEventActorName;
+ const latestConversationTurns = useMemo(
+ () => (data == null ? [] : adaptDurableThreadConversation(data)),
+ [data],
+ );
+ const previousLatestTurnsRef = useRef({
+ threadId,
+ generation: latestHistoryGeneration,
+ turns: latestConversationTurns,
+ });
+ useEffect(() => {
+ if (data == null) return;
+ const previous = previousLatestTurnsRef.current;
+ if (previous.threadId === threadId) {
+ const latestTaskIds = new Set(latestConversationTurns.map((turn) => turn.taskId));
+ const displaced = previous.turns.filter((turn) => !latestTaskIds.has(turn.taskId));
+ if (displaced.length > 0 && historyHasLoadedRef.current) {
+ if (historyRebaseActiveRef.current) {
+ const retained = retainBoundedMovingWindowTurns(postRebaseTurnsRef.current, displaced);
+ postRebaseTurnsRef.current = retained;
+ setPostRebaseTurns(retained);
+ } else {
+ setMovingWindowTurns((current) => retainBoundedMovingWindowTurns(current, displaced));
+ }
+ }
+ }
+ previousLatestTurnsRef.current = {
+ threadId,
+ generation: latestHistoryGeneration,
+ turns: latestConversationTurns,
+ };
+ }, [data, historyRebaseActive, latestConversationTurns, latestHistoryGeneration, threadId]);
const conversationTurns = useMemo(() => {
- const durableTurns = data == null ? [] : adaptDurableThreadConversation(data);
+ const durableTurns = mergeChildConversationTurns(
+ olderTurns,
+ movingWindowTurns,
+ rebaseTurns,
+ postRebaseTurns,
+ latestConversationTurns,
+ );
if (durableTurns.length > 0) {
const selectedTurnIndex = durableTurns.findIndex((turn) => turn.taskId === taskId);
if (selectedTurnIndex >= 0) {
- return durableTurns.map((turn, index) =>
- index === selectedTurnIndex ? { ...turn, activity } : turn,
- );
+ return durableTurns.map((turn, index) => {
+ const selected = index === selectedTurnIndex ? { ...turn, activity } : turn;
+ const override = turnDetailOverrides.get(turn.taskId);
+ return override == null ? selected : { ...selected, activity: override };
+ });
}
// The API keeps the exact selected activity even when its bounded
// chronological turn is the first item removed from the response.
// Preserve that selection ahead of the retained newer continuation.
- return [
+ const retained = [
{
taskId: taskId || `${selection.parentMessageId}:${selection.toolCallId}`,
trigger: {
@@ -514,6 +798,10 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
},
...durableTurns,
];
+ return retained.map((turn) => {
+ const override = turnDetailOverrides.get(turn.taskId);
+ return override == null ? turn : { ...turn, activity: override };
+ });
}
return [
{
@@ -526,7 +814,30 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
activity,
},
];
- }, [activity, data, selection, taskId]);
+ }, [
+ activity,
+ latestConversationTurns,
+ movingWindowTurns,
+ olderTurns,
+ postRebaseTurns,
+ rebaseTurns,
+ selection,
+ taskId,
+ turnDetailOverrides,
+ ]);
+ const effectiveTurnDetailStates = useMemo(() => {
+ const states = new Map(turnDetailStates);
+ if (activity.activityTruncated === true && taskId !== '') states.set(taskId, 'unavailable');
+ return states;
+ }, [activity.activityTruncated, taskId, turnDetailStates]);
+ const historyCursorUsesLatest =
+ !historyRebaseActive &&
+ (historyCursor === undefined || historyCursorGeneration !== latestHistoryGeneration);
+ const effectiveHistoryCursor = historyCursorUsesLatest ? data?.nextCursor : historyCursor;
+ const showUnavailableHistoryBoundary =
+ historyBoundaryUnavailable ||
+ data?.historyUnavailable === true ||
+ (historyCursorUsesLatest && data?.historyTruncated === true && data.nextCursor == null);
/** During a rolling deployment an older API replica can omit `turns`. Keep
* that response readable through the same deep activity renderer; every
* current host otherwise enters the conversation-native rendering seam. */
@@ -626,13 +937,14 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
</Button>
</div>
);
- } else if (eventSummary?.tasksTruncated) {
+ } else if (eventSummary?.tasksTruncated === true) {
timelinePrefix = (
<div
- role="note"
- className="border-b border-border-light px-4 py-3 text-sm text-text-secondary"
+ role="status"
+ aria-label={localize('com_ui_subagent_thread_history_truncated')}
+ className="flex h-7 items-center justify-center border-b border-border-light text-text-tertiary"
>
- {localize('com_ui_subagent_thread_history_truncated')}
+ <span aria-hidden>•••</span>
</div>
);
}
@@ -645,12 +957,40 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
if (hasConversationProjection) {
activityPanel = (
<SubagentActivityScrollSurface padded={false}>
- {data?.historyTruncated === true && (
+ {showUnavailableHistoryBoundary && (
<div
- role="note"
- className="border-b border-border-light px-4 py-3 text-sm text-text-secondary"
+ role="status"
+ aria-label={localize('com_ui_subagent_thread_history_truncated')}
+ className="flex h-7 items-center justify-center border-b border-border-light text-text-tertiary"
>
- {localize('com_ui_subagent_thread_history_truncated')}
+ <span aria-hidden>•••</span>
+ </div>
+ )}
+ {effectiveHistoryCursor != null && historyState !== 'error' && (
+ <div className="flex justify-center border-b border-border-light px-4 py-2">
+ <Button
+ type="button"
+ variant="ghost"
+ size="sm"
+ disabled={historyState === 'loading'}
+ onClick={() => void loadEarlierHistory()}
+ >
+ {historyState === 'loading'
+ ? localize('com_ui_loading')
+ : localize('com_ui_subagent_load_earlier_activity')}
+ </Button>
+ </div>
+ )}
+ {historyState === 'error' && (
+ <div className="flex justify-center border-b border-border-light px-4 py-2">
+ <Button
+ type="button"
+ variant="ghost"
+ size="sm"
+ onClick={() => void loadEarlierHistory()}
+ >
+ {localize('com_ui_retry')}
+ </Button>
</div>
)}
<SubagentConversation
@@ -664,10 +1004,15 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
onCancelControl={(_controlledTaskId, controlId) =>
submitControl('cancel_message', controlId)
}
+ detailStateByTask={effectiveTurnDetailStates}
+ onLoadTurnDetails={loadTurnDetails}
/>
</SubagentActivityScrollSurface>
);
- } else if (selection.event != null && (eventSummary?.tasks.length ?? 0) > 1) {
+ } else if (
+ selection.event != null &&
+ ((eventSummary?.tasks.length ?? 0) > 1 || eventSummary?.tasksTruncated === true)
+ ) {
activityPanel = (
<SubagentActivityScrollSurface padded={false}>
<div data-subagent-thread-timeline>
@@ -701,33 +1046,42 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
aria-label={localize('com_ui_subagent_thread_panel')}
className="flex h-full w-full flex-col overflow-hidden bg-surface-primary-alt text-text-primary"
>
- <header className="flex min-h-14 shrink-0 items-center gap-3 border-b border-border-light px-4 py-3">
+ <header className="flex h-14 shrink-0 items-center gap-2 border-b border-border-light px-3">
<div className="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-surface-tertiary">
<Bot size={17} aria-hidden="true" />
</div>
<div className="min-w-0 flex-1">
- <h2 className="truncate text-sm font-semibold" title={activity.title}>
- {activity.title}
- </h2>
- {data?.depth != null && (
- <div className="truncate text-xs text-text-secondary">
- {localize('com_ui_subagent_depth', { 0: String(data.depth) })}
- </div>
+ {selection.event != null && eventSiblings.length > 1 ? (
+ <Select value={threadId} onValueChange={selectActor}>
+ <SelectTrigger
+ className="h-8 max-w-sm border-0 bg-transparent px-1 font-semibold shadow-none"
+ aria-label={localize('com_ui_subagent_actor')}
+ >
+ <SelectValue />
+ </SelectTrigger>
+ <SelectContent>
+ {eventSiblings.map((child) => (
+ <SelectItem
+ key={child.threadId}
+ value={child.threadId}
+ disabled={!child.latestTaskId}
+ >
+ {child.agentId != null && agentsMap?.[child.agentId]?.name
+ ? agentsMap[child.agentId]?.name
+ : child.actorId || child.title}
+ {child.actorId != null && agentsMap?.[child.agentId ?? '']?.name
+ ? ` · ${child.actorId}`
+ : ''}
+ </SelectItem>
+ ))}
+ </SelectContent>
+ </Select>
+ ) : (
+ <h2 className="truncate text-sm font-semibold" title={panelTitle}>
+ {panelTitle}
+ </h2>
)}
</div>
- {selection.host === 'conversation' && (
- <Button
- type="button"
- variant="ghost"
- size="sm"
- onClick={close}
- aria-label={localize('com_ui_subagent_view_in_parent')}
- className="h-8 shrink-0 gap-1.5"
- >
- <CornerUpLeft size={15} aria-hidden="true" />
- <span className="hidden lg:inline">{localize('com_ui_subagent_view_in_parent')}</span>
- </Button>
- )}
{canContinueAsChat && (
<Button
type="button"
@@ -754,34 +1108,6 @@ export default function SubagentThreadPanel({ selection }: { selection: ActiveSu
</Button>
</header>
- {selection.event != null && (
- <div className="flex shrink-0 items-center gap-2 border-b border-border-light px-4 py-2">
- <div className="min-w-0 flex-1">
- <Select value={threadId} onValueChange={selectActor}>
- <SelectTrigger className="h-8" aria-label={localize('com_ui_subagent_actor')}>
- <SelectValue />
- </SelectTrigger>
- <SelectContent>
- {eventSiblings.map((child) => (
- <SelectItem
- key={child.threadId}
- value={child.threadId}
- disabled={!child.latestTaskId}
- >
- {child.agentId != null && agentsMap?.[child.agentId]?.name
- ? agentsMap[child.agentId]?.name
- : child.actorId || child.title}
- {child.actorId != null && agentsMap?.[child.agentId ?? '']?.name
- ? ` · ${child.actorId}`
- : ''}
- </SelectItem>
- ))}
- </SelectContent>
- </Select>
- </div>
- </div>
- )}
-
{/* Keep the foreground panel's existing nested-tool approval controls
coordinated within this invocation. Detached activity projections
never include approval payloads. */}
diff --git a/client/src/components/Chat/Subagents/adapters.test.ts b/client/src/components/Chat/Subagents/adapters.test.ts
index 8c0c162bea..fb7a0b77a1 100644
--- a/client/src/components/Chat/Subagents/adapters.test.ts
+++ b/client/src/components/Chat/Subagents/adapters.test.ts
@@ -4,12 +4,19 @@ import type {
SubagentUpdateEvent,
TMessageContentParts,
} from 'librechat-data-provider';
+import type { ChildConversationTurn } from './adapters';
+import {
+ adaptDurableThreadActivity,
+ adaptLivePersistedActivity,
+ MAX_RETAINED_MOVING_WINDOW_TURNS,
+ mergeChildConversationTurns,
+ retainBoundedMovingWindowTurns,
+} from './adapters';
import {
aggregateSubagentContent,
initSubagentAggregatorState,
initSubagentTickerState,
} from '~/utils/subagentContent';
-import { adaptDurableThreadActivity, adaptLivePersistedActivity } from './adapters';
describe('child activity adapters', () => {
it('prefers authoritative parent persistence over a partial live foreground trace', () => {
@@ -535,4 +542,56 @@ describe('child activity adapters', () => {
expect.objectContaining({ status: 'completed', items: [{ type: 'writing', text: 'Done.' }] }),
);
});
+
+ it('merges a page-split task trigger with its newer assistant activity', () => {
+ const triggerHalf: ChildConversationTurn = {
+ taskId: 'task',
+ trigger: {
+ kind: 'external_event',
+ summary: 'Play the next move.',
+ createdAt: '2026-08-27T12:00:00.000Z',
+ externalEvent: {
+ eventType: 'chess.turn.ready',
+ sourceType: 'speed-chess',
+ occurredAt: '2026-08-27T12:00:00.000Z',
+ },
+ },
+ activity: { title: 'Player', status: 'running', items: [] },
+ };
+ const assistantHalf: ChildConversationTurn = {
+ taskId: 'task',
+ trigger: { kind: 'parent_continuation', summary: '' },
+ activity: {
+ title: 'Player',
+ status: 'completed',
+ items: [{ type: 'writing', text: 'Played e4.' }],
+ },
+ };
+
+ expect(mergeChildConversationTurns([triggerHalf], [assistantHalf])).toEqual([
+ {
+ taskId: 'task',
+ trigger: triggerHalf.trigger,
+ activity: expect.objectContaining({
+ status: 'completed',
+ items: [{ type: 'writing', text: 'Played e4.' }],
+ }),
+ },
+ ]);
+ });
+
+ it('bounds automatically retained moving-window turns', () => {
+ const turns = Array.from(
+ { length: MAX_RETAINED_MOVING_WINDOW_TURNS + 3 },
+ (_, index): ChildConversationTurn => ({
+ taskId: `task-${index}`,
+ trigger: { kind: 'parent_continuation', summary: '' },
+ activity: { title: 'Player', status: 'completed', items: [] },
+ }),
+ );
+
+ expect(retainBoundedMovingWindowTurns([], turns).map((turn) => turn.taskId)).toEqual(
+ turns.slice(-MAX_RETAINED_MOVING_WINDOW_TURNS).map((turn) => turn.taskId),
+ );
+ });
});
diff --git a/client/src/components/Chat/Subagents/adapters.ts b/client/src/components/Chat/Subagents/adapters.ts
index 5b323adcb0..ba45420448 100644
--- a/client/src/components/Chat/Subagents/adapters.ts
+++ b/client/src/components/Chat/Subagents/adapters.ts
@@ -4,7 +4,6 @@ import type {
PartMetadata,
SubagentActivityItem,
SubagentControlReceipt,
- SubagentThreadTriggerKind,
SubagentThreadTurn,
SubagentThreadStatus,
SubagentThreadView,
@@ -66,12 +65,7 @@ export type ChildActivity = {
export type ChildConversationTurn = {
taskId: string;
- trigger: {
- kind: SubagentThreadTriggerKind;
- summary: string;
- createdAt?: string;
- summaryTruncated?: boolean;
- };
+ trigger: SubagentThreadTurn['trigger'];
activity: ChildActivity;
};
@@ -370,3 +364,66 @@ const adaptDurableTurn = (turn: SubagentThreadTurn, title: string): ChildConvers
export function adaptDurableThreadConversation(view: SubagentThreadView): ChildConversationTurn[] {
return (view.turns ?? []).map((turn) => adaptDurableTurn(turn, view.title));
}
+
+const triggerDetailScore = (turn: ChildConversationTurn): number =>
+ (turn.trigger.summary.trim().length > 0 ? 1 : 0) +
+ (turn.trigger.createdAt == null ? 0 : 1) +
+ (turn.trigger.externalEvent == null ? 0 : 2);
+
+const mergeTurnControls = (
+ older: ChildActivity['controls'],
+ newer: ChildActivity['controls'],
+): ChildActivity['controls'] => {
+ if (older == null) return newer;
+ if (newer == null) return older;
+ const receipts = new Map(older.map((receipt) => [receipt.invocationId, receipt]));
+ for (const receipt of newer) receipts.set(receipt.invocationId, receipt);
+ return [...receipts.values()];
+};
+
+/** Merge chronological page projections whose bounded Mongo windows can split
+ * one task between its user trigger and assistant activity records. */
+export function mergeChildConversationTurns(
+ ...pages: ChildConversationTurn[][]
+): ChildConversationTurn[] {
+ const merged: ChildConversationTurn[] = [];
+ const indexByTaskId = new Map<string, number>();
+ for (const turn of pages.flat()) {
+ const existingIndex = indexByTaskId.get(turn.taskId);
+ if (existingIndex == null) {
+ indexByTaskId.set(turn.taskId, merged.length);
+ merged.push(turn);
+ continue;
+ }
+ const older = merged[existingIndex];
+ const trigger =
+ triggerDetailScore(turn) > triggerDetailScore(older) ? turn.trigger : older.trigger;
+ const controls = mergeTurnControls(older.activity.controls, turn.activity.controls);
+ merged[existingIndex] = {
+ taskId: turn.taskId,
+ trigger,
+ activity: {
+ ...older.activity,
+ ...turn.activity,
+ items: turn.activity.items.length > 0 ? turn.activity.items : older.activity.items,
+ ...(controls == null ? {} : { controls }),
+ activityTruncated:
+ older.activity.activityTruncated === true || turn.activity.activityTruncated === true,
+ controlsTruncated:
+ older.activity.controlsTruncated === true || turn.activity.controlsTruncated === true,
+ },
+ };
+ }
+ return merged;
+}
+
+/** Polling may displace turns from the API's latest window. Retain only one
+ * bounded bridge window; older pages remain an explicit user action. */
+export const MAX_RETAINED_MOVING_WINDOW_TURNS = 50;
+
+export function retainBoundedMovingWindowTurns(
+ current: ChildConversationTurn[],
+ displaced: ChildConversationTurn[],
+): ChildConversationTurn[] {
+ return mergeChildConversationTurns(current, displaced).slice(-MAX_RETAINED_MOVING_WINDOW_TURNS);
+}
diff --git a/client/src/locales/en/translation.json b/client/src/locales/en/translation.json
index b581c965b9..0563fd6dee 100644
--- a/client/src/locales/en/translation.json
+++ b/client/src/locales/en/translation.json
@@ -2218,6 +2218,13 @@
"com_ui_subagent_control_history": "Control history",
"com_ui_subagent_control_history_truncated": "Earlier control activity is not shown.",
"com_ui_subagent_activity_details_truncated": "Some activity details were shortened.",
+ "com_ui_subagent_activity_details_unavailable": "Additional activity details are unavailable.",
+ "com_ui_subagent_show_full_activity": "Show full activity",
+ "com_ui_subagent_load_earlier_activity": "Load earlier activity",
+ "com_ui_subagent_event_type": "Event",
+ "com_ui_subagent_event_source": "Source",
+ "com_ui_subagent_event_received": "Occurred",
+ "com_ui_subagent_event_expected_action": "Expected action",
"com_ui_subagent_control_interrupt": "Interrupt",
"com_ui_subagent_control_message": "Message to subagent",
"com_ui_subagent_control_message_truncated": "Message shortened for display.",
@@ -2243,11 +2250,10 @@
"com_ui_subagent_empty_result": "No text returned.",
"com_ui_subagent_errored": "Agent errored",
"com_ui_subagent_no_result_yet": "Still running — no final result yet.",
- "com_ui_subagent_thread_history_truncated": "Earlier activity is not shown.",
+ "com_ui_subagent_thread_history_truncated": "Some earlier activity is unavailable.",
"com_ui_subagent_thread_load_error": "The agent activity could not be loaded.",
"com_ui_subagent_thread_panel": "Child agent activity",
"com_ui_subagent_depth": "Level {{0}} child",
- "com_ui_subagent_view_in_parent": "View in parent",
"com_ui_subagent_thread_read_only": "This child thread is view-only here. Its parent agent owns this execution and can continue it with the saved thread history.",
"com_ui_subagent_thread_status_cancelled": "Cancelled",
"com_ui_subagent_thread_status_completed": "Completed",
diff --git a/packages/api/src/agents/view.spec.ts b/packages/api/src/agents/view.spec.ts
index a4570d4b22..c306c6ac05 100644
--- a/packages/api/src/agents/view.spec.ts
+++ b/packages/api/src/agents/view.spec.ts
@@ -243,6 +243,7 @@ describe('subagent thread parent-scoped view', () => {
]);
expect(JSON.stringify(view)).not.toContain('abandoned');
expect(view.historyTruncated).toBe(true);
+ expect(view.historyUnavailable).toBe(true);
});
it('labels a retained continuation honestly when its task ancestor was truncated', async () => {
@@ -601,6 +602,8 @@ describe('subagent thread parent-scoped view', () => {
SUBAGENT_THREAD_VIEW_LIMITS.responseBytes,
);
expect(view.historyTruncated).toBe(true);
+ const firstRetainedTask = Number(view.turns[0].taskId.replace('task-', ''));
+ expect(view.nextCursor).toBe(`task-${firstRetainedTask - 1}:assistant`);
});
it('requires tenantless messages when the authenticated request has no tenant', async () => {
@@ -1091,6 +1094,13 @@ describe('parent child-thread index', () => {
text: 'Safe instruction. {"privateRoutingKey":"must-not-leak"}',
textProjectionTruncated: true,
createdAt: new Date('2026-08-21T11:00:00.000Z'),
+ subagentTriggerProjection: {
+ version: 1,
+ eventType: 'chess.turn.ready',
+ sourceType: 'speed-chess',
+ occurredAt: new Date('2026-08-21T10:59:00.000Z'),
+ expectedActionToolName: 'submit_move',
+ },
},
]);
const handler = createSubagentThreadViewHandler({
@@ -1108,7 +1118,16 @@ describe('parent child-thread index', () => {
turns: [
expect.objectContaining({
taskId: 'delivery-1',
- trigger: expect.objectContaining({ kind: 'external_event', summary: '' }),
+ trigger: expect.objectContaining({
+ kind: 'external_event',
+ summary: '',
+ externalEvent: {
+ eventType: 'chess.turn.ready',
+ sourceType: 'speed-chess',
+ occurredAt: '2026-08-21T10:59:00.000Z',
+ expectedActionToolName: 'submit_move',
+ },
+ }),
activity: [
expect.objectContaining({
type: 'tool',
@@ -1134,6 +1153,77 @@ describe('parent child-thread index', () => {
);
});
+ it('anchors an older page through an exact scoped task-message cursor', async () => {
+ const olderInput = {
+ ...message('older:user', 'running', true),
+ parentMessageId: null,
+ } as IMessage;
+ const olderAssistant = {
+ ...message('older:assistant', 'completed'),
+ parentMessageId: 'older:user',
+ } as IMessage;
+ const getMessagesForSubagentThreadView = jest
+ .fn()
+ .mockResolvedValue([olderAssistant, olderInput]);
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership: jest.fn().mockResolvedValue(parent),
+ getSubagentThreadForParent: jest.fn().mockResolvedValue(child),
+ getMessagesForSubagentThreadView,
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest({}, { cursor: 'newer:user' }), response);
+
+ expect(getMessagesForSubagentThreadView).toHaveBeenCalledWith(
+ expect.objectContaining({ beforeMessageId: 'newer:user' }),
+ );
+ expect(json.mock.calls[0][0].turns).toEqual([expect.objectContaining({ taskId: 'older' })]);
+ });
+
+ it('marks a vanished inclusive history cursor as unavailable', async () => {
+ const getMessagesForSubagentThreadView = jest.fn().mockResolvedValue([]);
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership: jest.fn().mockResolvedValue(parent),
+ getSubagentThreadForParent: jest.fn().mockResolvedValue(child),
+ getMessagesForSubagentThreadView,
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest({}, { cursor: 'vanished:assistant' }), response);
+
+ expect(getMessagesForSubagentThreadView).toHaveBeenCalledWith(
+ expect.objectContaining({ beforeMessageId: 'vanished:assistant' }),
+ );
+ expect(json.mock.calls[0][0]).toEqual(
+ expect.objectContaining({
+ historyTruncated: true,
+ historyUnavailable: true,
+ }),
+ );
+ expect(json.mock.calls[0][0]).not.toHaveProperty('nextCursor');
+ });
+
+ it('rejects malformed or combined history cursors before storage access', async () => {
+ const getMessagesForSubagentThreadView = jest.fn();
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership: jest.fn(),
+ getSubagentThreadForParent: jest.fn(),
+ getMessagesForSubagentThreadView,
+ });
+ const malformed = createResponse();
+ const combined = createResponse();
+
+ await handler(createRequest({}, { cursor: 'private-routing-id' }), malformed.response);
+ await handler(
+ createRequest({}, { cursor: 'older:user', taskId: 'selected-task' }),
+ combined.response,
+ );
+
+ expect(malformed.status).toHaveBeenCalledWith(404);
+ expect(combined.status).toHaveBeenCalledWith(404);
+ expect(getMessagesForSubagentThreadView).not.toHaveBeenCalled();
+ });
+
it('projects ordinary and event children together without exposing event delivery identity', async () => {
const handler = createParentSubagentIndexHandler({
getConvoOwnership: jest.fn().mockResolvedValue(parent),
diff --git a/packages/api/src/agents/view.ts b/packages/api/src/agents/view.ts
index 7fe00a70a7..2037825a02 100644
--- a/packages/api/src/agents/view.ts
+++ b/packages/api/src/agents/view.ts
@@ -56,6 +56,13 @@ type SubagentThreadViewParams = {
threadId?: string;
};
+const validTaskMessageId = (value: unknown): value is string => {
+ if (typeof value !== 'string' || Buffer.byteLength(value, 'utf8') > MAX_PUBLIC_ID_BYTES) {
+ return false;
+ }
+ return taskIdFromMessageId(value) != null;
+};
+
const validConversationId = (value: string | undefined): value is string =>
value != null && value.trim() !== '' && value.length <= 256;
@@ -337,6 +344,31 @@ const publicThreadTurns = (
summary: eventThread ? '' : (input?.text ?? ''),
...(input?.createdAt == null ? {} : { createdAt: input.createdAt }),
...(!eventThread && input?.textTruncated === true ? { summaryTruncated: true } : {}),
+ ...(eventThread &&
+ record.input?.subagentTriggerProjection?.version === 1 &&
+ isoDate(record.input.subagentTriggerProjection.occurredAt) != null
+ ? {
+ externalEvent: {
+ eventType: truncateUtf8(
+ record.input.subagentTriggerProjection.eventType,
+ MAX_PUBLIC_ID_BYTES,
+ ).text,
+ sourceType: truncateUtf8(
+ record.input.subagentTriggerProjection.sourceType,
+ MAX_PUBLIC_ID_BYTES,
+ ).text,
+ occurredAt: isoDate(record.input.subagentTriggerProjection.occurredAt)!,
+ ...(record.input.subagentTriggerProjection.expectedActionToolName == null
+ ? {}
+ : {
+ expectedActionToolName: truncateUtf8(
+ record.input.subagentTriggerProjection.expectedActionToolName,
+ MAX_PUBLIC_ID_BYTES,
+ ).text,
+ }),
+ },
+ }
+ : {}),
},
status: publicStatus(
[record.assistant, record.input].filter(
@@ -537,12 +569,15 @@ export function createSubagentThreadViewHandler(deps: SubagentThreadViewDependen
const tenantId = req.user?.tenantId || undefined;
const { parentConversationId, threadId } = req.params as SubagentThreadViewParams;
const requestedTaskId = req.query?.taskId;
+ const historyCursor = req.query?.cursor;
if (
!userId ||
!validConversationId(parentConversationId) ||
!validConversationId(threadId) ||
parentConversationId === threadId ||
- (requestedTaskId != null && !validTaskId(requestedTaskId))
+ (requestedTaskId != null && !validTaskId(requestedTaskId)) ||
+ (historyCursor != null && !validTaskMessageId(historyCursor)) ||
+ (requestedTaskId != null && historyCursor != null)
) {
notFound(res);
return;
@@ -577,6 +612,7 @@ export function createSubagentThreadViewHandler(deps: SubagentThreadViewDependen
user: userId,
...(tenantId == null ? {} : { tenantId }),
...(requestedTaskId == null ? {} : { selectedTaskId: requestedTaskId }),
+ ...(historyCursor == null ? {} : { beforeMessageId: historyCursor }),
limit: MAX_THREAD_MESSAGES + 1,
textCodePointLimit: MAX_MESSAGE_TEXT_PROJECTION_CODE_POINTS,
});
@@ -584,11 +620,21 @@ export function createSubagentThreadViewHandler(deps: SubagentThreadViewDependen
let historyTruncated = messages.length > MAX_THREAD_MESSAGES;
const newestFirst = messages.slice(0, MAX_THREAD_MESSAGES);
const branch = canonicalThreadBranch(newestFirst);
- if (branch.length < newestFirst.length) historyTruncated = true;
+ /** A valid inclusive cursor returns at least its anchor. An empty cursor
+ * page means that the retained chain vanished between requests, so the
+ * public projection must expose the discontinuity instead of presenting
+ * the latest page as complete history. */
+ let historyUnavailable = historyCursor != null && messages.length === 0;
+ historyUnavailable ||= branch.length < newestFirst.length;
+ if (historyUnavailable) historyTruncated = true;
const branchRootParentId = branch[0]?.parentMessageId;
if (branchRootParentId != null && taskIdFromMessageId(branchRootParentId) != null) {
historyTruncated = true;
}
+ const nextCursor =
+ branchRootParentId != null && validTaskMessageId(branchRootParentId)
+ ? branchRootParentId
+ : undefined;
const activeLeaseTaskId =
child.subagentThreadLease != null && child.subagentThreadLease.expiresAt > now
? child.subagentThreadLease.taskId
@@ -655,6 +701,7 @@ export function createSubagentThreadViewHandler(deps: SubagentThreadViewDependen
const projected = projectedById.get(message.messageId);
return projected == null ? [] : [projected];
});
+ if (projectedMessages.length < publicSource.length) historyUnavailable = true;
const projectedMessagesById = new Map(
projectedMessages.map((message) => [message.messageId, message]),
);
@@ -690,13 +737,23 @@ export function createSubagentThreadViewHandler(deps: SubagentThreadViewDependen
turns,
messages: projectedMessages,
historyTruncated: historyTruncated || projectedMessages.length < publicSource.length,
+ ...(historyUnavailable ? { historyUnavailable: true } : {}),
+ ...(nextCursor == null ? {} : { nextCursor }),
...(isoDate(child.updatedAt) == null ? {} : { updatedAt: isoDate(child.updatedAt) }),
};
const selectedAssistantId =
requestedTaskId == null ? undefined : `${requestedTaskId}:assistant`;
while (Buffer.byteLength(JSON.stringify(view), 'utf8') > MAX_RESPONSE_BYTES) {
if ((view.turns?.length ?? 0) > 1) {
- view.turns?.shift();
+ const removedTurn = view.turns?.shift();
+ const removedTurnAnchor = [...branch]
+ .reverse()
+ .find(
+ (message) =>
+ removedTurn != null &&
+ taskIdFromMessageId(message.messageId) === removedTurn.taskId,
+ )?.messageId;
+ if (validTaskMessageId(removedTurnAnchor)) view.nextCursor = removedTurnAnchor;
view.historyTruncated = true;
continue;
}
diff --git a/packages/data-provider/src/api-endpoints.ts b/packages/data-provider/src/api-endpoints.ts
index 49c80fdced..156b6403f2 100644
--- a/packages/data-provider/src/api-endpoints.ts
+++ b/packages/data-provider/src/api-endpoints.ts
@@ -119,9 +119,15 @@ export const conversationById = (id: string) => `${conversationsRoot}/${id}`;
export const parentSubagents = (parentConversationId: string) =>
`${conversationsRoot}/${encodeURIComponent(parentConversationId)}/subagents`;
-export const subagentThread = (parentConversationId: string, threadId: string, taskId?: string) => {
+export const subagentThread = (
+ parentConversationId: string,
+ threadId: string,
+ taskId?: string,
+ cursor?: string,
+) => {
const endpoint = `${conversationsRoot}/${encodeURIComponent(parentConversationId)}/subagents/${encodeURIComponent(threadId)}`;
- return taskId == null ? endpoint : `${endpoint}?taskId=${encodeURIComponent(taskId)}`;
+ if (taskId != null) return `${endpoint}?taskId=${encodeURIComponent(taskId)}`;
+ return cursor == null ? endpoint : `${endpoint}?cursor=${encodeURIComponent(cursor)}`;
};
export const subagentControl = (parentConversationId: string, threadId: string) =>
diff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.ts
index 4192c66900..2b7262f3ec 100644
--- a/packages/data-provider/src/data-service.ts
+++ b/packages/data-provider/src/data-service.ts
@@ -1010,8 +1010,9 @@ export function getSubagentThread(
parentConversationId: string,
threadId: string,
taskId?: string,
+ cursor?: string,
): Promise<t.SubagentThreadView> {
- return request.get(endpoints.subagentThread(parentConversationId, threadId, taskId));
+ return request.get(endpoints.subagentThread(parentConversationId, threadId, taskId, cursor));
}
export function controlSubagentTask(
diff --git a/packages/data-provider/src/types/subagents.ts b/packages/data-provider/src/types/subagents.ts
index 2aa70fab00..2adc929b04 100644
--- a/packages/data-provider/src/types/subagents.ts
+++ b/packages/data-provider/src/types/subagents.ts
@@ -122,6 +122,13 @@ export type SubagentThreadTriggerKind =
| 'parent_continuation'
| 'external_event';
+export type SubagentExternalEventDetails = {
+ eventType: string;
+ sourceType: string;
+ occurredAt: string;
+ expectedActionToolName?: string;
+};
+
/**
* One chronological child execution boundary. The trigger is host-authored,
* while activity and messages are bounded public projections of the child run.
@@ -133,6 +140,7 @@ export type SubagentThreadTurn = {
summary: string;
createdAt?: string;
summaryTruncated?: boolean;
+ externalEvent?: SubagentExternalEventDetails;
};
status: SubagentThreadStatus;
activity: SubagentActivityItem[];
@@ -165,5 +173,9 @@ export type SubagentThreadView = {
turns?: SubagentThreadTurn[];
messages: SubagentThreadMessage[];
historyTruncated: boolean;
+ /** True when some branch rows were omitted and cannot be recovered with `nextCursor`. */
+ historyUnavailable?: boolean;
+ /** Opaque task-message cursor for the next older bounded branch page. */
+ nextCursor?: string;
updatedAt?: string;
};
diff --git a/packages/data-schemas/src/methods/message.spec.ts b/packages/data-schemas/src/methods/message.spec.ts
index 5ca6d060cf..6732b3eb98 100644
--- a/packages/data-schemas/src/methods/message.spec.ts
+++ b/packages/data-schemas/src/methods/message.spec.ts
@@ -1092,6 +1092,81 @@ describe('Message Operations', () => {
expect(messages[0]).not.toHaveProperty('conversationId');
});
+ it('anchors older pages by an exact scoped message without exposing Mongo ids', async () => {
+ const conversationId = uuidv4();
+ for (let index = 0; index < 4; index += 1) {
+ await saveMessage(mockCtx, {
+ messageId: `task-${index}:assistant`,
+ conversationId,
+ text: `Answer ${index}`,
+ user: 'user123',
+ createdAt: new Date(Date.UTC(2026, 7, 21, 12, index)),
+ });
+ }
+ await saveMessage(mockCtx, {
+ messageId: 'foreign:user',
+ conversationId: uuidv4(),
+ text: 'Foreign anchor',
+ user: 'user123',
+ });
+
+ const page = await getMessagesForSubagentThreadView({
+ user: 'user123',
+ conversationId,
+ beforeMessageId: 'task-2:assistant',
+ limit: 2,
+ textCodePointLimit: 8_192,
+ });
+ const foreign = await getMessagesForSubagentThreadView({
+ user: 'user123',
+ conversationId,
+ beforeMessageId: 'foreign:user',
+ limit: 2,
+ textCodePointLimit: 8_192,
+ });
+
+ expect(page.map((message) => message.messageId)).toEqual([
+ 'task-2:assistant',
+ 'task-1:assistant',
+ ]);
+ expect(page[0]).not.toHaveProperty('_id');
+ expect(foreign).toEqual([]);
+ });
+
+ it('projects only the bounded display-safe external event identity', async () => {
+ const conversationId = uuidv4();
+ await saveMessage(mockCtx, {
+ messageId: 'event:user',
+ conversationId,
+ text: 'Private event payload',
+ user: 'user123',
+ subagentTriggerProjection: {
+ version: 1,
+ eventType: 'chess.turn.ready',
+ sourceType: 'speed-chess',
+ occurredAt: new Date('2026-08-21T12:00:00.000Z'),
+ expectedActionToolName: 'submit_move',
+ },
+ });
+
+ const [projected] = await getMessagesForSubagentThreadView({
+ user: 'user123',
+ conversationId,
+ limit: 1,
+ textCodePointLimit: 8_192,
+ });
+
+ expect(projected.subagentTriggerProjection).toEqual({
+ version: 1,
+ eventType: 'chess.turn.ready',
+ sourceType: 'speed-chess',
+ occurredAt: new Date('2026-08-21T12:00:00.000Z'),
+ expectedActionToolName: 'submit_move',
+ });
+ expect(projected.subagentTriggerProjection).not.toHaveProperty('deliveryId');
+ expect(projected.subagentTriggerProjection).not.toHaveProperty('sourceId');
+ });
+
it('projects bounded private transcripts for the retained linear history', async () => {
const conversationId = uuidv4();
await saveMessage(mockCtx, {
diff --git a/packages/data-schemas/src/methods/message.ts b/packages/data-schemas/src/methods/message.ts
index e03b40b21c..0c9a38755e 100644
--- a/packages/data-schemas/src/methods/message.ts
+++ b/packages/data-schemas/src/methods/message.ts
@@ -366,6 +366,7 @@ export type SubagentThreadViewMessageRecord = Pick<
| 'error'
| 'unfinished'
| 'subagentTranscript'
+ | 'subagentTriggerProjection'
> & {
textProjectionTruncated?: boolean;
subagentTranscriptProjectionTruncated?: boolean;
@@ -499,6 +500,7 @@ export interface MessageMethods {
conversationId: string;
tenantId?: string;
selectedTaskId?: string;
+ beforeMessageId?: string;
limit: number;
textCodePointLimit: number;
}): Promise<SubagentThreadViewMessageRecord[]>;
@@ -1462,6 +1464,7 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
conversationId: string;
tenantId?: string;
selectedTaskId?: string;
+ beforeMessageId?: string;
limit: number;
textCodePointLimit: number;
}): Promise<SubagentThreadViewMessageRecord[]> {
@@ -1855,6 +1858,36 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
],
},
subagentTask: boundedSubagentTask,
+ subagentTriggerProjection: {
+ $cond: [
+ { $eq: ['$subagentTriggerProjection.version', 1] },
+ {
+ version: 1,
+ eventType: boundedString(
+ '$subagentTriggerProjection.eventType',
+ SUBAGENT_MESSAGE_ACTIVITY_ID_CODE_POINT_LIMIT,
+ ),
+ sourceType: boundedString(
+ '$subagentTriggerProjection.sourceType',
+ SUBAGENT_MESSAGE_ACTIVITY_ID_CODE_POINT_LIMIT,
+ ),
+ occurredAt: '$subagentTriggerProjection.occurredAt',
+ expectedActionToolName: {
+ $cond: [
+ {
+ $eq: [{ $type: '$subagentTriggerProjection.expectedActionToolName' }, 'string'],
+ },
+ boundedString(
+ '$subagentTriggerProjection.expectedActionToolName',
+ SUBAGENT_MESSAGE_ACTIVITY_ID_CODE_POINT_LIMIT,
+ ),
+ '$$REMOVE',
+ ],
+ },
+ },
+ '$$REMOVE',
+ ],
+ },
};
const sourceMetadataProjection = {
_subagentTranscriptSourceBytes: transcriptJsonBytes,
@@ -1894,17 +1927,34 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
? { tenantId: { $exists: false } }
: { tenantId: input.tenantId }),
};
+ const anchor =
+ input.beforeMessageId == null
+ ? null
+ : await Message.findOne({ ...baseMatch, messageId: input.beforeMessageId })
+ .select('_id createdAt')
+ .lean<Pick<IMessage, '_id' | 'createdAt'>>();
+ if (input.beforeMessageId != null && anchor == null) return [];
+ const pageMatch =
+ anchor == null
+ ? baseMatch
+ : {
+ ...baseMatch,
+ $or: [
+ { createdAt: { $lt: anchor.createdAt } },
+ { createdAt: anchor.createdAt, _id: { $lte: anchor._id } },
+ ],
+ };
/** Keep rows as independent MongoDB results. A `$facet` would combine the
* complete page into one BSON document and could exceed MongoDB's 16 MiB
* document limit before the API applies its smaller public byte budget. */
const messagesPromise = Message.aggregate<SubagentThreadViewMessageRecord>([
- { $match: baseMatch },
+ { $match: pageMatch },
{ $sort: { createdAt: -1, _id: -1 } },
{ $limit: input.limit },
{ $project: boundedMessageProjection },
]);
const recentSourcesPromise = Message.aggregate<ActivitySourceProjection>([
- { $match: baseMatch },
+ { $match: pageMatch },
{ $sort: { createdAt: -1, _id: -1 } },
{ $limit: SUBAGENT_ACTIVITY_SOURCE_CANDIDATE_LIMIT },
{
diff --git a/packages/data-schemas/src/schema/message.ts b/packages/data-schemas/src/schema/message.ts
index 83775b7de4..b1ad4458eb 100644
--- a/packages/data-schemas/src/schema/message.ts
+++ b/packages/data-schemas/src/schema/message.ts
@@ -166,6 +166,19 @@ const messageSchema: Schema<IMessage> = new Schema(
select: false,
default: undefined,
},
+ /** Bounded, display-safe identity for an event-authored child turn. */
+ subagentTriggerProjection: {
+ type: {
+ version: { type: Number, enum: [1], required: true },
+ eventType: { type: String, required: true },
+ sourceType: { type: String, required: true },
+ occurredAt: { type: Date, required: true },
+ expectedActionToolName: { type: String },
+ },
+ _id: false,
+ select: false,
+ default: undefined,
+ },
/** Durable, server-only marker used to make detached retries at-most-once. */
subagentTask: {
type: {
diff --git a/packages/data-schemas/src/types/message.ts b/packages/data-schemas/src/types/message.ts
index f8a963911b..69fd580630 100644
--- a/packages/data-schemas/src/types/message.ts
+++ b/packages/data-schemas/src/types/message.ts
@@ -19,6 +19,14 @@ export type SubagentTaskControlReceiptStatus =
| 'rejected'
| 'failed';
+export type SubagentTriggerProjection = {
+ version: 1;
+ eventType: string;
+ sourceType: string;
+ occurredAt: Date;
+ expectedActionToolName?: string;
+};
+
/** Server-private durable receipt for one parent-to-child control invocation. */
export interface ISubagentTaskControlReceipt {
invocationId: string;
@@ -108,6 +116,7 @@ export interface IMessage extends Document {
};
controlReceipts?: ISubagentTaskControlReceipt[];
};
+ subagentTriggerProjection?: SubagentTriggerProjection;
contextMeta?: {
calibrationRatio?: number;
encoding?: string;