tunacode-cli 0.0.9__py3-none-any.whl → 0.0.11__py3-none-any.whl

tunacode/core/agents/main.py

@@ -2,28 +2,49 @@
 
 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 tunacode.core.state import StateManager
-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
+from pydantic_ai import Agent, Tool
+from pydantic_ai.messages import ModelRequest, ToolReturnPart
 
-
-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)
+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]
 
 
 def patch_tool_messages(
@@ -31,10 +52,57 @@ def patch_tool_messages(
     state_manager: StateManager = None,
 ):
     """
-    Wrapper for backward compatibility.
-    TinyAgent handles tool errors internally, so this is mostly a no-op.
+    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.
     """
-    tinyagent_patch_tool_messages(error_message, state_manager)
+    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",
+                )
+            )
 
 
 async def process_request(
@@ -43,35 +111,9 @@ async def process_request(
     state_manager: StateManager,
     tool_callback: Optional[ToolCallback] = None,
 ) -> AgentRun:
-    """
-    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)
+    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

tunacode/core/setup/agent_setup.py

@@ -1,4 +1,4 @@
-"""Module: sidekick.core.setup.agent_setup
+"""Module: tinyagent.core.setup.agent_setup
 
 Agent initialization and configuration for the Sidekick CLI.
 Handles the setup and validation of AI agents with the selected model.

tunacode/core/setup/config_setup.py

@@ -1,4 +1,4 @@
-"""Module: sidekick.core.setup.config_setup
+"""Module: tinyagent.core.setup.config_setup
 
 Configuration system initialization for the Sidekick CLI.
 Handles user configuration loading, validation, and first-time setup onboarding.
@@ -27,6 +27,7 @@ class ConfigSetup(BaseSetup):
         self.config_dir: ConfigPath = Path.home() / ".config"
         self.config_file: ConfigFile = self.config_dir / CONFIG_FILE_NAME
         self.model_registry = ModelRegistry()
+        self.cli_config = None  # Will be set if CLI args are provided
 
     @property
     def name(self) -> str:
@@ -41,18 +42,37 @@ class ConfigSetup(BaseSetup):
         self.state_manager.session.device_id = system.get_device_id()
         loaded_config = user_configuration.load_config()
 
+        # Handle CLI configuration if provided
+        if self.cli_config and any(self.cli_config.values()):
+            await self._handle_cli_config(loaded_config)
+            return
+
         if loaded_config and not force_setup:
             # Silent loading
             # Merge loaded config with defaults to ensure all required keys exist
-            self.state_manager.session.user_config = self._merge_with_defaults(loaded_config)
+            self.state_manager.session.user_config = self._merge_with_defaults(
+                loaded_config
+            )
         else:
             if force_setup:
                 await ui.muted("Running setup process, resetting config")
+                self.state_manager.session.user_config = DEFAULT_USER_CONFIG.copy()
+                user_configuration.save_config(
+                    self.state_manager
+                )  # Save the default config initially
+                await self._onboarding()
             else:
-                await ui.muted("No user configuration found, running setup")
-            self.state_manager.session.user_config = DEFAULT_USER_CONFIG.copy()
-            user_configuration.save_config(self.state_manager)  # Save the default config initially
-            await self._onboarding()
+                # No config found - show CLI usage instead of onboarding
+                from tunacode.ui.console import console
+                console.print("\n[bold red]No configuration found![/bold red]")
+                console.print("\n[bold]Quick Setup:[/bold]")
+                console.print("Configure TunaCode using CLI flags:")
+                console.print("\n[blue]Examples:[/blue]")
+                console.print("  [green]tunacode --model 'openai:gpt-4' --key 'your-key'[/green]")
+                console.print("  [green]tunacode --model 'anthropic:claude-3-opus' --key 'your-key'[/green]")
+                console.print("  [green]tunacode --model 'openrouter:anthropic/claude-3.5-sonnet' --key 'your-key' --baseurl 'https://openrouter.ai/api/v1'[/green]")
+                console.print("\n[yellow]Run 'tunacode --help' for more options[/yellow]\n")
+                raise SystemExit(0)
 
         if not self.state_manager.session.user_config.get("default_model"):
             raise ConfigurationError(
@@ -62,21 +82,11 @@ class ConfigSetup(BaseSetup):
                 )
             )
 
-        # Check if the configured model still exists
-        default_model = self.state_manager.session.user_config["default_model"]
-        if not self.model_registry.get_model(default_model):
-            # If model not found, run the onboarding again
-            await ui.panel(
-                "Model Not Found",
-                f"The configured model '[bold]{default_model}[/bold]' is no longer available.\n"
-                "Let's reconfigure your setup.",
-                border_style=UI_COLORS["warning"],
-            )
-            await self._onboarding()
+        # No model validation - trust user's model choice
 
-        self.state_manager.session.current_model = self.state_manager.session.user_config[
-            "default_model"
-        ]
+        self.state_manager.session.current_model = (
+            self.state_manager.session.user_config["default_model"]
+        )
 
     async def validate(self) -> bool:
         """Validate that configuration is properly set up."""
@@ -88,10 +98,7 @@ class ConfigSetup(BaseSetup):
         if not self.state_manager.session.user_config.get("default_model"):
             return False
 
-        # Check that the default model is valid
-        default_model = self.state_manager.session.user_config["default_model"]
-        if not self.model_registry.get_model(default_model):
-            return False
+        # No model validation - trust user input
 
         return True
 
@@ -112,76 +119,149 @@ class ConfigSetup(BaseSetup):
 
     async def _onboarding(self):
         """Run the onboarding process for new users."""
-        initial_config = json.dumps(self.state_manager.session.user_config, sort_keys=True)
-
-        # Welcome message
-        message = (
-            f"Welcome to {APP_NAME}!\n\n"
-            "Let's configure your AI provider. TunaCode supports:\n"
-            "• OpenAI (api.openai.com)\n"
-            "• OpenRouter (openrouter.ai) - Access 100+ models\n"
-            "• Any OpenAI-compatible API\n"
+        initial_config = json.dumps(
+            self.state_manager.session.user_config, sort_keys=True
         )
-        await ui.panel("Setup", message, border_style=UI_COLORS["primary"])
 
-        # Step 1: Ask for base URL
-        base_url = await ui.input(
-            "step1",
-            pretext="  API Base URL (press Enter for OpenAI): ",
-            default="https://api.openai.com/v1",
-            state_manager=self.state_manager,
-        )
-        base_url = base_url.strip()
-        if not base_url:
-            base_url = "https://api.openai.com/v1"
-
-        # Step 2: Ask for API key
-        if "openrouter.ai" in base_url.lower():
-            key_prompt = "  OpenRouter API Key: "
-            key_name = "OPENROUTER_API_KEY"
-            default_model = "openrouter:openai/gpt-4o-mini"
-        else:
-            key_prompt = "  API Key: "
-            key_name = "OPENAI_API_KEY"
-            default_model = "openai:gpt-4o"
+        await self._step1_api_keys()
 
-        api_key = await ui.input(
-            "step2",
-            pretext=key_prompt,
-            is_password=True,
-            state_manager=self.state_manager,
-        )
-        api_key = api_key.strip()
+        # Only continue if at least one API key was provided
+        env = self.state_manager.session.user_config.get("env", {})
+        has_api_key = any(key.endswith("_API_KEY") and env.get(key) for key in env)
 
-        if api_key:
-            # Set the environment variable
-            self.state_manager.session.user_config["env"][key_name] = api_key
-            
-            # Set base URL in environment for OpenRouter
-            if "openrouter.ai" in base_url.lower():
-                import os
-                os.environ["OPENAI_BASE_URL"] = base_url
-            
-            # Set default model
-            self.state_manager.session.user_config["default_model"] = default_model
+        if has_api_key:
+            if not self.state_manager.session.user_config.get("default_model"):
+                await self._step2_default_model()
 
-            # Save configuration
-            current_config = json.dumps(self.state_manager.session.user_config, sort_keys=True)
+            # Compare configs to see if anything changed
+            current_config = json.dumps(
+                self.state_manager.session.user_config, sort_keys=True
+            )
             if initial_config != current_config:
                 if user_configuration.save_config(self.state_manager):
-                    message = (
-                        f"✅ Configuration saved!\n\n"
-                        f"Default model: {default_model}\n"
-                        f"Config file: {self.config_file}\n\n"
-                        f"You can change models anytime with /model"
+                    message = f"Config saved to: [bold]{self.config_file}[/bold]"
+                    await ui.panel(
+                        "Finished", message, top=0, border_style=UI_COLORS["success"]
                     )
-                    await ui.panel("Setup Complete", message, top=0, border_style=UI_COLORS["success"])
                 else:
                     await ui.error("Failed to save configuration.")
         else:
             await ui.panel(
                 "Setup canceled",
-                "An API key is required to use TunaCode.",
+                "At least one API key is required.",
                 border_style=UI_COLORS["warning"],
             )
 
+    async def _step1_api_keys(self):
+        """Onboarding step 1: Collect API keys."""
+        message = (
+            f"Welcome to {APP_NAME}!\n"
+            "Let's get you setup. First, we'll need to set some environment variables.\n"
+            "Skip the ones you don't need."
+        )
+        await ui.panel("Setup", message, border_style=UI_COLORS["primary"])
+        env_keys = self.state_manager.session.user_config["env"].copy()
+        for key in env_keys:
+            provider = key_to_title(key)
+            val = await ui.input(
+                "step1",
+                pretext=f"  {provider}: ",
+                is_password=True,
+                state_manager=self.state_manager,
+            )
+            val = val.strip()
+            if val:
+                self.state_manager.session.user_config["env"][key] = val
+
+    async def _step2_default_model(self):
+        """Onboarding step 2: Select default model."""
+        message = "Which model would you like to use by default?\n\n"
+
+        model_ids = self.model_registry.list_model_ids()
+        for index, model_id in enumerate(model_ids):
+            message += f"  {index} - {model_id}\n"
+        message = message.strip()
+
+        await ui.panel("Default Model", message, border_style=UI_COLORS["primary"])
+        choice = await ui.input(
+            "step2",
+            pretext="  Default model (#): ",
+            validator=ui.ModelValidator(len(model_ids)),
+            state_manager=self.state_manager,
+        )
+        self.state_manager.session.user_config["default_model"] = model_ids[int(choice)]
+
+    async def _step2_default_model_simple(self):
+        """Simple model selection - just enter model name."""
+        await ui.muted("Format: provider:model-name")
+        await ui.muted("Examples: openai:gpt-4.1, anthropic:claude-3-opus, google-gla:gemini-2.0-flash")
+        
+        while True:
+            model_name = await ui.input(
+                "step2",
+                pretext="  Model (provider:name): ",
+                state_manager=self.state_manager,
+            )
+            model_name = model_name.strip()
+            
+            # Check if provider prefix is present
+            if ":" not in model_name:
+                await ui.error("Model name must include provider prefix")
+                await ui.muted("Format: provider:model-name")
+                await ui.muted("You can always change it later with /model")
+                continue
+            
+            # No validation - user is responsible for correct model names
+            self.state_manager.session.user_config["default_model"] = model_name
+            await ui.warning("Model set without validation - verify the model name is correct")
+            await ui.success(f"Selected model: {model_name}")
+            break
+
+    async def _handle_cli_config(self, loaded_config: UserConfig) -> None:
+        """Handle configuration provided via CLI arguments."""
+        # Start with existing config or defaults
+        if loaded_config:
+            self.state_manager.session.user_config = self._merge_with_defaults(loaded_config)
+        else:
+            self.state_manager.session.user_config = DEFAULT_USER_CONFIG.copy()
+        
+        # Apply CLI overrides
+        if self.cli_config.get("key"):
+            # Determine which API key to set based on the model or baseurl
+            if self.cli_config.get("baseurl") and "openrouter" in self.cli_config["baseurl"]:
+                self.state_manager.session.user_config["env"]["OPENROUTER_API_KEY"] = self.cli_config["key"]
+            elif self.cli_config.get("model"):
+                if "claude" in self.cli_config["model"] or "anthropic" in self.cli_config["model"]:
+                    self.state_manager.session.user_config["env"]["ANTHROPIC_API_KEY"] = self.cli_config["key"]
+                elif "gpt" in self.cli_config["model"] or "openai" in self.cli_config["model"]:
+                    self.state_manager.session.user_config["env"]["OPENAI_API_KEY"] = self.cli_config["key"]
+                elif "gemini" in self.cli_config["model"]:
+                    self.state_manager.session.user_config["env"]["GEMINI_API_KEY"] = self.cli_config["key"]
+                else:
+                    # Default to OpenRouter for unknown models
+                    self.state_manager.session.user_config["env"]["OPENROUTER_API_KEY"] = self.cli_config["key"]
+        
+        if self.cli_config.get("baseurl"):
+            self.state_manager.session.user_config["env"]["OPENAI_BASE_URL"] = self.cli_config["baseurl"]
+        
+        if self.cli_config.get("model"):
+            model = self.cli_config["model"]
+            # Require provider prefix
+            if ":" not in model:
+                raise ConfigurationError(
+                    f"Model '{model}' must include provider prefix\n"
+                    "Format: provider:model-name\n"
+                    "Examples: openai:gpt-4.1, anthropic:claude-3-opus"
+                )
+            
+            self.state_manager.session.user_config["default_model"] = model
+        
+        # Set current model
+        self.state_manager.session.current_model = self.state_manager.session.user_config["default_model"]
+        
+        # Save the configuration
+        if user_configuration.save_config(self.state_manager):
+            await ui.warning("Model set without validation - verify the model name is correct")
+            await ui.success(f"Configuration saved to: {self.config_file}")
+        else:
+            await ui.error("Failed to save configuration.")

tunacode/core/setup/coordinator.py

@@ -1,4 +1,4 @@
-"""Module: sidekick.core.setup.coordinator
+"""Module: tinyagent.core.setup.coordinator
 
 Setup orchestration and coordination for the Sidekick CLI.
 Manages the execution order and validation of all registered setup steps.
@@ -32,7 +32,9 @@ class SetupCoordinator:
 
                     if not await step.validate():
                         await ui.error(f"Setup validation failed: {step.name}")
-                        raise RuntimeError(f"Setup step '{step.name}' failed validation")
+                        raise RuntimeError(
+                            f"Setup step '{step.name}' failed validation"
+                        )
                 else:
                     # Skip silently
                     pass

tunacode/core/setup/environment_setup.py

@@ -1,4 +1,4 @@
-"""Module: sidekick.core.setup.environment_setup
+"""Module: tunacode.core.setup.environment_setup
 
 Environment detection and configuration for the Sidekick CLI.
 Handles setting up environment variables from user configuration.