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

🚋 fix: Scope Document Name Traversal to Bedrock Agents (#17627)

lia-by-librechat[bot]f03a4686ff39
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<TestAgent>([], 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<TAgent> {
}[];
}
-/**
- * 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.
- */
-export function collectReachableAgents<T extends ReachableAgent<T>>(
- roots: readonly (T | null | undefined)[],
-): T[] {
- const agents: T[] = [];
- const visited = new Set<T>();
- const pending = [...roots];
-
- for (let index = 0; index < pending.length; index++) {
- const agent = pending[index];
- if (agent == null || visited.has(agent)) {
- continue;
+/** Visits each object once in breadth-first order, stopping before a match's descendants. */
+export function someReachableAgent<T extends ReachableAgent<T>>(
+ roots: Iterable<T | null | undefined>,
+ predicate: (agent: T) => boolean,
+): boolean {
+ let visited: Set<T> | undefined;
+ let pending: Array<T | null | undefined> | undefined;
+ const matches = (agent: T | null | undefined): boolean => {
+ if (agent == null || visited?.has(agent)) {
+ return false;
+ }
+ if (predicate(agent)) {
+ return true;
+ }
+ (visited ??= new Set<T>()).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);
}
- visited.add(agent);
- agents.push(agent);
- pending.push(
- ...(agent.subagentAgentConfigs ?? []),
- ...(agent.lazySubagentConfigs ?? []),
- ...(agent.subagentGraphMemberMetadata ?? []),
- );
for (const graph of agent.subagentGraphConfigs ?? []) {
- pending.push(...(graph.memberConfigs ?? []));
+ 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<T extends ReachableAgent<T>>(
+ roots: readonly (T | null | undefined)[],
+): T[] {
+ const agents: T[] = [];
+ someReachableAgent(roots, (agent) => {
+ agents.push(agent);
+ 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<DocumentRecipient> {
+ readonly provider?: string;
+}
+
+function isBedrockRecipient({ provider }: DocumentRecipient): boolean {
+ return provider === Providers.BEDROCK;
+}
+
+function hasBedrockRecipient(recipients: Iterable<DocumentRecipient>): 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<DocumentRecipient>,
): 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';