@dexto/core 1.3.0 → 1.4.0

package/dist/{chunk-C6A6W6XS.js → chunk-PTJYTZNU.js}

@@ -45,9 +45,52 @@ var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
 
 export {
   __decoratorStart,
   __runInitializers,
-  __decorateElement
+  __decorateElement,
+  __using,
+  __callDispose
 };

package/dist/{llm/tokenizer/default.cjs → context/compression/overflow.cjs}

@@ -16,26 +16,28 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var default_exports = {};
-__export(default_exports, {
-  DefaultTokenizer: () => DefaultTokenizer
+var overflow_exports = {};
+__export(overflow_exports, {
+  getCompressionTarget: () => getCompressionTarget,
+  isOverflow: () => isOverflow
 });
-module.exports = __toCommonJS(default_exports);
-class DefaultTokenizer {
-  /**
-   * Assumes roughly 4 characters per token.
-   * @param text Text content to count tokens for
-   * @returns Approximate number of tokens
-   */
-  countTokens(text) {
-    if (!text) return 0;
-    return Math.ceil(text.length / 4);
-  }
-  getProviderName() {
-    return "default";
-  }
+module.exports = __toCommonJS(overflow_exports);
+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;
+  const inputTokens = tokens.inputTokens ?? 0;
+  return inputTokens > usableTokens;
+}
+function getCompressionTarget(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);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DefaultTokenizer
+  getCompressionTarget,
+  isOverflow
 });

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

@@ -0,0 +1,33 @@
+import type { TokenUsage } from '../../llm/types.js';
+/**
+ * Model limits configuration for overflow detection.
+ * These limits define the context window boundaries.
+ */
+export interface ModelLimits {
+    /** Maximum context window size in tokens */
+    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.
+ *
+ * Overflow is detected when:
+ * used tokens > (contextWindow - outputBuffer)
+ *
+ * The outputBuffer ensures we always have room for the model's response.
+ *
+ * @param tokens The actual token usage from the last LLM API call
+ * @param modelLimits The model's context window and output limits
+ * @returns true if context has overflowed and compression is needed
+ */
+export declare function isOverflow(tokens: TokenUsage, modelLimits: ModelLimits): boolean;
+/**
+ * Calculate the compression 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%)
+ * @returns The target token count after compression
+ */
+export declare function getCompressionTarget(modelLimits: ModelLimits, targetPercentage?: number): number;
+//# sourceMappingURL=overflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"overflow.d.ts","sourceRoot":"","sources":["../../../src/context/compression/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,oBAAoB,CAChC,WAAW,EAAE,WAAW,EACxB,gBAAgB,GAAE,MAAY,GAC/B,MAAM,CAMR"}

package/dist/context/compression/overflow.js

@@ -0,0 +1,19 @@
+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;
+  const inputTokens = tokens.inputTokens ?? 0;
+  return inputTokens > usableTokens;
+}
+function getCompressionTarget(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);
+}
+export {
+  getCompressionTarget,
+  isOverflow
+};

