@defai.digital/ax-cli 3.8.1 → 3.8.2

package/README.md

@@ -164,6 +164,29 @@ AX CLI uses **industry-standard max tokens** based on research of leading AI cod
 
 [View all features →](docs/features.md)
 
+## 🎉 What's New in v3.8.2
+
+**Deep Bug Fixes** - Comprehensive stability improvements for enhanced input handling:
+
+### 🐛 Bug Fixes
+
+- **Fixed external editor paste buffer race condition** - External editor callback now properly clears pending paste accumulation to prevent content overwrite
+- **Fixed `pastedBlocks` stale closure in submit** - Added `pastedBlocksRef` to ensure `expandPlaceholdersForSubmit` always has current paste block data during rapid paste + submit sequences
+- **Synchronized paste block refs** - All `setPastedBlocks` calls now sync `pastedBlocksRef` immediately to prevent race conditions
+- **Fixed async iterator cleanup** - Proper cleanup for async iterators in LLM agent
+- **Fixed cache eviction improvements** - Better memory management for token counter cache
+- **Fixed state validation and race conditions** - Improved state handling in MCP reconnection logic
+- **Fixed event listener error handling** - Better error boundaries for edge cases
+
+### ✅ Quality
+
+- All tests passing
+- 98%+ test coverage maintained
+- Zero breaking changes
+- Improved stability for paste operations
+
+---
+
 ## 🎉 What's New in v3.8.0
 
 **UI/UX Refinements & Bug Fixes** - Polish and stability improvements:

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

