diff --git a/api/server/controllers/agents/client.js b/api/server/controllers/agents/client.js index 142688d369..1a68393c4f 100644 --- a/api/server/controllers/agents/client.js +++ b/api/server/controllers/agents/client.js @@ -2907,7 +2907,7 @@ class AgentClient extends BaseClient { } } /** After the steer stamp, which adds replayed steers' documents of its own. */ - dedupeDocumentNames(payload); + dedupeDocumentNames(payload, agentsById.values()); if (hasFileContext) { for (let i = 0; i < orderedMessages.length; i++) { memoryPayload.push( diff --git a/api/server/controllers/agents/client.test.js b/api/server/controllers/agents/client.test.js index a22ebf9ef3..9b5cabe411 100644 --- a/api/server/controllers/agents/client.test.js +++ b/api/server/controllers/agents/client.test.js @@ -6485,7 +6485,87 @@ describe('AgentClient - titleConvo', () => { expect(client.publishRunContextMeta).toHaveBeenCalledTimes(expectSeed ? 1 : 0); }); - it('gives every resent document a unique name before formatting', async () => { + it.each([Providers.OPENAI, Providers.ANTHROPIC, Providers.GOOGLE])( + 'continues a large existing %s chat with a new short message', + async (provider) => { + client.options.agent.provider = provider; + client.agentConfigs = new Map([ + ['secondary-agent', { ...mockAgent, id: 'secondary-agent', provider: Providers.GOOGLE }], + ]); + const resolve = jest.fn(); + client.options.agent.lazySubagentConfigs = [ + { id: 'lazy-agent', provider: Providers.ANTHROPIC, configId: 'lazy-config', resolve }, + ]; + const history = Array.from({ length: 80 }, (_, index) => ({ + messageId: `history-${index}`, + parentMessageId: index === 0 ? null : `history-${index - 1}`, + sender: index % 2 === 0 ? 'User' : 'Assistant', + isCreatedByUser: index % 2 === 0, + content: Array.from({ length: 51 }, () => ({ type: ContentTypes.TEXT, text: 'ok' })), + })); + const latest = { + messageId: 'next-message', + parentMessageId: 'history-79', + sender: 'User', + isCreatedByUser: true, + text: 'x', + }; + const messages = [...history, latest]; + const original = structuredClone(messages); + client.setModelBoundStoredMessages(messages); + + const result = await client.buildMessages(messages, latest.messageId, {}, {}); + + expect(result.prompt).toHaveLength(messages.length); + expect(result.prompt.at(-1).content).toBe('x'); + expect(messages).toMatchObject(original); + expect(resolve).not.toHaveBeenCalled(); + }, + ); + + it.each([ + 'primary', + 'secondary', + 'nested subagent', + 'nested graph member', + 'lazy subagent', + 'nested lazy subagent', + 'lazy graph member', + ])('gives every resent document a unique name for a Bedrock %s', async (recipient) => { + const bedrockAgent = { + ...mockAgent, + id: 'bedrock-recipient', + provider: Providers.BEDROCK, + }; + const resolve = jest.fn().mockResolvedValue(bedrockAgent); + const lazyAgent = { ...bedrockAgent, configId: 'bedrock-config', resolve }; + if (recipient === 'primary') { + client.options.agent.provider = Providers.BEDROCK; + } else if (recipient === 'secondary') { + client.agentConfigs = new Map([[bedrockAgent.id, bedrockAgent]]); + } else if (recipient === 'nested subagent') { + client.options.agent.subagentAgentConfigs = [ + { ...mockAgent, id: 'middle-agent', subagentAgentConfigs: [bedrockAgent] }, + ]; + } else if (recipient === 'nested graph member') { + client.options.agent.subagentGraphConfigs = [{ memberConfigs: [bedrockAgent] }]; + } else if (recipient === 'lazy subagent') { + client.options.agent.lazySubagentConfigs = [lazyAgent]; + } else if (recipient === 'nested lazy subagent') { + client.options.agent.subagentAgentConfigs = [ + { ...mockAgent, id: 'middle-agent', lazySubagentConfigs: [lazyAgent] }, + ]; + } else { + client.options.agent.lazySubagentConfigs = [ + { + id: 'lazy-team', + provider: Providers.OPENAI, + configId: 'team-config', + resolve, + subagentGraphMemberMetadata: [bedrockAgent], + }, + ]; + } const bedrockDocument = (name) => ({ type: 'document', document: { name, format: 'pdf', source: { bytes: Buffer.from(name) } }, @@ -6526,6 +6606,9 @@ describe('AgentClient - titleConvo', () => { : [], ); expect(names).toEqual(['Stripe fees', 'Stripe fees (2)']); + expect(firstQuestion.documents[0].document.name).toBe('Stripe fees'); + expect(secondQuestion.documents[0].document.name).toBe('Stripe fees'); + expect(resolve).not.toHaveBeenCalled(); }); it('preserves persisted source identity through both agent formatting passes', async () => { diff --git a/packages/api/src/agents/traversal.spec.ts b/packages/api/src/agents/traversal.spec.ts index 21e7188b2d..9815412747 100644 --- a/packages/api/src/agents/traversal.spec.ts +++ b/packages/api/src/agents/traversal.spec.ts @@ -1,4 +1,4 @@ -import { collectReachableAgents } from './traversal'; +import { someReachableAgent, collectReachableAgents } from './traversal'; interface TestAgent { id: string; @@ -43,3 +43,101 @@ describe('collectReachableAgents', () => { expect(collectReachableAgents([root])).toEqual([root, eager, lazy, graphMetadata, graphMember]); }); }); + +describe('someReachableAgent', () => { + it('stops before reading matched descendants or consuming later roots', () => { + const descendants = jest.fn(() => { + throw new Error('Matched descendants must not be read'); + }); + const matched: TestAgent = { + id: 'match', + get lazySubagentConfigs() { + return descendants(); + }, + }; + const laterRoots = jest.fn(() => { + throw new Error('Later roots must not be consumed'); + }); + function* roots() { + yield matched; + yield laterRoots(); + } + const predicate = jest.fn((agent: TestAgent) => agent.id === 'match'); + + expect(someReachableAgent(roots(), predicate)).toBe(true); + expect(predicate).toHaveBeenCalledTimes(1); + expect(descendants).not.toHaveBeenCalled(); + expect(laterRoots).not.toHaveBeenCalled(); + }); + + it.each([ + 'subagentAgentConfigs', + 'lazySubagentConfigs', + 'subagentGraphMemberMetadata', + 'subagentGraphConfigs', + ] as const)('finds a descendant through %s without resolving it', (route) => { + const resolve = jest.fn(); + const matched = { id: 'match', resolve }; + const root: TestAgent = { + id: 'root', + ...(route === 'subagentGraphConfigs' + ? { subagentGraphConfigs: [{ memberConfigs: [matched] }] } + : { [route]: [matched] }), + }; + + expect(someReachableAgent([root], (agent) => agent.id === 'match')).toBe(true); + expect(resolve).not.toHaveBeenCalled(); + }); + + it('visits every distinct object once in breadth-first order when nothing matches', () => { + const first: TestAgent = { id: 'same' }; + const second: TestAgent = { id: 'same' }; + const root: TestAgent = { + id: 'root', + subagentAgentConfigs: [first, second], + lazySubagentConfigs: [first], + }; + first.subagentGraphMemberMetadata = [root, second]; + second.subagentAgentConfigs = [root]; + const predicate = jest.fn(() => false); + + expect(someReachableAgent([null, root, root, undefined], predicate)).toBe(false); + expect(predicate.mock.calls).toEqual([[root], [first], [second]]); + expect(collectReachableAgents([null, root, root, undefined])).toEqual([root, first, second]); + }); + + it('stops before inspecting later descendants after a nested match', () => { + const match: TestAgent = { id: 'match' }; + const later: TestAgent = { id: 'later' }; + const root: TestAgent = { id: 'root', lazySubagentConfigs: [match, later] }; + const predicate = jest.fn((agent: TestAgent) => agent === match); + + expect(someReachableAgent([root], predicate)).toBe(true); + expect(predicate.mock.calls).toEqual([[root], [match]]); + }); + + it('does not invoke the predicate for empty roots', () => { + const predicate = jest.fn(() => true); + + expect(someReachableAgent([], predicate)).toBe(false); + expect(predicate).not.toHaveBeenCalled(); + }); + + it('propagates predicate failures without expanding the matched node', () => { + const failure = new Error('Predicate failed'); + const descendants = jest.fn(); + const root: TestAgent = { + id: 'root', + get subagentAgentConfigs() { + return descendants(); + }, + }; + + expect(() => + someReachableAgent([root], () => { + throw failure; + }), + ).toThrow(failure); + expect(descendants).not.toHaveBeenCalled(); + }); +}); diff --git a/packages/api/src/agents/traversal.ts b/packages/api/src/agents/traversal.ts index 1685664066..30ea13f243 100644 --- a/packages/api/src/agents/traversal.ts +++ b/packages/api/src/agents/traversal.ts @@ -7,34 +7,63 @@ export interface ReachableAgent { }[]; } -/** - * Collects each agent object reachable from the supplied roots exactly once. - * Object identity preserves distinct initialized snapshots while preventing - * shared subagent nodes and cyclic graphs from repeating work. - */ +/** Visits each object once in breadth-first order, stopping before a match's descendants. */ +export function someReachableAgent>( + roots: Iterable, + predicate: (agent: T) => boolean, +): boolean { + let visited: Set | undefined; + let pending: Array | undefined; + const matches = (agent: T | null | undefined): boolean => { + if (agent == null || visited?.has(agent)) { + return false; + } + if (predicate(agent)) { + return true; + } + (visited ??= new Set()).add(agent); + const eager = agent.subagentAgentConfigs; + const lazy = agent.lazySubagentConfigs; + const metadata = agent.subagentGraphMemberMetadata; + if (eager?.length) { + (pending ??= []).push(...eager); + } + if (lazy?.length) { + (pending ??= []).push(...lazy); + } + if (metadata?.length) { + (pending ??= []).push(...metadata); + } + for (const graph of agent.subagentGraphConfigs ?? []) { + const members = graph.memberConfigs; + if (members?.length) { + (pending ??= []).push(...members); + } + } + return false; + }; + + for (const root of roots) { + if (matches(root)) { + return true; + } + } + for (let index = 0; pending && index < pending.length; index++) { + if (matches(pending[index])) { + return true; + } + } + return false; +} + +/** Collects distinct snapshots in breadth-first order, including shared and cyclic graphs. */ export function collectReachableAgents>( roots: readonly (T | null | undefined)[], ): T[] { const agents: T[] = []; - const visited = new Set(); - const pending = [...roots]; - - for (let index = 0; index < pending.length; index++) { - const agent = pending[index]; - if (agent == null || visited.has(agent)) { - continue; - } - visited.add(agent); + someReachableAgent(roots, (agent) => { agents.push(agent); - pending.push( - ...(agent.subagentAgentConfigs ?? []), - ...(agent.lazySubagentConfigs ?? []), - ...(agent.subagentGraphMemberMetadata ?? []), - ); - for (const graph of agent.subagentGraphConfigs ?? []) { - pending.push(...(graph.memberConfigs ?? [])); - } - } - + return false; + }); return agents; } diff --git a/packages/api/src/files/encode/document.spec.ts b/packages/api/src/files/encode/document.spec.ts index 66a86bf27e..5674233a71 100644 --- a/packages/api/src/files/encode/document.spec.ts +++ b/packages/api/src/files/encode/document.spec.ts @@ -1222,6 +1222,113 @@ describe('dedupeDocumentNames', () => { ); const contentOf = (message: Message) => (Array.isArray(message.content) ? message.content : []); + it.each(Object.values(Providers).filter((provider) => provider !== Providers.BEDROCK))( + 'does not inspect replay content for %s', + (provider) => { + const content = jest.fn(() => { + throw new Error('Non-Bedrock content must not be traversed'); + }); + const messages: Message[] = [ + { + get content() { + return content(); + }, + }, + ]; + messages.length = CONTENT_TRAVERSAL_MAX_NODES + 1; + + dedupeDocumentNames(messages, [{ provider }]); + + expect(content).not.toHaveBeenCalled(); + }, + ); + + it('stops recipient traversal as soon as Bedrock naming is required', () => { + const descendants = jest.fn(() => { + throw new Error('Bedrock descendants must not be read'); + }); + const recipients = [ + { + provider: Providers.BEDROCK, + get lazySubagentConfigs() { + return descendants(); + }, + }, + ]; + const messages: Message[] = [{ content: [bedrock('notes'), bedrock('notes')] }]; + + dedupeDocumentNames(messages, recipients); + + expect(names(contentOf(messages[0]))).toEqual(['notes', 'notes (2)']); + expect(descendants).not.toHaveBeenCalled(); + }); + + it('renames documents for a Bedrock recipient after a non-Bedrock primary', () => { + const messages: Message[] = [{ content: [bedrock('notes'), bedrock('notes')] }]; + const recipients = new Map([ + ['primary', { provider: Providers.OPENAI }], + ['secondary', { provider: Providers.BEDROCK }], + ]); + + dedupeDocumentNames(messages, recipients.values()); + + expect(names(contentOf(messages[0]))).toEqual(['notes', 'notes (2)']); + }); + + it.each(['lazySubagentConfigs', 'subagentGraphMemberMetadata'] as const)( + 'includes Bedrock providers in %s without resolving them', + (route) => { + const messages: Message[] = [{ content: [bedrock('notes'), bedrock('notes')] }]; + const resolve = jest.fn(); + const child = { provider: Providers.BEDROCK, resolve }; + const recipients = [{ provider: Providers.OPENAI, [route]: [child] }]; + + dedupeDocumentNames(messages, recipients); + + expect(names(contentOf(messages[0]))).toEqual(['notes', 'notes (2)']); + expect(resolve).not.toHaveBeenCalled(); + }, + ); + + it('handles cyclic metadata without losing distinct snapshots of the same agent', () => { + const child = { id: 'shared-id', provider: Providers.BEDROCK }; + const root = { + id: 'shared-id', + provider: Providers.OPENAI, + lazySubagentConfigs: [] as Array<{ provider: Providers }>, + }; + root.lazySubagentConfigs.push(root, child, child); + const messages: Message[] = [{ content: [bedrock('notes'), bedrock('notes')] }]; + + dedupeDocumentNames(messages, [root]); + + expect(names(contentOf(messages[0]))).toEqual(['notes', 'notes (2)']); + }); + + it('leaves a large replay untouched without any Bedrock recipients', () => { + const content: PayloadContentPart[] = new Array(CONTENT_TRAVERSAL_MAX_NODES); + const messages: Message[] = [{ content }]; + const recipients = new Map([ + ['primary', { provider: Providers.OPENAI }], + ['secondary', { provider: Providers.ANTHROPIC }], + ]); + + const resolve = jest.fn(); + const lazy = { + provider: Providers.GOOGLE, + resolve, + subagentGraphMemberMetadata: [{ provider: Providers.ANTHROPIC }], + lazySubagentConfigs: [] as Array<{ provider: Providers }>, + }; + lazy.lazySubagentConfigs.push(lazy); + const root = { provider: Providers.OPENAI, lazySubagentConfigs: [lazy] }; + + dedupeDocumentNames(messages, [...recipients.values(), root]); + + expect(messages[0].content).toBe(content); + expect(resolve).not.toHaveBeenCalled(); + }); + it('renames repeated Bedrock document names across the payload in order', () => { const first = bedrock('Stripe fees'); const messages: Message[] = [ @@ -1347,6 +1454,12 @@ describe('dedupeDocumentNames', () => { const messages: Message[] = [{ content }]; expect(() => dedupeDocumentNames(messages)).toThrow(ContentTraversalLimitError); + expect(() => + dedupeDocumentNames(messages, [ + { provider: Providers.OPENAI }, + { provider: Providers.BEDROCK }, + ]), + ).toThrow(ContentTraversalLimitError); expect(messages[0].content).toBe(content); expect(content[1].document.name).toBe('notes'); }); diff --git a/packages/api/src/files/encode/document.ts b/packages/api/src/files/encode/document.ts index 27444f6446..368f3a72e5 100644 --- a/packages/api/src/files/encode/document.ts +++ b/packages/api/src/files/encode/document.ts @@ -15,6 +15,7 @@ import type { DocumentResult, ServerRequest, } from '~/types'; +import type { ReachableAgent } from '~/agents/traversal'; import { CONTENT_TRAVERSAL_MAX_DEPTH, CONTENT_TRAVERSAL_MAX_NODES, @@ -26,6 +27,7 @@ import { isAttachmentObjectNotFoundError, } from './utils'; import { validatePdf, validateBedrockDocument } from '~/files/validation'; +import { someReachableAgent } from '~/agents/traversal'; import { runGuardedEncode } from './memoryGuard'; /** The longest document name LibreChat sends to Bedrock. */ @@ -95,6 +97,18 @@ function renameDocumentParts( return renamed ?? parts; } +interface DocumentRecipient extends ReachableAgent { + readonly provider?: string; +} + +function isBedrockRecipient({ provider }: DocumentRecipient): boolean { + return provider === Providers.BEDROCK; +} + +function hasBedrockRecipient(recipients: Iterable): boolean { + return someReachableAgent(recipients, isBedrockRecipient); +} + /** * Bedrock rejects a request in which two documents share a name, and every turn resends the * documents of earlier turns (and of steers replayed with their attachments), so two uploads with @@ -102,11 +116,17 @@ function renameDocumentParts( * formatted payload in conversation order (`report`, `report (2)`), leaving the first occurrence, * every other kind of part, and the parts themselves untouched: a message whose documents change * gets a new content array. Names compare case-insensitively, as the restriction is not - * documented to be case-sensitive. Replay always enforces traversal limits, even without filters. + * documented to be case-sensitive. Recipient metadata includes lazy children and graph + * members without resolving them. Only runs with a Bedrock recipient need naming; + * Bedrock replay enforces traversal limits even without filters. */ export function dedupeDocumentNames( messages: Array<{ content?: string | PayloadContentPart[] | null }>, + recipients?: Iterable, ): void { + if (recipients != null && !hasBedrockRecipient(recipients)) { + return; + } const budget = { remaining: CONTENT_TRAVERSAL_MAX_NODES - messages.length }; if (budget.remaining < 0) { throw new ContentTraversalLimitError(); diff --git a/packages/chat/src/react/chat/session.tsx b/packages/chat/src/react/chat/session.tsx index a13f138f72..263d195e37 100644 --- a/packages/chat/src/react/chat/session.tsx +++ b/packages/chat/src/react/chat/session.tsx @@ -3,8 +3,8 @@ import type { TMessage } from 'librechat-data-provider'; import type { ReactNode } from 'react'; import { submissionByIndex, useIsSubmitting } from '../submission'; import useQueuedTurnReveal from '../steering/useQueuedTurnReveal'; -import useQueueDrain from '../steering/useQueueDrain'; import { useResumeOnLoad } from '../stream/resume/load'; +import useQueueDrain from '../steering/useQueueDrain'; import useAdaptiveSSE from '../stream/adaptive'; import { ChatContext } from './context'; import useChatHelpers from './helpers';