package/dist/context/compression/reactive-overflow.cjs

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reactive_overflow_exports = {};
+__export(reactive_overflow_exports, {
+  ReactiveOverflowStrategy: () => ReactiveOverflowStrategy
+});
+module.exports = __toCommonJS(reactive_overflow_exports);
+var import_ai = require("ai");
+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
+
+Be concise but preserve essential context. Output only the summary, no preamble.
+
+Conversation:
+{conversation}`
+};
+class ReactiveOverflowStrategy {
+  name = "reactive-overflow";
+  model;
+  options;
+  logger;
+  constructor(model, options = {}, logger) {
+    this.model = model;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    this.logger = logger;
+  }
+  /**
+   * 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 compress(history) {
+    if (history.length <= 2) {
+      this.logger.debug("ReactiveOverflowStrategy: History too short, skipping compression");
+      return [];
+    }
+    const { toSummarize, toKeep } = this.splitHistory(history);
+    if (toSummarize.length === 0) {
+      this.logger.debug("ReactiveOverflowStrategy: No messages to summarize");
+      return [];
+    }
+    this.logger.info(
+      `ReactiveOverflowStrategy: Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`
+    );
+    const summary = await this.generateSummary(toSummarize);
+    const summaryMessage = {
+      role: "assistant",
+      content: [{ type: "text", text: summary }],
+      timestamp: Date.now(),
+      metadata: {
+        isSummary: true,
+        summarizedAt: Date.now(),
+        summarizedMessageCount: toSummarize.length,
+        originalFirstTimestamp: toSummarize[0]?.timestamp,
+        originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
+      }
+    };
+    return [summaryMessage];
+  }
+  /**
+   * Split history into messages to summarize and messages to keep.
+   * Keeps the last N turns (user + assistant pairs) intact.
+   */
+  splitHistory(history) {
+    const turnsToKeep = this.options.preserveLastNTurns;
+    const userMessageIndices = [];
+    for (let i = history.length - 1; i >= 0; i--) {
+      if (history[i]?.role === "user") {
+        userMessageIndices.unshift(i);
+        if (userMessageIndices.length >= turnsToKeep) {
+          break;
+        }
+      }
+    }
+    if (userMessageIndices.length > 0) {
+      const splitIndex = userMessageIndices[0];
+      if (splitIndex !== void 0) {
+        if (splitIndex === 0) {
+          return {
+            toSummarize: [],
+            toKeep: history
+          };
+        }
+        return {
+          toSummarize: history.slice(0, splitIndex),
+          toKeep: history.slice(splitIndex)
+        };
+      }
+    }
+    const keepCount = Math.min(4, history.length);
+    return {
+      toSummarize: history.slice(0, -keepCount),
+      toKeep: history.slice(-keepCount)
+    };
+  }
+  /**
+   * Generate an LLM summary of the messages.
+   */
+  async generateSummary(messages) {
+    const formattedConversation = this.formatMessagesForSummary(messages);
+    const prompt = this.options.summaryPrompt.replace("{conversation}", formattedConversation);
+    try {
+      const result = await (0, import_ai.generateText)({
+        model: this.model,
+        prompt,
+        maxOutputTokens: this.options.maxSummaryTokens
+      });
+      return `[Previous conversation summary]
+${result.text}`;
+    } catch (error) {
+      this.logger.error("ReactiveOverflowStrategy: Failed to generate summary", { error });
+      return this.createFallbackSummary(messages);
+    }
+  }
+  /**
+   * Format messages for the summary prompt.
+   */
+  formatMessagesForSummary(messages) {
+    return messages.map((msg) => {
+      const role = msg.role.toUpperCase();
+      let content;
+      if (typeof msg.content === "string") {
+        content = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        content = msg.content.filter(
+          (part) => part.type === "text"
+        ).map((part) => part.text).join("\n");
+      } else {
+        content = "[no content]";
+      }
+      if (content.length > 2e3) {
+        content = content.slice(0, 2e3) + "... [truncated]";
+      }
+      if ((0, import_types.isAssistantMessage)(msg) && msg.toolCalls && msg.toolCalls.length > 0) {
+        const toolNames = msg.toolCalls.map((tc) => tc.function.name).join(", ");
+        content += `
+[Used tools: ${toolNames}]`;
+      }
+      if ((0, import_types.isToolMessage)(msg)) {
+        return `TOOL (${msg.name}): ${content.slice(0, 500)}${content.length > 500 ? "..." : ""}`;
+      }
+      return `${role}: ${content}`;
+    }).join("\n\n");
+  }
+  /**
+   * Create a fallback summary if LLM call fails.
+   */
+  createFallbackSummary(messages) {
+    const userMessages = messages.filter((m) => m.role === "user");
+    const assistantWithTools = messages.filter(
+      (m) => (0, import_types.isAssistantMessage)(m) && !!m.toolCalls && m.toolCalls.length > 0
+    );
+    const userTopics = userMessages.slice(-3).map((m) => {
+      const text = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.filter(
+        (p) => p.type === "text"
+      ).map((p) => p.text).join(" ") : "";
+      return text.slice(0, 100);
+    }).join("; ");
+    const toolsUsed = [
+      ...new Set(
+        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"}`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReactiveOverflowStrategy
+});

package/dist/context/compression/reactive-overflow.d.ts

