@librechat/agents 3.3.2 → 3.3.4

package/src/messages/ensureThinkingBlock.test.ts

@@ -755,6 +755,54 @@ describe('ensureThinkingBlockInMessages', () => {
       expect(result[0]).toBeInstanceOf(HumanMessage);
       expect(result[1]).toBeInstanceOf(ToolMessage);
     });
+
+    test('should not emit an empty user message after the shared fold budget is exhausted', () => {
+      const messages = [
+        new HumanMessage({ content: 'Run both tools' }),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            { id: 'first', name: 'query', args: {}, type: 'tool_call' },
+          ],
+        }),
+        new ToolMessage({
+          content: Array.from({ length: 60 }, () => ({
+            type: 'text',
+            text: 'x'.repeat(8_000),
+          })),
+          tool_call_id: 'first',
+        }),
+        new AIMessage({
+          content: '',
+          tool_calls: [
+            { id: 'second', name: 'query', args: {}, type: 'tool_call' },
+          ],
+        }),
+        new ToolMessage({
+          content: 'second result',
+          tool_call_id: 'second',
+        }),
+      ];
+
+      const result = ensureThinkingBlockInMessages(
+        messages,
+        Providers.ANTHROPIC
+      );
+
+      expect(result).toHaveLength(2);
+      expect(getTextContent(result[1])).toContain(
+        'additional folded context omitted'
+      );
+      expect(
+        result
+          .filter((message) => message instanceof HumanMessage)
+          .every((message) =>
+            typeof message.content === 'string'
+              ? message.content.length > 0
+              : message.content.length > 0
+          )
+      ).toBe(true);
+    });
   });
 
   describe('image content preservation (token amplification fix)', () => {
@@ -1132,7 +1180,7 @@ describe('ensureThinkingBlockInMessages', () => {
 
       expect(result).toHaveLength(2);
       const allText = getTextContent(result[1]);
-      // The resource block should be serialized as text, not silently dropped
+      // The resource block should be serialized as text, not silently dropped.
       expect(allText).toContain('[resource]');
       expect(allText).toContain('data.csv');
     });

package/src/messages/foldToollessToolBlocks.test.ts

@@ -6,7 +6,11 @@ import {
   ToolMessage,
 } from '@langchain/core/messages';
 import type { ExtendedMessageContent } from '@/types';
-import { foldToolBlocksForToollessAgent } from './format';
+import {
+  foldToolBlocksForToollessAgent,
+  isSyntheticProviderContextMessage,
+} from './format';
+import { HARD_MAX_TOOL_RESULT_CHARS } from '@/utils/truncation';
 
 /** Concatenated text across a message's content (string or structured array). */
 function getTextContent(msg: {
@@ -96,6 +100,12 @@ describe('foldToolBlocksForToollessAgent', () => {
     expect(folded).toContain('file_search');
     expect(folded).toContain('roadmap');
     expect(folded).toContain('Found roadmap.md');
+    expect(isSyntheticProviderContextMessage(result[1])).toBe(true);
+    expect(
+      isSyntheticProviderContextMessage(
+        new HumanMessage('[Previous tool interaction] user-authored text')
+      )
+    ).toBe(false);
   });
 
   test('folds historical tool content that precedes the last human turn (the reported bug)', () => {
@@ -338,7 +348,11 @@ describe('foldToolBlocksForToollessAgent', () => {
       }),
       new HumanMessage({
         content: [
-          { type: 'tool_result', tool_use_id: 'c1', content: 'Found roadmap.md' },
+          {
+            type: 'tool_result',
+            tool_use_id: 'c1',
+            content: 'Found roadmap.md',
+          },
         ],
       }),
       new HumanMessage('thanks'),
@@ -393,9 +407,7 @@ describe('foldToolBlocksForToollessAgent', () => {
       new HumanMessage('Render a chart'),
       new AIMessage({
         content: '',
-        tool_calls: [
-          { id: 'c', name: 'chart', args: {}, type: 'tool_call' },
-        ],
+        tool_calls: [{ id: 'c', name: 'chart', args: {}, type: 'tool_call' }],
       }),
       new ToolMessage({
         content: [
@@ -422,6 +434,152 @@ describe('foldToolBlocksForToollessAgent', () => {
     ).toBe(true);
   });
 
+  test('bounds non-portable media blocks instead of preserving or JSON-expanding them', () => {
+    const blob = 'A'.repeat(20_000);
+    const resource = {
+      type: 'resource',
+      resource: { uri: 'file:///report.bin', blob },
+    };
+    const messages = [
+      new HumanMessage('Read the report'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          { id: 'doc', name: 'read_document', args: {}, type: 'tool_call' },
+        ],
+      }),
+      new ToolMessage({
+        content: [{ type: 'text', text: 'report:' }, resource],
+        tool_call_id: 'doc',
+        name: 'read_document',
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+    const foldedContent = result[result.length - 1].content;
+    const foldedText = getTextContent(result[result.length - 1]);
+
+    expect(
+      Array.isArray(foldedContent) &&
+        foldedContent.some(
+          (block) => typeof block === 'object' && block.type === 'resource'
+        )
+    ).toBe(false);
+    expect(foldedText).toContain('[resource]');
+    expect(foldedText).toContain('report.bin');
+    expect(foldedText.length).toBeLessThan(9_000);
+    expect(foldedText).not.toContain(blob);
+  });
+
+  test('does not invoke toJSON while folding a small non-portable media block', () => {
+    let toJSONCalls = 0;
+    const resource = {
+      type: 'resource',
+      resource: { uri: 'file:///report.bin', blob: 'AAAA' },
+      toJSON() {
+        toJSONCalls++;
+        return { expanded: 'x'.repeat(100_000) };
+      },
+    };
+    const messages = [
+      new HumanMessage('Read the report'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          { id: 'doc', name: 'read_document', args: {}, type: 'tool_call' },
+        ],
+      }),
+      new ToolMessage({
+        content: [resource],
+        tool_call_id: 'doc',
+        name: 'read_document',
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+    const foldedText = getTextContent(result[result.length - 1]);
+
+    expect(toJSONCalls).toBe(0);
+    expect(foldedText).toContain('report.bin');
+    expect(foldedText.length).toBeLessThan(9_000);
+    expect(foldedText).not.toContain('x'.repeat(1_000));
+  });
+
+  test('bounds the aggregate folded context across many large text blocks', () => {
+    const messages = [
+      new HumanMessage('Summarize the query'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          { id: 'query', name: 'run_query', args: {}, type: 'tool_call' },
+        ],
+      }),
+      new ToolMessage({
+        content: Array.from({ length: 100 }, (_, index) => ({
+          type: 'text',
+          text: `${index}:${'x'.repeat(8_000)}`,
+        })),
+        tool_call_id: 'query',
+        name: 'run_query',
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+    const foldedText = getTextContent(result[result.length - 1]);
+
+    expect(foldedText.length).toBeLessThanOrEqual(HARD_MAX_TOOL_RESULT_CHARS);
+    expect(foldedText).toContain('additional folded context omitted');
+  });
+
+  test('does not emit an empty user message when an earlier fold exhausts the shared budget', () => {
+    const messages = [
+      new HumanMessage('Run both queries'),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          { id: 'first', name: 'run_query', args: {}, type: 'tool_call' },
+        ],
+      }),
+      new ToolMessage({
+        content: Array.from({ length: 60 }, () => ({
+          type: 'text',
+          text: 'x'.repeat(8_000),
+        })),
+        tool_call_id: 'first',
+        name: 'run_query',
+      }),
+      new AIMessage({
+        content: '',
+        tool_calls: [
+          { id: 'second', name: 'run_query', args: {}, type: 'tool_call' },
+        ],
+      }),
+      new ToolMessage({
+        content: 'second result',
+        tool_call_id: 'second',
+        name: 'run_query',
+      }),
+    ];
+
+    const result = foldToolBlocksForToollessAgent(messages);
+    const syntheticMessages = result.filter(isSyntheticProviderContextMessage);
+
+    expect(hasResidualToolContent(result)).toBe(false);
+    expect(syntheticMessages).toHaveLength(1);
+    expect(getTextContent(syntheticMessages[0])).toContain(
+      'additional folded context omitted'
+    );
+    expect(
+      result
+        .filter((message) => message instanceof HumanMessage)
+        .every((message) =>
+          typeof message.content === 'string'
+            ? message.content.length > 0
+            : message.content.length > 0
+        )
+    ).toBe(true);
+  });
+
   test('leaves non-tool conversations untouched', () => {
     const messages = [
       new SystemMessage('sys'),