@librechat/agents 3.1.77-dev.1 → 3.1.78-dev.0

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

@@ -1,4 +1,4 @@
-import { HumanMessage } from '@langchain/core/messages';
+import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
 import type { RunnableConfig } from '@langchain/core/runnables';
 import type * as t from '@/types';
 import { GraphEvents, Providers } from '@/common';
@@ -16,7 +16,13 @@ import { AgentContext } from '@/agents/AgentContext';
 // ---------------------------------------------------------------------------
 
 /** Creates a real AgentContext via fromConfig with sensible defaults.
- *  Extra properties are assigned directly for test-specific overrides. */
+ *  Extra properties are assigned directly for test-specific overrides.
+ *
+ *  Defaults `retainRecent.turns` to `0` so that tests which use 1–2 message
+ *  states still exercise the LLM-call summarization path.  The recency-window
+ *  default of `2` turns would otherwise short-circuit summarization for those
+ *  inputs.  Tests that target recency-window behavior should pass an explicit
+ *  `summarizationConfig.retainRecent` value. */
 function createAgentContext(
   overrides: Record<string, unknown> = {}
 ): AgentContext {
@@ -32,12 +38,17 @@ function createAgentContext(
     ...extra
   } = overrides;
 
+  const effectiveSummarizationConfig =
+    summarizationConfig != null
+      ? summarizationConfig
+      : { retainRecent: { turns: 0 } };
+
   const ctx = AgentContext.fromConfig({
     agentId: agentId as string,
     provider: provider as Providers,
     instructions: instructions as string,
     summarizationEnabled: summarizationEnabled as boolean,
-    ...(summarizationConfig != null ? { summarizationConfig } : {}),
+    summarizationConfig: effectiveSummarizationConfig,
     ...(maxContextTokens != null ? { maxContextTokens } : {}),
     ...(tools != null ? { tools } : {}),
   } as import('@/types').AgentInputs);
@@ -706,6 +717,491 @@ describe('budget check — instructions exceed context', () => {
   });
 });
 
