tunacode-cli 0.0.55__py3-none-any.whl → 0.0.78.6__py3-none-any.whl

tunacode/core/agents/agent_components/agent_config.py

@@ -1,25 +1,48 @@
 """Agent configuration and creation utilities."""
 
 from pathlib import Path
+from typing import Dict, Tuple
 
+from httpx import AsyncClient, HTTPStatusError
 from pydantic_ai import Agent
+from pydantic_ai.models.anthropic import AnthropicModel
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.providers.anthropic import AnthropicProvider
+from pydantic_ai.providers.openai import OpenAIProvider
+from pydantic_ai.retries import AsyncTenacityTransport, RetryConfig, wait_retry_after
+from tenacity import retry_if_exception_type, stop_after_attempt
 
 from tunacode.core.logging.logger import get_logger
 from tunacode.core.state import StateManager
-from tunacode.services.mcp import get_mcp_servers
+from tunacode.services.mcp import get_mcp_servers, register_mcp_agent
 from tunacode.tools.bash import bash
 from tunacode.tools.glob import glob
 from tunacode.tools.grep import grep
 from tunacode.tools.list_dir import list_dir
 from tunacode.tools.read_file import read_file
 from tunacode.tools.run_command import run_command
-from tunacode.tools.todo import TodoTool
 from tunacode.tools.update_file import update_file
 from tunacode.tools.write_file import write_file
 from tunacode.types import ModelName, PydanticAgent
 
 logger = get_logger(__name__)
 
+# Module-level caches for system prompts
+_PROMPT_CACHE: Dict[str, Tuple[str, float]] = {}
+_TUNACODE_CACHE: Dict[str, Tuple[str, float]] = {}
+
+# Module-level cache for agents to persist across requests
+_AGENT_CACHE: Dict[ModelName, PydanticAgent] = {}
+_AGENT_CACHE_VERSION: Dict[ModelName, int] = {}
+
+
+def clear_all_caches():
+    """Clear all module-level caches. Useful for testing."""
+    _PROMPT_CACHE.clear()
+    _TUNACODE_CACHE.clear()
+    _AGENT_CACHE.clear()
+    _AGENT_CACHE_VERSION.clear()
+
 
 def get_agent_tool():
     """Lazy import for Agent and Tool to avoid circular imports."""
@@ -28,44 +51,176 @@ def get_agent_tool():
     return Agent, Tool
 
 
-def load_system_prompt(base_path: Path) -> str:
-    """Load the system prompt from file."""
-    prompt_path = base_path / "prompts" / "system.md"
+def _read_prompt_from_path(prompt_path: Path) -> str:
+    """Return prompt content from disk, leveraging the cache when possible."""
+    cache_key = str(prompt_path)
+
     try:
-        with open(prompt_path, "r", encoding="utf-8") as f:
-            return f.read().strip()
-    except FileNotFoundError:
-        # Fallback to system.txt if system.md not found
-        prompt_path = base_path / "prompts" / "system.txt"
-        try:
-            with open(prompt_path, "r", encoding="utf-8") as f:
-                return f.read().strip()
-        except FileNotFoundError:
-            # Use a default system prompt if neither file exists
-            return "You are a helpful AI assistant for software development tasks."
+        current_mtime = prompt_path.stat().st_mtime
+    except FileNotFoundError as error:
+        raise FileNotFoundError from error
+
+    if cache_key in _PROMPT_CACHE:
+        cached_content, cached_mtime = _PROMPT_CACHE[cache_key]
+        if current_mtime == cached_mtime:
+            return cached_content
+
+    try:
+        content = prompt_path.read_text(encoding="utf-8").strip()
+    except FileNotFoundError as error:
+        raise FileNotFoundError from error
+
+    _PROMPT_CACHE[cache_key] = (content, current_mtime)
+    return content
+
+
+def load_system_prompt(base_path: Path) -> str:
+    """Load the system prompt from system.xml file with caching.
+
+    Raises:
+        FileNotFoundError: If system.xml does not exist in the prompts directory.
+    """
+    prompts_dir = base_path / "prompts"
+    prompt_path = prompts_dir / "system.xml"
+
+    if not prompt_path.exists():
+        raise FileNotFoundError(
+            f"Required system prompt file not found: {prompt_path}. "
+            "The system.xml file must exist in the prompts directory."
+        )
+
+    return _read_prompt_from_path(prompt_path)
 
 
 def load_tunacode_context() -> str:
-    """Load TUNACODE.md context if it exists."""
+    """Load AGENTS.md context if it exists with caching."""
     try:
