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

tunacode/core/agents/agent_components/agent_config.py

@@ -3,19 +3,24 @@
 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.present_plan import create_present_plan_tool
 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
@@ -46,55 +51,55 @@ def get_agent_tool():
     return Agent, Tool
 
 
-def load_system_prompt(base_path: Path) -> str:
-    """Load the system prompt from file with caching."""
-    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)
 
-    # Check cache with file modification time
     try:
-        if cache_key in _PROMPT_CACHE:
-            cached_content, cached_mtime = _PROMPT_CACHE[cache_key]
-            current_mtime = prompt_path.stat().st_mtime
-            if current_mtime == cached_mtime:
-                return cached_content
+        current_mtime = prompt_path.stat().st_mtime
+    except FileNotFoundError as error:
+        raise FileNotFoundError from error
 
-        # Load from file and cache
-        with open(prompt_path, "r", encoding="utf-8") as f:
-            content = f.read().strip()
-        _PROMPT_CACHE[cache_key] = (content, prompt_path.stat().st_mtime)
-        return content
+    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
 
-    except FileNotFoundError:
-        # Fallback to system.txt if system.md not found
-        prompt_path = base_path / "prompts" / "system.txt"
-        cache_key = str(prompt_path)
+    _PROMPT_CACHE[cache_key] = (content, current_mtime)
+    return content
 
-        try:
-            if cache_key in _PROMPT_CACHE:
-                cached_content, cached_mtime = _PROMPT_CACHE[cache_key]
-                current_mtime = prompt_path.stat().st_mtime
-                if current_mtime == cached_mtime:
-                    return cached_content
 
-            with open(prompt_path, "r", encoding="utf-8") as f:
-                content = f.read().strip()
-            _PROMPT_CACHE[cache_key] = (content, prompt_path.stat().st_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."
+        )
 
-        except FileNotFoundError:
-            # Use a default system prompt if neither file exists
-            return "You are a helpful AI assistant."
+    return _read_prompt_from_path(prompt_path)
 
 
 def load_tunacode_context() -> str:
-    """Load TUNACODE.md context if it exists with caching."""
+    """Load AGENTS.md context if it exists with caching."""
     try:
-        tunacode_path = Path.cwd() / "TUNACODE.md"
+        tunacode_path = Path.cwd() / "AGENTS.md"
         cache_key = str(tunacode_path)
 
         if not tunacode_path.exists():
-            logger.info("📄 TUNACODE.md not found: Using default context")
+            logger.info("📄 AGENTS.md not found: Using default context")
             return ""
 
         # Check cache with file modification time
@@ -107,20 +112,82 @@ def load_tunacode_context() -> str:
         # Load from file and cache
         tunacode_content = tunacode_path.read_text(encoding="utf-8")
         if tunacode_content.strip():
