tunacode-cli 0.0.71__py3-none-any.whl → 0.0.73__py3-none-any.whl

tunacode/cli/commands/implementations/model.py

@@ -1,61 +1,361 @@
 """Model management commands for TunaCode CLI."""
 
-from typing import Optional
+from typing import Dict, List, Optional
 
-from .... import utils
 from ....exceptions import ConfigurationError
 from ....types import CommandArgs, CommandContext
 from ....ui import console as ui
+from ....ui.model_selector import select_model_interactive
+from ....utils import user_configuration
+from ....utils.models_registry import ModelInfo, ModelsRegistry
 from ..base import CommandCategory, CommandSpec, SimpleCommand
 
 
 class ModelCommand(SimpleCommand):
-    """Manage model selection."""
+    """Manage model selection with models.dev integration."""
 
     spec = CommandSpec(
         name="model",
         aliases=["/model"],
-        description="Switch model (e.g., /model gpt-4 or /model openai:gpt-4)",
+        description="Switch model with interactive selection or search",
         category=CommandCategory.MODEL,
     )
 
+    def __init__(self):
+        """Initialize the model command."""
+        super().__init__()
+        self.registry = ModelsRegistry()
+        self._registry_loaded = False
+
+    async def _ensure_registry(self) -> bool:
+        """Ensure the models registry is loaded."""
+        if not self._registry_loaded:
+            self._registry_loaded = await self.registry.load()
+        return self._registry_loaded
+
     async def execute(self, args: CommandArgs, context: CommandContext) -> Optional[str]:
-        # No arguments - show current model
+        # Handle special flags
+        if args and args[0] in ["--list", "-l"]:
+            return await self._list_models()
+
+        if args and args[0] in ["--info", "-i"]:
+            if len(args) < 2:
+                await ui.error("Usage: /model --info <model-id>")
+                return None
+            return await self._show_model_info(args[1])
+
+        # No arguments - show interactive selector
         if not args:
-            current_model = context.state_manager.session.current_model
-            await ui.info(f"Current model: {current_model}")
-            await ui.muted("Usage: /model <provider:model-name> [default]")
-            await ui.muted("Example: /model openai:gpt-4.1")
+            return await self._interactive_select(context)
+
+        # Single argument - could be search query or model ID
+        model_query = args[0]
+
+        # Check for flags
+        if model_query in ["--search", "-s"]:
+            search_query = " ".join(args[1:]) if len(args) > 1 else ""
+            return await self._interactive_select(context, search_query)
+
+        # Direct model specification
+        return await self._set_model(model_query, args[1:], context)
+
+    async def _interactive_select(
+        self, context: CommandContext, initial_query: str = ""
+    ) -> Optional[str]:
+        """Show interactive model selector."""
+        await self._ensure_registry()
+
+        # Show current model
+        current_model = context.state_manager.session.current_model
+        await ui.info(f"Current model: {current_model}")
+
+        # Check if we have models loaded
+        if not self.registry.models:
+            await ui.error("No models available. Try /model --list to see if models can be loaded.")
             return None
 
-        # Get the model name from args
-        model_name = args[0]
+        # For now, use a simple text-based approach instead of complex UI
+        # This avoids prompt_toolkit compatibility issues
+        if initial_query:
+            models = self.registry.search_models(initial_query)
+            if not models:
+                await ui.error(f"No models found matching '{initial_query}'")
+                return None
+        else:
+            # Show popular models for quick selection
+            popular_searches = ["gpt", "claude", "gemini"]
+            await ui.info("Popular model searches:")
+            for search in popular_searches:
+                models = self.registry.search_models(search)[:3]  # Top 3
+                if models:
+                    await ui.info(f"\n{search.upper()} models:")
+                    for model in models:
+                        await ui.muted(f"  • {model.full_id} - {model.name}")
+
+            await ui.info("\nUsage:")
+            await ui.muted("  /model <search-term>  - Search for models")
+            await ui.muted("  /model --list         - Show all models")
+            await ui.muted("  /model --info <id>    - Show model details")
+            await ui.muted("  /model <provider:id>  - Set model directly")
+            return None
 
