@codebolt/agent 6.0.0 → 6.1.2

package/dist/unified/services/compaction/snipCompact.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Layer 1: Snip Compact
+ *
+ * Proactively removes older messages from the model-facing view each turn.
+ * Keeps them in the conversation for scrollback/UI purposes, but removes
+ * them from what gets sent to the LLM.
+ *
+ * Key properties:
+ * - Runs every turn, proactively
+ * - tokensFreed is plumbed to autocompact so its threshold check is accurate
+ * - Cheapest compaction layer (no LLM call, just array slicing)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnipCompact = void 0;
+const types_1 = require("./types");
+/** Number of recent turns (user messages) to always protect from snipping */
+const DEFAULT_PROTECTED_TURNS = 4;
+/** Maximum fraction of messages that snip is allowed to remove in one pass */
+const DEFAULT_MAX_SNIP_FRACTION = 0.4;
+class SnipCompact {
+    constructor(options) {
+        var _a, _b, _c;
+        this.name = 'snip';
+        this.options = {
+            protectedTurns: (_a = options === null || options === void 0 ? void 0 : options.protectedTurns) !== null && _a !== void 0 ? _a : DEFAULT_PROTECTED_TURNS,
+            maxSnipFraction: (_b = options === null || options === void 0 ? void 0 : options.maxSnipFraction) !== null && _b !== void 0 ? _b : DEFAULT_MAX_SNIP_FRACTION,
+            enableLogging: (_c = options === null || options === void 0 ? void 0 : options.enableLogging) !== null && _c !== void 0 ? _c : false,
+        };
+    }
+    shouldApply(ctx) {
+        // Snip runs proactively every turn, as long as there are enough messages.
+        // Skip if there's been a recent compaction boundary we must respect.
+        const messages = ctx.messages;
+        if (!messages || messages.length <= this.options.protectedTurns * 3) {
+            return false;
+        }
+        return true;
+    }
+    async apply(ctx) {
+        var _a;
+        const messages = ctx.messages;
+        const estimator = new types_1.TokenEstimator();
+        // Find turn boundaries (each turn starts with a user message that is not a tool response)
+        const turnStarts = this.findTurnStarts(messages);
+        if (turnStarts.length <= this.options.protectedTurns) {
+            return ctx;
+        }
+        // Determine how many turns to snip
+        const maxSnippable = turnStarts.length - this.options.protectedTurns;
+        const snipCount = Math.min(maxSnippable, Math.ceil(turnStarts.length * this.options.maxSnipFraction));
+        if (snipCount <= 0) {
+            return ctx;
+        }
+        // The first protected turn index
+        const firstProtectedTurn = (_a = turnStarts[snipCount]) !== null && _a !== void 0 ? _a : messages.length;
+        // Count tokens in the snipped range
+        const snippedMessages = messages.slice(0, firstProtectedTurn);
+        const tokensFreed = estimator.estimateForMessages(snippedMessages);
+        // Preserve system messages from the snipped range
+        const systemMessages = snippedMessages.filter(m => m.role === 'system');
+        // Keep: system messages + protected range
+        const protectedMessages = messages.slice(firstProtectedTurn);
+        const resultMessages = [
+            ...systemMessages,
+            // Add a lightweight placeholder noting what was snipped
+            {
+                role: 'user',
+                content: `[Context: ${snipCount} earlier conversation turn(s) trimmed to manage context length. The original task and all recent work are preserved below.]`,
+            },
+            {
+                role: 'assistant',
+                content: 'Understood. I have the trimmed context and will continue from the current state.',
+            },
+            ...protectedMessages,
+        ];
+        const boundary = {
+            layer: 'snip',
+            tokensFreed,
+            messagesRemoved: snippedMessages.length - systemMessages.length,
+            timestamp: new Date().toISOString(),
+        };
+        if (this.options.enableLogging) {
+            console.log(`[SnipCompact] Snipped ${snipCount} turns (${snippedMessages.length} messages, ~${tokensFreed} tokens freed)`);
+        }
+        return {
+            ...ctx,
+            messages: resultMessages,
+            snipTokensFreed: tokensFreed,
+            compactionHistory: [...(ctx.compactionHistory || []), boundary],
+        };
+    }
+    reset() {
+        // SnipCompact is stateless across turns
+    }
+    findTurnStarts(messages) {
+        const turns = [];
+        for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            if (!msg)
+                continue;
+            // A turn starts at a user message that isn't a tool response
+            if (msg.role === 'user' &&
+                !this.isToolResponse(msg)) {
+                turns.push(i);
+            }
+        }
+        return turns;
+    }
+    isToolResponse(msg) {
+        if (msg.role === 'tool')
+            return true;
+        if (msg.tool_call_id)
+            return true;
+        if (typeof msg.content === 'object' && msg.content !== null) {
+            if (Array.isArray(msg.content)) {
+                return msg.content.some((block) => block &&
+                    (block.type === 'tool_result' || block.type === 'function_response'));
+            }
+        }
+        return false;
+    }
+}
+exports.SnipCompact = SnipCompact;

