@dexto/core 1.5.8 → 1.6.1

package/dist/context/compaction/strategies/{reactive-overflow.cjs → reactive-overflow-compaction.cjs}

@@ -16,13 +16,14 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var reactive_overflow_exports = {};
-__export(reactive_overflow_exports, {
-  ReactiveOverflowStrategy: () => ReactiveOverflowStrategy
+var reactive_overflow_compaction_exports = {};
+__export(reactive_overflow_compaction_exports, {
+  ReactiveOverflowCompactionStrategy: () => ReactiveOverflowCompactionStrategy
 });
-module.exports = __toCommonJS(reactive_overflow_exports);
+module.exports = __toCommonJS(reactive_overflow_compaction_exports);
 var import_ai = require("ai");
 var import_types = require("../../types.js");
+var import_overflow = require("../overflow.js");
 const DEFAULT_OPTIONS = {
   preserveLastNTurns: 2,
   maxSummaryTokens: 2e3,
@@ -58,30 +59,43 @@ IMPORTANT: The assistant will continue working based on this summary. Ensure the
 Conversation to summarize:
 {conversation}`
 };
-class ReactiveOverflowStrategy {
+class ReactiveOverflowCompactionStrategy {
   name = "reactive-overflow";
-  model;
-  options;
-  logger;
-  constructor(model, options = {}, logger) {
-    this.model = model;
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-    this.logger = logger;
+  settings;
+  strategyOptions;
+  constructor(options = {}) {
+    this.settings = {
+      enabled: options.enabled ?? true,
+      maxContextTokens: options.maxContextTokens,
+      thresholdPercent: options.thresholdPercent ?? 0.9
+    };
+    this.strategyOptions = {
+      ...DEFAULT_OPTIONS,
+      ...options.strategy ?? {}
+    };
   }
-  /**
-   * Generate a summary message for the old portion of history.
-   *
-   * IMPORTANT: This does NOT replace history. It returns a summary message
-   * that the caller should ADD to history via contextManager.addMessage().
-   * Read-time filtering (filterCompacted) will then exclude pre-summary
-   * messages when formatting for LLM.
-   *
-   * @param history The full conversation history
-   * @returns Array with single summary message to add, or empty if nothing to summarize
-   */
-  async compact(history) {
+  getSettings() {
+    return this.settings;
+  }
+  getModelLimits(modelContextWindow) {
+    const capped = this.settings.enabled && this.settings.maxContextTokens !== void 0 ? Math.min(modelContextWindow, this.settings.maxContextTokens) : modelContextWindow;
+    return { contextWindow: capped };
+  }
+  shouldCompact(inputTokens, modelLimits) {
+    if (!this.settings.enabled) {
+      return false;
+    }
+    return (0, import_overflow.isOverflow)({ inputTokens }, modelLimits, this.settings.thresholdPercent);
+  }
+  async compact(history, context) {
+    if (!this.settings.enabled) {
+      return [];
+    }
+    const { model, logger } = context;
     if (history.length <= 2) {
-      this.logger.debug("ReactiveOverflowStrategy: History too short, skipping compaction");
+      logger.debug(
+        "ReactiveOverflowCompactionStrategy: History too short, skipping compaction"
+      );
       return [];
     }
     let existingSummaryIndex = -1;
@@ -95,26 +109,32 @@ class ReactiveOverflowStrategy {
     if (existingSummaryIndex !== -1) {
       const messagesAfterSummary = history.slice(existingSummaryIndex + 1);
       if (messagesAfterSummary.length <= 4) {
-        this.logger.debug(
-          `ReactiveOverflowStrategy: Only ${messagesAfterSummary.length} messages after existing summary, skipping re-compaction`
+        logger.debug(
+          `ReactiveOverflowCompactionStrategy: Only ${messagesAfterSummary.length} messages after existing summary, skipping re-compaction`
         );
         return [];
       }
-      this.logger.info(
-        `ReactiveOverflowStrategy: Found existing summary at index ${existingSummaryIndex}, working with ${messagesAfterSummary.length} messages after it`
+      logger.info(
+        `ReactiveOverflowCompactionStrategy: Found existing summary at index ${existingSummaryIndex}, working with ${messagesAfterSummary.length} messages after it`
+      );
+      return this.compactSubset(
+        messagesAfterSummary,
+        history,
+        existingSummaryIndex,
+        model,
+        logger
       );
-      return this.compactSubset(messagesAfterSummary, history, existingSummaryIndex);
     }
     const { toSummarize, toKeep } = this.splitHistory(history);
     if (toSummarize.length === 0) {
-      this.logger.debug("ReactiveOverflowStrategy: No messages to summarize");
+      logger.debug("ReactiveOverflowCompactionStrategy: No messages to summarize");
       return [];
     }
     const currentTaskMessage = this.findCurrentTaskMessage(history);
-    this.logger.info(
-      `ReactiveOverflowStrategy: Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`
+    logger.info(
+      `ReactiveOverflowCompactionStrategy: Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`
     );
-    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage, model, logger);
     const summaryMessage = {
       role: "assistant",
       content: [{ type: "text", text: summary }],
@@ -133,23 +153,18 @@ class ReactiveOverflowStrategy {
    * Handle re-compaction when there's already a summary in history.
    * Only summarizes messages AFTER the existing summary, preventing
    * cascading summaries of summaries.
-   *
-   * @param messagesAfterSummary Messages after the existing summary
-   * @param fullHistory The complete history (for current task detection)
-   * @param existingSummaryIndex Index of the existing summary in fullHistory
-   * @returns Array with single summary message, or empty if nothing to summarize
    */
-  async compactSubset(messagesAfterSummary, fullHistory, existingSummaryIndex) {
+  async compactSubset(messagesAfterSummary, fullHistory, existingSummaryIndex, model, logger) {
     const { toSummarize, toKeep } = this.splitHistory(messagesAfterSummary);
     if (toSummarize.length === 0) {
-      this.logger.debug("ReactiveOverflowStrategy: No messages to summarize in subset");
+      logger.debug("ReactiveOverflowCompactionStrategy: No messages to summarize in subset");
       return [];
     }
     const currentTaskMessage = this.findCurrentTaskMessage(fullHistory);
-    this.logger.info(
-      `ReactiveOverflowStrategy (re-compact): Summarizing ${toSummarize.length} messages after existing summary, keeping ${toKeep.length}`
+    logger.info(
+      `ReactiveOverflowCompactionStrategy (re-compact): Summarizing ${toSummarize.length} messages after existing summary, keeping ${toKeep.length}`
     );
-    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage, model, logger);
     const absoluteOriginalMessageCount = existingSummaryIndex + 1 + toSummarize.length;
     const summaryMessage = {
       role: "assistant",
@@ -160,7 +175,6 @@ class ReactiveOverflowStrategy {
         summarizedAt: Date.now(),
         originalMessageCount: absoluteOriginalMessageCount,
         isRecompaction: true,
-        // Mark that this is a re-compaction
         originalFirstTimestamp: toSummarize[0]?.timestamp,
         originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
       }
@@ -169,7 +183,6 @@ class ReactiveOverflowStrategy {
   }
   /**
    * Find the most recent user message that represents the current task.
-   * This helps preserve context about what the user is currently asking for.
    */
   findCurrentTaskMessage(history) {
     for (let i = history.length - 1; i >= 0; i--) {
@@ -191,13 +204,9 @@ class ReactiveOverflowStrategy {
   }
   /**
    * Split history into messages to summarize and messages to keep.
-   * Keeps the last N turns (user + assistant pairs) intact.
-   *
-   * For long agentic conversations with many tool calls, this also ensures
-   * we don't try to keep too many messages even within preserved turns.
    */
   splitHistory(history) {
-    const turnsToKeep = this.options.preserveLastNTurns;
+    const turnsToKeep = this.strategyOptions.preserveLastNTurns;
     const userMessageIndices = [];
     for (let i = history.length - 1; i >= 0; i--) {
       if (history[i]?.role === "user") {
@@ -225,9 +234,6 @@ class ReactiveOverflowStrategy {
         toKeep: history
       };
     }
-    this.logger.debug(
-      `splitHistory: Using fallback - keeping last ${keepCount} of ${history.length} messages`
-    );
     return {
       toSummarize: history.slice(0, -keepCount),
       toKeep: history.slice(-keepCount)
@@ -235,11 +241,8 @@ class ReactiveOverflowStrategy {
   }
   /**
    * Generate an LLM summary of the messages.
-   *
-   * @param messages Messages to summarize
-   * @param currentTask The most recent user message (current task context)
    */
-  async generateSummary(messages, currentTask) {
+  async generateSummary(messages, currentTask, model, logger) {
     const formattedConversation = this.formatMessagesForSummary(messages);
     let conversationWithContext = formattedConversation;
     if (currentTask) {
@@ -248,21 +251,21 @@ class ReactiveOverflowStrategy {
 --- CURRENT TASK (most recent user request) ---
 ${currentTask}`;
     }
-    const prompt = this.options.summaryPrompt.replace(
+    const prompt = this.strategyOptions.summaryPrompt.replace(
       "{conversation}",
       conversationWithContext
     );
     try {
       const result = await (0, import_ai.generateText)({
-        model: this.model,
+        model,
         prompt,
-        maxOutputTokens: this.options.maxSummaryTokens
+        maxOutputTokens: this.strategyOptions.maxSummaryTokens
       });
       return `[Session Compaction Summary]
 ${result.text}`;
     } catch (error) {
-      this.logger.error(
-        `ReactiveOverflowStrategy: Failed to generate summary - ${error instanceof Error ? error.message : String(error)}`
+      logger.error(
+        `ReactiveOverflowCompactionStrategy: Failed to generate summary - ${error instanceof Error ? error.message : String(error)}`
       );
       return this.createFallbackSummary(messages, currentTask);
     }
@@ -339,5 +342,5 @@ ${result.text}`;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ReactiveOverflowStrategy
+  ReactiveOverflowCompactionStrategy
 });

package/dist/context/compaction/strategies/{reactive-overflow.d.ts → reactive-overflow-compaction.d.ts}

@@ -1,9 +1,8 @@
-import { type LanguageModel } from 'ai';
-import type { ICompactionStrategy } from '../types.js';
 import type { InternalMessage } from '../../types.js';
-import type { IDextoLogger } from '../../../logger/v2/types.js';
+import { type ModelLimits } from '../overflow.js';
+import type { CompactionRuntimeContext, CompactionSettings, CompactionStrategy } from '../types.js';
 /**
- * Configuration options for ReactiveOverflowStrategy.
+ * Configuration options for ReactiveOverflowCompactionStrategy.
  */
 export interface ReactiveOverflowOptions {
     /**
@@ -23,8 +22,14 @@ export interface ReactiveOverflowOptions {
      */
     summaryPrompt?: string;
 }
+export interface ReactiveOverflowCompactionStrategyOptions {
+    enabled?: boolean | undefined;
+    maxContextTokens?: number | undefined;
+    thresholdPercent?: number | undefined;
+    strategy?: ReactiveOverflowOptions | undefined;
+}
 /**
- * ReactiveOverflowStrategy implements reactive compaction.
+ * ReactiveOverflowCompactionStrategy implements reactive compaction.
  *
  * Key behaviors:
  * - Triggers on overflow (after actual tokens exceed context limit)
@@ -42,53 +47,31 @@ export interface ReactiveOverflowOptions {
  * and filterCompacted() handles excluding old messages at read-time.
  * This preserves full history for audit/recovery purposes.
  */
-export declare class ReactiveOverflowStrategy implements ICompactionStrategy {
+export declare class ReactiveOverflowCompactionStrategy implements CompactionStrategy {
     readonly name = "reactive-overflow";
-    private readonly model;
-    private readonly options;
-    private readonly logger;
-    constructor(model: LanguageModel, options: ReactiveOverflowOptions | undefined, logger: IDextoLogger);
-    /**
-     * Generate a summary message for the old portion of history.
-     *
-     * IMPORTANT: This does NOT replace history. It returns a summary message
-     * that the caller should ADD to history via contextManager.addMessage().
-     * Read-time filtering (filterCompacted) will then exclude pre-summary
-     * messages when formatting for LLM.
-     *
-     * @param history The full conversation history
-     * @returns Array with single summary message to add, or empty if nothing to summarize
-     */
-    compact(history: readonly InternalMessage[]): Promise<InternalMessage[]>;
+    private readonly settings;
+    private readonly strategyOptions;
+    constructor(options?: ReactiveOverflowCompactionStrategyOptions);
+    getSettings(): CompactionSettings;
+    getModelLimits(modelContextWindow: number): ModelLimits;
+    shouldCompact(inputTokens: number, modelLimits: ModelLimits): boolean;
+    compact(history: readonly InternalMessage[], context: CompactionRuntimeContext): Promise<InternalMessage[]>;
     /**
      * Handle re-compaction when there's already a summary in history.
      * Only summarizes messages AFTER the existing summary, preventing
      * cascading summaries of summaries.
-     *
-     * @param messagesAfterSummary Messages after the existing summary
-     * @param fullHistory The complete history (for current task detection)
-     * @param existingSummaryIndex Index of the existing summary in fullHistory
-     * @returns Array with single summary message, or empty if nothing to summarize
      */
     private compactSubset;
     /**
      * Find the most recent user message that represents the current task.
-     * This helps preserve context about what the user is currently asking for.
      */
     private findCurrentTaskMessage;
     /**
      * Split history into messages to summarize and messages to keep.
-     * Keeps the last N turns (user + assistant pairs) intact.
-     *
-     * For long agentic conversations with many tool calls, this also ensures
-     * we don't try to keep too many messages even within preserved turns.
      */
     private splitHistory;
     /**
      * Generate an LLM summary of the messages.
-     *
-     * @param messages Messages to summarize
-     * @param currentTask The most recent user message (current task context)
      */
     private generateSummary;
     /**
@@ -100,4 +83,4 @@ export declare class ReactiveOverflowStrategy implements ICompactionStrategy {
      */
     private createFallbackSummary;
 }
-//# sourceMappingURL=reactive-overflow.d.ts.map
+//# sourceMappingURL=reactive-overflow-compaction.d.ts.map

package/dist/context/compaction/strategies/reactive-overflow-compaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive-overflow-compaction.d.ts","sourceRoot":"","sources":["../../../../src/context/compaction/strategies/reactive-overflow-compaction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAY,MAAM,gBAAgB,CAAC;AAGhE,OAAO,EAAc,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,KAAK,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEpG;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,yCAAyC;IACtD,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,QAAQ,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;CAClD;AAsCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,kCAAmC,YAAW,kBAAkB;IACzE,QAAQ,CAAC,IAAI,uBAAuB;IAEpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;gBAExD,OAAO,GAAE,yCAA8C;IAYnE,WAAW,IAAI,kBAAkB;IAIjC,cAAc,CAAC,kBAAkB,EAAE,MAAM,GAAG,WAAW;IASvD,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO;IAO/D,OAAO,CACT,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,OAAO,EAAE,wBAAwB,GAClC,OAAO,CAAC,eAAe,EAAE,CAAC;IA+F7B;;;;OAIG;YACW,aAAa;IA8C3B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAsB9B;;OAEG;IACH,OAAO,CAAC,YAAY;IA8CpB;;OAEG;YACW,eAAe;IAkC7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAuChC;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAyDhC"}

package/dist/context/compaction/strategies/{reactive-overflow.js → reactive-overflow-compaction.js}

@@ -1,6 +1,7 @@
 import "../../../chunk-PTJYTZNU.js";
 import { generateText } from "ai";
 import { isAssistantMessage, isToolMessage } from "../../types.js";
+import { isOverflow } from "../overflow.js";
 const DEFAULT_OPTIONS = {
   preserveLastNTurns: 2,
   maxSummaryTokens: 2e3,
@@ -36,30 +37,43 @@ IMPORTANT: The assistant will continue working based on this summary. Ensure the
 Conversation to summarize:
 {conversation}`
 };
-class ReactiveOverflowStrategy {
+class ReactiveOverflowCompactionStrategy {
   name = "reactive-overflow";
-  model;
-  options;
-  logger;
-  constructor(model, options = {}, logger) {
-    this.model = model;
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-    this.logger = logger;
+  settings;
+  strategyOptions;
+  constructor(options = {}) {
+    this.settings = {
+      enabled: options.enabled ?? true,
+      maxContextTokens: options.maxContextTokens,
+      thresholdPercent: options.thresholdPercent ?? 0.9
+    };
+    this.strategyOptions = {
+      ...DEFAULT_OPTIONS,
+      ...options.strategy ?? {}
+    };
   }
-  /**
-   * Generate a summary message for the old portion of history.
-   *
-   * IMPORTANT: This does NOT replace history. It returns a summary message
-   * that the caller should ADD to history via contextManager.addMessage().
-   * Read-time filtering (filterCompacted) will then exclude pre-summary
-   * messages when formatting for LLM.
-   *
-   * @param history The full conversation history
-   * @returns Array with single summary message to add, or empty if nothing to summarize
-   */
-  async compact(history) {
+  getSettings() {
+    return this.settings;
+  }
+  getModelLimits(modelContextWindow) {
+    const capped = this.settings.enabled && this.settings.maxContextTokens !== void 0 ? Math.min(modelContextWindow, this.settings.maxContextTokens) : modelContextWindow;
+    return { contextWindow: capped };
+  }
+  shouldCompact(inputTokens, modelLimits) {
+    if (!this.settings.enabled) {
+      return false;
+    }
+    return isOverflow({ inputTokens }, modelLimits, this.settings.thresholdPercent);
+  }
+  async compact(history, context) {
+    if (!this.settings.enabled) {
+      return [];
+    }
+    const { model, logger } = context;
     if (history.length <= 2) {
-      this.logger.debug("ReactiveOverflowStrategy: History too short, skipping compaction");
+      logger.debug(
+        "ReactiveOverflowCompactionStrategy: History too short, skipping compaction"
+      );
       return [];
     }
     let existingSummaryIndex = -1;
@@ -73,26 +87,32 @@ class ReactiveOverflowStrategy {
     if (existingSummaryIndex !== -1) {
       const messagesAfterSummary = history.slice(existingSummaryIndex + 1);
       if (messagesAfterSummary.length <= 4) {
-        this.logger.debug(
-          `ReactiveOverflowStrategy: Only ${messagesAfterSummary.length} messages after existing summary, skipping re-compaction`
+        logger.debug(
+          `ReactiveOverflowCompactionStrategy: Only ${messagesAfterSummary.length} messages after existing summary, skipping re-compaction`
         );
         return [];
       }
-      this.logger.info(
-        `ReactiveOverflowStrategy: Found existing summary at index ${existingSummaryIndex}, working with ${messagesAfterSummary.length} messages after it`
+      logger.info(
+        `ReactiveOverflowCompactionStrategy: Found existing summary at index ${existingSummaryIndex}, working with ${messagesAfterSummary.length} messages after it`
+      );
+      return this.compactSubset(
+        messagesAfterSummary,
+        history,
+        existingSummaryIndex,
+        model,
+        logger
       );
-      return this.compactSubset(messagesAfterSummary, history, existingSummaryIndex);
     }
     const { toSummarize, toKeep } = this.splitHistory(history);
     if (toSummarize.length === 0) {
-      this.logger.debug("ReactiveOverflowStrategy: No messages to summarize");
+      logger.debug("ReactiveOverflowCompactionStrategy: No messages to summarize");
       return [];
     }
     const currentTaskMessage = this.findCurrentTaskMessage(history);
-    this.logger.info(
-      `ReactiveOverflowStrategy: Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`
+    logger.info(
+      `ReactiveOverflowCompactionStrategy: Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`
     );
-    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage, model, logger);
     const summaryMessage = {
       role: "assistant",
       content: [{ type: "text", text: summary }],
@@ -111,23 +131,18 @@ class ReactiveOverflowStrategy {
    * Handle re-compaction when there's already a summary in history.
    * Only summarizes messages AFTER the existing summary, preventing
    * cascading summaries of summaries.
-   *
-   * @param messagesAfterSummary Messages after the existing summary
-   * @param fullHistory The complete history (for current task detection)
-   * @param existingSummaryIndex Index of the existing summary in fullHistory
-   * @returns Array with single summary message, or empty if nothing to summarize
    */
-  async compactSubset(messagesAfterSummary, fullHistory, existingSummaryIndex) {
+  async compactSubset(messagesAfterSummary, fullHistory, existingSummaryIndex, model, logger) {
     const { toSummarize, toKeep } = this.splitHistory(messagesAfterSummary);
     if (toSummarize.length === 0) {
-      this.logger.debug("ReactiveOverflowStrategy: No messages to summarize in subset");
+      logger.debug("ReactiveOverflowCompactionStrategy: No messages to summarize in subset");
       return [];
     }
     const currentTaskMessage = this.findCurrentTaskMessage(fullHistory);
-    this.logger.info(
-      `ReactiveOverflowStrategy (re-compact): Summarizing ${toSummarize.length} messages after existing summary, keeping ${toKeep.length}`
+    logger.info(
+      `ReactiveOverflowCompactionStrategy (re-compact): Summarizing ${toSummarize.length} messages after existing summary, keeping ${toKeep.length}`
     );
-    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage, model, logger);
     const absoluteOriginalMessageCount = existingSummaryIndex + 1 + toSummarize.length;
     const summaryMessage = {
       role: "assistant",
@@ -138,7 +153,6 @@ class ReactiveOverflowStrategy {
         summarizedAt: Date.now(),
         originalMessageCount: absoluteOriginalMessageCount,
         isRecompaction: true,
-        // Mark that this is a re-compaction
         originalFirstTimestamp: toSummarize[0]?.timestamp,
         originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
       }
@@ -147,7 +161,6 @@ class ReactiveOverflowStrategy {
   }
   /**
    * Find the most recent user message that represents the current task.
-   * This helps preserve context about what the user is currently asking for.
    */
   findCurrentTaskMessage(history) {
     for (let i = history.length - 1; i >= 0; i--) {
@@ -169,13 +182,9 @@ class ReactiveOverflowStrategy {
   }
   /**
    * Split history into messages to summarize and messages to keep.
-   * Keeps the last N turns (user + assistant pairs) intact.
-   *
-   * For long agentic conversations with many tool calls, this also ensures
-   * we don't try to keep too many messages even within preserved turns.
    */
   splitHistory(history) {
-    const turnsToKeep = this.options.preserveLastNTurns;
+    const turnsToKeep = this.strategyOptions.preserveLastNTurns;
     const userMessageIndices = [];
     for (let i = history.length - 1; i >= 0; i--) {
       if (history[i]?.role === "user") {
@@ -203,9 +212,6 @@ class ReactiveOverflowStrategy {
         toKeep: history
       };
     }
-    this.logger.debug(
-      `splitHistory: Using fallback - keeping last ${keepCount} of ${history.length} messages`
-    );
     return {
       toSummarize: history.slice(0, -keepCount),
       toKeep: history.slice(-keepCount)
@@ -213,11 +219,8 @@ class ReactiveOverflowStrategy {
   }
   /**
    * Generate an LLM summary of the messages.
-   *
-   * @param messages Messages to summarize
-   * @param currentTask The most recent user message (current task context)
    */
-  async generateSummary(messages, currentTask) {
+  async generateSummary(messages, currentTask, model, logger) {
     const formattedConversation = this.formatMessagesForSummary(messages);
     let conversationWithContext = formattedConversation;
     if (currentTask) {
@@ -226,21 +229,21 @@ class ReactiveOverflowStrategy {
 --- CURRENT TASK (most recent user request) ---
 ${currentTask}`;
     }
-    const prompt = this.options.summaryPrompt.replace(
+    const prompt = this.strategyOptions.summaryPrompt.replace(
       "{conversation}",
       conversationWithContext
     );
     try {
       const result = await generateText({
-        model: this.model,
+        model,
         prompt,
-        maxOutputTokens: this.options.maxSummaryTokens
+        maxOutputTokens: this.strategyOptions.maxSummaryTokens
       });
       return `[Session Compaction Summary]
 ${result.text}`;
     } catch (error) {
-      this.logger.error(
-        `ReactiveOverflowStrategy: Failed to generate summary - ${error instanceof Error ? error.message : String(error)}`
+      logger.error(
+        `ReactiveOverflowCompactionStrategy: Failed to generate summary - ${error instanceof Error ? error.message : String(error)}`
       );
       return this.createFallbackSummary(messages, currentTask);
     }
@@ -316,5 +319,5 @@ ${result.text}`;
   }
 }
 export {
-  ReactiveOverflowStrategy
+  ReactiveOverflowCompactionStrategy
 };

package/dist/context/compaction/types.d.ts

@@ -1,14 +1,45 @@
-import { InternalMessage } from '../types.js';
+import type { LanguageModel } from 'ai';
+import type { Logger } from '../../logger/v2/types.js';
+import type { InternalMessage } from '../types.js';
+import type { ModelLimits } from './overflow.js';
+export interface CompactionSettings {
+    enabled: boolean;
+    /**
+     * Optional cap on the model context window used for compaction decisions.
+     * When set, compaction will behave as if the model's context window is:
+     * `min(modelContextWindow, maxContextTokens)`.
+     */
+    maxContextTokens?: number | undefined;
+    /**
+     * Percentage (0.1–1.0) of the effective context window at which compaction triggers.
+     * Example: 0.9 triggers at 90% of context usage.
+     */
+    thresholdPercent: number;
+}
+export interface CompactionRuntimeContext {
+    sessionId: string;
+    model: LanguageModel;
+    logger: Logger;
+}
 /**
- * Compaction strategy interface.
+ * Compaction strategy.
  *
- * Strategies are responsible for reducing conversation history size
- * when context limits are exceeded. The strategy is called by TurnExecutor
- * after detecting overflow via actual token usage from the API.
+ * This is the DI surface used by core runtime (TurnExecutor/VercelLLMService) to:
+ * - decide when to compact (budget + overflow logic)
+ * - execute compaction given per-session runtime context (model, logger, sessionId)
+ *
+ * Strategies are created by host layers (CLI/server/apps) via image factories.
+ * Core does not parse YAML, validate Zod schemas, or switch on `type` strings.
  */
-export interface ICompactionStrategy {
+export type CompactionStrategy = {
     /** Human-readable name for logging/UI */
     readonly name: string;
+    /** Effective budgeting settings for this strategy */
+    getSettings(): CompactionSettings;
+    /** Effective model limits after applying any strategy caps */
+    getModelLimits(modelContextWindow: number): ModelLimits;
+    /** Whether compaction should run given current input token usage */
+    shouldCompact(inputTokens: number, modelLimits: ModelLimits): boolean;
     /**
      * Compacts the provided message history.
      *
@@ -25,8 +56,9 @@ export interface ICompactionStrategy {
      * - `isSessionSummary: true` - Alternative to isSummary for session-level summaries
      *
      * @param history The current conversation history.
+     * @param context Per-session runtime context (model/logger/sessionId)
      * @returns Summary messages to add to history. Empty array if nothing to compact.
      */
-    compact(history: readonly InternalMessage[]): Promise<InternalMessage[]> | InternalMessage[];
-}
+    compact(history: readonly InternalMessage[], context: CompactionRuntimeContext): Promise<InternalMessage[]>;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/context/compaction/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAChC,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC;CAChG"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,wBAAwB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC7B,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,qDAAqD;IACrD,WAAW,IAAI,kBAAkB,CAAC;IAElC,8DAA8D;IAC9D,cAAc,CAAC,kBAAkB,EAAE,MAAM,GAAG,WAAW,CAAC;IAExD,oEAAoE;IACpE,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC;IAEtE;;;;;;;;;;;;;;;;;;OAkBG;IACH,OAAO,CACH,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,OAAO,EAAE,wBAAwB,GAClC,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;CACjC,CAAC"}