@librechat/agents 3.1.57 → 3.1.61

package/src/messages/formatAgentMessages.test.ts

@@ -4,7 +4,7 @@ import {
   SystemMessage,
   ToolMessage,
 } from '@langchain/core/messages';
-import type { TPayload } from '@/types';
+import type { MessageContentComplex, TPayload } from '@/types';
 import { formatAgentMessages } from './format';
 import { ContentTypes } from '@/common';
 
@@ -20,6 +20,41 @@ describe('formatAgentMessages', () => {
     expect(result.messages[1]).toBeInstanceOf(AIMessage);
   });
 
+  it('preserves source messageId on formatted messages', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        messageId: 'msg_assistant_1',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            [ContentTypes.TEXT]: 'Running tool',
+            tool_call_ids: ['tool_1'],
+          },
+          {
+            type: ContentTypes.TOOL_CALL,
+            tool_call: {
+              id: 'tool_1',
+              name: 'search',
+              args: '{"query":"hello"}',
+              output: 'world',
+            },
+          },
+        ],
+      },
+      { role: 'user', messageId: 'msg_user_1', content: 'thanks' },
+    ];
+
+    const result = formatAgentMessages(payload);
+    expect(result.messages).toHaveLength(3);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[1]).toBeInstanceOf(ToolMessage);
+    expect(result.messages[2]).toBeInstanceOf(HumanMessage);
+    expect(result.messages[0].id).toBe('msg_assistant_1');
+    expect(result.messages[1].id).toBe('msg_assistant_1');
+    expect(result.messages[2].id).toBe('msg_user_1');
+  });
+
   it('should handle system messages', () => {
     const payload = [
       { role: 'system', content: 'You are a helpful assistant.' },
@@ -29,6 +64,83 @@ describe('formatAgentMessages', () => {
     expect(result.messages[0]).toBeInstanceOf(SystemMessage);
   });
 
+  it('should prepend the latest summary and trim context before its boundary', () => {
+    const payload: TPayload = [
+      { role: 'user', content: 'Old user message' },
+      { role: 'assistant', content: 'Old assistant message' },
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.TEXT, text: 'Covered by summary' },
+          {
+            type: ContentTypes.SUMMARY,
+            text: 'Conversation summary',
+            tokenCount: 12,
+          },
+          { type: ContentTypes.TEXT, text: 'Preserved tail' },
+        ],
+      },
+      { role: 'user', content: 'Latest user message' },
+    ];
+
+    const result = formatAgentMessages(payload, {
+      0: 5,
+      1: 6,
+      2: 18,
+      3: 4,
+    });
+
+    expect(result.messages).toHaveLength(2);
+    expect(result.summary).toBeDefined();
+    expect(result.summary!.text).toBe('Conversation summary');
+    expect(result.summary!.tokenCount).toBe(12);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(result.messages[1]).toBeInstanceOf(HumanMessage);
+    expect(
+      (result.messages[0].content as MessageContentComplex[])[0]
+    ).toMatchObject({
+      type: ContentTypes.TEXT,
+      text: 'Preserved tail',
+    });
+    expect(result.indexTokenCountMap?.[0]).toBeLessThan(18);
+    expect(result.indexTokenCountMap?.[0]).toBeGreaterThan(0);
+    expect(result.indexTokenCountMap?.[1]).toBe(4);
+  });
+
+  it('should apply last-summary-wins when multiple summary blocks exist', () => {
+    const payload: TPayload = [
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.SUMMARY, text: 'Old summary', tokenCount: 3 },
+          { type: ContentTypes.TEXT, text: 'Old tail' },
+        ],
+      },
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.TEXT, text: 'Drop this part' },
+          { type: ContentTypes.SUMMARY, text: 'Newest summary', tokenCount: 9 },
+          { type: ContentTypes.TEXT, text: 'Keep this part' },
+        ],
+      },
+    ];
+
+    const result = formatAgentMessages(payload);
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.summary).toBeDefined();
+    expect(result.summary!.text).toBe('Newest summary');
+    expect(result.summary!.tokenCount).toBe(9);
+    expect(result.messages[0]).toBeInstanceOf(AIMessage);
+    expect(
+      (result.messages[0].content as MessageContentComplex[])[0]
+    ).toMatchObject({
+      type: ContentTypes.TEXT,
+      text: 'Keep this part',
+    });
+  });
+
   it('should format messages with content arrays', () => {
     const payload = [
       {
@@ -2683,4 +2795,402 @@ describe('formatAgentMessages', () => {
       }).not.toThrow();
     });
   });
