): string => {
+ if (key === 'com_ui_subagent_dialog_title') return `Agent ${values?.[0] ?? ''}`;
+ if (key === 'com_ui_subagent_complete') return 'Ran agent';
+ if (key === 'com_ui_subagent_activity') return 'Agent activity';
+ return key;
+ },
+}));
+
+jest.mock('~/Providers', () => ({ useAgentsMapContext: () => ({}) }));
+jest.mock('~/components/Share/MessageIcon', () => ({ __esModule: true, default: () => null }));
+jest.mock('~/hooks/MCP', () => ({ useMCPServerNames: () => [] }));
+
+jest.mock('./SubagentActivity', () => ({
+ __esModule: true,
+ default: ({
+ activity,
+ }: {
+ activity: { title: string; items: Array<{ type: string; text?: string }> };
+ }) => (
+
+ {activity.title}
+ {activity.items.map((item, index) => (
+ {item.text ?? item.type}
+ ))}
+
+ ),
+}));
+
+const persistedContent = (text: string): TMessageContentParts[] => [
+ { type: ContentTypes.TEXT, text } as TMessageContentParts,
+];
+
+const detachedOutput = JSON.stringify({
+ background_task_id: 'task-1',
+ subagent_thread_id: 'thread-1',
+ tool: 'subagent',
+ subagent_type: 'researcher',
+ status: 'running',
+ message:
+ 'Started subagent "researcher" background task. Poll the host background-task tool with background_task_id "task-1".',
+});
+
+function renderSharedCall(input: {
+ output?: string;
+ persistedContent?: TMessageContentParts[];
+ detached?: boolean;
+}) {
+ return render(
+
+
+
+
+
+
+
+ ,
+ );
+}
+
+describe('SharedSubagentActivityDialog', () => {
+ beforeEach(() => mockUseSubagentThreadQuery.mockClear());
+
+ it('opens readable foreground activity from the shared message payload and restores focus', async () => {
+ renderSharedCall({
+ output: 'Legacy fallback.',
+ persistedContent: persistedContent('Shared review complete.'),
+ });
+ const trigger = screen.getByRole('button', { name: 'Ran agent' });
+
+ fireEvent.click(trigger);
+
+ expect(screen.getByRole('dialog')).toBeInTheDocument();
+ expect(screen.getByText('Shared review complete.')).toBeInTheDocument();
+ fireEvent.click(screen.getByRole('button', { name: 'Close' }));
+ await waitFor(() => expect(trigger).toHaveFocus());
+ });
+
+ it('renders detached persisted activity without performing the private durable query', () => {
+ renderSharedCall({
+ output: detachedOutput,
+ persistedContent: persistedContent('Detached work survived refresh.'),
+ detached: true,
+ });
+
+ fireEvent.click(screen.getByRole('button', { name: 'Agent activity' }));
+
+ expect(screen.getByText('Detached work survived refresh.')).toBeInTheDocument();
+ expect(mockUseSubagentThreadQuery).not.toHaveBeenCalled();
+ });
+
+ it('makes a detached shared card without persisted activity explicitly noninteractive', () => {
+ renderSharedCall({ output: detachedOutput, detached: true });
+
+ expect(screen.getByRole('button', { name: 'Agent activity' })).toBeDisabled();
+ expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+ expect(mockUseSubagentThreadQuery).not.toHaveBeenCalled();
+ });
+});
diff --git a/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.tsx b/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.tsx
new file mode 100644
index 0000000000..9bcde4ab49
--- /dev/null
+++ b/client/src/components/Chat/Subagents/SharedSubagentActivityDialog.tsx
@@ -0,0 +1,74 @@
+import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useRecoilValue, useResetRecoilState } from 'recoil';
+import { OGDialog, OGDialogContent, OGDialogHeader, OGDialogTitle } from '@librechat/client';
+import { activeSubagentPanel } from '~/store/subagents';
+import { adaptLivePersistedActivity } from './adapters';
+import SubagentActivity from './SubagentActivity';
+import { useLocalize } from '~/hooks';
+
+/** Public-share fallback for subagent activity already embedded in the shared message payload. */
+export default function SharedSubagentActivityDialog({ shareId }: { shareId?: string }) {
+ const localize = useLocalize();
+ const selected = useRecoilValue(activeSubagentPanel);
+ const resetSelection = useResetRecoilState(activeSubagentPanel);
+ const selection = selected?.host === 'share' && selected.shareId === shareId ? selected : null;
+ const restoreSelectionRef = useRef(selection);
+ if (selection != null) restoreSelectionRef.current = selection;
+ const title =
+ selection?.subagentType === 'self'
+ ? localize('com_ui_subagent_dialog_title_self')
+ : localize('com_ui_subagent_dialog_title', { 0: selection?.subagentType ?? '' });
+ const activity = useMemo(
+ () =>
+ adaptLivePersistedActivity({
+ title,
+ prompt: selection?.prompt,
+ progress: null,
+ persistedContent: selection?.persistedContent,
+ legacyOutput: selection?.legacyOutput,
+ initialProgress: selection?.initialProgress ?? 1,
+ isSubmitting: false,
+ runStepStatus: selection?.runStepStatus,
+ approvalVisibility: 'hidden',
+ }),
+ [selection, title],
+ );
+
+ const restoreTriggerFocus = useCallback((event: Event) => {
+ event.preventDefault();
+ const selectionToRestore = restoreSelectionRef.current;
+ if (selectionToRestore == null) return;
+ requestAnimationFrame(() => {
+ const trigger = Array.from(
+ document.querySelectorAll('[data-subagent-tool-call]'),
+ ).find(
+ (element) =>
+ element.dataset.subagentToolCall === selectionToRestore.toolCallId &&
+ element.dataset.subagentParentMessage === selectionToRestore.parentMessageId &&
+ element.dataset.subagentPartIndex === String(selectionToRestore.partIndex),
+ );
+ trigger?.focus();
+ });
+ }, []);
+
+ useEffect(() => () => resetSelection(), [resetSelection]);
+ useEffect(() => {
+ if (selected?.host === 'share' && selected.shareId !== shareId) resetSelection();
+ }, [resetSelection, selected, shareId]);
+
+ return (
+ !open && resetSelection()}>
+
+
+
+ {activity.title}
+
+
+
+
+
+ );
+}
diff --git a/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx b/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx
index ede8983cfa..8cf79862af 100644
--- a/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx
+++ b/client/src/components/Chat/Subagents/SubagentThreadPanel.test.tsx
@@ -78,6 +78,7 @@ jest.mock('lucide-react', () => ({
}));
const selection: ActiveSubagentPanel = {
+ host: 'conversation',
parentConversationId: 'parent-conversation',
parentMessageId: 'parent-message',
toolCallId: 'tool-call',
@@ -179,6 +180,7 @@ describe('SubagentThreadPanel', () => {
isReadinessPending: false,
});
const foreground: ActiveSubagentPanel = {
+ host: 'conversation',
parentConversationId: 'parent-conversation',
parentMessageId: 'parent-message',
toolCallId: 'foreground-call',
diff --git a/client/src/components/Chat/Subagents/adapters.test.ts b/client/src/components/Chat/Subagents/adapters.test.ts
index 4eb639e8ff..273efb613a 100644
--- a/client/src/components/Chat/Subagents/adapters.test.ts
+++ b/client/src/components/Chat/Subagents/adapters.test.ts
@@ -145,6 +145,34 @@ describe('child activity adapters', () => {
);
});
+ it('keeps shared-message activity read-only by omitting approval controls', () => {
+ const activity = adaptLivePersistedActivity({
+ title: 'researcher',
+ progress: null,
+ persistedContent: [
+ {
+ type: ContentTypes.TOOL_CALL,
+ [ContentTypes.TOOL_CALL]: {
+ id: 'tool',
+ name: 'protected_tool',
+ args: '{}',
+ output: '',
+ progress: 0.1,
+ approval: { expires_at: 123 },
+ },
+ },
+ ] as unknown as TMessageContentParts[],
+ initialProgress: 1,
+ isSubmitting: false,
+ approvalVisibility: 'hidden',
+ });
+
+ expect(activity.items[0]).toEqual(
+ expect.objectContaining({ type: 'tool', name: 'protected_tool' }),
+ );
+ expect(activity.items[0]).not.toHaveProperty('approval');
+ });
+
it('uses the exact assistant row as terminal authority for an older API response', () => {
const oldView = {
threadId: 'thread',
diff --git a/client/src/components/Chat/Subagents/adapters.ts b/client/src/components/Chat/Subagents/adapters.ts
index baa0231089..55452a82f4 100644
--- a/client/src/components/Chat/Subagents/adapters.ts
+++ b/client/src/components/Chat/Subagents/adapters.ts
@@ -52,6 +52,7 @@ type ContentToolCall = {
const contentPartsToActivity = (
parts: TMessageContentParts[],
reasoningVisibility: 'visible' | 'marker',
+ approvalVisibility: 'visible' | 'hidden',
): ChildActivityItem[] =>
parts.flatMap((part, index): ChildActivityItem[] => {
if (part.type === ContentTypes.TEXT) {
@@ -85,7 +86,9 @@ const contentPartsToActivity = (
...(tool.args == null ? {} : { input: tool.args }),
...(tool.output == null ? {} : { output: tool.output }),
status: runStepStatus ?? (completed ? 'completed' : 'running'),
- ...(tool.approval == null ? {} : { approval: tool.approval }),
+ ...(tool.approval == null || approvalVisibility === 'hidden'
+ ? {}
+ : { approval: tool.approval }),
},
];
});
@@ -129,11 +132,16 @@ export function adaptLivePersistedActivity(input: {
isSubmitting: boolean;
runStepStatus?: PartMetadata['runStepStatus'];
reasoningVisibility?: 'visible' | 'marker';
+ approvalVisibility?: 'visible' | 'hidden';
}): ChildActivity {
const persisted = input.persistedContent ?? [];
const live = (input.progress?.contentParts ?? []) as TMessageContentParts[];
const parts = persisted.length > 0 ? persisted : live;
- const items = contentPartsToActivity(parts, input.reasoningVisibility ?? 'visible');
+ const items = contentPartsToActivity(
+ parts,
+ input.reasoningVisibility ?? 'visible',
+ input.approvalVisibility ?? 'visible',
+ );
if (items.length === 0 && input.legacyOutput != null && input.legacyOutput !== '') {
items.push({ type: 'writing', text: input.legacyOutput });
}
diff --git a/client/src/components/Share/ShareView.tsx b/client/src/components/Share/ShareView.tsx
index 4d5f0c2a6a..c76bdf4566 100644
--- a/client/src/components/Share/ShareView.tsx
+++ b/client/src/components/Share/ShareView.tsx
@@ -19,6 +19,7 @@ import {
TooltipAnchor,
useToastContext,
} from '@librechat/client';
+import SharedSubagentActivityDialog from '~/components/Chat/Subagents/SharedSubagentActivityDialog';
import { cn, DEFAULT_APP_TITLE, getResponseStatus, selectActiveBranchTail } from '~/utils';
import { ThemeSelector, LangSelector } from '~/components/Appearance';
import { ShareMessagesProvider } from './ShareMessagesProvider';
@@ -239,6 +240,7 @@ function SharedView() {
{artifactsContainer}
+
);
}
diff --git a/client/src/store/subagents.ts b/client/src/store/subagents.ts
index 26369a77d6..8f6d93ef8f 100644
--- a/client/src/store/subagents.ts
+++ b/client/src/store/subagents.ts
@@ -46,6 +46,8 @@ export interface SubagentProgress {
/** One child invocation selected for the shared read-only activity panel. */
export type ActiveSubagentPanel = {
+ host: 'conversation' | 'share';
+ shareId?: string;
parentConversationId: string;
parentMessageId: string;
toolCallId: string;
diff --git a/packages/api/src/agents/view.spec.ts b/packages/api/src/agents/view.spec.ts
index f16f5b9c64..9849af90e4 100644
--- a/packages/api/src/agents/view.spec.ts
+++ b/packages/api/src/agents/view.spec.ts
@@ -5,6 +5,7 @@ import { createSubagentThreadViewHandler, SUBAGENT_THREAD_VIEW_LIMITS } from './
jest.mock('@librechat/data-schemas', () => ({
CLIENT_MESSAGE_SELECT: '-_id -user',
+ SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT: 256 * 1024,
logger: { error: jest.fn() },
}));
@@ -259,6 +260,34 @@ describe('subagent thread parent-scoped view', () => {
expect(JSON.stringify(json.mock.calls[0][0])).not.toContain('Wrong task.');
});
+ it('falls back to the bounded final message when storage omits an oversized transcript', async () => {
+ const selected = {
+ ...message('task-1:assistant', 'completed'),
+ text: 'The bounded final answer.',
+ subagentTranscriptProjectionTruncated: true,
+ } as IMessage & { subagentTranscriptProjectionTruncated: boolean };
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership: jest.fn().mockResolvedValue(parent),
+ getSubagentThreadForParent: jest
+ .fn()
+ .mockResolvedValue({ ...child, subagentThreadLease: undefined }),
+ getMessagesForSubagentThreadView: jest.fn().mockResolvedValue([selected]),
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest({}, { taskId: 'task-1' }), response);
+
+ const view = json.mock.calls[0][0];
+ expect(view).toEqual(
+ expect.objectContaining({
+ activity: [],
+ activityTruncated: true,
+ messages: [expect.objectContaining({ text: 'The bounded final answer.' })],
+ }),
+ );
+ expect(JSON.stringify(view)).not.toContain('subagentTranscript');
+ });
+
it('bounds the complete UTF-8 response while retaining the newest history', async () => {
const getConvoOwnership = jest.fn().mockResolvedValue(parent);
const messages = Array.from(
diff --git a/packages/api/src/agents/view.ts b/packages/api/src/agents/view.ts
index a850a77aa1..92503a3240 100644
--- a/packages/api/src/agents/view.ts
+++ b/packages/api/src/agents/view.ts
@@ -1,4 +1,4 @@
-import { logger } from '@librechat/data-schemas';
+import { logger, SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT } from '@librechat/data-schemas';
import type {
ConversationMethods,
MessageMethods,
@@ -204,23 +204,30 @@ export function createSubagentThreadViewHandler(deps: SubagentThreadViewDependen
child.subagentThreadLease != null && child.subagentThreadLease.expiresAt > now
? child.subagentThreadLease.taskId
: undefined;
- const selectedTranscript =
+ const selectedMessage =
requestedTaskId == null
? undefined
- : newestFirst.find((message) => message.messageId === `${requestedTaskId}:assistant`)
- ?.subagentTranscript;
+ : newestFirst.find((message) => message.messageId === `${requestedTaskId}:assistant`);
+ const selectedTranscript = selectedMessage?.subagentTranscript;
const selectedInput =
requestedTaskId == null
? undefined
: newestFirst.find((message) => message.messageId === `${requestedTaskId}:user`);
- const projectedActivity =
- selectedTranscript != null && selectedTranscript.taskId === requestedTaskId
- ? projectSubagentActivity(
- selectedTranscript.messagesJson,
- selectedTranscript.mode,
- selectedInput?.textProjectionTruncated === true ? undefined : selectedInput?.text,
- )
- : { activity: [], truncated: selectedTranscript != null };
+ let projectedActivity: ReturnType = {
+ activity: [],
+ truncated: false,
+ };
+ if (selectedMessage?.subagentTranscriptProjectionTruncated === true) {
+ projectedActivity = { activity: [], truncated: true };
+ } else if (selectedTranscript != null && selectedTranscript.taskId === requestedTaskId) {
+ projectedActivity = projectSubagentActivity(
+ selectedTranscript.messagesJson,
+ selectedTranscript.mode,
+ selectedInput?.textProjectionTruncated === true ? undefined : selectedInput?.text,
+ );
+ } else if (selectedTranscript != null) {
+ projectedActivity = { activity: [], truncated: true };
+ }
const projectedNewestFirst: SubagentThreadMessage[] = [];
let remainingTextBytes = MAX_RESPONSE_TEXT_BYTES;
for (const message of newestFirst) {
@@ -272,6 +279,7 @@ export const SUBAGENT_THREAD_VIEW_LIMITS: Readonly<{
responseBytes: number;
activityItems: number;
activityBytes: number;
+ activitySourceBytes: number;
}> = {
messages: MAX_THREAD_MESSAGES,
messageTextBytes: MAX_MESSAGE_TEXT_BYTES,
@@ -279,4 +287,5 @@ export const SUBAGENT_THREAD_VIEW_LIMITS: Readonly<{
responseBytes: MAX_RESPONSE_BYTES,
activityItems: SUBAGENT_ACTIVITY_LIMITS.items,
activityBytes: SUBAGENT_ACTIVITY_LIMITS.bytes,
+ activitySourceBytes: SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT,
};
diff --git a/packages/data-schemas/src/index.ts b/packages/data-schemas/src/index.ts
index 9220c5f67a..b1a56dc206 100644
--- a/packages/data-schemas/src/index.ts
+++ b/packages/data-schemas/src/index.ts
@@ -8,6 +8,7 @@ export { createModels } from './models';
export {
createMethods,
CLIENT_MESSAGE_SELECT,
+ SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT,
RoleConflictError,
DEFAULT_REFRESH_TOKEN_EXPIRY,
DEFAULT_SESSION_EXPIRY,
diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.ts
index d90f48ed17..de61ec3e64 100644
--- a/packages/data-schemas/src/methods/index.ts
+++ b/packages/data-schemas/src/methods/index.ts
@@ -47,6 +47,7 @@ import { createConversationTagMethods, type ConversationTagMethods } from './con
import {
createMessageMethods,
CLIENT_MESSAGE_SELECT,
+ SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT,
type MessageMethods,
type SubagentThreadViewMessageRecord,
type SubagentTaskResultClaim,
@@ -146,7 +147,7 @@ export {
};
export { tokenValues, cacheTokenValues, premiumTokenValues, defaultRate, createTxMethods };
export { permissionBitSupersets };
-export { CLIENT_MESSAGE_SELECT };
+export { CLIENT_MESSAGE_SELECT, SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT };
export {
partitionIssues,
validateSkillName,
diff --git a/packages/data-schemas/src/methods/message.spec.ts b/packages/data-schemas/src/methods/message.spec.ts
index 390f5efcf1..30d3fe3105 100644
--- a/packages/data-schemas/src/methods/message.spec.ts
+++ b/packages/data-schemas/src/methods/message.spec.ts
@@ -3,7 +3,11 @@ import { v4 as uuidv4 } from 'uuid';
import { RetentionMode } from 'librechat-data-provider';
import { MongoMemoryServer } from 'mongodb-memory-server';
import type { IMessage } from '..';
-import { createMessageMethods, CLIENT_MESSAGE_SELECT } from './message';
+import {
+ createMessageMethods,
+ CLIENT_MESSAGE_SELECT,
+ SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT,
+} from './message';
import { tenantStorage, runAsSystem } from '~/config/tenantContext';
import { createModels } from '../models';
import logger from '~/config/winston';
@@ -750,6 +754,39 @@ describe('Message Operations', () => {
expect(messages[0]).toHaveProperty('messageId', 'task-a:assistant');
expect(messages[0]).toHaveProperty('subagentTranscript.taskId', 'task-a');
});
+
+ it('omits an oversized private transcript before returning the application result', async () => {
+ const conversationId = uuidv4();
+ await saveMessage(mockCtx, {
+ messageId: 'task-large:assistant',
+ conversationId,
+ text: 'The bounded public answer remains available.',
+ user: 'user123',
+ subagentTranscript: {
+ taskId: 'task-large',
+ mode: 'append',
+ messagesJson: JSON.stringify([
+ {
+ type: 'ai',
+ data: { content: 'x'.repeat(SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT + 1) },
+ },
+ ]),
+ },
+ });
+
+ const messages = await getMessagesForSubagentThreadView({
+ user: 'user123',
+ conversationId,
+ limit: 1,
+ textCodePointLimit: 8_192,
+ taskId: 'task-large',
+ });
+
+ expect(messages).toHaveLength(1);
+ expect(messages[0].text).toBe('The bounded public answer remains available.');
+ expect(messages[0]).not.toHaveProperty('subagentTranscript');
+ expect(messages[0].subagentTranscriptProjectionTruncated).toBe(true);
+ });
});
describe('deleteMessages', () => {
diff --git a/packages/data-schemas/src/methods/message.ts b/packages/data-schemas/src/methods/message.ts
index dd443669b6..4d466decdc 100644
--- a/packages/data-schemas/src/methods/message.ts
+++ b/packages/data-schemas/src/methods/message.ts
@@ -9,6 +9,14 @@ import logger from '~/config/winston';
/** Simple UUID v4 regex to replace zod validation */
const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Maximum private transcript JSON that may cross the MongoDB projection seam
+ * for the bounded public subagent-activity view. This gives the sanitizer
+ * enough source headroom while preventing multi-megabyte transcripts from
+ * being materialized merely to produce a 64 KiB public activity response.
+ */
+export const SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT: number = 256 * 1024;
+
/**
* Exclusion projection for message reads that feed the chat client (the
* conversation GET and shared-link reads). Every excluded field is either
@@ -63,7 +71,10 @@ export type SubagentThreadViewMessageRecord = Pick<
| 'error'
| 'subagentTranscript'
| 'subagentTask'
-> & { textProjectionTruncated?: boolean };
+> & {
+ textProjectionTruncated?: boolean;
+ subagentTranscriptProjectionTruncated?: boolean;
+};
export interface MessageMethods {
saveMessage(
@@ -751,6 +762,21 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
}): Promise {
try {
const Message = mongoose.models.Message as Model;
+ const selectedAssistantMessageId =
+ input.taskId == null ? undefined : `${input.taskId}:assistant`;
+ const transcriptJsonBytes = {
+ $strLenBytes: {
+ $convert: {
+ input: '$subagentTranscript.messagesJson',
+ to: 'string',
+ onError: '',
+ onNull: '',
+ },
+ },
+ };
+ const transcriptIsString = {
+ $eq: [{ $type: '$subagentTranscript.messagesJson' }, 'string'],
+ };
return await Message.aggregate([
{
$match: {
@@ -770,6 +796,16 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
},
{ $sort: { createdAt: -1, _id: -1 } },
{ $limit: input.limit },
+ ...(input.taskId == null
+ ? []
+ : [
+ {
+ $set: {
+ _subagentTranscriptSourceBytes: transcriptJsonBytes,
+ _subagentTranscriptSourceIsString: transcriptIsString,
+ },
+ },
+ ]),
{
$project: {
_id: 0,
@@ -789,8 +825,48 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
: {
subagentTranscript: {
$cond: [
- { $eq: ['$messageId', `${input.taskId}:assistant`] },
- '$subagentTranscript',
+ {
+ $and: [
+ { $eq: ['$messageId', selectedAssistantMessageId] },
+ '$_subagentTranscriptSourceIsString',
+ {
+ $lte: [
+ '$_subagentTranscriptSourceBytes',
+ SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT,
+ ],
+ },
+ ],
+ },
+ {
+ taskId: '$subagentTranscript.taskId',
+ mode: '$subagentTranscript.mode',
+ messagesJson: '$subagentTranscript.messagesJson',
+ },
+ '$$REMOVE',
+ ],
+ },
+ subagentTranscriptProjectionTruncated: {
+ $cond: [
+ {
+ $and: [
+ { $eq: ['$messageId', selectedAssistantMessageId] },
+ {
+ $ne: [{ $type: '$subagentTranscript.messagesJson' }, 'missing'],
+ },
+ {
+ $or: [
+ { $eq: ['$_subagentTranscriptSourceIsString', false] },
+ {
+ $gt: [
+ '$_subagentTranscriptSourceBytes',
+ SUBAGENT_TRANSCRIPT_SOURCE_BYTE_LIMIT,
+ ],
+ },
+ ],
+ },
+ ],
+ },
+ true,
'$$REMOVE',
],
},