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: Read Child Threads Through Their Parent (#15073)

Danny Avila634432b2ae1a
diff --git a/api/server/routes/__test-utils__/convos-route-mocks.js b/api/server/routes/__test-utils__/convos-route-mocks.js
index 5233d27ef0..b739ffb893 100644
--- a/api/server/routes/__test-utils__/convos-route-mocks.js
+++ b/api/server/routes/__test-utils__/convos-route-mocks.js
@@ -32,6 +32,7 @@ module.exports = {
});
return archiveAllHandler;
}),
+ createSubagentThreadViewHandler: jest.fn(() => (_req, res) => res.status(200).json({})),
deleteConvoSharedLinksWithCleanup: jest.fn(),
deleteAllSharedLinksWithCleanup: jest.fn(),
deleteAgentCheckpoints: jest.fn(),
diff --git a/api/server/routes/convos.js b/api/server/routes/convos.js
index e7ad4e26c8..e594cfff14 100644
--- a/api/server/routes/convos.js
+++ b/api/server/routes/convos.js
@@ -5,6 +5,7 @@ const {
isEnabled,
deleteAgentCheckpoints,
createArchiveAllHandler,
+ createSubagentThreadViewHandler,
resolveImportMaxFileSize,
restoreTenantContextFromReq,
deleteAllSharedLinksWithCleanup,
@@ -33,6 +34,11 @@ const assistantClients = {
const router = express.Router();
const archiveAllHandler = createArchiveAllHandler({ archiveAllConvos: db.archiveAllConvos });
+const subagentThreadViewHandler = createSubagentThreadViewHandler({
+ getConvoOwnership: db.getConvoOwnership,
+ getSubagentThreadForParent: db.getSubagentThreadForParent,
+ getMessagesForSubagentThreadView: db.getMessagesForSubagentThreadView,
+});
router.use(requireJwtAuth);
const isValidProjectFilter = (projectId) =>
@@ -79,6 +85,8 @@ router.get('/', async (req, res) => {
}
});
+router.get('/:parentConversationId/subagents/:threadId', subagentThreadViewHandler);
+
router.get('/:conversationId', async (req, res) => {
const { conversationId } = req.params;
const convo = await db.getConvo(req.user.id, conversationId);
diff --git a/packages/api/src/agents/index.ts b/packages/api/src/agents/index.ts
index 27dc43921c..765333ac25 100644
--- a/packages/api/src/agents/index.ts
+++ b/packages/api/src/agents/index.ts
@@ -51,5 +51,6 @@ export * from './triggers';
export * from './activityLabels';
export * from './activityPhases';
export * from './subagentDelivery';
+export * from './view';
export * from './reasoningLabels';
export * from './toolValidation';
diff --git a/packages/api/src/agents/view.spec.ts b/packages/api/src/agents/view.spec.ts
new file mode 100644
index 0000000000..dd3733288e
--- /dev/null
+++ b/packages/api/src/agents/view.spec.ts
@@ -0,0 +1,383 @@
+import type { IConversation, IMessage } from '@librechat/data-schemas';
+import type { Response } from 'express';
+import type { ServerRequest } from '~/types';
+import { createSubagentThreadViewHandler, SUBAGENT_THREAD_VIEW_LIMITS } from './view';
+
+jest.mock('@librechat/data-schemas', () => ({
+ CLIENT_MESSAGE_SELECT: '-_id -user',
+ logger: { error: jest.fn() },
+}));
+
+const parentConversationId = 'parent-conversation';
+const threadId = 'child-thread';
+
+const parent = {
+ conversationId: parentConversationId,
+ user: 'user-1',
+ tenantId: 'tenant-1',
+} as IConversation;
+
+const child = {
+ conversationId: threadId,
+ user: 'user-1',
+ tenantId: 'tenant-1',
+ title: 'Research child',
+ agent_id: 'agent-1',
+ updatedAt: new Date('2026-08-21T12:00:00.000Z'),
+ subagentThreadLease: {
+ token: 'lease-token',
+ taskId: 'task-1',
+ expiresAt: new Date('2099-08-21T12:00:00.000Z'),
+ },
+ subagentThread: {
+ rootConversationId: parentConversationId,
+ parentConversationId,
+ parentMessageId: 'parent-message',
+ parentToolCallId: 'parent-tool-call',
+ subagentType: 'researcher',
+ subagentKind: 'agent',
+ depth: 1,
+ },
+} as IConversation;
+
+const message = (
+ messageId: string,
+ status: NonNullable<IMessage['subagentTask']>['status'],
+ isCreatedByUser = false,
+): IMessage =>
+ ({
+ messageId,
+ conversationId: threadId,
+ user: 'user-1',
+ parentMessageId: isCreatedByUser ? '00000000-0000-0000-0000-000000000000' : 'task-1:user',
+ sender: isCreatedByUser ? 'User' : 'researcher',
+ text: isCreatedByUser ? 'Investigate this.' : 'Finished the research.',
+ isCreatedByUser,
+ createdAt: new Date(isCreatedByUser ? '2026-08-21T11:00:00.000Z' : '2026-08-21T11:01:00.000Z'),
+ subagentTask: {
+ attemptKey: 'attempt-1',
+ status,
+ },
+ }) as IMessage;
+
+const createResponse = () => {
+ const json = jest.fn();
+ const status = jest.fn(() => ({ json }));
+ return {
+ response: { status } as unknown as Response,
+ status,
+ json,
+ };
+};
+
+const createRequest = (params: Record<string, string> = {}): ServerRequest =>
+ ({
+ params: { parentConversationId, threadId, ...params },
+ user: { id: 'user-1', tenantId: 'tenant-1' },
+ }) as ServerRequest;
+
+describe('subagent thread parent-scoped view', () => {
+ it('returns a bounded public child projection through the owning parent', async () => {
+ const getConvoOwnership = jest.fn().mockResolvedValue(parent);
+ const newest = {
+ ...message('task-1:assistant', 'completed'),
+ text: 'a'.repeat(SUBAGENT_THREAD_VIEW_LIMITS.messageTextBytes / 4),
+ textProjectionTruncated: true,
+ } as IMessage & { textProjectionTruncated: boolean };
+ const getMessages = jest
+ .fn()
+ .mockResolvedValue([newest, message('task-1:user', 'running', true)]);
+ const getSubagentThreadForParent = jest.fn().mockResolvedValue(child);
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership,
+ getSubagentThreadForParent,
+ getMessagesForSubagentThreadView: getMessages,
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest(), response);
+
+ expect(getMessages).toHaveBeenCalledWith({
+ conversationId: threadId,
+ user: 'user-1',
+ tenantId: 'tenant-1',
+ limit: SUBAGENT_THREAD_VIEW_LIMITS.messages + 1,
+ textCodePointLimit: SUBAGENT_THREAD_VIEW_LIMITS.messageTextBytes / 4,
+ });
+ expect(getConvoOwnership).toHaveBeenCalledWith('user-1', parentConversationId, 'tenant-1');
+ expect(json).toHaveBeenCalledWith({
+ threadId,
+ parentConversationId,
+ parentMessageId: 'parent-message',
+ parentToolCallId: 'parent-tool-call',
+ subagentType: 'researcher',
+ subagentKind: 'agent',
+ agentId: 'agent-1',
+ title: 'Research child',
+ status: 'completed',
+ messages: [
+ expect.objectContaining({ messageId: 'task-1:user', role: 'user' }),
+ expect.objectContaining({
+ messageId: 'task-1:assistant',
+ role: 'assistant',
+ textTruncated: true,
+ }),
+ ],
+ historyTruncated: false,
+ updatedAt: '2026-08-21T12:00:00.000Z',
+ });
+ expect(Buffer.byteLength(json.mock.calls[0][0].messages[1].text, 'utf8')).toBeLessThanOrEqual(
+ SUBAGENT_THREAD_VIEW_LIMITS.messageTextBytes,
+ );
+ expect(Buffer.byteLength(JSON.stringify(json.mock.calls[0][0]), 'utf8')).toBeLessThanOrEqual(
+ SUBAGENT_THREAD_VIEW_LIMITS.responseBytes,
+ );
+ expect(json.mock.calls[0][0].messages[1]).not.toHaveProperty('subagentTask');
+ });
+
+ it('bounds the complete UTF-8 response while retaining the newest history', async () => {
+ const getConvoOwnership = jest.fn().mockResolvedValue(parent);
+ const messages = Array.from(
+ { length: SUBAGENT_THREAD_VIEW_LIMITS.messages },
+ (_, index) =>
+ ({
+ ...message(`task-${index}:assistant`, 'completed'),
+ text: '🧵'.repeat(SUBAGENT_THREAD_VIEW_LIMITS.messageTextBytes),
+ }) as IMessage,
+ );
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership,
+ getSubagentThreadForParent: jest.fn().mockResolvedValue(child),
+ getMessagesForSubagentThreadView: jest.fn().mockResolvedValue(messages),
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest(), response);
+
+ const view = json.mock.calls[0][0];
+ expect(Buffer.byteLength(JSON.stringify(view), 'utf8')).toBeLessThanOrEqual(
+ SUBAGENT_THREAD_VIEW_LIMITS.responseBytes,
+ );
+ expect(view.historyTruncated).toBe(true);
+ expect(view.messages.at(-1).messageId).toBe('task-0:assistant');
+ });
+
+ it('requires tenantless messages when the authenticated request has no tenant', async () => {
+ const getMessages = jest.fn().mockResolvedValue([]);
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership: jest.fn().mockResolvedValue({ ...parent, tenantId: undefined }),
+ getSubagentThreadForParent: jest
+ .fn()
+ .mockResolvedValue({ ...child, tenantId: undefined, subagentThreadLease: undefined }),
+ getMessagesForSubagentThreadView: getMessages,
+ });
+ const { response } = createResponse();
+
+ await handler(
+ { ...createRequest(), user: { id: 'user-1', tenantId: undefined } } as ServerRequest,
+ response,
+ );
+
+ expect(getMessages).toHaveBeenCalledWith({
+ conversationId: threadId,
+ user: 'user-1',
+ limit: SUBAGENT_THREAD_VIEW_LIMITS.messages + 1,
+ textCodePointLimit: SUBAGENT_THREAD_VIEW_LIMITS.messageTextBytes / 4,
+ });
+ });
+
+ it.each([
+ ['running', 'running'],
+ ['error', 'failed'],
+ ['cancelled', 'cancelled'],
+ ] as const)('normalizes durable %s tasks as %s', async (durableStatus, publicStatus) => {
+ const getConvoOwnership = jest.fn().mockResolvedValue(parent);
+ const getMessages = jest
+ .fn()
+ .mockResolvedValue([
+ message(
+ durableStatus === 'running' ? 'task-1:user' : 'task-1:assistant',
+ durableStatus,
+ durableStatus === 'running',
+ ),
+ ]);
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership,
+ getSubagentThreadForParent: jest.fn().mockResolvedValue(child),
+ getMessagesForSubagentThreadView: getMessages,
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest(), response);
+
+ expect(json.mock.calls[0][0]).toEqual(expect.objectContaining({ status: publicStatus }));
+ });
+
+ it('reports a reserved child with no durable task messages as dispatched', async () => {
+ const getConvoOwnership = jest.fn().mockResolvedValue(parent);
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership,
+ getSubagentThreadForParent: jest
+ .fn()
+ .mockResolvedValue({ ...child, subagentThreadLease: undefined }),
+ getMessagesForSubagentThreadView: jest.fn().mockResolvedValue([]),
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest(), response);
+
+ expect(json.mock.calls[0][0]).toEqual(
+ expect.objectContaining({ status: 'dispatched', messages: [] }),
+ );
+ });
+
+ it('reports a child with an active preparation lease as running before its seed exists', async () => {
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership: jest.fn().mockResolvedValue(parent),
+ getSubagentThreadForParent: jest.fn().mockResolvedValue(child),
+ getMessagesForSubagentThreadView: jest.fn().mockResolvedValue([]),
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest(), response);
+
+ expect(json.mock.calls[0][0]).toEqual(
+ expect.objectContaining({ status: 'running', messages: [] }),
+ );
+ });
+
+ it('does not mistake an older completed turn for the active leased turn', async () => {
+ const activeChild = {
+ ...child,
+ subagentThreadLease: { ...child.subagentThreadLease!, taskId: 'task-2' },
+ } as IConversation;
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership: jest.fn().mockResolvedValue(parent),
+ getSubagentThreadForParent: jest.fn().mockResolvedValue(activeChild),
+ getMessagesForSubagentThreadView: jest
+ .fn()
+ .mockResolvedValue([message('task-1:assistant', 'completed')]),
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest(), response);
+
+ expect(json.mock.calls[0][0]).toEqual(expect.objectContaining({ status: 'running' }));
+ });
+
+ it('keeps the newest bounded tail and marks older history as truncated', async () => {
+ const getConvoOwnership = jest.fn().mockResolvedValue(parent);
+ const messages = Array.from({ length: SUBAGENT_THREAD_VIEW_LIMITS.messages + 1 }, (_, index) =>
+ message(`task-${index}:assistant`, 'completed'),
+ );
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership,
+ getSubagentThreadForParent: jest.fn().mockResolvedValue(child),
+ getMessagesForSubagentThreadView: jest.fn().mockResolvedValue(messages),
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest(), response);
+
+ const view = json.mock.calls[0][0];
+ expect(view.historyTruncated).toBe(true);
+ expect(view.messages).toHaveLength(SUBAGENT_THREAD_VIEW_LIMITS.messages);
+ expect(view.messages[0].messageId).toBe(
+ `task-${SUBAGENT_THREAD_VIEW_LIMITS.messages - 1}:assistant`,
+ );
+ expect(view.messages.at(-1).messageId).toBe('task-0:assistant');
+ });
+
+ it.each([
+ ['missing parent', null, child, 'tenant-1'],
+ ['missing child', parent, null, 'tenant-1'],
+ [
+ 'unrelated child',
+ parent,
+ {
+ ...child,
+ subagentThread: { ...child.subagentThread, parentConversationId: 'another-parent' },
+ },
+ 'tenant-1',
+ ],
+ ['parent tenant mismatch', { ...parent, tenantId: 'tenant-2' }, child, 'tenant-1'],
+ ['child tenant mismatch', parent, { ...child, tenantId: 'tenant-2' }, 'tenant-1'],
+ ])('returns the same 404 for %s', async (_, parentRecord, childRecord, tenantId) => {
+ const getConvoOwnership = jest.fn().mockResolvedValue(parentRecord);
+ const getMessages = jest.fn().mockResolvedValue([message('task-1:assistant', 'completed')]);
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership,
+ getSubagentThreadForParent: jest.fn().mockResolvedValue(childRecord),
+ getMessagesForSubagentThreadView: getMessages,
+ });
+ const { response, status, json } = createResponse();
+
+ await handler(
+ {
+ ...createRequest(),
+ user: { id: 'user-1', tenantId },
+ } as ServerRequest,
+ response,
+ );
+
+ expect(status).toHaveBeenCalledWith(404);
+ expect(json).toHaveBeenCalledWith({ error: 'Conversation not found' });
+ expect(getMessages).not.toHaveBeenCalled();
+ });
+
+ it('rejects a child id used as its own parent before reading storage', async () => {
+ const getConvoOwnership = jest.fn();
+ const getSubagentThreadForParent = jest.fn();
+ const getMessages = jest.fn();
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership,
+ getSubagentThreadForParent,
+ getMessagesForSubagentThreadView: getMessages,
+ });
+ const { response, status } = createResponse();
+
+ await handler(createRequest({ parentConversationId: threadId }), response);
+
+ expect(status).toHaveBeenCalledWith(404);
+ expect(getConvoOwnership).not.toHaveBeenCalled();
+ expect(getSubagentThreadForParent).not.toHaveBeenCalled();
+ expect(getMessages).not.toHaveBeenCalled();
+ });
+
+ it('rejects oversized route identifiers before reading storage', async () => {
+ const getConvoOwnership = jest.fn();
+ const getSubagentThreadForParent = jest.fn();
+ const getMessages = jest.fn();
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership,
+ getSubagentThreadForParent,
+ getMessagesForSubagentThreadView: getMessages,
+ });
+ const { response, status } = createResponse();
+
+ await handler(createRequest({ threadId: 'x'.repeat(257) }), response);
+
+ expect(status).toHaveBeenCalledWith(404);
+ expect(getConvoOwnership).not.toHaveBeenCalled();
+ expect(getSubagentThreadForParent).not.toHaveBeenCalled();
+ expect(getMessages).not.toHaveBeenCalled();
+ });
+
+ it('marks an unleased running seed as interrupted', async () => {
+ const getConvoOwnership = jest.fn().mockResolvedValue(parent);
+ const handler = createSubagentThreadViewHandler({
+ getConvoOwnership,
+ getSubagentThreadForParent: jest
+ .fn()
+ .mockResolvedValue({ ...child, subagentThreadLease: undefined }),
+ getMessagesForSubagentThreadView: jest
+ .fn()
+ .mockResolvedValue([message('task-1:user', 'running', true)]),
+ });
+ const { response, json } = createResponse();
+
+ await handler(createRequest(), response);
+
+ expect(json.mock.calls[0][0]).toEqual(expect.objectContaining({ status: 'interrupted' }));
+ });
+});
diff --git a/packages/api/src/agents/view.ts b/packages/api/src/agents/view.ts
new file mode 100644
index 0000000000..f821de020b
--- /dev/null
+++ b/packages/api/src/agents/view.ts
@@ -0,0 +1,242 @@
+import { logger } from '@librechat/data-schemas';
+import type {
+ ConversationMethods,
+ MessageMethods,
+ SubagentThreadViewMessageRecord,
+} from '@librechat/data-schemas';
+import type {
+ SubagentThreadMessage,
+ SubagentThreadStatus,
+ SubagentThreadView,
+} from 'librechat-data-provider';
+import type { Response } from 'express';
+import type { ServerRequest } from '~/types';
+
+const MAX_THREAD_MESSAGES = 50;
+const MAX_MESSAGE_TEXT_BYTES = 32 * 1024;
+// MongoDB slices by Unicode code points, so reserve the UTF-8 worst case and
+// keep the storage projection at or below the public byte ceiling.
+const MAX_MESSAGE_TEXT_PROJECTION_CODE_POINTS = Math.floor(MAX_MESSAGE_TEXT_BYTES / 4);
+const MAX_RESPONSE_TEXT_BYTES = 128 * 1024;
+const MAX_RESPONSE_BYTES = 160 * 1024;
+const MAX_PUBLIC_ID_BYTES = 512;
+const MAX_TITLE_BYTES = 1024;
+type SubagentThreadViewDependencies = Pick<
+ ConversationMethods,
+ 'getConvoOwnership' | 'getSubagentThreadForParent'
+> &
+ Pick<MessageMethods, 'getMessagesForSubagentThreadView'>;
+
+type SubagentThreadViewParams = {
+ parentConversationId?: string;
+ threadId?: string;
+};
+
+const validConversationId = (value: string | undefined): value is string =>
+ value != null && value.trim() !== '' && value.length <= 256;
+
+const tenantMatches = (recordTenantId: string | undefined, requestTenantId: string | undefined) =>
+ recordTenantId === requestTenantId;
+
+const isoDate = (value: Date | string | undefined): string | undefined => {
+ if (value == null) {
+ return undefined;
+ }
+ return value instanceof Date ? value.toISOString() : value;
+};
+
+const truncateUtf8 = (
+ input: string,
+ byteLimit: number,
+): { text: string; truncated: boolean; bytes: number } => {
+ const inputBytes = Buffer.byteLength(input, 'utf8');
+ if (inputBytes <= byteLimit) {
+ return { text: input, truncated: false, bytes: inputBytes };
+ }
+ let low = 0;
+ let high = input.length;
+ while (low < high) {
+ const middle = Math.ceil((low + high) / 2);
+ if (Buffer.byteLength(input.slice(0, middle), 'utf8') <= byteLimit) {
+ low = middle;
+ } else {
+ high = middle - 1;
+ }
+ }
+ let end = low;
+ if (end > 0 && /[\uD800-\uDBFF]/.test(input[end - 1])) {
+ end -= 1;
+ }
+ const text = input.slice(0, end);
+ return { text, truncated: true, bytes: Buffer.byteLength(text, 'utf8') };
+};
+
+const publicMessage = (
+ message: SubagentThreadViewMessageRecord,
+ byteLimit: number,
+): { message: SubagentThreadMessage; bytes: number } => {
+ const text = message.text ?? '';
+ const projected = truncateUtf8(text, Math.min(MAX_MESSAGE_TEXT_BYTES, byteLimit));
+ return {
+ message: {
+ messageId: truncateUtf8(message.messageId, MAX_PUBLIC_ID_BYTES).text,
+ parentMessageId:
+ message.parentMessageId == null
+ ? null
+ : truncateUtf8(message.parentMessageId, MAX_PUBLIC_ID_BYTES).text,
+ role: message.isCreatedByUser ? 'user' : 'assistant',
+ text: projected.text,
+ ...(isoDate(message.createdAt) == null ? {} : { createdAt: isoDate(message.createdAt) }),
+ ...(message.error === true ? { error: true } : {}),
+ ...(message.textProjectionTruncated === true || projected.truncated
+ ? { textTruncated: true }
+ : {}),
+ },
+ bytes: projected.bytes,
+ };
+};
+
+const publicStatus = (
+ messages: SubagentThreadViewMessageRecord[],
+ activeLeaseTaskId: string | undefined,
+): SubagentThreadStatus => {
+ if (activeLeaseTaskId != null) {
+ const activeTaskMessage = messages.find(
+ (message) =>
+ message.messageId === `${activeLeaseTaskId}:user` ||
+ message.messageId === `${activeLeaseTaskId}:assistant`,
+ );
+ if (
+ activeTaskMessage?.subagentTask?.status == null ||
+ activeTaskMessage.subagentTask.status === 'running'
+ ) {
+ return 'running';
+ }
+ return publicStatus([activeTaskMessage], undefined);
+ }
+ const message = messages.find((candidate) => candidate.subagentTask != null);
+ switch (message?.subagentTask?.status) {
+ case 'running':
+ return 'interrupted';
+ case 'completed':
+ return 'completed';
+ case 'error':
+ return 'failed';
+ case 'cancelled':
+ return 'cancelled';
+ default:
+ return 'dispatched';
+ }
+};
+
+const notFound = (res: Response): void => {
+ res.status(404).json({ error: 'Conversation not found' });
+};
+
+/** Reads one durable child through its parent without reopening ordinary conversation reads. */
+export function createSubagentThreadViewHandler(deps: SubagentThreadViewDependencies) {
+ return async (req: ServerRequest, res: Response): Promise<void> => {
+ const userId = req.user?.id;
+ const tenantId = req.user?.tenantId || undefined;
+ const { parentConversationId, threadId } = req.params as SubagentThreadViewParams;
+ if (
+ !userId ||
+ !validConversationId(parentConversationId) ||
+ !validConversationId(threadId) ||
+ parentConversationId === threadId
+ ) {
+ notFound(res);
+ return;
+ }
+
+ try {
+ const now = new Date();
+ const [parent, child] = await Promise.all([
+ deps.getConvoOwnership(userId, parentConversationId, tenantId ?? null),
+ deps.getSubagentThreadForParent({
+ user: userId,
+ parentConversationId,
+ conversationId: threadId,
+ ...(tenantId == null ? {} : { tenantId }),
+ }),
+ ]);
+ const lineage = child?.subagentThread;
+ const authorized =
+ parent != null &&
+ child != null &&
+ lineage != null &&
+ lineage.parentConversationId === parentConversationId &&
+ tenantMatches(parent.tenantId, tenantId) &&
+ tenantMatches(child.tenantId, tenantId);
+ if (!authorized || lineage == null || child == null) {
+ notFound(res);
+ return;
+ }
+
+ const messages = await deps.getMessagesForSubagentThreadView({
+ conversationId: threadId,
+ user: userId,
+ ...(tenantId == null ? {} : { tenantId }),
+ limit: MAX_THREAD_MESSAGES + 1,
+ textCodePointLimit: MAX_MESSAGE_TEXT_PROJECTION_CODE_POINTS,
+ });
+
+ const historyTruncated = messages.length > MAX_THREAD_MESSAGES;
+ const newestFirst = historyTruncated ? messages.slice(0, MAX_THREAD_MESSAGES) : messages;
+ const activeLeaseTaskId =
+ child.subagentThreadLease != null && child.subagentThreadLease.expiresAt > now
+ ? child.subagentThreadLease.taskId
+ : undefined;
+ const projectedNewestFirst: SubagentThreadMessage[] = [];
+ let remainingTextBytes = MAX_RESPONSE_TEXT_BYTES;
+ for (const message of newestFirst) {
+ if (remainingTextBytes === 0) {
+ break;
+ }
+ const projected = publicMessage(message, remainingTextBytes);
+ projectedNewestFirst.push(projected.message);
+ remainingTextBytes -= projected.bytes;
+ }
+ const view: SubagentThreadView = {
+ threadId,
+ parentConversationId,
+ parentMessageId: truncateUtf8(lineage.parentMessageId, MAX_PUBLIC_ID_BYTES).text,
+ parentToolCallId: truncateUtf8(lineage.parentToolCallId, MAX_PUBLIC_ID_BYTES).text,
+ subagentType: truncateUtf8(lineage.subagentType, MAX_PUBLIC_ID_BYTES).text,
+ subagentKind: lineage.subagentKind,
+ ...(child.agent_id == null
+ ? {}
+ : { agentId: truncateUtf8(child.agent_id, MAX_PUBLIC_ID_BYTES).text }),
+ title: truncateUtf8(child.title ?? `Subagent: ${lineage.subagentType}`, MAX_TITLE_BYTES)
+ .text,
+ status: publicStatus(newestFirst, activeLeaseTaskId),
+ messages: projectedNewestFirst.reverse(),
+ historyTruncated: historyTruncated || projectedNewestFirst.length < newestFirst.length,
+ ...(isoDate(child.updatedAt) == null ? {} : { updatedAt: isoDate(child.updatedAt) }),
+ };
+ while (Buffer.byteLength(JSON.stringify(view), 'utf8') > MAX_RESPONSE_BYTES) {
+ if (view.messages.length === 0) {
+ throw new Error('Subagent thread projection exceeded its response limit');
+ }
+ view.messages.shift();
+ view.historyTruncated = true;
+ }
+ res.status(200).json(view);
+ } catch (error) {
+ logger.error('[subagentThreads] Failed to read child thread through parent', error);
+ res.status(500).json({ error: 'Failed to load subagent thread' });
+ }
+ };
+}
+
+export const SUBAGENT_THREAD_VIEW_LIMITS: Readonly<{
+ messages: number;
+ messageTextBytes: number;
+ responseTextBytes: number;
+ responseBytes: number;
+}> = {
+ messages: MAX_THREAD_MESSAGES,
+ messageTextBytes: MAX_MESSAGE_TEXT_BYTES,
+ responseTextBytes: MAX_RESPONSE_TEXT_BYTES,
+ responseBytes: MAX_RESPONSE_BYTES,
+};
diff --git a/packages/data-provider/src/api-endpoints.ts b/packages/data-provider/src/api-endpoints.ts
index 80acb4990a..7eb3c25a31 100644
--- a/packages/data-provider/src/api-endpoints.ts
+++ b/packages/data-provider/src/api-endpoints.ts
@@ -116,6 +116,9 @@ export const conversations = (params: q.ConversationListParams) => {
export const conversationById = (id: string) => `${conversationsRoot}/${id}`;
+export const subagentThread = (parentConversationId: string, threadId: string) =>
+ `${conversationsRoot}/${encodeURIComponent(parentConversationId)}/subagents/${encodeURIComponent(threadId)}`;
+
export const genTitle = (conversationId: string) =>
`${conversationsRoot}/gen_title/${encodeURIComponent(conversationId)}`;
diff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.ts
index 89383f070b..2ab212cf8c 100644
--- a/packages/data-provider/src/data-service.ts
+++ b/packages/data-provider/src/data-service.ts
@@ -1002,6 +1002,13 @@ export function getMessagesByConvoId(conversationId: string): Promise<s.TMessage
return request.get(endpoints.messages({ conversationId }));
}
+export function getSubagentThread(
+ parentConversationId: string,
+ threadId: string,
+): Promise<t.SubagentThreadView> {
+ return request.get(endpoints.subagentThread(parentConversationId, threadId));
+}
+
export function getPrompt(id: string): Promise<{ prompt: t.TPrompt }> {
return request.get(endpoints.getPrompt(id));
}
diff --git a/packages/data-provider/src/index.ts b/packages/data-provider/src/index.ts
index dbe8b51764..f799c164e1 100644
--- a/packages/data-provider/src/index.ts
+++ b/packages/data-provider/src/index.ts
@@ -34,6 +34,7 @@ export * from './types/runs';
export * from './types/web';
export * from './types/graph';
export * from './types/insights';
+export * from './types/subagents';
/* access permissions */
export * from './accessPermissions';
/* query/mutation keys */
diff --git a/packages/data-provider/src/keys.ts b/packages/data-provider/src/keys.ts
index 8f7b8fa2e3..67f4a3a81f 100644
--- a/packages/data-provider/src/keys.ts
+++ b/packages/data-provider/src/keys.ts
@@ -93,6 +93,7 @@ export enum QueryKeys {
/* Scheduled chats */
schedules = 'schedules',
schedule = 'schedule',
+ subagentThread = 'subagentThread',
}
// Dynamic query keys that require parameters
diff --git a/packages/data-provider/src/types.ts b/packages/data-provider/src/types.ts
index 861c67fb3c..e2bcf99eec 100644
--- a/packages/data-provider/src/types.ts
+++ b/packages/data-provider/src/types.ts
@@ -17,6 +17,7 @@ import type { TMinimalFeedback } from './feedback';
import type { ContentTypes } from './types/runs';
export * from './schemas';
+export * from './types/subagents';
export type TMessages = TMessage[];
diff --git a/packages/data-provider/src/types/index.ts b/packages/data-provider/src/types/index.ts
index bd6e3ad79b..f8df4b0a1d 100644
--- a/packages/data-provider/src/types/index.ts
+++ b/packages/data-provider/src/types/index.ts
@@ -1,2 +1,3 @@
export * from './queries';
export * from './mcpServers';
+export * from './subagents';
diff --git a/packages/data-provider/src/types/subagents.ts b/packages/data-provider/src/types/subagents.ts
new file mode 100644
index 0000000000..fd35b67a98
--- /dev/null
+++ b/packages/data-provider/src/types/subagents.ts
@@ -0,0 +1,32 @@
+export type SubagentThreadStatus =
+ | 'dispatched'
+ | 'running'
+ | 'completed'
+ | 'failed'
+ | 'interrupted'
+ | 'cancelled';
+
+export type SubagentThreadMessage = {
+ messageId: string;
+ parentMessageId: string | null;
+ role: 'user' | 'assistant';
+ text: string;
+ createdAt?: string;
+ error?: boolean;
+ textTruncated?: boolean;
+};
+
+export type SubagentThreadView = {
+ threadId: string;
+ parentConversationId: string;
+ parentMessageId: string;
+ parentToolCallId: string;
+ subagentType: string;
+ subagentKind: 'agent' | 'graph';
+ agentId?: string;
+ title: string;
+ status: SubagentThreadStatus;
+ messages: SubagentThreadMessage[];
+ historyTruncated: boolean;
+ updatedAt?: string;
+};
diff --git a/packages/data-schemas/src/methods/conversation.spec.ts b/packages/data-schemas/src/methods/conversation.spec.ts
index 7323c12a06..3d1507286d 100644
--- a/packages/data-schemas/src/methods/conversation.spec.ts
+++ b/packages/data-schemas/src/methods/conversation.spec.ts
@@ -1490,6 +1490,7 @@ describe('Conversation Operations', () => {
await Conversation.create({
conversationId: mockConversationData.conversationId,
user: 'user123',
+ tenantId: 'tenant-a',
title: 'Test Conversation',
endpoint: EModelEndpoint.openAI,
});
@@ -1500,6 +1501,7 @@ describe('Conversation Operations', () => {
);
expect(result?.user).toBe('user123');
+ expect(result?.tenantId).toBe('tenant-a');
expect(result).not.toHaveProperty('title');
expect(result).not.toHaveProperty('messages');
expect(result).not.toHaveProperty('endpoint');
@@ -1544,6 +1546,36 @@ describe('Conversation Operations', () => {
});
expect(result).not.toHaveProperty('title');
});
+
+ it('selects the exact tenant when conversation identifiers collide', async () => {
+ await runAsSystem(async () => {
+ await Conversation.create([
+ {
+ conversationId: 'shared-conversation-id',
+ user: 'user123',
+ title: 'Tenantless parent',
+ endpoint: EModelEndpoint.agents,
+ },
+ {
+ conversationId: 'shared-conversation-id',
+ user: 'user123',
+ tenantId: 'tenant-a',
+ title: 'Tenant parent',
+ endpoint: EModelEndpoint.agents,
+ },
+ ]);
+ });
+
+ const tenantless = await methods.getConvoOwnership('user123', 'shared-conversation-id', null);
+ const tenant = await methods.getConvoOwnership(
+ 'user123',
+ 'shared-conversation-id',
+ 'tenant-a',
+ );
+
+ expect(tenantless?.tenantId).toBeUndefined();
+ expect(tenant?.tenantId).toBe('tenant-a');
+ });
});
describe('getConvoRetention', () => {
@@ -3396,6 +3428,72 @@ describe('Conversation Operations', () => {
expect(saved?.subagentThread).toEqual(lineage);
});
+ it('reads a child only through its exact parent and tenant with the private lease', async () => {
+ const parentConversationId = uuidv4();
+ const conversationId = uuidv4();
+ await Conversation.create([
+ {
+ conversationId: parentConversationId,
+ user: 'view-user',
+ tenantId: 'tenant-a',
+ endpoint: EModelEndpoint.agents,
+ },
+ {
+ conversationId,
+ user: 'view-user',
+ tenantId: 'tenant-a',
+ endpoint: EModelEndpoint.agents,
+ subagentThread: {
+ rootConversationId: parentConversationId,
+ parentConversationId,
+ parentMessageId: 'parent-message',
+ parentToolCallId: 'parent-tool',
+ subagentType: 'researcher',
+ subagentKind: 'agent',
+ depth: 1,
+ },
+ subagentThreadLease: {
+ token: 'private-token',
+ taskId: 'task-1',
+ expiresAt: new Date('2099-08-21T12:00:00.000Z'),
+ },
+ },
+ ]);
+
+ await expect(
+ methods.getSubagentThreadForParent({
+ user: 'view-user',
+ parentConversationId,
+ conversationId,
+ tenantId: 'tenant-a',
+ }),
+ ).resolves.toEqual(
+ expect.objectContaining({
+ conversationId,
+ subagentThreadLease: expect.objectContaining({ taskId: 'task-1' }),
+ }),
+ );
+ await expect(
+ methods.getSubagentThreadForParent({
+ user: 'view-user',
+ parentConversationId: 'another-parent',
+ conversationId,
+ tenantId: 'tenant-a',
+ }),
+ ).resolves.toBeNull();
+ await expect(
+ methods.getSubagentThreadForParent({
+ user: 'view-user',
+ parentConversationId,
+ conversationId,
+ tenantId: 'tenant-b',
+ }),
+ ).resolves.toBeNull();
+ expect(await methods.getConvo('view-user', conversationId)).not.toHaveProperty(
+ 'subagentThreadLease',
+ );
+ });
+
it('admits one cross-replica owner and fences renewal and release by token', async () => {
const conversationId = uuidv4();
await Conversation.create({
diff --git a/packages/data-schemas/src/methods/conversation.ts b/packages/data-schemas/src/methods/conversation.ts
index e44dabb10a..c821e89684 100644
--- a/packages/data-schemas/src/methods/conversation.ts
+++ b/packages/data-schemas/src/methods/conversation.ts
@@ -38,6 +38,17 @@ type ConversationUpdateResult = {
};
};
+export type SubagentThreadReadRecord = Pick<
+ IConversation,
+ | 'conversationId'
+ | 'tenantId'
+ | 'title'
+ | 'agent_id'
+ | 'updatedAt'
+ | 'subagentThread'
+ | 'subagentThreadLease'
+>;
+
const ARCHIVE_CONVERSATION_BATCH_SIZE = 500;
const PROJECT_STATS_REFRESH_CONCURRENCY = 10;
const PROJECT_STATS_REFRESH_MAX_PASSES = 2;
@@ -150,6 +161,12 @@ export interface ConversationMethods {
convoMap: Record<string, unknown>;
}>;
getConvo(user: string, conversationId: string): Promise<IConversation | null>;
+ getSubagentThreadForParent(input: {
+ user: string;
+ parentConversationId: string;
+ conversationId: string;
+ tenantId?: string;
+ }): Promise<SubagentThreadReadRecord | null>;
reserveSubagentThread(input: {
user: string;
conversationId: string;
@@ -192,7 +209,8 @@ export interface ConversationMethods {
getConvoOwnership(
user: string,
conversationId: string,
- ): Promise<Pick<IConversation, 'user' | 'subagentThread'> | null>;
+ tenantId?: string | null,
+ ): Promise<Pick<IConversation, 'user' | 'tenantId' | 'subagentThread'> | null>;
getConvoRetention(
user: string,
conversationId: string,
@@ -254,6 +272,31 @@ export function createConversationMethods(
}
}
+ /** Resolves a child only through its owning parent and includes its private live lease. */
+ async function getSubagentThreadForParent(input: {
+ user: string;
+ parentConversationId: string;
+ conversationId: string;
+ tenantId?: string;
+ }): Promise<SubagentThreadReadRecord | null> {
+ try {
+ const Conversation = mongoose.models.Conversation as Model<IConversation>;
+ return await Conversation.findOne({
+ user: input.user,
+ conversationId: input.conversationId,
+ 'subagentThread.parentConversationId': input.parentConversationId,
+ ...subagentLeaseTenantFilter(input.tenantId),
+ })
+ .select(
+ 'conversationId tenantId title agent_id updatedAt subagentThread +subagentThreadLease',
+ )
+ .lean<SubagentThreadReadRecord>();
+ } catch (error) {
+ logger.error('[getSubagentThreadForParent] Error getting child conversation', error);
+ throw new Error('Error getting child conversation');
+ }
+ }
+
/** Creates immutable child lineage exactly once without overwriting a concurrent winner. */
async function reserveSubagentThread(input: {
user: string;
@@ -436,12 +479,19 @@ export function createConversationMethods(
* without materializing the full conversation document (preset spread +
* message ObjectId array).
*/
- async function getConvoOwnership(user: string, conversationId: string) {
+ async function getConvoOwnership(user: string, conversationId: string, tenantId?: string | null) {
try {
const Conversation = mongoose.models.Conversation as Model<IConversation>;
- return await Conversation.findOne({ user, conversationId }, 'user subagentThread').lean<
- Pick<IConversation, 'user' | 'subagentThread'>
- >();
+ const tenantFilter =
+ tenantId === undefined ? {} : subagentLeaseTenantFilter(tenantId ?? undefined);
+ return await Conversation.findOne(
+ {
+ user,
+ conversationId,
+ ...tenantFilter,
+ },
+ 'user tenantId subagentThread',
+ ).lean<Pick<IConversation, 'user' | 'tenantId' | 'subagentThread'>>();
} catch (error) {
logger.error('[getConvoOwnership] Error checking conversation ownership', error);
throw new Error('Error checking conversation ownership');
@@ -1566,6 +1616,7 @@ export function createConversationMethods(
getConvosByCursor,
getConvosQueried,
getConvo,
+ getSubagentThreadForParent,
reserveSubagentThread,
acquireSubagentThreadLease,
renewSubagentThreadLease,
diff --git a/packages/data-schemas/src/methods/index.ts b/packages/data-schemas/src/methods/index.ts
index 1370343de3..d90f48ed17 100644
--- a/packages/data-schemas/src/methods/index.ts
+++ b/packages/data-schemas/src/methods/index.ts
@@ -48,6 +48,7 @@ import {
createMessageMethods,
CLIENT_MESSAGE_SELECT,
type MessageMethods,
+ type SubagentThreadViewMessageRecord,
type SubagentTaskResultClaim,
} from './message';
import { createConversationMethods, type ConversationMethods } from './conversation';
@@ -376,6 +377,7 @@ export type {
PresetMethods,
ConversationTagMethods,
MessageMethods,
+ SubagentThreadViewMessageRecord,
SubagentTaskResultClaim,
ConversationMethods,
ChatProjectMethods,
diff --git a/packages/data-schemas/src/methods/message.spec.ts b/packages/data-schemas/src/methods/message.spec.ts
index b94dd88528..57a495bb55 100644
--- a/packages/data-schemas/src/methods/message.spec.ts
+++ b/packages/data-schemas/src/methods/message.spec.ts
@@ -21,6 +21,9 @@ let mongoServer: InstanceType<typeof MongoMemoryServer>;
let Message: mongoose.Model<IMessage>;
let saveMessage: ReturnType<typeof createMessageMethods>['saveMessage'];
let getMessages: ReturnType<typeof createMessageMethods>['getMessages'];
+let getMessagesForSubagentThreadView: ReturnType<
+ typeof createMessageMethods
+>['getMessagesForSubagentThreadView'];
let updateMessage: ReturnType<typeof createMessageMethods>['updateMessage'];
let updateToolCallResult: ReturnType<typeof createMessageMethods>['updateToolCallResult'];
let deleteMessages: ReturnType<typeof createMessageMethods>['deleteMessages'];
@@ -44,6 +47,7 @@ beforeAll(async () => {
const methods = createMessageMethods(mongoose);
saveMessage = methods.saveMessage;
getMessages = methods.getMessages;
+ getMessagesForSubagentThreadView = methods.getMessagesForSubagentThreadView;
updateMessage = methods.updateMessage;
updateToolCallResult = methods.updateToolCallResult;
deleteMessages = methods.deleteMessages;
@@ -621,7 +625,7 @@ describe('Message Operations', () => {
it('declares the compound index that serves the conversation fetch and its sort', () => {
const indexes = Message.schema.indexes() as Array<[Record<string, number>, unknown]>;
expect(indexes).toContainEqual([
- { conversationId: 1, user: 1, createdAt: 1 },
+ { conversationId: 1, user: 1, createdAt: 1, _id: 1 },
expect.anything(),
]);
});
@@ -684,6 +688,32 @@ describe('Message Operations', () => {
});
});
+ describe('getMessagesForSubagentThreadView', () => {
+ it('bounds text in MongoDB before returning the public projection', async () => {
+ const conversationId = uuidv4();
+ await saveMessage(mockCtx, {
+ messageId: 'bounded-message',
+ conversationId,
+ text: '🧵'.repeat(20_000),
+ user: 'user123',
+ });
+
+ const messages = await getMessagesForSubagentThreadView({
+ user: 'user123',
+ conversationId,
+ limit: 1,
+ textCodePointLimit: 8_192,
+ });
+
+ expect(messages).toHaveLength(1);
+ expect(Array.from(messages[0].text ?? '')).toHaveLength(8_192);
+ expect(Buffer.byteLength(messages[0].text ?? '', 'utf8')).toBeLessThanOrEqual(32 * 1024);
+ expect(messages[0].textProjectionTruncated).toBe(true);
+ expect(messages[0]).not.toHaveProperty('user');
+ expect(messages[0]).not.toHaveProperty('conversationId');
+ });
+ });
+
describe('deleteMessages', () => {
it('should delete messages with the correct filter', async () => {
// Save some messages for different users
diff --git a/packages/data-schemas/src/methods/message.ts b/packages/data-schemas/src/methods/message.ts
index 500fb05ea6..a1f89f6ed6 100644
--- a/packages/data-schemas/src/methods/message.ts
+++ b/packages/data-schemas/src/methods/message.ts
@@ -53,6 +53,17 @@ export type SubagentTaskResultClaim =
| { status: 'claimed'; message: IMessage }
| { status: 'acquired'; message: IMessage };
+export type SubagentThreadViewMessageRecord = Pick<
+ IMessage,
+ | 'messageId'
+ | 'parentMessageId'
+ | 'isCreatedByUser'
+ | 'text'
+ | 'createdAt'
+ | 'error'
+ | 'subagentTask'
+> & { textProjectionTruncated?: boolean };
+
export interface MessageMethods {
saveMessage(
ctx: { userId: string; isTemporary?: boolean; interfaceConfig?: AppConfig['interfaceConfig'] },
@@ -110,6 +121,13 @@ export interface MessageMethods {
select?: string,
options?: MessageQueryOptions,
): Promise<IMessage[]>;
+ getMessagesForSubagentThreadView(input: {
+ user: string;
+ conversationId: string;
+ tenantId?: string;
+ limit: number;
+ textCodePointLimit: number;
+ }): Promise<SubagentThreadViewMessageRecord[]>;
getMessage(params: { user: string; messageId: string }): Promise<IMessage | null>;
getMessagesByCursor(
filter: FilterQuery<IMessage>,
@@ -717,6 +735,55 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
}
}
+ /**
+ * Reads the fixed public child-thread projection and truncates text inside
+ * MongoDB so oversized persisted messages are never materialized by the API.
+ */
+ async function getMessagesForSubagentThreadView(input: {
+ user: string;
+ conversationId: string;
+ tenantId?: string;
+ limit: number;
+ textCodePointLimit: number;
+ }): Promise<SubagentThreadViewMessageRecord[]> {
+ try {
+ const Message = mongoose.models.Message as Model<IMessage>;
+ return await Message.aggregate<SubagentThreadViewMessageRecord>([
+ {
+ $match: {
+ user: input.user,
+ conversationId: input.conversationId,
+ ...(input.tenantId == null
+ ? { tenantId: { $exists: false } }
+ : { tenantId: input.tenantId }),
+ },
+ },
+ { $sort: { createdAt: -1, _id: -1 } },
+ { $limit: input.limit },
+ {
+ $project: {
+ _id: 0,
+ messageId: 1,
+ parentMessageId: 1,
+ isCreatedByUser: 1,
+ text: {
+ $substrCP: [{ $ifNull: ['$text', ''] }, 0, input.textCodePointLimit],
+ },
+ textProjectionTruncated: {
+ $gt: [{ $strLenCP: { $ifNull: ['$text', ''] } }, input.textCodePointLimit],
+ },
+ createdAt: 1,
+ error: 1,
+ subagentTask: 1,
+ },
+ },
+ ]);
+ } catch (err) {
+ logger.error('Error getting bounded subagent thread messages:', err);
+ throw err;
+ }
+ }
+
/**
* Retrieves a single message from the database.
*/
@@ -806,6 +873,7 @@ export function createMessageMethods(mongoose: typeof import('mongoose')): Messa
releaseSubagentTaskResultClaim,
deleteMessagesSince,
getMessages,
+ getMessagesForSubagentThreadView,
getMessage,
getMessagesByCursor,
searchMessages,
diff --git a/packages/data-schemas/src/schema/message.ts b/packages/data-schemas/src/schema/message.ts
index 289b28b12d..a7ecf71faa 100644
--- a/packages/data-schemas/src/schema/message.ts
+++ b/packages/data-schemas/src/schema/message.ts
@@ -245,12 +245,13 @@ messageSchema.index({
/**
* Serves the conversation fetch ({conversationId, user} filter + createdAt
- * sort) from the index alone; without it Mongo fetches every full document in
- * the conversation and sorts them in memory. tenantId is deliberately not in
- * the middle: untenanted deployments issue no tenantId predicate, and a gap in
- * the prefix would push the sort back into memory for them.
+ * sort) and the deterministic child-thread view sort from the index alone;
+ * without it Mongo fetches every full document in the conversation and sorts
+ * them in memory. tenantId is deliberately not in the middle: untenanted
+ * deployments issue no tenantId predicate, and a gap in the prefix would push
+ * the sort back into memory for them.
*/
-messageSchema.index({ conversationId: 1, user: 1, createdAt: 1 });
+messageSchema.index({ conversationId: 1, user: 1, createdAt: 1, _id: 1 });
/** Bounds parent-run completion snapshots without scanning a user's message history. */
messageSchema.index(