-        # 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(
-                "Examples: openai:gpt-4.1, anthropic:claude-3-opus, google-gla:gemini-2.0-flash"
-            )
+        # Show search results
+        if len(models) == 1:
+            # Auto-select single result
+            model = models[0]
+            context.state_manager.session.current_model = model.full_id
+            await ui.success(f"Switched to model: {model.full_id} - {model.name}")
+            return None
+
+        # Show multiple results
+        await ui.info(f"Found {len(models)} models:")
+        for i, model in enumerate(models[:10], 1):  # Show top 10
+            details = []
+            if model.cost.input is not None:
+                details.append(f"${model.cost.input}/{model.cost.output}")
+            if model.limits.context:
+                details.append(f"{model.limits.context // 1000}k")
+            detail_str = f" ({', '.join(details)})" if details else ""
+
+            await ui.info(f"{i:2d}. {model.full_id} - {model.name}{detail_str}")
+
+        if len(models) > 10:
+            await ui.muted(f"... and {len(models) - 10} more")
+
+        await ui.muted("Use '/model <provider:model-id>' to select a specific model")
+        return None
+
+    async def _set_model(
+        self, model_name: str, extra_args: CommandArgs, context: CommandContext
+    ) -> Optional[str]:
+        """Set model directly or by search."""
+        # Load registry for validation
+        await self._ensure_registry()
+
+        # Check if it's a direct model ID
+        if ":" in model_name:
+            # Validate against registry if loaded
+            if self._registry_loaded:
+                model_info = self.registry.get_model(model_name)
+                if not model_info:
+                    # Search for similar models
+                    similar = self.registry.search_models(model_name.split(":")[-1])
+                    if similar:
+                        await ui.warning(f"Model '{model_name}' not found in registry")
+                        await ui.muted("Did you mean one of these?")
+                        for model in similar[:5]:
+                            await ui.muted(f"  • {model.full_id} - {model.name}")
+                        return None
+                    else:
+                        await ui.warning("Model not found in registry - setting anyway")
+                else:
+                    # Show model info
+                    await ui.info(f"Selected: {model_info.name}")
+                    if model_info.cost.input is not None:
+                        await ui.muted(f"  Pricing: {model_info.cost.format_cost()}")
+                    if model_info.limits.context:
+                        await ui.muted(f"  Limits: {model_info.limits.format_limits()}")
+
+            # Set the model
+            context.state_manager.session.current_model = model_name
+
+            # Check if setting as default
+            if extra_args and extra_args[0] == "default":
+                try:
+                    user_configuration.set_default_model(model_name, context.state_manager)
+                    await ui.muted("Updating default model")
+                    return "restart"
+                except ConfigurationError as e:
+                    await ui.error(str(e))
+                    return None
+
+            await ui.success(f"Switched to model: {model_name}")
+            return None
+
+        # No colon - treat as search query
+        models = self.registry.search_models(model_name)
+
+        if not models:
+            await ui.error(f"No models found matching '{model_name}'")
+            await ui.muted("Try /model --list to see all available models")
+            return None
+
+        if len(models) == 1:
+            # Single match - use it
+            model = models[0]
+            context.state_manager.session.current_model = model.full_id
+            await ui.success(f"Switched to model: {model.full_id} - {model.name}")
             return None
 
-        # No validation - user is responsible for correct model names
-        await ui.warning("Model set without validation - verify the model name is correct")
+        # Multiple matches - show interactive selector with results
+        await ui.info(f"Found {len(models)} models matching '{model_name}'")
+        selected_model = await select_model_interactive(self.registry, model_name)
 
-        # Set the model
-        context.state_manager.session.current_model = model_name
+        if selected_model:
+            context.state_manager.session.current_model = selected_model
+            await ui.success(f"Switched to model: {selected_model}")
+        else:
+            await ui.info("Model selection cancelled")
 
