@illuma-ai/agents 1.1.3 → 1.1.5

package/dist/esm/graphs/Graph.mjs

@@ -11,7 +11,7 @@ import { ensureThinkingBlockInMessages } from '../messages/format.mjs';
 import { addCacheControl, addBedrockCacheControl } from '../messages/cache.mjs';
 import { formatContentStrings } from '../messages/content.mjs';
 import { GraphNodeKeys, Providers, ContentTypes, GraphEvents, MessageTypes, StepTypes, Constants } from '../common/enum.mjs';
-import { TOOL_TURN_THINKING_BUDGET, PROACTIVE_SUMMARY_THRESHOLD, SUMMARIZATION_CONTEXT_THRESHOLD } from '../common/constants.mjs';
+import { TOOL_TURN_THINKING_BUDGET, PROACTIVE_SUMMARY_THRESHOLD, SUMMARIZATION_CONTEXT_THRESHOLD, COMPACTION_RECENT_ROUNDS } from '../common/constants.mjs';
 import { deduplicateSystemMessages } from '../messages/dedup.mjs';
 import { resetIfNotEmpty, joinKeys } from '../utils/graph.mjs';
 import { isOpenAILike, isGoogleLike } from '../utils/llm.mjs';
@@ -25,6 +25,7 @@ import 'zod-to-json-schema';
 import { hasTaskTool, buildPostPruneNote, detectDocuments, shouldInjectMultiDocHint, buildMultiDocHintContent } from '../utils/contextPressure.mjs';
 import { ToolDiscoveryCache } from '../utils/toolDiscoveryCache.mjs';
 import { createPruneCalibration, applyCalibration, updatePruneCalibration } from '../utils/pruneCalibration.mjs';
+import { buildFileManifestBlock } from '../utils/fileManifest.mjs';
 import { getChatModelClass, manualToolStreamProviders } from '../llm/providers.mjs';
 import { ToolNode, toolsCondition } from '../tools/ToolNode.mjs';
 import { ChatOpenAI, AzureChatOpenAI } from '../llm/openai/index.mjs';