-        tunacode_path = Path.cwd() / "TUNACODE.md"
-        if tunacode_path.exists():
-            tunacode_content = tunacode_path.read_text(encoding="utf-8")
-            if tunacode_content.strip():
-                logger.info("📄 TUNACODE.md located: Loading context...")
-                return "\n\n# Project Context from TUNACODE.md\n" + tunacode_content
-            else:
-                logger.info("📄 TUNACODE.md not found: Using default context")
+        tunacode_path = Path.cwd() / "AGENTS.md"
+        cache_key = str(tunacode_path)
+
+        if not tunacode_path.exists():
+            logger.info("📄 AGENTS.md not found: Using default context")
+            return ""
+
+        # Check cache with file modification time
+        if cache_key in _TUNACODE_CACHE:
+            cached_content, cached_mtime = _TUNACODE_CACHE[cache_key]
+            current_mtime = tunacode_path.stat().st_mtime
+            if current_mtime == cached_mtime:
+                return cached_content
+
+        # Load from file and cache
+        tunacode_content = tunacode_path.read_text(encoding="utf-8")
+        if tunacode_content.strip():
+            logger.info("📄 AGENTS.md located: Loading context...")
+            result = "\n\n# Project Context from AGENTS.md\n" + tunacode_content
+            _TUNACODE_CACHE[cache_key] = (result, tunacode_path.stat().st_mtime)
+            return result
         else:
-            logger.info("📄 TUNACODE.md not found: Using default context")
+            logger.info("📄 AGENTS.md not found: Using default context")
+            _TUNACODE_CACHE[cache_key] = ("", tunacode_path.stat().st_mtime)
+            return ""
+
     except Exception as e:
-        logger.debug(f"Error loading TUNACODE.md: {e}")
-    return ""
+        logger.debug(f"Error loading AGENTS.md: {e}")
+        return ""
+
+
+def _create_model_with_retry(
+    model_string: str, http_client: AsyncClient, state_manager: StateManager
+):
+    """Create a model instance with retry-enabled HTTP client.
+
+    Parses model string in format 'provider:model_name' and creates
+    appropriate provider and model instances with the retry-enabled HTTP client.
+    """
+    # Extract environment config
+    env = state_manager.session.user_config.get("env", {})
+
+    # Provider configuration: API key names and base URLs
+    PROVIDER_CONFIG = {
+        "anthropic": {"api_key_name": "ANTHROPIC_API_KEY", "base_url": None},
+        "openai": {"api_key_name": "OPENAI_API_KEY", "base_url": None},
+        "openrouter": {
+            "api_key_name": "OPENROUTER_API_KEY",
+            "base_url": "https://openrouter.ai/api/v1",
+        },
+        "azure": {
+            "api_key_name": "AZURE_OPENAI_API_KEY",
+            "base_url": env.get("AZURE_OPENAI_ENDPOINT"),
+        },
+        "deepseek": {"api_key_name": "DEEPSEEK_API_KEY", "base_url": None},
+    }
+
+    # Parse model string
+    if ":" in model_string:
+        provider_name, model_name = model_string.split(":", 1)
+    else:
+        # Auto-detect provider from model name
+        model_name = model_string
+        if model_name.startswith("claude"):
+            provider_name = "anthropic"
+        elif model_name.startswith(("gpt", "o1", "o3")):
+            provider_name = "openai"
+        else:
+            # Default to treating as model string (pydantic-ai will auto-detect)
+            return model_string
+
+    # Create provider with api_key + base_url + http_client
+    if provider_name == "anthropic":
+        api_key = env.get("ANTHROPIC_API_KEY")
+        provider = AnthropicProvider(api_key=api_key, http_client=http_client)
+        return AnthropicModel(model_name, provider=provider)
+    elif provider_name in ("openai", "openrouter", "azure", "deepseek"):
+        # OpenAI-compatible providers all use OpenAIChatModel
+        config = PROVIDER_CONFIG.get(provider_name, {})
+        api_key = env.get(config.get("api_key_name"))
+        base_url = config.get("base_url")
+        provider = OpenAIProvider(api_key=api_key, base_url=base_url, http_client=http_client)
+        return OpenAIChatModel(model_name, provider=provider)
+    else:
+        # Unsupported provider, return string and let pydantic-ai handle it
+        # (won't have retry support but won't break)
+        logger.warning(
+            f"Provider '{provider_name}' not configured for HTTP retries. "
+            f"Falling back to default behavior."
+        )
+        return model_string
 
 
 def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
     """Get existing agent or create new one for the specified model."""
