tunacode-cli 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

tunacode/core/agents/main.py

@@ -2,49 +2,28 @@
 
 Main agent functionality and coordination for the Sidekick CLI.
 Provides agent creation, message processing, and tool call management.
+Now using tinyAgent instead of pydantic-ai.
 """
 
-from datetime import datetime, timezone
 from typing import Optional
 
-from pydantic_ai import Agent, Tool
-from pydantic_ai.messages import ModelRequest, ToolReturnPart
-
 from tunacode.core.state import StateManager
-from tunacode.services.mcp import get_mcp_servers
-from tunacode.tools.read_file import read_file
-from tunacode.tools.run_command import run_command
-from tunacode.tools.update_file import update_file
-from tunacode.tools.write_file import write_file
-from tunacode.types import (AgentRun, ErrorMessage, ModelName, PydanticAgent, ToolCallback,
-                            ToolCallId, ToolName)
-
-
-async def _process_node(node, tool_callback: Optional[ToolCallback], state_manager: StateManager):
-    if hasattr(node, "request"):
-        state_manager.session.messages.append(node.request)
-
-    if hasattr(node, "model_response"):
-        state_manager.session.messages.append(node.model_response)
-        for part in node.model_response.parts:
-            if part.part_kind == "tool-call" and tool_callback:
-                await tool_callback(part, node)
-
-
-def get_or_create_agent(model: ModelName, state_manager: StateManager) -> PydanticAgent:
-    if model not in state_manager.session.agents:
-        max_retries = state_manager.session.user_config["settings"]["max_retries"]
-        state_manager.session.agents[model] = Agent(
-            model=model,
-            tools=[
-                Tool(read_file, max_retries=max_retries),
-                Tool(run_command, 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),
-        )
-    return state_manager.session.agents[model]
+from tunacode.types import AgentRun, ErrorMessage, ModelName, ToolCallback
+
+# Import tinyAgent implementation
+from .tinyagent_main import get_or_create_react_agent
+from .tinyagent_main import patch_tool_messages as tinyagent_patch_tool_messages
+from .tinyagent_main import process_request_with_tinyagent
+
+# Wrapper functions for backward compatibility with pydantic-ai interface
+
+
+def get_or_create_agent(model: ModelName, state_manager: StateManager):
+    """
+    Wrapper for backward compatibility.
+    Returns the ReactAgent instance from tinyAgent.
+    """
+    return get_or_create_react_agent(model, state_manager)
 
 
 def patch_tool_messages(
@@ -52,57 +31,10 @@ def patch_tool_messages(
     state_manager: StateManager = None,
 ):
     """
