@codebolt/agent 5.0.9 → 6.0.1

package/dist/unified/index.d.ts

@@ -15,9 +15,18 @@ export { InitialPromptGenerator } from './base/initialPromptGenerator';
 export { AgentStep } from './base/agentStep';
 export { ResponseExecutor } from './base/responseExecutor';
 export { LoopDetectionService, LoopType } from './services/LoopDetectionService';
+export { CompressionCoordinator, type CompressionCoordinatorOptions, type CompressionDecision, type CompressionMetadata, type CompressionRecoveryResult, type CompressionStage, } from './services/CompressionCoordinator';
 export { Agent } from './agent/agent';
 export { CodeboltAgent, createCodeboltAgent, type CodeboltAgentConfig } from './agent/codeboltAgent';
 export { Tool, createTool } from './agent/tools';
 export { Workflow } from './agent/workflow';
 export { type OpenAIMessage, type OpenAITool, type ToolResult, type CodeboltAPI, type AgentExecutionResult, type StreamChunk, type StreamCallback } from './types/libTypes';
 export { type LLMConfig } from './types/libTypes';
+export { CompactionOrchestrator, type CompactionPipelineResult, } from './services/compaction/compactionOrchestrator';
+export { SnipCompact, type SnipCompactOptions } from './services/compaction/snipCompact';
+export { MicroCompact, type MicroCompactOptions } from './services/compaction/microCompact';
+export { ContextCollapse, type ContextCollapseOptions } from './services/compaction/contextCollapse';
+export { AutoCompact, type AutoCompactOptions, type AutoCompactTracking } from './services/compaction/autoCompact';
+export { ReactiveCompact, type ReactiveCompactOptions, type ReactiveRecoveryResult } from './services/compaction/reactiveCompact';
+export { PostCompactCleanup, type PostCompactCleanupOptions } from './services/compaction/postCompactCleanup';
+export { TokenEstimator, type CompactionContext, type CompactionLayer, type CompactionLayerKind, type CompactionBoundary, type CompactionOrchestratorOptions, } from './services/compaction/types';

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;
+}