+describe('recency window — first-turn protection', () => {
+  it('skips the LLM call when only one turn exists (default turns: 2)', async () => {
+    const events = captureEvents();
+
+    const invokeMock = jest
+      .fn()
+      .mockResolvedValue({ content: 'should not be called' });
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return { invoke: invokeMock };
+        }
+      } as never
+    );
+
+    const setSummary = jest.fn();
+    const agentContext = createAgentContext({
+      summarizationConfig: {} /* defaults to retainRecent.turns = 2 */,
+      setSummary,
+    } as never);
+    const graph = mockGraph();
+    const summarizeNode = createSummarizeNode({
+      agentContext,
+      graph: graph as never,
+      generateStepId,
+    });
+
+    const largePayload = 'paste'.repeat(10_000);
+    const result = await summarizeNode(
+      {
+        messages: [new HumanMessage(largePayload)],
+        summarizationRequest: {
+          remainingContextTokens: 0,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    // No LLM call — first user message is preserved verbatim.
+    expect(invokeMock).not.toHaveBeenCalled();
+    expect(setSummary).not.toHaveBeenCalled();
+    // No state mutation — original messages stay.
+    expect(result.messages).toBeUndefined();
+    expect(result.summarizationRequest).toBeUndefined();
+    // No ON_SUMMARIZE_START emitted on the skip path.
+    const eventNames = events.map((e) => e.event);
+    expect(eventNames).not.toContain(GraphEvents.ON_SUMMARIZE_START);
+    expect(eventNames).not.toContain(GraphEvents.ON_SUMMARIZE_COMPLETE);
+  });
+
+  it('skips when a single-turn includes assistant + tool messages', async () => {
+    captureEvents();
+
+    const invokeMock = jest.fn().mockResolvedValue({ content: 'unused' });
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return { invoke: invokeMock };
+        }
+      } as never
+    );
+
+    const setSummary = jest.fn();
+    const agentContext = createAgentContext({
+      summarizationConfig: {},
+      setSummary,
+    } as never);
+    const graph = mockGraph();
+    const summarizeNode = createSummarizeNode({
+      agentContext,
+      graph: graph as never,
+      generateStepId,
+    });
+
+    const result = await summarizeNode(
+      {
+        messages: [
+          new HumanMessage('the first user prompt'),
+          new AIMessage({
+            content: '',
+            tool_calls: [{ id: 'c', name: 'search', args: {} }],
+          }),
+          new ToolMessage({
+            content: 'result',
+            tool_call_id: 'c',
+            name: 'search',
+          }),
+          new AIMessage('here is what i found'),
+        ],
+        summarizationRequest: {
+          remainingContextTokens: 0,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    expect(invokeMock).not.toHaveBeenCalled();
+    expect(setSummary).not.toHaveBeenCalled();
+    expect(result.messages).toBeUndefined();
+  });
+
+  it('still summarizes the head when older turns exist beyond the recency window', async () => {
+    captureEvents();
+
+    let capturedMessages: { type: string; content: unknown }[] = [];
+    const invokeMock = jest.fn().mockImplementation((messages: unknown) => {
+      capturedMessages = (
+        messages as Array<{ getType: () => string; content: unknown }>
+      ).map((m) => ({ type: m.getType(), content: m.content }));
+      return Promise.resolve({ content: 'Summary of older turns' });
+    });
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return { invoke: invokeMock };
+        }
+      } as never
+    );
+
+    const setSummary = jest.fn();
+    const agentContext = createAgentContext({
+      summarizationConfig: { retainRecent: { turns: 1 } },
+      setSummary,
+    } as never);
+    const graph = mockGraph();
+    const summarizeNode = createSummarizeNode({
+      agentContext,
+      graph: graph as never,
+      generateStepId,
+    });
+
+    const messages = [
+      new HumanMessage('turn 1 query'),
+      new AIMessage('turn 1 reply'),
+      new HumanMessage('turn 2 query'),
+      new AIMessage('turn 2 reply'),
+    ];
+    const result = await summarizeNode(
+      {
+        messages,
+        summarizationRequest: {
+          remainingContextTokens: 0,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    // Head (turn 1) summarized; tail (turn 2) preserved verbatim.
+    expect(setSummary).toHaveBeenCalledWith(
+      expect.stringContaining('Summary of older turns'),
+      expect.any(Number)
+    );
+    // Captured messages are the head + the appended summarization instruction.
+    // Head has 2 messages (turn 1) + 1 instruction = 3 total.
+    expect(capturedMessages).toHaveLength(3);
+    expect(capturedMessages[0]?.content).toBe('turn 1 query');
+    expect(capturedMessages[1]?.content).toBe('turn 1 reply');
+
+    // Returned messages: removeAll marker + tail.
+    expect(result.messages).toBeDefined();
+    expect(result.messages![0]?._getType()).toBe('remove');
+    expect(result.messages!.slice(1)).toHaveLength(2);
+    expect((result.messages![1] as HumanMessage).content).toBe('turn 2 query');
+    expect((result.messages![2] as AIMessage).content).toBe('turn 2 reply');
+  });
+
+  it('keeps the masked tail content (does not re-inject restored tool payloads into state)', async () => {
+    captureEvents();
+
+    let summarizerSawRestored = false;
+    const invokeMock = jest.fn().mockImplementation((messages: unknown) => {
+      const arr = messages as Array<{
+        getType: () => string;
+        content: unknown;
+        tool_call_id?: string;
+      }>;
+      // Confirm the summarizer's input for the restored tool result has
+      // the FULL content, not the masked stub.
+      summarizerSawRestored = arr.some(
+        (m) =>
+          m.getType() === 'tool' &&
+          typeof m.content === 'string' &&
+          (m.content as string).includes('FULL_ORIGINAL_OUTPUT')
+      );
+      return Promise.resolve({ content: 'summary' });
+    });
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return { invoke: invokeMock };
+        }
+      } as never
+    );
+
+    const setSummary = jest.fn();
+    const agentContext = createAgentContext({
+      summarizationConfig: { retainRecent: { turns: 1 } },
+      setSummary,
+    } as never);
+    // Restoration map keyed by message index — applies to head (idx 2)
+    // AND to a tool message inside the retained tail (idx 5).  Only the
+    // head's restoration should leak into the summarizer; the tail must
+    // keep the masked content.
+    agentContext.pendingOriginalToolContent = new Map<number, string>([
+      [2, 'FULL_ORIGINAL_OUTPUT for head tool result'],
+      [5, 'FULL_ORIGINAL_OUTPUT for tail tool result — must NOT survive'],
+    ]);
+
+    const graph = mockGraph();
+    const summarizeNode = createSummarizeNode({
+      agentContext,
+      graph: graph as never,
+      generateStepId,
+    });
+
+    const headToolCall = new AIMessage({
+      content: '',
+      tool_calls: [{ id: 'h', name: 'search', args: {} }],
+    });
+    const headToolResult = new ToolMessage({
+      content: 'masked-head-stub',
+      tool_call_id: 'h',
+      name: 'search',
+    });
+    const tailToolCall = new AIMessage({
+      content: '',
+      tool_calls: [{ id: 't', name: 'search', args: {} }],
+    });
+    const tailToolResult = new ToolMessage({
+      content: 'masked-tail-stub',
+      tool_call_id: 't',
+      name: 'search',
+    });
+    const messages = [
+      new HumanMessage('turn 1 query'),
+      headToolCall,
+      headToolResult, // index 2 — restored for summarizer
+      new HumanMessage('turn 2 query'),
+      tailToolCall,
+      tailToolResult, // index 5 — must stay masked in returned tail
+    ];
+
+    const result = await summarizeNode(
+      {
+        messages,
+        summarizationRequest: {
+          remainingContextTokens: 0,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    // Summarizer saw the full restored head tool result.
+    expect(summarizerSawRestored).toBe(true);
+
+    // Returned tail must contain the MASKED tool result, not the restored one.
+    expect(result.messages).toBeDefined();
+    const tailToolMsg = result.messages!.find(
+      (m) => m._getType() === 'tool'
+    ) as ToolMessage | undefined;
+    expect(tailToolMsg).toBeDefined();
+    expect(tailToolMsg!.content).toBe('masked-tail-stub');
+    expect(tailToolMsg!.content).not.toContain('FULL_ORIGINAL_OUTPUT');
+  });
+
+  it('preserves tail-relevant pendingOriginalToolContent entries (reindexed) for future summaries', async () => {
+    captureEvents();
+
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return mockInvokeModel('summary');
+        }
+      } as never
+    );
+
+    const setSummary = jest.fn();
+    const agentContext = createAgentContext({
+      summarizationConfig: { retainRecent: { turns: 1 } },
+      setSummary,
+    } as never);
+    // Original-content map covers BOTH a head index (1) and tail indices
+    // (3, 5).  Only the tail entries should survive, reindexed to the
+    // post-removeAll state where tail messages start at 0.
+    agentContext.pendingOriginalToolContent = new Map<number, string>([
+      [1, 'fullHead'], // belongs to summarized head — should be dropped
+      [3, 'fullTailA'], // tail position 3 → reindexed to 0
+      [5, 'fullTailB'], // tail position 5 → reindexed to 2
+    ]);
+
+    const graph = mockGraph();
+    const summarizeNode = createSummarizeNode({
+      agentContext,
+      graph: graph as never,
+      generateStepId,
+    });
+
+    const messages = [
+      new HumanMessage('turn 1 query'),
+      new AIMessage('turn 1 reply'), // idx 1
+      new HumanMessage('turn 2 query'), // idx 2 — tail starts here
+      new ToolMessage({
+        // idx 3
+        content: 'masked-stub-A',
+        tool_call_id: 'a',
+        name: 'search',
+      }),
+      new AIMessage('turn 2 reply'), // idx 4
+      new ToolMessage({
+        // idx 5
+        content: 'masked-stub-B',
+        tool_call_id: 'b',
+        name: 'search',
+      }),
+    ];
+
+    await summarizeNode(
+      {
+        messages,
+        summarizationRequest: {
+          remainingContextTokens: 0,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    // Summarize fired (we used a real summary text), so head index 1
+    // is gone.  Tail entries should remain, reindexed by subtracting
+    // tailStartIndex (=2): 3→1, 5→3.
+    const carryOver = agentContext.pendingOriginalToolContent;
+    expect(carryOver).toBeDefined();
+    expect(carryOver!.size).toBe(2);
+    expect(carryOver!.get(1)).toBe('fullTailA');
+    expect(carryOver!.get(3)).toBe('fullTailB');
+    expect(carryOver!.has(0)).toBe(false);
+    expect(carryOver!.has(5)).toBe(false);
+  });
+
+  it('aligns the dedupe baseline with the surviving tail length after compaction', async () => {
+    captureEvents();
+
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return mockInvokeModel('summary');
+        }
+      } as never
+    );
+
+    const agentContext = createAgentContext({
+      summarizationConfig: { retainRecent: { turns: 1 } },
+    } as never);
+    const graph = mockGraph();
+    const summarizeNode = createSummarizeNode({
+      agentContext,
+      graph: graph as never,
+      generateStepId,
+    });
+
+    const messages = [
+      new HumanMessage('turn 1 query'),
+      new AIMessage('turn 1 reply'),
+      new HumanMessage('turn 2 query'),
+      new AIMessage('turn 2 reply'),
+    ];
+
+    await summarizeNode(
+      {
+        messages,
+        summarizationRequest: {
+          remainingContextTokens: 0,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    // Tail = last turn = 2 messages.  Baseline must equal that count
+    // so a follow-up prune call on the unchanged tail short-circuits
+    // via shouldSkipSummarization rather than re-triggering compaction.
+    expect(agentContext.shouldSkipSummarization(2)).toBe(true);
+    expect(agentContext.shouldSkipSummarization(3)).toBe(false);
+  });
+
+  it('does not clear pendingOriginalToolContent on the skip path (state unchanged)', async () => {
+    captureEvents();
+
+    const invokeMock = jest.fn();
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return { invoke: invokeMock };
+        }
+      } as never
+    );
+
+    const agentContext = createAgentContext({
+      summarizationConfig: { retainRecent: { turns: 2 } },
+    } as never);
+    const seededMap = new Map<number, string>([[1, 'preserved-original']]);
+    agentContext.pendingOriginalToolContent = seededMap;
+
+    const graph = mockGraph();
+    const summarizeNode = createSummarizeNode({
+      agentContext,
+      graph: graph as never,
+      generateStepId,
+    });
+
+    await summarizeNode(
+      {
+        messages: [
+          new HumanMessage('only turn'),
+          new ToolMessage({
+            content: 'masked',
+            tool_call_id: 'x',
+            name: 'search',
+          }),
+        ],
+        summarizationRequest: {
+          remainingContextTokens: 0,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    // No LLM call (skip path); pendingOriginalToolContent must still be
+    // available so a future summarization can restore the original.
+    expect(invokeMock).not.toHaveBeenCalled();
+    expect(agentContext.pendingOriginalToolContent).toBe(seededMap);
+    expect(agentContext.pendingOriginalToolContent!.get(1)).toBe(
+      'preserved-original'
+    );
+  });
+
+  it('preserves the legacy "remove all, summary only" shape when retainRecent.turns is 0', async () => {
+    captureEvents();
+
+    jest.spyOn(providers, 'getChatModelClass').mockReturnValue(
+      class {
+        constructor() {
+          return mockInvokeModel('Legacy summary');
+        }
+      } as never
+    );
+
+    const setSummary = jest.fn();
+    const agentContext = createAgentContext({
+      summarizationConfig: { retainRecent: { turns: 0 } },
+      setSummary,
+    } as never);
+    const graph = mockGraph();
+    const summarizeNode = createSummarizeNode({
+      agentContext,
+      graph: graph as never,
+      generateStepId,
+    });
+
+    const result = await summarizeNode(
+      {
+        messages: [
+          new HumanMessage('only message'),
+          new AIMessage('only reply'),
+        ],
+        summarizationRequest: {
+          remainingContextTokens: 0,
+          agentId: 'agent_0',
+        },
+      },
+      {} as RunnableConfig
+    );
+
+    expect(setSummary).toHaveBeenCalled();
+    // Legacy: remove-all only, no tail re-injection.
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages![0]?._getType()).toBe('remove');
+  });
+});
+
 describe('emoji-heavy content does not break summarization', () => {
   it('summarization completes without JSON errors on emoji-heavy messages', async () => {
     captureEvents();