-    Find any tool calls without responses and add synthetic error responses for them.
-    Takes an error message to use in the synthesized tool response.
-
-    Ignores tools that have corresponding retry prompts as the model is already
-    addressing them.
+    Wrapper for backward compatibility.
+    TinyAgent handles tool errors internally, so this is mostly a no-op.
     """
-    if state_manager is None:
-        raise ValueError("state_manager is required for patch_tool_messages")
-
-    messages = state_manager.session.messages
-
-    if not messages:
-        return
-
-    # Map tool calls to their tool returns
-    tool_calls: dict[ToolCallId, ToolName] = {}  # tool_call_id -> tool_name
-    tool_returns: set[ToolCallId] = set()  # set of tool_call_ids with returns
-    retry_prompts: set[ToolCallId] = set()  # set of tool_call_ids with retry prompts
-
-    for message in messages:
-        if hasattr(message, "parts"):
-            for part in message.parts:
-                if (
-                    hasattr(part, "part_kind")
-                    and hasattr(part, "tool_call_id")
-                    and part.tool_call_id
-                ):
-                    if part.part_kind == "tool-call":
-                        tool_calls[part.tool_call_id] = part.tool_name
-                    elif part.part_kind == "tool-return":
-                        tool_returns.add(part.tool_call_id)
-                    elif part.part_kind == "retry-prompt":
-                        retry_prompts.add(part.tool_call_id)
-
-    # Identify orphaned tools (those without responses and not being retried)
-    for tool_call_id, tool_name in list(tool_calls.items()):
-        if tool_call_id not in tool_returns and tool_call_id not in retry_prompts:
-            messages.append(
-                ModelRequest(
-                    parts=[
-                        ToolReturnPart(
-                            tool_name=tool_name,
-                            content=error_message,
-                            tool_call_id=tool_call_id,
-                            timestamp=datetime.now(timezone.utc),
-                            part_kind="tool-return",
-                        )
-                    ],
-                    kind="request",
-                )
-            )
+    tinyagent_patch_tool_messages(error_message, state_manager)
 
 
 async def process_request(
@@ -111,9 +43,35 @@ async def process_request(
     state_manager: StateManager,
     tool_callback: Optional[ToolCallback] = None,
 ) -> AgentRun:
-    agent = get_or_create_agent(model, state_manager)
-    mh = state_manager.session.messages.copy()
-    async with agent.iter(message, message_history=mh) as agent_run:
-        async for node in agent_run:
-            await _process_node(node, tool_callback, state_manager)
-        return agent_run
+    """
+    Process a request using tinyAgent.
+    Returns a result that mimics the pydantic-ai AgentRun structure.
+    """
+    result = await process_request_with_tinyagent(model, message, state_manager, tool_callback)
+
+    # Create a mock AgentRun object for compatibility
+    class MockAgentRun:
+        def __init__(self, result_dict):
+            self._result = result_dict
+
+        @property
+        def result(self):
+            class MockResult:
+                def __init__(self, content):
+                    self._content = content
+
+                @property
+                def output(self):
+                    return self._content
+
+            return MockResult(self._result.get("result", ""))
+
+        @property
+        def messages(self):
+            return state_manager.session.messages
+
+        @property
+        def model(self):
+            return self._result.get("model", model)
+
+    return MockAgentRun(result)

tunacode/core/agents/tinyagent_main.py

@@ -0,0 +1,173 @@
+"""TinyAgent-based agent implementation."""
+
+from contextlib import asynccontextmanager
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from tinyagent import ReactAgent
+
+from tunacode.core.state import StateManager
+from tunacode.tools.tinyagent_tools import read_file, run_command, update_file, write_file
+from tunacode.types import ModelName, ToolCallback
+
+
+def get_or_create_react_agent(model: ModelName, state_manager: StateManager) -> ReactAgent:
+    """
+    Get or create a ReactAgent for the specified model.
+
+    Args:
+        model: The model name (e.g., "openai:gpt-4o", "openrouter:openai/gpt-4.1")
+        state_manager: The state manager instance
+
+    Returns:
+        ReactAgent instance configured for the model
+    """
+    agents = state_manager.session.agents
+
+    if model not in agents:
+        # Parse model string to determine provider and actual model name
+        # Format: "provider:model" or "openrouter:provider/model"
+        if model.startswith("openrouter:"):
+            # OpenRouter model - extract the actual model name
+            actual_model = model.replace("openrouter:", "")
+            # Set environment to use OpenRouter base URL
+            import os
+
+            os.environ["OPENAI_BASE_URL"] = "https://openrouter.ai/api/v1"
+            # Use OpenRouter API key if available
+            if state_manager.session.user_config["env"].get("OPENROUTER_API_KEY"):
+                os.environ["OPENAI_API_KEY"] = state_manager.session.user_config["env"][
+                    "OPENROUTER_API_KEY"
+                ]
+        else:
+            # Direct provider (openai, anthropic, google-gla)
+            provider, actual_model = model.split(":", 1)
+            # Reset to default base URL for direct providers
+            import os
+
+            if provider == "openai":
+                os.environ["OPENAI_BASE_URL"] = "https://api.openai.com/v1"
+            # Set appropriate API key
+            provider_key_map = {
+                "openai": "OPENAI_API_KEY",
+                "anthropic": "ANTHROPIC_API_KEY",
+                "google-gla": "GEMINI_API_KEY",
+            }
+            if provider in provider_key_map:
+                key_name = provider_key_map[provider]
+                if state_manager.session.user_config["env"].get(key_name):
+                    os.environ[key_name] = state_manager.session.user_config["env"][key_name]
+
+        # Create new ReactAgent with tools
+        # Note: tinyAgent gets model from environment variables, not constructor
+        agent = ReactAgent(tools=[read_file, write_file, update_file, run_command])
+
+        # Add MCP compatibility method
+        @asynccontextmanager
+        async def run_mcp_servers():
+            # TinyAgent doesn't have built-in MCP support yet
+            # This is a placeholder for compatibility
+            yield
+
+        agent.run_mcp_servers = run_mcp_servers
+
+        # Cache the agent
+        agents[model] = agent
+
+    return agents[model]
+
+
+async def process_request_with_tinyagent(
+    model: ModelName,
+    message: str,
+    state_manager: StateManager,
+    tool_callback: Optional[ToolCallback] = None,
+) -> Dict[str, Any]:
+    """
+    Process a request using TinyAgent's ReactAgent.
+
+    Args:
+        model: The model to use
+        message: The user message
+        state_manager: State manager instance
+        tool_callback: Optional callback for tool execution (for UI updates)
+
+    Returns:
+        Dict containing the result and any metadata
+    """
+    agent = get_or_create_react_agent(model, state_manager)
+
+    # Convert message history to format expected by tinyAgent
+    # Note: tinyAgent handles message history differently than pydantic-ai
+    # We'll need to adapt based on tinyAgent's actual API
+
+    try:
+        # Run the agent with the message
+        # The new API's run() method might be synchronous based on the examples
+        import asyncio
+        if asyncio.iscoroutinefunction(agent.run):
+            result = await agent.run(message)
+        else:
+            result = agent.run(message)
+
+        # Update message history in state_manager
+        # This will need to be adapted based on how tinyAgent returns messages
+        state_manager.session.messages.append(
+            {
+                "role": "user",
+                "content": message,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
+
+        state_manager.session.messages.append(
+            {
+                "role": "assistant",
+                "content": result,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
+
+        return {"result": result, "success": True, "model": model}
+
+    except Exception as e:
+        # Handle errors
+        error_result = {
+            "result": f"Error: {str(e)}",
+            "success": False,
+            "model": model,
+            "error": str(e),
+        }
+
+        # Still update message history with the error
+        state_manager.session.messages.append(
+            {
+                "role": "user",
+                "content": message,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+        )
+
+        state_manager.session.messages.append(
+            {
+                "role": "assistant",
+                "content": f"Error occurred: {str(e)}",
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "error": True,
+            }
+        )
+
+        return error_result
+
+
+def patch_tool_messages(
+    error_message: str = "Tool operation failed",
+    state_manager: StateManager = None,
+):
+    """
+    Compatibility function for patching tool messages.
+    With tinyAgent, this may not be needed as it handles tool errors differently.
+    """
+    # TinyAgent handles tool retries and errors internally
+    # This function is kept for compatibility but may be simplified
+    pass

tunacode/core/setup/git_safety_setup.py

@@ -13,15 +13,12 @@ from tunacode.ui.panels import panel
 async def yes_no_prompt(question: str, default: bool = True) -> bool:
     """Simple yes/no prompt."""
     default_text = "[Y/n]" if default else "[y/N]"
-    response = await prompt_input(
-        session_key="yes_no",
-        pretext=f"{question} {default_text}: "
-    )
-    
+    response = await prompt_input(session_key="yes_no", pretext=f"{question} {default_text}: ")
+
     if not response.strip():
         return default
-    
-    return response.lower().strip() in ['y', 'yes']
+
+    return response.lower().strip() in ["y", "yes"]
 
 
 class GitSafetySetup(BaseSetup):
@@ -29,7 +26,7 @@ class GitSafetySetup(BaseSetup):
 
     def __init__(self, state_manager: StateManager):
         super().__init__(state_manager)
-    
+
     @property
     def name(self) -> str:
         """Return the name of this setup step."""
@@ -45,18 +42,15 @@ class GitSafetySetup(BaseSetup):
         try:
             # Check if git is installed
             result = subprocess.run(
-                ["git", "--version"],
-                capture_output=True,
-                text=True,
-                check=False
+                ["git", "--version"], capture_output=True, text=True, check=False
             )
-            
+
             if result.returncode != 0:
                 await panel(
                     "⚠️  Git Not Found",
                     "Git is not installed or not in PATH. TunaCode will modify files directly.\n"
                     "It's strongly recommended to install Git for safety.",
-                    border_style="yellow"
+                    border_style="yellow",
                 )
                 return
 
@@ -66,33 +60,31 @@ class GitSafetySetup(BaseSetup):
                 capture_output=True,
                 text=True,
                 check=False,
-                cwd=Path.cwd()
+                cwd=Path.cwd(),
             )
-            
+
             if result.returncode != 0:
                 await panel(
                     "⚠️  Not a Git Repository",
                     "This directory is not a Git repository. TunaCode will modify files directly.\n"
                     "Consider initializing a Git repository for safety: git init",
-                    border_style="yellow"
+                    border_style="yellow",
                 )
                 return
 
             # Get current branch name
             result = subprocess.run(
-                ["git", "branch", "--show-current"],
-                capture_output=True,
-                text=True,
-                check=True
+                ["git", "branch", "--show-current"], capture_output=True, text=True, check=True
             )
             current_branch = result.stdout.strip()
-            
+
             if not current_branch:
                 # Detached HEAD state
                 await panel(
                     "⚠️  Detached HEAD State",
-                    "You're in a detached HEAD state. TunaCode will continue without creating a branch.",
-                    border_style="yellow"
+                    "You're in a detached HEAD state. TunaCode will continue "
+                    "without creating a branch.",
+                    border_style="yellow",
                 )
                 return
 
@@ -103,31 +95,28 @@ class GitSafetySetup(BaseSetup):
 
             # Propose new branch name
             new_branch = f"{current_branch}-tunacode"
-            
+
             # Check if there are uncommitted changes
             result = subprocess.run(
-                ["git", "status", "--porcelain"],
-                capture_output=True,
-                text=True,
-                check=True
+                ["git", "status", "--porcelain"], capture_output=True, text=True, check=True
             )
-            
+
             has_changes = bool(result.stdout.strip())
-            
+
             # Ask user if they want to create a safety branch
             message = (
-                f"For safety, TunaCode can create a new branch '{new_branch}' based on '{current_branch}'.\n"
+                f"For safety, TunaCode can create a new branch '{new_branch}' "
+                f"based on '{current_branch}'.\n"
                 f"This helps protect your work from unintended changes.\n"
             )
-            
+
             if has_changes:
-                message += "\n⚠️  You have uncommitted changes that will be brought to the new branch."
-            
-            create_branch = await yes_no_prompt(
-                f"{message}\n\nCreate safety branch?",
-                default=True
-            )
-            
+                message += (
+                    "\n⚠️  You have uncommitted changes that will be brought to the new branch."
+                )
+
+            create_branch = await yes_no_prompt(f"{message}\n\nCreate safety branch?", default=True)
+
             if not create_branch:
                 # User declined - show warning
                 await panel(
@@ -135,26 +124,25 @@ class GitSafetySetup(BaseSetup):
                     "You've chosen to work directly on your current branch.\n"
                     "TunaCode will modify files in place. Make sure you have backups!\n"
                     "You can always use /undo to revert changes.",
-                    border_style="red"
+                    border_style="red",
                 )
                 # Save preference
                 self.state_manager.session.user_config["skip_git_safety"] = True
                 return
-            
+
             # Create and checkout the new branch
             try:
                 # Check if branch already exists
                 result = subprocess.run(
                     ["git", "show-ref", "--verify", f"refs/heads/{new_branch}"],
                     capture_output=True,
-                    check=False
+                    check=False,
                 )
-                
+
                 if result.returncode == 0:
                     # Branch exists, ask to use it
                     use_existing = await yes_no_prompt(
-                        f"Branch '{new_branch}' already exists. Switch to it?",
-                        default=True
+                        f"Branch '{new_branch}' already exists. Switch to it?", default=True
                     )
                     if use_existing:
                         subprocess.run(["git", "checkout", new_branch], check=True)
@@ -165,24 +153,24 @@ class GitSafetySetup(BaseSetup):
                     # Create new branch
                     subprocess.run(["git", "checkout", "-b", new_branch], check=True)
                     await ui.success(f"Created and switched to new branch: {new_branch}")
-                    
+
             except subprocess.CalledProcessError as e:
                 await panel(
                     "❌ Failed to Create Branch",
                     f"Could not create branch '{new_branch}': {str(e)}\n"
                     "Continuing on current branch.",
-                    border_style="red"
+                    border_style="red",
                 )
-                
+
         except Exception as e:
             # Non-fatal error - just warn the user
             await panel(
                 "⚠️  Git Safety Setup Failed",
                 f"Could not set up Git safety: {str(e)}\n"
                 "TunaCode will continue without branch protection.",
-                border_style="yellow"
+                border_style="yellow",
             )
 
     async def validate(self) -> bool:
         """Validate git safety setup - always returns True as this is optional."""
-        return True
+        return True

tunacode/core/setup/optimized_coordinator.py

@@ -0,0 +1,73 @@
+"""Optimized setup coordinator with deferred loading."""
+
+import asyncio
+from typing import List, Set
+
+from tunacode.core.setup.base import BaseSetup
+from tunacode.core.state import StateManager
+from tunacode.ui import console as ui
+
+
+class OptimizedSetupCoordinator:
+    """Optimized coordinator that defers non-critical setup steps."""
+
+    def __init__(self, state_manager: StateManager):
+        self.state_manager = state_manager
+        self.critical_steps: List[BaseSetup] = []
+        self.deferred_steps: List[BaseSetup] = []
+        self._deferred_task = None
+
+        # Define critical steps that must run at startup
+        self.critical_step_names: Set[str] = {
+            "Configuration",  # Need config to know which model to use
+            "Environment Variables",  # Need API keys
+        }
+
+    def register_step(self, step: BaseSetup) -> None:
+        """Register a setup step, separating critical from deferred."""
+        if step.name in self.critical_step_names:
+            self.critical_steps.append(step)
+        else:
+            self.deferred_steps.append(step)
+
+    async def run_setup(self, force_setup: bool = False) -> None:
+        """Run critical setup immediately, defer the rest."""
+        # Run critical steps synchronously
+        for step in self.critical_steps:
+            try:
+                if await step.should_run(force_setup):
+                    await step.execute(force_setup)
+                    if not await step.validate():
+                        await ui.error(f"Setup validation failed: {step.name}")
+                        raise RuntimeError(f"Setup step '{step.name}' failed validation")
+            except Exception as e:
+                await ui.error(f"Setup failed at step '{step.name}': {str(e)}")
+                raise
+
+        # Schedule deferred steps to run in background
+        if self.deferred_steps and not self._deferred_task:
+            self._deferred_task = asyncio.create_task(self._run_deferred_steps(force_setup))
+
+    async def _run_deferred_steps(self, force_setup: bool) -> None:
+        """Run deferred steps in the background."""
+        # Wait a moment to let the main UI start
+        await asyncio.sleep(0.1)
+
+        for step in self.deferred_steps:
+            try:
+                if await step.should_run(force_setup):
+                    await step.execute(force_setup)
+                    # Don't validate deferred steps - they're non-critical
+            except Exception:
+                # Log but don't fail on deferred steps
+                pass
+
+    async def ensure_deferred_complete(self) -> None:
+        """Ensure deferred steps are complete before certain operations."""
+        if self._deferred_task and not self._deferred_task.done():
+            await self._deferred_task
+
+    def clear_steps(self) -> None:
+        """Clear all registered setup steps."""
+        self.critical_steps.clear()
+        self.deferred_steps.clear()

tunacode/exceptions.py

@@ -77,8 +77,6 @@ class MCPError(ServiceError):
         super().__init__(f"MCP server '{server_name}' error: {message}")
 
 
-
-
 class GitOperationError(ServiceError):
     """Raised when Git operations fail."""