@@ -0,0 +1,81 @@
+import { type LanguageModel } from 'ai';
+import type { ICompressionStrategy } from './types.js';
+import type { InternalMessage } from '../types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
+/**
+ * Configuration options for ReactiveOverflowStrategy.
+ */
+export interface ReactiveOverflowOptions {
+    /**
+     * Number of recent turns to preserve (not summarize).
+     * A "turn" is a user message + assistant response pair.
+     * Default: 2
+     */
+    preserveLastNTurns?: number;
+    /**
+     * Maximum tokens for the summary output.
+     * Default: 2000
+     */
+    maxSummaryTokens?: number;
+    /**
+     * Custom summary prompt template.
+     * Use {conversation} as placeholder for formatted messages.
+     */
+    summaryPrompt?: string;
+}
+/**
+ * ReactiveOverflowStrategy implements reactive compression.
+ *
+ * Key behaviors:
+ * - Triggers on overflow (after actual tokens exceed context limit)
+ * - Uses LLM to generate intelligent summary of older messages
+ * - Returns summary message to ADD to history (not replace)
+ * - Read-time filtering via filterCompacted() excludes pre-summary messages
+ *
+ * This strategy is designed to work with TurnExecutor's main loop:
+ * 1. After each step, check if overflow occurred
+ * 2. If yes, generate summary and ADD it to history
+ * 3. filterCompacted() in getFormattedMessages() excludes old messages
+ * 4. Continue with fresh context (summary + recent messages)
+ *
+ * NOTE: This does NOT replace history. The summary message is ADDED,
+ * and filterCompacted() handles excluding old messages at read-time.
+ * This preserves full history for audit/recovery purposes.
+ */
+export declare class ReactiveOverflowStrategy implements ICompressionStrategy {
+    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
+     */
+    compress(history: readonly InternalMessage[]): Promise<InternalMessage[]>;
+    /**
+     * Split history into messages to summarize and messages to keep.
+     * Keeps the last N turns (user + assistant pairs) intact.
+     */
+    private splitHistory;
+    /**
+     * Generate an LLM summary of the messages.
+     */
+    private generateSummary;
+    /**
+     * Format messages for the summary prompt.
+     */
+    private formatMessagesForSummary;
+    /**
+     * Create a fallback summary if LLM call fails.
+     */
+    private createFallbackSummary;
+}
+//# sourceMappingURL=reactive-overflow.d.ts.map

package/dist/context/compression/reactive-overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive-overflow.d.ts","sourceRoot":"","sources":["../../../src/context/compression/reactive-overflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,aAAa,EAAE,MAAM,IAAI,CAAC;AACtD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAY,MAAM,aAAa,CAAC;AAE7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;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,oBAAoB;IACjE,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,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IA0C/E;;;OAGG;IACH,OAAO,CAAC,YAAY;IA2CpB;;OAEG;YACW,eAAe;IAmB7B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA2ChC;;OAEG;IACH,OAAO,CAAC,qBAAqB;CAiChC"}

package/dist/context/compression/reactive-overflow.js

@@ -0,0 +1,178 @@
+import "../../chunk-PTJYTZNU.js";
+import { generateText } from "ai";
+import { isAssistantMessage, isToolMessage } from "../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
+
+Be concise but preserve essential context. Output only the summary, no preamble.
+
+Conversation:
+{conversation}`
+};
+class ReactiveOverflowStrategy {
+  name = "reactive-overflow";
+  model;
+  options;
+  logger;
+  constructor(model, options = {}, logger) {
+    this.model = model;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+    this.logger = logger;
+  }
+  /**
+   * 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 compress(history) {
+    if (history.length <= 2) {
+      this.logger.debug("ReactiveOverflowStrategy: History too short, skipping compression");
+      return [];
+    }
+    const { toSummarize, toKeep } = this.splitHistory(history);
+    if (toSummarize.length === 0) {
+      this.logger.debug("ReactiveOverflowStrategy: No messages to summarize");
+      return [];
+    }
+    this.logger.info(
+      `ReactiveOverflowStrategy: Summarizing ${toSummarize.length} messages, keeping ${toKeep.length}`
+    );
+    const summary = await this.generateSummary(toSummarize);
+    const summaryMessage = {
+      role: "assistant",
+      content: [{ type: "text", text: summary }],
+      timestamp: Date.now(),
+      metadata: {
+        isSummary: true,
+        summarizedAt: Date.now(),
+        summarizedMessageCount: toSummarize.length,
+        originalFirstTimestamp: toSummarize[0]?.timestamp,
+        originalLastTimestamp: toSummarize[toSummarize.length - 1]?.timestamp
+      }
+    };
+    return [summaryMessage];
+  }
+  /**
+   * Split history into messages to summarize and messages to keep.
+   * Keeps the last N turns (user + assistant pairs) intact.
+   */
+  splitHistory(history) {
+    const turnsToKeep = this.options.preserveLastNTurns;
+    const userMessageIndices = [];
+    for (let i = history.length - 1; i >= 0; i--) {
+      if (history[i]?.role === "user") {
+        userMessageIndices.unshift(i);
+        if (userMessageIndices.length >= turnsToKeep) {
+          break;
+        }
+      }
+    }
+    if (userMessageIndices.length > 0) {
+      const splitIndex = userMessageIndices[0];
+      if (splitIndex !== void 0) {
+        if (splitIndex === 0) {
+          return {
+            toSummarize: [],
+            toKeep: history
+          };
+        }
+        return {
+          toSummarize: history.slice(0, splitIndex),
+          toKeep: history.slice(splitIndex)
+        };
+      }
+    }
+    const keepCount = Math.min(4, history.length);
+    return {
+      toSummarize: history.slice(0, -keepCount),
+      toKeep: history.slice(-keepCount)
+    };
+  }
+  /**
+   * Generate an LLM summary of the messages.
+   */
+  async generateSummary(messages) {
+    const formattedConversation = this.formatMessagesForSummary(messages);
+    const prompt = this.options.summaryPrompt.replace("{conversation}", formattedConversation);
+    try {
+      const result = await generateText({
+        model: this.model,
+        prompt,
+        maxOutputTokens: this.options.maxSummaryTokens
+      });
+      return `[Previous conversation summary]
+${result.text}`;
+    } catch (error) {
+      this.logger.error("ReactiveOverflowStrategy: Failed to generate summary", { error });
+      return this.createFallbackSummary(messages);
+    }
+  }
+  /**
+   * Format messages for the summary prompt.
+   */
+  formatMessagesForSummary(messages) {
+    return messages.map((msg) => {
+      const role = msg.role.toUpperCase();
+      let content;
+      if (typeof msg.content === "string") {
+        content = msg.content;
+      } else if (Array.isArray(msg.content)) {
+        content = msg.content.filter(
+          (part) => part.type === "text"
+        ).map((part) => part.text).join("\n");
+      } else {
+        content = "[no content]";
+      }
+      if (content.length > 2e3) {
+        content = content.slice(0, 2e3) + "... [truncated]";
+      }
+      if (isAssistantMessage(msg) && msg.toolCalls && msg.toolCalls.length > 0) {
+        const toolNames = msg.toolCalls.map((tc) => tc.function.name).join(", ");
+        content += `
+[Used tools: ${toolNames}]`;
+      }
+      if (isToolMessage(msg)) {
+        return `TOOL (${msg.name}): ${content.slice(0, 500)}${content.length > 500 ? "..." : ""}`;
+      }
+      return `${role}: ${content}`;
+    }).join("\n\n");
+  }
+  /**
+   * Create a fallback summary if LLM call fails.
+   */
+  createFallbackSummary(messages) {
+    const userMessages = messages.filter((m) => m.role === "user");
+    const assistantWithTools = messages.filter(
+      (m) => isAssistantMessage(m) && !!m.toolCalls && m.toolCalls.length > 0
+    );
+    const userTopics = userMessages.slice(-3).map((m) => {
+      const text = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.filter(
+        (p) => p.type === "text"
+      ).map((p) => p.text).join(" ") : "";
+      return text.slice(0, 100);
+    }).join("; ");
+    const toolsUsed = [
+      ...new Set(
+        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"}`;
+  }
+}
+export {
+  ReactiveOverflowStrategy
+};

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