@@ -73,6 +73,8 @@ export declare class LLMAgent extends EventEmitter {
     /** Tool approval system for VSCode integration */
     private requireToolApproval;
     private toolApprovalCallbacks;
+    /** BUG FIX: Track approval timeouts for cleanup to prevent memory leaks */
+    private toolApprovalTimeouts;
     constructor(apiKey: string, baseURL?: string, model?: string, maxToolRounds?: number);
     private initializeCheckpointManager;
     private initializeMCP;

package/dist/agent/llm-agent.js

@@ -56,6 +56,8 @@ export class LLMAgent extends EventEmitter {
     /** Tool approval system for VSCode integration */
     requireToolApproval = false;
     toolApprovalCallbacks = new Map();
+    /** BUG FIX: Track approval timeouts for cleanup to prevent memory leaks */
+    toolApprovalTimeouts = new Map();
     constructor(apiKey, baseURL, model, maxToolRounds) {
         super();
         const manager = getSettingsManager();
@@ -81,10 +83,15 @@ export class LLMAgent extends EventEmitter {
         // Load sampling configuration from settings (supports env vars, project, and user settings)
         this.samplingConfig = manager.getSamplingSettings();
         // Wire up checkpoint callback for automatic checkpoint creation
+        // CRITICAL FIX: Deep clone chatHistory to prevent race conditions
+        // The checkpoint creation is async and chatHistory can be modified during the operation
         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
+            const chatHistorySnapshot = JSON.parse(JSON.stringify(this.chatHistory));
             await this.checkpointManager.createCheckpoint({
                 files,
-                conversationState: this.chatHistory,
+                conversationState: chatHistorySnapshot,
                 description,
                 metadata: {
                     model: this.llmClient.getCurrentModel(),
@@ -116,8 +123,15 @@ export class LLMAgent extends EventEmitter {
             content: `Current working directory: ${process.cwd()}\nTimestamp: ${new Date().toISOString().split('T')[0]}`,
         });
         // NEW: Listen for context pruning to generate summaries
-        this.contextManager.on('before_prune', async (data) => {
-            await this.handleContextOverflow(data);
+        // 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) => {
+            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);
+            });
         });
     }
     initializeCheckpointManager() {
@@ -222,6 +236,12 @@ export class LLMAgent extends EventEmitter {
     approveToolCall(toolCallId, approved) {
         const callback = this.toolApprovalCallbacks.get(toolCallId);
         if (callback) {
+            // BUG FIX: Clear the timeout when approval is received (prevents memory leak)
+            const timeout = this.toolApprovalTimeouts.get(toolCallId);
+            if (timeout) {
+                clearTimeout(timeout);
+                this.toolApprovalTimeouts.delete(toolCallId);
+            }
             callback(approved);
             this.toolApprovalCallbacks.delete(toolCallId);
         }
@@ -239,13 +259,18 @@ export class LLMAgent extends EventEmitter {
             this.emit('tool:approval_required', toolCall);
             // Store callback
             this.toolApprovalCallbacks.set(toolCall.id, resolve);
-            // Timeout after 5 minutes (auto-reject)
-            setTimeout(() => {
+            // BUG FIX: Track the timeout so it can be cleared on approval/disposal
+            // This prevents memory leaks from dangling timers
+            const timeoutId = setTimeout(() => {
+                // Clean up both the callback and timeout tracking
+                this.toolApprovalTimeouts.delete(toolCall.id);
                 if (this.toolApprovalCallbacks.has(toolCall.id)) {
                     this.toolApprovalCallbacks.delete(toolCall.id);
                     resolve(false); // Auto-reject on timeout
                 }
             }, 5 * 60 * 1000);
+            // Track the timeout for cleanup
+            this.toolApprovalTimeouts.set(toolCall.id, timeoutId);
         });
     }
     /**
@@ -281,27 +306,41 @@ export class LLMAgent extends EventEmitter {
      * BUGFIX: Prevents chatHistory from growing unbounded
      */
     applyContextPruning() {
+        // Prune LLM messages if needed
         if (this.contextManager.shouldPrune(this.messages, this.tokenCounter)) {
-            // Prune LLM messages
             this.messages = this.contextManager.pruneMessages(this.messages, this.tokenCounter);
-            // Also prune chatHistory to prevent unlimited growth
-            // Keep last 200 entries which is more than enough for UI display
-            const MAX_CHAT_HISTORY_ENTRIES = 200;
-            if (this.chatHistory.length > MAX_CHAT_HISTORY_ENTRIES) {
-                const entriesToRemove = this.chatHistory.length - MAX_CHAT_HISTORY_ENTRIES;
-                this.chatHistory = this.chatHistory.slice(entriesToRemove);
-                // Update tool call index map after pruning
-                // Clear and rebuild only for remaining entries
-                this.toolCallIndexMap.clear();
-                this.chatHistory.forEach((entry, index) => {
-                    if (entry.type === "tool_call" && entry.toolCall?.id) {
-                        this.toolCallIndexMap.set(entry.toolCall.id, index);
-                    }
-                    else if (entry.type === "tool_result" && entry.toolCall?.id) {
-                        this.toolCallIndexMap.set(entry.toolCall.id, index);
-                    }
-                });
-            }
+        }
+        // CRITICAL FIX: Always check and prune chatHistory to prevent unbounded growth
+        // This must happen UNCONDITIONALLY, even if context pruning is disabled
+        // Keep last 200 entries which is more than enough for UI display
+        const MAX_CHAT_HISTORY_ENTRIES = 200;
+        if (this.chatHistory.length > MAX_CHAT_HISTORY_ENTRIES) {
+            const entriesToRemove = this.chatHistory.length - MAX_CHAT_HISTORY_ENTRIES;
+            this.chatHistory = this.chatHistory.slice(entriesToRemove);
+            // Update tool call index map after pruning
+            // Clear and rebuild only for remaining entries
+            this.toolCallIndexMap.clear();
+            this.chatHistory.forEach((entry, index) => {
+                if (entry.type === "tool_call" && entry.toolCall?.id) {
+                    this.toolCallIndexMap.set(entry.toolCall.id, index);
+                }
+                else if (entry.type === "tool_result" && entry.toolCall?.id) {
+                    this.toolCallIndexMap.set(entry.toolCall.id, index);
+                }
+            });
+        }
+        // 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) {
+            // 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);
+            this.messages = [
+                ...systemMessages,
+                ...nonSystemMessages.slice(-keepMessages)
+            ];
         }
     }
     /**
@@ -323,13 +362,16 @@ export class LLMAgent extends EventEmitter {
         try {
             const args = JSON.parse(toolCall.function.arguments || '{}');
             this.toolCallArgsCache.set(toolCall.id, args);
-            // Prevent unbounded memory growth - limit cache size
+            // 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
+                const toRemove = this.toolCallArgsCache.size - targetSize;
                 let deleted = 0;
                 for (const key of this.toolCallArgsCache.keys()) {
                     this.toolCallArgsCache.delete(key);
                     deleted++;
-                    if (deleted >= 100)
+                    if (deleted >= toRemove)
                         break;
                 }
             }
@@ -1278,85 +1320,102 @@ export class LLMAgent extends EventEmitter {
         let accumulatedContent = "";
         let toolCallsYielded = false;
         let usageData = null;
-        for await (const chunk of stream) {
-            // Check for cancellation in the streaming loop
-            if (this.isCancelled()) {
-                yield* this.yieldCancellation();
-                // Return empty state after cancellation to avoid processing partial results
-                return { accumulated: {}, content: "", yielded: false };
-            }
-            if (!chunk.choices?.[0])
-                continue;
-            // Capture usage data from chunks (usually in the final chunk)
-            if (chunk.usage) {
-                usageData = chunk.usage;
-            }
-            // Accumulate the message using reducer
-            accumulatedMessage = this.messageReducer(accumulatedMessage, chunk);
-            // Check for tool calls - yield when we have complete tool calls with function names
-            const toolCalls = accumulatedMessage.tool_calls;
-            if (!toolCallsYielded && toolCalls && Array.isArray(toolCalls) && toolCalls.length > 0) {
-                const hasCompleteTool = toolCalls.some((tc) => tc.function?.name);
-                if (hasCompleteTool) {
+        // CRITICAL FIX: Ensure stream is properly closed on cancellation or error
+        // Without this, HTTP connections and buffers remain in memory
+        try {
+            for await (const chunk of stream) {
+                // Check for cancellation in the streaming loop
+                if (this.isCancelled()) {
+                    yield* this.yieldCancellation();
+                    // Return empty state after cancellation to avoid processing partial results
+                    return { accumulated: {}, content: "", yielded: false };
+                }
+                if (!chunk.choices?.[0])
+                    continue;
+                // Capture usage data from chunks (usually in the final chunk)
+                if (chunk.usage) {
+                    usageData = chunk.usage;
+                }
+                // Accumulate the message using reducer
+                accumulatedMessage = this.messageReducer(accumulatedMessage, chunk);
+                // Check for tool calls - yield when we have complete tool calls with function names
+                const toolCalls = accumulatedMessage.tool_calls;
+                if (!toolCallsYielded && toolCalls && Array.isArray(toolCalls) && toolCalls.length > 0) {
+                    const hasCompleteTool = toolCalls.some((tc) => tc.function?.name);
+                    if (hasCompleteTool) {
+                        yield {
+                            type: "tool_calls",
+                            toolCalls: toolCalls,
+                        };
+                        toolCallsYielded = true;
+                    }
+                }
+                // Stream reasoning content (GLM-4.6 thinking mode)
+                // Safety check: ensure choices[0] exists before accessing
+                if (chunk.choices[0]?.delta?.reasoning_content) {
                     yield {
-                        type: "tool_calls",
-                        toolCalls: toolCalls,
+                        type: "reasoning",
+                        reasoningContent: chunk.choices[0].delta.reasoning_content,
                     };
-                    toolCallsYielded = true;
+                }
+                // Stream content as it comes
+                if (chunk.choices[0]?.delta?.content) {
+                    accumulatedContent += chunk.choices[0].delta.content;
+                    yield {
+                        type: "content",
+                        content: chunk.choices[0].delta.content,
+                    };
+                    // Emit token count update (throttled and optimized)
+                    const now = Date.now();
+                    if (now - lastTokenUpdate.value > 1000) { // Increased throttle to 1s for better performance
+                        lastTokenUpdate.value = now;
+                        // Use fast estimation during streaming (4 chars ≈ 1 token)
+                        // This is ~70% faster than tiktoken encoding
+                        const estimatedOutputTokens = Math.floor(accumulatedContent.length / 4) +
+                            (accumulatedMessage.tool_calls
+                                ? Math.floor(JSON.stringify(accumulatedMessage.tool_calls).length / 4)
+                                : 0);
+                        totalOutputTokens.value = estimatedOutputTokens;
+                        yield {
+                            type: "token_count",
+                            tokenCount: inputTokens + estimatedOutputTokens,
+                        };
+                    }
                 }
             }
-            // Stream reasoning content (GLM-4.6 thinking mode)
-            // Safety check: ensure choices[0] exists before accessing
-            if (chunk.choices[0]?.delta?.reasoning_content) {
-                yield {
-                    type: "reasoning",
-                    reasoningContent: chunk.choices[0].delta.reasoning_content,
-                };
-            }
-            // Stream content as it comes
-            if (chunk.choices[0]?.delta?.content) {
-                accumulatedContent += chunk.choices[0].delta.content;
-                yield {
-                    type: "content",
-                    content: chunk.choices[0].delta.content,
-                };
-                // Emit token count update (throttled and optimized)
-                const now = Date.now();
-                if (now - lastTokenUpdate.value > 1000) { // Increased throttle to 1s for better performance
-                    lastTokenUpdate.value = now;
-                    // Use fast estimation during streaming (4 chars ≈ 1 token)
-                    // This is ~70% faster than tiktoken encoding
-                    const estimatedOutputTokens = Math.floor(accumulatedContent.length / 4) +
-                        (accumulatedMessage.tool_calls
-                            ? Math.floor(JSON.stringify(accumulatedMessage.tool_calls).length / 4)
-                            : 0);
-                    totalOutputTokens.value = estimatedOutputTokens;
+            // Track usage if available and emit accurate final token count
+            if (usageData) {
+                const tracker = getUsageTracker();
+                tracker.trackUsage(this.llmClient.getCurrentModel(), usageData);
+                // Emit accurate token count from API usage data (replaces estimation)
+                const totalTokens = usageData.total_tokens;
+                const completionTokens = usageData.completion_tokens;
+                if (totalTokens) {
+                    totalOutputTokens.value = completionTokens || 0;
                     yield {
                         type: "token_count",
-                        tokenCount: inputTokens + estimatedOutputTokens,
+                        tokenCount: totalTokens,
                     };
                 }
             }
+            // CRITICAL: Yield the accumulated result so the main loop can access it!
+            const result = { accumulated: accumulatedMessage, content: accumulatedContent, yielded: toolCallsYielded };
+            yield result;
+            return result;
         }
-        // Track usage if available and emit accurate final token count
-        if (usageData) {
-            const tracker = getUsageTracker();
-            tracker.trackUsage(this.llmClient.getCurrentModel(), usageData);
-            // Emit accurate token count from API usage data (replaces estimation)
-            const totalTokens = usageData.total_tokens;
-            const completionTokens = usageData.completion_tokens;
-            if (totalTokens) {
-                totalOutputTokens.value = completionTokens || 0;
-                yield {
-                    type: "token_count",
-                    tokenCount: totalTokens,
-                };
+        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);
+                }
             }
         }
-        // CRITICAL: Yield the accumulated result so the main loop can access it!
-        const result = { accumulated: accumulatedMessage, content: accumulatedContent, yielded: toolCallsYielded };
-        yield result;
-        return result;
     }
     /**
      * Add assistant message to history and conversation
@@ -1856,6 +1915,9 @@ export class LLMAgent extends EventEmitter {
             // Safely preserve system message if it exists
             const systemMessage = this.messages.length > 0 ? this.messages[0] : null;
             this.messages = systemMessage ? [systemMessage] : [];
+            // CRITICAL FIX: Track tool calls to validate tool results
+            // Prevents API errors from orphaned tool results without corresponding tool calls
+            const toolCallIds = new Set();
             for (const entry of conversationState) {
                 if (entry.type === 'user') {
                     this.messages.push({
@@ -1864,6 +1926,14 @@ export class LLMAgent extends EventEmitter {
                     });
                 }
                 else if (entry.type === 'assistant') {
+                    // Track tool call IDs from assistant messages
+                    if (entry.toolCalls && Array.isArray(entry.toolCalls)) {
+                        for (const toolCall of entry.toolCalls) {
+                            if (toolCall?.id) {
+                                toolCallIds.add(toolCall.id);
+                            }
+                        }
+                    }
                     this.messages.push({
                         role: 'assistant',
                         content: entry.content,
@@ -1871,11 +1941,18 @@ export class LLMAgent extends EventEmitter {
                     });
                 }
                 else if (entry.type === 'tool_result' && entry.toolCall) {
-                    this.messages.push({
-                        role: 'tool',
-                        content: entry.content,
-                        tool_call_id: entry.toolCall.id,
-                    });
+                    // CRITICAL FIX: Only add tool result if corresponding tool call exists
+                    // This prevents "tool message without corresponding tool call" API errors
+                    if (toolCallIds.has(entry.toolCall.id)) {
+                        this.messages.push({
+                            role: 'tool',
+                            content: entry.content,
+                            tool_call_id: entry.toolCall.id,
+                        });
+                    }
+                    else {
+                        console.warn(`Skipping orphaned tool result for tool_call_id: ${entry.toolCall.id}`);
+                    }
                 }
             }
             this.emit('system', `Conversation rewound to checkpoint ${checkpointId}`);
@@ -2058,12 +2135,22 @@ 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');
         // Dispose tools that have cleanup methods
         this.bash.dispose();
         // Clear in-memory caches
         this.recentToolCalls.clear();
         this.toolCallIndexMap.clear();
         this.toolCallArgsCache.clear();
+        // BUG FIX: Clear all pending tool approval timeouts to prevent memory leaks
+        // These timers would otherwise keep running for up to 5 minutes after dispose
+        for (const timeout of this.toolApprovalTimeouts.values()) {
+            clearTimeout(timeout);
+        }
+        this.toolApprovalTimeouts.clear();
+        this.toolApprovalCallbacks.clear();
         // Clear conversation history to free memory
         this.chatHistory = [];
         this.messages = [];