@dexto/core 1.3.0 → 1.5.0

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

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { LanguageModel } from 'ai';
+import type { ICompactionStrategy } from './types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
+/**
+ * Context provided to compaction strategy creation
+ */
+export interface CompactionContext {
+    logger: IDextoLogger;
+    model?: LanguageModel;
+}
+/**
+ * Provider interface for compaction strategies.
+ *
+ * Follows the same pattern as blob storage and tools providers:
+ * - Type discriminator for config validation
+ * - Zod schema for runtime validation
+ * - Factory function to create instances
+ * - Metadata for discovery and UI
+ *
+ * TConfig should be the output type (z.output) with defaults applied
+ */
+export interface CompactionProvider<TType extends string = string, TConfig extends CompactionConfig = CompactionConfig> {
+    /** Unique identifier for this strategy type */
+    type: TType;
+    /** Zod schema for validating configuration - accepts input, produces TConfig output */
+    configSchema: z.ZodType<TConfig, z.ZodTypeDef, any>;
+    /** Metadata for discovery and UI */
+    metadata?: {
+        displayName: string;
+        description: string;
+        requiresLLM: boolean;
+        isProactive: boolean;
+    };
+    /**
+     * Create a compaction strategy instance
+     * @param config - Validated configuration with defaults applied (output type)
+     */
+    create(config: TConfig, context: CompactionContext): ICompactionStrategy | Promise<ICompactionStrategy>;
+}
+/**
+ * Base configuration for all compaction strategies
+ */
+export interface CompactionConfig {
+    type: string;
+    enabled?: boolean;
+}
+//# sourceMappingURL=provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AACxC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,CAAC,EAAE,aAAa,CAAC;CACzB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB,CAC/B,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,OAAO,SAAS,gBAAgB,GAAG,gBAAgB;IAEnD,+CAA+C;IAC/C,IAAI,EAAE,KAAK,CAAC;IAEZ,uFAAuF;IACvF,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;IAEpD,oCAAoC;IACpC,QAAQ,CAAC,EAAE;QACP,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,OAAO,CAAC;QACrB,WAAW,EAAE,OAAO,CAAC;KACxB,CAAC;IAEF;;;OAGG;IACH,MAAM,CACF,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,iBAAiB,GAC3B,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;CACzD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB"}

package/dist/context/compaction/providers/noop-provider.cjs

@@ -0,0 +1,48 @@
+"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 noop_provider_exports = {};
+__export(noop_provider_exports, {
+  NoOpConfigSchema: () => NoOpConfigSchema,
+  noopProvider: () => noopProvider
+});
+module.exports = __toCommonJS(noop_provider_exports);
+var import_zod = require("zod");
+var import_noop = require("../strategies/noop.js");
+const NoOpConfigSchema = import_zod.z.object({
+  type: import_zod.z.literal("noop"),
+  enabled: import_zod.z.boolean().default(true).describe("Enable or disable compaction")
+}).strict();
+const noopProvider = {
+  type: "noop",
+  configSchema: NoOpConfigSchema,
+  metadata: {
+    displayName: "No Compaction",
+    description: "Disables compaction entirely, keeping full conversation history",
+    requiresLLM: false,
+    isProactive: false
+  },
+  create(_config, _context) {
+    return new import_noop.NoOpCompactionStrategy();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NoOpConfigSchema,
+  noopProvider
+});

package/dist/context/compaction/providers/noop-provider.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import type { CompactionProvider } from '../provider.js';
+/**
+ * Configuration schema for no-op compaction
+ */
+export declare const NoOpConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"noop">;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    type: "noop";
+    enabled: boolean;
+}, {
+    type: "noop";
+    enabled?: boolean | undefined;
+}>;
+export type NoOpConfig = z.output<typeof NoOpConfigSchema>;
+/**
+ * Provider for no-op compaction strategy.
+ *
+ * This strategy disables compaction entirely, keeping full conversation history.
+ * Useful for testing, debugging, or contexts where full history is required.
+ */
+export declare const noopProvider: CompactionProvider<'noop', NoOpConfig>;
+//# sourceMappingURL=noop-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"noop-provider.d.ts","sourceRoot":"","sources":["../../../../src/context/compaction/providers/noop-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,gBAAgB;;;;;;;;;EAKhB,CAAC;AAEd,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,kBAAkB,CAAC,MAAM,EAAE,UAAU,CAa/D,CAAC"}