@@ -1,18 +1,20 @@
 import { InternalMessage } from '../types.js';
-import { ITokenizer } from '../../llm/tokenizer/types.js';
 /**
- * Defines the contract for a strategy used to compress a conversation history
- * to fit within a maximum token limit.
+ * Compression strategy interface.
+ *
+ * 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.
  */
 export interface ICompressionStrategy {
+    /** Human-readable name for logging/UI */
+    readonly name: string;
     /**
      * Compresses the provided message history.
      *
      * @param history The current conversation history.
-     * @param tokenizer The tokenizer used to calculate message tokens.
-     * @param maxInputTokens The maximum number of tokens allowed in the history.
-     * @returns The potentially compressed message history.
+     * @returns Summary messages to add to history (filterCompacted handles the rest).
      */
-    compress(history: InternalMessage[], tokenizer: ITokenizer, maxInputTokens: number): InternalMessage[];
+    compress(history: readonly InternalMessage[]): Promise<InternalMessage[]> | InternalMessage[];
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/context/compression/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;;;;;OAOG;IACH,QAAQ,CACJ,OAAO,EAAE,eAAe,EAAE,EAC1B,SAAS,EAAE,UAAU,EACrB,cAAc,EAAE,MAAM,GACvB,eAAe,EAAE,CAAC;CACxB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/context/compression/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACjC,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,GAAG,eAAe,EAAE,CAAC;CACjG"}

package/dist/context/error-codes.cjs

@@ -33,6 +33,9 @@ var ContextErrorCode = /* @__PURE__ */ ((ContextErrorCode2) => {
   ContextErrorCode2["TOKEN_COUNT_FAILED"] = "context_token_count_failed";
   ContextErrorCode2["PRESERVE_VALUES_NEGATIVE"] = "context_preserve_values_negative";
   ContextErrorCode2["MIN_MESSAGES_NEGATIVE"] = "context_min_messages_negative";
+  ContextErrorCode2["MESSAGE_NOT_FOUND"] = "context_message_not_found";
+  ContextErrorCode2["MESSAGE_NOT_ASSISTANT"] = "context_message_not_assistant";
+  ContextErrorCode2["ASSISTANT_CONTENT_NOT_STRING"] = "context_assistant_content_not_string";
   return ContextErrorCode2;
 })(ContextErrorCode || {});
 // Annotate the CommonJS export names for ESM import in node: