@codebolt/agent 6.0.0 → 6.1.2

package/dist/unified/index.js

@@ -10,7 +10,7 @@
  * The framework is designed to be modular, extensible, and easy to use.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Workflow = exports.createTool = exports.Tool = exports.createCodeboltAgent = exports.CodeboltAgent = exports.Agent = exports.LoopType = exports.LoopDetectionService = exports.ResponseExecutor = exports.AgentStep = exports.InitialPromptGenerator = exports.createDefaultMessageProcessor = exports.UnifiedToolExecutionError = exports.UnifiedResponseExecutionError = exports.UnifiedStepExecutionError = exports.UnifiedMessageProcessingError = exports.UnifiedAgentError = void 0;
+exports.TokenEstimator = exports.PostCompactCleanup = exports.ReactiveCompact = exports.AutoCompact = exports.ContextCollapse = exports.MicroCompact = exports.SnipCompact = exports.CompactionOrchestrator = exports.Workflow = exports.createTool = exports.Tool = exports.createCodeboltAgent = exports.CodeboltAgent = exports.Agent = exports.CompressionCoordinator = exports.LoopType = exports.LoopDetectionService = exports.ResponseExecutor = exports.AgentStep = exports.InitialPromptGenerator = exports.createDefaultMessageProcessor = exports.UnifiedToolExecutionError = exports.UnifiedResponseExecutionError = exports.UnifiedStepExecutionError = exports.UnifiedMessageProcessingError = exports.UnifiedAgentError = void 0;
 // Error types
 var types_1 = require("./types/types");
 Object.defineProperty(exports, "UnifiedAgentError", { enumerable: true, get: function () { return types_1.UnifiedAgentError; } });
@@ -30,6 +30,8 @@ Object.defineProperty(exports, "ResponseExecutor", { enumerable: true, get: func
 var LoopDetectionService_1 = require("./services/LoopDetectionService");
 Object.defineProperty(exports, "LoopDetectionService", { enumerable: true, get: function () { return LoopDetectionService_1.LoopDetectionService; } });
 Object.defineProperty(exports, "LoopType", { enumerable: true, get: function () { return LoopDetectionService_1.LoopType; } });
+var CompressionCoordinator_1 = require("./services/CompressionCoordinator");
+Object.defineProperty(exports, "CompressionCoordinator", { enumerable: true, get: function () { return CompressionCoordinator_1.CompressionCoordinator; } });
 // Agent framework components
 var agent_1 = require("./agent/agent");
 Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });
@@ -42,15 +44,20 @@ Object.defineProperty(exports, "createTool", { enumerable: true, get: function (
 var workflow_1 = require("./agent/workflow");
 Object.defineProperty(exports, "Workflow", { enumerable: true, get: function () { return workflow_1.Workflow; } });
 // Workflow step factories
-// Orchestrator system
-// export {
-//     UnifiedOrchestrator,
-//     createOrchestrator,
-//     createRuntimeContext,
-//     type OrchestratorConfig,
-//     type RuntimeContext,
-//     type OrchestratorResult,
-//     type OrchestratorDecision,
-//     type OrchestratorExecutionStep,
-//     type OrchestratorMetrics
-// } from './orchestrator/orchestrator';
+// Multi-layer compaction system
+var compactionOrchestrator_1 = require("./services/compaction/compactionOrchestrator");
+Object.defineProperty(exports, "CompactionOrchestrator", { enumerable: true, get: function () { return compactionOrchestrator_1.CompactionOrchestrator; } });
+var snipCompact_1 = require("./services/compaction/snipCompact");
+Object.defineProperty(exports, "SnipCompact", { enumerable: true, get: function () { return snipCompact_1.SnipCompact; } });
+var microCompact_1 = require("./services/compaction/microCompact");
+Object.defineProperty(exports, "MicroCompact", { enumerable: true, get: function () { return microCompact_1.MicroCompact; } });
+var contextCollapse_1 = require("./services/compaction/contextCollapse");
+Object.defineProperty(exports, "ContextCollapse", { enumerable: true, get: function () { return contextCollapse_1.ContextCollapse; } });
+var autoCompact_1 = require("./services/compaction/autoCompact");
+Object.defineProperty(exports, "AutoCompact", { enumerable: true, get: function () { return autoCompact_1.AutoCompact; } });
+var reactiveCompact_1 = require("./services/compaction/reactiveCompact");
+Object.defineProperty(exports, "ReactiveCompact", { enumerable: true, get: function () { return reactiveCompact_1.ReactiveCompact; } });
+var postCompactCleanup_1 = require("./services/compaction/postCompactCleanup");
+Object.defineProperty(exports, "PostCompactCleanup", { enumerable: true, get: function () { return postCompactCleanup_1.PostCompactCleanup; } });
+var types_2 = require("./services/compaction/types");
+Object.defineProperty(exports, "TokenEstimator", { enumerable: true, get: function () { return types_2.TokenEstimator; } });

package/dist/unified/services/CompressionCoordinator.d.ts

@@ -0,0 +1,67 @@
+import type { ProcessedMessage } from '@codebolt/types/agent';
+import type { FlatUserMessage } from '@codebolt/types/sdk';
+import { ChatCompressionModifier, ConversationCompactorModifier } from '../../processor-pieces';
+export type CompressionStage = 'pre_inference' | 'post_tool' | 'reactive_force_compact';
+export interface CompressionCoordinatorOptions {
+    enabled?: boolean;
+    proactiveThreshold?: number;
+    postToolThreshold?: number;
+    preserveThreshold?: number;
+    toolResponseTokenBudget?: number;
+    truncateLines?: number;
+    reactiveRetryLimit?: number;
+    modelTokenLimit?: number;
+    compactStrategy?: 'simple' | 'smart' | 'summarize';
+    enableLogging?: boolean;
+}
+export interface CompressionMetadata {
+    status: string;
+    stage: CompressionStage;
+    originalTokenCount: number;
+    newTokenCount: number;
+    timestamp: string;
+    strategy: string;
+    messagesCompressed?: number;
+    messagesPreserved?: number;
+    toolOutputsTruncated?: boolean;
+    failedAttempts?: number;
+    reactiveRetryCount?: number;
+    reason?: string;
+}
+export interface CompressionDecision {
+    shouldCompress: boolean;
+    estimatedTokens: number;
+    threshold: number;
+    reason: string;
+}
+export interface CompressionRecoveryResult {
+    recoveredMessage: ProcessedMessage;
+    shouldRetry: boolean;
+    reason: string;
+}
+export declare class CompressionCoordinator {
+    private readonly options;
+    private readonly chatCompression;
+    private readonly conversationCompactor;
+    private reactiveRetryCount;
+    constructor(options?: CompressionCoordinatorOptions);
+    shouldCompressBeforeInference(message: ProcessedMessage): CompressionDecision;
+    compressBeforeInference(_originalRequest: FlatUserMessage, message: ProcessedMessage): Promise<ProcessedMessage>;
+    getPreInferenceProcessor(): ChatCompressionModifier;
+    getPostToolCallProcessor(): ConversationCompactorModifier;
+    compressAfterTools(input: {
+        llmMessageSent: ProcessedMessage;
+        rawLLMResponseMessage: any;
+        nextPrompt: ProcessedMessage;
+        toolResults: any[];
+        tokenLimit?: number;
+        maxOutputTokens?: number;
+    }): Promise<ProcessedMessage>;
+    recoverFromContextError(_originalRequest: FlatUserMessage, message: ProcessedMessage, error: unknown): Promise<CompressionRecoveryResult>;
+    resetReactiveRetries(): void;
+    getReactiveRetryCount(): number;
+    private countMessageTokens;
+    private withCompressionStage;
+    private withCompressionMetadata;
+    private isRecoverableContextError;
+}

package/dist/unified/services/CompressionCoordinator.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionCoordinator = void 0;
+const processor_pieces_1 = require("../../processor-pieces");
+const DEFAULT_MODEL_TOKEN_LIMIT = 128000;
+class CompressionCoordinator {
+    constructor(options = {}) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        this.reactiveRetryCount = 0;
+        this.options = {
+            enabled: (_a = options.enabled) !== null && _a !== void 0 ? _a : true,
+            proactiveThreshold: (_b = options.proactiveThreshold) !== null && _b !== void 0 ? _b : 0.7,
+            postToolThreshold: (_c = options.postToolThreshold) !== null && _c !== void 0 ? _c : 0.5,
+            preserveThreshold: (_d = options.preserveThreshold) !== null && _d !== void 0 ? _d : 0.3,
+            toolResponseTokenBudget: (_e = options.toolResponseTokenBudget) !== null && _e !== void 0 ? _e : 50000,
+            truncateLines: (_f = options.truncateLines) !== null && _f !== void 0 ? _f : 30,
+            reactiveRetryLimit: (_g = options.reactiveRetryLimit) !== null && _g !== void 0 ? _g : 1,
+            modelTokenLimit: (_h = options.modelTokenLimit) !== null && _h !== void 0 ? _h : DEFAULT_MODEL_TOKEN_LIMIT,
+            compactStrategy: (_j = options.compactStrategy) !== null && _j !== void 0 ? _j : 'summarize',
+            enableLogging: (_k = options.enableLogging) !== null && _k !== void 0 ? _k : false,
+        };
+        const chatCompressionOptions = {
+            enableCompression: this.options.enabled,
+            contextPercentageThreshold: this.options.proactiveThreshold,
+            modelTokenLimit: this.options.modelTokenLimit,
+        };
+        const conversationCompactorOptions = {
+            compressionTokenThreshold: this.options.postToolThreshold,
+            preserveThreshold: this.options.preserveThreshold,
+            toolResponseTokenBudget: this.options.toolResponseTokenBudget,
+            truncateLines: this.options.truncateLines,
+            compactStrategy: this.options.compactStrategy,
+            modelTokenLimit: this.options.modelTokenLimit,
+            enableLogging: this.options.enableLogging,
+        };
+        this.chatCompression = new processor_pieces_1.ChatCompressionModifier(chatCompressionOptions);
+        this.conversationCompactor = new processor_pieces_1.ConversationCompactorModifier(conversationCompactorOptions);
+    }
+    shouldCompressBeforeInference(message) {
+        const estimatedTokens = this.countMessageTokens(message.message.messages);
+        const threshold = this.options.proactiveThreshold * this.options.modelTokenLimit;
+        if (!this.options.enabled) {
+            return {
+                shouldCompress: false,
+                estimatedTokens,
+                threshold,
+                reason: 'Compression disabled',
+            };
+        }
+        if (estimatedTokens >= threshold) {
+            return {
+                shouldCompress: true,
+                estimatedTokens,
+                threshold,
+                reason: 'Proactive threshold reached',
+            };
+        }
+        return {
+            shouldCompress: false,
+            estimatedTokens,
+            threshold,
+            reason: 'Below proactive threshold',
+        };
+    }
+    async compressBeforeInference(_originalRequest, message) {
+        if (!this.options.enabled) {
+            return message;
+        }
+        return this.chatCompression.modify(_originalRequest, message);
+    }
+    getPreInferenceProcessor() {
+        return this.chatCompression;
+    }
+    getPostToolCallProcessor() {
+        return this.conversationCompactor;
+    }
+    async compressAfterTools(input) {
+        const result = await this.conversationCompactor.modify(input);
+        return this.withCompressionStage(result.nextPrompt, 'post_tool');
+    }
+    async recoverFromContextError(_originalRequest, message, error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (!this.isRecoverableContextError(errorMessage)) {
+            return {
+                recoveredMessage: message,
+                shouldRetry: false,
+                reason: 'Error is not context-related',
+            };
+        }
+        if (this.reactiveRetryCount >= this.options.reactiveRetryLimit) {
+            return {
+                recoveredMessage: this.withCompressionMetadata(message, {
+                    status: 'FAILED_REACTIVE_RETRY_LIMIT',
+                    stage: 'reactive_force_compact',
+                    originalTokenCount: this.countMessageTokens(message.message.messages),
+                    newTokenCount: this.countMessageTokens(message.message.messages),
+                    timestamp: new Date().toISOString(),
+                    strategy: this.options.compactStrategy,
+                    reactiveRetryCount: this.reactiveRetryCount,
+                    reason: 'Reactive retry limit reached',
+                }),
+                shouldRetry: false,
+                reason: 'Reactive retry limit reached',
+            };
+        }
+        this.reactiveRetryCount++;
+        const proactiveCompression = await this.chatCompression.tryCompressChat(message.message.messages, true);
+        if (proactiveCompression.compressedMessages &&
+            proactiveCompression.compressionStatus === 1) {
+            return {
+                recoveredMessage: this.withCompressionMetadata({
+                    ...message,
+                    message: {
+                        ...message.message,
+                        messages: proactiveCompression.compressedMessages,
+                    },
+                }, {
+                    status: 'COMPRESSED',
+                    stage: 'reactive_force_compact',
+                    originalTokenCount: proactiveCompression.originalTokenCount,
+                    newTokenCount: proactiveCompression.newTokenCount,
+                    timestamp: new Date().toISOString(),
+                    strategy: 'summarize',
+                    reactiveRetryCount: this.reactiveRetryCount,
+                    reason: 'Reactive pre-inference compression applied',
+                }),
+                shouldRetry: true,
+                reason: 'Reactive pre-inference compression applied',
+            };
+        }
+        const forceCompressed = await this.conversationCompactor.forceCompress(message.message.messages);
+        return {
+            recoveredMessage: this.withCompressionMetadata({
+                ...message,
+                message: {
+                    ...message.message,
+                    messages: forceCompressed.messages,
+                },
+            }, {
+                status: 'COMPRESSED',
+                stage: 'reactive_force_compact',
+                originalTokenCount: this.countMessageTokens(message.message.messages),
+                newTokenCount: this.countMessageTokens(forceCompressed.messages),
+                timestamp: new Date().toISOString(),
+                strategy: this.options.compactStrategy,
+                ...(forceCompressed.metadata.messagesCompressed !==
+                    undefined && {
+                    messagesCompressed: forceCompressed.metadata.messagesCompressed,
+                }),
+                ...(forceCompressed.metadata.messagesPreserved !==
+                    undefined && {
+                    messagesPreserved: forceCompressed.metadata.messagesPreserved,
+                }),
+                ...(forceCompressed.metadata.toolOutputsTruncated !==
+                    undefined && {
+                    toolOutputsTruncated: forceCompressed.metadata.toolOutputsTruncated,
+                }),
+                reactiveRetryCount: this.reactiveRetryCount,
+                reason: 'Reactive post-tool compaction applied',
+            }),
+            shouldRetry: true,
+            reason: 'Reactive post-tool compaction applied',
+        };
+    }
+    resetReactiveRetries() {
+        this.reactiveRetryCount = 0;
+    }
+    getReactiveRetryCount() {
+        return this.reactiveRetryCount;
+    }
+    countMessageTokens(messages) {
+        return messages.reduce((totalTokens, message) => {
+            var _a;
+            const content = typeof message.content === 'string'
+                ? message.content
+                : JSON.stringify((_a = message.content) !== null && _a !== void 0 ? _a : '');
+            return totalTokens + Math.ceil(content.length / 4) + 4;
+        }, 0);
+    }
+    withCompressionStage(message, stage) {
+        var _a;
+        const existingMetadata = (_a = message.metadata) === null || _a === void 0 ? void 0 : _a['compression'];
+        if (!existingMetadata) {
+            return message;
+        }
+        return this.withCompressionMetadata(message, {
+            ...existingMetadata,
+            stage,
+        });
+    }
+    withCompressionMetadata(message, compression) {
+        return {
+            ...message,
+            metadata: {
+                ...message.metadata,
+                compression,
+            },
+        };
+    }
+    isRecoverableContextError(errorMessage) {
+        const contextErrorPatterns = [
+            /prompt too long/i,
+            /context length/i,
+            /maximum context/i,
+            /context window/i,
+            /too many tokens/i,
+            /token limit/i,
+            /request too large/i,
+            /input is too long/i,
+        ];
+        return contextErrorPatterns.some(pattern => pattern.test(errorMessage));
+    }
+}
+exports.CompressionCoordinator = CompressionCoordinator;

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

@@ -0,0 +1,52 @@
+/**
+ * Layer 4: Auto Compact
+ *
+ * Full conversation summary via LLM when approaching the context window limit.
+ * Two sub-paths:
+ *   4a. Session memory compaction (using continuously-extracted memory)
+ *   4b. Legacy full summary (sends conversation to LLM for detailed summary)
+ *
+ * Key properties:
+ * - Triggers at effectiveContextWindow - bufferTokens (default 13K)
+ * - Circuit breaker: stops after N consecutive failures
+ * - Produces a CompactBoundaryMessage for boundary tracking
+ * - Post-compact cleanup resets all tracking state
+ * - When context collapse is active, auto-compact is suppressed
+ */
+import { type CompactionContext, type CompactionLayer, type CompactionLayerKind } from './types';
+export interface AutoCompactOptions {
+    /** Buffer tokens below context window (default: 13000) */
+    bufferTokens?: number;
+    /** Max consecutive failures before circuit breaker (default: 3) */
+    maxConsecutiveFailures?: number;
+    /** Model token limit (default: 128000) */
+    modelTokenLimit?: number;
+    /** Fraction of recent history to preserve after compression (default: 0.3) */
+    preserveThreshold?: number;
+    /** LLM role for summarization calls (default: 'summarizer') */
+    llmRole?: string;
+    /** Enable logging (default: false) */
+    enableLogging?: boolean;
+}
+export interface AutoCompactTracking {
+    compacted: boolean;
+    turnId: string;
+    turnCounter: number;
+    consecutiveFailures: number;
+}
+export declare class AutoCompact implements CompactionLayer {
+    readonly name: CompactionLayerKind;
+    private readonly options;
+    private consecutiveFailures;
+    private tracking;
+    constructor(options?: AutoCompactOptions);
+    shouldApply(ctx: CompactionContext): boolean;
+    apply(ctx: CompactionContext): Promise<CompactionContext>;
+    reset(): void;
+    getTracking(): AutoCompactTracking | undefined;
+    getConsecutiveFailures(): number;
+    private compactConversation;
+    private findSplitIndex;
+    private generateSummary;
+    private isToolResponse;
+}

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

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * Layer 4: Auto Compact
+ *
+ * Full conversation summary via LLM when approaching the context window limit.
+ * Two sub-paths:
+ *   4a. Session memory compaction (using continuously-extracted memory)
+ *   4b. Legacy full summary (sends conversation to LLM for detailed summary)
+ *
+ * Key properties:
+ * - Triggers at effectiveContextWindow - bufferTokens (default 13K)
+ * - Circuit breaker: stops after N consecutive failures
+ * - Produces a CompactBoundaryMessage for boundary tracking
+ * - Post-compact cleanup resets all tracking state
+ * - When context collapse is active, auto-compact is suppressed
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoCompact = void 0;
+const types_1 = require("./types");
+/** Tokens below context window to trigger proactive auto-compact */
+const DEFAULT_AUTOCOMPACT_BUFFER = 13000;
+/** Max consecutive failures before circuit breaker trips */
+const DEFAULT_MAX_CONSECUTIVE_FAILURES = 3;
+/** Default model token limit */
+const DEFAULT_MODEL_TOKEN_LIMIT = 128000;
+class AutoCompact {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f;
+        this.name = 'auto';
+        this.consecutiveFailures = 0;
+        this.options = {
+            bufferTokens: (_a = options === null || options === void 0 ? void 0 : options.bufferTokens) !== null && _a !== void 0 ? _a : DEFAULT_AUTOCOMPACT_BUFFER,
+            maxConsecutiveFailures: (_b = options === null || options === void 0 ? void 0 : options.maxConsecutiveFailures) !== null && _b !== void 0 ? _b : DEFAULT_MAX_CONSECUTIVE_FAILURES,
+            modelTokenLimit: (_c = options === null || options === void 0 ? void 0 : options.modelTokenLimit) !== null && _c !== void 0 ? _c : DEFAULT_MODEL_TOKEN_LIMIT,
+            preserveThreshold: (_d = options === null || options === void 0 ? void 0 : options.preserveThreshold) !== null && _d !== void 0 ? _d : 0.3,
+            llmRole: (_e = options === null || options === void 0 ? void 0 : options.llmRole) !== null && _e !== void 0 ? _e : 'summarizer',
+            enableLogging: (_f = options === null || options === void 0 ? void 0 : options.enableLogging) !== null && _f !== void 0 ? _f : false,
+        };
+    }
+    shouldApply(ctx) {
+        // Don't auto-compact if context collapse is handling it
+        if (ctx.contextCollapseEnabled) {
+            return false;
+        }
+        // Circuit breaker
+        if (this.consecutiveFailures >= this.options.maxConsecutiveFailures) {
+            return false;
+        }
+        // Check threshold
+        const estimator = new types_1.TokenEstimator();
+        const tokenCount = estimator.estimateForMessages(ctx.messages) - (ctx.snipTokensFreed || 0);
+        const threshold = this.options.modelTokenLimit - this.options.bufferTokens;
+        return tokenCount >= threshold;
+    }
+    async apply(ctx) {
+        const messages = ctx.messages;
+        const estimator = new types_1.TokenEstimator();
+        const originalTokens = estimator.estimateForMessages(messages) - (ctx.snipTokensFreed || 0);
+        try {
+            const result = await this.compactConversation(messages, ctx);
+            if (!result) {
+                this.consecutiveFailures++;
+                return ctx;
+            }
+            // Success — reset failure counter
+            this.consecutiveFailures = 0;
+            const newTokens = estimator.estimateForMessages(result);
+            const boundary = {
+                layer: 'auto',
+                tokensFreed: originalTokens - newTokens,
+                messagesRemoved: messages.length - result.length,
+                timestamp: new Date().toISOString(),
+                summaryIncluded: true,
+            };
+            this.tracking = {
+                compacted: true,
+                turnId: `auto-${Date.now()}`,
+                turnCounter: 0,
+                consecutiveFailures: 0,
+            };
+            if (this.options.enableLogging) {
+                console.log(`[AutoCompact] Compacted: ${originalTokens} -> ${newTokens} tokens (${boundary.tokensFreed} freed, ${boundary.messagesRemoved} messages removed)`);
+            }
+            return {
+                ...ctx,
+                messages: result,
+                compactionHistory: [...(ctx.compactionHistory || []), boundary],
+                autoCompactTracking: this.tracking,
+            };
+        }
+        catch (error) {
+            this.consecutiveFailures++;
+            if (this.options.enableLogging) {
+                console.error('[AutoCompact] Compaction failed:', error);
+            }
+            return ctx;
+        }
+    }
+    reset() {
+        this.consecutiveFailures = 0;
+        this.tracking = undefined;
+    }
+    getTracking() {
+        return this.tracking;
+    }
+    getConsecutiveFailures() {
+        return this.consecutiveFailures;
+    }
+    // ─── Core Compaction Logic ────────────────────────────────────────
+    async compactConversation(messages, ctx) {
+        const estimator = new types_1.TokenEstimator();
+        // Find split point: preserve the most recent portion of conversation
+        const splitIndex = this.findSplitIndex(messages);
+        if (splitIndex === 0) {
+            return null; // Nothing to compact
+        }
+        // Separate into history-to-compact and history-to-keep
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const historyToCompress = messages
+            .slice(0, splitIndex)
+            .filter(m => m.role !== 'system');
+        const preservedMessages = messages.slice(splitIndex);
+        if (historyToCompress.length === 0) {
+            return null;
+        }
+        // Generate summary
+        const summary = await this.generateSummary(historyToCompress);
+        if (!summary || summary.trim().length === 0) {
+            return null;
+        }
+        // Build post-compact message array
+        const postCompactMessages = [
+            ...systemMessages,
+            {
+                role: 'user',
+                content: `This session is being continued from a previous conversation that ran out of context. Below is a summary of the conversation so far.\n\n${summary}\n\nPlease continue from where the previous conversation left off. Do not ask the user to re-explain what they already told you — the summary above contains all the context you need.`,
+            },
+            {
+                role: 'assistant',
+                content: 'Understood. I have the summary of the previous conversation and will continue from where we left off.',
+            },
+            ...preservedMessages,
+        ];
+        // Verify compression was effective
+        const newTokens = estimator.estimateForMessages(postCompactMessages);
+        const originalTokens = estimator.estimateForMessages(messages) - (ctx.snipTokensFreed || 0);
+        if (newTokens >= originalTokens) {
+            if (this.options.enableLogging) {
+                console.warn(`[AutoCompact] Summary inflated token count: ${originalTokens} -> ${newTokens}`);
+            }
+            return null;
+        }
+        return postCompactMessages;
+    }
+    findSplitIndex(messages) {
+        var _a;
+        // Find turn boundaries (user messages that aren't tool responses)
+        const turnStarts = [];
+        for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            if (!msg)
+                continue;
+            if (msg.role === 'user' &&
+                !msg.tool_call_id &&
+                !this.isToolResponse(msg)) {
+                turnStarts.push(i);
+            }
+        }
+        if (turnStarts.length <= 3) {
+            return 0; // Too few turns to compress
+        }
+        // Keep the last preserveThreshold fraction of turns
+        const turnsToKeep = Math.max(3, Math.ceil(turnStarts.length * this.options.preserveThreshold));
+        const turnsToRemove = turnStarts.length - turnsToKeep;
+        if (turnsToRemove <= 0) {
+            return 0;
+        }
+        // Adjust to avoid splitting in the middle of a tool-response chain
+        let splitIndex = (_a = turnStarts[turnsToRemove]) !== null && _a !== void 0 ? _a : messages.length;
+        // Walk forward to skip tool responses that belong to the previous turn
+        while (splitIndex < messages.length) {
+            const msg = messages[splitIndex];
+            if (!msg)
+                break;
+            if (msg.role === 'tool' || msg.tool_call_id) {
+                splitIndex++;
+                continue;
+            }
+            break;
+        }
+        return splitIndex;
+    }
+    async generateSummary(messages) {
+        var _a, _b, _c, _d, _e;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const codebolt = require('@codebolt/codeboltjs');
+            // Build compression prompt
+            const historyText = messages
+                .map((msg, i) => {
+                var _a;
+                const content = typeof msg.content === 'string'
+                    ? msg.content
+                    : JSON.stringify((_a = msg.content) !== null && _a !== void 0 ? _a : '');
+                // Truncate very long messages for the prompt
+                const truncated = content.length > 2000
+                    ? content.slice(0, 1000) +
+                        `\n...[${content.length - 2000} chars truncated]...\n` +
+                        content.slice(-1000)
+                    : content;
+                return `[${i + 1}] ${msg.role}: ${truncated}`;
+            })
+                .join('\n\n');
+            const prompt = `You are a conversation compression assistant. Create a detailed, structured summary that preserves ALL critical context so work can continue seamlessly.
+
+CONVERSATION HISTORY TO COMPRESS:
+${historyText}
+
+Generate the summary with ALL of the following sections:
+
+<summary>
+1. PRIMARY REQUEST
+[The user's original, complete request]
+
+2. TASK EVOLUTION
+[How the task evolved. Include key user instructions that changed direction]
+
+3. KEY TECHNICAL CONCEPTS
+[Architecture decisions, design patterns, algorithms, data structures, API contracts]
+
+4. FILES AND CODE
+[Every file that was read, created, or modified. Include file paths and key changes]
+
+5. PROBLEM SOLVING
+[Errors encountered and solutions applied]
+
+6. PENDING TASKS
+[Tasks mentioned but NOT yet completed]
+
+7. CURRENT WORK STATE
+[Exactly where the work left off]
+
+8. NEXT STEP
+[The most logical next action]
+</summary>
+
+CRITICAL RULES:
+- Preserve ALL file paths exactly
+- Preserve ALL code snippets, function names, error messages verbatim
+- Include the FULL original user request, not a paraphrase
+- Do not summarize away technical details
+- Focus on facts and specifics`;
+            const response = await codebolt.llm.inference({
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are a precise conversation compression assistant. Be comprehensive but concise.',
+                    },
+                    { role: 'user', content: prompt },
+                ],
+            });
+            // Extract summary from response
+            let summary;
+            if (typeof ((_a = response === null || response === void 0 ? void 0 : response.completion) === null || _a === void 0 ? void 0 : _a.content) === 'string') {
+                summary = response.completion.content;
+            }
+            else if ((_e = (_d = (_c = (_b = response === null || response === void 0 ? void 0 : response.completion) === null || _b === void 0 ? void 0 : _b.choices) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.message) === null || _e === void 0 ? void 0 : _e.content) {
+                summary = response.completion.choices[0].message.content;
+            }
+            if (summary && summary.trim().length > 0) {
+                return summary.trim();
+            }
+            return '';
+        }
+        catch (error) {
+            console.error('[AutoCompact] Error generating summary:', error);
+            return '';
+        }
+    }
+    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.AutoCompact = AutoCompact;