@illuma-ai/agents 1.1.1 → 1.1.3

package/src/graphs/gapFeatures.test.ts

@@ -518,3 +518,348 @@ describe('All Features Combined — Full Pipeline', () => {
     expect(callback).toHaveBeenCalled();
   });
 });
+
+// ===========================================================================
+// Proactive Summarization — Context Pressure
+// ===========================================================================
+
+import { getContextUtilization } from '@/messages/prune';
+import { PROACTIVE_SUMMARY_THRESHOLD } from '@/common/constants';
+
+describe('Proactive Summarization — Context Pressure', () => {
+  it('triggers proactive summary at 80% utilization BEFORE pruning', () => {
+    // Simulate context at 82% utilization
+    const maxContextTokens = 200_000;
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    // Build messages that fill ~82% of context
+    const msgsNeeded = 40;
+    const tokensPerMsg = Math.floor((maxContextTokens * 0.82) / msgsNeeded);
+    for (let i = 0; i < msgsNeeded; i++) {
+      indexTokenCountMap[String(i)] = tokensPerMsg;
+    }
+
+    const utilization = getContextUtilization(indexTokenCountMap, 0, maxContextTokens);
+    const threshold = PROACTIVE_SUMMARY_THRESHOLD * 100; // 80
+
+    expect(utilization).toBeGreaterThanOrEqual(threshold);
+    // At 82%, proactive summary should fire
+    // But pruning should NOT have happened yet (context < 90% safety factor)
+    const effectiveBudget = Math.floor(maxContextTokens * 0.9); // CONTEXT_SAFETY_FACTOR
+    const totalTokens = Object.values(indexTokenCountMap).reduce((s, v) => (s ?? 0) + (v ?? 0), 0) as number;
+    expect(totalTokens).toBeLessThan(effectiveBudget);
+  });
+
+  it('does NOT trigger proactive summary below 80%', () => {
+    const maxContextTokens = 200_000;
+    const indexTokenCountMap: Record<string, number | undefined> = {};
+    // Fill to 50% utilization
+    const msgsNeeded = 20;
+    const tokensPerMsg = Math.floor((maxContextTokens * 0.5) / msgsNeeded);
+    for (let i = 0; i < msgsNeeded; i++) {
+      indexTokenCountMap[String(i)] = tokensPerMsg;
+    }
+
+    const utilization = getContextUtilization(indexTokenCountMap, 0, maxContextTokens);
+    expect(utilization).toBeLessThan(PROACTIVE_SUMMARY_THRESHOLD * 100);
+  });
+
+  it('selects only older messages for proactive summarization (keeps recent turns)', () => {
+    const messages: BaseMessage[] = [
+      new SystemMessage('System prompt'),
+      ...Array.from({ length: 20 }, (_, i) =>
+        i % 2 === 0
+          ? new HumanMessage(`User message ${i}`)
+          : new AIMessage(`AI response ${i}`)
+      ),
+    ];
+
+    // Simulate the selection logic from Graph.ts proactive summarization
+    const recentTurnCount = Math.max(4, Math.floor(messages.length * 0.3));
+    const oldMessages = messages.slice(
+      1, // skip system message
+      Math.max(1, messages.length - recentTurnCount)
+    );
+
+    // Recent 30% (~6 messages) preserved, older messages selected for summary
+    expect(oldMessages.length).toBeLessThan(messages.length);
+    expect(oldMessages.length).toBeGreaterThan(0);
+    // System message not included
+    expect(oldMessages[0].getType()).not.toBe('system');
+    // Last messages of conversation not included (recent turns preserved)
+    const lastOldIndex = messages.indexOf(oldMessages[oldMessages.length - 1]);
+    expect(lastOldIndex).toBeLessThan(messages.length - recentTurnCount);
+  });
+
+  it('never blocks — proactive summary is always fire-and-forget', async () => {
+    let resolveCallback: ((v: string) => void) | undefined;
+    const slowCallback = jest.fn(
+      () =>
+        new Promise<string>((resolve) => {
+          resolveCallback = resolve;
+        })
+    );
+
+    // Simulate proactive summary fire-and-forget
+    const summaryPromise = slowCallback().then((updated) => {
+      return updated;
+    });
+
+    // Main flow continues immediately — callback hasn't resolved yet
+    expect(slowCallback).toHaveBeenCalledTimes(1);
+
+    // Later, callback resolves (simulating Nova Micro responding)
+    resolveCallback!('Proactive summary result');
+    const result = await summaryPromise;
+    expect(result).toBe('Proactive summary result');
+  });
+
+  it('at 100%+ utilization, uses existing summary without throwing', () => {
+    const maxContextTokens = 200_000;
+    const cachedSummary = 'Previously generated summary of the conversation';
+
+    // Context is at 105% (over budget)
+    const indexTokenCountMap: Record<string, number | undefined> = {
+      '0': 210_000, // system + everything
+    };
+
+    const utilization = getContextUtilization(indexTokenCountMap, 0, maxContextTokens);
+    expect(utilization).toBeGreaterThan(100);
+
+    // Even at 100%+, we use the existing cached summary — no error thrown
+    expect(cachedSummary).toBeTruthy();
+    // Compaction builds a windowed view — no messages deleted, no throwing
+  });
+});
+
+// ===========================================================================
+// Context Compaction (Copilot-style: never delete messages)
+// ===========================================================================
+
+import { applyCalibration as _applyCalibration } from '@/utils/pruneCalibration';
+
+describe('Context Compaction — Windowed View (no message deletion)', () => {
+  /**
+   * Simulates the compaction logic from Graph.ts without the full Graph instance.
+   * This tests the windowed-view algorithm directly.
+   */
+  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;
+
+    for (let i = messages.length - 1; i >= contentStart; i--) {
+      const msgTokens = indexTokenCountMap[i] ?? 0;
+      if (usedTokens + msgTokens > recentBudget) break;
+      usedTokens += msgTokens;
+      windowStart = i;
+    }
+
+    // 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('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);
+  });
+});