erosolar-cli 2.1.168 → 2.1.169

package/dist/core/agent.js

@@ -4,65 +4,7 @@ import { safeErrorMessage } from './secretStore.js';
  * Maximum number of context overflow recovery attempts
  */
 const MAX_CONTEXT_RECOVERY_ATTEMPTS = 3;
-/**
- * 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;
-}
+// Streaming runs without timeouts - we let the model take as long as it needs
 /**
  * Check if an error is a context overflow error
  */
@@ -77,15 +19,53 @@ function isContextOverflowError(error) {
         message.includes('max_tokens') ||
         message.includes('context window'));
 }
-class StreamInterruptionError extends Error {
-    reason;
-    partialResponse;
-    constructor(reason, message, partialResponse) {
-        super(message);
-        this.name = 'StreamInterruptionError';
-        this.reason = reason;
-        this.partialResponse = partialResponse;
+/**
+ * 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;
+    }
+    // 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 = [];
@@ -99,7 +79,19 @@ export class AgentRuntime {
     modelId;
     workingDirectory;
     cancellationRequested = false;
-    _autoContinueEnabled = 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
+    // 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
     constructor(options) {
         this.provider = options.provider;
         this.toolRuntime = options.toolRuntime;
@@ -108,7 +100,6 @@ 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) {
@@ -134,25 +125,14 @@ 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 at start of new request
+        // Reset cancellation flag and loop tracking 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);
@@ -168,28 +148,9 @@ export class AgentRuntime {
         const run = { startedAt: Date.now() };
         this.activeRun = run;
         try {
+            // Always use streaming when available - no fallback
             if (useStreaming && this.provider.generateStream) {
-                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.processConversationStreaming();
             }
             return await this.processConversation();
         }
@@ -203,7 +164,7 @@ export class AgentRuntime {
     }
     async processConversation() {
         let contextRecoveryAttempts = 0;
-        let autoContinueAttempts = 0;
+        let transientRetryAttempts = 0;
         while (true) {
             // Check for cancellation at start of each iteration
             if (this.cancellationRequested) {
@@ -219,44 +180,59 @@ export class AgentRuntime {
                 // Reset recovery attempts on successful generation
                 contextRecoveryAttempts = 0;
                 if (response.type === 'tool_calls') {
-                    const suppressNarration = this.shouldSuppressToolNarration();
-                    const narration = suppressNarration ? '' : response.content?.trim();
+                    // 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 toolSignature = response.toolCalls
+                        .map((t) => `${t.name}:${JSON.stringify(t.arguments)}`)
+                        .sort()
+                        .join('|');
+                    if (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 {
+                        this.lastToolCallSignature = toolSignature;
+                        this.repeatedToolCallCount = 1;
+                    }
+                    // Emit narration if present - it shows the AI's thought process before tools
+                    const narration = response.content?.trim();
                     if (narration) {
-                        this.emitAssistantMessage(narration, { isFinal: false, usage, contextStats });
+                        this.emitAssistantMessage(narration, {
+                            isFinal: false,
+                            usage,
+                            contextStats,
+                        });
                     }
                     const assistantMessage = {
                         role: 'assistant',
-                        content: suppressNarration ? '' : (response.content ?? ''),
+                        content: 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() ?? '';
-                // 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;
+                // Reset loop detection when we get a text response (not just tool calls)
+                if (reply.length >= 10) {
+                    this.lastToolCallSignature = null;
+                    this.repeatedToolCallCount = 0;
                 }
                 if (reply) {
                     this.emitAssistantMessage(reply, { isFinal: true, usage, contextStats });
@@ -278,6 +254,14 @@ 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;
             }
@@ -288,7 +272,7 @@ export class AgentRuntime {
             return this.processConversation();
         }
         let contextRecoveryAttempts = 0;
-        let autoContinueAttempts = 0;
+        let transientRetryAttempts = 0;
         while (true) {
             // Check for cancellation at start of each iteration
             if (this.cancellationRequested) {
@@ -321,45 +305,10 @@ export class AgentRuntime {
                         }
                     }
                 };
-                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;
+                // Simple streaming loop - no timeouts, let the stream run until done
                 try {
                     while (true) {
-                        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();
+                        const result = await iterator.next();
                         // Check for cancellation during streaming
                         if (this.cancellationRequested) {
                             await closeStream();
@@ -374,17 +323,10 @@ 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) {
@@ -397,11 +339,19 @@ export class AgentRuntime {
                             }
                         }
                         else if (chunk.type === 'tool_call' && chunk.toolCall) {
-                            toolCalls.push(chunk.toolCall);
-                            // Drop any speculative narration once we know the model is actually calling tools
-                            if (suppressStreamNarration) {
-                                bufferedContent = '';
+                            // 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);
                         }
                         else if (chunk.type === 'usage' && chunk.usage) {
                             usage = chunk.usage;
@@ -409,61 +359,81 @@ 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, flush any buffered narration now
-                if (suppressStreamNarration && toolCalls.length === 0 && bufferedContent) {
-                    this.callbacks.onStreamChunk?.(bufferedContent, 'content');
-                    bufferedContent = '';
+                // 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 = '';
+                    }
                 }
                 // Check if we got tool calls
                 if (toolCalls.length > 0) {
-                    const suppressNarration = this.shouldSuppressToolNarration();
-                    const narration = suppressNarration ? '' : combinedContent.trim();
+                    // 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 toolSignature = toolCalls
+                        .map((t) => `${t.name}:${JSON.stringify(t.arguments)}`)
+                        .sort()
+                        .join('|');
+                    if (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 {
+                        this.lastToolCallSignature = toolSignature;
+                        this.repeatedToolCallCount = 1;
+                    }
+                    // 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();
                     if (narration) {
-                        // Mark as wasStreamed since content was already output via onStreamChunk
-                        this.emitAssistantMessage(narration, { isFinal: false, usage, contextStats, wasStreamed: true });
+                        this.emitAssistantMessage(narration, {
+                            isFinal: false,
+                            usage,
+                            contextStats,
+                            wasStreamed: true,
+                        });
                     }
                     const assistantMessage = {
                         role: 'assistant',
-                        content: suppressNarration ? '' : combinedContent,
+                        content: 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();
-                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;
+                // Reset loop detection when we get a text response (not just tool calls)
+                if (reply.length >= 10) {
+                    this.lastToolCallSignature = null;
+                    this.repeatedToolCallCount = 0;
                 }
                 // Final message - mark as streamed to avoid double-display in UI
                 if (reply) {
@@ -486,6 +456,14 @@ 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;
             }
@@ -517,7 +495,23 @@ 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,
@@ -527,56 +521,106 @@ 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 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,
-                });
+            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,
+                    });
+                }
             }
             return;
         }
-        // PERF: For large batches, use chunked parallel execution
-        // This prevents memory pressure from too many concurrent operations
+        // PERF: For large batches, use chunked parallel execution with caching
         const CHUNK_SIZE = 8;
-        const results = [];
+        const allResults = [];
         for (let i = 0; i < numCalls; i += CHUNK_SIZE) {
             const chunk = toolCalls.slice(i, i + CHUNK_SIZE);
-            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,
-            });
+            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,
+                });
+            }
         }
     }
     get providerTools() {
         return this.toolRuntime.listProviderTools();
     }
     /**
-     * OpenAI models frequently add speculative tool narration in the content field.
-     * Suppress that text to avoid surfacing hallucinated tool usage in the UI.
+     * Whether to suppress tool narration in the content field.
+     * Previously suppressed for OpenAI but now we show all thinking/narration.
      */
     shouldSuppressToolNarration() {
-        return this.providerId.toLowerCase().includes('openai');
+        return false; // Always show thinking/narration
     }
     emitAssistantMessage(content, metadata) {
-        if (!content) {
+        if (!content || !content.trim()) {
             return;
         }
         const elapsedMs = this.activeRun ? Date.now() - this.activeRun.startedAt : undefined;
@@ -626,6 +670,138 @@ 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
+     *
+     * 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) {
+        // 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 = toolCalls.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 - cached results remain valid across turns
+        // to prevent re-executing identical tool calls within a session
+    }
+    /**
+     * 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)}`;
+    }
+    /**
+     * Get cached result for a tool call, or null if not cached
+     */
+    getCachedToolResult(call) {
+        const key = this.getToolCacheKey(call);
+        return this.toolResultCache.get(key) ?? null;
+    }
+    /**
+     * Cache a tool result for future identical calls
+     */
+    cacheToolResult(call, result) {
+        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);
     }