-    if model not in state_manager.session.agents:
+    import logging
+
+    logger = logging.getLogger(__name__)
+
+    # Check session-level cache first (for backward compatibility with tests)
+    if model in state_manager.session.agents:
+        logger.debug(f"Using session-cached agent for model {model}")
+        return state_manager.session.agents[model]
+
+    # Check module-level cache
+    if model in _AGENT_CACHE:
+        # Verify cache is still valid (check for config changes)
+        settings = state_manager.session.user_config.get("settings", {})
+        current_version = hash(
+            (
+                str(settings.get("max_retries", 3)),
+                str(settings.get("tool_strict_validation", False)),
+                str(state_manager.session.user_config.get("mcpServers", {})),
+            )
+        )
+        if _AGENT_CACHE_VERSION.get(model) == current_version:
+            logger.debug(f"Using module-cached agent for model {model}")
+            state_manager.session.agents[model] = _AGENT_CACHE[model]
+            return _AGENT_CACHE[model]
+        else:
+            logger.debug(f"Cache invalidated for model {model} due to config change")
+            del _AGENT_CACHE[model]
+            del _AGENT_CACHE_VERSION[model]
+
+    if model not in _AGENT_CACHE:
+        logger.debug(f"Creating new agent for model {model}")
         max_retries = state_manager.session.user_config.get("settings", {}).get("max_retries", 3)
 
         # Lazy import Agent and Tool
@@ -75,35 +230,74 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
         base_path = Path(__file__).parent.parent.parent.parent
         system_prompt = load_system_prompt(base_path)
 
-        # Load TUNACODE.md context
+        # Load AGENTS.md context
         system_prompt += load_tunacode_context()
 
-        # Initialize todo tool
-        todo_tool = TodoTool(state_manager=state_manager)
+        # Get tool strict validation setting from config (default to False for backward
+        # compatibility)
+        tool_strict_validation = state_manager.session.user_config.get("settings", {}).get(
+            "tool_strict_validation", False
+        )
+
+        # Create tool list
+        tools_list = [
+            Tool(bash, max_retries=max_retries, strict=tool_strict_validation),
+            Tool(glob, max_retries=max_retries, strict=tool_strict_validation),
+            Tool(grep, max_retries=max_retries, strict=tool_strict_validation),
+            Tool(list_dir, max_retries=max_retries, strict=tool_strict_validation),
+            Tool(read_file, max_retries=max_retries, strict=tool_strict_validation),
+            Tool(run_command, max_retries=max_retries, strict=tool_strict_validation),
+            Tool(update_file, max_retries=max_retries, strict=tool_strict_validation),
+            Tool(write_file, max_retries=max_retries, strict=tool_strict_validation),
+        ]
 
-        # Add todo context if available
-        try:
-            current_todos = todo_tool.get_current_todos_sync()
-            if current_todos != "No todos found":
-                system_prompt += f'\n\n# Current Todo List\n\nYou have existing todos that need attention:\n\n{current_todos}\n\nRemember to check progress on these todos and update them as you work. Use todo("list") to see current status anytime.'
-        except Exception as e:
-            logger.warning(f"Warning: Failed to load todos: {e}")
+        logger.debug(f"Creating agent with {len(tools_list)} tools")
+
+        mcp_servers = get_mcp_servers(state_manager)
+
+        # Configure HTTP client with retry logic at transport layer
+        # This handles retries BEFORE node creation, avoiding pydantic-ai's
+        # single-stream-per-node constraint violations
+        # https://ai.pydantic.dev/api/retries/#pydantic_ai.retries.wait_retry_after
+        transport = AsyncTenacityTransport(
+            config=RetryConfig(
+                retry=retry_if_exception_type(HTTPStatusError),
+                wait=wait_retry_after(max_wait=60),
+                stop=stop_after_attempt(max_retries),
+                reraise=True,
+            ),
+            validate_response=lambda r: r.raise_for_status(),
+        )
+        http_client = AsyncClient(transport=transport)
 