-        # Check if setting as default
-        if len(args) > 1 and args[1] == "default":
-            try:
-                utils.user_configuration.set_default_model(model_name, context.state_manager)
-                await ui.muted("Updating default model")
-                return "restart"
-            except ConfigurationError as e:
-                await ui.error(str(e))
+        return None
+
+    async def _list_models(self) -> Optional[str]:
+        """List all available models."""
+        await self._ensure_registry()
+
+        if not self.registry.models:
+            await ui.error("No models available")
+            return None
+
+        # Group by provider
+        providers: Dict[str, List[ModelInfo]] = {}
+        for model in self.registry.models.values():
+            if model.provider not in providers:
+                providers[model.provider] = []
+            providers[model.provider].append(model)
+
+        # Display models
+        await ui.info(f"Available models ({len(self.registry.models)} total):")
+
+        for provider_id in sorted(providers.keys()):
+            provider_info = self.registry.providers.get(provider_id)
+            provider_name = provider_info.name if provider_info else provider_id
+
+            await ui.print(f"\n{provider_name}:")
+
+            for model in sorted(providers[provider_id], key=lambda m: m.name):
+                line = f"  • {model.id}"
+                if model.cost.input is not None:
+                    line += f" (${model.cost.input}/{model.cost.output})"
+                if model.limits.context:
+                    line += f" [{model.limits.context // 1000}k]"
+                await ui.muted(line)
+
+        return None
+
+    async def _show_model_info(self, model_id: str) -> Optional[str]:
+        """Show detailed information about a model."""
+        await self._ensure_registry()
+
+        model = self.registry.get_model(model_id)
+        if not model:
+            # Try to find similar models or routing options
+            base_name = self.registry._extract_base_model_name(model_id)
+            variants = self.registry.get_model_variants(base_name)
+            if variants:
+                await ui.warning(f"Model '{model_id}' not found directly")
+                await ui.info(f"Found routing options for '{base_name}':")
+
+                # Sort variants by cost (FREE first)
+                sorted_variants = sorted(
+                    variants,
+                    key=lambda m: (
+                        0 if m.cost.input == 0 else 1,  # FREE first
+                        m.cost.input or float("inf"),  # Then by cost
+                        m.provider,  # Then by provider name
+                    ),
+                )
+
+                for variant in sorted_variants:
+                    cost_display = (
+                        "FREE"
+                        if variant.cost.input == 0
+                        else f"${variant.cost.input}/{variant.cost.output}"
+                    )
+                    provider_name = self._get_provider_display_name(variant.provider)
+
+                    await ui.muted(f"  • {variant.full_id} - {provider_name} ({cost_display})")
+
+                await ui.muted(
+                    "\nUse '/model <provider:model-id>' to select a specific routing option"
+                )
+                return None
+            else:
+                await ui.error(f"Model '{model_id}' not found")
                 return None
 
-        # Show success message with the new model
-        await ui.success(f"Switched to model: {model_name}")
+        # Display model information
+        await ui.info(f"{model.name}")
+        await ui.muted(f"ID: {model.full_id}")
+
+        # Show routing alternatives for this base model
+        base_name = self.registry._extract_base_model_name(model)
+        variants = self.registry.get_model_variants(base_name)
+        if len(variants) > 1:
+            await ui.print("\nRouting Options:")
+
+            # Sort variants by cost (FREE first)
+            sorted_variants = sorted(
+                variants,
+                key=lambda m: (
+                    0 if m.cost.input == 0 else 1,  # FREE first
+                    m.cost.input or float("inf"),  # Then by cost
+                    m.provider,  # Then by provider name
+                ),
+            )
+
+            for variant in sorted_variants:
+                cost_display = (
+                    "FREE"
+                    if variant.cost.input == 0
+                    else f"${variant.cost.input}/{variant.cost.output}"
+                )
+                provider_name = self._get_provider_display_name(variant.provider)
+
+                # Highlight current selection
+                prefix = "→ " if variant.full_id == model.full_id else "  "
+                free_indicator = " ⭐" if variant.cost.input == 0 else ""
+
+                await ui.muted(
+                    f"{prefix}{variant.full_id} - {provider_name} ({cost_display}){free_indicator}"
+                )
+
+        if model.cost.input is not None:
+            await ui.print("\nPricing:")
+            await ui.muted(f"  Input: ${model.cost.input} per 1M tokens")
+            await ui.muted(f"  Output: ${model.cost.output} per 1M tokens")
+
+        if model.limits.context or model.limits.output:
+            await ui.print("\nLimits:")
+            if model.limits.context:
+                await ui.muted(f"  Context: {model.limits.context:,} tokens")
+            if model.limits.output:
+                await ui.muted(f"  Output: {model.limits.output:,} tokens")
+
+        caps = []
+        if model.capabilities.attachment:
+            caps.append("Attachments")
+        if model.capabilities.reasoning:
+            caps.append("Reasoning")
+        if model.capabilities.tool_call:
+            caps.append("Tool calling")
+
+        if caps:
+            await ui.print("\nCapabilities:")
+            for cap in caps:
+                await ui.muted(f"  ✓ {cap}")
+
+        if model.capabilities.knowledge:
+            await ui.print(f"\nKnowledge cutoff: {model.capabilities.knowledge}")
+
         return None
