@dexto/core 1.5.3 → 1.5.4

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

@@ -4,29 +4,32 @@ import type { TokenUsage } from '../../llm/types.js';
  * These limits define the context window boundaries.
  */
 export interface ModelLimits {
-    /** Maximum context window size in tokens */
+    /** Maximum context window size in tokens (the model's input limit) */
     contextWindow: number;
-    /** Maximum output tokens the model can generate */
-    maxOutput: number;
 }
 /**
- * Determines if the context has overflowed based on actual token usage from the API.
+ * Determines if the context has overflowed based on token usage.
  *
  * Overflow is detected when:
- * used tokens > (contextWindow - outputBuffer)
+ *   inputTokens > contextWindow * thresholdPercent
  *
- * The outputBuffer ensures we always have room for the model's response.
+ * The thresholdPercent allows triggering compaction before hitting 100% (e.g., at 90%).
+ * This provides a safety margin for estimation errors and prevents hitting hard limits.
  *
- * @param tokens The actual token usage from the last LLM API call
- * @param modelLimits The model's context window and output limits
+ * Note: We don't reserve space for "output" because input and output have separate limits
+ * in LLM APIs. The model's output doesn't consume from the input context window.
+ *
+ * @param tokens The token usage (actual from API or estimated)
+ * @param modelLimits The model's context window limit
+ * @param thresholdPercent Percentage of context window at which to trigger (default 0.9 = 90%)
  * @returns true if context has overflowed and compaction is needed
  */
-export declare function isOverflow(tokens: TokenUsage, modelLimits: ModelLimits): boolean;
+export declare function isOverflow(tokens: TokenUsage, modelLimits: ModelLimits, thresholdPercent?: number): boolean;
 /**
  * Calculate the compaction target - how many tokens we need to reduce to.
  *
- * @param modelLimits The model's context window and output limits
- * @param targetPercentage What percentage of usable context to target (default 70%)
+ * @param modelLimits The model's context window limit
+ * @param targetPercentage What percentage of context to target (default 70%)
  * @returns The target token count after compaction
  */
 export declare function getCompactionTarget(modelLimits: ModelLimits, targetPercentage?: number): number;

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

@@ -1 +1 @@
-{"version":3,"file":"overflow.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/overflow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,WAAW;IACxB,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;CACrB;AAQD;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,GAAG,OAAO,CAYhF;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAC/B,WAAW,EAAE,WAAW,EACxB,gBAAgB,GAAE,MAAY,GAC/B,MAAM,CAMR"}
+{"version":3,"file":"overflow.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/overflow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,WAAW;IACxB,sEAAsE;IACtE,aAAa,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,CACtB,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,WAAW,EACxB,gBAAgB,GAAE,MAAY,GAC/B,OAAO,CAWT;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAC/B,WAAW,EAAE,WAAW,EACxB,gBAAgB,GAAE,MAAY,GAC/B,MAAM,CAGR"}

package/dist/context/compaction/overflow.js

@@ -1,17 +1,13 @@
 import "../../chunk-PTJYTZNU.js";
