@dexto/core 1.5.3 → 1.5.5

package/dist/llm/executor/stream-processor.js

@@ -27,8 +27,10 @@ class StreamProcessor {
   actualTokens = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
   finishReason = "unknown";
   reasoningText = "";
+  reasoningMetadata;
   accumulatedText = "";
   logger;
+  hasStepUsage = false;
   /**
    * Track pending tool calls (added to context but no result yet).
    * On cancel/abort, we add synthetic "cancelled" results to maintain tool_use/tool_result pairing.
@@ -59,6 +61,9 @@ class StreamProcessor {
             break;
           case "reasoning-delta":
             this.reasoningText += event.text;
+            if (event.providerMetadata) {
+              this.reasoningMetadata = event.providerMetadata;
+            }
             if (this.streaming) {
               this.eventBus.emit("llm:chunk", {
                 chunkType: "reasoning",
@@ -136,41 +141,63 @@ class StreamProcessor {
           }
           case "finish-step":
             if (event.usage) {
-              const anthropicMeta = event.providerMetadata?.["anthropic"];
-              const bedrockMeta = event.providerMetadata?.["bedrock"];
-              const cacheWriteTokens = anthropicMeta?.["cacheCreationInputTokens"] ?? bedrockMeta?.usage?.["cacheWriteInputTokens"] ?? 0;
-              const cacheReadTokens = anthropicMeta?.["cacheReadInputTokens"] ?? bedrockMeta?.usage?.["cacheReadInputTokens"] ?? event.usage.cachedInputTokens ?? 0;
+              const providerMetadata = this.getProviderMetadata(event);
+              const stepUsage = this.normalizeUsage(event.usage, providerMetadata);
               this.actualTokens = {
-                inputTokens: (this.actualTokens.inputTokens ?? 0) + (event.usage.inputTokens ?? 0),
-                outputTokens: (this.actualTokens.outputTokens ?? 0) + (event.usage.outputTokens ?? 0),
-                totalTokens: (this.actualTokens.totalTokens ?? 0) + (event.usage.totalTokens ?? 0),
-                ...event.usage.reasoningTokens !== void 0 && {
-                  reasoningTokens: (this.actualTokens.reasoningTokens ?? 0) + event.usage.reasoningTokens
+                inputTokens: (this.actualTokens.inputTokens ?? 0) + (stepUsage.inputTokens ?? 0),
+                outputTokens: (this.actualTokens.outputTokens ?? 0) + (stepUsage.outputTokens ?? 0),
+                totalTokens: (this.actualTokens.totalTokens ?? 0) + (stepUsage.totalTokens ?? 0),
+                ...stepUsage.reasoningTokens !== void 0 && {
+                  reasoningTokens: (this.actualTokens.reasoningTokens ?? 0) + stepUsage.reasoningTokens
                 },
                 // Cache tokens
-                cacheReadTokens: (this.actualTokens.cacheReadTokens ?? 0) + cacheReadTokens,
-                cacheWriteTokens: (this.actualTokens.cacheWriteTokens ?? 0) + cacheWriteTokens
+                cacheReadTokens: (this.actualTokens.cacheReadTokens ?? 0) + (stepUsage.cacheReadTokens ?? 0),
+                cacheWriteTokens: (this.actualTokens.cacheWriteTokens ?? 0) + (stepUsage.cacheWriteTokens ?? 0)
               };
+              this.hasStepUsage = true;
             }
             break;
           case "finish": {
             this.finishReason = event.finishReason;
-            const cacheReadTokens = this.actualTokens.cacheReadTokens ?? event.totalUsage.cachedInputTokens ?? 0;
-            const cacheWriteTokens = this.actualTokens.cacheWriteTokens ?? 0;
-            const providerExcludesCached = this.config.provider === "anthropic" || this.config.provider === "bedrock";
-            const adjustedInputTokens = providerExcludesCached ? event.totalUsage.inputTokens ?? 0 : (event.totalUsage.inputTokens ?? 0) - cacheReadTokens;
-            const usage = {
-              inputTokens: adjustedInputTokens,
-              outputTokens: event.totalUsage.outputTokens ?? 0,
-              totalTokens: event.totalUsage.totalTokens ?? 0,
-              // Capture reasoning tokens if available (from Claude extended thinking, etc.)
-              ...event.totalUsage.reasoningTokens !== void 0 && {
-                reasoningTokens: event.totalUsage.reasoningTokens
-              },
-              // Cache tokens from accumulated finish-step events or totalUsage fallback
-              cacheReadTokens,
-              cacheWriteTokens
-            };
+            const providerMetadata = this.getProviderMetadata(event);
+            const fallbackUsage = this.normalizeUsage(
+              event.totalUsage,
+              providerMetadata
+            );
+            const usage = this.hasStepUsage ? { ...this.actualTokens } : fallbackUsage;
+            if (this.hasStepUsage) {
+              const fallbackInput = fallbackUsage.inputTokens ?? 0;
+              if ((usage.inputTokens ?? 0) === 0 && fallbackInput > 0) {
+                this.logger.debug(
+                  "Backfilling inputTokens from fallback usage (step reported 0)",
+                  { stepValue: usage.inputTokens, fallbackValue: fallbackInput }
+                );
+                usage.inputTokens = fallbackInput;
+              }
+              const fallbackOutput = fallbackUsage.outputTokens ?? 0;
+              if ((usage.outputTokens ?? 0) === 0 && fallbackOutput > 0) {
+                this.logger.debug(
+                  "Backfilling outputTokens from fallback usage (step reported 0)",
+                  { stepValue: usage.outputTokens, fallbackValue: fallbackOutput }
+                );
+                usage.outputTokens = fallbackOutput;
+              }
+              const fallbackCacheRead = fallbackUsage.cacheReadTokens ?? 0;
+              if ((usage.cacheReadTokens ?? 0) === 0 && fallbackCacheRead > 0) {
+                usage.cacheReadTokens = fallbackCacheRead;
+              }
+              const fallbackCacheWrite = fallbackUsage.cacheWriteTokens ?? 0;
+              if ((usage.cacheWriteTokens ?? 0) === 0 && fallbackCacheWrite > 0) {
+                usage.cacheWriteTokens = fallbackCacheWrite;
+              }
+              const fallbackTotalTokens = fallbackUsage.totalTokens ?? 0;
+              if ((usage.totalTokens ?? 0) === 0 && fallbackTotalTokens > 0) {
+                usage.totalTokens = fallbackTotalTokens;
+              }
+              if (usage.reasoningTokens === void 0 && fallbackUsage.reasoningTokens !== void 0) {
+                usage.reasoningTokens = fallbackUsage.reasoningTokens;
+              }
+            }
             this.actualTokens = usage;
             this.logger.info("LLM response complete", {
               finishReason: event.finishReason,
@@ -188,7 +215,12 @@ class StreamProcessor {
               await this.contextManager.updateAssistantMessage(
                 this.assistantMessageId,
                 {
-                  tokenUsage: usage
+                  tokenUsage: usage,
+                  // Persist reasoning text and metadata for round-tripping
+                  ...this.reasoningText && { reasoning: this.reasoningText },
+                  ...this.reasoningMetadata && {
+                    reasoningMetadata: this.reasoningMetadata
+                  }
                 }
               );
             }
@@ -200,6 +232,9 @@ class StreamProcessor {
                 provider: this.config.provider,
                 model: this.config.model,
                 tokenUsage: usage,
+                ...this.config.estimatedInputTokens !== void 0 && {
+                  estimatedInputTokens: this.config.estimatedInputTokens
+                },
                 finishReason: this.finishReason
               });
             }
@@ -261,6 +296,9 @@ class StreamProcessor {
               provider: this.config.provider,
               model: this.config.model,
               tokenUsage: this.actualTokens,
+              ...this.config.estimatedInputTokens !== void 0 && {
+                estimatedInputTokens: this.config.estimatedInputTokens
+              },
               finishReason: "cancelled"
             });
             return {
@@ -282,6 +320,9 @@ class StreamProcessor {
           provider: this.config.provider,
           model: this.config.model,
           tokenUsage: this.actualTokens,
+          ...this.config.estimatedInputTokens !== void 0 && {
+            estimatedInputTokens: this.config.estimatedInputTokens
+          },
           finishReason: "cancelled"
         });
         return {
@@ -304,6 +345,41 @@ class StreamProcessor {
       usage: this.actualTokens
     };
   }
+  getCacheTokensFromProviderMetadata(providerMetadata) {
+    const anthropicMeta = providerMetadata?.["anthropic"];
+    const bedrockMeta = providerMetadata?.["bedrock"];
+    const cacheWriteTokens = anthropicMeta?.["cacheCreationInputTokens"] ?? bedrockMeta?.usage?.["cacheWriteInputTokens"] ?? 0;
+    const cacheReadTokens = anthropicMeta?.["cacheReadInputTokens"] ?? bedrockMeta?.usage?.["cacheReadInputTokens"] ?? 0;
+    return { cacheReadTokens, cacheWriteTokens };
+  }
+  normalizeUsage(usage, providerMetadata) {
+    const inputTokensRaw = usage?.inputTokens ?? 0;
+    const outputTokens = usage?.outputTokens ?? 0;
+    const totalTokens = usage?.totalTokens ?? 0;
+    const reasoningTokens = usage?.reasoningTokens;
+    const cachedInputTokens = usage?.cachedInputTokens;
+    const inputTokenDetails = usage?.inputTokenDetails;
+    const providerCache = this.getCacheTokensFromProviderMetadata(providerMetadata);
+    const cacheReadTokens = inputTokenDetails?.cacheReadTokens ?? cachedInputTokens ?? providerCache.cacheReadTokens ?? 0;
+    const cacheWriteTokens = inputTokenDetails?.cacheWriteTokens ?? providerCache.cacheWriteTokens ?? 0;
+    const needsCacheWriteAdjustment = inputTokenDetails === void 0 && cachedInputTokens !== void 0 && providerCache.cacheWriteTokens > 0;
+    const noCacheTokens = inputTokenDetails?.noCacheTokens ?? (cachedInputTokens !== void 0 ? inputTokensRaw - cachedInputTokens - (needsCacheWriteAdjustment ? providerCache.cacheWriteTokens : 0) : inputTokensRaw);
+    return {
+      inputTokens: Math.max(0, noCacheTokens),
+      outputTokens,
+      totalTokens,
+      ...reasoningTokens !== void 0 && { reasoningTokens },
+      cacheReadTokens,
+      cacheWriteTokens
+    };
+  }
+  getProviderMetadata(event) {
+    const metadata = "providerMetadata" in event ? event.providerMetadata : void 0;
+    if (!metadata || typeof metadata !== "object") {
+      return void 0;
+    }
+    return metadata;
+  }
   async createAssistantMessage() {
     await this.contextManager.addAssistantMessage("", [], {});
     return this.getLastMessageId();

package/dist/llm/executor/turn-executor.cjs

@@ -91,7 +91,7 @@ var import_reactive_overflow = require("../../context/compaction/strategies/reac
 const toolSupportCache = /* @__PURE__ */ new Map();
 const LOCAL_PROVIDERS = ["ollama", "local"];
 class TurnExecutor {
-  constructor(model, toolManager, contextManager, eventBus, resourceManager, sessionId, config, llmContext, logger, messageQueue, modelLimits, externalSignal, compactionStrategy) {
+  constructor(model, toolManager, contextManager, eventBus, resourceManager, sessionId, config, llmContext, logger, messageQueue, modelLimits, externalSignal, compactionStrategy, compactionThresholdPercent = 1) {
     this.model = model;
     this.toolManager = toolManager;
     this.contextManager = contextManager;
@@ -103,6 +103,7 @@ class TurnExecutor {
     this.messageQueue = messageQueue;
     this.modelLimits = modelLimits;
     this.externalSignal = externalSignal;
+    this.compactionThresholdPercent = compactionThresholdPercent;
     this.logger = logger.createChild(import_types4.DextoLogComponent.EXECUTOR);
     this.stepAbortController = new AbortController();
     if (compactionStrategy !== void 0) {
@@ -125,11 +126,13 @@ class TurnExecutor {
   approvalMetadata = /* @__PURE__ */ new Map();
   /**
    * Get StreamProcessor config from TurnExecutor state.
+   * @param estimatedInputTokens Optional estimated input tokens for analytics
    */
-  getStreamProcessorConfig() {
+  getStreamProcessorConfig(estimatedInputTokens) {
     return {
       provider: this.llmContext.provider,
-      model: this.llmContext.model
+      model: this.llmContext.model,
+      ...estimatedInputTokens !== void 0 && { estimatedInputTokens }
     };
   }
   /**
@@ -185,13 +188,41 @@ class TurnExecutor {
           if (coalesced) {
             await this.injectQueuedMessages(coalesced);
           }
-          if (lastStepTokens && this.checkAndHandleOverflow(lastStepTokens)) {
-            await this.compress(lastStepTokens.inputTokens ?? 0);
-          }
-          const prepared = await this.contextManager.getFormattedMessagesWithCompression(
+          await this.pruneOldToolOutputs();
+          let prepared = await this.contextManager.getFormattedMessagesForLLM(
             contributorContext,
             this.llmContext
           );
+          const toolDefinitions = supportsTools ? await this.toolManager.getAllTools() : {};
+          let estimatedTokens = await this.contextManager.getEstimatedNextInputTokens(
+            prepared.systemPrompt,
+            prepared.preparedHistory,
+            toolDefinitions
+          );
+          if (this.shouldCompact(estimatedTokens)) {
+            this.logger.debug(
+              `Pre-check: estimated ${estimatedTokens} tokens exceeds threshold, compacting`
+            );
+            const didCompact = await this.compactContext(
+              estimatedTokens,
+              contributorContext,
+              toolDefinitions
+            );
+            if (didCompact) {
+              prepared = await this.contextManager.getFormattedMessagesForLLM(
+                contributorContext,
+                this.llmContext
+              );
+              estimatedTokens = await this.contextManager.getEstimatedNextInputTokens(
+                prepared.systemPrompt,
+                prepared.preparedHistory,
+                toolDefinitions
+              );
+              this.logger.debug(
+                `Post-compaction: recomputed estimate is ${estimatedTokens} tokens`
+              );
+            }
+          }
           this.logger.debug(`Step ${stepCount}: Starting`);
           const tools = supportsTools ? await this.createTools() : {};
           const streamProcessor = new import_stream_processor.StreamProcessor(
@@ -199,7 +230,7 @@ class TurnExecutor {
             this.eventBus,
             this.resourceManager,
             this.stepAbortController.signal,
-            this.getStreamProcessorConfig(),
+            this.getStreamProcessorConfig(estimatedTokens),
             this.logger,
             streaming,
             this.approvalMetadata
@@ -238,6 +269,35 @@ class TurnExecutor {
           this.logger.debug(
             `Step ${stepCount}: Finished with reason="${result.finishReason}", tokens=${JSON.stringify(result.usage)}`
           );
+          if (result.finishReason === "cancelled") {
+            this.logger.info(
+              `Context estimation (cancelled): keeping last known actuals, partial response (${result.text.length} chars) will be estimated`
+            );
+          } else if (result.usage?.inputTokens !== void 0) {
+            const contextInputTokens2 = this.getContextInputTokens(result.usage);
+            const actualInputTokens = contextInputTokens2 ?? result.usage.inputTokens;
+            const diff = estimatedTokens - actualInputTokens;
+            const diffPercent = actualInputTokens > 0 ? (diff / actualInputTokens * 100).toFixed(1) : "0.0";
+            this.logger.info(
+              `Context estimation accuracy: estimated=${estimatedTokens}, actual=${actualInputTokens}, error=${diff} (${diffPercent}%)`
+            );
+            this.contextManager.setLastActualInputTokens(actualInputTokens);
+            if (result.usage?.outputTokens !== void 0) {
+              this.contextManager.setLastActualOutputTokens(result.usage.outputTokens);
+            }
+            await this.contextManager.recordLastCallMessageCount();
+          }
+          const contextInputTokens = result.usage ? this.getContextInputTokens(result.usage) : null;
+          if (contextInputTokens && this.shouldCompactFromActual(contextInputTokens)) {
+            this.logger.debug(
+              `Post-response: actual ${contextInputTokens} tokens exceeds threshold, compacting`
+            );
+            await this.compactContext(
+              contextInputTokens,
+              contributorContext,
+              toolDefinitions
+            );
+          }
           if (result.finishReason !== "tool-calls") {
             const queuedOnTerminate = this.messageQueue.dequeueAll();
             if (queuedOnTerminate) {
@@ -261,7 +321,6 @@ class TurnExecutor {
             lastFinishReason = "max-steps";
             break;
           }
-          await this.pruneOldToolOutputs();
         }
       } catch (error) {
         const mappedError = this.mapProviderError(error);
@@ -589,7 +648,7 @@ class TurnExecutor {
   /**
    * Prunes old tool outputs by marking them with compactedAt timestamp.
    * Does NOT modify content - transformation happens at format time in
-   * ContextManager.getFormattedMessagesWithCompression().
+   * ContextManager.prepareHistory().
    *
    * Algorithm:
    * 1. Go backwards through history (most recent first)
@@ -658,54 +717,108 @@ class TurnExecutor {
     this.messageQueue.clear();
   }
   /**
-   * Check if context has overflowed based on actual token usage from API.
+   * Check if context should be compacted based on estimated token count.
+   * Uses the threshold percentage from compaction config to trigger earlier (e.g., at 90%).
+   *
+   * @param estimatedTokens Estimated token count from the current context
+   * @returns true if compaction is needed before making the LLM call
    */
-  checkAndHandleOverflow(tokens) {
+  shouldCompact(estimatedTokens) {
     if (!this.modelLimits || !this.compactionStrategy) {
       return false;
     }
-    return (0, import_overflow.isOverflow)(tokens, this.modelLimits);
+    return (0, import_overflow.isOverflow)(
+      { inputTokens: estimatedTokens },
+      this.modelLimits,
+      this.compactionThresholdPercent
+    );
   }
   /**
-   * Compress context using ReactiveOverflowStrategy.
+   * Check if context should be compacted based on actual token count from API response.
+   * This is a post-response check using real token counts rather than estimates.
    *
-   * Generates a summary of older messages and adds it to history.
-   * The actual token reduction happens at read-time via filterCompacted()
-   * in getFormattedMessagesWithCompression().
+   * @param actualTokens Actual input token count from the API response
+   * @returns true if compaction is needed
+   */
+  shouldCompactFromActual(actualTokens) {
+    if (!this.modelLimits || !this.compactionStrategy) {
+      return false;
+    }
+    return (0, import_overflow.isOverflow)(
+      { inputTokens: actualTokens },
+      this.modelLimits,
+      this.compactionThresholdPercent
+    );
+  }
+  /**
+   * Compact context by generating a summary and adding it to the same session.
+   *
+   * The summary message is added to the conversation history with `isSummary: true` metadata.
+   * When the context is loaded via getFormattedMessagesForLLM(), filterCompacted() will
+   * exclude all messages before the summary, effectively compacting the context.
    *
-   * @param originalTokens The actual input token count from API that triggered overflow
+   * @param originalTokens The estimated input token count that triggered overflow
+   * @param contributorContext Context for system prompt contributors (needed for accurate token estimation)
+   * @param tools Tool definitions (needed for accurate token estimation)
+   * @returns true if compaction occurred, false if skipped
    */
-  async compress(originalTokens) {
+  async compactContext(originalTokens, contributorContext, tools) {
     if (!this.compactionStrategy) {
-      return;
+      return false;
     }
     this.logger.info(
-      `Context overflow detected (${originalTokens} tokens), running compression`
+      `Context overflow detected (${originalTokens} tokens), checking if compression is possible`
     );
     const history = await this.contextManager.getHistory();
+    const { filterCompacted } = await import("../../context/utils.js");
+    const originalFiltered = filterCompacted(history);
+    const originalMessages = originalFiltered.length;
+    if (history.length < 4) {
+      this.logger.debug("Compaction skipped: history too short to summarize");
+      return false;
+    }
+    this.eventBus.emit("context:compacting", {
+      estimatedTokens: originalTokens
+    });
     const summaryMessages = await this.compactionStrategy.compact(history);
     if (summaryMessages.length === 0) {
-      this.logger.debug("Compaction returned no summary (history too short)");
-      return;
+      this.logger.debug(
+        "Compaction skipped: strategy returned no summary (likely already compacted or nothing to summarize)"
+      );
+      this.eventBus.emit("context:compacted", {
+        originalTokens,
+        compactedTokens: originalTokens,
+        // No change
+        originalMessages,
+        compactedMessages: originalMessages,
+        // No change
+        strategy: this.compactionStrategy.name,
+        reason: "overflow"
+      });
+      return false;
     }
     for (const summary of summaryMessages) {
       await this.contextManager.addMessage(summary);
     }
-    const { filterCompacted, estimateMessagesTokens } = await import("../../context/utils.js");
-    const updatedHistory = await this.contextManager.getHistory();
-    const filteredHistory = filterCompacted(updatedHistory);
-    const compactedTokens = estimateMessagesTokens(filteredHistory);
+    this.contextManager.resetActualTokenTracking();
+    const afterEstimate = await this.contextManager.getContextTokenEstimate(
+      contributorContext,
+      tools
+    );
+    const compactedTokens = afterEstimate.estimated;
+    const compactedMessages = afterEstimate.stats.filteredMessageCount;
     this.eventBus.emit("context:compacted", {
       originalTokens,
       compactedTokens,
-      originalMessages: history.length,
-      compactedMessages: filteredHistory.length,
+      originalMessages,
+      compactedMessages,
       strategy: this.compactionStrategy.name,
       reason: "overflow"
     });
     this.logger.info(
-      `Compaction complete: ${originalTokens} \u2192 ~${compactedTokens} tokens (${history.length} \u2192 ${filteredHistory.length} messages after filtering)`
+      `Compaction complete: ${originalTokens} \u2192 ~${compactedTokens} tokens (${originalMessages} \u2192 ${compactedMessages} messages after filtering)`
     );
+    return true;
   }
   /**
    * Set telemetry span attributes for token usage.
@@ -728,6 +841,10 @@ class TurnExecutor {
       activeSpan.setAttribute("gen_ai.usage.reasoning_tokens", usage.reasoningTokens);
     }
   }
+  getContextInputTokens(usage) {
+    if (usage.inputTokens === void 0) return null;
+    return usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
+  }
   /**
    * Map provider errors to DextoRuntimeError.
    */

package/dist/llm/executor/turn-executor.d.ts

@@ -34,6 +34,7 @@ export declare class TurnExecutor {
     private messageQueue;
     private modelLimits?;
     private externalSignal?;
+    private compactionThresholdPercent;
     private logger;
     /**
      * Per-step abort controller. Created fresh for each iteration of the loop.
@@ -52,9 +53,10 @@ export declare class TurnExecutor {
         temperature?: number | undefined;
         baseURL?: string | undefined;
         reasoningEffort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | undefined;
-    }, llmContext: LLMContext, logger: IDextoLogger, messageQueue: MessageQueueService, modelLimits?: ModelLimits | undefined, externalSignal?: AbortSignal | undefined, compactionStrategy?: ICompactionStrategy | null);
+    }, llmContext: LLMContext, logger: IDextoLogger, messageQueue: MessageQueueService, modelLimits?: ModelLimits | undefined, externalSignal?: AbortSignal | undefined, compactionStrategy?: ICompactionStrategy | null, compactionThresholdPercent?: number);
     /**
      * Get StreamProcessor config from TurnExecutor state.
+     * @param estimatedInputTokens Optional estimated input tokens for analytics
      */
     private getStreamProcessorConfig;
     /**
@@ -119,7 +121,7 @@ export declare class TurnExecutor {
     /**
      * Prunes old tool outputs by marking them with compactedAt timestamp.
      * Does NOT modify content - transformation happens at format time in
-     * ContextManager.getFormattedMessagesWithCompression().
+     * ContextManager.prepareHistory().
      *
      * Algorithm:
      * 1. Go backwards through history (most recent first)
@@ -143,23 +145,39 @@ export declare class TurnExecutor {
      */
     private cleanup;
     /**
-     * Check if context has overflowed based on actual token usage from API.
+     * Check if context should be compacted based on estimated token count.
+     * Uses the threshold percentage from compaction config to trigger earlier (e.g., at 90%).
+     *
+     * @param estimatedTokens Estimated token count from the current context
+     * @returns true if compaction is needed before making the LLM call
+     */
+    private shouldCompact;
+    /**
+     * Check if context should be compacted based on actual token count from API response.
+     * This is a post-response check using real token counts rather than estimates.
+     *
+     * @param actualTokens Actual input token count from the API response
+     * @returns true if compaction is needed
      */
-    private checkAndHandleOverflow;
+    private shouldCompactFromActual;
     /**
-     * Compress context using ReactiveOverflowStrategy.
+     * Compact context by generating a summary and adding it to the same session.
      *
-     * Generates a summary of older messages and adds it to history.
-     * The actual token reduction happens at read-time via filterCompacted()
-     * in getFormattedMessagesWithCompression().
+     * The summary message is added to the conversation history with `isSummary: true` metadata.
+     * When the context is loaded via getFormattedMessagesForLLM(), filterCompacted() will
+     * exclude all messages before the summary, effectively compacting the context.
      *
-     * @param originalTokens The actual input token count from API that triggered overflow
+     * @param originalTokens The estimated input token count that triggered overflow
+     * @param contributorContext Context for system prompt contributors (needed for accurate token estimation)
+     * @param tools Tool definitions (needed for accurate token estimation)
+     * @returns true if compaction occurred, false if skipped
      */
-    private compress;
+    private compactContext;
     /**
      * Set telemetry span attributes for token usage.
      */
     private setTelemetryAttributes;
+    private getContextInputTokens;
     /**
      * Map provider errors to DextoRuntimeError.
      */

package/dist/llm/executor/turn-executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"turn-executor.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/turn-executor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"turn-executor.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/turn-executor.ts"],"names":[],"mappings":"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"}