package/dist/unified/services/compaction/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Multi-Layer Compaction Types
+ *
+ * Shared types for the 5-layer defense-in-depth compaction system.
+ */
+import type { MessageObject } from '@codebolt/types/sdk';
+export declare class TokenEstimator {
+    private charsPerToken;
+    estimate(text: string): number;
+    estimateForMessages(messages: MessageObject[]): number;
+    calibrate(estimatedTokens: number, actualTokens: number): void;
+}
+export type CompactionLayerKind = 'snip' | 'micro' | 'collapse' | 'auto' | 'reactive';
+export interface CompactionBoundary {
+    /** Which layer produced this boundary */
+    layer: CompactionLayerKind;
+    /** Approximate tokens freed by this compaction */
+    tokensFreed: number;
+    /** Number of messages removed */
+    messagesRemoved: number;
+    /** ISO timestamp */
+    timestamp: string;
+    /** For auto-compact: whether a summary was included */
+    summaryIncluded?: boolean;
+    /** For collapse: number of granular summaries committed */
+    committed?: number;
+}
+export interface CompactionContext {
+    /** Current messages to evaluate/compress */
+    messages: MessageObject[];
+    /** Tokens freed by snip compact (layer 1) */
+    snipTokensFreed?: number;
+    /** Whether context collapse is enabled (suppresses auto-compact when true) */
+    contextCollapseEnabled?: boolean;
+    /** Compaction history (boundaries applied so far) */
+    compactionHistory?: CompactionBoundary[];
+    /** Auto-compact tracking state */
+    autoCompactTracking?: {
+        compacted: boolean;
+        turnId: string;
+        turnCounter: number;
+        consecutiveFailures: number;
+    };
+}
+export interface CompactionOrchestratorOptions {
+    modelTokenLimit?: number;
+    autoCompactEnabled?: boolean;
+    autoCompactBufferTokens?: number;
+    maxConsecutiveFailures?: number;
+    snipEnabled?: boolean;
+    microCompactEnabled?: boolean;
+    contextCollapseEnabled?: boolean;
+    microCompactGapMinutes?: number;
+    microCompactKeepRecent?: number;
+    collapseCommitThreshold?: number;
+    collapseBlockingThreshold?: number;
+    reactiveRetryLimit?: number;
+    llmRole?: string;
+    enableLogging?: boolean;
+}
+export interface CompactionLayer {
+    readonly name: CompactionLayerKind;
+    shouldApply(ctx: CompactionContext): boolean;
+    apply(ctx: CompactionContext): Promise<CompactionContext>;
+    reset(): void;
+}