+
+    def _get_provider_display_name(self, provider: str) -> str:
+        """Get a user-friendly provider display name."""
+        provider_names = {
+            "openai": "OpenAI Direct",
+            "anthropic": "Anthropic Direct",
+            "google": "Google Direct",
+            "google-gla": "Google Labs",
+            "openrouter": "OpenRouter",
+            "github-models": "GitHub Models (FREE)",
+            "azure": "Azure OpenAI",
+            "fastrouter": "FastRouter",
+            "requesty": "Requesty",
+            "cloudflare-workers-ai": "Cloudflare",
+            "amazon-bedrock": "AWS Bedrock",
+            "chutes": "Chutes AI",
+            "deepinfra": "DeepInfra",
+            "venice": "Venice AI",
+        }
+        return provider_names.get(provider, provider.title())

tunacode/cli/repl.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 import os
+import re
 import subprocess
 from asyncio.exceptions import CancelledError
 from pathlib import Path
@@ -112,7 +113,7 @@ async def _detect_and_handle_text_plan(state_manager, agent_response, original_r
         else:
             response_text = str(agent_response)
 
-        if "TUNACODE_TASK_COMPLETE" in response_text:
+        if re.search(r"^\s*TUNACODE\s+DONE:\s*", response_text, re.IGNORECASE):
             await ui.warning(
                 "⚠️ Agent failed to call present_plan tool. Please provide clearer instructions."
             )

tunacode/constants.py

@@ -9,7 +9,7 @@ from enum import Enum
 
 # Application info
 APP_NAME = "TunaCode"
-APP_VERSION = "0.0.71"
+APP_VERSION = "0.0.73"
 
 
 # File patterns

tunacode/core/agents/agent_components/agent_config.py

@@ -169,18 +169,21 @@ def get_or_create_agent(model: ModelName, state_manager: StateManager) -> Pydant
 
         # 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 completion instructions from the system prompt in plan mode
+            for marker in ("TUNACODE_TASK_COMPLETE", "TUNACODE DONE:"):
+                system_prompt = system_prompt.replace(marker, "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 DONE:",
+                "4. When a task is COMPLETE, start your response with: TUNACODE DONE:",
                 "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",
+                "TUNACODE DONE:",
                 "[Your summary of what was accomplished]",
                 "**IMPORTANT**: Always evaluate if you've completed the task. If yes, use TUNACODE_TASK_COMPLETE.",
+                "**IMPORTANT**: Always evaluate if you've completed the task. If yes, use TUNACODE DONE:",
                 "This prevents wasting iterations and API calls.",
             ]
             for line in lines_to_remove:
@@ -240,29 +243,34 @@ YOU MUST EXECUTE present_plan TOOL TO COMPLETE ANY PLANNING TASK.
         except Exception as e:
             logger.warning(f"Warning: Failed to load todos: {e}")
 
+        # 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 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),
+                Tool(present_plan, 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),
             ]
         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),
