From b69adddcd46ba3b1b5ff67722a57b3e9cfacc2e0 Mon Sep 17 00:00:00 2001 From: "lia-by-librechat[bot]" <328778573+lia-by-librechat[bot]@users.noreply.github.com> Date: Sat, 24 Oct 2026 11:44:47 +0200 Subject: [PATCH] =?UTF-8?q?=F0=9F=8E=A3=20fix:=20Bound=20Attachment=20Prev?= =?UTF-8?q?iew=20Matching=20Work=20(#17384)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * 🎣 fix: Bound Attachment Preview Matching Work * test: Type the Scope Iterator and Check Concurrent Requests * fix: Keep Attachment Candidate Selection Lint-Clean --------- Co-authored-by: Lia --- .../__tests__/messages-tool-previews.spec.js | 48 +++- packages/api/src/messages/previews.spec.ts | 141 ++++++++++++ packages/api/src/messages/previews.ts | 217 +++++++++++++----- packages/data-provider/src/config.ts | 2 + 4 files changed, 349 insertions(+), 59 deletions(-) diff --git a/api/server/routes/__tests__/messages-tool-previews.spec.js b/api/server/routes/__tests__/messages-tool-previews.spec.js index 125cec7e62..288377f965 100644 --- a/api/server/routes/__tests__/messages-tool-previews.spec.js +++ b/api/server/routes/__tests__/messages-tool-previews.spec.js @@ -129,11 +129,12 @@ describe('tool-call previews on the message routes', () => { const messagesRouter = require('../messages'); app = express(); - app.use(express.json({ limit: '10mb' })); + app.use(express.json({ limit: '3mb' })); app.use((req, _res, next) => { req.user = { id: req.headers['x-user'] ?? OWNER }; next(); }); + app.get('/health', (_req, res) => res.sendStatus(200)); app.use('/api/messages', messagesRouter); }); @@ -202,6 +203,51 @@ describe('tool-call previews on the message routes', () => { expect(message.content[0]).toEqual({ type: 'text', text: 'Building now', agentId: 'agent_a' }); }); + it('previews a persisted large client-authored transcript with repeated attachment scopes', async () => { + const messageId = 'repeated-attachments'; + const payload = { + messageId, + parentMessageId: 'user-1', + isCreatedByUser: false, + text: '', + content: [ + { + type: 'tool_call', + tool_call: { + id: 'parent', + name: 'subagent', + output: 'done', + subagent_content: Array.from({ length: 10_000 }, () => ({ + type: 'tool_call', + tool_call: { id: 'x' }, + })), + }, + }, + ], + attachments: Array.from({ length: 30_000 }, () => ({ toolCallId: 'x' })), + }; + expect(Buffer.byteLength(JSON.stringify(payload))).toBeLessThan(3 * 1024 * 1024); + const saved = await request(app).post(`/api/messages/${conversationId}`).send(payload); + expect(saved.status).toBe(201); + + const started = performance.now(); + const [response, health] = await Promise.all([ + request(app).get(`/api/messages/${conversationId}?toolPreviews=1`), + new Promise((resolve) => setTimeout(resolve, 25)).then(() => request(app).get('/health')), + ]); + expect(health.status).toBe(200); + expect(response.status).toBe(200); + const preview = response.body.find((message) => message.messageId === messageId); + expect(preview.content[0].tool_call).toMatchObject({ + subagentContentOmitted: true, + subagentAttachmentCalls: [{ id: 'x' }], + }); + expect(preview.content[0].tool_call).not.toHaveProperty('subagent_content'); + expect(performance.now() - started).toBeLessThan(3_000); + const [stored] = await mockDb.methods.getMessages({ messageId, user: OWNER }); + expect(stored.content[0].tool_call.subagent_content).toHaveLength(10_000); + }); + it('previews a stored long decimal without changing its numeric text or stored output', async () => { const output = `{"n":1.${'0'.repeat(80_000)}1}`; const messageId = 'long-decimal'; diff --git a/packages/api/src/messages/previews.spec.ts b/packages/api/src/messages/previews.spec.ts index 24c50c118c..b9a397f0d5 100644 --- a/packages/api/src/messages/previews.spec.ts +++ b/packages/api/src/messages/previews.spec.ts @@ -8,6 +8,7 @@ import { containsToolCallPreviews, prepareToolCallPreviews, previewMessagesToolCalls, + previewContentToolCalls, prepareResultToolCallPreviews, rejectToolCallPreviewWrites, withToolCallPreviews, @@ -49,6 +50,21 @@ const toolPart = (toolCall: TestToolCall) => ({ const longOutput = (head: string, tail: string, fill = 'x'.repeat(20_000)) => `${head}${fill}${tail}`; +describe('attachment matching work configuration', () => { + it('defaults to a bounded budget and accepts overrides', () => { + expect(toolCallPreviewsConfigSchema.parse({}).attachmentWorkLimit).toBe(100_000); + expect(toolCallPreviewsConfigSchema.parse({ attachmentWorkLimit: 2 }).attachmentWorkLimit).toBe( + 2, + ); + }); + + it.each([0, -1, 1.5, 1_000_001, Infinity, '100'])('rejects invalid budget %p', (value) => { + expect(toolCallPreviewsConfigSchema.safeParse({ attachmentWorkLimit: value }).success).toBe( + false, + ); + }); +}); + describe('previewOutputText', () => { it('keeps short output untouched', () => { expect(previewOutputText('done', 1_024)).toBe('done'); @@ -532,6 +548,92 @@ describe('previewMessagesToolCalls', () => { expect(part.tool_call.subagentAttachmentCalls).toHaveLength(1); }); + it('deduplicates repeated attachment tuples before charging the matching budget', () => { + const subagent = toolPart({ + name: 'subagent', + output: 'done', + subagent_content: Array.from({ length: 10_000 }, () => toolPart({ id: 'x' })), + }); + const attachments = Array.from({ length: 30_000 }, () => ({ toolCallId: 'x' })); + const messages = [{ content: [subagent], attachments }]; + expect(Buffer.byteLength(JSON.stringify(messages))).toBeLessThan(3 * 1024 * 1024); + const [message] = previewMessagesToolCalls(messages, { + ...limits, + attachmentWorkLimit: 10_001, + }); + expect(message.content[0].tool_call).toMatchObject({ + subagentContentOmitted: true, + subagentAttachmentCalls: [{ id: 'x' }], + }); + expect(subagent.tool_call.subagent_content).toHaveLength(10_000); + }); + + it('looks up each distinct scope once rather than scanning it for every reused child id', () => { + const scopes = Array.from({ length: 300 }, (_, i) => ({ agentId: `agent_${i}` })); + let visits = 0; + const originalIterator = scopes[Symbol.iterator].bind(scopes); + scopes[Symbol.iterator] = () => { + const iterator = originalIterator(); + const next = iterator.next.bind(iterator); + iterator.next = () => { + const entry = next(); + if (!entry.done && ++visits > scopes.length) { + throw new Error('Attachment scope scanned more than once'); + } + return entry; + }; + return iterator; + }; + const subagent = toolPart({ + name: 'subagent', + output: 'done', + subagent_content: Array.from({ length: 300 }, (_, i) => + toolPart({ id: 'x', agentId: `agent_${i}` }), + ), + }); + const [part] = previewContentToolCalls( + [subagent], + limits, + '', + new Map([['x', scopes]]), + ) as Array<{ tool_call: TestToolCall }>; + expect(part.tool_call.subagentContentOmitted).toBe(true); + expect(part.tool_call.subagentAttachmentCalls).toHaveLength(300); + expect(visits).toBe(300); + }); + + it('shares the work budget across parent calls and keeps incomplete transcripts in full', () => { + const parent = (id: string) => + toolPart({ + id, + name: 'subagent', + output: 'done', + subagent_content: [toolPart({ id: 'x' })], + }); + const content = [parent('first'), parent('second')]; + const [message] = previewMessagesToolCalls([{ content, attachments: [{ toolCallId: 'x' }] }], { + ...limits, + attachmentWorkLimit: 3, + }); + expect(message.content[0].tool_call.subagentContentOmitted).toBe(true); + expect(message.content[1]).toBe(content[1]); + expect(message.content[1].tool_call).not.toHaveProperty('subagentAttachmentCalls'); + expect(message.content[1].tool_call.subagent_content).toHaveLength(1); + }); + + it('keeps the full transcript when the node budget is exhausted before a later match', () => { + const subagent = toolPart({ + output: 'done', + subagent_content: [{ type: ContentTypes.TEXT, text: 'first' }, toolPart({ id: 'x' })], + }); + const [message] = previewMessagesToolCalls( + [{ content: [subagent], attachments: [{ toolCallId: 'x' }] }], + { ...limits, attachmentWorkLimit: 1 }, + ); + expect(message.content[0]).toBe(subagent); + expect(message.content[0].tool_call).not.toHaveProperty('subagentContentOmitted'); + }); + it('scopes hints to the agent a stored subagent call ran', () => { const subagent = toolPart({ name: 'subagent', @@ -814,6 +916,45 @@ describe('findSubagentAttachmentCalls', () => { ]); }); + it('preserves first exact and first agreeing matches for every partial scope', () => { + const values = [undefined, '', 'a', 'b']; + const scopes = values.flatMap((agentId) => values.map((stepId) => ({ agentId, stepId }))); + const calls = scopes.map((scope) => ({ id: 'x', ...scope })); + // Rotate traversal order so an unscoped fallback does not always precede an exact match. + for (let offset = 0; offset < calls.length; offset++) { + const ordered = [...calls.slice(offset), ...calls.slice(0, offset)]; + for (const file of scopes) { + const exact = ordered.find( + (candidate) => + (file.agentId == null || candidate.agentId === file.agentId) && + (file.stepId == null || candidate.stepId === file.stepId), + ); + const agreeing = ordered.find( + (candidate) => + (file.agentId == null || + candidate.agentId == null || + candidate.agentId === file.agentId) && + (file.stepId == null || candidate.stepId == null || candidate.stepId === file.stepId), + ); + const expected = ordered.filter( + (candidate) => candidate === exact || candidate === agreeing, + ); + const transcript = ordered.map(({ id, agentId, stepId }) => + toolPart({ id, agentId, stepId }), + ); + expect( + findSubagentAttachmentCalls( + [subagent('parent', transcript)], + [ + { toolCallId: 'x', ...file }, + { toolCallId: 'x', ...file }, + ], + ), + ).toEqual([{ toolCallId: 'parent', calls: expected }]); + } + } + }); + it('walks nested runs and ignores calls no queried file names', () => { const content = [ subagent('outer', [subagent('inner', [call('deep'), call('other')])]), diff --git a/packages/api/src/messages/previews.ts b/packages/api/src/messages/previews.ts index ce109eb51f..69036e3f8a 100644 --- a/packages/api/src/messages/previews.ts +++ b/packages/api/src/messages/previews.ts @@ -18,7 +18,18 @@ import type { AppConfig } from '@librechat/data-schemas'; import type { AppConfigUserLike, GetAppConfigOptions } from '~/app/service'; import { getAppConfigOptionsFromUser } from '~/app/service'; -export type ToolCallPreviewLimits = Pick; +export type ToolCallPreviewLimits = Pick & + Partial>; + +type AttachmentWorkBudget = { remaining: number }; + +const DEFAULT_ATTACHMENT_WORK_LIMIT: number = toolCallPreviewsConfigSchema.parse( + {}, +).attachmentWorkLimit; + +const attachmentWorkBudget = (limits: ToolCallPreviewLimits): AttachmentWorkBudget => ({ + remaining: limits.attachmentWorkLimit ?? DEFAULT_ATTACHMENT_WORK_LIMIT, +}); /** Separates the kept start and end of an output preview. */ export const TOOL_CALL_PREVIEW_ELISION = '\n…\n'; @@ -175,69 +186,120 @@ type AttachmentScope = { agentId?: string; stepId?: string }; /** Each tool call id a message's attachments were saved under, with the scopes saved with it. */ type AttachmentScopes = ReadonlyMap; -/** A scope both sides carry must agree: the ownership rule the client applies. */ -const scopeAgrees = (call: AttachmentScope, file: AttachmentScope): boolean => - (call.agentId == null || file.agentId == null || call.agentId === file.agentId) && - (call.stepId == null || file.stepId == null || call.stepId === file.stepId); - /** The agent a stored subagent call ran, from its persisted identity. */ const runAgentId = (toolCall: StoredToolCall): string | undefined => { const identity = toolCall.subagentIdentity as { subagentAgentId?: unknown } | undefined; return typeof identity?.subagentAgentId === 'string' ? identity.subagentAgentId : undefined; }; -/** Whether the call carries every scope the attachment does. */ -const scopeMatches = (call: AttachmentScope, file: AttachmentScope): boolean => - (file.agentId == null || call.agentId === file.agentId) && - (file.stepId == null || call.stepId === file.stepId); +type IndexedAttachmentCall = { call: Agents.SubagentAttachmentCall; order: number }; + +interface AttachmentCallIndex { + first: IndexedAttachmentCall; + byAgent: Map; + byStep: Map; + byScope: Map>; +} + +/** First call carrying every field the file scopes, with absent file fields as wildcards. */ +function firstAttachmentCall( + index: AttachmentCallIndex, + scope: AttachmentScope, +): IndexedAttachmentCall | undefined { + if (scope.agentId == null) { + return scope.stepId == null ? index.first : index.byStep.get(scope.stepId); + } + return scope.stepId == null + ? index.byAgent.get(scope.agentId) + : index.byScope.get(scope.agentId)?.get(scope.stepId); +} + +/** First compatible call, including calls missing a field the file carries. */ +function firstAgreeingAttachmentCall( + index: AttachmentCallIndex, + scope: AttachmentScope, +): IndexedAttachmentCall | undefined { + if (scope.agentId == null && scope.stepId == null) { + return index.first; + } + let candidates: Array; + if (scope.agentId == null) { + candidates = [index.byStep.get(scope.stepId), index.byStep.get(undefined)]; + } else if (scope.stepId == null) { + candidates = [index.byAgent.get(scope.agentId), index.byAgent.get(undefined)]; + } else { + candidates = [ + index.byScope.get(scope.agentId)?.get(scope.stepId), + index.byScope.get(undefined)?.get(scope.stepId), + index.byScope.get(scope.agentId)?.get(undefined), + index.byScope.get(undefined)?.get(undefined), + ]; + } + let first: IndexedAttachmentCall | undefined; + for (const candidate of candidates) { + if (candidate != null && (first == null || candidate.order < first.order)) { + first = candidate; + } + } + return first; +} /** * Tool calls anywhere in the parts, including inside nested subagent runs, that one of the * message's attachments can belong to, with the agent and step scope a client checks it against. * For each attachment scope only the first call matching it exactly and the first call agreeing * with it are kept (the two a client can choose between), so a reused id, or an attachment with - * no scope to narrow it, does not grow the hint with the transcript. + * no scope to narrow it, does not grow the hint with the transcript. Indexing makes each scope + * a constant-time lookup rather than a scan for every child call. */ function nestedAttachmentCalls( parts: unknown[], wanted: AttachmentScopes, ownerAgentId?: string, -): Agents.SubagentAttachmentCall[] { - const found = new Map(); - const exactFor = new Set(); - const agreeingFor = new Set(); + budget?: AttachmentWorkBudget, +): Agents.SubagentAttachmentCall[] | undefined { + const indexes = new Map(); + const ordered: IndexedAttachmentCall[] = []; /** Each level carries the agent of the run it belongs to, for parts that do not stamp one. */ const stack: Array<[unknown[], string | undefined]> = [[parts, ownerAgentId]]; while (stack.length > 0) { const [current, levelOwner] = stack.pop() ?? [[], undefined]; for (const part of current) { + if (budget != null && budget.remaining-- <= 0) { + return undefined; + } if (!isToolCallPart(part)) { continue; } const { id, stepId, subagent_content } = part.tool_call; - const scopes = typeof id === 'string' ? wanted.get(id) : undefined; - if (scopes != null) { - /** The owner is stored on the part, on the call, or on the run that holds it. */ + if (typeof id === 'string' && wanted.has(id)) { const owner = part.agentId ?? part.tool_call.agentId ?? levelOwner; - const call: Agents.SubagentAttachmentCall = { - id: id as string, - ...(typeof owner === 'string' ? { agentId: owner } : {}), - ...(typeof stepId === 'string' ? { stepId } : {}), - }; - let useful = false; - for (const scope of scopes) { - if (!exactFor.has(scope) && scopeMatches(call, scope)) { - exactFor.add(scope); - useful = true; + const agentId = typeof owner === 'string' ? owner : undefined; + const step = typeof stepId === 'string' ? stepId : undefined; + let index = indexes.get(id); + if (index?.byScope.get(agentId)?.has(step) !== true) { + const entry: IndexedAttachmentCall = { + call: { + id, + ...(agentId != null ? { agentId } : {}), + ...(step != null ? { stepId: step } : {}), + }, + order: ordered.length, + }; + ordered.push(entry); + if (index == null) { + index = { first: entry, byAgent: new Map(), byStep: new Map(), byScope: new Map() }; + indexes.set(id, index); } - if (!agreeingFor.has(scope) && scopeAgrees(call, scope)) { - agreeingFor.add(scope); - useful = true; + if (!index.byAgent.has(agentId)) { + index.byAgent.set(agentId, entry); } - } - const identity = [call.id, call.agentId ?? '', call.stepId ?? ''].join('\u0000'); - if (useful && !found.has(identity)) { - found.set(identity, call); + if (!index.byStep.has(step)) { + index.byStep.set(step, entry); + } + const steps = index.byScope.get(agentId) ?? new Map(); + steps.set(step, entry); + index.byScope.set(agentId, steps); } } if (Array.isArray(subagent_content)) { @@ -245,15 +307,40 @@ function nestedAttachmentCalls( } } } - return [...found.values()]; + const selected = new Set(); + for (const [id, index] of indexes) { + for (const scope of wanted.get(id) ?? []) { + if (budget != null && budget.remaining-- <= 0) { + return undefined; + } + const exact = firstAttachmentCall(index, scope); + const agreeing = firstAgreeingAttachmentCall(index, scope); + if (exact != null) { + selected.add(exact); + } + if (agreeing != null) { + selected.add(agreeing); + } + } + } + const calls: Agents.SubagentAttachmentCall[] = []; + for (const entry of ordered) { + if (selected.has(entry)) { + calls.push(entry.call); + } + } + return calls; } -/** The tool call ids a message's attachments were saved under, with their scopes. */ -function attachmentToolCallIds(message: PreviewableMessage): AttachmentScopes | undefined { +/** Deduplicates attachment scope tuples before any transcript is matched. */ +function attachmentToolCallIds(message: { + attachments?: readonly unknown[] | null; +}): AttachmentScopes | undefined { if (!Array.isArray(message.attachments) || message.attachments.length === 0) { return undefined; } const scopes = new Map(); + const seen = new Map>(); for (const attachment of message.attachments) { if (!isObject(attachment)) { continue; @@ -266,11 +353,19 @@ function attachmentToolCallIds(message: PreviewableMessage): AttachmentScopes | if (typeof toolCallId !== 'string' || toolCallId === '') { continue; } - const entries = scopes.get(toolCallId) ?? []; - entries.push({ + const scope: AttachmentScope = { ...(typeof agentId === 'string' ? { agentId } : {}), ...(typeof stepId === 'string' ? { stepId } : {}), - }); + }; + const key = JSON.stringify([scope.agentId, scope.stepId]); + const keys = seen.get(toolCallId) ?? new Set(); + if (keys.has(key)) { + continue; + } + keys.add(key); + seen.set(toolCallId, keys); + const entries = scopes.get(toolCallId) ?? []; + entries.push(scope); scopes.set(toolCallId, entries); } return scopes.size > 0 ? scopes : undefined; @@ -297,14 +392,9 @@ export function findSubagentAttachmentCalls( content: unknown[], files: ReadonlyArray, ): SubagentAttachmentCallsEntry[] { - const wanted = new Map(); - for (const { toolCallId, agentId, stepId } of files) { - const scopes = wanted.get(toolCallId) ?? []; - scopes.push({ ...(agentId != null ? { agentId } : {}), ...(stepId != null ? { stepId } : {}) }); - wanted.set(toolCallId, scopes); - } + const wanted = attachmentToolCallIds({ attachments: files }); const entries: SubagentAttachmentCallsEntry[] = []; - if (wanted.size === 0) { + if (wanted == null) { return entries; } for (const part of content) { @@ -320,7 +410,7 @@ export function findSubagentAttachmentCalls( wanted, runAgentId(part.tool_call), ); - if (calls.length === 0) { + if (calls == null || calls.length === 0) { continue; } entries.push({ @@ -629,6 +719,7 @@ export function previewToolCall( limits: ToolCallPreviewLimits, revision = '', attachmentIds?: AttachmentScopes, + budget: AttachmentWorkBudget = attachmentWorkBudget(limits), ): T { if (!isAgentToolCall(toolCall) || !isSettled(toolCall) || !hasIdentity(toolCall)) { return toolCall; @@ -641,11 +732,23 @@ export function previewToolCall( const outputPreview = previewToolCallOutput(toolCall, output, limits.outputChars); const argsPreview = previewToolCallArgs(toolCall.args, limits.argsChars); const subagentContent = toolCall.subagent_content; - const omitSubagentContent = + let omitSubagentContent = Array.isArray(subagentContent) && subagentContent.length > 0 && !hasPendingApproval(subagentContent); + let childCalls: Agents.SubagentAttachmentCall[] | undefined; + if (omitSubagentContent && attachmentIds != null) { + childCalls = nestedAttachmentCalls( + subagentContent as unknown[], + attachmentIds, + runAgentId(toolCall), + budget, + ); + // Never omit a transcript with incomplete attachment ownership hints. + omitSubagentContent = childCalls != null; + } + if (outputPreview === output && argsPreview == null && !omitSubagentContent) { return toolCall; } @@ -665,11 +768,7 @@ export function previewToolCall( delete next.subagent_content; next.subagentContentOmitted = true; next.subagentContentParts = (subagentContent as unknown[]).length; - const childCalls = - attachmentIds == null - ? [] - : nestedAttachmentCalls(subagentContent as unknown[], attachmentIds, runAgentId(toolCall)); - if (childCalls.length > 0) { + if (childCalls != null && childCalls.length > 0) { next.subagentAttachmentCalls = childCalls; } } @@ -687,10 +786,11 @@ function previewToolCallSafely( toolCall: T, limits: ToolCallPreviewLimits, revision: string, - attachmentIds?: AttachmentScopes, + attachmentIds: AttachmentScopes | undefined, + budget: AttachmentWorkBudget, ): T { try { - return previewToolCall(toolCall, limits, revision, attachmentIds); + return previewToolCall(toolCall, limits, revision, attachmentIds, budget); } catch (error) { logger.warn('[toolCallPreviews] Sending a tool call in full; its preview failed', error); return toolCall; @@ -704,6 +804,7 @@ export function previewContentToolCalls( revision = '', attachmentIds?: AttachmentScopes, ): unknown[] { + const budget = attachmentWorkBudget(limits); let result: unknown[] | undefined; /** First index of each identity; a repeat sends both calls whole (see `toolCallIdentity`). */ const firstIndex = new Map(); @@ -725,7 +826,7 @@ export function previewContentToolCalls( continue; } firstIndex.set(identity, i); - const toolCall = previewToolCallSafely(part.tool_call, limits, revision, attachmentIds); + const toolCall = previewToolCallSafely(part.tool_call, limits, revision, attachmentIds, budget); if (toolCall === part.tool_call) { continue; } diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.ts index ff809ea4a9..ee83dc7ec7 100644 --- a/packages/data-provider/src/config.ts +++ b/packages/data-provider/src/config.ts @@ -4279,6 +4279,8 @@ export const toolCallPreviewsConfigSchema = z.object({ /** Characters of serialized `args` kept per tool call. JSON arguments stay valid JSON with * every field present; only the longest strings are shortened. */ argsChars: z.number().int().min(256).max(1_000_000).default(512), + /** Transcript nodes and unique scope lookups per message; exhausted calls keep their transcript. */ + attachmentWorkLimit: z.number().int().min(1).max(1_000_000).default(100_000), }); export type TToolCallPreviewsConfig = z.infer;