hanuscode 1.0.0__py3-none-any.whl

hanus/query_engine.py

@@ -0,0 +1,1594 @@
+# hanus/query_engine.py
+"""
+Motor de consultas agéntico — soporte dual nativo (Claude/OpenAI) y XML (resto).
+
+Ctrl+C durante ejecución del modelo interrumpe la llamada actual y vuelve
+al prompt sin salir del programa.
+"""
+from __future__ import annotations
+import re
+import sys
+import time
+import signal
+import threading
+from typing import List, Dict, Optional, Callable, Any, Tuple
+
+from hanus.connectors.base import BaseConnector, ModelResponse, ToolCall
+from hanus.tools import ToolExecutor, ToolResult, TOOL_DEFINITIONS
+from hanus.session_manager import SessionManager
+from hanus.permissions import PermissionManager
+import hanus.logger as log
+
+
+# ─── Señal de interrupción ────────────────────────────────────────────────────
+_interrupt_requested = threading.Event()
+
+
+def _sigint_handler(sig, frame):
+    """Ctrl+C → marcar interrupción, no salir del proceso."""
+    _interrupt_requested.set()
+
+
+# ─── Exponential backoff ──────────────────────────────────────────────────────
+
+def _backoff(attempt: int, base: float = 2.0, cap: float = 60.0) -> float:
+    """Calcula el tiempo de espera con exponential backoff + jitter."""
+    import random
+    delay = min(base ** attempt, cap)
+    jitter = random.uniform(0, delay * 0.2)
+    return delay + jitter
+
+
+HTTP_RETRYABLE = {429, 500, 502, 503, 504, 524, 520, 521, 522, 523}
+
+
+def _is_retryable_error(exc: Exception) -> bool:
+    msg = str(exc).lower()
+    for code in HTTP_RETRYABLE:
+        if str(code) in msg:
+            return True
+    for kw in ("rate limit", "timeout", "connection", "temporary", "service unavailable",
+               "overloaded", "retry", "too many requests"):
+        if kw in msg:
+            return True
+    return False
+
+
+# ─── Helpers de detección ────────────────────────────────────────────────────
+
+def _response_has_code(text: str) -> bool:
+    """Detect if response contains code blocks or raw code."""
+    # Code in ``` fences
+    if re.search(r'```\w*\n.+?```', text, re.DOTALL):
+        return True
+
+    # Raw code patterns (code without fences)
+    code_patterns = [
+        # C/C++
+        r'^\s*/\*[\s\*].*\*/',  # Block comments
+        r'^\s*#\s*include\s*[<"]',  # Includes
+        r'^\s*#\s*define\s+\w+',  # Preprocessor defines
+        r'^\s*#\s*if\s+',  # Preprocessor conditionals
+        r'^\s*#\s*endif',  # Preprocessor endif
+        r'^\s*(int|void|char|float|double|long|unsigned|signed|bool|size_t)\s+\w+\s*\(',  # C function definitions
+        r'^\s*(struct|typedef|enum)\s+\w+',  # C type definitions
+        r'^\s*return\s+\d+;',  # Return statements with number
+        r'^\s*return\s+\w+;',  # Return statements with variable
+        r'^\s*return\s*;',  # Empty return
+        # Python
+        r'^\s*import\s+\w+',  # Imports
+        r'^\s*from\s+\w+\s+import',  # From imports
+        r'^\s*def\s+\w+\s*\(',  # Function definitions
+        r'^\s*class\s+\w+[:\(]',  # Class definitions
+        r'^\s*@\w+\s*(def|class|async)',  # Decorators
+        r'^\s*if\s+__name__\s*==',  # Python main guard
+        r'^\s*async\s+def\s+',  # Async functions
+        r'^\s*pass\s*$',  # Pass statement
+        r'^\s*print\s*\(',  # Print function
+        r'^\s*return\s*$',  # Empty return
+        r'^\s*raise\s+\w+',  # Raise exceptions
+        r'^\s*with\s+\w+',  # Context managers
+        r'^\s*try\s*:',  # Try blocks
+        r'^\s*except\s+\w*',  # Except blocks
+        r'^\s*for\s+\w+\s+in\s+',  # For loops
+        # JavaScript/TypeScript
+        r'^\s*function\s+\w+\s*\(',  # Function declarations
+        r'^\s*(const|let|var)\s+\w+\s*=',  # Variable declarations
+        r'^\s*export\s+(default\s+)?(function|class|const)',  # ES6 exports
+        r'^\s*import\s+\{.*\}\s+from',  # ES6 imports
+        r'^\s*async\s+function',  # Async functions
+        # Java/Kotlin
+        r'^\s*package\s+\w+',  # Package declarations
+        r'^\s*public\s+(class|static|void|interface)',  # Java declarations
+        r'^\s*private\s+\w+',  # Private members
+        r'^\s*@Override',  # Java annotations
+        # Rust
+        r'^\s*fn\s+\w+\s*\(',  # Rust functions
+        r'^\s*(pub\s+)?struct\s+\w+',  # Rust structs
+        r'^\s*(pub\s+)?enum\s+\w+',  # Rust enums
+        r'^\s*impl\s+\w+',  # Rust impl blocks
+        r'^\s*use\s+\w+',  # Rust use statements
+        # Go
+        r'^\s*type\s+\w+\s+struct',  # Go structs
+        r'^\s*func\s+\w+\s*\(',  # Go functions
+        r'^\s*defer\s+',  # Go defer
+        # Shell/Bash
+        r'^\s*#\s*!/bin/',  # Shebang
+        r'^\s*echo\s+',  # Echo commands
+        r'^\s*export\s+\w+=',  # Shell exports
+        r'^\s*(if|then|else|fi)\s*$',  # Shell conditionals
+        r'^\s*(for|do|done)\s*$',  # Shell loops
+        # HTML/XML
+        r'^\s*<\w+[^>]*>',  # Opening tags
+        r'^\s*</\w+>',  # Closing tags
+        r'^\s*<\w+\s*/>',  # Self-closing tags
+        # SQL
+        r'^\s*SELECT\s+',  # SQL SELECT
+        r'^\s*INSERT\s+INTO',  # SQL INSERT
+        r'^\s*CREATE\s+TABLE',  # SQL CREATE
+        # General patterns
+        r'^\s*\}\s*$',  # Lone closing brace
+        r'^\s*\{\s*$',  # Lone opening brace
+        r'^\s*\w+\s*=\s*\w+\s*;',  # Variable assignments with semicolon
+    ]
+
+    lines = text.split('\n')
+    code_line_count = 0
+
+    for line in lines:
+        line_stripped = line.strip()
+        if not line_stripped:
+            continue
+        for pattern in code_patterns:
+            if re.search(pattern, line_stripped, re.MULTILINE):
+                code_line_count += 1
+                break
+
+    # If 2+ lines look like code, it's probably code
+    return code_line_count >= 2
+
+
+def _has_done_tag(text: str) -> bool:
+    """Check if model signaled completion with <done/> or <final_response/>."""
+    text_lower = text.lower()
+    return bool(re.search(r'<done\s*/?>|<final_response\s*/?>|<task_complete\s*/?>', text_lower))
+
+
+def _extract_done_content(text: str) -> str:
+    """Extract content up to and including the done tag.
+
+    If the text contains <done/>, return everything up to and including that tag.
+    This prevents the model from continuing after signaling completion.
+    """
+    # Look for done tags
+    patterns = [
+        r'(<done\s*/?>)',
+        r'(<final_response\s*/?>)',
+        r'(<task_complete\s*/?>)',
+    ]
+
+    for pattern in patterns:
+        match = re.search(pattern, text, re.IGNORECASE)
+        if match:
+            # Return content up to and including the tag
+            return text[:match.end()]
+
+    return text
+
+
+def _has_unclosed_write_file(text: str) -> bool:
+    """Check if response has unclosed or multiple write_file tags."""
+    # Count opening write_file tags
+    open_tags = len(re.findall(r'<write_file\b[^>]*>', text, re.IGNORECASE))
+    # Count closing tags
+    close_tags = len(re.findall(r'</write_file\s*>', text, re.IGNORECASE))
+
+    # If more opens than closes, or multiple opens, there's a problem
+    return open_tags > close_tags or open_tags > 1
+
+
+def _has_mixed_code_and_tools(text: str) -> bool:
+    """Check if response has both code-as-text AND XML tools mixed together."""
+    # Check for XML tools
+    has_tools = bool(re.search(
+        r'<(task_create|task_update|task_list|read_file|exec_cmd|grep_search|glob_search)\b',
+        text, re.IGNORECASE
+    ))
+
+    if not has_tools:
+        return False
+
+    # Check for code outside XML tags (code-as-text)
+    # Remove content inside write_file tags first
+    text_without_files = re.sub(
+        r'<write_file\b[^>]*>.*?</write_file>',
+        '', text, flags=re.DOTALL | re.IGNORECASE
+    )
+    text_without_files = re.sub(
+        r'<append_to_file\b[^>]*>.*?</append_to_file>',
+        '', text_without_files, flags=re.DOTALL | re.IGNORECASE
+    )
+
+    # Check if remaining text has code patterns
+    return _response_has_code(text_without_files)
+
+
+def _has_incomplete_code(text: str) -> bool:
+    """Check if write_file content appears incomplete (unclosed braces, strings)."""
+    # Find all write_file contents
+    matches = re.findall(
+        r'<write_file\b[^>]*>(.*?)</write_file>',
+        text, re.DOTALL | re.IGNORECASE
+    )
+
+    for content in matches:
+        # Check for unclosed braces
+        open_braces = content.count('{')
+        close_braces = content.count('}')
+        if open_braces > close_braces:
+            return True
+
+        # Check for unclosed string literals (simple check)
+        # Count unescaped quotes
+        lines = content.split('\n')
+        for line in lines:
+            # Skip comment lines
+            stripped = line.strip()
+            if stripped.startswith('//') or stripped.startswith('#'):
+                continue
+            # Check for odd number of quotes in a line (might be incomplete)
+            # This is a heuristic, not perfect
+            dq_count = line.count('"') - line.count('\\"')
+            if dq_count % 2 == 1 and not line.strip().endswith(';') and not line.strip().endswith(','):
+                # Might be incomplete string, check if it's end of file
+                if not line.strip().endswith('"'):
+                    # Odd quotes and doesn't end with quote - likely incomplete
+                    return True
+
+    return False
+
+
+def _has_pending_tasks(tool_executor) -> bool:
+    """Check if there are pending or in-progress tasks."""
+    try:
+        # Get task manager from executor
+        tm = None
+        if hasattr(tool_executor, 'task_manager') and tool_executor.task_manager:
+            tm = tool_executor.task_manager
+        elif hasattr(tool_executor, 'tasks') and tool_executor.tasks:
+            tm = tool_executor.tasks
+
+        if tm:
+            # TaskManager uses list(), not list_tasks()
+            tasks = tm.list() if hasattr(tm, 'list') else []
+            for t in tasks:
+                status = t.status.value if hasattr(t.status, 'value') else str(t.status)
+                if status in ('pending', 'in_progress'):
+                    return True
+    except Exception as e:
+        log.info(f"Error checking pending tasks: {e}")
+    return False
+
+
+def _looks_finished(text: str) -> bool:
+    """Check if response looks like a final summary."""
+    t = text.lower().strip()
+    signals = [
+        "task completed", "i have completed", "work finished",
+        "all done", "everything is complete", "in summary",
+        "summary:", "i created", "i modified", "i implemented",
+        "the project is", "the changes are", "it's ready",
+        "finished", "completed successfully", "done and verified",
+        "all tasks completed", "mission accomplished",
+        "## summary", "## final", "## completed",
+    ]
+    return any(s in t for s in signals)
+
+
+# ─── Herramientas de solo lectura (ilimitadas) ───────────────────────────────
+
+READ_ONLY_TOOLS = {
+    "read_file", "list_files", "glob_search", "grep_search",
+    "git_status", "git_diff", "git_log", "web_fetch", "web_search",
+}
+
+# ─── Continuation messages ─────────────────────────────────────────────────
+
+_CONTINUE_AFTER_TOOLS = (
+    "Tool executed successfully. RESULT CONFIRMED.\n"
+    "DO NOT repeat the same action.\n"
+    "NEXT STEP:\n"
+    "- If writing files: VERIFY content was written, then move to NEXT file\n"
+    "- If running commands: READ output, then proceed\n"
+    "- If error: Analyze and FIX\n"
+    "When subtask done: <task_update taskId=\"<id>\" status=\"completed\"/>\n"
+    "When ALL done: <done/>"
+)
+_CONTINUE_INCOMPLETE = (
+    "STOP writing text. You MUST use XML tools NOW. "
+    "<read_file path=\"...\"/> or <write_file path=\"...\">code</write_file> "
+    "NEVER respond with just text. USE TOOLS."
+    "\n\nIf you said you will do something, DO IT NOW with tools."
+    "\n\nAvailable tools:\n"
+    "- <read_file path=\"...\"/> - Read a file\n"
+    "- <write_file path=\"...\">content</write_file> - Write a file\n"
+    "- <exec_cmd>command</exec_cmd> - Execute a command\n"
+    "- <grep_search pattern=\"...\"/> - Search in files\n"
+)
+_CONTINUE_NEAR_LIMIT = (
+    "LOW TURNS LEFT. FINISH NOW. "
+    "Use write_file for remaining code. End with <done/> when complete."
+)
+_CONTINUE_EMPTY = (
+    "NO TOOL EXECUTED. You MUST use XML tools. "
+    "DO NOT write explanations. USE TOOLS NOW."
+)
+_CONTINUE_ERROR = (
+    "COMMAND FAILED. Analyze the error and FIX IT.\n"
+    "Common fixes:\n"
+    "- Write code to a file first, then run it\n"
+    "- Fix syntax errors in command\n"
+    "- Use simpler command\n"
+    "- Check file paths\n"
+    "DO NOT STOP. Try a different approach."
+)
+_CONTINUE_CODE_AS_TEXT = (
+    "STOP! You wrote code as TEXT instead of using write_file.\n"
+    "NEVER write code outside XML tags.\n"
+    "NEVER start a write_file in the middle of text.\n"
+    "CORRECT APPROACH:\n"
+    "1. Use write_file from the START\n"
+    "2. Write the COMPLETE file\n"
+    "3. Close with </write_file>\n"
+    "Example:\n"
+    "<write_file path=\"file.c\">\n"
+    "int main() {\n"
+    "    return 0;\n"
+    "}\n"
+    "</write_file>\n"
+    "REDO YOUR RESPONSE. Use write_file properly."
+)
+_CONTINUE_UNCLOSED_FILE = (
+    "ERROR: You started a new write_file without closing the previous one.\n"
+    "ONE FILE AT A TIME.\n"
+    "You MUST:\n"
+    "1. FINISH the current file completely\n"
+    "2. Close with </write_file>\n"
+    "3. THEN start the next file\n"
+    "DO NOT open multiple write_file tags.\n"
+    "Complete your current file NOW."
+)
+_CONTINUE_MIXED_CONTENT = (
+    "ERROR: You mixed code-as-text with XML tools.\n"
+    "This creates BROKEN output.\n"
+    "You MUST:\n"
+    "1. Put ALL code inside <write_file>...</write_file>\n"
+    "2. FINISH the code completely\n"
+    "3. THEN use other tools\n"
+    "NEVER write code AND tools in the same response.\n"
+    "Use ONE write_file per response, or ONE other tool.\n"
+    "RESTART. Use write_file properly."
+)
+_CONTINUE_INCOMPLETE_CODE = (
+    "ERROR: Your code is INCOMPLETE.\n"
+    "The file has unclosed braces or incomplete strings.\n"
+    "You MUST write COMPLETE, COMPILABLE code.\n"
+    "Finish all functions. Close all braces.\n"
+    "Complete all string literals.\n"
+    "REWRITE the file with complete code."
+)
+_CONTINUE_FILE_LOOP = (
+    "⚠️ LOOP DETECTED: Same file written twice.\n"
+    "FILE WAS ALREADY WRITTEN SUCCESSFULLY.\n"
+    "DO NOT write this file again.\n"
+    "OPTIONS:\n"
+    "1. If file is CORRECT → Move to NEXT task or <done/>\n"
+    "2. If you need to FIX → Use <edit_file path=\"...\" old_str=\"...\" new_str=\"...\"/>\n"
+    "3. If truly incomplete → Write ONLY the missing part\n"
+    "STOP rewriting complete files. Use <done/> when finished."
+)
+_FILE_WRITE_BLOCKED = (
+    "🛑 WRITE BLOCKED: File has been written 3+ times!\n"
+    "This indicates a loop. The write has been SKIPPED.\n"
+    "YOU MUST:\n"
+    "1. Move to the NEXT task immediately\n"
+    "2. Or use <done/> to finish\n"
+    "3. Or ask the user for clarification\n"
+    "DO NOT attempt to write this file again.\n"
+    "PROCEED TO NEXT TASK NOW."
+)
+_CONTINUE_PENDING_TASKS = (
+    "ACTIVE TASK DETECTED. DO THE WORK NOW.\n"
+    "DO NOT create more tasks. DO NOT update tasks.\n"
+    "EXECUTE REAL WORK:\n"
+    "  <write_file path=\"...\">code here</write_file>\n"
+    "  <exec_cmd cmd=\"...\"/>\n"
+    "STOP managing tasks. START writing code."
+)
+_CONTINUE_TASK_LOOP = (
+    "TASK MANAGEMENT LOOP DETECTED.\n"
+    "You have done too many task operations without writing code.\n"
+    "STOP creating/updating tasks.\n"
+    "IMMEDIATELY use write_file or exec_cmd NOW.\n"
+    "NO MORE task_create or task_update until you write code."
+)
+_LIMIT_REACHED = (
+    "Turn limit reached. Write summary of completed work."
+)
+_CONTINUE_NO_TOOLS = (
+    "NO TOOLS WERE EXECUTED in this turn.\n"
+    "You wrote text but didn't take any action.\n\n"
+    "AVAILABLE TOOLS (use XML format):\n"
+    "- <read_file path=\"...\"/> - Read a file\n"
+    "- <write_file path=\"...\">content</write_file> - Write a file\n"
+    "- <exec_cmd>command</exec_cmd> - Execute a shell command\n"
+    "- <grep_search pattern=\"...\" dir=\".\"/> - Search in files\n"
+    "- <glob_search pattern=\"**/*.py\"/> - Find files\n"
+    "- <web_fetch url=\"...\"/> - Fetch URL content\n"
+    "\n"
+    "If you said you will do something: DO IT NOW with tools.\n"
+    "If you are DONE with ALL tasks: respond with <done/>\n"
+    "Otherwise: USE TOOLS NOW to make progress."
+)
+
+# ─── XML Tools Prompt (Mode B) ─────────────────────────────────────
+
+XML_TOOLS_PROMPT = """
+---
+## TOOL SYSTEM
+
+Tools are activated with XML in your response. ONE per turn.
+
+**CRITICAL RULES**:
+
+1. **NEVER write code as text** - No ``` blocks, no raw code outside XML tags.
+   WRONG: `int main() { return 0; }`
+   RIGHT: `<write_file path="main.c">int main() { return 0; }</write_file>`
+
+2. **ONE FILE AT A TIME** - Start and COMPLETE one file before another.
+   NEVER start a new write_file before closing the previous one.
+
+3. **COMPLETE FILES** - Write the ENTIRE file content. No "# ... rest unchanged".
+
+4. **CLOSE YOUR TAGS** - Always end write_file with `</write_file>`.
+
+### EXPLORE
+
+<list_files dir="."/>
+<read_file path="src/main.py"/>
+<glob_search pattern="**/*.py"/>
+<grep_search pattern="def function|class Class"/>
+
+### SAVE CODE (ALWAYS use write_file, never raw text)
+
+<write_file path="src/new.py">
+# COMPLETE file content here - the entire file
+def main():
+    pass
+
+if __name__ == "__main__":
+    main()
+</write_file>
+
+<!-- Each write_file must be complete and closed before starting another -->
+
+<append_to_file path="requirements.txt">
+new-lib>=1.0
+</append_to_file>
+
+<file_edit path="config.py" search="DEBUG = False" replace="DEBUG = True"/>
+
+<!-- edit_file: safer, requires old_str to be unique -->
+<edit_file path="config.py" old_str="def old():" new_str="def new(): "/>
+
+### EXECUTE AND VERIFY
+
+<!-- exec_cmd: Use block format for complex commands with quotes/special chars -->
+<exec_cmd>
+python file.py
+</exec_cmd>
+
+<exec_cmd>
+python -m pytest -v
+</exec_cmd>
+
+<!-- Or use attribute format for simple commands -->
+<exec_cmd cmd="node index.js"/>
+<exec_cmd cmd="go build ./..."/>
+<exec_cmd cmd="cargo test"/>
+
+<!-- Complex commands with quotes - USE BLOCK FORMAT -->
+<exec_cmd>
+sed -i 's/old/new/g' file.txt
+</exec_cmd>
+
+<exec_cmd>
+find . -name "*.py" -exec grep -l "pattern" {} \\;
+</exec_cmd>
+
+### GIT
+
+<git_status/>
+<git_diff/>
+<git_commit message="feat: description"/>
+
+### WEB
+
+<web_search query="python asyncio docs"/>
+<web_fetch url="https://docs.python.org"/>
+
+### TASK MANAGEMENT (optional but helpful)
+
+<task_create subject="New task" description="Optional description"/>
+<task_update taskId="1" status="in_progress"/>
+<task_list/>
+<task_get taskId="1"/>
+
+### SUBAGENTS (delegate complex tasks)
+
+<!-- Explore codebase in parallel -->
+<subagent type="explore" task="Find all API endpoints" context="Project is a Flask app"/>
+
+<!-- Plan implementation -->
+<subagent type="plan" task="Design the user system architecture"/>
+
+<!-- Code review -->
+<subagent type="review" task="Review security.py for vulnerabilities"/>
+
+<!-- General agent for autonomous tasks -->
+<subagent type="general" task="Implement POST /users endpoint" context="Use existing pattern in src/api/"/>
+
+### PLANNING (organize work before executing)
+
+<plan_create title="Refactor auth" description="Modernize authentication system"/>
+<plan_add_step description="Explore current code"/>
+<plan_add_step description="Design new architecture"/>
+<plan_add_step description="Implement changes"/>
+<plan_list/>
+<plan_get/>
+<plan_approve/>  <!-- Approve and start execution -->
+<plan_reject/>   <!-- Reject and delete plan -->
+<plan_update_step step_id="1" status="completed" notes="Reviewed auth.py"/>
+
+### BINARY EXPLOITATION (BinSmasher)
+
+For CTFs, authorized pentesting and security research:
+
+<binsmasher binary="./challenge" action="analyze"/>
+<binsmasher binary="./vuln" action="detect"/>
+<binsmasher binary="./pwnable" action="exploit"/>
+<binsmasher binary="./remote" action="exploit" host="ctf.example.com" port="9001"/>
+<binsmasher binary="./binary" action="template"/>
+
+Available actions:
+- analyze: full analysis (protections, vulns, gadgets)
+- detect: detect vulnerability only
+- exploit: generate and run exploit
+- template: generate exploit template for manual editing
+- multistage: two-phase exploitation (leak + ret2libc)
+- heap: advanced heap exploitation
+
+### ASK USER (interactive questions)
+
+When you need user input to make a decision, ask clarifying questions, or get preferences:
+
+<ask_user question="Which approach should I use for authentication?" header="Auth" multiSelect="false">
+<option label="JWT" description="Stateless, scalable, good for microservices"/>
+<option label="Session" description="Traditional, server-side storage, simpler revocation"/>
+<option label="OAuth" description="Third-party auth, social login support"/>
+</ask_user>
+
+<ask_user question="Which frameworks should I include?" header="Stack" multiSelect="true">
+<option label="FastAPI" description="Modern async Python web framework"/>
+<option label="Django" description="Full-featured batteries-included framework"/>
+<option label="Flask" description="Lightweight microframework"/>
+</ask_user>
+
+User will see interactive options and can select one/multiple or provide custom input.
+Use this when:
+- Choosing between multiple valid approaches
+- Getting user preferences on implementation
+- Clarifying ambiguous requirements
+- Asking about architectural decisions
+
+---
+## RULES
+
+1. ONE tool per turn. Wait for result before the next.
+2. Code → ALWAYS write_file. NEVER ``` blocks in text.
+3. COMPLETE content in write_file. No "# ... rest unchanged".
+4. Verify with exec_cmd after writing code.
+5. Mark task completed when verified: <task_update taskId="X" status="completed"/>
+6. KEEP WORKING until ALL tasks are complete.
+7. When ALL done, write summary then use: <done/>
+
+## COMPLETION SIGNAL
+
+Use <done/> ONLY when:
+- All tasks completed
+- Code verified and working
+- Summary written
+
+Example completion:
+```
+## Summary
+- Created src/api.py
+- Modified config.py
+- Tests passed
+
+<done/>
+```
+"""
+
+
+# ─── Parser XML ───────────────────────────────────────────────────────────────
+
+def parse_xml_actions(text: str) -> List[Dict[str, Any]]:
+    matches: List[Tuple[int, Dict[str, Any]]] = []
+
+    # Parse ask_user with nested <option> elements first (it's a special block tag)
+    for m in re.finditer(
+        r'<ask_user\b([^>]*)>(.*?)</ask_user>',
+        text, re.DOTALL | re.IGNORECASE
+    ):
+        attrs = _parse_attrs(m.group(1))
+        inner_content = m.group(2)
+
+        # Parse options
+        options = []
+        for opt_m in re.finditer(
+            r'<option\s+label="([^"]*)"(?:\s+description="([^"]*)")?\s*/?>',
+            inner_content, re.IGNORECASE
+        ):
+            options.append({
+                "label": opt_m.group(1),
+                "description": opt_m.group(2) or ""
+            })
+
+        matches.append((m.start(), {
+            "type": "ask_user",
+            "question": attrs.get("question", ""),
+            "header": attrs.get("header", ""),
+            "multiSelect": attrs.get("multiSelect", "false").lower() == "true",
+            "options": options,
+            "_raw": m.group(0)
+        }))
+
+    # Block tags that use <tag>content</tag> format
+    BLOCK_TAGS = r"write_file|create_file|append_to_file|exec_cmd|memory_save"
+    for m in re.finditer(
+        r'<(' + BLOCK_TAGS + r')\b([^>]*)>(.*?)</\1>',
+        text, re.DOTALL | re.IGNORECASE
+    ):
+        tag     = m.group(1).lower()
+        attrs   = _parse_attrs(m.group(2))
+        content = _strip_fence(m.group(3).strip())
+
+        if tag == "exec_cmd":
+            # exec_cmd can be <exec_cmd>command</exec_cmd> or <exec_cmd cmd="command"/>
+            if content:
+                matches.append((m.start(), {
+                    "type": tag, "cmd": content, "_raw": m.group(0)
+                }))
+            elif attrs.get("cmd"):
+                matches.append((m.start(), {
+                    "type": tag, "cmd": attrs.get("cmd", ""), "_raw": m.group(0)
+                }))
+        elif tag == "memory_save":
+            # memory_save can use body content or content attribute
+            matches.append((m.start(), {
+                "type": tag,
+                "name": attrs.get("name", ""),
+                "mem_type": attrs.get("type", "project"),
+                "content": content or attrs.get("content", ""),
+                "description": attrs.get("description", ""),
+                "_raw": m.group(0)
+            }))
+        else:
+            matches.append((m.start(), {
+                "type": tag, "path": attrs.get("path", ""),
+                "content": content, "_raw": m.group(0)
+            }))
+
+    SELF_TAGS = (
+        r"read_file|list_files|glob_search|grep_search|exec_cmd|exec_file|"
+        r"git_status|git_diff|git_log|git_commit|git_push|git_branch|"
+        r"web_fetch|web_search|file_edit|edit_file|structured_output|run_plugin|"
+        r"task_create|task_update|task_list|task_get|"
+        r"memory_search|memory_list|subagent|"
+        r"plan_create|plan_add_step|plan_update_step|plan_list|plan_get|plan_approve|plan_reject|"
+        r"binsmasher"
+        # Note: ask_user is handled separately above (block tag with nested options)
+        # Note: memory_save is handled as BLOCK_TAG (uses body content)
+    )
+
+    # Usar un parser más robusto para self-closing tags
+    # El problema: cmd="find ... 2>/dev/null" contiene > que rompe [^>]*
+    tag_pattern = re.compile(r'<(' + SELF_TAGS + r')\b', re.IGNORECASE)
+
+    for m in tag_pattern.finditer(text):
+        tag = m.group(1).lower()
+        start = m.start()
+
+        # Encontrar el cierre del tag
+        remaining = text[m.end():]
+        end_pos = _find_tag_end(remaining)
+
+        if end_pos == -1:
+            continue
+
+        attr_text = remaining[:end_pos]
+        attrs = _parse_attrs(attr_text)
+        attrs["type"] = tag
+        attrs["_raw"] = text[start:start + m.end() - start + end_pos + 1]
+        matches.append((start, attrs))
+
+    matches.sort(key=lambda x: x[0])
+    seen: set = set()
+    unique: List[Dict[str, Any]] = []
+    for _, action in matches:
+        raw = action.get("_raw", "")
+        if raw not in seen:
+            seen.add(raw)
+            unique.append(action)
+    return unique
+
+
+def _find_tag_end(s: str) -> int:
+    """Encuentra la posición del final de un tag self-closing."""
+    in_single_quote = False
+    in_double_quote = False
+    i = 0
+
+    while i < len(s):
+        c = s[i]
+
+        if c == "'" and not in_double_quote:
+            in_single_quote = not in_single_quote
+        elif c == '"' and not in_single_quote:
+            in_double_quote = not in_double_quote
+        elif c == '>' and not in_single_quote and not in_double_quote:
+            # Encontramos el cierre
+            if i > 0 and s[i-1] == '/':
+                return i
+            return i
+        i += 1
+
+    return -1
+
+
+def _parse_attrs(s: str) -> Dict[str, str]:
+    """Parsea atributos XML soportando comillas escapadas y atributos vacíos."""
+    result = {}
+
+    # Primero: atributos con comillas dobles
+    for m in re.finditer(r'(\w+)\s*=\s*"((?:[^"\\]|\\.)*)"', s or ""):
+        result[m.group(1)] = m.group(2)
+
+    # Segundo: atributos con comillas simples
+    for m in re.finditer(r"(\w+)\s*=\s*'((?:[^'\\]|\\.)*)'", s or ""):
+        key = m.group(1)
+        if key not in result:
+            result[key] = m.group(2)
+
+    # Tercero: atributos vacíos (attr= sin valor, seguido de espacio, > o fin)
+    # Ejemplo: title= description="..." -> title=""
+    for m in re.finditer(r'(\w+)\s*=\s*(?=[\s>]|$)', s or ""):
+        key = m.group(1)
+        if key not in result:
+            result[key] = ""
+
+    # Cuarto: atributos sin comillas (attr=value donde value no tiene espacios)
+    # Solo si no se capturó ya
+    for m in re.finditer(r'(\w+)\s*=\s*([^\s"\'>]+)', s or ""):
+        key = m.group(1)
+        if key not in result:
+            result[key] = m.group(2)
+
+    return result
+
+
+def _strip_fence(content: str) -> str:
+    content = content.strip()
+    if content.startswith("```"):
+        lines = content.splitlines()
+        if len(lines) > 2:
+            return "\n".join(lines[1:-1]).strip()
+    return content
+
+
+def action_to_tool_args(action: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    t   = action["type"]
+    raw = {k: v for k, v in action.items() if not k.startswith("_") and k != "type"}
+
+    if t == "exec_cmd":   return "exec_cmd",  {"cmd": raw.get("cmd") or raw.get("command", "")}
+    if t == "exec_file":  return "exec_file",  {"path": raw.get("path", "")}
+    if t == "read_file":  return "read_file",  {"path": raw.get("path", "")}
+    if t == "list_files": return "list_files", {"dir": raw.get("dir", ".")}
+    if t == "glob_search": return "glob_search", {"pattern": raw.get("pattern","*"), "dir": raw.get("dir",".")}
+    if t == "grep_search": return "grep_search", {
+        "pattern": raw.get("pattern",""), "dir": raw.get("dir","."),
+        "regex": raw.get("regex","false").lower() == "true"
+    }
+    if t in ("write_file","create_file","append_to_file"):
+        return t, {"path": raw.get("path",""), "content": raw.get("content","")}
+    if t == "file_edit":  return "file_edit", {
+        "path": raw.get("path",""), "search": raw.get("search",""), "replace": raw.get("replace","")
+    }
+    if t == "edit_file": return "edit_file", {
+        "path": raw.get("path",""), "old_str": raw.get("old_str",""), "new_str": raw.get("new_str","")
+    }
+    if t == "task_create": return "task_create", {
+        "subject": raw.get("subject",""), "description": raw.get("description",""),
+        "activeForm": raw.get("activeForm",""), "metadata": raw.get("metadata","")
+    }
+    if t == "task_update": return "task_update", {
+        "taskId": raw.get("taskId",""), "status": raw.get("status",""),
+        "subject": raw.get("subject",""), "description": raw.get("description",""),
+        "addBlockedBy": raw.get("addBlockedBy","").split(",") if raw.get("addBlockedBy") else [],
+        "addBlocks": raw.get("addBlocks","").split(",") if raw.get("addBlocks") else [],
+    }
+    if t == "task_list": return "task_list", {}
+    if t == "task_get":  return "task_get", {"taskId": raw.get("taskId","")}
+    if t == "memory_save": return "memory_save", {
+        "name": raw.get("name",""), "type": raw.get("mem_type") or raw.get("type","project"),
+        "content": raw.get("content",""), "description": raw.get("description","")
+    }
+    if t == "memory_search": return "memory_search", {"query": raw.get("query",""), "type": raw.get("type","")}
+    if t == "memory_list": return "memory_list", {"type": raw.get("type","")}
+    if t == "git_status":  return "git_status",  {}
+    if t == "git_diff":    return "git_diff",    {"args": raw.get("args","")}
+    if t == "git_log":     return "git_log",     {"n": int(raw.get("n",10))}
+    if t == "git_commit":  return "git_commit",  {"message": raw.get("message","auto-commit")}
+    if t == "git_push":    return "git_push",    {"branch": raw.get("branch",""), "remote": raw.get("remote","origin")}
+    if t == "git_branch":  return "git_branch",  {"name": raw.get("name","")}
+    if t == "web_fetch":   return "web_fetch",   {"url": raw.get("url","")}
+    if t == "web_search":  return "web_search",  {"query": raw.get("query",""), "results": int(raw.get("results",5))}
+    if t == "structured_output": return "structured_output", {"data": raw.get("data","{}"), "schema": raw.get("schema","{}")}
+    if t == "subagent": return "subagent", {
+        "type": raw.get("type","general"),
+        "task": raw.get("task",""),
+        "context": raw.get("context",""),
+        "isolation": raw.get("isolation","shared")
+    }
+    if t == "plan_create": return "plan_create", {
+        "title": raw.get("title",""), "description": raw.get("description","")
+    }
+    if t == "plan_add_step": return "plan_add_step", {
+        "plan_id": raw.get("plan_id",""), "description": raw.get("description","")
+    }
+    if t == "plan_update_step": return "plan_update_step", {
+        "plan_id": raw.get("plan_id",""), "step_id": raw.get("step_id",""),
+        "status": raw.get("status",""), "notes": raw.get("notes","")
+    }
+    if t == "plan_list": return "plan_list", {"status": raw.get("status","")}
+    if t == "plan_get": return "plan_get", {"plan_id": raw.get("plan_id","")}
+    if t == "plan_approve": return "plan_approve", {"plan_id": raw.get("plan_id","")}
+    if t == "plan_reject": return "plan_reject", {"plan_id": raw.get("plan_id","")}
+    if t == "binsmasher": return "binsmasher", {
+        "binary": raw.get("binary",""), "action": raw.get("action","analyze"),
+        "host": raw.get("host",""), "port": raw.get("port",""),
+        "timeout": int(raw.get("timeout","120"))
+    }
+    if t == "ask_user": return "ask_user", {
+        "question": raw.get("question",""),
+        "header": raw.get("header",""),
+        "multiSelect": raw.get("multiSelect", False),
+        "options": raw.get("options", [])
+    }
+    # run_plugin → pasar como herramienta especial
+    if t == "run_plugin":  return "run_plugin",  {"name": raw.get("name",""), "args": raw.get("args","")}
+    return t, raw
+
+
+# ─── Motor principal ──────────────────────────────────────────────────────────
+
+class QueryEngine:
+    MAX_ITERATIONS   = 500   # Límite de iteraciones muy alto - el agente termina con <done/>
+    MAX_API_RETRIES  = 5     # reintentos con backoff exponencial
+    READ_TOOL_LIMIT  = 999
+    WRITE_TOOL_LIMIT = 50    # Límite de escrituras por sesión
+    WARN_AT          = 400   # Advertir cuando queden pocas iteraciones
+
+    def __init__(
+        self,
+        connector:           BaseConnector,
+        tool_executor:       ToolExecutor,
+        session_manager:     SessionManager,
+        permission_manager:  PermissionManager,
+        plugin_manager=None,
+        stream_callback:     Optional[Callable[[str], None]] = None,
+        tool_start_callback: Optional[Callable[[str, Dict], None]] = None,
+        tool_end_callback:   Optional[Callable[[str, str, bool], None]] = None,
+        thinking_callback:   Optional[Callable[[str], None]] = None,
+        budget_usd:          float = 0.0,
+        context_manager=None,  # ContextManager para compresión
+        ui=None,  # Referencia a UI para indicador de procesamiento
+        pending_messages_callback: Optional[Callable[[], List[str]]] = None,  # Returns pending user messages
+    ):
+        self.connector      = connector
+        self.executor       = tool_executor
+        self.session        = session_manager
+        self.perms          = permission_manager
+        self.plugin_mgr     = plugin_manager
+        self.stream_cb      = stream_callback
+        self.tool_start     = tool_start_callback
+        self.tool_end       = tool_end_callback
+        self.thinking_cb    = thinking_callback
+        self.budget_usd     = budget_usd
+        self.context_mgr    = context_manager
+        self._ui            = ui  # UI reference
+        self._pending_messages_callback = pending_messages_callback
+        self._messages:     List[Dict] = []
+        self._tool_counts:  Dict[str, int] = {}
+        self._empty_streak: int = 0
+        self._interrupted:  bool = False
+        self._task_ops_streak: int = 0  # Counter for consecutive task operations
+        self._last_file_written: str = ""  # Track last file written for consecutive detection
+        self._files_written: Dict[str, int] = {}  # Track total writes per file
+        self._pending_input: str = ""  # User input received while working (from terminal_prompt)
+        self._chat_mode: bool = False  # Simple chat mode (no tools)
+        self._single_turn: bool = False  # Single turn mode (execute tools once then stop)
+
+    # ── API pública ───────────────────────────────────────────────────────────
+
+    def set_system_prompt(self, system: str):
+        if not self.connector.NATIVE_TOOLS:
+            system = system.rstrip() + "\n" + XML_TOOLS_PROMPT
+        self._messages = [{"role": "system", "content": system}]
+
+    def inject_context(self, context: str):
+        self._messages.append({"role": "user",
+                                "content": f"Contexto del proyecto:\n\n{context}"})
+        self._messages.append({"role": "assistant",
+                                "content": "Contexto recibido. Listo."})
+
+    def interrupt(self):
+        """Señal externa para detener el bucle agéntico."""
+        self._interrupted = True
+
+    def set_chat_mode(self, enabled: bool = True):
+        """Enable or disable chat mode (no tools, just text response)."""
+        self._chat_mode = enabled
+
+    def get_pending_input(self) -> str:
+        """Get and clear pending input from background collection."""
+        inp = self._pending_input
+        self._pending_input = ""
+        return inp
+
+    def set_pending_input(self, text: str):
+        """Set pending input (called from agent_runner when background input collected)."""
+        self._pending_input = text
+
+    def has_pending_input(self) -> bool:
+        """Check if there's pending input."""
+        return bool(self._pending_input.strip())
+
+    def _append_pending_input(self, message: str) -> str:
+        """Append pending input to a message and clear it."""
+        pending = self._pending_input.strip()
+        if pending:
+            self._pending_input = ""  # Clear after appending
+            return f"{message}\n\n[USER INPUT DURING PROCESSING]:\n{pending}"
+        return message
+
+    def chat(self, user_message: str) -> ModelResponse:
+        """Send a message in chat mode (no tools, just text response)."""
+        self._messages.append({"role": "user", "content": user_message})
+
+        try:
+            response = self._call_model_with_backoff(0)
+            if response.text:
+                self._messages.append({"role": "assistant", "content": response.text})
+            return response
+        except Exception as e:
+            return ModelResponse(text=f"[Error] {e}", stop_reason="error")
+
+    def send(self, user_message: str) -> ModelResponse:
+        """Envía un mensaje y ejecuta el bucle agéntico completo."""
+        if self.budget_usd > 0 and self.session.current:
+            if self.session.current.total_cost_usd >= self.budget_usd:
+                return ModelResponse(
+                    text=f"Presupuesto ${self.budget_usd:.2f} alcanzado. Usa /budget para aumentarlo.",
+                    stop_reason="budget",
+                )
+
+        self._tool_counts.clear()
+        self._empty_streak  = 0
+        self._interrupted   = False
+        self._task_ops_streak = 0  # Reset task operations counter
+        self._last_file_written = ""  # Reset consecutive write tracker
+        self._files_written = {}  # Reset file write count tracker
+        _interrupt_requested.clear()
+
+        # ── Compresión de contexto si es necesario ──────────────────────────────
+        compression_summary = None
+        if self.context_mgr:
+            stats = self.context_mgr.get_context_stats(self._messages)
+            token_count = stats.get("total_tokens", 0)
+            usage_pct = stats.get("usage_percent", 0)
+
+            # Log del estado del contexto
+            log.info(f"[DEBUG] Contexto: {token_count:,} tokens ({usage_pct:.1f}% del límite)")
+
+            if stats.get("needs_compression", False):
+                log.info(f"[DEBUG] Comprimiendo contexto...")
+                compressed, summary = self.context_mgr.compress(self._messages)
+                self._messages = compressed
+                compression_summary = summary
+                new_stats = self.context_mgr.get_context_stats(self._messages)
+                log.info(f"[DEBUG] Contexto comprimido: {len(self._messages)} msgs, {new_stats.get('total_tokens', 0):,} tokens")
+
+        # Instalar handler de Ctrl+C para esta llamada (solo en main thread)
+        old_handler = None
+        if threading.current_thread() is threading.main_thread():
+            try:
+                old_handler = signal.signal(signal.SIGINT, _sigint_handler)
+            except ValueError:
+                # signal doesn't work in non-main threads
+                pass
+
+        # Añadir mensaje del usuario (con resumen de compresión si hay)
+        # Si hay pending input del usuario mientras el agente trabajaba, adjuntarlo
+        pending = self.get_pending_input()
+        if pending:
+            user_message = f"{user_message}\n\n[User input during processing]:\n{pending}"
+
+        if compression_summary:
+            self._messages.append({"role": "user", "content": f"{user_message}\n\n{compression_summary}"})
+        else:
+            self._messages.append({"role": "user", "content": user_message})
+
+        # ── Chat mode: solo una llamada al modelo, sin ejecutar tools ─────────────
+        if self._chat_mode:
+            try:
+                response = self._call_model_with_backoff(0)
+                if response.text:
+                    self._messages.append({"role": "assistant", "content": response.text})
+                return response
+            finally:
+                if old_handler is not None:
+                    signal.signal(signal.SIGINT, old_handler)
+                _interrupt_requested.clear()
+
+        last = ModelResponse()
+
+        try:
+            for iteration in range(self.MAX_ITERATIONS):
+                log.info(f"[DEBUG] === Iteration {iteration + 1}/{self.MAX_ITERATIONS} ===")
+
+                # ── Verificar mensajes pendientes (desde webui u otra fuente) ─────────────
+                if self._pending_messages_callback:
+                    try:
+                        pending_msgs = self._pending_messages_callback()
+                        if pending_msgs:
+                            # Agregar mensajes pendientes al contexto
+                            for msg in pending_msgs:
+                                self._messages.append({"role": "user", "content": msg})
+                            log.info(f"[DEBUG] Injected {len(pending_msgs)} pending message(s) into context")
+                            # Anexar al mensaje actual para que el modelo los vea
+                            combined_pending = "\n\n".join([f"[NEW USER MESSAGE]:\n{msg}" for msg in pending_msgs])
+                            user_message = f"{user_message}\n\n{combined_pending}"
+                    except Exception as e:
+                        log.info(f"[DEBUG] Error checking pending messages: {e}")
+
+                # ── Verificar interrupción ────────────────────────────────────
+                if _interrupt_requested.is_set() or self._interrupted:
+                    log.info("Bucle agéntico interrumpido por el usuario")
+                    last.text = last.text or "[Interrumpido por el usuario]"
+                    last.stop_reason = "interrupted"
+                    break
+
+                # Verificar límite de escritura
+                write_count = sum(v for k, v in self._tool_counts.items() if k in ("write_file", "create_file", "append_to_file", "edit_file", "file_edit"))
+                if write_count > self.WRITE_TOOL_LIMIT:
+                    log.info(f"[DEBUG] Write limit reached: {write_count} > {self.WRITE_TOOL_LIMIT}")
+
+                t0       = time.time()
+                response = self._call_model_with_backoff(iteration)
+                elapsed  = time.time() - t0
+                last     = response
+
+                log.log_response(
+                    self.connector.provider_name, self.connector.model_id,
+                    response.input_tokens, response.output_tokens,
+                    response.cost_usd, elapsed, response.stop_reason
+                )
+
+                if self.session.current:
+                    self.session.update_costs(
+                        response.input_tokens, response.output_tokens, response.cost_usd,
+                    )
+
+                if response.stop_reason == "error":
+                    self._messages.append({"role": "assistant", "content": response.text})
+                    break
+
+                # Trim content after done tag to prevent continuation
+                response.text = _extract_done_content(response.text)
+
+                # ── MODE A: Native tool calls ────────────────────────────────
+                if self.connector.NATIVE_TOOLS:
+                    self._messages.append({
+                        "role":    "assistant",
+                        "content": self._resp_to_str(response),
+                    })
+
+                    # Debug logging
+                    log.info(f"[DEBUG] stop_reason={response.stop_reason}, tool_calls={len(response.tool_calls) if response.tool_calls else 0}, text_len={len(response.text)}")
+
+                    # Check for done tag FIRST - explicit completion signal
+                    if _has_done_tag(response.text):
+                        log.info("[DEBUG] Breaking: done tag found")
+                        break
+
+                    # Check for pending tasks - force continuation
+                    if _has_pending_tasks(self.executor):
+                        # Check if stuck in task loop
+                        if self._task_ops_streak >= 3:
+                            cont_msg = self._append_pending_input(_CONTINUE_TASK_LOOP)
+                        else:
+                            cont_msg = self._append_pending_input(_CONTINUE_PENDING_TASKS)
+                        self._messages.append({"role": "user", "content": cont_msg})
+                        log.info("[DEBUG] Continuing: pending tasks")
+                        continue
+
+                    # ── Handle responses WITHOUT tool calls ───────────────────────────
+                    if not response.tool_calls or response.stop_reason != "tool_use":
+                        # Model responded with text, not tools. Decide: continue or stop?
+                        log.info(f"[DEBUG] No tools path: tool_calls={bool(response.tool_calls)}, stop_reason={response.stop_reason}")
+
+                        # Check if code written as text (not in write_file)
+                        if _response_has_code(response.text):
+                            cont_msg = self._append_pending_input(_CONTINUE_CODE_AS_TEXT)
+                            self._messages.append({"role": "user", "content": cont_msg})
+                            log.info("[DEBUG] Continuing: code as text")
+                            continue
+
+                        # Check if looks like a final summary (explicit completion)
+                        if _looks_finished(response.text):
+                            log.info("[DEBUG] Breaking: looks finished")
+                            break
+
+                        # Empty or very short response - model is stuck
+                        if len(response.text.strip()) < 50:
+                            cont_msg = self._append_pending_input(_CONTINUE_EMPTY)
+                            self._messages.append({"role": "user", "content": cont_msg})
+                            log.info("[DEBUG] Continuing: empty/short response")
+                            continue
+
+                        # Response has substance but no tools and no done signal
+                        # The model is explaining something - ask for next action
+                        # This prevents the agent from stopping mid-task
+                        cont_msg = self._append_pending_input(_CONTINUE_NO_TOOLS)
+                        self._messages.append({"role": "user", "content": cont_msg})
+                        log.info("[DEBUG] Continuing: no tools, forcing continuation")
+                        continue
+
+                    # ── Handle responses WITH tool calls ───────────────────────────────
+                    log.info(f"[DEBUG] Executing {len(response.tool_calls)} tool calls")
+
+                    # Show thinking text before executing tools (non-streaming mode)
+                    if self.thinking_cb and response.text.strip():
+                        self.thinking_cb(response.text)
+
+                    # Check for mixed code-as-text with tools (broken response)
+                    if _has_mixed_code_and_tools(response.text):
+                        self._messages.append({"role": "user", "content": _CONTINUE_MIXED_CONTENT})
+                        continue
+
+                    if iteration >= self.WARN_AT:
+                        cont_msg = self._append_pending_input(_CONTINUE_NEAR_LIMIT)
+                        self._messages.append({"role": "user", "content": cont_msg})
+                    results, had_failure, consecutive_write, write_blocked = self._execute_native_tools(response.tool_calls)
+
+                    # Choose appropriate continuation message
+                    if write_blocked:
+                        cont = _FILE_WRITE_BLOCKED
+                    elif consecutive_write:
+                        cont = _CONTINUE_FILE_LOOP
+                    elif had_failure:
+                        cont = _CONTINUE_ERROR
+                    elif self._task_ops_streak >= 3:
+                        cont = _CONTINUE_TASK_LOOP
+                    elif _has_pending_tasks(self.executor):
+                        cont = _CONTINUE_PENDING_TASKS
+                    else:
+                        cont = _CONTINUE_AFTER_TOOLS
+
+                    # Append pending input to continuation message
+                    cont_with_pending = self._append_pending_input(f"{results}\n\n{cont}")
+                    self._messages.append({"role": "user", "content": cont_with_pending})
+                    log.info(f"[DEBUG] Tools executed, continuing iteration {iteration}")
+                else:
+                    self._messages.append({"role": "assistant", "content": response.text})
+
+                    # Debug logging for XML mode
+                    log.info(f"[DEBUG XML] text_len={len(response.text)}, stop_reason={response.stop_reason}")
+
+                    # Check for done tag first - explicit completion signal
+                    if _has_done_tag(response.text):
+                        log.info("[DEBUG XML] Breaking: done tag found")
+                        break
+
+                    # Check for pending tasks - must continue
+                    has_pending = _has_pending_tasks(self.executor)
+
+                    actions = parse_xml_actions(response.text)
+                    log.info(f"[DEBUG XML] actions={len(actions)}, has_pending={has_pending}")
+
+                    if not actions:
+                        self._empty_streak += 1
+                        log.info(f"[DEBUG XML] No actions, empty_streak={self._empty_streak}")
+
+                        # Empty response - retry with instructions
+                        if not response.text.strip():
+                            if self._empty_streak >= 5:  # Aumentado de 3 a 5
+                                log.info("[DEBUG XML] Breaking: empty streak >= 5")
+                                break
+                            cont_msg = self._append_pending_input(_CONTINUE_EMPTY)
+                            self._messages.append({"role": "user", "content": cont_msg})
+                            log.info("[DEBUG XML] Continuing: empty response")
+                            continue
+
+                        # Check for unclosed/multiple write_file tags
+                        if _has_unclosed_write_file(response.text):
+                            cont_msg = self._append_pending_input(_CONTINUE_UNCLOSED_FILE)
+                            self._messages.append({"role": "user", "content": cont_msg})
+                            self._empty_streak = 0  # Reset streak
+                            log.info("[DEBUG XML] Continuing: unclosed write_file")
+                            continue
+
+                        # Code as text - MUST use write_file
+                        if _response_has_code(response.text):
+                            cont_msg = self._append_pending_input(_CONTINUE_CODE_AS_TEXT)
+                            self._messages.append({"role": "user", "content": cont_msg})
+                            self._empty_streak = 0  # Reset streak
+                            log.info("[DEBUG XML] Continuing: code as text")
+                            continue
+
+                        # Pending tasks - must continue working
+                        if has_pending:
+                            cont_msg = self._append_pending_input(_CONTINUE_PENDING_TASKS)
+                            self._messages.append({"role": "user", "content": cont_msg})
+                            self._empty_streak = 0  # Reset streak
+                            log.info("[DEBUG XML] Continuing: pending tasks")
+                            continue
+
+                        # Action intentions without execution (English and Spanish)
+                        tl = response.text.lower()
+                        action_intentions = [
+                            # English
+                            "i will", "proceeding", "going to", "i'll",
+                            "step 1", "step 2", "first,", "now i",
+                            "next,", "i need to", "i'm going to", "let me",
+                            "i have to", "must", "should", "planning to",
+                            "i'm going", "going to", "will now", "now i will",
+                            # Spanish
+                            "voy a", "voy a ", "primero", "ahora voy",
+                            "siguiente", "necesito", "tengo que", "debo",
+                            "pasos:", "paso 1", "paso 2", "primero", "luego",
+                            "continuar", "proceder", "ejecutar", "usar",
+                        ]
+                        if any(w in tl for w in action_intentions):
+                            cont_msg = self._append_pending_input(_CONTINUE_INCOMPLETE)
+                            self._messages.append({"role": "user", "content": cont_msg})
+                            self._empty_streak = 0  # Reset streak - model has intent
+                            log.info("[DEBUG XML] Continuing: action intentions detected")
+                            continue
+
+                        # Looks finished - allow exit ONLY if explicit completion signals
+                        if _looks_finished(response.text):
+                            log.info("[DEBUG XML] Breaking: looks finished")
+                            break
+
+                        # Response has substance but no actions and no done signal
+                        # Force continuation - the model should use tools or signal done
+                        # Reset streak if response has substantial content
+                        if len(response.text.strip()) > 100:
+                            self._empty_streak = 0  # Reset - model is thinking/explaining
+
+                        if self._empty_streak < 5:  # Aumentado de 3 a 5
+                            cont_msg = self._append_pending_input(_CONTINUE_NO_TOOLS)
+                            self._messages.append({"role": "user", "content": cont_msg})
+                            log.info("[DEBUG XML] Continuing: no actions, forcing continuation")
+                            continue
+
+                        # After 5+ empty responses, stop to avoid infinite loop
+                        log.info("[DEBUG XML] Breaking: empty streak >= 5 (no actions)")
+                        break
+
+                    # Show thinking text before executing tools (XML mode)
+                    if self.thinking_cb and response.text.strip():
+                        # Extract text before XML actions
+                        text_before_actions = response.text.split('<')[0].strip()
+                        if text_before_actions:
+                            self.thinking_cb(text_before_actions)
+
+                    self._empty_streak = 0
+                    results, had_failure, consecutive_write, write_blocked = self._execute_xml_actions(actions)
+
+                    if _interrupt_requested.is_set():
+                        break
+
+                    # Check for incomplete code in write_file
+                    if _has_incomplete_code(response.text):
+                        cont_msg = self._append_pending_input(_CONTINUE_INCOMPLETE_CODE)
+                        self._messages.append({"role": "user", "content": cont_msg})
+                        continue
+
+                    # Check for mixed code-as-text with tools
+                    if _has_mixed_code_and_tools(response.text):
+                        cont_msg = self._append_pending_input(_CONTINUE_MIXED_CONTENT)
+                        self._messages.append({"role": "user", "content": cont_msg})
+                        continue
+
+                    # After executing tools, check for write blocked first
+                    if write_blocked:
+                        cont = _FILE_WRITE_BLOCKED
+                    elif consecutive_write:
+                        cont = _CONTINUE_FILE_LOOP
+                    elif had_failure:
+                        cont = _CONTINUE_ERROR
+                    elif self._task_ops_streak >= 3:
+                        cont = _CONTINUE_TASK_LOOP
+                    elif _has_pending_tasks(self.executor):
+                        cont = _CONTINUE_PENDING_TASKS
+                    elif iteration >= self.WARN_AT:
+                        cont = _CONTINUE_NEAR_LIMIT
+                    else:
+                        cont = _CONTINUE_AFTER_TOOLS
+
+                    # Append pending input to continuation message
+                    cont_with_pending = self._append_pending_input(f"Results:\n\n{results}\n\n{cont}")
+                    self._messages.append({
+                        "role":    "user",
+                        "content": cont_with_pending,
+                    })
+
+            # Log fin del bucle
+            log.info(f"[DEBUG] Loop ended after {iteration + 1} iterations")
+
+        finally:
+            # Restaurar handler original de Ctrl+C
+            if old_handler is not None:
+                signal.signal(signal.SIGINT, old_handler)
+            _interrupt_requested.clear()
+
+        # Si la respuesta está vacía, generar un mensaje de finalización
+        if last and (not last.text or not last.text.strip()):
+            last.text = "✓ Tarea completada."
+            log.info("[DEBUG] Empty response replaced with completion message")
+
+        log.info(f"[DEBUG] QueryEngine.send() returning, stop_reason={last.stop_reason}")
+        return last
+
+    def get_messages(self) -> List[Dict]:
+        return list(self._messages)
+
+    def set_messages(self, msgs: List[Dict]):
+        self._messages = list(msgs)
+
+    def clear(self, system: str, context: str = ""):
+        self.set_system_prompt(system)
+        if context:
+            self.inject_context(context)
+
+    # ── Llamada al modelo con exponential backoff ─────────────────────────────
+
+    def _call_model_with_backoff(self, iteration: int = 0) -> ModelResponse:
+        # Iniciar indicador de procesamiento si streaming está OFF
+        streaming_active = self.stream_cb is not None and (self._ui and self._ui.is_streaming_enabled())
+        if self._ui and not streaming_active:
+            self._ui.start_processing()
+
+        try:
+            for attempt in range(self.MAX_API_RETRIES):
+                if _interrupt_requested.is_set():
+                    return ModelResponse(text="[Interrumpido]", stop_reason="interrupted")
+                try:
+                    log.log_request(
+                        self.connector.provider_name, self.connector.model_id,
+                        len(self._messages), attempt
+                    )
+                    if self.connector.NATIVE_TOOLS:
+                        return self.connector.chat_with_tools(
+                            messages=self._messages,
+                            tools=TOOL_DEFINITIONS,
+                            stream_callback=self.stream_cb if streaming_active else None,
+                        )
+                    else:
+                        return self.connector.chat(
+                            messages=self._messages,
+                            stream_callback=self.stream_cb if streaming_active else None,
+                        )
+
+                except Exception as e:
+                    log.log_error(f"API attempt {attempt+1}/{self.MAX_API_RETRIES}", e)
+                    is_last = (attempt == self.MAX_API_RETRIES - 1)
+                    if is_last or not _is_retryable_error(e):
+                        return ModelResponse(
+                            text=f"[Error API] {type(e).__name__}: {e}",
+                            stop_reason="error",
+                        )
+                    wait = _backoff(attempt)
+                    log.info(f"Reintentando en {wait:.1f}s (attempt {attempt+1})")
+                    time.sleep(wait)
+        finally:
+            # Detener indicador de procesamiento
+            if self._ui:
+                self._ui.stop_processing()
+
+        return ModelResponse(text="[Error desconocido]", stop_reason="error")
+
+    # ── Límite por herramienta ────────────────────────────────────────────────
+
+    def _check_tool_limit(self, tool_name: str) -> Optional[str]:
+        self._tool_counts[tool_name] = self._tool_counts.get(tool_name, 0) + 1
+        if tool_name in READ_ONLY_TOOLS:
+            return None
+        count = self._tool_counts[tool_name]
+        if count > self.WRITE_TOOL_LIMIT:
+            return (f"[Aviso] '{tool_name}' usada {count}x. "
+                    "Verifica que no estás en un bucle.")
+        return None
+
+    def _check_file_write_loop(self, path: str) -> tuple:
+        """
+        Check if file is being written repeatedly (loop detection).
+        Returns (is_consecutive, write_count, should_block).
+
+        - is_consecutive: True if same file was just written
+        - write_count: Total times this file has been written
+        - should_block: True if file has been written too many times (>=3)
+        """
+        # Track total writes per file
+        self._files_written[path] = self._files_written.get(path, 0) + 1
+        write_count = self._files_written[path]
+
+        # Check consecutive write
+        is_consecutive = (path == self._last_file_written and path != "")
+
+        # Update last file written
+        if path:
+            self._last_file_written = path
+
+        # Block if file written 3+ times
+        should_block = write_count >= 3
+
+        return is_consecutive, write_count, should_block
+
+    # ── Ejecución MODO A ──────────────────────────────────────────────────────
+
+    def _execute_native_tools(self, tool_calls: List[ToolCall]) -> tuple:
+        """Execute native tools. Returns (results_string, had_failure, consecutive_write, write_blocked)."""
+        parts = ["[Resultados]"]
+        had_failure = False
+        consecutive_write = False
+        write_blocked = False
+        for tc in tool_calls:
+            # Track task operations for loop detection
+            if tc.name in ("task_create", "task_update", "task_list", "task_get"):
+                self._task_ops_streak += 1
+            elif tc.name in ("write_file", "create_file", "append_to_file", "exec_cmd", "edit_file", "file_edit"):
+                self._task_ops_streak = 0  # Reset when real work is done
+
+            # Check for file write loop
+            if tc.name in ("write_file", "create_file"):
+                path = tc.arguments.get("path", "")
+                is_cons, write_count, should_block = self._check_file_write_loop(path)
+                if should_block:
+                    # Block the write - skip execution
+                    write_blocked = True
+                    parts.append(f"\n[🛫 BLOCKED] write_file '{path}' - Written {write_count} times already")
+                    parts.append(_FILE_WRITE_BLOCKED)
+                    continue
+                elif is_cons:
+                    consecutive_write = True
+
+            if self.tool_start:
+                self.tool_start(tc.name, tc.arguments)
+            warn   = self._check_tool_limit(tc.name)
+            t0     = time.time()
+            result = self.executor.execute(tc.name, tc.arguments)
+            elapsed = time.time() - t0
+            log.log_tool(tc.name, tc.arguments, result.success, elapsed)
+            self._record(tc.name, tc.arguments)
+            if self.tool_end:
+                self.tool_end(tc.name, result.to_str(), result.success)
+            status = "✓" if result.success else "✗"
+            entry  = f"\n[{status} {tc.name}]\n{result.to_str()}"
+            if warn:
+                entry += f"\n{warn}"
+            parts.append(entry)
+            if not result.success:
+                had_failure = True
+        return "\n".join(parts), had_failure, consecutive_write, write_blocked
+
+    # ── Ejecución MODO B ──────────────────────────────────────────────────────
+
+    def _execute_xml_actions(self, actions: List[Dict]) -> tuple:
+        """Execute XML actions. Returns (results_string, had_failure, consecutive_write, write_blocked)."""
+        parts = []
+        had_failure = False
+        consecutive_write = False
+        write_blocked = False
+        for action in actions:
+            tool_name, args = action_to_tool_args(action)
+
+            # Track task operations for loop detection
+            if tool_name in ("task_create", "task_update", "task_list", "task_get"):
+                self._task_ops_streak += 1
+            elif tool_name in ("write_file", "create_file", "append_to_file", "exec_cmd", "edit_file", "file_edit"):
+                self._task_ops_streak = 0  # Reset when real work is done
+
+            # Check for file write loop
+            if tool_name in ("write_file", "create_file"):
+                path = args.get("path", "")
+                is_cons, write_count, should_block = self._check_file_write_loop(path)
+                if should_block:
+                    # Block the write - skip execution
+                    write_blocked = True
+                    parts.append(f"[🛑 BLOCKED] write_file '{path}' - Written {write_count} times already")
+                    parts.append(_FILE_WRITE_BLOCKED)
+                    continue
+                elif is_cons:
+                    consecutive_write = True
+
+            # run_plugin → delegado al plugin_manager
+            if tool_name == "run_plugin":
+                result = self._run_plugin(args.get("name",""), args.get("args",""))
+                parts.append(f"[✓ plugin:{args.get('name','')}]\n{result}")
+                continue
+
+            if self.tool_start:
+                self.tool_start(tool_name, args)
+            warn    = self._check_tool_limit(tool_name)
+            t0      = time.time()
+            result  = self.executor.execute(tool_name, args)
+            elapsed = time.time() - t0
+            log.log_tool(tool_name, args, result.success, elapsed)
+            self._record(tool_name, args)
+            if self.tool_end:
+                self.tool_end(tool_name, result.to_str(), result.success)
+            status = "✓" if result.success else "✗"
+            entry  = f"[{status} {tool_name}]\n{result.to_str()}"
+            if warn:
+                entry += f"\n{warn}"
+            parts.append(entry)
+            if not result.success:
+                had_failure = True
+        return "\n\n".join(parts), had_failure, consecutive_write, write_blocked
+
+    def _run_plugin(self, name: str, args: str) -> str:
+        if not self.plugin_mgr:
+            return f"[Error] Plugin manager no disponible"
+        t0     = time.time()
+        result = self.plugin_mgr.run(name, args) or ""
+        elapsed = time.time() - t0
+        log.log_plugin(name, args, elapsed)
+        if self.tool_start:
+            self.tool_start(f"plugin:{name}", {"args": args})
+        if self.tool_end:
+            self.tool_end(f"plugin:{name}", result, True)
+        return result
+
+    # ── Helpers ───────────────────────────────────────────────────────────────
+
+    def _record(self, tool_name: str, args: Dict):
+        if tool_name in ("write_file", "create_file", "file_edit", "append_to_file"):
+            p = args.get("path", "")
+            if p:
+                self.session.snapshot_file(p)
+                self.session.record_file_modified(p)
+        if tool_name == "exec_cmd":
+            self.session.record_command(args.get("cmd", ""))
+
+    def _resp_to_str(self, r: ModelResponse) -> str:
+        parts = []
+        if r.text:
+            parts.append(r.text)
+        for tc in r.tool_calls:
+            parts.append(f"[Tool: {tc.name} {tc.arguments}]")
+        return "\n".join(parts)