erosolar-cli 2.1.166 → 2.1.168

package/dist/core/agent.js

@@ -6,347 +6,62 @@ import { safeErrorMessage } from './secretStore.js';
 const MAX_CONTEXT_RECOVERY_ATTEMPTS = 3;
 /**
  * Maximum number of auto-continuation attempts when model expresses intent but doesn't act
- * Increased to allow more recovery attempts for complex tasks
  */
-const MAX_AUTO_CONTINUE_ATTEMPTS = 8;
+const MAX_AUTO_CONTINUE_ATTEMPTS = 3;
 /**
- * Threshold for short completion - responses shorter than this can be valid completions.
- * Anything longer after tool work needs scrutiny.
+ * 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
  */
-const SHORT_COMPLETION_THRESHOLD = 80;
-const AUTO_CONTINUE_ESCALATION_ATTEMPT = 4;
-// Streaming runs without timeouts - we let the model take as long as it needs
+// 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 = [
-    // TEXT-FORMATTED TOOL CALLS: Model outputs tool call as text instead of using API
-    // These are CRITICAL to catch - model is trying to call tools but failing to do so properly
-    // Pattern: "_tool_call_" or similar markers followed by function-like syntax
-    /_tool_call_\s*\n?\s*\w+\(/im,
-    // Pattern: "tool_call:" or "Tool call:" followed by function name
-    /tool[_\s]?call:?\s*\n?\s*\w+\(/im,
-    // Pattern: function call syntax at start of line like "read_file(..." without being in code block
-    /^\s*(read_file|write_file|edit_file|execute_bash|list_files|search|grep|glob)\s*\(/im,
-    // Pattern: "Executing X..." or "Calling X..." without actual tool call
-    /\b(executing|calling)\s+(read_file|write_file|edit_file|execute_bash|list_files|search|grep|glob)\b/i,
-    // Pattern: indented tool call syntax like "  read_file(package.json)"
-    /^\s{2,}(read_file|write_file|edit_file|execute_bash|list_files|Bash|Read|Write|Edit|Grep|Glob)\s*\([^)]*\)\s*$/im,
     // "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|run)/i,
-    // "I'll X" / "I will X" patterns - include all apostrophe variants (straight ', left ', right ')
-    /\bi['''\u2018\u2019]ll\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|start|begin|now|use|inspect|examine|run)/i,
-    /\bi will\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|start|begin|now|use|inspect|examine|run)/i,
-    // "Will X" without "I" (common pattern)
-    /\bwill\s+(run|use|read|search|check|inspect|examine|list|find|analyze|create|write|look)\s/i,
-    // "I'm going to X" patterns - include all apostrophe variants
-    /\bi['''\u2018\u2019]m going to\s+(create|write|implement|add|update|edit|modify|fix|build|make|refactor|read|check|look|search|find|analyze|run)/i,
+    /\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['''\u2018\u2019]ll\s+/i,
+    /\b(now|first|next)\s*(,)?\s*i['']ll\s+/i,
     // Explicit continuation signals
-    /\bhere['''\u2018\u2019]s (the|my) (plan|approach|solution|implementation)/i,
-    // "Approach:" header indicates planning without action
-    /\bapproach:/i,
+    /\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,
-    // Statements about needing to do something
-    /\bneed\s+(to\s+)?(identify|search|find|check|read|look|inspect|analyze|examine|review|list|remove)/i,
-    // "Should be X" - model is describing action but not taking it
-    /\bshould be\s+(deleted|removed|fixed|updated|changed|cleaned|cleared)/i,
-    // "Can be X" - same pattern
-    /\bcan be\s+(deleted|removed|fixed|updated|changed|cleaned|cleared)/i,
-    // Questions that should trigger investigation instead of asking user
-    /\bwhat (files?|areas?|code|patterns?)\s+(should|would you like|do you want)/i,
-    // GIVING UP PATTERNS - model is asking for clarification instead of investigating
-    /\bplease\s+(point me to|show me|tell me|specify|clarify|provide)/i,
-    /\bwithout\s+(more|additional|further)\s+(details?|info|information|context|guidance)/i,
-    /\bcan you\s+(clarify|specify|tell me|point me|show me)/i,
-    /\blet me know\s+(what|which|where|how)/i,
-    /\b(no|can['\u2018\u2019]t|cannot)\s+(obvious|clear|specific|find|identify|determine)/i,
-    // "I don't have enough" type responses
-    /\bdon['\u2018\u2019]t have\s+(enough|sufficient|the)\s+(info|information|context|details)/i,
-    // "Could you" requests for clarification
-    /\bcould you\s+(provide|specify|clarify|point|tell|show)/i,
 ];
-/**
- * Patterns that indicate the model gave a premature summary without concrete findings.
- * These summaries wrap up too quickly without file:line citations or code snippets.
- */
-const PREMATURE_CONCLUSION_PATTERNS = [
-    // "Performed/Did a quick X" - surface-level investigation claim
-    /\b(performed|did)\s+a\s+(quick|brief|fast)\s+(search|grep|scan|review|check)/i,
-    // "Validated by running" - claiming verification without showing details
-    /\bvalidated\s+by\s+running/i,
-    // Mentioning matches but not examining them: "found X matches" without file paths
-    /\bfound\s+\d+\s+(match|result|item|file|issue)/i,
-    // Summary without substance: "cleaned up", "removed", "fixed" but no specifics
-    // Allow any words between the article and the target noun (e.g., "removed the .tsbuildinfo build cache")
-    /\b(cleaned up|removed|fixed)\s+(the|a|some)?\s*\S*\s*(file|cache|build|artifact)/i,
-];
-/**
- * Check if response looks like a premature conclusion without concrete findings.
- * Looks for summary language without actual file:line citations.
- */
-function isPrematureConclusion(content) {
-    // Must match a premature conclusion pattern
-    const matchesPremature = PREMATURE_CONCLUSION_PATTERNS.some(p => p.test(content));
-    if (!matchesPremature) {
-        return false;
-    }
-    // Check if there are actual file:line citations (e.g., "src/foo.ts:42")
-    const hasFileCitation = /\b\w+\.(ts|js|tsx|jsx|py|go|rs|java|c|cpp|h|md|json|yaml|yml):\d+\b/.test(content);
-    if (hasFileCitation) {
-        return false; // Has concrete findings, not premature
-    }
-    // Check for code blocks with actual code
-    const hasCodeBlock = /```[\s\S]{20,}```/.test(content);
-    if (hasCodeBlock) {
-        return false; // Has code snippets, not premature
-    }
-    // Short response with no concrete findings = premature conclusion
-    return content.length < 500;
-}
-// Short, forceful prompts - model should just act
 const AUTO_CONTINUE_PROMPTS = [
-    'Continue.',
-    'Keep going. Call tools.',
-    'You stopped mid-task. Continue with tools.',
-    'Do not summarize. Act with tools or ask a specific question.',
-    'Use tools to complete the task.',
+    '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.',
 ];
-// Specific prompt for when model outputs text-formatted tool calls instead of using the API
-const TEXT_TOOL_CALL_PROMPT = 'You wrote a tool call as text. Use the actual tool API - call the function directly, do not write it as text.';
-// Forceful prompt used when the model keeps narrating or stalling after several attempts
-const AUTO_CONTINUE_FORCE_PROMPT = 'You are stuck narrating. Immediately call the necessary tools to finish the task. If truly done, respond with a concise final answer citing any file paths/lines touched. Do not ask for confirmation.';
-const SHORT_RESPONSE_PROMPT = 'Based on the tool results above, provide your complete response. Summarize findings and suggest next steps if applicable.';
 /**
- * Select an auto-continue prompt and user-facing message based on attempt count and reason.
- * Escalates to a forceful instruction after repeated stalls.
+ * 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 buildAutoContinueInstruction(attempt, reason) {
-    const promptIndex = Math.max(0, Math.min(attempt - 1, AUTO_CONTINUE_PROMPTS.length - 1));
-    let prompt;
-    switch (reason) {
-        case 'text_tool_call':
-            prompt = TEXT_TOOL_CALL_PROMPT;
-            break;
-        case 'short_response':
-            prompt = SHORT_RESPONSE_PROMPT;
-            break;
-        default:
-            prompt = AUTO_CONTINUE_PROMPTS[promptIndex];
-            break;
-    }
-    const isEscalated = attempt >= AUTO_CONTINUE_ESCALATION_ATTEMPT;
-    if (isEscalated) {
-        prompt = AUTO_CONTINUE_FORCE_PROMPT;
-    }
-    const baseMessage = {
-        after_tools_narration: 'Model narrated after tools instead of completing. Prompting to continue...',
-        intent_without_action: "Model expressed intent but didn't act. Prompting to continue...",
-        text_tool_call: 'Model wrote tool call as text instead of using API. Prompting to use actual tools...',
-        short_response: 'Model responded too briefly. Prompting for a complete answer...',
-    };
-    const message = isEscalated
-        ? `${baseMessage[reason]} Escalating to force tool use and completion.`
-        : baseMessage[reason];
-    return { prompt, message };
-}
-/**
- * Generate a short, UI-safe preview of planning/intent text.
- * Keeps only the first line and truncates long content.
- */
-function buildPlanningPreview(content, maxLength = 140) {
-    const trimmed = (content || '').trim();
-    if (!trimmed) {
-        return null;
-    }
-    const firstLine = trimmed.split('\n').find(line => line.trim()) ?? '';
-    const collapsed = firstLine.replace(/\s+/g, ' ').trim();
-    if (!collapsed) {
-        return null;
-    }
-    const needsEllipsis = collapsed.length > maxLength;
-    const preview = collapsed.slice(0, maxLength).trim();
-    return needsEllipsis ? `${preview}...` : preview;
-}
-/**
- * Detect if content contains text-formatted tool calls that should have been actual API calls.
- * This is a PROGRAMMATIC check - if the model outputs "read_file(package.json)" as text,
- * it clearly intended to call a tool but failed to use the proper API.
- */
-function hasTextFormattedToolCall(content) {
-    // Patterns that indicate the model wrote a tool call as text instead of using the API
-    const textToolCallPatterns = [
-        // "_tool_call_" marker with function syntax
-        /_tool_call_\s*\n?\s*\w+\(/im,
-        // "tool_call:" followed by function name
-        /tool[_\s]?call:?\s*\n?\s*\w+\(/im,
-        // Common tool function call syntax at line start (not in code block)
-        /^\s*(read_file|write_file|edit_file|execute_bash|list_files)\s*\([^)]+\)/im,
-        // Indented tool call like "  read_file(package.json)"
-        /^\s{2,}(read_file|write_file|edit_file|execute_bash|list_files|Bash|Read|Write|Edit|Grep|Glob)\s*\([^)]*\)\s*$/im,
-        // "Executing/Calling tool_name..." without actual execution
-        /\b(executing|calling)\s+(read_file|write_file|edit_file|execute_bash)\s*\.{3}?\s*$/im,
-    ];
-    // Skip if the content is inside a code block (```...```)
-    const withoutCodeBlocks = content.replace(/```[\s\S]*?```/g, '');
-    return textToolCallPatterns.some(p => p.test(withoutCodeBlocks));
-}
-/**
- * Patterns that indicate genuine completion of a task.
- * These are short, definitive statements that signal work is done.
- */
-const COMPLETION_SIGNAL_PATTERNS = [
-    // Explicit done signals
-    /^(done|complete|finished|all set)[.!]?$/i,
-    // Short confirmations with specifics
-    /^(removed|deleted|fixed|created|updated|added)\s+.{1,50}[.!]?$/i,
-    // "X is now Y" short statements
-    /^.{1,30}\s+is\s+now\s+.{1,30}[.!]?$/i,
-    // Task completion with count
-    /^(cleaned|removed|fixed|updated)\s+\d+\s+.{1,30}[.!]?$/i,
-];
-/**
- * Patterns that indicate errors, failures, or incomplete work.
- * When these are present, auto-continue should kick in to fix the issues.
- * This is a PROGRAMMATIC check - if errors are reported, the task is NOT complete.
- */
-const ERROR_INDICATOR_PATTERNS = [
-    // Build/compile errors
-    /\b(error|errors|fail(s|ed|ure|ing)?|broken|crash(es|ed|ing)?)\b/i,
-    // Test failures
-    /\b(test(s)?\s+(fail|failing|failed)|failing\s+test)/i,
-    // TypeScript/compilation errors
-    /\b(typescript|ts|type)\s+error/i,
-    /\bts\(\d+,\d+\)/i, // TS error format like ts(700,45)
-    // Remaining/unresolved issues
-    /\b(persists?|remains?|still\s+(has|have|is|are|broken|failing))\b/i,
-    /\b(unresolved|outstanding|remaining)\s+(error|issue|problem)/i,
-    // Explicit incomplete signals
-    /\b(didn'?t|did\s+not|couldn'?t|could\s+not|wasn'?t|was\s+not)\s+(work|succeed|complete|finish|pass)/i,
-    /\b(skipped|blocked|cannot|unable\s+to)\b/i,
-];
-/**
- * Check if response contains error indicators that mean work is NOT complete.
- * This is a simple, programmatic check - no complex NLP needed.
- */
-function containsErrorIndicators(content) {
-    return ERROR_INDICATOR_PATTERNS.some(p => p.test(content));
-}
-/**
- * Check if response is a genuine completion signal (short, definitive statement).
- * Returns true if the model is signaling it's actually done with the task.
- * IMPORTANT: Returns false if error indicators are present - model should continue.
- */
-function isCompletionSignal(content) {
-    const trimmed = content.trim();
-    // PROGRAMMATIC: If errors are reported, this is NOT a valid completion
-    if (containsErrorIndicators(trimmed)) {
-        return false;
-    }
-    // Very short responses (<50 chars) with completion patterns are genuine signals
-    if (trimmed.length < 50) {
-        return COMPLETION_SIGNAL_PATTERNS.some(p => p.test(trimmed));
-    }
-    // Responses asking user for direction are valid stops
-    if (/\b(would you like|shall I|want me to|anything else)\b/i.test(trimmed) && trimmed.length < 200) {
-        return true;
-    }
-    // File:line citations indicate concrete work was shown
-    const hasCitation = /\b\w+\.(ts|js|tsx|jsx|py|go|rs|java|c|cpp|h|md|json|yaml|yml):\d+\b/.test(trimmed);
-    if (hasCitation) {
-        return true;
-    }
-    return false;
-}
-/**
- * PROGRAMMATIC CHECK: After tool calls, should we auto-continue?
- *
- * SIMPLE RULE: After tools, model should ONLY stop if:
- * 1. It asks the user a question (ends with ?)
- * 2. It gives a very short completion (< 80 chars) WITHOUT planning words
- *
- * Everything else = CONTINUE. This is intentionally aggressive.
- * The model should either be DONE (short message) or ASKING (question).
- * Long explanations after tool work = continue to force action.
- */
-function shouldContinueAfterTools(content) {
-    const trimmed = content.trim();
-    // No content after tools = continue to get results
-    if (trimmed.length === 0) {
-        return true;
-    }
-    // ALWAYS CONTINUE: Error indicators mean work isn't done
-    if (containsErrorIndicators(trimmed)) {
-        return true;
-    }
-    // ALWAYS CONTINUE: Intent/planning patterns mean model wants to do more
-    if (INTENT_WITHOUT_ACTION_PATTERNS.some(p => p.test(trimmed))) {
-        return true;
-    }
-    // VALID STOP: Model asking user a question (ends with ?)
-    if (/\?\s*$/.test(trimmed)) {
+function shouldAutoContinue(content, hasToolCalls) {
+    // If there are tool calls, no need to auto-continue
+    if (hasToolCalls) {
         return false;
     }
-    // VALID STOP: Explicit user-direction phrases
-    if (/\b(would you like|shall I|want me to|do you want|should I|what would you prefer)\b/i.test(trimmed)) {
+    // If content is very short, likely not an incomplete intent
+    if (content.length < 50) {
         return false;
     }
-    // VALID STOP: Very short completion (< 80 chars) - likely "Done." or similar
-    // But ONLY if it doesn't have planning words
-    if (trimmed.length < SHORT_COMPLETION_THRESHOLD) {
-        const hasPlanningWords = /\b(i'll|i will|let me|i need|i'm going|will now|going to|first|next|now i)\b/i.test(trimmed);
-        if (!hasPlanningWords) {
-            return false; // Short and not planning = valid completion
+    // Check for intent patterns
+    for (const pattern of INTENT_WITHOUT_ACTION_PATTERNS) {
+        if (pattern.test(content)) {
+            return true;
         }
-        // Short but has planning words = continue
-        return true;
-    }
-    // CONTINUE: Long response after tools = likely narrating/summarizing
-    // Force model to either ask a question or give a short completion
-    return true;
-}
-function shouldAutoContinue(content, hasToolCalls, hasReasoningContent = false) {
-    // Strip <thinking> blocks to get actual response content
-    const withoutThinking = content.replace(/<thinking>[\s\S]*?<\/thinking>/gi, '').trim();
-    // Empty content shouldn't trigger auto-continue
-    if (withoutThinking.length === 0) {
-        return { shouldContinue: false };
-    }
-    // HIGHEST PRIORITY: Check for text-formatted tool calls
-    // This is when the model writes "read_file(package.json)" as text instead of calling the API
-    if (hasTextFormattedToolCall(withoutThinking)) {
-        return { shouldContinue: true, reason: 'text_tool_call' };
-    }
-    // PROGRAMMATIC: If response reports errors/failures, auto-continue to fix them
-    // This is critical - if model reports "error persists" or "build failed", it should continue
-    if (containsErrorIndicators(withoutThinking)) {
-        return { shouldContinue: true, reason: 'error_indicators' };
     }
-    // If model output thinking/reasoning without much content, likely needs prompting
-    if (hasReasoningContent && withoutThinking.length < 30) {
-        return { shouldContinue: true, reason: 'short_reasoning' };
-    }
-    // Check for intent patterns - model wants to do more work
-    const hasMoreIntent = INTENT_WITHOUT_ACTION_PATTERNS.some(p => p.test(withoutThinking));
-    // Even if tools were called, continue if narrative expresses MORE intent
-    // e.g., model calls grep but then says "I need to remove..." - should continue
-    if (hasToolCalls) {
-        return { shouldContinue: hasMoreIntent, reason: hasMoreIntent ? 'intent_patterns' : undefined };
-    }
-    // No tool calls - check for intent or premature conclusion
-    if (hasMoreIntent) {
-        return { shouldContinue: true, reason: 'intent_patterns' };
-    }
-    // Check for premature conclusions - model summarized without concrete findings
-    if (isPrematureConclusion(withoutThinking)) {
-        return { shouldContinue: true, reason: 'premature_conclusion' };
-    }
-    return { shouldContinue: false };
+    return false;
 }
 /**
  * Check if an error is a context overflow error
@@ -362,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;
-    }
-    // Rate limit errors
-    if (message.includes('rate limit') || message.includes('429') || message.includes('too many requests')) {
-        return true;
+class StreamInterruptionError extends Error {
+    reason;
+    partialResponse;
+    constructor(reason, message, partialResponse) {
+        super(message);
+        this.name = 'StreamInterruptionError';
+        this.reason = reason;
+        this.partialResponse = partialResponse;
     }
-    // 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 = [];
@@ -423,21 +100,6 @@ export class AgentRuntime {
     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
-    // Track if first tool call callback has been fired this turn
-    firstToolCallFired = false;
     constructor(options) {
         this.provider = options.provider;
         this.toolRuntime = options.toolRuntime;
@@ -489,20 +151,8 @@ export class AgentRuntime {
         if (!prompt) {
             return '';
         }
-        // CRITICAL: Fire acknowledgement callback IMMEDIATELY - before ANY other processing
-        // This guarantees the user sees feedback the moment their request is received
-        if (this.callbacks.onRequestReceived) {
-            const maxLength = 160;
-            const normalized = prompt.replace(/\s+/g, ' ');
-            const preview = normalized.length > maxLength
-                ? `${normalized.slice(0, maxLength - 3)}...`
-                : normalized;
-            this.callbacks.onRequestReceived(preview);
-        }
-        // Reset cancellation flag, loop tracking, and first tool call flag at start of new request
+        // Reset cancellation flag at start of new request
         this.cancellationRequested = false;
-        this.resetBehavioralLoopTracking();
-        this.firstToolCallFired = false;
         // Handle multi-line paste: show summary to user, send full content to AI
         if (isMultilinePaste(prompt)) {
             const processed = processPaste(prompt);
@@ -518,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();
         }
@@ -535,7 +204,6 @@ 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) {
@@ -551,120 +219,43 @@ 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 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;
-                    }
-                    // Always emit narration if present - it shows the AI's thought process before tools
-                    const narration = response.content?.trim();
-                    const hasNarration = !!narration;
-                    // Fire first tool call callback if not yet fired this turn
-                    // ALWAYS emit acknowledgement before first tool - ensures user sees immediate feedback
-                    if (!this.firstToolCallFired && this.callbacks.onBeforeFirstToolCall) {
-                        this.firstToolCallFired = true;
-                        const toolNames = response.toolCalls.map(t => t.name);
-                        const injectedAck = this.callbacks.onBeforeFirstToolCall(toolNames, hasNarration);
-                        // ALWAYS emit acknowledgement if returned - provides immediate user feedback
-                        if (injectedAck) {
-                            this.emitAssistantMessage(injectedAck, { isFinal: false, usage, contextStats });
-                        }
-                    }
+                    const suppressNarration = this.shouldSuppressToolNarration();
+                    const narration = suppressNarration ? '' : response.content?.trim();
                     if (narration) {
                         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);
-                    // PROGRAMMATIC CONTINUATION: After tool work, model must either:
-                    // 1. Call more tools (already handled by continue above)
-                    // 2. Give a short completion signal
-                    // 3. Ask user for direction
-                    // PROGRAMMATIC: If model outputs narrative instead of concrete findings, continue
-                    if (this._autoContinueEnabled && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
-                        if (shouldContinueAfterTools(narration ?? '')) {
-                            autoContinueAttempts++;
-                            const instruction = buildAutoContinueInstruction(autoContinueAttempts, 'after_tools_narration');
-                            this.messages.push({
-                                role: 'user',
-                                content: instruction.prompt,
-                            });
-                            this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, instruction.message);
-                            continue;
-                        }
-                    }
                     // 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;
-                }
-                // If model returned empty or very short AND auto-continue is enabled, prompt it to respond
-                // This is disabled by default to prevent loops
-                if (this._autoContinueEnabled && reply.length < 10 && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
-                    autoContinueAttempts++;
-                    const instruction = buildAutoContinueInstruction(autoContinueAttempts, 'short_response');
-                    this.messages.push({ role: 'assistant', content: reply || '' });
-                    this.messages.push({
-                        role: 'user',
-                        content: instruction.prompt,
-                    });
-                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, instruction.message);
-                    continue;
-                }
                 // Check if model expressed intent to act but didn't call tools
                 // This catches "Let me create..." without actual tool calls
-                // Also catches text-formatted tool calls like "_tool_call_\nread_file(...)"
                 // Only auto-continue if the feature is enabled
-                const continueResult = shouldAutoContinue(reply, false);
-                if (this._autoContinueEnabled && continueResult.shouldContinue && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
+                if (this._autoContinueEnabled && shouldAutoContinue(reply, false) && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
                     autoContinueAttempts++;
-                    const planningPreview = buildPlanningPreview(reply);
+                    // 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 });
-                    // Choose prompt based on reason - text tool calls get a specific, forceful prompt
-                    const continueReason = continueResult.reason === 'text_tool_call' ? 'text_tool_call' : 'intent_without_action';
-                    const instruction = buildAutoContinueInstruction(autoContinueAttempts, continueReason);
+                    // Auto-prompt with increasingly direct instructions
+                    const promptIndex = Math.min(autoContinueAttempts - 1, AUTO_CONTINUE_PROMPTS.length - 1);
                     this.messages.push({
                         role: 'user',
-                        content: instruction.prompt,
+                        content: AUTO_CONTINUE_PROMPTS[promptIndex],
                     });
-                    const uiMessage = planningPreview
-                        ? `${instruction.message} Planning preview: ${planningPreview}`
-                        : instruction.message;
-                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, uiMessage);
+                    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) {
@@ -687,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;
             }
@@ -706,7 +289,6 @@ export class AgentRuntime {
         }
         let contextRecoveryAttempts = 0;
         let autoContinueAttempts = 0;
-        let transientRetryAttempts = 0;
         while (true) {
             // Check for cancellation at start of each iteration
             if (this.cancellationRequested) {
@@ -739,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();
@@ -757,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) {
@@ -773,31 +397,11 @@ export class AgentRuntime {
                             }
                         }
                         else if (chunk.type === 'tool_call' && chunk.toolCall) {
-                            // FIRST TOOL CALL: ALWAYS inject acknowledgement for immediate user feedback
-                            if (toolCalls.length === 0) {
-                                const hasNarration = !!(fullContent.trim() || reasoningContent.trim());
-                                // Fire callback and ALWAYS inject acknowledgement BEFORE anything else
-                                if (!this.firstToolCallFired && this.callbacks.onBeforeFirstToolCall) {
-                                    this.firstToolCallFired = true;
-                                    const injectedAck = this.callbacks.onBeforeFirstToolCall([chunk.toolCall.name], hasNarration);
-                                    // ALWAYS inject acknowledgement if returned - ensures immediate user feedback
-                                    if (injectedAck) {
-                                        // Inject acknowledgement as the FIRST thing user sees
-                                        this.callbacks.onStreamChunk?.(injectedAck + '\n', 'content');
-                                        fullContent = injectedAck + '\n' + fullContent; // Add to content for context
-                                    }
-                                }
-                                // 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;
@@ -805,87 +409,37 @@ 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 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();
+                    const suppressNarration = this.shouldSuppressToolNarration();
+                    const narration = suppressNarration ? '' : combinedContent.trim();
                     if (narration) {
+                        // 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);
-                    // PROGRAMMATIC CONTINUATION: After tool work, model must either:
-                    // 1. Call more tools (already handled by continue above)
-                    // 2. Give a short completion signal
-                    // 3. Ask user for direction
-                    // PROGRAMMATIC: If model outputs narrative instead of concrete findings, continue
-                    if (this._autoContinueEnabled && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
-                        if (shouldContinueAfterTools(narration ?? '')) {
-                            autoContinueAttempts++;
-                            const instruction = buildAutoContinueInstruction(autoContinueAttempts, 'after_tools_narration');
-                            this.messages.push({
-                                role: 'user',
-                                content: instruction.prompt,
-                            });
-                            this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, instruction.message);
-                            continue;
-                        }
-                    }
-                    // Reset auto-continue counter since model appears to be done
+                    // Reset auto-continue counter since model is actively working
                     autoContinueAttempts = 0;
                     continue;
                 }
@@ -893,46 +447,24 @@ export class AgentRuntime {
                 // 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 model returned empty or very short AND auto-continue is enabled, prompt it to respond
-                // This is disabled by default to prevent loops
-                if (this._autoContinueEnabled && reply.length < 10 && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
+                if (this._autoContinueEnabled && shouldAutoContinue(reply, false) && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
                     autoContinueAttempts++;
-                    const instruction = buildAutoContinueInstruction(autoContinueAttempts, 'short_response');
-                    this.messages.push({ role: 'assistant', content: reply || '' });
+                    // 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: instruction.prompt,
+                        content: AUTO_CONTINUE_PROMPTS[promptIndex],
                     });
-                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, instruction.message);
+                    const autoContinueMessage = `Model expressed intent but didn't use tools. Auto-prompting to continue...`;
+                    this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, autoContinueMessage);
                     continue;
                 }
-                // PROGRAMMATIC CHECK: Text-only responses after tool work need scrutiny
-                // If model outputs substantial narrative without tools, it's likely summarizing
-                // Check if this is a genuine completion or a premature summary
-                // Also catches text-formatted tool calls like "_tool_call_\nread_file(...)"
-                if (this._autoContinueEnabled && autoContinueAttempts < MAX_AUTO_CONTINUE_ATTEMPTS) {
-                    // Intent patterns still catch "let me X" without tools
-                    const streamContinueResult = shouldAutoContinue(reply, false);
-                    if (streamContinueResult.shouldContinue) {
-                        autoContinueAttempts++;
-                        const planningPreview = buildPlanningPreview(reply);
-                        this.messages.push({ role: 'assistant', content: reply });
-                        // Choose prompt based on reason - text tool calls get a specific, forceful prompt
-                        const continueReason = streamContinueResult.reason === 'text_tool_call' ? 'text_tool_call' : 'intent_without_action';
-                        const instruction = buildAutoContinueInstruction(autoContinueAttempts, continueReason);
-                        this.messages.push({ role: 'user', content: instruction.prompt });
-                        const uiMessage = planningPreview
-                            ? `${instruction.message} Planning preview: ${planningPreview}`
-                            : instruction.message;
-                        this.callbacks.onAutoContinue?.(autoContinueAttempts, MAX_AUTO_CONTINUE_ATTEMPTS, uiMessage);
-                        continue;
-                    }
-                }
                 // Final message - mark as streamed to avoid double-display in UI
                 if (reply) {
                     this.emitAssistantMessage(reply, { isFinal: true, usage, contextStats, wasStreamed: true });
@@ -954,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;
             }
@@ -993,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,
@@ -1019,103 +527,53 @@ 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) {
@@ -1168,138 +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
-     *
-     * 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);
     }