@illuma-ai/agents 1.1.2 → 1.1.4

package/src/graphs/gapFeatures.test.ts

@@ -627,7 +627,326 @@ describe('Proactive Summarization — Context Pressure', () => {
 
     // Even at 100%+, we use the existing cached summary — no error thrown
     expect(cachedSummary).toBeTruthy();
-    // Pruning will remove oldest messages to fit, and inject cached summary
-    // The key: no blocking, no throwing, just graceful degradation
+    // Compaction builds a windowed view — no messages deleted, no throwing
+  });
+});
+
+// ===========================================================================
+// Context Compaction (Copilot-style: never delete messages)
+// ===========================================================================
+
+import { applyCalibration as _applyCalibration } from '@/utils/pruneCalibration';
+import { COMPACTION_RECENT_ROUNDS } from '@/common/constants';
+
+describe('Context Compaction — Windowed View (no message deletion)', () => {
+  /**
+   * Simulates the compaction logic from Graph.ts without the full Graph instance.
+   * Mirrors the two modes:
+   *   A) No summary → fill budget with as many recent messages as fit
+   *   B) Summary exists → keep last COMPACTION_RECENT_ROUNDS rounds only
+   */
+  function buildWindowedView(opts: {
+    messages: BaseMessage[];
+    indexTokenCountMap: Record<string, number | undefined>;
+    maxTokens: number;
+    summary?: string;
+    tokenCounter: TokenCounter;
+  }) {
+    const { messages, indexTokenCountMap, maxTokens, summary, tokenCounter } = opts;
+
+    const systemMsg = messages[0]?.getType() === 'system' ? messages[0] : null;
+    const systemTokens = systemMsg != null ? (indexTokenCountMap[0] ?? 0) : 0;
+    const summaryMsg = summary
+      ? new SystemMessage(`[Conversation Summary]\n${summary}`)
+      : null;
+    const summaryTokens = summaryMsg != null ? tokenCounter(summaryMsg) : 0;
+
+    const recentBudget = maxTokens - systemTokens - summaryTokens - 3;
+    const contentStart = systemMsg != null ? 1 : 0;
+    let usedTokens = 0;
+    let windowStart = messages.length;
+
+    if (!summary) {
+      // Mode A: No summary — fill budget
+      for (let i = messages.length - 1; i >= contentStart; i--) {
+        const msgTokens = indexTokenCountMap[i] ?? 0;
+        if (usedTokens + msgTokens > recentBudget) break;
+        usedTokens += msgTokens;
+        windowStart = i;
+      }
+    } else {
+      // Mode B: Summary exists — keep last N rounds
+      let roundsSeen = 0;
+      for (let i = messages.length - 1; i >= contentStart; i--) {
+        const msgType = messages[i]?.getType();
+        const msgTokens = indexTokenCountMap[i] ?? 0;
+        if (usedTokens + msgTokens > recentBudget) break;
+        usedTokens += msgTokens;
+        windowStart = i;
+        if (msgType === 'human') {
+          roundsSeen++;
+          if (roundsSeen >= COMPACTION_RECENT_ROUNDS) break;
+        }
+      }
+    }
+
+    // Don't split tool-call / tool-result pairs
+    while (
+      windowStart > contentStart &&
+      messages[windowStart]?.getType() === 'tool'
+    ) {
+      windowStart--;
+      usedTokens += indexTokenCountMap[windowStart] ?? 0;
+    }
+
+    const recentMessages = messages.slice(windowStart);
+    const compactedMessages = messages.slice(contentStart, windowStart);
+
+    const view: BaseMessage[] = [];
+    if (systemMsg) view.push(systemMsg);
+    if (summaryMsg) view.push(summaryMsg);
+    view.push(...recentMessages);
+
+    return { view, compactedMessages, recentMessages, usedTokens };
+  }
+
+  it('builds a windowed view without deleting any messages', () => {
+    const messages = buildConversation(20, 400); // system + 20 content msgs
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = simpleTokenCounter(messages[i]);
+    }
+
+    const { view, compactedMessages, recentMessages } = buildWindowedView({
+      messages,
+      indexTokenCountMap,
+      maxTokens: 500, // small budget forces windowing
+      tokenCounter: simpleTokenCounter,
+    });
+
+    // View is smaller than original
+    expect(view.length).toBeLessThan(messages.length);
+    // But original messages array is untouched
+    expect(messages.length).toBe(21); // system + 20
+    // Compacted + recent = all non-system messages
+    expect(compactedMessages.length + recentMessages.length).toBe(20);
+    // View starts with system message
+    expect(view[0].getType()).toBe('system');
+  });
+
+  it('injects summary message covering compacted (windowed-out) messages', () => {
+    const messages = buildConversation(20, 400);
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = simpleTokenCounter(messages[i]);
+    }
+
+    const summary = 'Summary of earlier conversation turns';
+    const { view, compactedMessages } = buildWindowedView({
+      messages,
+      indexTokenCountMap,
+      maxTokens: 600,
+      summary,
+      tokenCounter: simpleTokenCounter,
+    });
+
+    // Summary is injected after system message
+    expect(view[1].content).toContain('[Conversation Summary]');
+    expect(view[1].content).toContain(summary);
+    // There should be compacted messages behind the summary
+    expect(compactedMessages.length).toBeGreaterThan(0);
+    // Original array is unchanged
+    expect(messages.length).toBe(21);
+  });
+
+  it('includes all messages when budget is large enough (no compaction)', () => {
+    const messages = buildConversation(5, 100); // small conversation
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = simpleTokenCounter(messages[i]);
+    }
+
+    const { view, compactedMessages } = buildWindowedView({
+      messages,
+      indexTokenCountMap,
+      maxTokens: 100_000, // huge budget
+      tokenCounter: simpleTokenCounter,
+    });
+
+    // All messages fit — no compaction
+    expect(view.length).toBe(messages.length);
+    expect(compactedMessages.length).toBe(0);
+  });
+
+  it('does not split tool-call / tool-result pairs at window boundary', () => {
+    const messages: BaseMessage[] = [
+      new SystemMessage('System'),
+      new HumanMessage('old question'),
+      new AIMessage('old answer'),
+      new HumanMessage('question about tool'),
+      new AIMessageChunk({
+        content: 'Let me search',
+        tool_calls: [{ id: 'tc_1', name: 'web_search', args: {} }],
+      }),
+      new ToolMessage({ content: 'Search results', tool_call_id: 'tc_1', name: 'web_search' }),
+      new AIMessage('Based on the search results...'),
+      new HumanMessage('latest question'),
+      new AIMessage('latest answer'),
+    ];
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = simpleTokenCounter(messages[i]);
+    }
+
+    // Budget that would naturally cut between the AI tool-call and ToolMessage
+    // Force the window to start at the ToolMessage by making budget tight
+    const toolMsgIdx = 5; // ToolMessage index
+    let budgetUpToTool = 3; // priming tokens
+    for (let i = toolMsgIdx; i < messages.length; i++) {
+      budgetUpToTool += indexTokenCountMap[i] ?? 0;
+    }
+    // Budget includes ToolMessage but NOT the AI tool-call before it
+    // The algorithm should walk back to include the AI message too
+    const tightBudget = budgetUpToTool + (indexTokenCountMap[0] ?? 0) + 5;
+
+    const { view } = buildWindowedView({
+      messages,
+      indexTokenCountMap,
+      maxTokens: tightBudget,
+      tokenCounter: simpleTokenCounter,
+    });
+
+    // Verify no ToolMessage appears without its preceding AI message
+    for (let i = 0; i < view.length; i++) {
+      if (view[i].getType() === 'tool' && i > 0) {
+        // The message before a ToolMessage should be an AI message (the tool caller)
+        // or another ToolMessage (multi-tool scenario), or system
+        const prevType = view[i - 1].getType();
+        expect(['ai', 'tool', 'system']).toContain(prevType);
+      }
+    }
+  });
+
+  it('with summary, recent messages use remaining budget after summary tokens', () => {
+    const messages = buildConversation(20, 400);
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = simpleTokenCounter(messages[i]);
+    }
+
+    // Large summary eats into the budget
+    const largeSummary = 'S'.repeat(1000); // ~250 tokens
+    const { view: viewWithSummary, recentMessages: recentWithSummary } = buildWindowedView({
+      messages,
+      indexTokenCountMap,
+      maxTokens: 800,
+      summary: largeSummary,
+      tokenCounter: simpleTokenCounter,
+    });
+
+    // Without summary — more recent messages fit
+    const { recentMessages: recentWithout } = buildWindowedView({
+      messages,
+      indexTokenCountMap,
+      maxTokens: 800,
+      tokenCounter: simpleTokenCounter,
+    });
+
+    // Summary takes budget, so fewer recent messages fit
+    expect(recentWithSummary.length).toBeLessThan(recentWithout.length);
+  });
+
+  it('with summary, limits window to last 2 rounds (not budget-filling)', () => {
+    // 20 messages = 10 rounds. With summary, should only keep last 2 rounds (4 msgs).
+    const messages: BaseMessage[] = [
+      new SystemMessage('System prompt'),
+    ];
+    for (let i = 0; i < 20; i++) {
+      messages.push(
+        i % 2 === 0
+          ? new HumanMessage(`User question ${i / 2}`)
+          : new AIMessage(`AI answer ${(i - 1) / 2}`)
+      );
+    }
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = simpleTokenCounter(messages[i]);
+    }
+
+    const { view, recentMessages, compactedMessages } = buildWindowedView({
+      messages,
+      indexTokenCountMap,
+      maxTokens: 100_000, // huge budget — would fit everything
+      summary: 'Summary of earlier conversation',
+      tokenCounter: simpleTokenCounter,
+    });
+
+    // Despite huge budget, only last 2 rounds kept (4 content msgs: H+A+H+A)
+    // Plus possible trailing messages in the last round
+    expect(recentMessages.length).toBeLessThanOrEqual(5); // 2 rounds + maybe 1 trailing
+    expect(recentMessages.length).toBeGreaterThanOrEqual(4); // at least 2 full rounds
+
+    // Most messages are compacted behind the summary
+    expect(compactedMessages.length).toBeGreaterThan(10);
+
+    // View = system + summary + recent window
+    expect(view[0].getType()).toBe('system');
+    expect(view[1].content).toContain('[Conversation Summary]');
+  });
+
+  it('without summary, fills budget (no round limit)', () => {
+    const messages = buildConversation(20, 100); // small messages
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = simpleTokenCounter(messages[i]);
+    }
+
+    const { recentMessages: withoutSummary } = buildWindowedView({
+      messages,
+      indexTokenCountMap,
+      maxTokens: 100_000, // huge budget
+      tokenCounter: simpleTokenCounter,
+      // no summary → mode A
+    });
+
+    const { recentMessages: withSummary } = buildWindowedView({
+      messages,
+      indexTokenCountMap,
+      maxTokens: 100_000,
+      summary: 'Summary exists',
+      tokenCounter: simpleTokenCounter,
+    });
+
+    // Without summary: all messages included (budget-filling mode)
+    expect(withoutSummary.length).toBe(20); // all content messages
+    // With summary: only last 2 rounds
+    expect(withSummary.length).toBeLessThan(withoutSummary.length);
+  });
+
+  it('original messages array is never mutated', () => {
+    const messages = buildConversation(15, 400);
+    const originalLength = messages.length;
+    const originalFirstContent = messages[0].content;
+    const originalLastContent = messages[messages.length - 1].content;
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    for (let i = 0; i < messages.length; i++) {
+      indexTokenCountMap[i] = simpleTokenCounter(messages[i]);
+    }
+
+    // Run compaction multiple times
+    for (let i = 0; i < 5; i++) {
+      buildWindowedView({
+        messages,
+        indexTokenCountMap,
+        maxTokens: 300,
+        summary: `Summary iteration ${i}`,
+        tokenCounter: simpleTokenCounter,
+      });
+    }
+
+    // Original array unchanged after 5 compaction runs
+    expect(messages.length).toBe(originalLength);
+    expect(messages[0].content).toBe(originalFirstContent);
+    expect(messages[messages.length - 1].content).toBe(originalLastContent);
   });
 });