package/dist/context/compaction/providers/noop-provider.js

@@ -0,0 +1,24 @@
+import "../../../chunk-PTJYTZNU.js";
+import { z } from "zod";
+import { NoOpCompactionStrategy } from "../strategies/noop.js";
+const NoOpConfigSchema = z.object({
+  type: z.literal("noop"),
+  enabled: z.boolean().default(true).describe("Enable or disable compaction")
+}).strict();
+const noopProvider = {
+  type: "noop",
+  configSchema: NoOpConfigSchema,
+  metadata: {
+    displayName: "No Compaction",
+    description: "Disables compaction entirely, keeping full conversation history",
+    requiresLLM: false,
+    isProactive: false
+  },
+  create(_config, _context) {
+    return new NoOpCompactionStrategy();
+  }
+};
+export {
+  NoOpConfigSchema,
+  noopProvider
+};

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

@@ -0,0 +1,61 @@
+"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_provider_exports = {};
+__export(reactive_overflow_provider_exports, {
+  ReactiveOverflowConfigSchema: () => ReactiveOverflowConfigSchema,
+  reactiveOverflowProvider: () => reactiveOverflowProvider
+});
+module.exports = __toCommonJS(reactive_overflow_provider_exports);
+var import_zod = require("zod");
+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"),
+  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")
+}).strict();
+const reactiveOverflowProvider = {
+  type: "reactive-overflow",
+  configSchema: ReactiveOverflowConfigSchema,
+  metadata: {
+    displayName: "Reactive Overflow Compaction",
+    description: "Generates summaries when context window overflows, preserving recent turns",
+    requiresLLM: true,
+    isProactive: false
+  },
+  create(config, context) {
+    if (!context.model) {
+      throw new Error("ReactiveOverflowStrategy requires LanguageModel");
+    }
+    const options = {
+      preserveLastNTurns: config.preserveLastNTurns,
+      maxSummaryTokens: config.maxSummaryTokens
+    };
+    if (config.summaryPrompt !== void 0) {
+      options.summaryPrompt = config.summaryPrompt;
+    }
+    return new import_reactive_overflow.ReactiveOverflowStrategy(context.model, options, context.logger);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReactiveOverflowConfigSchema,
+  reactiveOverflowProvider
+});

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

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import type { CompactionProvider } from '../provider.js';
+/**
+ * Configuration schema for reactive overflow compaction
+ */
+export declare const ReactiveOverflowConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"reactive-overflow">;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    preserveLastNTurns: z.ZodDefault<z.ZodNumber>;
+    maxSummaryTokens: z.ZodDefault<z.ZodNumber>;
+    summaryPrompt: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "reactive-overflow";
+    enabled: boolean;
+    preserveLastNTurns: number;
+    maxSummaryTokens: number;
+    summaryPrompt?: string | undefined;
+}, {
+    type: "reactive-overflow";
+    enabled?: boolean | undefined;
+    preserveLastNTurns?: number | undefined;
+    maxSummaryTokens?: number | undefined;
+    summaryPrompt?: string | undefined;
+}>;
+export type ReactiveOverflowConfig = z.output<typeof ReactiveOverflowConfigSchema>;
+/**
+ * Provider for reactive overflow compaction strategy.
+ *
+ * This strategy triggers compaction when context window overflow is detected:
+ * - Generates LLM-powered summaries of older messages
+ * - Preserves recent turns for context continuity
+ * - Falls back to simple text summary if LLM call fails
+ * - Adds summary message to history (read-time filtering excludes old messages)
+ */
+export declare const reactiveOverflowProvider: CompactionProvider<'reactive-overflow', ReactiveOverflowConfig>;
+//# sourceMappingURL=reactive-overflow-provider.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,37 @@
+import "../../../chunk-PTJYTZNU.js";
+import { z } from "zod";
+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"),
+  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")
+}).strict();
+const reactiveOverflowProvider = {
+  type: "reactive-overflow",
+  configSchema: ReactiveOverflowConfigSchema,
+  metadata: {
+    displayName: "Reactive Overflow Compaction",
+    description: "Generates summaries when context window overflows, preserving recent turns",
+    requiresLLM: true,
+    isProactive: false
+  },
+  create(config, context) {
+    if (!context.model) {
+      throw new Error("ReactiveOverflowStrategy requires LanguageModel");
+    }
+    const options = {
+      preserveLastNTurns: config.preserveLastNTurns,
+      maxSummaryTokens: config.maxSummaryTokens
+    };
+    if (config.summaryPrompt !== void 0) {
+      options.summaryPrompt = config.summaryPrompt;
+    }
+    return new ReactiveOverflowStrategy(context.model, options, context.logger);
+  }
+};
+export {
+  ReactiveOverflowConfigSchema,
+  reactiveOverflowProvider
+};