-        # Create agent with all tools
-        state_manager.session.agents[model] = Agent(
-            model=model,
+        # Create model instance with retry-enabled HTTP client
+        model_instance = _create_model_with_retry(model, http_client, state_manager)
+
+        agent = Agent(
+            model=model_instance,
             system_prompt=system_prompt,
-            tools=[
-                Tool(bash, max_retries=max_retries),
-                Tool(glob, max_retries=max_retries),
-                Tool(grep, max_retries=max_retries),
-                Tool(list_dir, max_retries=max_retries),
-                Tool(read_file, max_retries=max_retries),
-                Tool(run_command, max_retries=max_retries),
-                Tool(todo_tool._execute, max_retries=max_retries),
-                Tool(update_file, max_retries=max_retries),
-                Tool(write_file, max_retries=max_retries),
-            ],
-            mcp_servers=get_mcp_servers(state_manager),
+            tools=tools_list,
+            mcp_servers=mcp_servers,
         )
-    return state_manager.session.agents[model]
+
+        # Register agent for MCP cleanup tracking
+        mcp_server_names = state_manager.session.user_config.get("mcpServers", {}).keys()
+        for server_name in mcp_server_names:
+            register_mcp_agent(server_name, agent)
+
+        # Store in both caches
+        _AGENT_CACHE[model] = agent
+        _AGENT_CACHE_VERSION[model] = hash(
+            (
+                str(state_manager.session.user_config.get("settings", {}).get("max_retries", 3)),
+                str(
+                    state_manager.session.user_config.get("settings", {}).get(
+                        "tool_strict_validation", False
+                    )
+                ),
+                str(state_manager.session.user_config.get("mcpServers", {})),
+            )
+        )
+        state_manager.session.agents[model] = agent
+
+    return _AGENT_CACHE[model]

tunacode/core/agents/agent_components/agent_helpers.py

@@ -94,27 +94,29 @@ def create_empty_response_message(
     iteration: int,
     state_manager: StateManager,
 ) -> str:
-    """Create an aggressive message for handling empty responses."""
+    """Create a constructive message for handling empty responses."""
     tools_context = get_recent_tools_context(tool_calls)
 
-    content = f"""FAILURE DETECTED: You returned {("an " + empty_reason if empty_reason != "empty" else "an empty")} response.
-
-This is UNACCEPTABLE. You FAILED to produce output.
+    reason = empty_reason if empty_reason != "empty" else "empty"
+    content = f"""Response appears {reason} or incomplete. Let's troubleshoot and try again.
 
 Task: {message[:200]}...
 {tools_context}
-Current iteration: {iteration}
+Attempt: {iteration}
+
+Please take one of these specific actions:
 
-TRY AGAIN RIGHT NOW:
+1. **Search yielded no results?** → Try alternative search terms or broader patterns
+2. **Found what you need?** → Use TUNACODE DONE: to finalize
+3. **Encountering a blocker?** → Explain the specific issue preventing progress
+4. **Need more context?** → Use list_dir or expand your search scope
 
-1. If your search returned no results → Try a DIFFERENT search pattern
-2. If you found what you need → Use TUNACODE_TASK_COMPLETE
-3. If you're stuck → EXPLAIN SPECIFICALLY what's blocking you
-4. If you need to explore → Use list_dir or broader searches
+**Expected in your response:**
+- Execute at least one tool OR provide substantial analysis
+- If stuck, clearly describe what you've tried and what's blocking you
+- Avoid empty responses - the system needs actionable output to proceed
 
-YOU MUST PRODUCE REAL OUTPUT IN THIS RESPONSE. NO EXCUSES.
-EXECUTE A TOOL OR PROVIDE SUBSTANTIAL CONTENT.
-DO NOT RETURN ANOTHER EMPTY RESPONSE."""
+Ready to continue with a complete response."""
 
     return content
 
@@ -200,6 +202,34 @@ def create_fallback_response(
     return fallback
 
 
+async def handle_empty_response(
+    message: str,
+    reason: str,
+    iter_index: int,
+    state: Any,
+) -> None:
+    """Handle empty responses by creating a synthetic user message with retry guidance."""
+    from tunacode.ui import console as ui
+
+    force_action_content = create_empty_response_message(
+        message,
+        reason,
+        getattr(state.sm.session, "tool_calls", []),
+        iter_index,
+        state.sm,
+    )
+    create_user_message(force_action_content, state.sm)
+
+    if state.show_thoughts:
+        await ui.warning("\nEMPTY RESPONSE FAILURE - AGGRESSIVE RETRY TRIGGERED")
+        await ui.muted(f"   Reason: {reason}")
+        await ui.muted(
+            f"   Recent tools: "
+            f"{get_recent_tools_context(getattr(state.sm.session, 'tool_calls', []))}"
+        )
+        await ui.muted("   Injecting retry guidance prompt")
+
+
 def format_fallback_output(fallback: FallbackResponse) -> str:
     """Format a fallback response into a comprehensive output string."""
     output_parts = [fallback.summary, ""]