erosolar-cli 2.1.171 → 2.1.172

package/dist/core/agent.js

@@ -4,7 +4,65 @@ import { safeErrorMessage } from './secretStore.js';
  * Maximum number of context overflow recovery attempts
  */
 const MAX_CONTEXT_RECOVERY_ATTEMPTS = 3;
-// Streaming runs without timeouts - we let the model take as long as it needs
+/**
+ * Maximum number of auto-continuation attempts when model expresses intent but doesn't act
+ */
+const MAX_AUTO_CONTINUE_ATTEMPTS = 3;
+/**
+ * Streaming safety timeouts (ms)
+ * - First chunk timeout: fail fast if the stream never starts
+ * - Inactivity timeout: abort if no chunks arrive for an extended period
+ */
+// Allow more headroom before declaring a streaming stall to avoid premature fallbacks.
+const STREAM_FIRST_CHUNK_TIMEOUT_MS = 25000;
+const STREAM_INACTIVITY_TIMEOUT_MS = 60000;
+/**
+ * Patterns that indicate the model intends to take action but hasn't yet
+ * These suggest the model should be prompted to continue
+ */
+const INTENT_WITHOUT_ACTION_PATTERNS = [
+    // "Let me X" patterns - model is stating what it will do
+    /\blet me\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|examine|review)/i,
+    // "I'll X" / "I will X" patterns
+    /\bi['']ll\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|start|begin|now)/i,
+    /\bi will\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|start|begin|now)/i,
+    // "I'm going to X" patterns
+    /\bi['']m going to\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze)/i,
+    // "Now I'll X" / "First, I'll X" patterns
+    /\b(now|first|next)\s*(,)?\s*i['']ll\s+/i,
+    // Explicit continuation signals
+    /\bhere['']s (the|my) (plan|approach|solution|implementation)/i,
+    // Numbered steps suggesting action to come
+    /^\s*\d+\.\s+(create|write|implement|add|update|edit|modify|fix|show|read|check)/im,
+    // Bullet points suggesting planned actions
+    /^[\s•\-\*]+\s*(create|write|implement|add|update|edit|modify|fix|shows?|reads?|checks?)\s/im,
+];
+const AUTO_CONTINUE_PROMPTS = [
+    'Continue. Use tools now: start with Read/read_file to inspect the target file, then call Edit (or Write if available) with file_path/old_string/new_string to apply changes. Keep using tools until the task is done.',
+    'You MUST call tools immediately. Issue Read -> Edit/Write tool calls with explicit parameters; no more explaining or planning.',
+    'CRITICAL: Call a tool right now. Use Edit with file_path, old_string, new_string (or Write with file_path and content). Respond with tool calls only.',
+];
+/**
+ * Check if response indicates intent to act without actually acting
+ * This detects when the model says "let me do X" but doesn't call any tools
+ */
+function shouldAutoContinue(content, hasToolCalls) {
+    // If there are tool calls, no need to auto-continue
+    if (hasToolCalls) {
+        return false;
+    }
+    // If content is very short, likely not an incomplete intent
+    if (content.length < 50) {
+        return false;
+    }
+    // Check for intent patterns
+    for (const pattern of INTENT_WITHOUT_ACTION_PATTERNS) {
+        if (pattern.test(content)) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Check if an error is a context overflow error
  */
@@ -19,53 +77,15 @@ function isContextOverflowError(error) {
         message.includes('max_tokens') ||
         message.includes('context window'));
 }
-/**
- * Check if an error is a transient/retryable error (network issues, rate limits, server errors)
- */
-function isTransientError(error) {
-    if (!(error instanceof Error))
-        return false;
-    const message = error.message.toLowerCase();
-    // Network errors
-    const networkPatterns = [
-        'econnrefused', 'econnreset', 'enotfound', 'etimedout', 'epipe',
-        'network error', 'connection error', 'fetch failed', 'socket hang up',
-        'network is unreachable', 'connection refused', 'connection reset',
-    ];
-    if (networkPatterns.some(p => message.includes(p))) {
-        return true;
+class StreamInterruptionError extends Error {
+    reason;
+    partialResponse;
+    constructor(reason, message, partialResponse) {
+        super(message);
+        this.name = 'StreamInterruptionError';
+        this.reason = reason;
+        this.partialResponse = partialResponse;
     }
-    // Rate limit errors
-    if (message.includes('rate limit') || message.includes('429') || message.includes('too many requests')) {
-        return true;
-    }
-    // Server errors (5xx)
-    if (message.includes('500') || message.includes('502') || message.includes('503') || message.includes('504')) {
-        return true;
-    }
-    // Temporary service errors
-    if (message.includes('service unavailable') || message.includes('temporarily unavailable') ||
-        message.includes('overloaded') || message.includes('server error')) {
-        return true;
-    }
-    return false;
-}
-/**
- * Maximum number of transient error retries
- */
-const MAX_TRANSIENT_RETRIES = 3;
-/**
- * Delay before retry (in ms), with exponential backoff
- */
-function getRetryDelay(attempt) {
-    // Base delay of 1 second, doubles each attempt: 1s, 2s, 4s
-    return Math.min(1000 * Math.pow(2, attempt - 1), 10000);
-}
-/**
- * Sleep for the specified milliseconds
- */
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
 }
 export class AgentRuntime {
     messages = [];
@@ -79,53 +99,7 @@ export class AgentRuntime {
     modelId;
     workingDirectory;
     cancellationRequested = false;
-    // Loop detection: track last tool calls to detect stuck loops
-    lastToolCallSignature = null;
-    repeatedToolCallCount = 0;
-    static MAX_REPEATED_TOOL_CALLS = 5; // Allow up to 4 identical calls before stopping
-    // Behavioral loop detection: track recent tool calls to catch repetitive patterns
-    // e.g., calling "execute_bash" with "git status" 5 times even if output differs slightly
-    recentToolCalls = [];
-    static TOOL_HISTORY_SIZE = 12;
-    static BEHAVIORAL_LOOP_THRESHOLD = 3; // Same tool+cmd 3+ times in last 12 = stuck
-    // Never cache stateful tools - they must always execute to reflect current system state
-    static NON_CACHEABLE_TOOL_NAMES = new Set([
-        'bash',
-        'execute_bash',
-        'execute_command',
-        'run_command',
-        'edit',
-        'edit_file',
-        'notebookedit',
-        'read',
-        'read_file',
-        'read_files',
-        'list_files',
-        'list_dir',
-        'glob',
-        'grep',
-        'search',
-        'search_text',
-        'git_status',
-        'git_diff',
-        'git_log',
-        'git_commit',
-        'git_push',
-    ]);
-    // Skip loop short-circuiting for direct execution tools to avoid blocking user commands
-    static LOOP_EXEMPT_TOOL_NAMES = new Set([
-        'bash',
-        'execute_bash',
-        'execute_command',
-        'run_command',
-        'edit',
-        'edit_file',
-        'notebookedit',
-    ]);
-    // Tool result cache: prevent duplicate identical tool calls by returning cached results
-    // Key: tool signature (name + JSON args), Value: result string
-    toolResultCache = new Map();
-    static TOOL_CACHE_MAX_SIZE = 50; // Keep last 50 tool results
+    _autoContinueEnabled = false;
     constructor(options) {
         this.provider = options.provider;
         this.toolRuntime = options.toolRuntime;
@@ -134,6 +108,7 @@ export class AgentRuntime {
         this.providerId = options.providerId ?? 'unknown';
         this.modelId = options.modelId ?? 'unknown';
         this.workingDirectory = options.workingDirectory ?? process.cwd();
+        this._autoContinueEnabled = options.autoContinue ?? false;
         const trimmedPrompt = options.systemPrompt.trim();
         this.baseSystemPrompt = trimmedPrompt || null;
         if (trimmedPrompt) {
@@ -159,14 +134,25 @@ export class AgentRuntime {
     isRunning() {
         return this.activeRun !== null;
     }
+    /**
+     * Check if auto-continuation is enabled.
+     */
+    isAutoContinueEnabled() {
+        return this._autoContinueEnabled;
+    }
+    /**
+     * Enable or disable auto-continuation.
+     */
+    setAutoContinue(enabled) {
+        this._autoContinueEnabled = enabled;
+    }
     async send(text, useStreaming = false) {
         const prompt = text.trim();
         if (!prompt) {
             return '';
         }
-        // Reset cancellation flag and loop tracking at start of new request
+        // Reset cancellation flag at start of new request
         this.cancellationRequested = false;
-        this.resetBehavioralLoopTracking();
         // Handle multi-line paste: show summary to user, send full content to AI
         if (isMultilinePaste(prompt)) {
             const processed = processPaste(prompt);
@@ -182,9 +168,28 @@ export class AgentRuntime {
         const run = { startedAt: Date.now() };
         this.activeRun = run;
         try {
-            // Always use streaming when available - no fallback
             if (useStreaming && this.provider.generateStream) {
-                return await this.processConversationStreaming();
+                try {
+                    return await this.processConversationStreaming();
+                }
+                catch (error) {
+                    const message = safeErrorMessage(error);
+                    const reason = error instanceof StreamInterruptionError ? error.reason : undefined;
+                    const partialResponse = error instanceof StreamInterruptionError ? error.partialResponse : undefined;
+                    console.warn(`[agent] Streaming failed, falling back to non-streaming: ${message}`);
+                    // If we captured part of the response, seed it into history and ask the model to continue
+                    // so we don't restart the answer from scratch during fallback.
+                    if (partialResponse && partialResponse.trim()) {
+                        const partial = partialResponse.trim();
+                        this.messages.push({ role: 'assistant', content: partial });
+                        this.messages.push({
+                            role: 'user',
+                            content: 'Continue your previous response from where it stopped. Do not repeat text you already provided.',
+                        });
+                    }
+                    this.callbacks.onStreamFallback?.({ message, error, reason, partialResponse });
+                    return await this.processConversation();
+                }
             }
             return await this.processConversation();
         }
@@ -198,7 +203,7 @@ export class AgentRuntime {
     }
     async processConversation() {
         let contextRecoveryAttempts = 0;
-        let transientRetryAttempts = 0;
+        let autoContinueAttempts = 0;
         while (true) {
             // Check for cancellation at start of each iteration
             if (this.cancellationRequested) {
@@ -214,66 +219,44 @@ export class AgentRuntime {
                 // Reset recovery attempts on successful generation
                 contextRecoveryAttempts = 0;
                 if (response.type === 'tool_calls') {
-                    // BEHAVIORAL LOOP DETECTION: Check if model is stuck calling same tool repeatedly
-                    const behavioralLoopResult = this.checkBehavioralLoop(response.toolCalls);
-                    if (behavioralLoopResult) {
-                        this.emitAssistantMessage(behavioralLoopResult, { isFinal: true, usage, contextStats });
-                        this.messages.push({ role: 'assistant', content: behavioralLoopResult });
-                        return behavioralLoopResult;
-                    }
-                    // Loop detection: check if same tool calls are being repeated (exact signature match)
-                    const signatureCalls = response.toolCalls.filter(call => !this.shouldSkipLoopDetection(call));
-                    const toolSignature = signatureCalls.length
-                        ? signatureCalls
-                            .map((t) => `${t.name}:${JSON.stringify(t.arguments)}`)
-                            .sort()
-                            .join('|')
-                        : null;
-                    if (toolSignature && toolSignature === this.lastToolCallSignature) {
-                        this.repeatedToolCallCount++;
-                        if (this.repeatedToolCallCount >= AgentRuntime.MAX_REPEATED_TOOL_CALLS) {
-                            // Break out of loop - model is stuck
-                            const loopMsg = `Tool loop detected: same tools called ${this.repeatedToolCallCount} times. Please try a different approach or provide more specific instructions.`;
-                            this.emitAssistantMessage(loopMsg, { isFinal: true, usage, contextStats });
-                            this.messages.push({ role: 'assistant', content: loopMsg });
-                            this.lastToolCallSignature = null;
-                            this.repeatedToolCallCount = 0;
-                            return loopMsg;
-                        }
-                    }
-                    else if (toolSignature) {
-                        this.lastToolCallSignature = toolSignature;
-                        this.repeatedToolCallCount = 1;
-                    }
-                    else {
-                        this.lastToolCallSignature = null;
-                        this.repeatedToolCallCount = 0;
-                    }
-                    // Emit narration if present - it shows the AI's thought process before tools
-                    const narration = response.content?.trim();
+                    const suppressNarration = this.shouldSuppressToolNarration();
+                    const narration = suppressNarration ? '' : response.content?.trim();
                     if (narration) {
-                        this.emitAssistantMessage(narration, {
-                            isFinal: false,
-                            usage,
-                            contextStats,
-                        });
+                        this.emitAssistantMessage(narration, { isFinal: false, usage, contextStats });
                     }
                     const assistantMessage = {
                         role: 'assistant',
-                        content: response.content ?? '',
+                        content: suppressNarration ? '' : (response.content ?? ''),
                     };
                     if (response.toolCalls?.length) {
                         assistantMessage.toolCalls = response.toolCalls;
                     }
                     this.messages.push(assistantMessage);
                     await this.resolveToolCalls(response.toolCalls);
+                    // Reset auto-continue counter since model is actively working
+                    autoContinueAttempts = 0;
                     continue;
                 }
                 const reply = response.content?.trim() ?? '';
-                // Reset loop detection when we get a text response (not just tool calls)
-                if (reply.length >= 10) {
-                    this.lastToolCallSignature = null;
-                    this.repeatedToolCallCount = 0;
+                // Check if model expressed intent to act but didn't call tools
+                // This catches "Let me create..." without actual tool calls
+                // Only auto-continue if the feature is enabled
+                if (this._autoContinueEnabled && shouldAutoContinue(reply, false) && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
+                    autoContinueAttempts++;
+                    // Emit the planning content but mark as non-final
+                    if (reply) {
+                        this.emitAssistantMessage(reply, { isFinal: false, usage, contextStats });
+                    }
+                    this.messages.push({ role: 'assistant', content: reply });
+                    // Auto-prompt with increasingly direct instructions
+                    const promptIndex = Math.min(autoContinueAttempts - 1, AUTO_CONTINUE_PROMPTS.length - 1);
+                    this.messages.push({
+                        role: 'user',
+                        content: AUTO_CONTINUE_PROMPTS[promptIndex],
+                    });
+                    const autoContinueMessage = `Model expressed intent but didn't use tools. Auto-prompting to continue...`;
+                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, autoContinueMessage);
+                    continue;
                 }
                 if (reply) {
                     this.emitAssistantMessage(reply, { isFinal: true, usage, contextStats });
@@ -295,14 +278,6 @@ export class AgentRuntime {
                         continue;
                     }
                 }
-                // Auto-retry transient errors (network issues, rate limits, server errors)
-                if (isTransientError(error) && transientRetryAttempts < MAX_TRANSIENT_RETRIES) {
-                    transientRetryAttempts++;
-                    const delayMs = getRetryDelay(transientRetryAttempts);
-                    this.callbacks.onRetrying?.(transientRetryAttempts, MAX_TRANSIENT_RETRIES, error);
-                    await sleep(delayMs);
-                    continue;
-                }
                 // Re-throw if not recoverable or recovery failed
                 throw error;
             }
@@ -313,7 +288,7 @@ export class AgentRuntime {
             return this.processConversation();
         }
         let contextRecoveryAttempts = 0;
-        let transientRetryAttempts = 0;
+        let autoContinueAttempts = 0;
         while (true) {
             // Check for cancellation at start of each iteration
             if (this.cancellationRequested) {
@@ -346,10 +321,45 @@ export class AgentRuntime {
                         }
                     }
                 };
-                // Simple streaming loop - no timeouts, let the stream run until done
+                const buildTimeoutError = (reason) => {
+                    const base = reason === 'startup-timeout'
+                        ? 'Streaming stalled before any content arrived.'
+                        : 'Streaming stalled due to inactivity.';
+                    return new StreamInterruptionError(reason, `${base} Falling back to non-streaming.`, fullContent || reasoningContent);
+                };
+                // Timer for first token arrival
+                let startupTimer = null;
+                const startupTimeoutPromise = new Promise((_, reject) => {
+                    startupTimer = setTimeout(() => reject(buildTimeoutError('startup-timeout')), STREAM_FIRST_CHUNK_TIMEOUT_MS);
+                });
+                const createIdleTimeout = () => {
+                    let idleTimer = null;
+                    const promise = new Promise((_, reject) => {
+                        idleTimer = setTimeout(() => reject(buildTimeoutError('idle-timeout')), STREAM_INACTIVITY_TIMEOUT_MS);
+                    });
+                    const cancel = () => {
+                        if (idleTimer) {
+                            clearTimeout(idleTimer);
+                            idleTimer = null;
+                        }
+                    };
+                    return { promise, cancel };
+                };
+                let idleTimeout = createIdleTimeout();
+                let firstChunkSeen = false;
                 try {
                     while (true) {
-                        const result = await iterator.next();
+                        const races = [
+                            iterator.next(),
+                            idleTimeout.promise,
+                        ];
+                        if (!firstChunkSeen) {
+                            races.push(startupTimeoutPromise);
+                        }
+                        const result = (await Promise.race(races));
+                        // Reset idle timer for the next iteration
+                        idleTimeout.cancel();
+                        idleTimeout = createIdleTimeout();
                         // Check for cancellation during streaming
                         if (this.cancellationRequested) {
                             await closeStream();
@@ -364,10 +374,17 @@ export class AgentRuntime {
                             break;
                         }
                         const chunk = result.value;
+                        if (!firstChunkSeen) {
+                            firstChunkSeen = true;
+                            if (startupTimer) {
+                                clearTimeout(startupTimer);
+                                startupTimer = null;
+                            }
+                        }
                         if (chunk.type === 'reasoning' && chunk.content) {
-                            // Buffer reasoning content - don't stream token-by-token
-                            // It will be emitted as a complete block when ready
                             reasoningContent += chunk.content;
+                            // Surface reasoning tokens to the UI so thought process is visible
+                            this.callbacks.onStreamChunk?.(chunk.content, 'reasoning');
                             continue;
                         }
                         if (chunk.type === 'content' && chunk.content) {
@@ -380,19 +397,11 @@ export class AgentRuntime {
                             }
                         }
                         else if (chunk.type === 'tool_call' && chunk.toolCall) {
-                            // On first tool call, flush any buffered content
-                            if (toolCalls.length === 0) {
-                                // Emit complete reasoning block first
-                                if (reasoningContent.trim()) {
-                                    this.callbacks.onStreamChunk?.(reasoningContent, 'reasoning');
-                                }
-                                // Then emit buffered narration content
-                                if (suppressStreamNarration && bufferedContent) {
-                                    this.callbacks.onStreamChunk?.(bufferedContent, 'content');
-                                    bufferedContent = '';
-                                }
-                            }
                             toolCalls.push(chunk.toolCall);
+                            // Drop any speculative narration once we know the model is actually calling tools
+                            if (suppressStreamNarration) {
+                                bufferedContent = '';
+                            }
                         }
                         else if (chunk.type === 'usage' && chunk.usage) {
                             usage = chunk.usage;
@@ -400,88 +409,61 @@ export class AgentRuntime {
                     }
                 }
                 finally {
+                    idleTimeout.cancel();
+                    if (startupTimer) {
+                        clearTimeout(startupTimer);
+                    }
                     await closeStream();
                 }
                 // Reset recovery attempts on successful generation
                 contextRecoveryAttempts = 0;
                 const contextStats = this.getContextStats();
                 const combinedContent = fullContent || reasoningContent;
-                // If no tool calls were issued, emit reasoning and buffered content as complete blocks
-                if (toolCalls.length === 0) {
-                    // Emit complete reasoning block if we have one
-                    if (reasoningContent.trim()) {
-                        this.callbacks.onStreamChunk?.(reasoningContent, 'reasoning');
-                    }
-                    // Emit buffered narration content
-                    if (suppressStreamNarration && bufferedContent) {
-                        this.callbacks.onStreamChunk?.(bufferedContent, 'content');
-                        bufferedContent = '';
-                    }
+                // If no tool calls were issued, flush any buffered narration now
+                if (suppressStreamNarration && toolCalls.length === 0 && bufferedContent) {
+                    this.callbacks.onStreamChunk?.(bufferedContent, 'content');
+                    bufferedContent = '';
                 }
                 // Check if we got tool calls
                 if (toolCalls.length > 0) {
-                    // BEHAVIORAL LOOP DETECTION: Check if model is stuck calling same tool repeatedly
-                    // This catches patterns like "git status" called 5 times even with slightly different outputs
-                    const behavioralLoopResult = this.checkBehavioralLoop(toolCalls);
-                    if (behavioralLoopResult) {
-                        this.emitAssistantMessage(behavioralLoopResult, { isFinal: true, usage, contextStats, wasStreamed: true });
-                        this.messages.push({ role: 'assistant', content: behavioralLoopResult });
-                        return behavioralLoopResult;
-                    }
-                    // Loop detection: check if same tool calls are being repeated (exact signature match)
-                    const signatureCalls = toolCalls.filter(call => !this.shouldSkipLoopDetection(call));
-                    const toolSignature = signatureCalls.length
-                        ? signatureCalls
-                            .map((t) => `${t.name}:${JSON.stringify(t.arguments)}`)
-                            .sort()
-                            .join('|')
-                        : null;
-                    if (toolSignature && toolSignature === this.lastToolCallSignature) {
-                        this.repeatedToolCallCount++;
-                        if (this.repeatedToolCallCount >= AgentRuntime.MAX_REPEATED_TOOL_CALLS) {
-                            // Break out of loop - model is stuck
-                            const loopMsg = `Tool loop detected: same tools called ${this.repeatedToolCallCount} times. Please try a different approach or provide more specific instructions.`;
-                            this.emitAssistantMessage(loopMsg, { isFinal: true, usage, contextStats, wasStreamed: true });
-                            this.messages.push({ role: 'assistant', content: loopMsg });
-                            this.lastToolCallSignature = null;
-                            this.repeatedToolCallCount = 0;
-                            return loopMsg;
-                        }
-                    }
-                    else if (toolSignature) {
-                        this.lastToolCallSignature = toolSignature;
-                        this.repeatedToolCallCount = 1;
-                    }
-                    else {
-                        this.lastToolCallSignature = null;
-                        this.repeatedToolCallCount = 0;
-                    }
-                    // Content was already streamed via onStreamChunk, just record it for context
-                    // (wasStreamed=true prevents duplicate display)
-                    // Note: Acknowledgement injection happens during streaming (when first tool_call chunk arrives)
-                    const narration = combinedContent.trim();
+                    const suppressNarration = this.shouldSuppressToolNarration();
+                    const narration = suppressNarration ? '' : combinedContent.trim();
                     if (narration) {
-                        this.emitAssistantMessage(narration, {
-                            isFinal: false,
-                            usage,
-                            contextStats,
-                            wasStreamed: true,
-                        });
+                        // Mark as wasStreamed since content was already output via onStreamChunk
+                        this.emitAssistantMessage(narration, { isFinal: false, usage, contextStats, wasStreamed: true });
                     }
                     const assistantMessage = {
                         role: 'assistant',
-                        content: combinedContent,
+                        content: suppressNarration ? '' : combinedContent,
                         toolCalls,
                     };
                     this.messages.push(assistantMessage);
                     await this.resolveToolCalls(toolCalls);
+                    // Reset auto-continue counter since model is actively working
+                    autoContinueAttempts = 0;
                     continue;
                 }
+                // Check if model expressed intent to act but didn't call tools
+                // This catches "Let me create..." without actual tool calls
+                // Only auto-continue if the feature is enabled
                 const reply = combinedContent.trim();
-                // Reset loop detection when we get a text response (not just tool calls)
-                if (reply.length >= 10) {
-                    this.lastToolCallSignature = null;
-                    this.repeatedToolCallCount = 0;
+                if (this._autoContinueEnabled && shouldAutoContinue(reply, false) && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
+                    autoContinueAttempts++;
+                    // Emit the planning content but mark as non-final
+                    // Mark as wasStreamed since content was already output via onStreamChunk
+                    if (reply) {
+                        this.emitAssistantMessage(reply, { isFinal: false, usage, contextStats, wasStreamed: true });
+                    }
+                    this.messages.push({ role: 'assistant', content: reply });
+                    // Auto-prompt with increasingly direct instructions
+                    const promptIndex = Math.min(autoContinueAttempts - 1, AUTO_CONTINUE_PROMPTS.length - 1);
+                    this.messages.push({
+                        role: 'user',
+                        content: AUTO_CONTINUE_PROMPTS[promptIndex],
+                    });
+                    const autoContinueMessage = `Model expressed intent but didn't use tools. Auto-prompting to continue...`;
+                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, autoContinueMessage);
+                    continue;
                 }
                 // Final message - mark as streamed to avoid double-display in UI
                 if (reply) {
@@ -504,14 +486,6 @@ export class AgentRuntime {
                         continue;
                     }
                 }
-                // Auto-retry transient errors (network issues, rate limits, server errors)
-                if (isTransientError(error) && transientRetryAttempts < MAX_TRANSIENT_RETRIES) {
-                    transientRetryAttempts++;
-                    const delayMs = getRetryDelay(transientRetryAttempts);
-                    this.callbacks.onRetrying?.(transientRetryAttempts, MAX_TRANSIENT_RETRIES, error);
-                    await sleep(delayMs);
-                    continue;
-                }
                 // Re-throw if not recoverable or recovery failed
                 throw error;
             }
@@ -543,23 +517,7 @@ export class AgentRuntime {
         // Fast path: single tool call
         if (numCalls === 1) {
             const call = toolCalls[0];
-            // Check cache first - prevent duplicate identical tool calls
-            const cached = this.getCachedToolResult(call);
-            if (cached !== null) {
-                // Return cached result with indicator that it was from cache
-                this.messages.push({
-                    role: 'tool',
-                    name: call.name,
-                    toolCallId: call.id,
-                    content: `[Cached result - identical call already executed]\n\n${cached}`,
-                });
-                return;
-            }
-            this.callbacks.onToolExecution?.(call.name, true);
             const output = await this.toolRuntime.execute(call);
-            this.callbacks.onToolExecution?.(call.name, false);
-            // Cache the result for future identical calls
-            this.cacheToolResult(call, output);
             this.messages.push({
                 role: 'tool',
                 name: call.name,
@@ -569,106 +527,56 @@ export class AgentRuntime {
             return;
         }
         // PERF: For reasonable batch sizes, execute all in parallel
-        // Check cache for each call and only execute non-cached ones
         if (numCalls <= 10) {
-            const cachedResults = [];
-            const toExecute = [];
-            // Separate cached from non-cached calls
-            for (const call of toolCalls) {
-                const cached = this.getCachedToolResult(call);
-                if (cached !== null) {
-                    cachedResults.push({ call, output: cached, fromCache: true });
-                }
-                else {
-                    toExecute.push(call);
-                }
-            }
-            // Execute non-cached calls in parallel
-            if (toExecute.length > 0) {
-                const toolNames = toExecute.map(c => c.name).join(', ');
-                this.callbacks.onToolExecution?.(toolNames, true);
-                const executed = await Promise.all(toExecute.map(async (call) => {
-                    const output = await this.toolRuntime.execute(call);
-                    this.cacheToolResult(call, output);
-                    return { call, output, fromCache: false };
-                }));
-                this.callbacks.onToolExecution?.(toolNames, false);
-                cachedResults.push(...executed);
-            }
-            // Add all results to messages in the original order
-            for (const originalCall of toolCalls) {
-                const result = cachedResults.find(r => r.call.id === originalCall.id);
-                if (result) {
-                    const content = result.fromCache
-                        ? `[Cached result - identical call already executed]\n\n${result.output}`
-                        : result.output;
-                    this.messages.push({
-                        role: 'tool',
-                        name: result.call.name,
-                        toolCallId: result.call.id,
-                        content,
-                    });
-                }
+            const results = await Promise.all(toolCalls.map(async (call) => ({
+                call,
+                output: await this.toolRuntime.execute(call),
+            })));
+            // Add results to messages in the same order as tool calls
+            for (const { call, output } of results) {
+                this.messages.push({
+                    role: 'tool',
+                    name: call.name,
+                    toolCallId: call.id,
+                    content: output,
+                });
             }
             return;
         }
-        // PERF: For large batches, use chunked parallel execution with caching
+        // PERF: For large batches, use chunked parallel execution
+        // This prevents memory pressure from too many concurrent operations
         const CHUNK_SIZE = 8;
-        const allResults = [];
+        const results = [];
         for (let i = 0; i < numCalls; i += CHUNK_SIZE) {
             const chunk = toolCalls.slice(i, i + CHUNK_SIZE);
-            const cachedInChunk = [];
-            const toExecuteInChunk = [];
-            for (const call of chunk) {
-                const cached = this.getCachedToolResult(call);
-                if (cached !== null) {
-                    cachedInChunk.push({ call, output: cached, fromCache: true });
-                }
-                else {
-                    toExecuteInChunk.push(call);
-                }
-            }
-            if (toExecuteInChunk.length > 0) {
-                const chunkNames = toExecuteInChunk.map(c => c.name).join(', ');
-                this.callbacks.onToolExecution?.(chunkNames, true);
-                const executed = await Promise.all(toExecuteInChunk.map(async (call) => {
-                    const output = await this.toolRuntime.execute(call);
-                    this.cacheToolResult(call, output);
-                    return { call, output, fromCache: false };
-                }));
-                this.callbacks.onToolExecution?.(chunkNames, false);
-                cachedInChunk.push(...executed);
-            }
-            allResults.push(...cachedInChunk);
-        }
-        // Add results to messages in original order
-        for (const originalCall of toolCalls) {
-            const result = allResults.find(r => r.call.id === originalCall.id);
-            if (result) {
-                const content = result.fromCache
-                    ? `[Cached result - identical call already executed]\n\n${result.output}`
-                    : result.output;
-                this.messages.push({
-                    role: 'tool',
-                    name: result.call.name,
-                    toolCallId: result.call.id,
-                    content,
-                });
-            }
+            const chunkResults = await Promise.all(chunk.map(async (call) => ({
+                call,
+                output: await this.toolRuntime.execute(call),
+            })));
+            results.push(...chunkResults);
+        }
+        // Add results to messages in order
+        for (const { call, output } of results) {
+            this.messages.push({
+                role: 'tool',
+                name: call.name,
+                toolCallId: call.id,
+                content: output,
+            });
         }
     }
     get providerTools() {
         return this.toolRuntime.listProviderTools();
     }
     /**
-     * Whether to suppress tool narration in the content field.
-     * Previously suppressed for OpenAI but now we show all thinking/narration.
+     * OpenAI models frequently add speculative tool narration in the content field.
+     * Suppress that text to avoid surfacing hallucinated tool usage in the UI.
      */
     shouldSuppressToolNarration() {
-        return false; // Always show thinking/narration
+        return this.providerId.toLowerCase().includes('openai');
     }
     emitAssistantMessage(content, metadata) {
-        if (!content || !content.trim()) {
+        if (!content) {
             return;
         }
         const elapsedMs = this.activeRun ? Date.now() - this.activeRun.startedAt : undefined;
@@ -718,165 +626,6 @@ export class AgentRuntime {
             model: this.modelId,
         });
     }
-    /**
-     * Extract a "command hash" from tool arguments for behavioral loop detection.
-     * For execute_bash, this is the actual command. For other tools, key identifying args.
-     */
-    extractCmdHash(name, args) {
-        // For bash/execute commands, extract the command itself
-        if (name === 'execute_bash' || name === 'Bash') {
-            const cmd = args['command'];
-            if (cmd) {
-                // Normalize: trim, take first 100 chars, remove variable parts like timestamps
-                return cmd.trim().slice(0, 100).replace(/\d{10,}/g, 'N');
-            }
-        }
-        // For file operations, use the path
-        if (name === 'read_file' || name === 'Read' || name === 'read_files') {
-            const path = args['path'] || args['file_path'] || args['paths'];
-            if (path)
-                return `path:${JSON.stringify(path).slice(0, 100)}`;
-        }
-        if (name === 'list_files' || name === 'Glob') {
-            const path = args['path'] || args['pattern'];
-            if (path)
-                return `path:${JSON.stringify(path).slice(0, 100)}`;
-        }
-        // For search, use the query/pattern
-        if (name === 'Grep' || name === 'grep' || name === 'search') {
-            const pattern = args['pattern'] || args['query'];
-            if (pattern)
-                return `search:${String(pattern).slice(0, 100)}`;
-        }
-        // Default: use first significant arg value
-        const firstArg = Object.values(args)[0];
-        if (firstArg) {
-            return String(firstArg).slice(0, 100);
-        }
-        return 'no-args';
-    }
-    /**
-     * Check for behavioral loops - model calling the same tool with similar args repeatedly.
-     * Returns an error message if a loop is detected, null otherwise.
-     *
-     * FUNDAMENTAL PREVENTION: Cached calls are excluded from loop detection since they
-     * don't actually execute (the cache provides the result). This means:
-     * - First call: executes and caches result
-     * - Second identical call: returns cached result, NOT counted toward loop
-     * - Only genuinely NEW (non-cached) repetitive calls trigger loop detection
-     *
-     * Direct execution tools (bash/edit) are also exempt to avoid short-circuiting
-     * legitimate repeated user commands.
-     *
-     * This catches patterns like:
-     * - "git status -sb" called 3 times with DIFFERENT outputs (cache miss each time)
-     * - Repeated file reads where file content changed
-     * - Repeated searches with same pattern but new results
-     */
-    checkBehavioralLoop(toolCalls) {
-        // Skip loop detection for direct execution tools (bash/edit) to avoid false positives
-        const loopEligibleCalls = toolCalls.filter(call => !this.shouldSkipLoopDetection(call));
-        if (loopEligibleCalls.length === 0) {
-            return null;
-        }
-        // Filter out calls that will be served from cache - these don't count toward loops
-        // since they're handled fundamentally by the caching mechanism
-        const nonCachedCalls = loopEligibleCalls.filter(call => this.getCachedToolResult(call) === null);
-        // If all calls are cached, no loop detection needed
-        if (nonCachedCalls.length === 0) {
-            return null;
-        }
-        // Count existing occurrences in recent history
-        const existingCounts = new Map();
-        for (const { name, cmdHash } of this.recentToolCalls) {
-            const key = `${name}:${cmdHash}`;
-            existingCounts.set(key, (existingCounts.get(key) ?? 0) + 1);
-        }
-        // Check if ANY incoming NON-CACHED call would exceed threshold
-        for (const call of nonCachedCalls) {
-            const cmdHash = this.extractCmdHash(call.name, call.arguments ?? {});
-            const key = `${call.name}:${cmdHash}`;
-            const currentCount = existingCounts.get(key) ?? 0;
-            // If adding this call would reach or exceed threshold, block immediately
-            if (currentCount + 1 >= AgentRuntime.BEHAVIORAL_LOOP_THRESHOLD) {
-                // Reset history to prevent immediate re-trigger
-                this.recentToolCalls = [];
-                return `Behavioral loop detected: "${call.name}" called ${currentCount + 1} times with similar arguments. The task appears stuck. Please try a different approach or provide more specific instructions.`;
-            }
-        }
-        // Track only non-cached tool calls (cached ones are handled by caching)
-        for (const call of nonCachedCalls) {
-            const cmdHash = this.extractCmdHash(call.name, call.arguments ?? {});
-            this.recentToolCalls.push({ name: call.name, cmdHash });
-        }
-        // Keep only recent history
-        while (this.recentToolCalls.length > AgentRuntime.TOOL_HISTORY_SIZE) {
-            this.recentToolCalls.shift();
-        }
-        return null;
-    }
-    /**
-     * Reset behavioral loop tracking (called when user provides new input or task completes)
-     */
-    resetBehavioralLoopTracking() {
-        this.recentToolCalls = [];
-        this.lastToolCallSignature = null;
-        this.repeatedToolCallCount = 0;
-        // Note: we DON'T clear toolResultCache here for cacheable tools; stateful tools bypass caching
-    }
-    /**
-     * Create a stable cache key for a tool call based on name and arguments
-     */
-    getToolCacheKey(call) {
-        const args = call.arguments ?? {};
-        // Sort keys for consistent ordering
-        const sortedArgs = Object.keys(args).sort().reduce((acc, key) => {
-            acc[key] = args[key];
-            return acc;
-        }, {});
-        return `${call.name}:${JSON.stringify(sortedArgs)}`;
-    }
-    /**
-     * Only cache tools that are safe to reuse; stateful commands must always execute.
-     */
-    isCacheableTool(call) {
-        const nameLower = call.name.toLowerCase();
-        return !AgentRuntime.NON_CACHEABLE_TOOL_NAMES.has(nameLower);
-    }
-    /**
-     * Direct execution tools should not trigger behavioral loop short-circuiting.
-     */
-    shouldSkipLoopDetection(call) {
-        const nameLower = call.name.toLowerCase();
-        return AgentRuntime.LOOP_EXEMPT_TOOL_NAMES.has(nameLower);
-    }
-    /**
-     * Get cached result for a tool call, or null if not cached
-     */
-    getCachedToolResult(call) {
-        if (!this.isCacheableTool(call)) {
-            return null;
-        }
-        const key = this.getToolCacheKey(call);
-        return this.toolResultCache.get(key) ?? null;
-    }
-    /**
-     * Cache a tool result for future identical calls
-     */
-    cacheToolResult(call, result) {
-        if (!this.isCacheableTool(call)) {
-            return;
-        }
-        const key = this.getToolCacheKey(call);
-        // Evict oldest entries if cache is full
-        if (this.toolResultCache.size >= AgentRuntime.TOOL_CACHE_MAX_SIZE) {
-            const firstKey = this.toolResultCache.keys().next().value;
-            if (firstKey) {
-                this.toolResultCache.delete(firstKey);
-            }
-        }
-        this.toolResultCache.set(key, result);
-    }
     getHistory() {
         return this.messages.map(cloneMessage);
     }