package/dist/{llm/tokenizer/factory.cjs → context/compaction/registry.cjs}

@@ -16,29 +16,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var factory_exports = {};
-__export(factory_exports, {
-  createTokenizer: () => createTokenizer
+var registry_exports = {};
+__export(registry_exports, {
+  compactionRegistry: () => compactionRegistry
 });
-module.exports = __toCommonJS(factory_exports);
-var import_openai = require("./openai.js");
-var import_anthropic = require("./anthropic.js");
-var import_google = require("./google.js");
-var import_default = require("./default.js");
-function createTokenizer(provider, model, logger) {
-  switch (provider) {
-    case "openai":
-      return new import_openai.OpenAITokenizer(model, logger);
-    case "anthropic":
-      return new import_anthropic.AnthropicTokenizer();
-    case "google":
-      return new import_google.GoogleTokenizer(model);
-    // Add cases for other providers here
-    default:
-      return new import_default.DefaultTokenizer();
+module.exports = __toCommonJS(registry_exports);
+var import_errors = require("../errors.js");
+var import_base_registry = require("../../providers/base-registry.js");
+const compactionErrorFactory = {
+  alreadyRegistered: (type) => import_errors.ContextError.compactionProviderAlreadyRegistered(type),
+  notFound: (type, availableTypes) => import_errors.ContextError.compactionInvalidType(type, availableTypes)
+};
+class CompactionRegistry extends import_base_registry.BaseRegistry {
+  constructor() {
+    super(compactionErrorFactory);
   }
 }
+const compactionRegistry = new CompactionRegistry();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createTokenizer
+  compactionRegistry
 });

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

@@ -0,0 +1,19 @@
+import type { CompactionProvider } from './provider.js';
+import { BaseRegistry } from '../../providers/base-registry.js';
+/**
+ * Global registry for compaction providers.
+ *
+ * Follows the same pattern as blob storage and tools registries:
+ * - Singleton instance exported
+ * - Registration before agent initialization
+ * - Type-safe provider lookup
+ *
+ * Extends BaseRegistry for common registry functionality.
+ */
+declare class CompactionRegistry extends BaseRegistry<CompactionProvider<any, any>> {
+    constructor();
+}
+/** Global singleton instance */
+export declare const compactionRegistry: CompactionRegistry;
+export {};
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,EAAE,YAAY,EAA6B,MAAM,kCAAkC,CAAC;AAY3F;;;;;;;;;GASG;AACH,cAAM,kBAAmB,SAAQ,YAAY,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;;CAI1E;AAED,gCAAgC;AAChC,eAAO,MAAM,kBAAkB,oBAA2B,CAAC"}

package/dist/context/compaction/registry.js

@@ -0,0 +1,16 @@
+import "../../chunk-PTJYTZNU.js";
+import { ContextError } from "../errors.js";
+import { BaseRegistry } from "../../providers/base-registry.js";
+const compactionErrorFactory = {
+  alreadyRegistered: (type) => ContextError.compactionProviderAlreadyRegistered(type),
+  notFound: (type, availableTypes) => ContextError.compactionInvalidType(type, availableTypes)
+};
+class CompactionRegistry extends BaseRegistry {
+  constructor() {
+    super(compactionErrorFactory);
+  }
+}
+const compactionRegistry = new CompactionRegistry();
+export {
+  compactionRegistry
+};

package/dist/context/compaction/schemas.cjs

@@ -0,0 +1,38 @@
+"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 schemas_exports = {};
+__export(schemas_exports, {
+  CompactionConfigSchema: () => CompactionConfigSchema,
+  DEFAULT_COMPACTION_CONFIG: () => DEFAULT_COMPACTION_CONFIG
+});
+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")
+}).passthrough().describe("Context compaction configuration");
+const DEFAULT_COMPACTION_CONFIG = {
+  type: "reactive-overflow",
+  enabled: true
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CompactionConfigSchema,
+  DEFAULT_COMPACTION_CONFIG
+});

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+/**
+ * Base compaction configuration schema.
+ * Uses discriminated union to support different provider types.
+ *
+ * Each provider registers its own schema with specific validation rules.
+ * This schema accepts any configuration with a 'type' field.
+ */
+export declare const CompactionConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">>;
+export type CompactionConfigInput = z.output<typeof CompactionConfigSchema>;
+/**
+ * Default compaction configuration - uses reactive-overflow strategy
+ */
+export declare const DEFAULT_COMPACTION_CONFIG: CompactionConfigInput;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +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"}

