@codebolt/agent 6.0.0 → 6.1.2

package/dist/processor-pieces/preInferenceProcessors/chatCompressionModifier.js

@@ -51,19 +51,8 @@ function isFunctionResponse(message) {
     }
     return false;
 }
-// Mock token limit for different models (should be replaced with actual implementation)
-function tokenLimit(model) {
-    // Default token limits for common models
-    if (model.includes('gemini-pro'))
-        return 30720;
-    if (model.includes('gemini-flash'))
-        return 1048576;
-    if (model.includes('gpt-4'))
-        return 8192;
-    if (model.includes('gpt-3.5'))
-        return 4096;
-    return 8192; // Default fallback
-}
+/** Default model token limit when none is configured */
+const DEFAULT_MODEL_TOKEN_LIMIT = 128000;
 class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
     constructor(options = {}) {
         super();
@@ -71,11 +60,50 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
         this.options = {
             contextPercentageThreshold: options.contextPercentageThreshold || COMPRESSION_TOKEN_THRESHOLD,
             enableCompression: options.enableCompression !== false,
-            force: options.force || false
+            force: options.force || false,
+            modelTokenLimit: options.modelTokenLimit || DEFAULT_MODEL_TOKEN_LIMIT
+        };
+    }
+    buildCompressionMetadata(compressionInfo, stage) {
+        var _a;
+        return {
+            status: (_a = CompressionStatus[compressionInfo.compressionStatus]) !== null && _a !== void 0 ? _a : 'NOOP',
+            stage,
+            originalTokenCount: compressionInfo.originalTokenCount,
+            newTokenCount: compressionInfo.newTokenCount,
+            timestamp: new Date().toISOString(),
+            strategy: 'summarize',
+            failedAttempts: this.hasFailedCompressionAttempt ? 1 : 0,
         };
     }
     async modify(_originalRequest, createdMessage) {
+        var _a, _b, _c;
         try {
+            // Check if ConversationCompactorModifier already compressed in the previous iteration.
+            // If so, skip re-compression unless token count has grown past the threshold again.
+            const compressionMeta = (_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a['compression'];
+            if ((compressionMeta === null || compressionMeta === void 0 ? void 0 : compressionMeta.status) === 'COMPRESSED' &&
+                compressionMeta.stage !== 'reactive_force_compact') {
+                const modelTokenLimit = this.options.modelTokenLimit || DEFAULT_MODEL_TOKEN_LIMIT;
+                const threshold = ((_b = this.options.contextPercentageThreshold) !== null && _b !== void 0 ? _b : COMPRESSION_TOKEN_THRESHOLD) * modelTokenLimit;
+                const currentTokens = (_c = compressionMeta.newTokenCount) !== null && _c !== void 0 ? _c : 0;
+                if (currentTokens < threshold) {
+                    // Already compressed and still under threshold — skip
+                    return {
+                        ...createdMessage,
+                        metadata: {
+                            ...createdMessage.metadata,
+                            compression: this.buildCompressionMetadata({
+                                originalTokenCount: currentTokens,
+                                newTokenCount: currentTokens,
+                                compressionStatus: CompressionStatus.NOOP,
+                            }, 'pre_inference'),
+                            chatCompressionSkipped: true,
+                            chatCompressionSkipReason: 'Already compressed by ConversationCompactorModifier'
+                        }
+                    };
+                }
+            }
             const compressionResult = await this.tryCompressChat(createdMessage.message.messages, this.options.force || false);
             if (compressionResult.compressionStatus === CompressionStatus.COMPRESSED) {
                 return {
@@ -85,10 +113,8 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
                     },
                     metadata: {
                         ...createdMessage.metadata,
+                        compression: this.buildCompressionMetadata(compressionResult, 'pre_inference'),
                         chatCompressed: true,
-                        originalTokenCount: compressionResult.originalTokenCount,
-                        newTokenCount: compressionResult.newTokenCount,
-                        compressionStatus: compressionResult.compressionStatus
                     }
                 };
             }
@@ -96,9 +122,7 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
                 ...createdMessage,
                 metadata: {
                     ...createdMessage.metadata,
-                    compressionStatus: compressionResult.compressionStatus,
-                    originalTokenCount: compressionResult.originalTokenCount,
-                    newTokenCount: compressionResult.newTokenCount
+                    compression: this.buildCompressionMetadata(compressionResult, 'pre_inference'),
                 }
             };
         }