-const DEFAULT_OUTPUT_BUFFER = 16e3;
-function isOverflow(tokens, modelLimits) {
-  const { contextWindow, maxOutput } = modelLimits;
-  const outputBuffer = Math.min(maxOutput, DEFAULT_OUTPUT_BUFFER);
-  const usableTokens = contextWindow - outputBuffer;
+function isOverflow(tokens, modelLimits, thresholdPercent = 0.9) {
+  const { contextWindow } = modelLimits;
+  const effectiveLimit = Math.floor(contextWindow * thresholdPercent);
   const inputTokens = tokens.inputTokens ?? 0;
-  return inputTokens > usableTokens;
+  return inputTokens > effectiveLimit;
 }
 function getCompactionTarget(modelLimits, targetPercentage = 0.7) {
-  const { contextWindow, maxOutput } = modelLimits;
-  const outputBuffer = Math.min(maxOutput, DEFAULT_OUTPUT_BUFFER);
-  const usableTokens = contextWindow - outputBuffer;
-  return Math.floor(usableTokens * targetPercentage);
+  const { contextWindow } = modelLimits;
+  return Math.floor(contextWindow * targetPercentage);
 }
 export {
   getCompactionTarget,

package/dist/context/compaction/providers/reactive-overflow-provider.cjs

@@ -27,6 +27,21 @@ var import_reactive_overflow = require("../strategies/reactive-overflow.js");
 const ReactiveOverflowConfigSchema = import_zod.z.object({
   type: import_zod.z.literal("reactive-overflow"),
   enabled: import_zod.z.boolean().default(true).describe("Enable or disable compaction"),
+  /**
+   * Maximum context tokens before compaction triggers.
+   * When set, overrides the model's context window for compaction threshold.
+   * Useful for capping context size below the model's maximum limit.
+   */
+  maxContextTokens: import_zod.z.number().positive().optional().describe(
+    "Maximum context tokens before compaction triggers. Overrides model context window when set."
+  ),
+  /**
+   * Percentage of context window that triggers compaction (0.1 to 1.0).
+   * Default is 1.0 (100%), meaning compaction triggers when context is full.
+   */
+  thresholdPercent: import_zod.z.number().min(0.1).max(1).default(1).describe(
+    "Percentage of context window that triggers compaction (0.1 to 1.0, default 1.0)"
+  ),
   preserveLastNTurns: import_zod.z.number().int().positive().default(2).describe("Number of recent turns (user+assistant pairs) to preserve"),
   maxSummaryTokens: import_zod.z.number().int().positive().default(2e3).describe("Maximum tokens for the summary output"),
   summaryPrompt: import_zod.z.string().optional().describe("Custom summary prompt template. Use {conversation} as placeholder")

package/dist/context/compaction/providers/reactive-overflow-provider.d.ts

@@ -6,18 +6,33 @@ import type { CompactionProvider } from '../provider.js';
 export declare const ReactiveOverflowConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"reactive-overflow">;
     enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Maximum context tokens before compaction triggers.
+     * When set, overrides the model's context window for compaction threshold.
+     * Useful for capping context size below the model's maximum limit.
+     */
+    maxContextTokens: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Percentage of context window that triggers compaction (0.1 to 1.0).
+     * Default is 1.0 (100%), meaning compaction triggers when context is full.
+     */
+    thresholdPercent: z.ZodDefault<z.ZodNumber>;
     preserveLastNTurns: z.ZodDefault<z.ZodNumber>;
     maxSummaryTokens: z.ZodDefault<z.ZodNumber>;
     summaryPrompt: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
     type: "reactive-overflow";
     enabled: boolean;
+    thresholdPercent: number;
     preserveLastNTurns: number;
     maxSummaryTokens: number;
+    maxContextTokens?: number | undefined;
     summaryPrompt?: string | undefined;
 }, {
     type: "reactive-overflow";
     enabled?: boolean | undefined;
+    maxContextTokens?: number | undefined;
+    thresholdPercent?: number | undefined;
     preserveLastNTurns?: number | undefined;
     maxSummaryTokens?: number | undefined;
     summaryPrompt?: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"reactive-overflow-provider.d.ts","sourceRoot":"","sources":["../../../../src/context/compaction/providers/reactive-overflow-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAGzD;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;EAqB5B,CAAC;AAEd,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAEnF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,EAAE,kBAAkB,CACrD,mBAAmB,EACnB,sBAAsB,CA2BzB,CAAC"}
+{"version":3,"file":"reactive-overflow-provider.d.ts","sourceRoot":"","sources":["../../../../src/context/compaction/providers/reactive-overflow-provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAGzD;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;IAIjC;;;;OAIG;;IAQH;;;OAGG;;;;;;;;;;;;;;;;;;;;;EA0BE,CAAC;AAEd,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAEnF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,EAAE,kBAAkB,CACrD,mBAAmB,EACnB,sBAAsB,CA2BzB,CAAC"}

package/dist/context/compaction/providers/reactive-overflow-provider.js

@@ -4,6 +4,21 @@ import { ReactiveOverflowStrategy } from "../strategies/reactive-overflow.js";
 const ReactiveOverflowConfigSchema = z.object({
   type: z.literal("reactive-overflow"),
   enabled: z.boolean().default(true).describe("Enable or disable compaction"),
+  /**
+   * Maximum context tokens before compaction triggers.
+   * When set, overrides the model's context window for compaction threshold.
+   * Useful for capping context size below the model's maximum limit.
+   */
+  maxContextTokens: z.number().positive().optional().describe(
+    "Maximum context tokens before compaction triggers. Overrides model context window when set."
+  ),
+  /**
+   * Percentage of context window that triggers compaction (0.1 to 1.0).
+   * Default is 1.0 (100%), meaning compaction triggers when context is full.
+   */
+  thresholdPercent: z.number().min(0.1).max(1).default(1).describe(
+    "Percentage of context window that triggers compaction (0.1 to 1.0, default 1.0)"
+  ),
   preserveLastNTurns: z.number().int().positive().default(2).describe("Number of recent turns (user+assistant pairs) to preserve"),
   maxSummaryTokens: z.number().int().positive().default(2e3).describe("Maximum tokens for the summary output"),
   summaryPrompt: z.string().optional().describe("Custom summary prompt template. Use {conversation} as placeholder")

package/dist/context/compaction/schemas.cjs

@@ -25,11 +25,31 @@ module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
 const CompactionConfigSchema = import_zod.z.object({
   type: import_zod.z.string().describe("Compaction provider type"),
-  enabled: import_zod.z.boolean().default(true).describe("Enable or disable compaction")
+  enabled: import_zod.z.boolean().default(true).describe("Enable or disable compaction"),
+  /**
+   * Maximum context tokens before compaction triggers.
+   * When set, overrides the model's context window for compaction threshold.
+   * Useful for capping context size below the model's maximum limit.
+   * Example: Set to 50000 to trigger compaction at 50K tokens even if
+   * the model supports 200K tokens.
+   */
+  maxContextTokens: import_zod.z.number().positive().optional().describe(
+    "Maximum context tokens before compaction triggers. Overrides model context window when set."
+  ),
+  /**
+   * Percentage of context window that triggers compaction (0.0 to 1.0).
+   * Default is 0.9 (90%), leaving a 10% buffer to avoid context degradation.
+   * Set lower values to trigger compaction earlier.
+   * Example: 0.8 triggers compaction when 80% of context is used.
+   */
+  thresholdPercent: import_zod.z.number().min(0.1).max(1).default(0.9).describe(
+    "Percentage of context window that triggers compaction (0.1 to 1.0, default 0.9)"
+  )
 }).passthrough().describe("Context compaction configuration");
 const DEFAULT_COMPACTION_CONFIG = {
   type: "reactive-overflow",
-  enabled: true
+  enabled: true,
+  thresholdPercent: 0.9
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -9,12 +9,57 @@ import { z } from 'zod';
 export declare const CompactionConfigSchema: z.ZodObject<{
     type: z.ZodString;
     enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Maximum context tokens before compaction triggers.
+     * When set, overrides the model's context window for compaction threshold.
+     * Useful for capping context size below the model's maximum limit.
+     * Example: Set to 50000 to trigger compaction at 50K tokens even if
+     * the model supports 200K tokens.
+     */
+    maxContextTokens: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Percentage of context window that triggers compaction (0.0 to 1.0).
+     * Default is 0.9 (90%), leaving a 10% buffer to avoid context degradation.
+     * Set lower values to trigger compaction earlier.
+     * Example: 0.8 triggers compaction when 80% of context is used.
+     */
+    thresholdPercent: z.ZodDefault<z.ZodNumber>;
 }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
     type: z.ZodString;
     enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Maximum context tokens before compaction triggers.
+     * When set, overrides the model's context window for compaction threshold.
+     * Useful for capping context size below the model's maximum limit.
+     * Example: Set to 50000 to trigger compaction at 50K tokens even if
+     * the model supports 200K tokens.
+     */
+    maxContextTokens: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Percentage of context window that triggers compaction (0.0 to 1.0).
+     * Default is 0.9 (90%), leaving a 10% buffer to avoid context degradation.
+     * Set lower values to trigger compaction earlier.
+     * Example: 0.8 triggers compaction when 80% of context is used.
+     */
+    thresholdPercent: z.ZodDefault<z.ZodNumber>;
 }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
     type: z.ZodString;
     enabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Maximum context tokens before compaction triggers.
+     * When set, overrides the model's context window for compaction threshold.
+     * Useful for capping context size below the model's maximum limit.
+     * Example: Set to 50000 to trigger compaction at 50K tokens even if
+     * the model supports 200K tokens.
+     */
+    maxContextTokens: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Percentage of context window that triggers compaction (0.0 to 1.0).
+     * Default is 0.9 (90%), leaving a 10% buffer to avoid context degradation.
+     * Set lower values to trigger compaction earlier.
+     * Example: 0.8 triggers compaction when 80% of context is used.
+     */
+    thresholdPercent: z.ZodDefault<z.ZodNumber>;
 }, z.ZodTypeAny, "passthrough">>;
 export type CompactionConfigInput = z.output<typeof CompactionConfigSchema>;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;gCAMc,CAAC;AAElD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,qBAGvC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;IAI3B;;;;;;OAMG;;IAQH;;;;;OAKG;;;;;IAnBH;;;;;;OAMG;;IAQH;;;;;OAKG;;;;;IAnBH;;;;;;OAMG;;IAQH;;;;;OAKG;;gCAWsC,CAAC;AAElD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,yBAAyB,EAAE,qBAIvC,CAAC"}

package/dist/context/compaction/schemas.js

@@ -2,11 +2,31 @@ import "../../chunk-PTJYTZNU.js";
 import { z } from "zod";
 const CompactionConfigSchema = z.object({
   type: z.string().describe("Compaction provider type"),
-  enabled: z.boolean().default(true).describe("Enable or disable compaction")
+  enabled: z.boolean().default(true).describe("Enable or disable compaction"),
+  /**
+   * Maximum context tokens before compaction triggers.
+   * When set, overrides the model's context window for compaction threshold.
+   * Useful for capping context size below the model's maximum limit.
+   * Example: Set to 50000 to trigger compaction at 50K tokens even if
+   * the model supports 200K tokens.
+   */
+  maxContextTokens: z.number().positive().optional().describe(
+    "Maximum context tokens before compaction triggers. Overrides model context window when set."
+  ),
+  /**
+   * Percentage of context window that triggers compaction (0.0 to 1.0).
+   * Default is 0.9 (90%), leaving a 10% buffer to avoid context degradation.
+   * Set lower values to trigger compaction earlier.
+   * Example: 0.8 triggers compaction when 80% of context is used.
+   */
+  thresholdPercent: z.number().min(0.1).max(1).default(0.9).describe(
+    "Percentage of context window that triggers compaction (0.1 to 1.0, default 0.9)"
+  )
 }).passthrough().describe("Context compaction configuration");
 const DEFAULT_COMPACTION_CONFIG = {
   type: "reactive-overflow",
-  enabled: true
+  enabled: true,
+  thresholdPercent: 0.9
 };
 export {
   CompactionConfigSchema,

package/dist/context/compaction/strategies/reactive-overflow.cjs

@@ -26,15 +26,36 @@ var import_types = require("../../types.js");
 const DEFAULT_OPTIONS = {
   preserveLastNTurns: 2,
   maxSummaryTokens: 2e3,
-  summaryPrompt: `You are a conversation summarizer. Summarize the following conversation history concisely, focusing on:
-- What tasks were attempted and their outcomes
-- Current state and context the assistant needs to remember
-- Any important decisions or information discovered
-- What the user was trying to accomplish
+  summaryPrompt: `You are a conversation summarizer creating a structured summary for session continuation.
 
-Be concise but preserve essential context. Output only the summary, no preamble.
+Analyze the conversation and produce a summary in the following XML format:
 
-Conversation:
+<session_compaction>
+  <conversation_history>
+    A concise summary of what happened in the conversation:
+    - Tasks attempted and their outcomes (success/failure/in-progress)
+    - Important decisions made
+    - Key information discovered (file paths, configurations, errors encountered)
+    - Tools used and their results
+  </conversation_history>
+
+  <current_task>
+    The most recent task or instruction the user requested that may still be in progress.
+    Be specific - include the exact request and current status.
+  </current_task>
+
+  <important_context>
+    Critical state that must be preserved:
+    - File paths being worked on
+    - Variable values or configurations
+    - Error messages that need addressing
+    - Any pending actions or next steps
+  </important_context>
+</session_compaction>
+
+IMPORTANT: The assistant will continue working based on this summary. Ensure the current_task section clearly states what needs to be done next.
+
+Conversation to summarize:
 {conversation}`
 };
 class ReactiveOverflowStrategy {
@@ -63,15 +84,71 @@ class ReactiveOverflowStrategy {
       this.logger.debug("ReactiveOverflowStrategy: History too short, skipping compaction");
       return [];
     }
+    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;
+      }
+    }
+    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`
+        );
+        return [];
+      }
+      this.logger.info(
+        `ReactiveOverflowStrategy: Found existing summary at index ${existingSummaryIndex}, working with ${messagesAfterSummary.length} messages after it`
+      );
+      return this.compactSubset(messagesAfterSummary, history);
+    }
     const { toSummarize, toKeep } = this.splitHistory(history);
     if (toSummarize.length === 0) {
       this.logger.debug("ReactiveOverflowStrategy: No messages to summarize");
       return [];
     }
+    const currentTaskMessage = this.findCurrentTaskMessage(history);
     this.logger.info(
       `ReactiveOverflowStrategy: Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`
     );
-    const summary = await this.generateSummary(toSummarize);
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
+    const summaryMessage = {
+      role: "assistant",
+      content: [{ type: "text", text: summary }],
+      timestamp: Date.now(),
+      metadata: {
+        isSummary: true,
+        summarizedAt: Date.now(),
+        originalMessageCount: toSummarize.length,
+        originalFirstTimestamp: toSummarize[0]?.timestamp,
+        originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
+      }
+    };
+    return [summaryMessage];
+  }
+  /**
+   * 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)
+   * @returns Array with single summary message, or empty if nothing to summarize
+   */
+  async compactSubset(messagesAfterSummary, fullHistory) {
+    const { toSummarize, toKeep } = this.splitHistory(messagesAfterSummary);
+    if (toSummarize.length === 0) {
+      this.logger.debug("ReactiveOverflowStrategy: 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}`
+    );
+    const summary = await this.generateSummary(toSummarize, currentTaskMessage);
     const summaryMessage = {
       role: "assistant",
       content: [{ type: "text", text: summary }],
@@ -79,16 +156,43 @@ class ReactiveOverflowStrategy {
       metadata: {
         isSummary: true,
         summarizedAt: Date.now(),
-        summarizedMessageCount: toSummarize.length,
+        originalMessageCount: toSummarize.length,
+        isRecompaction: true,
+        // Mark that this is a re-compaction
         originalFirstTimestamp: toSummarize[0]?.timestamp,
         originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
       }
     };
     return [summaryMessage];
   }
+  /**
+   * 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--) {
+      const msg = history[i];
+      if (msg?.role === "user") {
+        if (typeof msg.content === "string") {
+          return msg.content;
+        } else if (Array.isArray(msg.content)) {
+          const textParts = msg.content.filter(
+            (part) => part.type === "text"
+          ).map((part) => part.text).join("\n");
+          if (textParts.length > 0) {
+            return textParts;
+          }
+        }
+      }
+    }
+    return null;
+  }
   /**
    * 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;
@@ -103,20 +207,25 @@ class ReactiveOverflowStrategy {
     }
     if (userMessageIndices.length > 0) {
       const splitIndex = userMessageIndices[0];
-      if (splitIndex !== void 0) {
-        if (splitIndex === 0) {
-          return {
-            toSummarize: [],
-            toKeep: history
-          };
-        }
+      if (splitIndex !== void 0 && splitIndex > 0) {
         return {
           toSummarize: history.slice(0, splitIndex),
           toKeep: history.slice(splitIndex)
         };
       }
     }
-    const keepCount = Math.min(4, history.length);
+    const minKeep = 3;
+    const maxKeepPercent = 0.2;
+    const keepCount = Math.max(minKeep, Math.floor(history.length * maxKeepPercent));
+    if (keepCount >= history.length) {
+      return {
+        toSummarize: [],
+        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)
@@ -124,21 +233,36 @@ 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) {
+  async generateSummary(messages, currentTask) {
     const formattedConversation = this.formatMessagesForSummary(messages);
-    const prompt = this.options.summaryPrompt.replace("{conversation}", formattedConversation);
+    let conversationWithContext = formattedConversation;
+    if (currentTask) {
+      conversationWithContext += `
+
+--- CURRENT TASK (most recent user request) ---
+${currentTask}`;
+    }
+    const prompt = this.options.summaryPrompt.replace(
+      "{conversation}",
+      conversationWithContext
+    );
     try {
       const result = await (0, import_ai.generateText)({
         model: this.model,
         prompt,
         maxOutputTokens: this.options.maxSummaryTokens
       });
-      return `[Previous conversation summary]
+      return `[Session Compaction Summary]
 ${result.text}`;
     } catch (error) {
-      this.logger.error("ReactiveOverflowStrategy: Failed to generate summary", { error });
-      return this.createFallbackSummary(messages);
+      this.logger.error(
+        `ReactiveOverflowStrategy: Failed to generate summary - ${error instanceof Error ? error.message : String(error)}`
+      );
+      return this.createFallbackSummary(messages, currentTask);
     }
   }
   /**
@@ -174,7 +298,7 @@ ${result.text}`;
   /**
    * Create a fallback summary if LLM call fails.
    */
-  createFallbackSummary(messages) {
+  createFallbackSummary(messages, currentTask) {
     const userMessages = messages.filter((m) => m.role === "user");
     const assistantWithTools = messages.filter(
       (m) => (0, import_types.isAssistantMessage)(m) && !!m.toolCalls && m.toolCalls.length > 0
@@ -190,9 +314,25 @@ ${result.text}`;
         assistantWithTools.flatMap((m) => m.toolCalls.map((tc) => tc.function.name))
       )
     ].join(", ");
-    return `[Previous conversation summary - fallback]
-User discussed: ${userTopics || "various topics"}
-Tools used: ${toolsUsed || "none"}`;
+    let fallback = `[Session Compaction Summary - Fallback]
+<session_compaction>
+  <conversation_history>
+    User discussed: ${userTopics || "various topics"}
+    Tools used: ${toolsUsed || "none"}
+    Messages summarized: ${messages.length}
+  </conversation_history>`;
+    if (currentTask) {
+      fallback += `
+  <current_task>
+    ${currentTask.slice(0, 500)}${currentTask.length > 500 ? "..." : ""}
+  </current_task>`;
+    }
+    fallback += `
+  <important_context>
+    Note: This is a fallback summary due to LLM error. Context may be incomplete.
+  </important_context>
+</session_compaction>`;
+    return fallback;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -60,13 +60,34 @@ export declare class ReactiveOverflowStrategy implements ICompactionStrategy {
      * @returns Array with single summary message to add, or empty if nothing to summarize
      */
     compact(history: readonly InternalMessage[]): 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)
+     * @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;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"reactive-overflow.d.ts","sourceRoot":"","sources":["../../../../src/context/compaction/strategies/reactive-overflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,IAAI,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAY,MAAM,gBAAgB,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;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;AAiBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAChE,QAAQ,CAAC,IAAI,uBAAuB;IAEpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAC5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAE1B,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,uBAAuB,YAAK,EAAE,MAAM,EAAE,YAAY;IAM7F;;;;;;;;;;OAUG;IACG,OAAO,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA0C9E;;;OAGG;IACH,OAAO,CAAC,YAAY;IA2CpB;;OAEG;YACW,eAAe;IAmB7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA2ChC;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAiChC"}
+{"version":3,"file":"reactive-overflow.d.ts","sourceRoot":"","sources":["../../../../src/context/compaction/strategies/reactive-overflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,IAAI,CAAC;AACtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAY,MAAM,gBAAgB,CAAC;AAEhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;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;AAsCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAChE,QAAQ,CAAC,IAAI,uBAAuB;IAEpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAC5D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;gBAE1B,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,uBAAuB,YAAK,EAAE,MAAM,EAAE,YAAY;IAM7F;;;;;;;;;;OAUG;IACG,OAAO,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAiF9E;;;;;;;;OAQG;YACW,aAAa;IA0C3B;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAuB9B;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAwDpB;;;;;OAKG;YACW,eAAe;IAmC7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA2ChC;;OAEG;IACH,OAAO,CAAC,qBAAqB;CA0DhC"}