package/dist/unified/services/compaction/types.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Multi-Layer Compaction Types
+ *
+ * Shared types for the 5-layer defense-in-depth compaction system.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenEstimator = void 0;
+// ─── Token Estimation ────────────────────────────────────────────────
+class TokenEstimator {
+    constructor() {
+        this.charsPerToken = 4;
+    }
+    estimate(text) {
+        if (!text)
+            return 0;
+        return Math.ceil(text.length / this.charsPerToken);
+    }
+    estimateForMessages(messages) {
+        if (!messages || !Array.isArray(messages))
+            return 0;
+        return messages.reduce((total, msg) => {
+            var _a;
+            if (!msg)
+                return total;
+            const content = typeof msg.content === 'string'
+                ? msg.content
+                : JSON.stringify((_a = msg.content) !== null && _a !== void 0 ? _a : '');
+            return total + this.estimate(content) + 4;
+        }, 0);
+    }
+    calibrate(estimatedTokens, actualTokens) {
+        if (actualTokens <= 0 || estimatedTokens <= 0)
+            return;
+        const ratio = estimatedTokens / actualTokens;
+        this.charsPerToken = Math.max(2, Math.min(6, this.charsPerToken * ratio));
+    }
+}
+exports.TokenEstimator = TokenEstimator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/agent",
-  "version": "6.0.0",
+  "version": "6.1.2",
   "description": "CodeBolt Agent utilities for building and managing AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,17 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "dev": "tsc --watch",
+    "test": "echo \"No tests yet, but build passes\" && exit 0",
+    "lint": "eslint src/**/*.ts && tsc --noEmit",
+    "lint:test": "npm run lint",
+    "docs": "node script/gen-docusaurus-agent-types.js",
+    "docs:clean": "node script/gen-docusaurus-agent-types.js --clean",
+    "docs:watch": "node script/gen-docusaurus-agent-types.js --watch"
+  },
   "keywords": [
     "ai",
     "agent",
@@ -24,40 +35,35 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/codeboltai/codeboltjs.git",
+    "url": "git+https://github.com/codeboltai/codebolt.git",
     "directory": "packages/agent"
   },
   "dependencies": {
+    "@codebolt/types": "*",
     "js-yaml": "^4.1.0",
-    "zod": "^3.22.4",
-    "@codebolt/types": "6.0.0"
+    "zod": "^3.22.4"
   },
   "peerDependencies": {
-    "@codebolt/codeboltjs": "6.0.0"
+    "@codebolt/codeboltjs": "*"
   },
   "devDependencies": {
+    "@codebolt/codeboltjs": "*",
+    "@codebolt/types": "*",
+    "@eslint/js": "^8.57.1",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.14.2",
     "@types/uri-templates": "^0.1.34",
     "@types/ws": "^8.5.10",
+    "eslint": "^8.57.1",
     "typedoc": "0.28.16",
     "typedoc-plugin-markdown": "4.9.0",
     "typescript": "^5.4.5",
-    "@codebolt/codeboltjs": "6.0.0",
-    "@codebolt/types": "6.0.0"
+    "typescript-eslint": "^7.18.0"
   },
   "exports": {
-    "./builder": {
-      "types": "./dist/builderpattern/index.d.ts",
-      "default": "./dist/builderpattern/index.js"
-    },
-    "./composable": {
-      "types": "./dist/composablepattern/index.d.ts",
-      "default": "./dist/composablepattern/index.js"
-    },
-    "./processor": {
-      "types": "./dist/processor/index.d.ts",
-      "default": "./dist/processor/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./processor-pieces": {
       "types": "./dist/processor-pieces/index.d.ts",
@@ -67,15 +73,5 @@
       "types": "./dist/unified/index.d.ts",
       "default": "./dist/unified/index.js"
     }
-  },
-  "scripts": {
-    "build": "tsc",
-    "clean": "rm -rf dist",
-    "dev": "tsc --watch",
-    "test": "echo \"No tests yet, but build passes\" && exit 0",
-    "lint:test": "eslint src/**/*.ts && tsc --noEmit",
-    "docs": "node script/gen-docusaurus-agent-types.js",
-    "docs:clean": "node script/gen-docusaurus-agent-types.js --clean",
-    "docs:watch": "node script/gen-docusaurus-agent-types.js --watch"
   }
-}
+}