@dexto/core 1.3.0 → 1.5.0

package/dist/approval/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/approval/schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/approval/schemas.ts"],"names":[],"mappings":"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"}

package/dist/approval/schemas.js

@@ -1,14 +1,25 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 import { z } from "zod";
 import { ApprovalType, ApprovalStatus, DenialReason } from "./types.js";
+import { isValidDisplayData } from "../tools/display-types.js";
 const JsonSchema7Schema = z.record(z.unknown());
 const ApprovalTypeSchema = z.nativeEnum(ApprovalType);
 const ApprovalStatusSchema = z.nativeEnum(ApprovalStatus);
 const DenialReasonSchema = z.nativeEnum(DenialReason);
+const ToolDisplayDataSchema = z.custom((val) => isValidDisplayData(val), {
+  message: "Invalid ToolDisplayData"
+});
 const ToolConfirmationMetadataSchema = z.object({
   toolName: z.string().describe("Name of the tool to confirm"),
+  toolCallId: z.string().describe("Unique tool call ID for tracking parallel tool calls"),
   args: z.record(z.unknown()).describe("Arguments for the tool"),
-  description: z.string().optional().describe("Description of the tool")
+  description: z.string().optional().describe("Description of the tool"),
+  displayPreview: ToolDisplayDataSchema.optional().describe(
+    "Preview display data for approval UI (e.g., diff preview)"
+  ),
+  suggestedPatterns: z.array(z.string()).optional().describe(
+    'Suggested patterns for session approval (for bash commands). E.g., ["git push *", "git *"] for command "git push origin main"'
+  )
 }).strict().describe("Tool confirmation metadata");
 const CommandConfirmationMetadataSchema = z.object({
   toolName: z.string().describe("Name of the tool executing the command"),
@@ -22,11 +33,17 @@ const ElicitationMetadataSchema = z.object({
   context: z.record(z.unknown()).optional().describe("Additional context")
 }).strict().describe("Elicitation metadata");
 const CustomApprovalMetadataSchema = z.record(z.unknown()).describe("Custom metadata");
+const DirectoryAccessMetadataSchema = z.object({
+  path: z.string().describe("Full path being accessed"),
+  parentDir: z.string().describe("Parent directory (what gets approved for session)"),
+  operation: z.enum(["read", "write", "edit"]).describe("Type of file operation"),
+  toolName: z.string().describe("Name of the tool requesting access")
+}).strict().describe("Directory access metadata");
 const BaseApprovalRequestSchema = z.object({
   approvalId: z.string().uuid().describe("Unique approval identifier"),
   type: ApprovalTypeSchema.describe("Type of approval"),
   sessionId: z.string().optional().describe("Session identifier"),
-  timeout: z.number().int().positive().describe("Timeout in milliseconds"),
+  timeout: z.number().int().positive().optional().describe("Timeout in milliseconds (optional - no timeout if not specified)"),
   timestamp: z.date().describe("When the request was created")
 }).describe("Base approval request");
 const ToolConfirmationRequestSchema = BaseApprovalRequestSchema.extend({
@@ -45,14 +62,22 @@ const CustomApprovalRequestSchema = BaseApprovalRequestSchema.extend({
   type: z.literal(ApprovalType.CUSTOM),
   metadata: CustomApprovalMetadataSchema
 }).strict();
+const DirectoryAccessRequestSchema = BaseApprovalRequestSchema.extend({
+  type: z.literal(ApprovalType.DIRECTORY_ACCESS),
+  metadata: DirectoryAccessMetadataSchema
+}).strict();
 const ApprovalRequestSchema = z.discriminatedUnion("type", [
   ToolConfirmationRequestSchema,
   CommandConfirmationRequestSchema,
   ElicitationRequestSchema,
-  CustomApprovalRequestSchema
+  CustomApprovalRequestSchema,
+  DirectoryAccessRequestSchema
 ]);
 const ToolConfirmationResponseDataSchema = z.object({
-  rememberChoice: z.boolean().optional().describe("Remember this choice")
+  rememberChoice: z.boolean().optional().describe("Remember this tool for the session (approves ALL uses of this tool)"),
+  rememberPattern: z.string().optional().describe(
+    'Remember a command pattern for bash commands (e.g., "git *"). Only applicable for bash_exec tool approvals.'
+  )
 }).strict().describe("Tool confirmation response data");
 const CommandConfirmationResponseDataSchema = z.object({
   // Command confirmations don't have remember choice - they're per-command
@@ -62,6 +87,9 @@ const ElicitationResponseDataSchema = z.object({
   formData: z.record(z.unknown()).describe("Form data matching schema")
 }).strict().describe("Elicitation response data");
 const CustomApprovalResponseDataSchema = z.record(z.unknown()).describe("Custom response data");
+const DirectoryAccessResponseDataSchema = z.object({
+  rememberDirectory: z.boolean().optional().describe("Remember this directory for the session (allows all file access within it)")
+}).strict().describe("Directory access response data");
 const BaseApprovalResponseSchema = z.object({
   approvalId: z.string().uuid().describe("Must match request approvalId"),
   status: ApprovalStatusSchema.describe("Approval status"),
@@ -84,21 +112,26 @@ const ElicitationResponseSchema = BaseApprovalResponseSchema.extend({
 const CustomApprovalResponseSchema = BaseApprovalResponseSchema.extend({
   data: CustomApprovalResponseDataSchema.optional()
 }).strict();
+const DirectoryAccessResponseSchema = BaseApprovalResponseSchema.extend({
+  data: DirectoryAccessResponseDataSchema.optional()
+}).strict();
 const ApprovalResponseSchema = z.union([
   ToolConfirmationResponseSchema,
   CommandConfirmationResponseSchema,
   ElicitationResponseSchema,
-  CustomApprovalResponseSchema
+  CustomApprovalResponseSchema,
+  DirectoryAccessResponseSchema
 ]);
 const ApprovalRequestDetailsSchema = z.object({
   type: ApprovalTypeSchema,
   sessionId: z.string().optional(),
-  timeout: z.number().int().positive(),
+  timeout: z.number().int().positive().optional().describe("Timeout in milliseconds (optional - no timeout if not specified)"),
   metadata: z.union([
     ToolConfirmationMetadataSchema,
     CommandConfirmationMetadataSchema,
     ElicitationMetadataSchema,
-    CustomApprovalMetadataSchema
+    CustomApprovalMetadataSchema,
+    DirectoryAccessMetadataSchema
   ])
 }).superRefine((data, ctx) => {
   if (data.type === ApprovalType.TOOL_CONFIRMATION) {
@@ -128,6 +161,15 @@ const ApprovalRequestDetailsSchema = z.object({
         path: ["metadata"]
       });
     }
+  } else if (data.type === ApprovalType.DIRECTORY_ACCESS) {
+    const result = DirectoryAccessMetadataSchema.safeParse(data.metadata);
+    if (!result.success) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Metadata must match DirectoryAccessMetadataSchema for DIRECTORY_ACCESS type",
+        path: ["metadata"]
+      });
+    }
   } else if (data.type === ApprovalType.CUSTOM) {
     const result = CustomApprovalMetadataSchema.safeParse(data.metadata);
     if (!result.success) {
@@ -156,6 +198,10 @@ export {
   CustomApprovalResponseDataSchema,
   CustomApprovalResponseSchema,
   DenialReasonSchema,
+  DirectoryAccessMetadataSchema,
+  DirectoryAccessRequestSchema,
+  DirectoryAccessResponseDataSchema,
+  DirectoryAccessResponseSchema,
   ElicitationMetadataSchema,
   ElicitationRequestSchema,
   ElicitationResponseDataSchema,

package/dist/approval/types.cjs

@@ -27,6 +27,7 @@ var ApprovalType = /* @__PURE__ */ ((ApprovalType2) => {
   ApprovalType2["TOOL_CONFIRMATION"] = "tool_confirmation";
   ApprovalType2["COMMAND_CONFIRMATION"] = "command_confirmation";
   ApprovalType2["ELICITATION"] = "elicitation";
+  ApprovalType2["DIRECTORY_ACCESS"] = "directory_access";
   ApprovalType2["CUSTOM"] = "custom";
   return ApprovalType2;
 })(ApprovalType || {});

package/dist/approval/types.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import type { ToolConfirmationMetadataSchema, CommandConfirmationMetadataSchema, ElicitationMetadataSchema, CustomApprovalMetadataSchema, BaseApprovalRequestSchema, ToolConfirmationRequestSchema, CommandConfirmationRequestSchema, ElicitationRequestSchema, CustomApprovalRequestSchema, ApprovalRequestSchema, ApprovalRequestDetailsSchema, ToolConfirmationResponseDataSchema, CommandConfirmationResponseDataSchema, ElicitationResponseDataSchema, CustomApprovalResponseDataSchema, BaseApprovalResponseSchema, ToolConfirmationResponseSchema, CommandConfirmationResponseSchema, ElicitationResponseSchema, CustomApprovalResponseSchema, ApprovalResponseSchema } from './schemas.js';
+import type { ToolConfirmationMetadataSchema, CommandConfirmationMetadataSchema, ElicitationMetadataSchema, CustomApprovalMetadataSchema, DirectoryAccessMetadataSchema, BaseApprovalRequestSchema, ToolConfirmationRequestSchema, CommandConfirmationRequestSchema, ElicitationRequestSchema, CustomApprovalRequestSchema, DirectoryAccessRequestSchema, ApprovalRequestSchema, ApprovalRequestDetailsSchema, ToolConfirmationResponseDataSchema, CommandConfirmationResponseDataSchema, ElicitationResponseDataSchema, CustomApprovalResponseDataSchema, DirectoryAccessResponseDataSchema, BaseApprovalResponseSchema, ToolConfirmationResponseSchema, CommandConfirmationResponseSchema, ElicitationResponseSchema, CustomApprovalResponseSchema, DirectoryAccessResponseSchema, ApprovalResponseSchema } from './schemas.js';
 /**
  * Types of approval requests supported by the system
  */
@@ -20,6 +20,11 @@ export declare enum ApprovalType {
      * Metadata contains: schema, prompt, serverName, context
      */
     ELICITATION = "elicitation",
+    /**
+     * Approval for accessing files outside the working directory
+     * Metadata contains: path, parentDir, operation, toolName
+     */
+    DIRECTORY_ACCESS = "directory_access",
     /**
      * Custom approval types for extensibility
      * Metadata format defined by consumer
@@ -74,6 +79,11 @@ export type ElicitationMetadata = z.output<typeof ElicitationMetadataSchema>;
  * Derived from CustomApprovalMetadataSchema
  */
 export type CustomApprovalMetadata = z.output<typeof CustomApprovalMetadataSchema>;
+/**
+ * Directory access metadata
+ * Derived from DirectoryAccessMetadataSchema
+ */
+export type DirectoryAccessMetadata = z.output<typeof DirectoryAccessMetadataSchema>;
 /**
  * Base approval request that all approvals extend
  * Derived from BaseApprovalRequestSchema
@@ -99,6 +109,11 @@ export type ElicitationRequest = z.output<typeof ElicitationRequestSchema>;
  * Derived from CustomApprovalRequestSchema
  */
 export type CustomApprovalRequest = z.output<typeof CustomApprovalRequestSchema>;
+/**
+ * Directory access request
+ * Derived from DirectoryAccessRequestSchema
+ */
+export type DirectoryAccessRequest = z.output<typeof DirectoryAccessRequestSchema>;
 /**
  * Union of all approval request types
  * Derived from ApprovalRequestSchema
@@ -124,6 +139,11 @@ export type ElicitationResponseData = z.output<typeof ElicitationResponseDataSch
  * Derived from CustomApprovalResponseDataSchema
  */
 export type CustomApprovalResponseData = z.output<typeof CustomApprovalResponseDataSchema>;
+/**
+ * Directory access response data
+ * Derived from DirectoryAccessResponseDataSchema
+ */
+export type DirectoryAccessResponseData = z.output<typeof DirectoryAccessResponseDataSchema>;
 /**
  * Base approval response
  * Derived from BaseApprovalResponseSchema
@@ -149,6 +169,11 @@ export type ElicitationResponse = z.output<typeof ElicitationResponseSchema>;
  * Derived from CustomApprovalResponseSchema
  */
 export type CustomApprovalResponse = z.output<typeof CustomApprovalResponseSchema>;
+/**
+ * Directory access response
+ * Derived from DirectoryAccessResponseSchema
+ */
+export type DirectoryAccessResponse = z.output<typeof DirectoryAccessResponseSchema>;
 /**
  * Union of all approval response types
  * Derived from ApprovalResponseSchema
@@ -214,5 +239,11 @@ export interface ApprovalHandler {
      * @remarks Not all handlers track pending requests (e.g., auto-approve handlers)
      */
     getPending?(): string[];
+    /**
+     * Get full pending approval requests (optional)
+     * @returns Array of pending approval requests
+     * @remarks Not all handlers track pending requests (e.g., auto-approve handlers)
+     */
+    getPendingRequests?(): ApprovalRequest[];
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/approval/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/approval/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/approval/types.ts"],"names":[],"mappings":"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"}

package/dist/approval/types.js

@@ -1,8 +1,9 @@
-import "../chunk-C6A6W6XS.js";
+import "../chunk-PTJYTZNU.js";
 var ApprovalType = /* @__PURE__ */ ((ApprovalType2) => {
   ApprovalType2["TOOL_CONFIRMATION"] = "tool_confirmation";
   ApprovalType2["COMMAND_CONFIRMATION"] = "command_confirmation";
   ApprovalType2["ELICITATION"] = "elicitation";
+  ApprovalType2["DIRECTORY_ACCESS"] = "directory_access";
   ApprovalType2["CUSTOM"] = "custom";
   return ApprovalType2;
 })(ApprovalType || {});

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/context/compaction/factory.cjs

@@ -0,0 +1,57 @@
+"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 factory_exports = {};
+__export(factory_exports, {
+  createCompactionStrategy: () => createCompactionStrategy
+});
+module.exports = __toCommonJS(factory_exports);
+var import_zod = require("zod");
+var import_registry = require("./registry.js");
+var import_errors = require("../errors.js");
+async function createCompactionStrategy(config, context) {
+  if (config.enabled === false) {
+    context.logger.info(`Compaction provider '${config.type}' is disabled`);
+    return null;
+  }
+  const provider = import_registry.compactionRegistry.get(config.type);
+  if (!provider) {
+    const available = import_registry.compactionRegistry.getTypes();
+    throw import_errors.ContextError.compactionInvalidType(config.type, available);
+  }
+  try {
+    const validatedConfig = provider.configSchema.parse(config);
+    if (provider.metadata?.requiresLLM && !context.model) {
+      throw import_errors.ContextError.compactionMissingLLM(config.type);
+    }
+    const strategy = await provider.create(validatedConfig, context);
+    context.logger.info(
+      `Created compaction strategy: ${provider.metadata?.displayName || config.type}`
+    );
+    return strategy;
+  } catch (error) {
+    if (error instanceof import_zod.z.ZodError) {
+      throw import_errors.ContextError.compactionValidation(config.type, error.errors);
+    }
+    throw error;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCompactionStrategy
+});

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

@@ -0,0 +1,17 @@
+import type { ICompactionStrategy } from './types.js';
+import type { CompactionContext, CompactionConfig } from './provider.js';
+/**
+ * Create a compaction strategy from configuration.
+ *
+ * Follows the same pattern as blob storage and tools:
+ * - Validates provider exists
+ * - Validates configuration with Zod schema
+ * - Checks LLM requirements
+ * - Creates strategy instance
+ *
+ * @param config - Compaction configuration from agent config
+ * @param context - Context with logger and optional LanguageModel
+ * @returns Strategy instance or null if disabled
+ */
+export declare function createCompactionStrategy(config: CompactionConfig, context: CompactionContext): Promise<ICompactionStrategy | null>;
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAIzE;;;;;;;;;;;;GAYG;AACH,wBAAsB,wBAAwB,CAC1C,MAAM,EAAE,gBAAgB,EACxB,OAAO,EAAE,iBAAiB,GAC3B,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAqCrC"}

package/dist/context/compaction/factory.js

@@ -0,0 +1,34 @@
+import "../../chunk-PTJYTZNU.js";
+import { z } from "zod";
+import { compactionRegistry } from "./registry.js";
+import { ContextError } from "../errors.js";
+async function createCompactionStrategy(config, context) {
+  if (config.enabled === false) {
+    context.logger.info(`Compaction provider '${config.type}' is disabled`);
+    return null;
+  }
+  const provider = compactionRegistry.get(config.type);
+  if (!provider) {
+    const available = compactionRegistry.getTypes();
+    throw ContextError.compactionInvalidType(config.type, available);
+  }
+  try {
+    const validatedConfig = provider.configSchema.parse(config);
+    if (provider.metadata?.requiresLLM && !context.model) {
+      throw ContextError.compactionMissingLLM(config.type);
+    }
+    const strategy = await provider.create(validatedConfig, context);
+    context.logger.info(
+      `Created compaction strategy: ${provider.metadata?.displayName || config.type}`
+    );
+    return strategy;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      throw ContextError.compactionValidation(config.type, error.errors);
+    }
+    throw error;
+  }
+}
+export {
+  createCompactionStrategy
+};

package/dist/context/compaction/index.cjs

@@ -0,0 +1,49 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compaction_exports = {};
+module.exports = __toCommonJS(compaction_exports);
+__reExport(compaction_exports, require("./types.js"), module.exports);
+__reExport(compaction_exports, require("./provider.js"), module.exports);
+__reExport(compaction_exports, require("./registry.js"), module.exports);
+__reExport(compaction_exports, require("./factory.js"), module.exports);
+__reExport(compaction_exports, require("./schemas.js"), module.exports);
+__reExport(compaction_exports, require("./strategies/reactive-overflow.js"), module.exports);
+__reExport(compaction_exports, require("./strategies/noop.js"), module.exports);
+__reExport(compaction_exports, require("./providers/reactive-overflow-provider.js"), module.exports);
+__reExport(compaction_exports, require("./providers/noop-provider.js"), module.exports);
+__reExport(compaction_exports, require("./overflow.js"), module.exports);
+var import_registry = require("./registry.js");
+var import_reactive_overflow_provider = require("./providers/reactive-overflow-provider.js");
+var import_noop_provider = require("./providers/noop-provider.js");
+if (!import_registry.compactionRegistry.has("reactive-overflow")) {
+  import_registry.compactionRegistry.register(import_reactive_overflow_provider.reactiveOverflowProvider);
+}
+if (!import_registry.compactionRegistry.has("noop")) {
+  import_registry.compactionRegistry.register(import_noop_provider.noopProvider);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types.js"),
+  ...require("./provider.js"),
+  ...require("./registry.js"),
+  ...require("./factory.js"),
+  ...require("./schemas.js"),
+  ...require("./strategies/reactive-overflow.js"),
+  ...require("./strategies/noop.js"),
+  ...require("./providers/reactive-overflow-provider.js"),
+  ...require("./providers/noop-provider.js"),
+  ...require("./overflow.js")
+});

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

@@ -0,0 +1,11 @@
+export * from './types.js';
+export * from './provider.js';
+export * from './registry.js';
+export * from './factory.js';
+export * from './schemas.js';
+export * from './strategies/reactive-overflow.js';
+export * from './strategies/noop.js';
+export * from './providers/reactive-overflow-provider.js';
+export * from './providers/noop-provider.js';
+export * from './overflow.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/context/compaction/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAG7B,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AAGrC,cAAc,2CAA2C,CAAC;AAC1D,cAAc,8BAA8B,CAAC;AAG7C,cAAc,eAAe,CAAC"}

package/dist/context/compaction/index.js

@@ -0,0 +1,19 @@
+export * from "./types.js";
+export * from "./provider.js";
+export * from "./registry.js";
+export * from "./factory.js";
+export * from "./schemas.js";
+export * from "./strategies/reactive-overflow.js";
+export * from "./strategies/noop.js";
+export * from "./providers/reactive-overflow-provider.js";
+export * from "./providers/noop-provider.js";
+export * from "./overflow.js";
+import { compactionRegistry } from "./registry.js";
+import { reactiveOverflowProvider } from "./providers/reactive-overflow-provider.js";
+import { noopProvider } from "./providers/noop-provider.js";
+if (!compactionRegistry.has("reactive-overflow")) {
+  compactionRegistry.register(reactiveOverflowProvider);
+}
+if (!compactionRegistry.has("noop")) {
+  compactionRegistry.register(noopProvider);
+}

package/dist/context/compaction/overflow.cjs

@@ -0,0 +1,43 @@
+"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 overflow_exports = {};
+__export(overflow_exports, {
+  getCompactionTarget: () => getCompactionTarget,
+  isOverflow: () => isOverflow
+});
+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 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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCompactionTarget,
+  isOverflow
+});

package/dist/context/compaction/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 compaction is needed
+ */
+export declare function isOverflow(tokens: TokenUsage, modelLimits: ModelLimits): 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%)
+ * @returns The target token count after compaction
+ */
+export declare function getCompactionTarget(modelLimits: ModelLimits, targetPercentage?: number): number;
+//# sourceMappingURL=overflow.d.ts.map

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

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

package/dist/context/compaction/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 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);
+}
+export {
+  getCompactionTarget,
+  isOverflow
+};

package/dist/context/compaction/provider.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 provider_exports = {};
+module.exports = __toCommonJS(provider_exports);