@@ -119,11 +143,10 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
                 compressionStatus: CompressionStatus.NOOP,
             };
         }
-        // Mock model - should be replaced with actual model detection
-        const model = "gemini-pro";
-        const originalTokenCount = await this.countTokens(model, curatedHistory);
+        const modelTokenLimit = this.options.modelTokenLimit || DEFAULT_MODEL_TOKEN_LIMIT;
+        const originalTokenCount = await this.countTokens(curatedHistory);
         if (originalTokenCount === undefined) {
-            console.warn(`Could not determine token count for model ${model}.`);
+            console.warn(`Could not determine token count.`);
             this.hasFailedCompressionAttempt = !force && true;
             return {
                 originalTokenCount: 0,
@@ -135,7 +158,7 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
         // Don't compress if not forced and we are under the limit.
         if (!force) {
             const threshold = contextPercentageThreshold !== null && contextPercentageThreshold !== void 0 ? contextPercentageThreshold : COMPRESSION_TOKEN_THRESHOLD;
-            if (originalTokenCount < threshold * tokenLimit(model)) {
+            if (originalTokenCount < threshold * modelTokenLimit) {
                 return {
                     originalTokenCount,
                     newTokenCount: originalTokenCount,
@@ -168,7 +191,7 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
             },
             ...historyToKeep,
         ];
-        const newTokenCount = await this.countTokens(model, compressedMessages);
+        const newTokenCount = await this.countTokens(compressedMessages);
         if (newTokenCount === undefined) {
             console.warn('Could not determine compressed history token count.');
             this.hasFailedCompressionAttempt = !force && true;
@@ -193,7 +216,7 @@ class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
             compressedMessages,
         };
     }
-    async countTokens(_model, messages) {
+    async countTokens(messages) {
         // Mock token counting - should be replaced with actual API call
         // Rough approximation: 4 characters per token
         const totalCharacters = messages.reduce((sum, msg) => {

package/dist/unified/agent/agent.d.ts

@@ -8,10 +8,20 @@ export declare class Agent implements AgentInterface {
     private readonly preToolCallProcessors;
     private readonly postToolCallProcessors;
     private readonly enableLogging;
+    private readonly compactionOrchestrator;
+    private readonly loopDetectionService;
+    private readonly maxTurns;
     constructor(config: AgentConfig);
     execute(reqMessage: FlatUserMessage): Promise<{
         success: boolean;
         result: any;
         error?: string;
     }>;
+    private applyCompaction;
+    private tryRecoverPrompt;
+    private refreshAvailableTools;
+    private mergeTools;
+    private getAllowedToolNames;
+    private getRecoverableResponseError;
+    private collectResponseMessages;
 }

package/dist/unified/agent/agent.js

@@ -1,12 +1,19 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
 const base_1 = require("../base");
-const responseExecutor_1 = require("../base/responseExecutor");
 const agentStep_1 = require("../base/agentStep");
+const responseExecutor_1 = require("../base/responseExecutor");
+const promptContext_1 = require("../base/promptContext");
+const compactionOrchestrator_1 = require("../services/compaction/compactionOrchestrator");
 class Agent {
     constructor(config) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
+        const runtimeConfig = config;
         this.config = { ...config };
         this.messageModifiers = ((_a = config.processors) === null || _a === void 0 ? void 0 : _a.messageModifiers) || [];
         this.preInferenceProcessors = ((_b = config.processors) === null || _b === void 0 ? void 0 : _b.preInferenceProcessors) || [];
@@ -14,6 +21,9 @@ class Agent {
         this.preToolCallProcessors = ((_d = config.processors) === null || _d === void 0 ? void 0 : _d.preToolCallProcessors) || [];
         this.postToolCallProcessors = ((_e = config.processors) === null || _e === void 0 ? void 0 : _e.postToolCallProcessors) || [];
         this.enableLogging = config.enableLogging !== false;
+        this.compactionOrchestrator = new compactionOrchestrator_1.CompactionOrchestrator(runtimeConfig.compaction || {});
+        this.loopDetectionService = runtimeConfig.loopDetectionService;
+        this.maxTurns = (_f = runtimeConfig.maxTurns) !== null && _f !== void 0 ? _f : 25;
     }
     async execute(reqMessage) {
         if (!reqMessage) {
@@ -31,19 +41,51 @@ class Agent {
             });
             let prompt = await promptGenerator.processMessage(reqMessage);
             let completed = false;
+            let turnNumber = 0;
             while (!completed) {
+                turnNumber += 1;
+                if (turnNumber > this.maxTurns) {
+                    throw new Error(`Agent exceeded the maximum turn limit of ${this.maxTurns}.`);
+                }
+                this.compactionOrchestrator.resetForTurn();
+                prompt = await this.applyCompaction(prompt);
+                prompt = await this.refreshAvailableTools(reqMessage, prompt);
                 const agentStep = new agentStep_1.AgentStep({
                     preInferenceProcessors: this.preInferenceProcessors,
                     postInferenceProcessors: this.postInferenceProcessors
                 });
-                const stepResult = await agentStep.executeStep(reqMessage, prompt);
-                prompt = stepResult.nextMessage;
-                if (this.enableLogging) {
-                    // console.log('[Agent] Step completed, processing response');
+                let stepResult;
+                while (!stepResult) {
+                    try {
+                        const nextStepResult = await agentStep.executeStep(reqMessage, prompt);
+                        const recoverableResponseError = this.getRecoverableResponseError(nextStepResult.rawLLMResponse);
+                        if (!recoverableResponseError) {
+                            stepResult = nextStepResult;
+                            break;
+                        }
+                        const recoveredPrompt = await this.tryRecoverPrompt(prompt, new Error(recoverableResponseError));
+                        if (!recoveredPrompt) {
+                            throw new Error(recoverableResponseError);
+                        }
+                        prompt = recoveredPrompt;
+                    }
+                    catch (error) {
+                        const recoveredPrompt = await this.tryRecoverPrompt(prompt, error);
+                        if (!recoveredPrompt) {
+                            throw error;
+                        }
+                        prompt = recoveredPrompt;
+                    }
+                }
+                if (!stepResult) {
+                    throw new Error('Agent step did not produce a response.');
                 }
                 const responseExecutor = new responseExecutor_1.ResponseExecutor({
                     preToolCallProcessors: this.preToolCallProcessors,
-                    postToolCallProcessors: this.postToolCallProcessors
+                    postToolCallProcessors: this.postToolCallProcessors,
+                    ...(this.loopDetectionService
+                        ? { loopDetectionService: this.loopDetectionService }
+                        : {}),
                 });
                 const executionResult = await responseExecutor.executeResponse({
                     initialUserMessage: reqMessage,
@@ -54,9 +96,6 @@ class Agent {
                 completed = executionResult.completed;
                 prompt = executionResult.nextMessage;
             }
-            if (this.enableLogging) {
-                // console.log('[Agent] Execution completed successfully');
-            }
             return {
                 success: true,
                 result: prompt
@@ -74,5 +113,154 @@ class Agent {
             };
         }
     }
+    async applyCompaction(prompt) {
+        const result = await this.compactionOrchestrator.compact((0, promptContext_1.getTranscriptMessages)(prompt));
+        if (!result.wasCompacted) {
+            return prompt;
+        }
+        return {
+            ...(0, promptContext_1.replaceTranscriptMessages)(prompt, result.messages),
+            metadata: {
+                ...prompt.metadata,
+                compaction: {
+                    totalTokensFreed: result.totalTokensFreed,
+                    layersApplied: result.layersApplied,
+                    boundaries: result.boundaries,
+                    timestamp: new Date().toISOString(),
+                },
+            },
+        };
+    }
+    async tryRecoverPrompt(prompt, error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (!this.compactionOrchestrator.getReactiveLayer().isRecoverableError(errorMessage)) {
+            return null;
+        }
+        const recovery = await this.compactionOrchestrator.recoverFromError((0, promptContext_1.getTranscriptMessages)(prompt), error);
+        if (!recovery.wasCompacted) {
+            return null;
+        }
+        return {
+            ...(0, promptContext_1.replaceTranscriptMessages)(prompt, recovery.messages),
+            metadata: {
+                ...prompt.metadata,
+                reactiveCompaction: {
+                    totalTokensFreed: recovery.totalTokensFreed,
+                    layersApplied: recovery.layersApplied,
+                    boundaries: recovery.boundaries,
+                    timestamp: new Date().toISOString(),
+                    error: errorMessage,
+                },
+            },
+        };
+    }
+    async refreshAvailableTools(originalRequest, prompt) {
+        var _a, _b, _c, _d;
+        if (((_a = prompt.metadata) === null || _a === void 0 ? void 0 : _a['toolsInjected']) !== true ||
+            ((_b = prompt.metadata) === null || _b === void 0 ? void 0 : _b['toolsLocation']) !== 'Tool') {
+            return prompt;
+        }
+        const existingTools = Array.isArray(prompt.message.tools)
+            ? prompt.message.tools
+            : [];
+        try {
+            const toolsResponse = await codeboltjs_1.default.mcp.listMcpFromServers(['codebolt']);
+            let refreshedTools = ((_c = toolsResponse === null || toolsResponse === void 0 ? void 0 : toolsResponse.data) === null || _c === void 0 ? void 0 : _c.tools) || (toolsResponse === null || toolsResponse === void 0 ? void 0 : toolsResponse.data) || [];
+            const mentionedMCPs = Array.isArray(originalRequest.mentionedMCPs)
+                ? originalRequest.mentionedMCPs
+                : [];
+            if (mentionedMCPs.length > 0) {
+                const { data: mentionedTools } = await codeboltjs_1.default.mcp.getTools(mentionedMCPs);
+                refreshedTools = [...refreshedTools, ...(mentionedTools || [])];
+            }
+            const allowedToolNames = this.getAllowedToolNames(prompt);
+            if (allowedToolNames && allowedToolNames.length > 0) {
+                const allowed = new Set(allowedToolNames);
+                refreshedTools = refreshedTools.filter((tool) => { var _a; return !!((_a = tool.function) === null || _a === void 0 ? void 0 : _a.name) && allowed.has(tool.function.name); });
+            }
+            const mergedTools = this.mergeTools(existingTools, refreshedTools);
+            return {
+                ...prompt,
+                message: {
+                    ...prompt.message,
+                    tools: mergedTools,
+                    ...(mergedTools.length > 0
+                        ? { tool_choice: (_d = prompt.message.tool_choice) !== null && _d !== void 0 ? _d : 'auto' }
+                        : {}),
+                },
+                metadata: {
+                    ...prompt.metadata,
+                    toolsCount: mergedTools.length,
+                    toolsRefreshedAt: new Date().toISOString(),
+                },
+            };
+        }
+        catch (error) {
+            if (this.enableLogging) {
+                console.error('[Agent] Failed to refresh tools:', error);
+            }
+            return prompt;
+        }
+    }
+    mergeTools(existingTools, refreshedTools) {
+        var _a, _b;
+        const mergedTools = new Map();
+        for (const tool of refreshedTools) {
+            const toolName = (_a = tool.function) === null || _a === void 0 ? void 0 : _a.name;
+            if (toolName) {
+                mergedTools.set(toolName, tool);
+            }
+        }
+        for (const tool of existingTools) {
+            const toolName = (_b = tool.function) === null || _b === void 0 ? void 0 : _b.name;
+            if (toolName && !mergedTools.has(toolName)) {
+                mergedTools.set(toolName, tool);
+            }
+        }
+        return Array.from(mergedTools.values());
+    }
+    getAllowedToolNames(prompt) {
+        var _a;
+        const metadataAllowedTools = (_a = prompt.metadata) === null || _a === void 0 ? void 0 : _a['allowedTools'];
+        if (!Array.isArray(metadataAllowedTools)) {
+            return undefined;
+        }
+        const allowedToolNames = metadataAllowedTools.filter((toolName) => typeof toolName === 'string' && toolName.length > 0);
+        return allowedToolNames.length > 0 ? allowedToolNames : undefined;
+    }
+    getRecoverableResponseError(response) {
+        var _a, _b, _c, _d;
+        const reactiveLayer = this.compactionOrchestrator.getReactiveLayer();
+        const candidateMessages = this.collectResponseMessages(response);
+        const recoverableMessage = candidateMessages.find((message) => reactiveLayer.isRecoverableError(message));
+        if (recoverableMessage) {
+            return recoverableMessage;
+        }
+        const finishReasons = [
+            response.finish_reason,
+            ...((_a = response.choices) !== null && _a !== void 0 ? _a : []).map((choice) => choice.finish_reason),
+        ].filter((reason) => typeof reason === 'string');
+        const hasLengthFinishReason = finishReasons.some((reason) => reason.toLowerCase() === 'length');
+        const hasToolCalls = ((_c = (_b = response.tool_calls) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > 0 ||
+            ((_d = response.choices) !== null && _d !== void 0 ? _d : []).some((choice) => { var _a, _b, _c; return ((_c = (_b = (_a = choice.message) === null || _a === void 0 ? void 0 : _a.tool_calls) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) > 0; });
+        if (hasLengthFinishReason && candidateMessages.length === 0 && !hasToolCalls) {
+            return 'Too many tokens or token limit reached before producing usable output.';
+        }
+        return null;
+    }
+    collectResponseMessages(response) {
+        var _a, _b;
+        const messages = [];
+        if (typeof response.content === 'string' && response.content.trim().length > 0) {
+            messages.push(response.content.trim());
+        }
+        for (const choice of (_a = response.choices) !== null && _a !== void 0 ? _a : []) {
+            if (typeof ((_b = choice.message) === null || _b === void 0 ? void 0 : _b.content) === 'string' &&
+                choice.message.content.trim().length > 0) {
+                messages.push(choice.message.content.trim());
+            }
+        }
+        return messages;
+    }
 }
 exports.Agent = Agent;

package/dist/unified/agent/codeboltAgent.d.ts

@@ -1,77 +1,15 @@
 import { AgentConfig, MessageModifier, PostInferenceProcessor, PostToolCallProcessor, PreInferenceProcessor, PreToolCallProcessor, ProcessedMessage } from "@codebolt/types/agent";
 import { FlatUserMessage } from "@codebolt/types/sdk";
-/**
- * Configuration options for CodeboltAgent
- */
+import { LoopDetectionService } from "../services/LoopDetectionService";
+import type { CompactionOrchestratorOptions } from "../services/compaction/types";
 export interface CodeboltAgentConfig extends AgentConfig {
-    /**
-     * Enable logging for debugging purposes.
-     * Defaults to true.
-     */
     enableLogging?: boolean;
-    /**
-     * Agent context to continue from.
-     * When provided, the agent will skip initial prompt generation
-     * and continue from where the previous agent left off.
-     */
     context?: ProcessedMessage;
-    /**
-     * List of allowed tool names. If provided, only these tools will be available to the agent.
-     * If not provided, all tools will be available.
-     * Example: ['readFile', 'writeFile', 'executeCommand']
-     */
     allowedTools?: string[];
+    compaction?: CompactionOrchestratorOptions;
+    loopDetectionService?: LoopDetectionService;
+    maxTurns?: number;
 }
-/**
- * CodeboltAgent is a high-level agent class that:
- * - Uses InitialPromptGenerator with configurable processors/modifiers
- * - Runs an agent loop with AgentStep and ResponseExecutor
- * - Handles tool execution and conversation flow automatically
- * - Is triggered via processMessage (not via onMessage listener)
- *
- * @example
- * ```typescript
- * import { CodeboltAgent } from '@codebolt/agent/unified';
- * import {
- *     EnvironmentContextModifier,
- *     CoreSystemPromptModifier,
- *     DirectoryContextModifier,
- *     IdeContextModifier,
- *     AtFileProcessorModifier,
- *     ToolInjectionModifier,
- *     ChatHistoryMessageModifier
- * } from '@codebolt/agent/processor-pieces';
- *
- * const systemPrompt = `You are an AI coding assistant...`;
- *
- * const agent = new CodeboltAgent({
- *     instructions: systemPrompt,
- *     processors: {
- *         messageModifiers: [
- *             new ChatHistoryMessageModifier({ enableChatHistory: true }),
- *             new EnvironmentContextModifier({ enableFullContext: true }),
- *             new DirectoryContextModifier(),
- *             new IdeContextModifier({
- *                 includeActiveFile: true,
- *                 includeOpenFiles: true,
- *                 includeCursorPosition: true,
- *                 includeSelectedText: true
- *             }),
- *             new CoreSystemPromptModifier({ customSystemPrompt: systemPrompt }),
- *             new ToolInjectionModifier({ includeToolDescriptions: true }),
- *             new AtFileProcessorModifier({ enableRecursiveSearch: true })
- *         ],
- *         preInferenceProcessors: [],
- *         postInferenceProcessors: [],
- *         preToolCallProcessors: [],
- *         postToolCallProcessors: []
- *     }
- * });
- *
- * // Process a message (triggered from graph node)
- * const result = await agent.processMessage(userMessage);
- * ```
- */
 export declare class CodeboltAgent {
     private readonly config;
     private readonly messageModifiers;
@@ -83,55 +21,33 @@ export declare class CodeboltAgent {
     private readonly baseSystemPrompt;
     private readonly context;
     private readonly allowedTools;
+    private readonly compactionOrchestrator;
+    private readonly loopDetectionService;
+    private readonly maxTurns;
     constructor(config: CodeboltAgentConfig);
-    /**
-     * Creates default message modifiers when none are provided
-     */
     private createDefaultMessageModifiers;
-    /**
-     * Creates a default FlatUserMessage from a string
-     */
     private createDefaultUserMessage;
-    /**
-     * Process a message through the agent pipeline.
-     * This is the main entry point - triggered from graph nodes.
-     * @param message - Either a string message or a FlatUserMessage object
-     * @param context - Optional context from a previous agent to continue from
-     */
     processMessage(message: string | FlatUserMessage, context?: ProcessedMessage): Promise<{
         success: boolean;
         result: any;
         context: ProcessedMessage | null;
+        finalMessage?: string;
         error?: string;
     }>;
-    /**
-     * Get the current configuration
-     */
     getConfig(): CodeboltAgentConfig;
-    /**
-     * Get all message modifiers
-     */
     getMessageModifiers(): MessageModifier[];
-    /**
-     * Get all pre-inference processors
-     */
     getPreInferenceProcessors(): PreInferenceProcessor[];
-    /**
-     * Get all post-inference processors
-     */
     getPostInferenceProcessors(): PostInferenceProcessor[];
-    /**
-     * Get all pre-tool-call processors
-     */
     getPreToolCallProcessors(): PreToolCallProcessor[];
-    /**
-     * Get all post-tool-call processors
-     */
     getPostToolCallProcessors(): PostToolCallProcessor[];
+    private applyCompaction;
+    private tryRecoverPrompt;
+    private refreshAvailableTools;
+    private mergeTools;
+    private getAllowedToolNames;
+    private getRecoverableResponseError;
+    private collectResponseMessages;
 }
-/**
- * Factory function to create a CodeboltAgent with common defaults
- */
 export declare function createCodeboltAgent(options: {
     systemPrompt: string;
     messageModifiers?: MessageModifier[];
@@ -140,4 +56,7 @@ export declare function createCodeboltAgent(options: {
     preToolCallProcessors?: PreToolCallProcessor[];
     postToolCallProcessors?: PostToolCallProcessor[];
     enableLogging?: boolean;
+    compaction?: CompactionOrchestratorOptions;
+    loopDetectionService?: LoopDetectionService;
+    maxTurns?: number;
 }): CodeboltAgent;