@defai.digital/ax-cli 3.8.6 → 3.8.8

package/dist/agent/llm-agent.d.ts

@@ -40,6 +40,16 @@ export interface StreamingChunk {
     /** Tool execution duration in milliseconds (for tool_result type) */
     executionDurationMs?: number;
 }
+/**
+ * Accumulated message from streaming response
+ * Contains the full message content and any tool calls
+ */
+export interface AccumulatedMessage {
+    role?: string;
+    content?: string;
+    tool_calls?: LLMToolCall[];
+    [key: string]: unknown;
+}
 export declare class LLMAgent extends EventEmitter {
     private llmClient;
     private textEditor;
@@ -47,7 +57,6 @@ export declare class LLMAgent extends EventEmitter {
     private bashOutput;
     private todoTool;
     private search;
-    private webSearch;
     private _architectureTool?;
     private _validationTool?;
     private chatHistory;
@@ -68,6 +77,8 @@ export declare class LLMAgent extends EventEmitter {
     private samplingConfig;
     /** Thinking/reasoning mode configuration */
     private thinkingConfig;
+    /** Stored reference to context overflow listener for proper cleanup */
+    private contextOverflowListener;
     /** Track if agent has been disposed */
     private disposed;
     /** Tool approval system for VSCode integration */
@@ -160,13 +171,23 @@ export declare class LLMAgent extends EventEmitter {
     private get validationTool();
     /**
      * Detect if a tool call is repetitive (likely causing a loop)
-     * Returns true if the same tool with similar arguments was called multiple times recently
+     * Uses the intelligent LoopDetector which provides:
+     * - Tool-specific thresholds (file ops get higher limits)
+     * - Progress-based detection (tracks success/failure)
+     * - Cycle pattern detection (A→B→A→B loops)
      */
     private isRepetitiveToolCall;
+    /** Last loop detection result for error messages */
+    private lastLoopResult?;
     /**
      * Reset the tool call tracking (called at start of new user message)
      */
     private resetToolCallTracking;
+    /**
+     * Generate a helpful warning message when a loop is detected
+     * Uses the lastLoopResult for context-aware suggestions
+     */
+    private getLoopWarningMessage;
     /**
      * Check if a request should trigger multi-phase planning
      */

package/dist/agent/llm-agent.js

@@ -3,11 +3,10 @@ import { getAllGrokTools, getMCPManager, initializeMCPServers, } from "../llm/to
 import { loadMCPConfig } from "../mcp/config.js";
 import { TextEditorTool, BashTool, TodoTool, SearchTool, } from "../tools/index.js";
 import { BashOutputTool } from "../tools/bash-output.js";
-import { WebSearchTool } from "../tools/web-search/index.js";
 import { ArchitectureTool } from "../tools/analysis-tools/architecture-tool.js";
 import { ValidationTool } from "../tools/analysis-tools/validation-tool.js";
 import { EventEmitter } from "events";
-import { AGENT_CONFIG } from "../constants.js";
+import { AGENT_CONFIG, CACHE_CONFIG } from "../constants.js";
 import { getTokenCounter } from "../utils/token-counter.js";
 import { loadCustomInstructions } from "../utils/custom-instructions.js";
 import { getSettingsManager } from "../utils/settings-manager.js";
@@ -22,6 +21,7 @@ import { PLANNER_CONFIG } from "../constants.js";
 import { resolveMCPReferences, extractMCPReferences } from "../mcp/resources.js";
 import { SDKError, SDKErrorCode } from "../sdk/errors.js";
 import { getStatusReporter } from "./status-reporter.js";
+import { getLoopDetector, resetLoopDetector } from "./loop-detector.js";
 export class LLMAgent extends EventEmitter {
     llmClient;
     textEditor;
@@ -29,7 +29,6 @@ export class LLMAgent extends EventEmitter {
     bashOutput;
     todoTool;
     search;
-    webSearch;
     // Lazy-loaded tools (rarely used)
     _architectureTool;
     _validationTool;
@@ -51,6 +50,8 @@ export class LLMAgent extends EventEmitter {
     samplingConfig;
     /** Thinking/reasoning mode configuration */
     thinkingConfig;
+    /** Stored reference to context overflow listener for proper cleanup */
+    contextOverflowListener;
     /** Track if agent has been disposed */
     disposed = false;
     /** Tool approval system for VSCode integration */
@@ -73,7 +74,6 @@ export class LLMAgent extends EventEmitter {
         this.bashOutput = new BashOutputTool();
         this.todoTool = new TodoTool();
         this.search = new SearchTool();
-        this.webSearch = new WebSearchTool();
         // architectureTool and validationTool are lazy-loaded (see getters below)
         this.tokenCounter = getTokenCounter(modelToUse);
         this.contextManager = new ContextManager({ model: modelToUse });
@@ -88,6 +88,9 @@ export class LLMAgent extends EventEmitter {
         this.textEditor.setCheckpointCallback(async (files, description) => {
             // Create immutable snapshot of chat history at callback time
             // This prevents inconsistencies if messages are added during checkpoint creation
+            // BUG FIX: Check if agent is disposed before creating checkpoint
+            if (this.disposed)
+                return;
             const chatHistorySnapshot = JSON.parse(JSON.stringify(this.chatHistory));
             await this.checkpointManager.createCheckpoint({
                 files,
@@ -125,14 +128,19 @@ export class LLMAgent extends EventEmitter {
         // NEW: Listen for context pruning to generate summaries
         // CRITICAL FIX: Wrap async callback to prevent uncaught promise rejections
         // Event listeners don't handle async errors automatically, so we must catch them
-        this.contextManager.on('before_prune', (data) => {
+        // Store listener reference for proper cleanup in dispose()
+        this.contextOverflowListener = (data) => {
+            // Skip if agent is disposed to prevent operations on disposed resources
+            if (this.disposed)
+                return;
             this.handleContextOverflow(data).catch((error) => {
                 const errorMsg = extractErrorMessage(error);
                 console.error('Error handling context overflow:', errorMsg);
                 // Emit error event for monitoring
                 this.emit('error', error);
             });
-        });
+        };
+        this.contextManager.on('before_prune', this.contextOverflowListener);
     }
     initializeCheckpointManager() {
         // Initialize checkpoint manager in the background
@@ -254,6 +262,10 @@ export class LLMAgent extends EventEmitter {
      * @returns Promise<boolean> - true if approved, false if rejected or timeout
      */
     waitForToolApproval(toolCall) {
+        // If agent is already disposed, immediately reject approval wait to avoid dangling promises
+        if (this.disposed) {
+            return Promise.resolve(false);
+        }
         return new Promise((resolve) => {
             // Emit event so external integrations can show diff preview
             this.emit('tool:approval_required', toolCall);
@@ -331,12 +343,11 @@ export class LLMAgent extends EventEmitter {
         }
         // CRITICAL FIX: Add hard limit for messages array as safety backstop
         // In case contextManager.shouldPrune() always returns false
-        const MAX_MESSAGES = 500;
-        if (this.messages.length > MAX_MESSAGES) {
+        if (this.messages.length > AGENT_CONFIG.MAX_MESSAGES) {
             // Keep system message (if exists) + last N messages
             const systemMessages = this.messages.filter(m => m.role === 'system');
             const nonSystemMessages = this.messages.filter(m => m.role !== 'system');
-            const keepMessages = Math.min(nonSystemMessages.length, MAX_MESSAGES - systemMessages.length);
+            const keepMessages = Math.min(nonSystemMessages.length, AGENT_CONFIG.MAX_MESSAGES - systemMessages.length);
             this.messages = [
                 ...systemMessages,
                 ...nonSystemMessages.slice(-keepMessages)
@@ -363,16 +374,14 @@ export class LLMAgent extends EventEmitter {
             const args = JSON.parse(toolCall.function.arguments || '{}');
             this.toolCallArgsCache.set(toolCall.id, args);
             // CRITICAL FIX: Prevent unbounded memory growth with proper cache eviction
-            // When cache exceeds limit, reduce to 80% capacity (not just remove 100 entries)
-            if (this.toolCallArgsCache.size > 500) {
-                const targetSize = 400; // 80% of max capacity
+            // When cache exceeds limit, reduce to 80% capacity (not just remove fixed entries)
+            if (this.toolCallArgsCache.size > CACHE_CONFIG.TOOL_ARGS_CACHE_MAX_SIZE) {
+                const targetSize = Math.floor(CACHE_CONFIG.TOOL_ARGS_CACHE_MAX_SIZE * 0.8);
                 const toRemove = this.toolCallArgsCache.size - targetSize;
-                let deleted = 0;
-                for (const key of this.toolCallArgsCache.keys()) {
+                // BUG FIX: Don't modify Map while iterating - create array of keys first
+                const keysToDelete = Array.from(this.toolCallArgsCache.keys()).slice(0, toRemove);
+                for (const key of keysToDelete) {
                     this.toolCallArgsCache.delete(key);
-                    deleted++;
-                    if (deleted >= toRemove)
-                        break;
                 }
             }
             return args;
@@ -404,102 +413,87 @@ export class LLMAgent extends EventEmitter {
     }
     /**
      * Detect if a tool call is repetitive (likely causing a loop)
-     * Returns true if the same tool with similar arguments was called multiple times recently
+     * Uses the intelligent LoopDetector which provides:
+     * - Tool-specific thresholds (file ops get higher limits)
+     * - Progress-based detection (tracks success/failure)
+     * - Cycle pattern detection (A→B→A→B loops)
      */
     isRepetitiveToolCall(toolCall) {
         // Check if loop detection is disabled globally
         if (!AGENT_CONFIG.ENABLE_LOOP_DETECTION) {
             return false;
         }
-        // Check if threshold is 0 (disabled via threshold)
-        if (AGENT_CONFIG.LOOP_DETECTION_THRESHOLD <= 0) {
-            return false;
-        }
-        try {
-            const args = this.parseToolArgumentsCached(toolCall);
-            // Create a detailed signature that includes key arguments
-            // This allows multiple different commands but catches true repetitions
-            let signature = toolCall.function.name;
-            if (toolCall.function.name === 'bash' && args.command && typeof args.command === 'string') {
-                // Normalize command: trim whitespace, collapse multiple spaces
-                const normalizedCommand = args.command.trim().replace(/\s+/g, ' ');
-                // Use full command for exact matching (catches true duplicates)
-                signature = `bash:${normalizedCommand}`;
-            }
-            else if (toolCall.function.name === 'search' && args.query && typeof args.query === 'string') {
-                // For search, include the normalized query
-                const normalizedQuery = args.query.trim().toLowerCase().replace(/\s+/g, ' ');
-                signature = `search:${normalizedQuery}`;
-            }
-            else if (toolCall.function.name === 'view_file' && args.path && typeof args.path === 'string') {
-                // For file reads, include the path
-                signature = `view:${args.path}`;
-            }
-            else if (toolCall.function.name === 'create_file' && args.path && typeof args.path === 'string') {
-                // For file writes, include the path
-                signature = `create:${args.path}`;
-            }
-            else if (toolCall.function.name === 'str_replace_editor' && args.path && typeof args.path === 'string') {
-                // For text editor, include the path
-                signature = `edit:${args.path}`;
-            }
-            // Track by detailed signature
-            const count = this.recentToolCalls.get(signature) || 0;
-            // Debug logging
-            if (process.env.DEBUG_LOOP_DETECTION === '1') {
-                console.error(`[LOOP DETECTION] Tool: ${toolCall.function.name}`);
-                console.error(`[LOOP DETECTION] Signature: ${signature}`);
-                console.error(`[LOOP DETECTION] Count: ${count}`);
-                console.error(`[LOOP DETECTION] Threshold: ${AGENT_CONFIG.LOOP_DETECTION_THRESHOLD}`);
-                console.error(`[LOOP DETECTION] Map size: ${this.recentToolCalls.size}`);
-            }
-            // Increment the count first
-            const newCount = count + 1;
-            this.recentToolCalls.set(signature, newCount);
-            // Check if we've exceeded the configured threshold
-            // newCount > threshold means we've seen it threshold+1 times
-            if (newCount > AGENT_CONFIG.LOOP_DETECTION_THRESHOLD) {
-                if (process.env.DEBUG_LOOP_DETECTION === '1') {
-                    console.error(`[LOOP DETECTION] ⚠️ LOOP DETECTED! Signature: ${signature} (count: ${newCount}, threshold: ${AGENT_CONFIG.LOOP_DETECTION_THRESHOLD})`);
-                }
-                return true;
-            }
-            if (process.env.DEBUG_LOOP_DETECTION === '1') {
-                console.error(`[LOOP DETECTION] ✅ Allowed, count now: ${newCount}`);
-                console.error(`[LOOP DETECTION] Current map:`, Array.from(this.recentToolCalls.entries()));
-            }
-            // Clean up old entries (keep only last N unique calls)
-            // Batch cleanup when exceeding threshold to prevent unbounded growth
-            if (this.recentToolCalls.size > AGENT_CONFIG.MAX_RECENT_TOOL_CALLS) {
-                const excessCount = this.recentToolCalls.size - AGENT_CONFIG.MAX_RECENT_TOOL_CALLS + 10;
-                let removed = 0;
-                for (const key of this.recentToolCalls.keys()) {
-                    if (removed >= excessCount)
-                        break;
-                    this.recentToolCalls.delete(key);
-                    removed++;
-                }
+        // Use the new intelligent loop detector
+        const detector = getLoopDetector();
+        const result = detector.checkForLoop(toolCall);
+        // Debug logging
+        if (process.env.DEBUG_LOOP_DETECTION === '1') {
+            console.error(`[LOOP DETECTION] Tool: ${toolCall.function.name}`);
+            console.error(`[LOOP DETECTION] Count: ${result.count}`);
+            console.error(`[LOOP DETECTION] Threshold: ${result.threshold}`);
+            console.error(`[LOOP DETECTION] Is Loop: ${result.isLoop}`);
+            if (result.reason) {
+                console.error(`[LOOP DETECTION] Reason: ${result.reason}`);
             }
-            return false;
+            const stats = detector.getStats();
+            console.error(`[LOOP DETECTION] Stats: ${JSON.stringify(stats)}`);
         }
-        catch (error) {
-            // If we can't parse, assume it's not repetitive
+        if (result.isLoop) {
+            // Store the result for generating better error message
+            this.lastLoopResult = result;
             if (process.env.DEBUG_LOOP_DETECTION === '1') {
-                console.error(`[LOOP DETECTION] ❌ Parse error:`, error);
+                console.error(`[LOOP DETECTION] ⚠️ LOOP DETECTED!`);
+                console.error(`[LOOP DETECTION] Reason: ${result.reason}`);
+                console.error(`[LOOP DETECTION] Suggestion: ${result.suggestion}`);
             }
-            return false;
+            return true;
+        }
+        // Record the tool call (will be marked success/failure after execution)
+        // For now, pre-record with success=true, we update if it fails
+        detector.recordToolCall(toolCall, true);
+        if (process.env.DEBUG_LOOP_DETECTION === '1') {
+            console.error(`[LOOP DETECTION] ✅ Allowed, count: ${result.count}/${result.threshold}`);
         }
+        return false;
     }
+    /** Last loop detection result for error messages */
+    lastLoopResult;
     /**
      * Reset the tool call tracking (called at start of new user message)
      */
     resetToolCallTracking() {
         if (process.env.DEBUG_LOOP_DETECTION === '1') {
-            console.error(`[LOOP TRACKING] 🔄 Resetting tool call tracking (map had ${this.recentToolCalls.size} entries)`);
+            const detector = getLoopDetector();
+            const stats = detector.getStats();
+            console.error(`[LOOP TRACKING] 🔄 Resetting tool call tracking (had ${stats.uniqueSignatures} signatures)`);
         }
+        // Reset the new intelligent loop detector
+        resetLoopDetector();
+        // Also reset the legacy tracking (keep for backward compatibility during transition)
         this.recentToolCalls.clear();
         // Also clear the args cache to prevent memory leak
         this.toolCallArgsCache.clear();
+        // Clear last loop result
+        this.lastLoopResult = undefined;
+    }
+    /**
+     * Generate a helpful warning message when a loop is detected
+     * Uses the lastLoopResult for context-aware suggestions
+     */
+    getLoopWarningMessage() {
+        const base = "\n\n⚠️ Detected repetitive operations. Stopping to prevent infinite loop.";
+        if (this.lastLoopResult) {
+            const parts = [base];
+            if (this.lastLoopResult.reason) {
+                parts.push(`\n\nReason: ${this.lastLoopResult.reason}`);
+            }
+            if (this.lastLoopResult.suggestion) {
+                parts.push(`\n\n💡 Suggestion: ${this.lastLoopResult.suggestion}`);
+            }
+            parts.push("\n\nI'll stop here and provide what I've accomplished so far. You can ask me to continue with a different approach.");
+            return parts.join('');
+        }
+        return base + "\n\nI apologize, but I seem to be stuck in a loop. Let me provide what I can without further tool use.";
     }
     // ============================================================================
     // Multi-Phase Planning Integration
@@ -949,14 +943,15 @@ export class LLMAgent extends EventEmitter {
                 // Add assistant message to history
                 this.addAssistantMessage(streamResult.accumulated);
                 // Handle tool calls if present
-                if (streamResult.accumulated.tool_calls?.length > 0) {
+                if (streamResult.accumulated.tool_calls && streamResult.accumulated.tool_calls.length > 0) {
                     toolRounds++;
                     // Check for repetitive tool calls (loop detection)
                     const hasRepetitiveCall = streamResult.accumulated.tool_calls.some((tc) => this.isRepetitiveToolCall(tc));
                     if (hasRepetitiveCall) {
+                        const loopMsg = this.getLoopWarningMessage();
                         yield {
                             type: "content",
-                            content: "\n\n⚠️ Detected repetitive tool calls. Stopping to prevent infinite loop.\n",
+                            content: loopMsg,
                         };
                         break;
                     }
@@ -1074,9 +1069,10 @@ export class LLMAgent extends EventEmitter {
                         if (process.env.DEBUG_LOOP_DETECTION === '1') {
                             console.error(`[LOOP CHECK] 🛑 Breaking loop!`);
                         }
+                        const loopMsg = this.getLoopWarningMessage();
                         const warningEntry = {
                             type: "assistant",
-                            content: "⚠️ Detected repetitive tool calls. Stopping to prevent infinite loop.\n\nI apologize, but I seem to be stuck in a loop trying to answer your question. Let me provide what I can without further tool use.",
+                            content: loopMsg,
                             timestamp: new Date(),
                         };
                         this.chatHistory.push(warningEntry);
@@ -1116,7 +1112,11 @@ export class LLMAgent extends EventEmitter {
                         const result = await this.executeTool(toolCall);
                         // Update the existing tool_call entry with the result (O(1) lookup)
                         const entryIndex = this.toolCallIndexMap.get(toolCall.id);
-                        if (entryIndex !== undefined) {
+                        // Validate entryIndex is still valid after potential context pruning
+                        // The index could become stale if chatHistory was modified between store and access
+                        if (entryIndex !== undefined &&
+                            entryIndex < this.chatHistory.length &&
+                            this.chatHistory[entryIndex]?.toolCall?.id === toolCall.id) {
                             const updatedEntry = {
                                 ...this.chatHistory[entryIndex],
                                 type: "tool_result",
@@ -1406,15 +1406,17 @@ export class LLMAgent extends EventEmitter {
         finally {
             // CRITICAL FIX: Properly close the async iterator to release HTTP connections and buffers
             // This prevents socket leaks when streams are cancelled or errors occur
-            if (typeof stream.return === 'function') {
-                try {
-                    await stream.return();
-                }
-                catch (cleanupError) {
-                    // Log but don't throw - cleanup errors shouldn't break the flow
-                    console.warn('Stream cleanup warning:', cleanupError);
+            try {
+                // Use a type assertion to safely access the return method
+                const streamWithReturn = stream;
+                if (typeof streamWithReturn.return === 'function') {
+                    await streamWithReturn.return();
                 }
             }
+            catch (cleanupError) {
+                // Log but don't throw - cleanup errors shouldn't break the flow
+                console.warn('Stream cleanup warning:', cleanupError);
+            }
         }
     }
     /**
@@ -1564,14 +1566,15 @@ export class LLMAgent extends EventEmitter {
                 // Add assistant message to history
                 this.addAssistantMessage(streamResult.accumulated);
                 // Handle tool calls if present
-                if (streamResult.accumulated.tool_calls?.length > 0) {
+                if (streamResult.accumulated.tool_calls && streamResult.accumulated.tool_calls.length > 0) {
                     toolRounds++;
                     // Check for repetitive tool calls (loop detection)
                     const hasRepetitiveCall = streamResult.accumulated.tool_calls.some((tc) => this.isRepetitiveToolCall(tc));
                     if (hasRepetitiveCall) {
+                        const loopMsg = this.getLoopWarningMessage();
                         yield {
                             type: "content",
-                            content: "\n\n⚠️ Detected repetitive tool calls. Stopping to prevent infinite loop.\n\nI apologize, but I seem to be stuck in a loop trying to answer your question. Let me provide what I can without further tool use.",
+                            content: loopMsg,
                         };
                         break;
                     }
@@ -1741,18 +1744,6 @@ export class LLMAgent extends EventEmitter {
                         fileTypes: Array.isArray(args.file_types) ? args.file_types : undefined,
                         includeHidden: getBoolean('include_hidden'),
                     });
-                case "web_search": {
-                    const freshnessValue = args.freshness;
-                    const validFreshness = (freshnessValue === 'day' || freshnessValue === 'week' || freshnessValue === 'month' || freshnessValue === 'year') ? freshnessValue : undefined;
-                    const searchDepthValue = args.searchDepth;
-                    const validSearchDepth = (searchDepthValue === 'basic' || searchDepthValue === 'advanced') ? searchDepthValue : 'basic';
-                    return await this.webSearch.search(getString('query'), {
-                        maxResults: getNumber('maxResults'),
-                        includeAnswer: getBoolean('includeAnswer'),
-                        searchDepth: validSearchDepth,
-                        freshness: validFreshness,
-                    });
-                }
                 case "analyze_architecture": {
                     const projectPath = typeof args.projectPath === 'string' ? args.projectPath : undefined;
                     const depth = typeof args.depth === 'string' ? args.depth : undefined;
@@ -1796,10 +1787,11 @@ export class LLMAgent extends EventEmitter {
                 // Extract error message from MCP result content
                 // Safely check content structure before accessing
                 let errorMsg = "MCP tool error";
-                if (result.content && result.content.length > 0) {
+                if (result.content && Array.isArray(result.content) && result.content.length > 0) {
                     const firstContent = result.content[0];
                     if (typeof firstContent === 'object' && firstContent !== null && 'text' in firstContent) {
-                        errorMsg = String(firstContent.text) || errorMsg;
+                        const textValue = firstContent.text;
+                        errorMsg = typeof textValue === 'string' ? textValue : String(textValue || errorMsg);
                     }
                 }
                 return {
@@ -2135,9 +2127,12 @@ export class LLMAgent extends EventEmitter {
         this.disposed = true;
         // Remove all event listeners to prevent memory leaks
         this.removeAllListeners();
-        // CRITICAL FIX: Remove event listeners from contextManager to prevent memory leak
-        // The 'before_prune' listener was registered in constructor (line 188) but never removed
-        this.contextManager.removeAllListeners('before_prune');
+        // CRITICAL FIX: Remove event listener from contextManager to prevent memory leak
+        // Only remove the specific listener we registered, not all listeners for this event
+        if (this.contextOverflowListener) {
+            this.contextManager.removeListener('before_prune', this.contextOverflowListener);
+            this.contextOverflowListener = undefined;
+        }
         // Dispose tools that have cleanup methods
         this.bash.dispose();
         // Clear in-memory caches
@@ -2150,6 +2145,15 @@ export class LLMAgent extends EventEmitter {
             clearTimeout(timeout);
         }
         this.toolApprovalTimeouts.clear();
+        // Resolve any pending approval callbacks so awaiting promises don't hang forever
+        for (const [, callback] of this.toolApprovalCallbacks) {
+            try {
+                callback(false);
+            }
+            catch {
+                // Ignore callback errors during teardown
+            }
+        }
         this.toolApprovalCallbacks.clear();
         // Clear conversation history to free memory
         this.chatHistory = [];