-            logger.info("📄 TUNACODE.md located: Loading context...")
-            result = "\n\n# Project Context from TUNACODE.md\n" + tunacode_content
+            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}")
+        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."""
     import logging
@@ -135,10 +202,11 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
     # 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(
             (
-                state_manager.is_plan_mode(),
-                str(state_manager.session.user_config.get("settings", {}).get("max_retries", 3)),
+                str(settings.get("max_retries", 3)),
+                str(settings.get("tool_strict_validation", False)),
                 str(state_manager.session.user_config.get("mcpServers", {})),
             )
         )
@@ -152,9 +220,7 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
             del _AGENT_CACHE_VERSION[model]
 
     if model not in _AGENT_CACHE:
-        logger.debug(
-            f"Creating new agent for model {model}, plan_mode={state_manager.is_plan_mode()}"
-        )
+        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
@@ -164,133 +230,71 @@ 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()
 
-        # Add plan mode context if in plan mode
-        if state_manager.is_plan_mode():
-            # REMOVE all TUNACODE_TASK_COMPLETE instructions from the system prompt
-            system_prompt = system_prompt.replace(
-                "TUNACODE_TASK_COMPLETE", "PLAN_MODE_TASK_PLACEHOLDER"
-            )
-            # Remove the completion guidance that conflicts with plan mode
-            lines_to_remove = [
-                "When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE",
-                "4. When a task is COMPLETE, start your response with: TUNACODE_TASK_COMPLETE",
-                "**How to signal completion:**",
-                "TUNACODE_TASK_COMPLETE",
-                "[Your summary of what was accomplished]",
-                "**IMPORTANT**: Always evaluate if you've completed the task. If yes, use TUNACODE_TASK_COMPLETE.",
-                "This prevents wasting iterations and API calls.",
-            ]
-            for line in lines_to_remove:
-                system_prompt = system_prompt.replace(line, "")
-            # COMPLETELY REPLACE system prompt in plan mode - nuclear option
-            system_prompt = """
-🔧 PLAN MODE - TOOL EXECUTION ONLY 🔧
-
-You are a planning assistant that ONLY communicates through tool execution.
-
-CRITICAL: You cannot respond with text. You MUST use tools for everything.
-
-AVAILABLE TOOLS:
-- read_file(filepath): Read file contents
-- grep(pattern): Search for text patterns
-- list_dir(directory): List directory contents
-- glob(pattern): Find files matching patterns
-- present_plan(title, overview, steps, files_to_create, success_criteria): Present structured plan
-
-MANDATORY WORKFLOW:
-1. User asks you to plan something
-2. You research using read-only tools (if needed)
-3. You EXECUTE present_plan tool with structured data
-4. DONE
-
-FORBIDDEN:
-- Text responses
-- Showing function calls as code
-- Saying "here is the plan"
-- Any text completion
-
-EXAMPLE:
-User: "plan a markdown file"
-You: [Call read_file or grep for research if needed]
-     [Call present_plan tool with actual parameters - NOT as text]
-
-The present_plan tool takes these parameters:
-- title: Brief title string
-- overview: What the plan accomplishes
-- steps: List of implementation steps
-- files_to_create: List of files to create
-- success_criteria: List of success criteria
-
-YOU MUST EXECUTE present_plan TOOL TO COMPLETE ANY PLANNING TASK.
-"""
-
-        # Initialize tools that need state manager
-        todo_tool = TodoTool(state_manager=state_manager)
-        present_plan = create_present_plan_tool(state_manager)
-        logger.debug(f"Tools initialized, present_plan available: {present_plan is not None}")
-
-        # 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}")
-
-        # Create tool list based on mode
-        if state_manager.is_plan_mode():
-            # Plan mode: Only read-only tools + present_plan
-            tools_list = [
-                Tool(present_plan, 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),
-            ]
-        else:
-            # Normal mode: All tools
-            tools_list = [
-                Tool(bash, max_retries=max_retries),
-                Tool(present_plan, 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),
-            ]
-
-        # Log which tools are being registered
-        logger.debug(
-            f"Creating agent: plan_mode={state_manager.is_plan_mode()}, tools={len(tools_list)}"
+        # 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
         )
-        if state_manager.is_plan_mode():
-            logger.debug(f"PLAN MODE TOOLS: {[str(tool) for tool in tools_list]}")
-            logger.debug(f"present_plan tool type: {type(present_plan)}")
 
-        if "PLAN MODE - YOU MUST USE THE present_plan TOOL" in system_prompt:
-            logger.debug("✅ Plan mode instructions ARE in system prompt")
-        else:
-            logger.debug("❌ Plan mode instructions NOT in system prompt")
+        # 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),
+        ]
+
+        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 model instance with retry-enabled HTTP client
+        model_instance = _create_model_with_retry(model, http_client, state_manager)
 
         agent = Agent(
-            model=model,
+            model=model_instance,
             system_prompt=system_prompt,
             tools=tools_list,
-            mcp_servers=get_mcp_servers(state_manager),
+            mcp_servers=mcp_servers,
         )
 
+        # 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(
             (
-                state_manager.is_plan_mode(),
                 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", {})),
             )
         )

tunacode/core/agents/agent_components/agent_helpers.py

@@ -97,7 +97,8 @@ def create_empty_response_message(
     """Create a constructive message for handling empty responses."""
     tools_context = get_recent_tools_context(tool_calls)
 
-    content = f"""Response appears {empty_reason if empty_reason != "empty" else "empty"} or incomplete. Let's troubleshoot and try again.
+    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}
@@ -106,7 +107,7 @@ Attempt: {iteration}
 Please take one of these specific actions:
 
 1. **Search yielded no results?** → Try alternative search terms or broader patterns
-2. **Found what you need?** → Use TUNACODE_TASK_COMPLETE to finalize
+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
 
@@ -201,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, ""]