@librechat/agents 3.1.57 → 3.1.61

package/src/specs/token-distribution-edge-case.test.ts

@@ -75,6 +75,7 @@ describe('Token Distribution Edge Case Tests', () => {
       startIndex: 0,
       tokenCounter,
       indexTokenCountMap: { ...indexTokenCountMap },
+      reserveRatio: 0,
     });
 
     // First call to establish lastCutOffIndex
@@ -115,18 +116,21 @@ describe('Token Distribution Edge Case Tests', () => {
 
     expect(atLeastOnePrunedMessageUnchanged).toBe(true);
 
-    // Verify that the sum of tokens for messages in the context is close to the total_tokens from usageMetadata
-    // There might be small rounding differences or implementation details that affect the exact sum
-    const totalContextTokens =
+    // Calibration uses input_tokens (30) only (no output), minus instruction overhead (0).
+    // Map stays in raw tiktoken space — calibrationRatio captures the multiplier.
+    // Context messages: indices 0, 3, 4 → raw sum unchanged.
+    // calibrationRatio × rawSum should approximate input_tokens (30).
+    const rawContextTokens =
       (result.indexTokenCountMap[0] ?? 0) +
       (result.indexTokenCountMap[3] ?? 0) +
       (result.indexTokenCountMap[4] ?? 0);
-    expect(totalContextTokens).toBeGreaterThan(0);
+    expect(rawContextTokens).toBeGreaterThan(0);
 
-    // The key thing we're testing is that the token distribution happens for messages in the context
-    // and that the sum is reasonably close to the expected total
-    const tokenDifference = Math.abs(totalContextTokens - 50);
-    expect(tokenDifference).toBeLessThan(20); // Allow for some difference due to implementation details
+    const calibratedTotal = Math.round(
+      rawContextTokens * (result.calibrationRatio ?? 1)
+    );
+    const tokenDifference = Math.abs(calibratedTotal - 30);
+    expect(tokenDifference).toBeLessThan(10);
   });
 
   it('should handle the case when all messages fit within the token limit', () => {
@@ -174,28 +178,22 @@ describe('Token Distribution Edge Case Tests', () => {
       usageMetadata,
     });
 
-    // Since all messages fit, all token counts should be adjusted
-    const initialTotalTokens =
-      indexTokenCountMap[0] + indexTokenCountMap[1] + indexTokenCountMap[2];
-    const expectedRatio = 30 / initialTotalTokens;
+    // Calibration uses input_tokens (20) only, minus instruction overhead (0).
+    // messageTokenSum = 17 + 9 + 10 = 36. ratio = 20/36 = 0.556. Safe.
+    // Map stays raw — calibrationRatio captures the multiplier
+    expect(result.indexTokenCountMap[0]).toBe(indexTokenCountMap[0]);
+    expect(result.indexTokenCountMap[1]).toBe(indexTokenCountMap[1]);
+    expect(result.indexTokenCountMap[2]).toBe(indexTokenCountMap[2]);
 
-    // Check that all token counts were adjusted
-    expect(result.indexTokenCountMap[0]).toBe(
-      Math.round(indexTokenCountMap[0] * expectedRatio)
-    );
-    expect(result.indexTokenCountMap[1]).toBe(
-      Math.round(indexTokenCountMap[1] * expectedRatio)
-    );
-    expect(result.indexTokenCountMap[2]).toBe(
-      Math.round(indexTokenCountMap[2] * expectedRatio)
-    );
-
-    // Verify that the sum of all tokens equals the total_tokens from usageMetadata
-    const totalTokens =
+    // rawSum × calibrationRatio should approximate input_tokens (20)
+    const rawTotal =
       (result.indexTokenCountMap[0] ?? 0) +
       (result.indexTokenCountMap[1] ?? 0) +
       (result.indexTokenCountMap[2] ?? 0);
-    expect(totalTokens).toBe(30);
+    const calibratedTotal = Math.round(
+      rawTotal * (result.calibrationRatio ?? 1)
+    );
+    expect(Math.abs(calibratedTotal - 20)).toBeLessThanOrEqual(3);
   });
 
   it('should handle multiple pruning operations with token redistribution', () => {
@@ -230,6 +228,7 @@ describe('Token Distribution Edge Case Tests', () => {
       startIndex: 0,
       tokenCounter,
       indexTokenCountMap: { ...indexTokenCountMap },
+      reserveRatio: 0,
     });
 
     // First pruning operation

package/src/splitStream.test.ts

@@ -254,7 +254,8 @@ After code.`;
 
     const codeBlockPart = contentParts.find(
       (part) =>
-        part?.type === ContentTypes.TEXT && part.text.includes('```python')
+        part?.type === ContentTypes.TEXT &&
+        part.text.includes('```python') === true
     );
 
     expect(codeBlockPart).toBeDefined();
@@ -493,46 +494,51 @@ describe('SplitStreamHandler', () => {
 
     // Check that content before <think> was handled as regular text
     expect(
-      messageDeltaEvents.some((event) =>
-        (
-          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
-        )?.text.includes('Here\'s')
+      messageDeltaEvents.some(
+        (event) =>
+          (
+            event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+          )?.text.includes('Here\'s') === true
       )
     ).toBe(true);
 
     // Check that <think> tag was handled as reasoning
     expect(
-      reasoningDeltaEvents.some((event) =>
-        (
-          event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined
-        )?.think.includes('<think>')
+      reasoningDeltaEvents.some(
+        (event) =>
+          (
+            event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined
+          )?.think.includes('<think>') === true
       )
     ).toBe(true);
 
     // Check that content inside <think> tags was handled as reasoning
     expect(
-      reasoningDeltaEvents.some((event) =>
-        (
-          event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined
-        )?.think.includes('thinking')
+      reasoningDeltaEvents.some(
+        (event) =>
+          (
+            event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined
+          )?.think.includes('thinking') === true
       )
     ).toBe(true);
 
     // Check that </think> tag was handled as reasoning
     expect(
-      reasoningDeltaEvents.some((event) =>
-        (
-          event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined
-        )?.think.includes('</think>')
+      reasoningDeltaEvents.some(
+        (event) =>
+          (
+            event.delta.content?.[0] as t.ReasoningDeltaUpdate | undefined
+          )?.think.includes('</think>') === true
       )
     ).toBe(true);
 
     // Check that content after </think> was handled as regular text
     expect(
-      messageDeltaEvents.some((event) =>
-        (
-          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
-        )?.text.includes('Back')
+      messageDeltaEvents.some(
+        (event) =>
+          (
+            event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+          )?.text.includes('Back') === true
       )
     ).toBe(true);
   });
@@ -568,10 +574,11 @@ describe('SplitStreamHandler', () => {
 
     // Check that think tags inside code blocks were treated as regular text
     expect(
-      messageDeltaEvents.some((event) =>
-        (
-          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
-        )?.text.includes('Regular')
+      messageDeltaEvents.some(
+        (event) =>
+          (
+            event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+          )?.text.includes('Regular') === true
       )
     ).toBe(true);
 
@@ -622,10 +629,11 @@ describe('SplitStreamHandler', () => {
 
     // Check that content before <think> was handled as regular text
     expect(
-      messageDeltaEvents.some((event) =>
-        (
-          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
-        )?.text.includes('regular')
+      messageDeltaEvents.some(
+        (event) =>
+          (
+            event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+          )?.text.includes('regular') === true
       )
     ).toBe(true);
 
@@ -673,10 +681,11 @@ describe('SplitStreamHandler', () => {
 
     // Check that content after </think> was handled as regular text
     expect(
-      messageDeltaEvents.some((event) =>
-        (
-          event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
-        )?.text.includes('Back')
+      messageDeltaEvents.some(
+        (event) =>
+          (
+            event.delta.content?.[0] as t.MessageDeltaUpdate | undefined
+          )?.text.includes('Back') === true
       )
     ).toBe(true);
 

package/src/stream.ts

@@ -148,6 +148,7 @@ export class ChatModelStreamHandler implements t.EventHandler {
     if (!graph.config) {
       throw new Error('Config not found in graph');
     }
+
     if (!data.chunk) {
       console.warn(`No chunk found in ${event} event`);
       return;
@@ -513,6 +514,18 @@ export function createContentAggregator(): t.ContentAggregatorResult {
       };
 
       contentParts[index] = update;
+    } else if (partType === ContentTypes.SUMMARY) {
+      const currentSummary = contentParts[index] as
+        | t.SummaryContentBlock
+        | undefined;
+      const incoming = contentPart as t.SummaryContentBlock;
+      contentParts[index] = {
+        ...incoming,
+        content: [
+          ...(currentSummary?.content ?? []),
+          ...(incoming.content ?? []),
+        ],
+      };
     } else if (
       partType === ContentTypes.IMAGE_URL &&
       'image_url' in contentPart
@@ -618,9 +631,41 @@ export function createContentAggregator(): t.ContentAggregatorResult {
       | t.RunStep
       | t.AgentUpdate
       | t.MessageDeltaEvent
+      | t.ReasoningDeltaEvent
       | t.RunStepDeltaEvent
+      | t.SummarizeDeltaData
+      | t.SummarizeCompleteEvent
       | { result: t.ToolEndEvent };
   }): void => {
+    if (event === GraphEvents.ON_SUMMARIZE_DELTA) {
+      const deltaData = data as t.SummarizeDeltaData;
+      const runStep = stepMap.get(deltaData.id);
+      if (!runStep) {
+        console.warn('No run step found for summarize delta event');
+        return;
+      }
+      updateContent(runStep.index, deltaData.delta.summary);
+      return;
+    }
+
+    if (event === GraphEvents.ON_SUMMARIZE_COMPLETE) {
+      const completeData = data as t.SummarizeCompleteEvent;
+      const summary = completeData.summary;
+      if (!summary?.boundary) {
+        return;
+      }
+      const runStep = stepMap.get(summary.boundary.messageId);
+      if (!runStep) {
+        return;
+      }
+      // Replace accumulated delta text with the authoritative final summary.
+      // Multi-stage summarization streams deltas from each chunk, which
+      // concatenate in updateContent.  This event carries only the correct
+      // final text from the last stage.
+      contentParts[runStep.index] = summary;
+      return;
+    }
+
     if (event === GraphEvents.ON_RUN_STEP) {
       const runStep = data as t.RunStep;
       stepMap.set(runStep.id, runStep);
@@ -641,7 +686,10 @@ export function createContentAggregator(): t.ContentAggregatorResult {
         contentMetaMap.set(runStep.index, existingMeta);
       }
 
-      // Store tool call IDs if present
+      if (runStep.summary != null) {
+        updateContent(runStep.index, runStep.summary);
+      }
+
       if (
         runStep.stepDetails.type === StepTypes.TOOL_CALLS &&
         runStep.stepDetails.tool_calls
@@ -732,24 +780,29 @@ export function createContentAggregator(): t.ContentAggregatorResult {
         });
       }
     } else if (event === GraphEvents.ON_RUN_STEP_COMPLETED) {
-      const { result } = data as unknown as { result: t.ToolEndEvent };
+      const { result } = data as unknown as {
+        result:
+          | t.ToolEndEvent
+          | (t.SummaryCompleted & { id: string; index: number });
+      };
 
       const { id: stepId } = result;
 
       const runStep = stepMap.get(stepId);
       if (!runStep) {
-        console.warn(
-          'No run step or runId found for completed tool call event'
-        );
+        console.warn('No run step or runId found for completed step event');
         return;
       }
 
-      const contentPart: t.MessageContentComplex = {
-        type: ContentTypes.TOOL_CALL,
-        tool_call: result.tool_call,
-      };
-
-      updateContent(runStep.index, contentPart, true);
+      if (result.type === ContentTypes.SUMMARY && 'summary' in result) {
+        contentParts[runStep.index] = result.summary as t.MessageContentComplex;
+      } else if ('tool_call' in result) {
+        const contentPart: t.MessageContentComplex = {
+          type: ContentTypes.TOOL_CALL,
+          tool_call: (result as t.ToolEndEvent).tool_call,
+        };
+        updateContent(runStep.index, contentPart, true);
+      }
     }
   };
 

package/src/summarization/__tests__/aggregator.test.ts

@@ -0,0 +1,153 @@
+import { createContentAggregator } from '@/stream';
+import { ContentTypes, GraphEvents, StepTypes } from '@/common';
+import type * as t from '@/types';
+
+describe('createContentAggregator – SUMMARY accumulation', () => {
+  it('accumulates text from multiple ON_SUMMARIZE_DELTA events', () => {
+    const { aggregateContent, contentParts } = createContentAggregator();
+
+    // Register a run step with a summary placeholder
+    const runStep: t.RunStep = {
+      stepIndex: 0,
+      id: 'step_sum_1',
+      type: StepTypes.MESSAGE_CREATION,
+      index: 0,
+      stepDetails: {
+        type: StepTypes.MESSAGE_CREATION,
+        message_creation: { message_id: 'step_sum_1' },
+      },
+      summary: {
+        type: ContentTypes.SUMMARY,
+        content: [],
+        tokenCount: 0,
+        provider: 'openai',
+      },
+      usage: null,
+    };
+
+    aggregateContent({
+      event: GraphEvents.ON_RUN_STEP,
+      data: runStep,
+    });
+
+    // The run step registration sets the initial placeholder
+    expect(contentParts[0]).toEqual(
+      expect.objectContaining({ type: ContentTypes.SUMMARY, content: [] })
+    );
+
+    // Send multiple deltas with content chunks
+    aggregateContent({
+      event: GraphEvents.ON_SUMMARIZE_DELTA,
+      data: {
+        id: 'step_sum_1',
+        delta: {
+          summary: {
+            type: ContentTypes.SUMMARY,
+            content: [{ type: 'text', text: 'Hello ' }],
+            tokenCount: 0,
+            provider: 'openai',
+          },
+        },
+      } as t.SummarizeDeltaData,
+    });
+
+    const afterFirst = contentParts[0] as t.SummaryContentBlock;
+    expect(afterFirst.content).toHaveLength(1);
+    expect((afterFirst.content![0] as { text: string }).text).toBe('Hello ');
+
+    aggregateContent({
+      event: GraphEvents.ON_SUMMARIZE_DELTA,
+      data: {
+        id: 'step_sum_1',
+        delta: {
+          summary: {
+            type: ContentTypes.SUMMARY,
+            content: [{ type: 'text', text: 'world!' }],
+            tokenCount: 0,
+            provider: 'openai',
+          },
+        },
+      } as t.SummarizeDeltaData,
+    });
+
+    // Should accumulate content blocks, not replace
+    const afterSecond = contentParts[0] as t.SummaryContentBlock;
+    expect(afterSecond.content).toHaveLength(2);
+    expect((afterSecond.content![0] as { text: string }).text).toBe('Hello ');
+    expect((afterSecond.content![1] as { text: string }).text).toBe('world!');
+  });
+
+  it('preserves metadata fields from the latest delta', () => {
+    const { aggregateContent, contentParts } = createContentAggregator();
+
+    const runStep: t.RunStep = {
+      stepIndex: 0,
+      id: 'step_sum_2',
+      type: StepTypes.MESSAGE_CREATION,
+      index: 0,
+      stepDetails: {
+        type: StepTypes.MESSAGE_CREATION,
+        message_creation: { message_id: 'step_sum_2' },
+      },
+      summary: {
+        type: ContentTypes.SUMMARY,
+        content: [],
+        tokenCount: 0,
+        provider: 'anthropic',
+        model: 'claude-sonnet-4-5',
+      },
+      usage: null,
+    };
+
+    aggregateContent({
+      event: GraphEvents.ON_RUN_STEP,
+      data: runStep,
+    });
+
+    aggregateContent({
+      event: GraphEvents.ON_SUMMARIZE_DELTA,
+      data: {
+        id: 'step_sum_2',
+        delta: {
+          summary: {
+            type: ContentTypes.SUMMARY,
+            content: [{ type: 'text', text: 'chunk' }],
+            tokenCount: 0,
+            provider: 'anthropic',
+            model: 'claude-sonnet-4-5',
+          },
+        },
+      } as t.SummarizeDeltaData,
+    });
+
+    const part = contentParts[0] as t.SummaryContentBlock;
+    expect(part.provider).toBe('anthropic');
+    expect(part.model).toBe('claude-sonnet-4-5');
+  });
+
+  it('handles delta when no run step exists', () => {
+    const { aggregateContent, contentParts } = createContentAggregator();
+
+    // No run step registered — should warn and not crash
+    const consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    aggregateContent({
+      event: GraphEvents.ON_SUMMARIZE_DELTA,
+      data: {
+        id: 'nonexistent',
+        delta: {
+          summary: {
+            type: ContentTypes.SUMMARY,
+            content: [{ type: 'text', text: 'orphan' }],
+            tokenCount: 0,
+          },
+        },
+      } as t.SummarizeDeltaData,
+    });
+
+    expect(consoleSpy).toHaveBeenCalled();
+    expect(contentParts.length).toBe(0);
+
+    consoleSpy.mockRestore();
+  });
+});