+
+  describe('summary boundary token count adjustment', () => {
+    it('should proportion token count when thinking block is sliced off by boundary', () => {
+      const thinkingText = 'x'.repeat(1000);
+      const payload: TPayload = [
+        { role: 'user', content: 'Old question' },
+        {
+          role: 'assistant',
+          content: [
+            { type: ContentTypes.THINKING, thinking: thinkingText },
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'Summary of conversation',
+              tokenCount: 15,
+            },
+            { type: ContentTypes.TEXT, text: 'Brief response after summary' },
+          ],
+        },
+        { role: 'user', content: 'Follow-up question' },
+      ];
+
+      const indexTokenCountMap = { 0: 5, 1: 1590, 2: 8 };
+      const result = formatAgentMessages(payload, indexTokenCountMap);
+
+      expect(result.summary).toBeDefined();
+      expect(result.summary!.text).toBe('Summary of conversation');
+
+      const boundaryMsgTokens = result.indexTokenCountMap?.[0];
+      expect(boundaryMsgTokens).toBeDefined();
+      expect(boundaryMsgTokens!).toBeLessThan(200);
+      expect(boundaryMsgTokens!).toBeGreaterThan(0);
+
+      expect(result.indexTokenCountMap?.[1]).toBe(8);
+    });
+
+    it('should proportion token count when thinking + tool_use are sliced off', () => {
+      const thinkingText = 'a'.repeat(800);
+      const toolInput = JSON.stringify({ data: 'b'.repeat(400) });
+      const payload: TPayload = [
+        {
+          role: 'assistant',
+          content: [
+            { type: ContentTypes.THINKING, thinking: thinkingText },
+            {
+              type: ContentTypes.TOOL_CALL,
+              tool_call: {
+                id: 'tc1',
+                name: 'search',
+                args: toolInput,
+                output: 'result',
+              },
+            },
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'Conversation summary after tool use',
+              tokenCount: 20,
+            },
+            { type: ContentTypes.TEXT, text: 'Short tail' },
+          ],
+        },
+      ];
+
+      const indexTokenCountMap = { 0: 2000 };
+      const result = formatAgentMessages(payload, indexTokenCountMap);
+
+      expect(result.summary).toBeDefined();
+
+      const totalOutputTokens = Object.values(
+        result.indexTokenCountMap || {}
+      ).reduce((sum, v) => sum + v, 0);
+
+      expect(totalOutputTokens).toBeLessThan(200);
+      expect(totalOutputTokens).toBeGreaterThan(0);
+    });
+
+    it('should roughly halve token count when content is evenly split around boundary', () => {
+      const payload: TPayload = [
+        {
+          role: 'assistant',
+          content: [
+            { type: ContentTypes.TEXT, text: 'a'.repeat(100) },
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'Mid-conversation summary',
+              tokenCount: 10,
+            },
+            { type: ContentTypes.TEXT, text: 'b'.repeat(100) },
+          ],
+        },
+      ];
+
+      const indexTokenCountMap = { 0: 500 };
+      const result = formatAgentMessages(payload, indexTokenCountMap);
+
+      expect(result.summary).toBeDefined();
+
+      const adjustedTokens = result.indexTokenCountMap?.[0] ?? 0;
+      expect(adjustedTokens).toBeGreaterThan(150);
+      expect(adjustedTokens).toBeLessThan(350);
+    });
+
+    it('should still adjust when summary is the first content part (its own text is sliced off)', () => {
+      const payload: TPayload = [
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'Summary at start',
+              tokenCount: 10,
+            },
+            { type: ContentTypes.TEXT, text: 'Everything after the summary' },
+          ],
+        },
+        { role: 'user', content: 'Next question' },
+      ];
+
+      const indexTokenCountMap = { 0: 300, 1: 10 };
+      const result = formatAgentMessages(payload, indexTokenCountMap);
+
+      expect(result.summary).toBeDefined();
+
+      const adjustedTokens = result.indexTokenCountMap?.[0] ?? 0;
+      expect(adjustedTokens).toBeLessThan(300);
+      expect(adjustedTokens).toBeGreaterThan(100);
+      expect(result.indexTokenCountMap?.[1]).toBe(10);
+    });
+
+    it('should account for tool_use input size in the char-length ratio', () => {
+      const hugeInput = JSON.stringify({ payload: 'z'.repeat(5000) });
+      const payload: TPayload = [
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: 'tool_use' as ContentTypes,
+              input: hugeInput,
+            } as unknown as MessageContentComplex,
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'After heavy tool use',
+              tokenCount: 12,
+            },
+            { type: ContentTypes.TEXT, text: 'Tiny tail' },
+          ],
+        },
+      ];
+
+      const indexTokenCountMap = { 0: 3000 };
+      const result = formatAgentMessages(payload, indexTokenCountMap);
+
+      expect(result.summary).toBeDefined();
+
+      const adjustedTokens = result.indexTokenCountMap?.[0] ?? 0;
+      expect(adjustedTokens).toBeLessThan(100);
+      expect(adjustedTokens).toBeGreaterThan(0);
+    });
+
+    it('should handle multiple content parts after the boundary', () => {
+      const thinkingText = 'x'.repeat(2000);
+      const payload: TPayload = [
+        {
+          role: 'assistant',
+          content: [
+            { type: ContentTypes.THINKING, thinking: thinkingText },
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'Conversation checkpoint',
+              tokenCount: 14,
+            },
+            { type: ContentTypes.TEXT, text: 'Part A of the tail' },
+            {
+              type: ContentTypes.TEXT,
+              text: 'Part B of the tail with more text',
+            },
+          ],
+        },
+        { role: 'user', content: 'Next message' },
+      ];
+
+      const indexTokenCountMap = { 0: 4000, 1: 6 };
+      const result = formatAgentMessages(payload, indexTokenCountMap);
+
+      expect(result.summary).toBeDefined();
+
+      const adjustedTokens = result.indexTokenCountMap?.[0] ?? 0;
+      expect(adjustedTokens).toBeLessThan(200);
+      expect(adjustedTokens).toBeGreaterThan(0);
+
+      expect(result.indexTokenCountMap?.[1]).toBe(6);
+    });
+
+    it('should produce integer token counts after proportional adjustment', () => {
+      const payload: TPayload = [
+        {
+          role: 'assistant',
+          content: [
+            { type: ContentTypes.THINKING, thinking: 'x'.repeat(333) },
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'Summary',
+              tokenCount: 5,
+            },
+            { type: ContentTypes.TEXT, text: 'y'.repeat(77) },
+          ],
+        },
+      ];
+
+      const indexTokenCountMap = { 0: 997 };
+      const result = formatAgentMessages(payload, indexTokenCountMap);
+
+      const adjustedTokens = result.indexTokenCountMap?.[0];
+      expect(adjustedTokens).toBeDefined();
+      expect(Number.isInteger(adjustedTokens)).toBe(true);
+    });
+  });
+
+  describe('cross-run summary token accounting', () => {
+    it('should conserve tokens: summary boundary excludes pre-boundary messages from the map', () => {
+      const payload: TPayload = [
+        { role: 'user', content: 'Old question' },
+        { role: 'assistant', content: 'Old answer' },
+        {
+          role: 'assistant',
+          content: [
+            { type: ContentTypes.TEXT, text: 'Text before summary' },
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'This is a conversation summary capturing prior context.',
+              tokenCount: 25,
+            },
+            { type: ContentTypes.TEXT, text: 'Text after summary' },
+          ],
+        },
+        { role: 'user', content: 'New question after summary' },
+        { role: 'assistant', content: 'New answer after summary' },
+      ];
+
+      const indexTokenCountMap = {
+        0: 8,
+        1: 12,
+        2: 60,
+        3: 10,
+        4: 15,
+      };
+
+      const result = formatAgentMessages(payload, indexTokenCountMap);
+
+      expect(result.summary).toBeDefined();
+      expect(result.summary!.text).toBe(
+        'This is a conversation summary capturing prior context.'
+      );
+      expect(result.summary!.tokenCount).toBe(25);
+
+      const outputKeys = Object.keys(result.indexTokenCountMap || {}).map(
+        Number
+      );
+      expect(outputKeys).toHaveLength(3);
+
+      const boundaryMsgTokens = result.indexTokenCountMap?.[0] ?? 0;
+      expect(boundaryMsgTokens).toBeLessThan(60);
+      expect(boundaryMsgTokens).toBeGreaterThan(0);
+      expect(result.indexTokenCountMap?.[1]).toBe(10);
+      expect(result.indexTokenCountMap?.[2]).toBe(15);
+    });
+
+    it('should preserve summary token at index 0 when tool calls expand post-boundary messages', () => {
+      const payload: TPayload = [
+        { role: 'user', content: 'Summarized away' },
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'Summary of the conversation so far.',
+              tokenCount: 20,
+            },
+          ],
+        },
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: ContentTypes.TEXT,
+              [ContentTypes.TEXT]: 'Let me compute that.',
+              tool_call_ids: ['calc_1'],
+            },
+            {
+              type: ContentTypes.TOOL_CALL,
+              tool_call: {
+                id: 'calc_1',
+                name: 'calculator',
+                args: '{"expr":"2+2"}',
+                output: '4',
+              },
+            },
+            {
+              type: ContentTypes.TEXT,
+              [ContentTypes.TEXT]: 'The answer is 4.',
+            },
+          ],
+        },
+        { role: 'user', content: 'Thanks!' },
+      ];
+
+      const indexTokenCountMap = {
+        0: 5,
+        1: 30,
+        2: 80,
+        3: 6,
+      };
+
+      const result = formatAgentMessages(payload, indexTokenCountMap);
+
+      expect(result.summary).toBeDefined();
+      expect(result.summary!.text).toBe('Summary of the conversation so far.');
+      expect(result.summary!.tokenCount).toBe(20);
+
+      const totalTokens = Object.values(result.indexTokenCountMap || {}).reduce(
+        (sum, count) => sum + count,
+        0
+      );
+      expect(totalTokens).toBe(80 + 6);
+    });
+
+    it('should produce correct maps across a simulated multi-run lifecycle', () => {
+      const run1Payload: TPayload = [
+        { role: 'user', content: 'What is 2+2?' },
+        { role: 'assistant', content: 'The answer is 4.' },
+      ];
+      const run1Map = { 0: 10, 1: 12 };
+
+      const run1Result = formatAgentMessages(run1Payload, run1Map);
+      expect(run1Result.messages).toHaveLength(2);
+      expect(run1Result.indexTokenCountMap?.[0]).toBe(10);
+      expect(run1Result.indexTokenCountMap?.[1]).toBe(12);
+
+      const run2Payload: TPayload = [
+        ...run1Payload,
+        { role: 'user', content: 'Now multiply 4 by 10.' },
+        {
+          role: 'assistant',
+          content: [
+            { type: ContentTypes.TEXT, text: 'Sure, the answer is 40.' },
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'User asked basic arithmetic: 2+2=4, then 4*10=40.',
+              tokenCount: 18,
+            },
+          ],
+        },
+      ];
+      const run2Map = { 0: 10, 1: 12, 2: 14, 3: 50 };
+
+      const run2Result = formatAgentMessages(run2Payload, run2Map);
+      expect(run2Result.summary).toBeDefined();
+      expect(run2Result.summary!.text).toBe(
+        'User asked basic arithmetic: 2+2=4, then 4*10=40.'
+      );
+      expect(run2Result.summary!.tokenCount).toBe(18);
+
+      const run2TotalPostBoundary = Object.values(
+        run2Result.indexTokenCountMap || {}
+      ).reduce((sum, v) => sum + v, 0);
+      expect(run2TotalPostBoundary).toBe(0);
+
+      const run3Payload: TPayload = [
+        {
+          role: 'assistant',
+          content: [
+            {
+              type: ContentTypes.SUMMARY,
+              text: 'User asked basic arithmetic: 2+2=4, then 4*10=40.',
+              tokenCount: 18,
+            },
+          ],
+        },
+        { role: 'user', content: 'What is the square root of 40?' },
+        {
+          role: 'assistant',
+          content: 'The square root of 40 is approximately 6.32.',
+        },
+      ];
+      const run3Map = { 0: 18, 1: 15, 2: 20 };
+
+      const run3Result = formatAgentMessages(run3Payload, run3Map);
+      expect(run3Result.summary).toBeDefined();
+      expect(run3Result.summary!.text).toBe(
+        'User asked basic arithmetic: 2+2=4, then 4*10=40.'
+      );
+      expect(run3Result.summary!.tokenCount).toBe(18);
+
+      const run3Total = Object.values(
+        run3Result.indexTokenCountMap || {}
+      ).reduce((sum, count) => sum + count, 0);
+      expect(run3Total).toBe(15 + 20);
+    });
+  });
 });

package/src/messages/index.ts

@@ -5,3 +5,6 @@ export * from './format';
 export * from './cache';
 export * from './content';
 export * from './tools';
+export * from './contextPruning';
+export * from './contextPruningSettings';
+export * from './reducer';