@@ -1179,17 +1180,52 @@ class StandardGraph extends Graph {
                     : 0;
                 // Budget for recent messages = total - system - summary - 3 (assistant priming)
                 const recentBudget = calibratedMax - systemTokens - summaryTokens - 3;
-                // Step 3: Walk newest→oldest, collect messages that fit in the budget
+                // Step 3: Determine window of recent messages to include.
+                //
+                // Two modes:
+                // A) No summary available → fill the budget (all messages that fit)
+                // B) Summary available → keep last 2 conversation rounds (H+A pairs)
+                //    + any trailing tool messages. The summary covers everything else.
+                //    This avoids wasting tokens on raw messages the summary already covers.
+                //
+                // A "round" = one human message + one AI response (+ any tool messages between).
                 const contentStart = systemMsg != null ? 1 : 0;
                 let usedTokens = 0;
                 let windowStart = messages.length; // index where the recent window begins
-                for (let i = messages.length - 1; i >= contentStart; i--) {
-                    const msgTokens = agentContext.indexTokenCountMap[i] ?? 0;
-                    if (usedTokens + msgTokens > recentBudget) {
-                        break;
+                let fileManifestTokens = 0; // populated in Step 4 if file manifest is injected
+                if (summary == null || summary === '') {
+                    // Mode A: No summary — include as many recent messages as fit in budget
+                    for (let i = messages.length - 1; i >= contentStart; i--) {
+                        const msgTokens = agentContext.indexTokenCountMap[i] ?? 0;
+                        if (usedTokens + msgTokens > recentBudget) {
+                            break;
+                        }
+                        usedTokens += msgTokens;
+                        windowStart = i;
+                    }
+                }
+                else {
+                    // Mode B: Summary exists — keep last 2 rounds (4 core messages: H+A+H+A)
+                    // Walk backward counting human messages as round boundaries.
+                    const MAX_RECENT_ROUNDS = COMPACTION_RECENT_ROUNDS;
+                    let roundsSeen = 0;
+                    for (let i = messages.length - 1; i >= contentStart; i--) {
+                        const msgType = messages[i]?.getType();
+                        const msgTokens = agentContext.indexTokenCountMap[i] ?? 0;
+                        // Budget guard — even in round-limited mode, don't exceed budget
+                        if (usedTokens + msgTokens > recentBudget) {
+                            break;
+                        }
+                        usedTokens += msgTokens;
+                        windowStart = i;
+                        // Count a human message as a round boundary
+                        if (msgType === 'human') {
+                            roundsSeen++;
+                            if (roundsSeen >= MAX_RECENT_ROUNDS) {
+                                break;
+                            }
+                        }
                     }
-                    usedTokens += msgTokens;
-                    windowStart = i;
                 }
                 // Ensure we don't split tool-call / tool-result pairs.
                 // If windowStart lands on a ToolMessage, walk back to include its AI message.
@@ -1202,7 +1238,11 @@ class StandardGraph extends Graph {
                 const compactedMessages = messages.slice(contentStart, windowStart);
                 const hasSummary = summaryMsg != null;
                 // Step 4: Assemble the windowed view
-                // [system] + [summary (covers compacted messages)] + [recent window]
+                // [system] + [summary] + [file manifest] + [recent window]
+                //
+                // File manifest is injected ONLY when compaction is active (messages behind summary).
+                // It provides the LLM with awareness of all conversation files so it can
+                // retrieve content on demand via file_search or content_tool read.
                 const viewParts = [];
                 if (systemMsg != null) {
                     viewParts.push(systemMsg);
@@ -1210,12 +1250,46 @@ class StandardGraph extends Graph {
                 if (summaryMsg != null) {
                     viewParts.push(summaryMsg);
                 }
+                // Inject file manifest when files exist and messages are being compacted
+                const fileManifest = agentContext.fileManifest;
+                if (fileManifest && fileManifest.length > 0 && compactedMessages.length > 0) {
+                    const manifestBlock = buildFileManifestBlock(fileManifest);
+                    if (manifestBlock) {
+                        const manifestMsg = new SystemMessage(manifestBlock);
+                        viewParts.push(manifestMsg);
+                        // Account for manifest tokens in the view token map
+                        const manifestTokens = tokenCounter != null ? tokenCounter(manifestMsg) : 0;
+                        // Will be inserted at the correct index when rebuilding viewTokenMap below
+                        fileManifestTokens = manifestTokens;
+                    }
+                }
                 viewParts.push(...recentMessages);
                 messagesToUse = viewParts;
-                console.debug(`[Graph:Compaction] View: ${messages.length}→${viewParts.length} msgs ` +
-                    `(${compactedMessages.length} behind summary, ${recentMessages.length} in window) | ` +
-                    `summary=${summarySource}${summary ? ` (len=${summary.length})` : ''} | ` +
-                    `budget=${recentBudget}/${calibratedMax} used=${usedTokens}`);
+                // Rebuild indexTokenCountMap for the windowed view so downstream
+                // analytics and summarization triggers see accurate token counts.
+                const viewTokenMap = {};
+                let viewIdx = 0;
+                if (systemMsg != null) {
+                    viewTokenMap[viewIdx] = systemTokens;
+                    viewIdx++;
+                }
+                if (summaryMsg != null) {
+                    viewTokenMap[viewIdx] = summaryTokens;
+                    viewIdx++;
+                }
+                if (fileManifestTokens > 0) {
+                    viewTokenMap[viewIdx] = fileManifestTokens;
+                    viewIdx++;
+                }
+                for (let i = windowStart; i < messages.length; i++) {
+                    viewTokenMap[viewIdx] = agentContext.indexTokenCountMap[i];
+                    viewIdx++;
+                }
+                agentContext.indexTokenCountMap = viewTokenMap;
+                console.debug(`[Graph:Compaction] ${messages.length}→${viewParts.length} msgs | ` +
+                    `compacted=${compactedMessages.length} window=${recentMessages.length} | ` +
+                    `summary=${summarySource} | budget=${usedTokens}/${recentBudget}` +
+                    (fileManifestTokens > 0 ? ` | manifest=${fileManifest?.length ?? 0} files (${fileManifestTokens}tok)` : ''));
                 // Step 5: Fire background summary update (non-blocking)
                 // Summarize messages outside the window so next iteration has a fresh summary.
                 // Only trigger if there are compacted messages worth summarizing.