@dexto/core 1.1.4 → 1.1.6

package/dist/config/writer.js

@@ -0,0 +1,146 @@
+import { promises as fs } from "fs";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import * as path from "path";
+import { logger } from "../logger/index.js";
+import { ConfigError } from "./errors.js";
+async function writeConfigFile(configPath, config) {
+  const absolutePath = path.resolve(configPath);
+  try {
+    const yamlContent = stringifyYaml(config, { indent: 2 });
+    await fs.writeFile(absolutePath, yamlContent, "utf-8");
+    logger.debug(`Wrote dexto config to: ${absolutePath}`);
+  } catch (error) {
+    throw ConfigError.fileWriteError(
+      absolutePath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function writeLLMPreferences(configPath, preferences, overrides) {
+  logger.debug(`Writing LLM preferences to: ${configPath}`, {
+    provider: overrides?.provider ?? preferences.llm.provider,
+    model: overrides?.model ?? preferences.llm.model,
+    hasApiKeyOverride: Boolean(overrides?.apiKey),
+    hasPreferenceApiKey: Boolean(preferences.llm.apiKey)
+  });
+  logger.debug(`Reading config file: ${configPath}`);
+  let fileContent;
+  try {
+    fileContent = await fs.readFile(configPath, "utf-8");
+    logger.debug(`Successfully read config file (${fileContent.length} chars)`);
+  } catch (error) {
+    logger.error(`Failed to read config file: ${configPath}`, { error });
+    throw ConfigError.fileReadError(
+      configPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  let config;
+  try {
+    config = parseYaml(fileContent);
+    logger.debug(`Successfully parsed YAML config`, {
+      hasLlmSection: Boolean(config.llm),
+      existingProvider: config.llm?.provider,
+      existingModel: config.llm?.model
+    });
+  } catch (error) {
+    logger.error(`Failed to parse YAML config: ${configPath}`, { error });
+    throw ConfigError.parseError(
+      configPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  const provider = overrides?.provider ?? preferences.llm.provider;
+  const model = overrides?.model ?? preferences.llm.model;
+  const apiKey = overrides?.apiKey ?? preferences.llm.apiKey;
+  logger.debug(`Applying LLM preferences`, {
+    finalProvider: provider,
+    finalModel: model,
+    hasApiKey: Boolean(apiKey),
+    source: overrides ? "CLI overrides + preferences" : "preferences only"
+  });
+  config.llm = {
+    ...config.llm,
+    // Preserve temperature, router, maxTokens, etc.
+    provider,
+    // Write user preference
+    model,
+    // Write user preference
+    apiKey
+    // Write user preference
+  };
+  await writeConfigFile(configPath, config);
+  logger.info(`\u2713 Applied preferences to: ${path.basename(configPath)} (${provider}/${model})`);
+}
+async function writePreferencesToAgent(installedPath, preferences, overrides) {
+  let stat;
+  try {
+    stat = await fs.stat(installedPath);
+  } catch (error) {
+    throw ConfigError.fileReadError(
+      installedPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  if (stat.isFile()) {
+    if (installedPath.endsWith(".yml") || installedPath.endsWith(".yaml")) {
+      await writeLLMPreferences(installedPath, preferences, overrides);
+      logger.info(`\u2713 Applied preferences to: ${path.basename(installedPath)}`, null, "green");
+    } else {
+      logger.warn(`Skipping non-YAML file: ${installedPath}`, null, "yellow");
+    }
+  } else if (stat.isDirectory()) {
+    await writePreferencesToDirectory(installedPath, preferences, overrides);
+  } else {
+    throw ConfigError.fileReadError(installedPath, "Path is neither a file nor directory");
+  }
+}
+async function writePreferencesToDirectory(installedDir, preferences, overrides) {
+  const configFiles = await findAgentConfigFiles(installedDir);
+  if (configFiles.length === 0) {
+    logger.warn(`No YAML config files found in: ${installedDir}`);
+    return;
+  }
+  let successCount = 0;
+  const oldProvider = preferences.llm.provider;
+  const oldModel = preferences.llm.model;
+  const newProvider = overrides?.provider ?? preferences.llm.provider;
+  const newModel = overrides?.model ?? preferences.llm.model;
+  for (const configPath of configFiles) {
+    try {
+      await writeLLMPreferences(configPath, preferences, overrides);
+      logger.debug(`Applied preferences to: ${path.relative(installedDir, configPath)}`);
+      successCount++;
+    } catch (error) {
+      logger.warn(
+        `Failed to write preferences to ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  logger.info(
+    `\u2713 Applied preferences to ${successCount}/${configFiles.length} config files (${oldProvider}\u2192${newProvider}, ${oldModel}\u2192${newModel})`
+  );
+}
+async function findAgentConfigFiles(dir) {
+  const configFiles = [];
+  async function walkDir(currentDir) {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!["docs", "data"].includes(entry.name)) {
+          await walkDir(fullPath);
+        }
+      } else if (entry.name.endsWith(".yml") || entry.name.endsWith(".yaml")) {
+        configFiles.push(fullPath);
+      }
+    }
+  }
+  await walkDir(dir);
+  return configFiles;
+}
+export {
+  writeConfigFile,
+  writeLLMPreferences,
+  writePreferencesToAgent
+};

package/dist/context/compression/middle-removal.cjs

@@ -0,0 +1,95 @@
+"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 middle_removal_exports = {};
+__export(middle_removal_exports, {
+  MiddleRemovalStrategy: () => MiddleRemovalStrategy
+});
+module.exports = __toCommonJS(middle_removal_exports);
+var import_utils = require("../utils.cjs");
+var import_errors = require("../errors.js");
+class MiddleRemovalStrategy {
+  preserveStart;
+  preserveEnd;
+  /**
+   * Creates an instance of MiddleRemovalStrategy.
+   *
+   * @param options Configuration options for preserving messages.
+   */
+  constructor(options = {}) {
+    this.preserveStart = options.preserveStart ?? 4;
+    this.preserveEnd = options.preserveEnd ?? 5;
+    if (this.preserveStart < 0 || this.preserveEnd < 0) {
+      throw import_errors.ContextError.preserveValuesNegative();
+    }
+  }
+  /**
+   * Compresses the history by removing messages from the middle if the total
+   * token count exceeds the specified maximum.
+   *
+   * @param history The current conversation history.
+   * @param tokenizer The tokenizer used to calculate message tokens.
+   * @param maxHistoryTokens The maximum number of tokens allowed *for the history messages*.
+   * @returns The potentially compressed message history.
+   */
+  compress(history, tokenizer, maxHistoryTokens) {
+    const initialTokenCount = (0, import_utils.countMessagesTokens)(history, tokenizer);
+    if (initialTokenCount <= maxHistoryTokens) {
+      return history;
+    }
+    const removableIndices = [];
+    const totalMessages = history.length;
+    if (totalMessages > this.preserveStart + this.preserveEnd) {
+      for (let i = this.preserveStart; i < totalMessages - this.preserveEnd; i++) {
+        removableIndices.push(i);
+      }
+    } else {
+      console.warn(
+        "MiddleRemovalStrategy: Not enough messages to apply middle removal based on preserve counts. History length:",
+        totalMessages,
+        "PreserveStart:",
+        this.preserveStart,
+        "PreserveEnd:",
+        this.preserveEnd
+      );
+      return history;
+    }
+    let currentHistory = [...history];
+    let currentTokenCount = initialTokenCount;
+    const removedIndices = /* @__PURE__ */ new Set();
+    while (currentTokenCount > maxHistoryTokens && removableIndices.length > 0) {
+      const indexToRemove = removableIndices.shift();
+      removedIndices.add(indexToRemove);
+      currentTokenCount = (0, import_utils.countMessagesTokens)(
+        currentHistory.filter((_, i) => !removedIndices.has(i)),
+        // Calculate tokens based on remaining messages
+        tokenizer
+      );
+    }
+    if (currentTokenCount > maxHistoryTokens) {
+      console.warn(
+        `MiddleRemovalStrategy: Unable to compress below max tokens (${maxHistoryTokens}). Final token count: ${currentTokenCount}`
+      );
+    }
+    return history.filter((_, i) => !removedIndices.has(i));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MiddleRemovalStrategy
+});

package/dist/context/compression/middle-removal.d.cts

@@ -0,0 +1,48 @@
+import { ITokenizer } from '../../llm/tokenizer/types.cjs';
+import { InternalMessage } from '../types.cjs';
+import { ICompressionStrategy } from './types.cjs';
+import '../../llm/types.cjs';
+
+/**
+ * Configuration options for the MiddleRemovalStrategy.
+ */
+interface MiddleRemovalStrategyOptions {
+    /**
+     * The number of messages to preserve at the beginning of the history.
+     * @default 4
+     */
+    preserveStart?: number;
+    /**
+     * The number of messages to preserve at the end of the history.
+     * @default 5
+     */
+    preserveEnd?: number;
+}
+/**
+ * Implements a compression strategy that removes messages from the middle of the
+ * conversation history, preserving a configurable number of messages at the
+ * beginning and end. It prioritizes removing the oldest messages within the
+ * removable middle section first.
+ */
+declare class MiddleRemovalStrategy implements ICompressionStrategy {
+    private readonly preserveStart;
+    private readonly preserveEnd;
+    /**
+     * Creates an instance of MiddleRemovalStrategy.
+     *
+     * @param options Configuration options for preserving messages.
+     */
+    constructor(options?: MiddleRemovalStrategyOptions);
+    /**
+     * Compresses the history by removing messages from the middle if the total
+     * token count exceeds the specified maximum.
+     *
+     * @param history The current conversation history.
+     * @param tokenizer The tokenizer used to calculate message tokens.
+     * @param maxHistoryTokens The maximum number of tokens allowed *for the history messages*.
+     * @returns The potentially compressed message history.
+     */
+    compress(history: InternalMessage[], tokenizer: ITokenizer, maxHistoryTokens: number): InternalMessage[];
+}
+
+export { MiddleRemovalStrategy, type MiddleRemovalStrategyOptions };

package/dist/context/compression/middle-removal.d.ts

@@ -0,0 +1,48 @@
+import { ITokenizer } from '../../llm/tokenizer/types.js';
+import { InternalMessage } from '../types.js';
+import { ICompressionStrategy } from './types.js';
+import '../../llm/types.js';
+
+/**
+ * Configuration options for the MiddleRemovalStrategy.
+ */
+interface MiddleRemovalStrategyOptions {
+    /**
+     * The number of messages to preserve at the beginning of the history.
+     * @default 4
+     */
+    preserveStart?: number;
+    /**
+     * The number of messages to preserve at the end of the history.
+     * @default 5
+     */
+    preserveEnd?: number;
+}
+/**
+ * Implements a compression strategy that removes messages from the middle of the
+ * conversation history, preserving a configurable number of messages at the
+ * beginning and end. It prioritizes removing the oldest messages within the
+ * removable middle section first.
+ */
+declare class MiddleRemovalStrategy implements ICompressionStrategy {
+    private readonly preserveStart;
+    private readonly preserveEnd;
+    /**
+     * Creates an instance of MiddleRemovalStrategy.
+     *
+     * @param options Configuration options for preserving messages.
+     */
+    constructor(options?: MiddleRemovalStrategyOptions);
+    /**
+     * Compresses the history by removing messages from the middle if the total
+     * token count exceeds the specified maximum.
+     *
+     * @param history The current conversation history.
+     * @param tokenizer The tokenizer used to calculate message tokens.
+     * @param maxHistoryTokens The maximum number of tokens allowed *for the history messages*.
+     * @returns The potentially compressed message history.
+     */
+    compress(history: InternalMessage[], tokenizer: ITokenizer, maxHistoryTokens: number): InternalMessage[];
+}
+
+export { MiddleRemovalStrategy, type MiddleRemovalStrategyOptions };

package/dist/context/compression/middle-removal.js

@@ -0,0 +1,71 @@
+import { countMessagesTokens } from "../utils.js";
+import { ContextError } from "../errors.js";
+class MiddleRemovalStrategy {
+  preserveStart;
+  preserveEnd;
+  /**
+   * Creates an instance of MiddleRemovalStrategy.
+   *
+   * @param options Configuration options for preserving messages.
+   */
+  constructor(options = {}) {
+    this.preserveStart = options.preserveStart ?? 4;
+    this.preserveEnd = options.preserveEnd ?? 5;
+    if (this.preserveStart < 0 || this.preserveEnd < 0) {
+      throw ContextError.preserveValuesNegative();
+    }
+  }
+  /**
+   * Compresses the history by removing messages from the middle if the total
+   * token count exceeds the specified maximum.
+   *
+   * @param history The current conversation history.
+   * @param tokenizer The tokenizer used to calculate message tokens.
+   * @param maxHistoryTokens The maximum number of tokens allowed *for the history messages*.
+   * @returns The potentially compressed message history.
+   */
+  compress(history, tokenizer, maxHistoryTokens) {
+    const initialTokenCount = countMessagesTokens(history, tokenizer);
+    if (initialTokenCount <= maxHistoryTokens) {
+      return history;
+    }
+    const removableIndices = [];
+    const totalMessages = history.length;
+    if (totalMessages > this.preserveStart + this.preserveEnd) {
+      for (let i = this.preserveStart; i < totalMessages - this.preserveEnd; i++) {
+        removableIndices.push(i);
+      }
+    } else {
+      console.warn(
+        "MiddleRemovalStrategy: Not enough messages to apply middle removal based on preserve counts. History length:",
+        totalMessages,
+        "PreserveStart:",
+        this.preserveStart,
+        "PreserveEnd:",
+        this.preserveEnd
+      );
+      return history;
+    }
+    let currentHistory = [...history];
+    let currentTokenCount = initialTokenCount;
+    const removedIndices = /* @__PURE__ */ new Set();
+    while (currentTokenCount > maxHistoryTokens && removableIndices.length > 0) {
+      const indexToRemove = removableIndices.shift();
+      removedIndices.add(indexToRemove);
+      currentTokenCount = countMessagesTokens(
+        currentHistory.filter((_, i) => !removedIndices.has(i)),
+        // Calculate tokens based on remaining messages
+        tokenizer
+      );
+    }
+    if (currentTokenCount > maxHistoryTokens) {
+      console.warn(
+        `MiddleRemovalStrategy: Unable to compress below max tokens (${maxHistoryTokens}). Final token count: ${currentTokenCount}`
+      );
+    }
+    return history.filter((_, i) => !removedIndices.has(i));
+  }
+}
+export {
+  MiddleRemovalStrategy
+};

package/dist/context/compression/oldest-removal.cjs

@@ -0,0 +1,70 @@
+"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 oldest_removal_exports = {};
+__export(oldest_removal_exports, {
+  OldestRemovalStrategy: () => OldestRemovalStrategy
+});
+module.exports = __toCommonJS(oldest_removal_exports);
+var import_utils = require("../utils.js");
+var import_errors = require("../errors.js");
+class OldestRemovalStrategy {
+  minMessagesToKeep;
+  /**
+   * Creates an instance of OldestRemovalStrategy.
+   *
+   * @param options Configuration options for preserving messages.
+   */
+  constructor(options = {}) {
+    this.minMessagesToKeep = options.minMessagesToKeep ?? 4;
+    if (this.minMessagesToKeep < 0) {
+      throw import_errors.ContextError.minMessagesNegative();
+    }
+  }
+  /**
+   * Compresses the history by removing the oldest messages if the total
+   * token count exceeds the specified maximum, while respecting minMessagesToKeep.
+   *
+   * @param history The current conversation history.
+   * @param tokenizer The tokenizer used to calculate message tokens.
+   * @param maxHistoryTokens The maximum number of tokens allowed *for the history messages*.
+   * @returns The potentially compressed message history.
+   */
+  compress(history, tokenizer, maxHistoryTokens) {
+    let currentHistory = [...history];
+    let currentTokenCount = (0, import_utils.countMessagesTokens)(currentHistory, tokenizer);
+    while (currentHistory.length > this.minMessagesToKeep && currentTokenCount > maxHistoryTokens) {
+      currentHistory.shift();
+      currentTokenCount = (0, import_utils.countMessagesTokens)(currentHistory, tokenizer);
+    }
+    if (currentTokenCount > maxHistoryTokens && currentHistory.length <= this.minMessagesToKeep) {
+      console.warn(
+        `OldestRemovalStrategy: Could not compress below max tokens (${maxHistoryTokens}) without violating minMessagesToKeep (${this.minMessagesToKeep}). Final token count: ${currentTokenCount}, Messages: ${currentHistory.length}`
+      );
+    } else if (currentTokenCount > maxHistoryTokens) {
+      console.warn(
+        `OldestRemovalStrategy: Unable to compress below max tokens (${maxHistoryTokens}). Final token count: ${currentTokenCount}`
+      );
+    }
+    return currentHistory;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OldestRemovalStrategy
+});

package/dist/context/compression/oldest-removal.d.cts

@@ -0,0 +1,43 @@
+import { ITokenizer } from '../../llm/tokenizer/types.cjs';
+import { InternalMessage } from '../types.cjs';
+import { ICompressionStrategy } from './types.cjs';
+import '../../llm/types.cjs';
+
+/**
+ * Configuration options for the OldestRemovalStrategy.
+ */
+interface OldestRemovalStrategyOptions {
+    /**
+     * The minimum number of messages to preserve at the end of the history.
+     * The strategy will not remove messages if doing so would reduce the
+     * history length below this number.
+     * @default 4
+     */
+    minMessagesToKeep?: number;
+}
+/**
+ * Implements a compression strategy that removes the oldest messages (from the
+ * beginning of the history array) until the token count is within the limit.
+ * Ensures a minimum number of recent messages are always preserved.
+ */
+declare class OldestRemovalStrategy implements ICompressionStrategy {
+    private readonly minMessagesToKeep;
+    /**
+     * Creates an instance of OldestRemovalStrategy.
+     *
+     * @param options Configuration options for preserving messages.
+     */
+    constructor(options?: OldestRemovalStrategyOptions);
+    /**
+     * Compresses the history by removing the oldest messages if the total
+     * token count exceeds the specified maximum, while respecting minMessagesToKeep.
+     *
+     * @param history The current conversation history.
+     * @param tokenizer The tokenizer used to calculate message tokens.
+     * @param maxHistoryTokens The maximum number of tokens allowed *for the history messages*.
+     * @returns The potentially compressed message history.
+     */
+    compress(history: InternalMessage[], tokenizer: ITokenizer, maxHistoryTokens: number): InternalMessage[];
+}
+
+export { OldestRemovalStrategy, type OldestRemovalStrategyOptions };

package/dist/context/compression/oldest-removal.d.ts

@@ -0,0 +1,43 @@
+import { ITokenizer } from '../../llm/tokenizer/types.js';
+import { InternalMessage } from '../types.js';
+import { ICompressionStrategy } from './types.js';
+import '../../llm/types.js';
+
+/**
+ * Configuration options for the OldestRemovalStrategy.
+ */
+interface OldestRemovalStrategyOptions {
+    /**
+     * The minimum number of messages to preserve at the end of the history.
+     * The strategy will not remove messages if doing so would reduce the
+     * history length below this number.
+     * @default 4
+     */
+    minMessagesToKeep?: number;
+}
+/**
+ * Implements a compression strategy that removes the oldest messages (from the
+ * beginning of the history array) until the token count is within the limit.
+ * Ensures a minimum number of recent messages are always preserved.
+ */
+declare class OldestRemovalStrategy implements ICompressionStrategy {
+    private readonly minMessagesToKeep;
+    /**
+     * Creates an instance of OldestRemovalStrategy.
+     *
+     * @param options Configuration options for preserving messages.
+     */
+    constructor(options?: OldestRemovalStrategyOptions);
+    /**
+     * Compresses the history by removing the oldest messages if the total
+     * token count exceeds the specified maximum, while respecting minMessagesToKeep.
+     *
+     * @param history The current conversation history.
+     * @param tokenizer The tokenizer used to calculate message tokens.
+     * @param maxHistoryTokens The maximum number of tokens allowed *for the history messages*.
+     * @returns The potentially compressed message history.
+     */
+    compress(history: InternalMessage[], tokenizer: ITokenizer, maxHistoryTokens: number): InternalMessage[];
+}
+
+export { OldestRemovalStrategy, type OldestRemovalStrategyOptions };

package/dist/context/compression/oldest-removal.js

@@ -0,0 +1,46 @@
+import { countMessagesTokens } from "../utils.js";
+import { ContextError } from "../errors.js";
+class OldestRemovalStrategy {
+  minMessagesToKeep;
+  /**
+   * Creates an instance of OldestRemovalStrategy.
+   *
+   * @param options Configuration options for preserving messages.
+   */
+  constructor(options = {}) {
+    this.minMessagesToKeep = options.minMessagesToKeep ?? 4;
+    if (this.minMessagesToKeep < 0) {
+      throw ContextError.minMessagesNegative();
+    }
+  }
+  /**
+   * Compresses the history by removing the oldest messages if the total
+   * token count exceeds the specified maximum, while respecting minMessagesToKeep.
+   *
+   * @param history The current conversation history.
+   * @param tokenizer The tokenizer used to calculate message tokens.
+   * @param maxHistoryTokens The maximum number of tokens allowed *for the history messages*.
+   * @returns The potentially compressed message history.
+   */
+  compress(history, tokenizer, maxHistoryTokens) {
+    let currentHistory = [...history];
+    let currentTokenCount = countMessagesTokens(currentHistory, tokenizer);
+    while (currentHistory.length > this.minMessagesToKeep && currentTokenCount > maxHistoryTokens) {
+      currentHistory.shift();
+      currentTokenCount = countMessagesTokens(currentHistory, tokenizer);
+    }
+    if (currentTokenCount > maxHistoryTokens && currentHistory.length <= this.minMessagesToKeep) {
+      console.warn(
+        `OldestRemovalStrategy: Could not compress below max tokens (${maxHistoryTokens}) without violating minMessagesToKeep (${this.minMessagesToKeep}). Final token count: ${currentTokenCount}, Messages: ${currentHistory.length}`
+      );
+    } else if (currentTokenCount > maxHistoryTokens) {
+      console.warn(
+        `OldestRemovalStrategy: Unable to compress below max tokens (${maxHistoryTokens}). Final token count: ${currentTokenCount}`
+      );
+    }
+    return currentHistory;
+  }
+}
+export {
+  OldestRemovalStrategy
+};

package/dist/context/compression/types.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -0,0 +1,21 @@
+import { InternalMessage } from '../types.cjs';
+import { ITokenizer } from '../../llm/tokenizer/types.cjs';
+import '../../llm/types.cjs';
+
+/**
+ * Defines the contract for a strategy used to compress a conversation history
+ * to fit within a maximum token limit.
+ */
+interface ICompressionStrategy {
+    /**
+     * 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.
+     */
+    compress(history: InternalMessage[], tokenizer: ITokenizer, maxInputTokens: number): InternalMessage[];
+}
+
+export type { ICompressionStrategy };

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

@@ -0,0 +1,21 @@
+import { InternalMessage } from '../types.js';
+import { ITokenizer } from '../../llm/tokenizer/types.js';
+import '../../llm/types.js';
+
+/**
+ * Defines the contract for a strategy used to compress a conversation history
+ * to fit within a maximum token limit.
+ */
+interface ICompressionStrategy {
+    /**
+     * 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.
+     */
+    compress(history: InternalMessage[], tokenizer: ITokenizer, maxInputTokens: number): InternalMessage[];
+}
+
+export type { ICompressionStrategy };