@dexto/core 1.5.4 → 1.5.6

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

@@ -52,6 +52,7 @@ class StreamProcessor {
   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.
@@ -162,41 +163,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,
@@ -344,6 +367,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/stream-processor.d.ts

@@ -26,6 +26,7 @@ export declare class StreamProcessor {
     private reasoningMetadata;
     private accumulatedText;
     private logger;
+    private hasStepUsage;
     /**
      * 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.
@@ -46,6 +47,9 @@ export declare class StreamProcessor {
         approvalStatus?: "approved" | "rejected";
     }> | undefined);
     process(streamFn: () => StreamTextResult<VercelToolSet, unknown>): Promise<StreamProcessorResult>;
+    private getCacheTokensFromProviderMetadata;
+    private normalizeUsage;
+    private getProviderMetadata;
     private createAssistantMessage;
     private getLastMessageId;
     /**

package/dist/llm/executor/stream-processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-processor.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/stream-processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,IAAI,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAmB,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGnD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,OAAO,EAAE,WAAW,EAAc,MAAM,aAAa,CAAC;AAEtD,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,qBAAa,eAAe;IAyBpB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,gBAAgB,CAAC;IA/B7B,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,YAAY,CAAmE;IACvF,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,iBAAiB,CAAsC;IAC/D,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,MAAM,CAAe;IAC7B;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAgD;IAExE;;;;;;;;;OASG;gBAES,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,eAAe,EACzB,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,qBAAqB,EACrC,MAAM,EAAE,YAAY,EACZ,SAAS,GAAE,OAAc,EACzB,gBAAgB,CAAC,EAAE,GAAG,CAC1B,MAAM,EACN;QAAE,eAAe,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,UAAU,GAAG,UAAU,CAAA;KAAE,CACzE,YAAA;IAKC,OAAO,CACT,QAAQ,EAAE,MAAM,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,GACzD,OAAO,CAAC,qBAAqB,CAAC;YAubnB,sBAAsB;YAKtB,gBAAgB;IAO9B;;;;OAIG;YACW,2BAA2B;CAmC5C"}
+{"version":3,"file":"stream-processor.d.ts","sourceRoot":"","sources":["../../../src/llm/executor/stream-processor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,IAAI,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAmB,MAAM,uBAAuB,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAGnD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,OAAO,EAAE,WAAW,EAAc,MAAM,aAAa,CAAC;AAetD,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,oBAAoB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,qBAAa,eAAe;IA0BpB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,MAAM;IAEd,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,gBAAgB,CAAC;IAhC7B,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,YAAY,CAAmE;IACvF,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,iBAAiB,CAAsC;IAC/D,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,YAAY,CAAS;IAC7B;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAgD;IAExE;;;;;;;;;OASG;gBAES,cAAc,EAAE,cAAc,EAC9B,QAAQ,EAAE,eAAe,EACzB,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,qBAAqB,EACrC,MAAM,EAAE,YAAY,EACZ,SAAS,GAAE,OAAc,EACzB,gBAAgB,CAAC,EAAE,GAAG,CAC1B,MAAM,EACN;QAAE,eAAe,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,UAAU,GAAG,UAAU,CAAA;KAAE,CACzE,YAAA;IAKC,OAAO,CACT,QAAQ,EAAE,MAAM,gBAAgB,CAAC,aAAa,EAAE,OAAO,CAAC,GACzD,OAAO,CAAC,qBAAqB,CAAC;IA4bjC,OAAO,CAAC,kCAAkC;IAoB1C,OAAO,CAAC,cAAc;IA0CtB,OAAO,CAAC,mBAAmB;YAab,sBAAsB;YAKtB,gBAAgB;IAO9B;;;;OAIG;YACW,2BAA2B;CAmC5C"}

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

@@ -30,6 +30,7 @@ class StreamProcessor {
   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.
@@ -140,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,
@@ -322,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

@@ -124,23 +124,6 @@ class TurnExecutor {
    * Used to pass approval info from tool execution to result persistence.
    */
   approvalMetadata = /* @__PURE__ */ new Map();
-  /**
-   * Tracks whether compaction occurred during this turn.
-   * Used to signal to the caller that session continuation may be needed.
-   */
-  compactionOccurred = false;
-  /**
-   * Compaction data captured during this turn.
-   * Contains summary text and preserved messages for session continuation.
-   * This data is passed up the call chain (NOT persisted to original session).
-   */
-  compactionData = null;
-  /**
-   * Virtual context for remaining iterations after compaction.
-   * When set, the main loop uses this instead of calling getFormattedMessagesForLLM().
-   * This provides reduced context to the LLM without persisting to the original session.
-   */
-  virtualContext = null;
   /**
    * Get StreamProcessor config from TurnExecutor state.
    * @param estimatedInputTokens Optional estimated input tokens for analytics
@@ -206,7 +189,7 @@ class TurnExecutor {
             await this.injectQueuedMessages(coalesced);
           }
           await this.pruneOldToolOutputs();
-          let prepared = this.virtualContext ? await this.buildMessagesFromVirtualContext(contributorContext) : await this.contextManager.getFormattedMessagesForLLM(
+          let prepared = await this.contextManager.getFormattedMessagesForLLM(
             contributorContext,
             this.llmContext
           );
@@ -220,9 +203,16 @@ class TurnExecutor {
             this.logger.debug(
               `Pre-check: estimated ${estimatedTokens} tokens exceeds threshold, compacting`
             );
-            await this.compactToVirtualContext(estimatedTokens);
-            if (this.virtualContext) {
-              prepared = await this.buildMessagesFromVirtualContext(contributorContext);
+            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,
@@ -284,22 +274,29 @@ class TurnExecutor {
               `Context estimation (cancelled): keeping last known actuals, partial response (${result.text.length} chars) will be estimated`
             );
           } else if (result.usage?.inputTokens !== void 0) {
-            const diff = estimatedTokens - result.usage.inputTokens;
-            const diffPercent = result.usage.inputTokens > 0 ? (diff / result.usage.inputTokens * 100).toFixed(1) : "0.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=${result.usage.inputTokens}, error=${diff} (${diffPercent}%)`
+              `Context estimation accuracy: estimated=${estimatedTokens}, actual=${actualInputTokens}, error=${diff} (${diffPercent}%)`
             );
-            this.contextManager.setLastActualInputTokens(result.usage.inputTokens);
+            this.contextManager.setLastActualInputTokens(actualInputTokens);
             if (result.usage?.outputTokens !== void 0) {
               this.contextManager.setLastActualOutputTokens(result.usage.outputTokens);
             }
             await this.contextManager.recordLastCallMessageCount();
           }
-          if (!this.virtualContext && result.usage?.inputTokens && this.shouldCompactFromActual(result.usage.inputTokens)) {
+          const contextInputTokens = result.usage ? this.getContextInputTokens(result.usage) : null;
+          if (contextInputTokens && this.shouldCompactFromActual(contextInputTokens)) {
             this.logger.debug(
-              `Post-response: actual ${result.usage.inputTokens} tokens exceeds threshold, compacting`
+              `Post-response: actual ${contextInputTokens} tokens exceeds threshold, compacting`
+            );
+            await this.compactContext(
+              contextInputTokens,
+              contributorContext,
+              toolDefinitions
             );
-            await this.compactToVirtualContext(result.usage.inputTokens);
           }
           if (result.finishReason !== "tool-calls") {
             const queuedOnTerminate = this.messageQueue.dequeueAll();
@@ -353,14 +350,7 @@ class TurnExecutor {
         text: lastText,
         stepCount,
         usage: lastStepTokens,
-        finishReason: lastFinishReason,
-        // Signal to caller that compaction occurred during this turn
-        // Caller can use this to trigger session-native continuation
-        didCompact: this.compactionOccurred,
-        // Pass compaction data up the chain (NOT persisted to original session)
-        // Caller uses this to create the continuation session with summary
-        // Use spread to conditionally include only when data exists (exactOptionalPropertyTypes)
-        ...this.compactionData && { compaction: this.compactionData }
+        finishReason: lastFinishReason
       };
     } catch (_2) {
       var _error = _2, _hasError = true;
@@ -761,27 +751,31 @@ class TurnExecutor {
     );
   }
   /**
-   * Compact context using ReactiveOverflowStrategy WITHOUT persisting to original session.
-   *
-   * Key design: Creates a virtual context (summary + preserved messages) that will be used
-   * for the remaining iterations of this turn. The compaction data is passed up the call chain
-   * so the caller can create a continuation session with the summary.
+   * Compact context by generating a summary and adding it to the same session.
    *
-   * The original session remains UNTOUCHED - no messages are added or modified.
+   * 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 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 compactToVirtualContext(originalTokens) {
+  async compactContext(originalTokens, contributorContext, tools) {
     if (!this.compactionStrategy) {
-      return;
+      return false;
     }
     this.logger.info(
       `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;
+      return false;
     }
     this.eventBus.emit("context:compacting", {
       estimatedTokens: originalTokens
@@ -795,106 +789,36 @@ class TurnExecutor {
         originalTokens,
         compactedTokens: originalTokens,
         // No change
-        originalMessages: history.length,
-        compactedMessages: history.length,
+        originalMessages,
+        compactedMessages: originalMessages,
         // No change
         strategy: this.compactionStrategy.name,
         reason: "overflow"
       });
-      return;
-    }
-    const summaryMessage = summaryMessages[0];
-    if (!summaryMessage) {
-      this.logger.warn("Compaction returned empty summary message array");
-      return;
+      return false;
     }
-    const summaryText = this.extractSummaryText(summaryMessage);
-    const summarizedCount = summaryMessage.metadata?.originalMessageCount ?? 0;
-    let existingSummaryIndex = -1;
-    for (let i = history.length - 1; i >= 0; i--) {
-      const msg = history[i];
-      if (msg?.metadata?.isSummary === true || msg?.metadata?.isSessionSummary === true) {
-        existingSummaryIndex = i;
-        break;
-      }
+    for (const summary of summaryMessages) {
+      await this.contextManager.addMessage(summary);
     }
-    const baseIndex = existingSummaryIndex >= 0 ? existingSummaryIndex + 1 : 0;
-    const preservedMessages = history.slice(baseIndex + summarizedCount);
-    const firstTimestamp = summaryMessage.metadata?.originalFirstTimestamp;
-    const lastTimestamp = summaryMessage.metadata?.originalLastTimestamp;
-    this.compactionData = {
-      summaryText,
-      preservedMessages: [...preservedMessages],
-      // Copy to avoid mutation
-      summarizedCount,
-      ...firstTimestamp !== void 0 && { originalFirstTimestamp: firstTimestamp },
-      ...lastTimestamp !== void 0 && { originalLastTimestamp: lastTimestamp }
-    };
-    this.virtualContext = {
-      summaryMessage,
-      preservedMessages: [...preservedMessages]
-    };
-    this.compactionOccurred = true;
     this.contextManager.resetActualTokenTracking();
-    const { estimateMessagesTokens: estimateTokens } = await import("../../context/utils.js");
-    const virtualMessages = [summaryMessage, ...preservedMessages];
-    const compactedTokens = estimateTokens(virtualMessages);
+    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: virtualMessages.length,
+      originalMessages,
+      compactedMessages,
       strategy: this.compactionStrategy.name,
       reason: "overflow"
     });
     this.logger.info(
-      `Compaction complete (virtual context): ${originalTokens} \u2192 ~${compactedTokens} tokens (${history.length} \u2192 ${virtualMessages.length} messages). Original session unchanged - summary will be passed to continuation session.`
+      `Compaction complete: ${originalTokens} \u2192 ~${compactedTokens} tokens (${originalMessages} \u2192 ${compactedMessages} messages after filtering)`
     );
-  }
-  /**
-   * Extract the summary text from a summary message.
-   */
-  extractSummaryText(summaryMessage) {
-    if (typeof summaryMessage.content === "string") {
-      return summaryMessage.content;
-    }
-    if (Array.isArray(summaryMessage.content)) {
-      return summaryMessage.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-    }
-    return "";
-  }
-  /**
-   * Build formatted messages from virtual context (after compaction).
-   *
-   * This creates LLM-ready messages using:
-   * - System prompt (same as normal flow)
-   * - Summary message (as first message)
-   * - Preserved messages (formatted for LLM)
-   *
-   * Uses the same formatting pipeline as getFormattedMessagesForLLM()
-   * but with our virtual history instead of the stored history.
-   *
-   * @param contributorContext Context for system prompt contributors
-   * @returns Formatted messages ready for LLM call, matching getFormattedMessagesForLLM return type
-   */
-  async buildMessagesFromVirtualContext(contributorContext) {
-    if (!this.virtualContext) {
-      throw new Error("buildMessagesFromVirtualContext called without virtual context");
-    }
-    const { summaryMessage, preservedMessages } = this.virtualContext;
-    const systemPrompt = await this.contextManager.getSystemPrompt(contributorContext);
-    const virtualHistory = [summaryMessage, ...preservedMessages];
-    const formattedMessages = await this.contextManager.getFormattedMessages(
-      contributorContext,
-      this.llmContext,
-      systemPrompt,
-      virtualHistory
-    );
-    return {
-      formattedMessages,
-      systemPrompt,
-      preparedHistory: virtualHistory
-    };
+    return true;
   }
   /**
    * Set telemetry span attributes for token usage.
@@ -917,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.
    */