package/dist/context/compaction/schemas.js

@@ -0,0 +1,14 @@
+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")
+}).passthrough().describe("Context compaction configuration");
+const DEFAULT_COMPACTION_CONFIG = {
+  type: "reactive-overflow",
+  enabled: true
+};
+export {
+  CompactionConfigSchema,
+  DEFAULT_COMPACTION_CONFIG
+};

package/dist/{llm/tokenizer/types.cjs → context/compaction/strategies/noop.cjs}

@@ -16,18 +16,21 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var types_exports = {};
-__export(types_exports, {
-  TokenizationError: () => TokenizationError
+var noop_exports = {};
+__export(noop_exports, {
+  NoOpCompactionStrategy: () => NoOpCompactionStrategy
 });
-module.exports = __toCommonJS(types_exports);
-class TokenizationError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "TokenizationError";
+module.exports = __toCommonJS(noop_exports);
+class NoOpCompactionStrategy {
+  name = "noop";
+  /**
+   * Does nothing - returns empty array (no summary needed)
+   */
+  async compact(_history) {
+    return [];
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  TokenizationError
+  NoOpCompactionStrategy
 });

package/dist/context/compaction/strategies/noop.d.ts

@@ -0,0 +1,18 @@
+import type { ICompactionStrategy } from '../types.js';
+import type { InternalMessage } from '../../types.js';
+/**
+ * No-op compaction strategy that doesn't perform any compaction.
+ *
+ * Useful for:
+ * - Testing without compaction overhead
+ * - Disabling compaction temporarily
+ * - Contexts where full history is required
+ */
+export declare class NoOpCompactionStrategy implements ICompactionStrategy {
+    readonly name = "noop";
+    /**
+     * Does nothing - returns empty array (no summary needed)
+     */
+    compact(_history: readonly InternalMessage[]): Promise<InternalMessage[]>;
+}
+//# sourceMappingURL=noop.d.ts.map

package/dist/context/compaction/strategies/noop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop.d.ts","sourceRoot":"","sources":["../../../../src/context/compaction/strategies/noop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtD;;;;;;;GAOG;AACH,qBAAa,sBAAuB,YAAW,mBAAmB;IAC9D,QAAQ,CAAC,IAAI,UAAU;IAEvB;;OAEG;IACG,OAAO,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;CAGlF"}

package/dist/context/compaction/strategies/noop.js

@@ -0,0 +1,13 @@
+import "../../../chunk-PTJYTZNU.js";
+class NoOpCompactionStrategy {
+  name = "noop";
+  /**
+   * Does nothing - returns empty array (no summary needed)
+   */
+  async compact(_history) {
+    return [];
+  }
+}
+export {
+  NoOpCompactionStrategy
+};