@illuma-ai/agents 1.1.2 → 1.1.3

package/dist/cjs/graphs/Graph.cjs

@@ -1124,68 +1124,116 @@ class StandardGraph extends Graph {
                 }
             }
             if (agentContext.pruneMessages) {
-                const { context, indexTokenCountMap, messagesToRefine } = agentContext.pruneMessages({
-                    messages: messages$1,
-                    usageMetadata: agentContext.currentUsage,
-                });
-                agentContext.indexTokenCountMap = indexTokenCountMap;
-                messagesToUse = context;
-                // ── Non-blocking summarization ──────────────────────────────────
-                // NEVER block the LLM call waiting for summarization. Instead:
-                //   1. If _cachedRunSummary exists → use it, fire async update
-                //   2. If persistedSummary exists → use it as fallback, fire async update
-                //   3. If NOTHING exists (first-ever prune) → skip summary, fire async generation
-                // The summary catches up asynchronously and is available for subsequent
-                // iterations (tool calls) and the next conversation turn.
+                // ── Context Compaction (Copilot-style: never delete messages) ─────
+                //
+                // DESIGN: Original messages are NEVER removed from the array.
+                // Instead, we build a "windowed view" for the LLM:
+                //   [system prompt] + [summary of older turns] + [recent turns that fit]
+                //
+                // This ensures:
+                //   - No context is ever lost (summary covers older turns)
+                //   - We can always re-summarize from originals if summary is stale
+                //   - Conversation chaining works naturally across turns
                 //
-                // SummarizationConfig integration:
-                //   - triggerType/triggerThreshold control WHEN summarization fires
-                //   - reserveRatio is enforced via calibrated maxTokens (above)
-                //   - initialSummary provides cross-run seeding as fallback before persistedSummary
-                let hasSummary = false;
+                // Flow:
+                //   1. Resolve best available summary (cached > persisted > seed)
+                //   2. Calculate token budget available for recent messages
+                //   3. Walk newest→oldest, build view of messages that fit
+                //   4. Assemble: [system] + [summary] + [recent window]
+                //   5. Fire background summary update for messages outside the window
                 const sumConfig = agentContext.summarizationConfig;
-                const shouldSummarize = this.shouldTriggerSummarization(messagesToRefine.length, agentContext.maxContextTokens ?? 0, agentContext.indexTokenCountMap, agentContext.instructionTokens, sumConfig);
-                if (messagesToRefine.length > 0 &&
-                    agentContext.summarizeCallback &&
-                    shouldSummarize) {
-                    try {
-                        let summary;
-                        let summarySource;
-                        if (this._cachedRunSummary != null) {
-                            summary = this._cachedRunSummary;
-                            summarySource = 'cached';
-                        }
-                        else if (agentContext.persistedSummary != null &&
-                            agentContext.persistedSummary !== '') {
-                            summary = agentContext.persistedSummary;
-                            this._cachedRunSummary = summary;
-                            summarySource = 'persisted';
-                        }
-                        else if (sumConfig?.initialSummary != null &&
-                            sumConfig.initialSummary !== '') {
-                            // Cross-run seed: use initialSummary when no persisted summary exists
-                            summary = sumConfig.initialSummary;
-                            this._cachedRunSummary = summary;
-                            summarySource = 'initial-seed';
-                        }
-                        else {
-                            summarySource = 'none';
-                        }
-                        // Single consolidated log for the entire prune+summarize decision
-                        console.debug(`[Graph:ContextMgmt] Pruned ${messages$1.length}→${context.length} msgs (${messagesToRefine.length} discarded) | summary=${summarySource}${summary ? ` (len=${summary.length})` : ''} | calibration=${this._pruneCalibration.ratio.toFixed(3)}(${this._pruneCalibration.iterations})`);
-                        // SCALE: Debounce background summarization — if a summary call is already
-                        // in-flight (from a prior tool iteration), accumulate messages instead of
-                        // firing another concurrent LLM call. At 2000 users with 3+ tool calls
-                        // per turn, this prevents 3x summary call volume.
+                const tokenCounter = agentContext.tokenCounter;
+                const maxTokens = agentContext.maxContextTokens ?? 0;
+                // Step 1: Resolve best available summary
+                let summary;
+                let summarySource;
+                if (this._cachedRunSummary != null) {
+                    summary = this._cachedRunSummary;
+                    summarySource = 'cached';
+                }
+                else if (agentContext.persistedSummary != null &&
+                    agentContext.persistedSummary !== '') {
+                    summary = agentContext.persistedSummary;
+                    this._cachedRunSummary = summary;
+                    summarySource = 'persisted';
+                }
+                else if (sumConfig?.initialSummary != null &&
+                    sumConfig.initialSummary !== '') {
+                    summary = sumConfig.initialSummary;
+                    this._cachedRunSummary = summary;
+                    summarySource = 'initial-seed';
+                }
+                else {
+                    summarySource = 'none';
+                }
+                // Step 2: Calculate token budget
+                // Apply EMA calibration for accuracy across iterations
+                const calibratedMax = pruneCalibration.applyCalibration(maxTokens, this._pruneCalibration);
+                const systemMsg = messages$1[0]?.getType() === 'system' ? messages$1[0] : null;
+                const systemTokens = systemMsg != null
+                    ? (agentContext.indexTokenCountMap[0] ?? 0)
+                    : 0;
+                const summaryMsg = summary != null && summary !== ''
+                    ? new messages.SystemMessage(`[Conversation Summary]\n${summary}`)
+                    : null;
+                const summaryTokens = summaryMsg != null && tokenCounter != null
+                    ? tokenCounter(summaryMsg)
+                    : 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
+                const contentStart = systemMsg != null ? 1 : 0;
+                let usedTokens = 0;
+                let windowStart = messages$1.length; // index where the recent window begins
+                for (let i = messages$1.length - 1; i >= contentStart; i--) {
+                    const msgTokens = agentContext.indexTokenCountMap[i] ?? 0;
+                    if (usedTokens + msgTokens > recentBudget) {
+                        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.
+                while (windowStart > contentStart &&
+                    messages$1[windowStart]?.getType() === 'tool') {
+                    windowStart--;
+                    usedTokens += agentContext.indexTokenCountMap[windowStart] ?? 0;
+                }
+                const recentMessages = messages$1.slice(windowStart);
+                const compactedMessages = messages$1.slice(contentStart, windowStart);
+                const hasSummary = summaryMsg != null;
+                // Step 4: Assemble the windowed view
+                // [system] + [summary (covers compacted messages)] + [recent window]
+                const viewParts = [];
+                if (systemMsg != null) {
+                    viewParts.push(systemMsg);
+                }
+                if (summaryMsg != null) {
+                    viewParts.push(summaryMsg);
+                }
+                viewParts.push(...recentMessages);
+                messagesToUse = viewParts;
+                console.debug(`[Graph:Compaction] View: ${messages$1.length}→${viewParts.length} msgs ` +
+                    `(${compactedMessages.length} behind summary, ${recentMessages.length} in window) | ` +
+                    `summary=${summarySource}${summary ? ` (len=${summary.length})` : ''} | ` +
+                    `budget=${recentBudget}/${calibratedMax} used=${usedTokens}`);
+                // 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.
+                if (compactedMessages.length > 0 &&
+                    agentContext.summarizeCallback) {
+                    const shouldSummarize = this.shouldTriggerSummarization(compactedMessages.length, maxTokens, agentContext.indexTokenCountMap, agentContext.instructionTokens, sumConfig);
+                    if (shouldSummarize) {
                         if (this._summaryInFlight) {
-                            this._pendingMessagesToRefine.push(...messagesToRefine);
-                            console.debug(`[Graph:ContextMgmt] Summary in-flight, queued ${messagesToRefine.length} msgs (pending=${this._pendingMessagesToRefine.length})`);
+                            this._pendingMessagesToRefine.push(...compactedMessages);
+                            console.debug(`[Graph:Compaction] Summary in-flight, queued ${compactedMessages.length} msgs (pending=${this._pendingMessagesToRefine.length})`);
                         }
                         else {
                             this._summaryInFlight = true;
                             const allMessages = this._pendingMessagesToRefine.length > 0
-                                ? [...this._pendingMessagesToRefine, ...messagesToRefine]
-                                : messagesToRefine;
+                                ? [...this._pendingMessagesToRefine, ...compactedMessages]
+                                : compactedMessages;
                             this._pendingMessagesToRefine = [];
                             agentContext
                                 .summarizeCallback(allMessages)
@@ -1195,40 +1243,17 @@ class StandardGraph extends Graph {
                                 }
                             })
                                 .catch((err) => {
-                                console.error('[Graph] Background summary failed (non-fatal):', err);
+                                console.error('[Graph:Compaction] Background summary update failed (non-fatal):', err);
                             })
                                 .finally(() => {
                                 this._summaryInFlight = false;
                             });
                         }
-                        if (summary != null && summary !== '') {
-                            hasSummary = true;
-                            const summaryMsg = new messages.SystemMessage(`[Conversation Summary]\n${summary}`);
-                            const systemIdx = messagesToUse[0]?.getType() === 'system' ? 1 : 0;
-                            messagesToUse = [
-                                ...messagesToUse.slice(0, systemIdx),
-                                summaryMsg,
-                                ...messagesToUse.slice(systemIdx),
-                            ];
-                        }
-                    }
-                    catch (err) {
-                        console.error('[Graph] Summarization failed:', err);
                     }
                 }
-                else if (messagesToRefine.length > 0) {
-                    // Log pruning even when no summarize callback (discard mode)
-                    console.debug(`[Graph:ContextMgmt] Pruned ${messages$1.length}→${context.length} msgs (${messagesToRefine.length} discarded, no summary callback) | calibration=${this._pruneCalibration.ratio.toFixed(3)}`);
-                }
-                // Deduplicate system messages that accumulate from repeated tool iterations
-                const { messages: dedupedMessages, removedCount } = dedup.deduplicateSystemMessages(messagesToUse);
-                if (removedCount > 0) {
-                    messagesToUse = dedupedMessages;
-                    console.debug(`[Graph:Dedup] Removed ${removedCount} duplicate system message(s)`);
-                }
-                // Post-prune context note for task-tool-enabled agents
-                if (messagesToRefine.length > 0 && contextPressure.hasTaskTool(agentContext.tools)) {
-                    const postPruneNote = contextPressure.buildPostPruneNote(messagesToRefine.length, hasSummary);
+                // Post-compaction context note for task-tool-enabled agents
+                if (compactedMessages.length > 0 && contextPressure.hasTaskTool(agentContext.tools)) {
+                    const postPruneNote = contextPressure.buildPostPruneNote(compactedMessages.length, hasSummary);
                     if (postPruneNote) {
                         messagesToUse = [
                             ...messagesToUse,
@@ -1237,6 +1262,14 @@ class StandardGraph extends Graph {
                     }
                 }
             }
+            // Deduplicate system messages — ALWAYS runs, not just during compaction.
+            // Duplicate system messages accumulate from repeated tool iterations,
+            // summary injections, and context notes across turns.
+            const { messages: dedupedMessages, removedCount } = dedup.deduplicateSystemMessages(messagesToUse);
+            if (removedCount > 0) {
+                messagesToUse = dedupedMessages;
+                console.debug(`[Graph:Dedup] Removed ${removedCount} duplicate system message(s)`);
+            }
             let finalMessages = messagesToUse;
             if (agentContext.useLegacyContent) {
                 finalMessages = content.formatContentStrings(finalMessages);