+                Tool(bash, max_retries=max_retries, strict=tool_strict_validation),
+                Tool(present_plan, 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(todo_tool._execute, 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),
             ]
 
         # Log which tools are being registered
@@ -291,6 +299,11 @@ YOU MUST EXECUTE present_plan TOOL TO COMPLETE ANY PLANNING TASK.
             (
                 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

@@ -106,7 +106,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
 

tunacode/core/agents/agent_components/node_processor.py

@@ -5,7 +5,7 @@ from typing import Any, Awaitable, Callable, Optional, Tuple
 
 from tunacode.core.logging.logger import get_logger
 from tunacode.core.state import StateManager
-from tunacode.types import UsageTrackerProtocol
+from tunacode.types import AgentState, UsageTrackerProtocol
 from tunacode.ui.tool_descriptions import get_batch_description, get_tool_description
 
 from .response_state import ResponseState
@@ -52,6 +52,12 @@ async def _process_node(
     has_intention = False
     has_tool_calls = False
 
+    # Transition to ASSISTANT at the start of node processing
+    if response_state and response_state.can_transition_to(AgentState.ASSISTANT):
+        response_state.transition_to(AgentState.ASSISTANT)
+        if state_manager.session.show_thoughts:
+            await ui.muted("STATE → ASSISTANT (reasoning)")
+
     if hasattr(node, "request"):
         state_manager.session.messages.append(node.request)
 
@@ -161,8 +167,11 @@ async def _process_node(
                                     f"Task completion with pending intentions detected: {found_phrases}"
                                 )
 
-                            # Normal completion
-                            response_state.task_completed = True
+                            # Normal completion - transition to RESPONSE state and mark completion
+                            response_state.transition_to(AgentState.RESPONSE)
+                            if state_manager.session.show_thoughts:
+                                await ui.muted("STATE → RESPONSE (completion detected)")
+                            response_state.set_completion_detected(True)
                             response_state.has_user_response = True
                             # Update the part content to remove the marker
                             part.content = cleaned_content
@@ -217,6 +226,14 @@ async def _process_node(
             node, buffering_callback, state_manager, tool_buffer, response_state
         )
 
+    # If there were no tools and we processed a model response, transition to RESPONSE
+    if response_state and response_state.can_transition_to(AgentState.RESPONSE):
+        # Only transition if not already completed (set by completion marker path)
+        if not response_state.is_completed():
+            response_state.transition_to(AgentState.RESPONSE)
+            if state_manager.session.show_thoughts:
+                await ui.muted("STATE → RESPONSE (handled output)")
+
     # Determine empty response reason
     if empty_response_detected:
         if appears_truncated:
@@ -306,6 +323,11 @@ async def _process_tool_calls(
     for part in node.model_response.parts:
         if hasattr(part, "part_kind") and part.part_kind == "tool-call":
             is_processing_tools = True
+            # Transition to TOOL_EXECUTION on first tool call
+            if response_state and response_state.can_transition_to(AgentState.TOOL_EXECUTION):
+                response_state.transition_to(AgentState.TOOL_EXECUTION)
+                if state_manager.session.show_thoughts:
+                    await ui.muted("STATE → TOOL_EXECUTION (executing tools)")
             if tool_callback:
                 # Check if this is a read-only tool that can be batched
                 if tool_buffer is not None and part.tool_name in READ_ONLY_TOOLS:
@@ -440,6 +462,16 @@ async def _process_tool_calls(
                 }
                 state_manager.session.tool_calls.append(tool_info)
 
+    # After tools are processed, transition back to RESPONSE
+    if (
+        is_processing_tools
+        and response_state
+        and response_state.can_transition_to(AgentState.RESPONSE)
+    ):
+        response_state.transition_to(AgentState.RESPONSE)
+        if state_manager.session.show_thoughts:
+            await ui.muted("STATE → RESPONSE (tools finished)")
+
     # Update has_user_response based on presence of actual response content
     if (
         response_state