code-puppy 0.0.171__py3-none-any.whl → 0.0.173__py3-none-any.whl

code_puppy/command_line/command_handler.py

@@ -81,7 +81,9 @@ def get_commands_help():
     )
     help_lines.append(
         Text("/truncate", style="cyan")
-        + Text(" <N>              Truncate message history to N most recent messages (keeping system message)")
+        + Text(
+            " <N>              Truncate message history to N most recent messages (keeping system message)"
+        )
     )
     help_lines.append(
         Text("/<unknown>", style="cyan")
@@ -409,23 +411,33 @@ def handle_command(command: str):
 
     if command.startswith("/pin_model"):
         # Handle agent model pinning
+        import json
+
         from code_puppy.agents.json_agent import discover_json_agents
         from code_puppy.command_line.model_picker_completion import load_model_names
-        import json
 
         tokens = command.split()
 
         if len(tokens) != 3:
             emit_warning("Usage: /pin_model <agent-name> <model-name>")
 
-            # Show available models and JSON agents
+            # Show available models and agents
             available_models = load_model_names()
             json_agents = discover_json_agents()
 
+            # Get built-in agents
+            from code_puppy.agents.agent_manager import get_agent_descriptions
+            builtin_agents = get_agent_descriptions()
+
             emit_info("Available models:")
             for model in available_models:
                 emit_info(f"  [cyan]{model}[/cyan]")
 
+            if builtin_agents:
+                emit_info("\nAvailable built-in agents:")
+                for agent_name, description in builtin_agents.items():
+                    emit_info(f"  [cyan]{agent_name}[/cyan] - {description}")
+
             if json_agents:
                 emit_info("\nAvailable JSON agents:")
                 for agent_name, agent_path in json_agents.items():
@@ -442,31 +454,51 @@ def handle_command(command: str):
             emit_warning(f"Available models: {', '.join(available_models)}")
             return True
 
-        # Check that we're modifying a JSON agent (not a built-in Python agent)
+        # Check if this is a JSON agent or a built-in Python agent
         json_agents = discover_json_agents()
-        if agent_name not in json_agents:
-            emit_error(f"JSON agent '{agent_name}' not found")
 
-            # Show available JSON agents
+        # Get list of available built-in agents
+        from code_puppy.agents.agent_manager import get_agent_descriptions
+        builtin_agents = get_agent_descriptions()
+
+        is_json_agent = agent_name in json_agents
+        is_builtin_agent = agent_name in builtin_agents
+
+        if not is_json_agent and not is_builtin_agent:
+            emit_error(f"Agent '{agent_name}' not found")
+
+            # Show available agents
+            if builtin_agents:
+                emit_info("Available built-in agents:")
+                for name, desc in builtin_agents.items():
+                    emit_info(f"  [cyan]{name}[/cyan] - {desc}")
+
             if json_agents:
-                emit_info("Available JSON agents:")
+                emit_info("\nAvailable JSON agents:")
                 for name, path in json_agents.items():
                     emit_info(f"  [cyan]{name}[/cyan] ({path})")
             return True
 
-        agent_file_path = json_agents[agent_name]
-
-        # Load, modify, and save the agent configuration
+        # Handle different agent types
         try:
-            with open(agent_file_path, "r", encoding="utf-8") as f:
-                agent_config = json.load(f)
+            if is_json_agent:
+                # Handle JSON agent - modify the JSON file
+                agent_file_path = json_agents[agent_name]
+
+                with open(agent_file_path, "r", encoding="utf-8") as f:
+                    agent_config = json.load(f)
 
-            # Set the model
-            agent_config["model"] = model_name
+                # Set the model
+                agent_config["model"] = model_name
 
-            # Save the updated configuration
-            with open(agent_file_path, "w", encoding="utf-8") as f:
-                json.dump(agent_config, f, indent=2, ensure_ascii=False)
+                # Save the updated configuration
+                with open(agent_file_path, "w", encoding="utf-8") as f:
+                    json.dump(agent_config, f, indent=2, ensure_ascii=False)
+
+            else:
+                # Handle built-in Python agent - store in config
+                from code_puppy.config import set_agent_pinned_model
+                set_agent_pinned_model(agent_name, model_name)
 
             emit_success(f"Model '{model_name}' pinned to agent '{agent_name}'")
 
@@ -622,9 +654,11 @@ def handle_command(command: str):
     if command.startswith("/truncate"):
         tokens = command.split()
         if len(tokens) != 2:
-            emit_error("Usage: /truncate <N> (where N is the number of messages to keep)")
+            emit_error(
+                "Usage: /truncate <N> (where N is the number of messages to keep)"
+            )
             return True
-        
+
         try:
             n = int(tokens[1])
             if n < 1:
@@ -633,23 +667,29 @@ def handle_command(command: str):
         except ValueError:
             emit_error("N must be a valid integer")
             return True
-        
+
         from code_puppy.state_management import get_message_history, set_message_history
-        
+
         history = get_message_history()
         if not history:
             emit_warning("No history to truncate yet. Ask me something first!")
             return True
-            
+
         if len(history) <= n:
-            emit_info(f"History already has {len(history)} messages, which is <= {n}. Nothing to truncate.")
+            emit_info(
+                f"History already has {len(history)} messages, which is <= {n}. Nothing to truncate."
+            )
             return True
-            
+
         # Always keep the first message (system message) and then keep the N-1 most recent messages
-        truncated_history = [history[0]] + history[-(n-1):] if n > 1 else [history[0]]
-        
+        truncated_history = (
+            [history[0]] + history[-(n - 1) :] if n > 1 else [history[0]]
+        )
+
         set_message_history(truncated_history)
-        emit_success(f"Truncated message history from {len(history)} to {len(truncated_history)} messages (keeping system message and {n-1} most recent)")
+        emit_success(
+            f"Truncated message history from {len(history)} to {len(truncated_history)} messages (keeping system message and {n - 1} most recent)"
+        )
         return True
 
     if command in ("/exit", "/quit"):

code_puppy/command_line/mcp/add_command.py

@@ -8,7 +8,7 @@ import os
 from typing import List, Optional
 
 from code_puppy.messaging import emit_info
-from code_puppy.state_management import is_tui_mode
+from code_puppy.tui_state import is_tui_mode
 
 from .base import MCPCommandBase
 from .wizard_utils import run_interactive_install_wizard
@@ -130,7 +130,7 @@ class AddCommand(MCPCommandBase):
         """
         try:
             from code_puppy.config import MCP_SERVERS_FILE
-            from code_puppy.mcp.managed_server import ServerConfig
+            from code_puppy.mcp_.managed_server import ServerConfig
 
             # Extract required fields
             name = config_dict.pop("name")

code_puppy/command_line/mcp/base.py

@@ -8,7 +8,7 @@ import logging
 
 from rich.console import Console
 
-from code_puppy.mcp.manager import get_mcp_manager
+from code_puppy.mcp_.manager import get_mcp_manager
 
 # Configure logging
 logger = logging.getLogger(__name__)

code_puppy/command_line/mcp/install_command.py

@@ -6,7 +6,7 @@ import logging
 from typing import List, Optional
 
 from code_puppy.messaging import emit_info
-from code_puppy.state_management import is_tui_mode
+from code_puppy.tui_state import is_tui_mode
 
 from .base import MCPCommandBase
 from .wizard_utils import run_interactive_install_wizard
@@ -76,7 +76,7 @@ class InstallCommand(MCPCommandBase):
     def _install_from_catalog(self, server_name_or_id: str, group_id: str) -> bool:
         """Install a server directly from the catalog by name or ID."""
         try:
-            from code_puppy.mcp.server_registry_catalog import catalog
+            from code_puppy.mcp_.server_registry_catalog import catalog
             from code_puppy.messaging import emit_prompt
 
             from .utils import find_server_id_by_name

code_puppy/command_line/mcp/list_command.py

@@ -8,7 +8,7 @@ from typing import List, Optional
 from rich.table import Table
 from rich.text import Text
 
-from code_puppy.mcp.managed_server import ServerState
+from code_puppy.mcp_.managed_server import ServerState
 from code_puppy.messaging import emit_info
 
 from .base import MCPCommandBase

code_puppy/command_line/mcp/search_command.py

@@ -34,7 +34,7 @@ class SearchCommand(MCPCommandBase):
             group_id = self.generate_group_id()
 
         try:
-            from code_puppy.mcp.server_registry_catalog import catalog
+            from code_puppy.mcp_.server_registry_catalog import catalog
 
             if not args:
                 # Show popular servers if no query

code_puppy/command_line/mcp/start_all_command.py

@@ -6,7 +6,7 @@ import logging
 import time
 from typing import List, Optional
 
-from code_puppy.mcp.managed_server import ServerState
+from code_puppy.mcp_.managed_server import ServerState
 from code_puppy.messaging import emit_info
 
 from .base import MCPCommandBase

code_puppy/command_line/mcp/status_command.py

@@ -8,7 +8,7 @@ from typing import List, Optional
 
 from rich.panel import Panel
 
-from code_puppy.mcp.managed_server import ServerState
+from code_puppy.mcp_.managed_server import ServerState
 from code_puppy.messaging import emit_info
 
 from .base import MCPCommandBase
@@ -117,7 +117,7 @@ class StatusCommand(MCPCommandBase):
 
             # Check async lifecycle manager status if available
             try:
-                from code_puppy.mcp.async_lifecycle import get_lifecycle_manager
+                from code_puppy.mcp_.async_lifecycle import get_lifecycle_manager
 
                 lifecycle_mgr = get_lifecycle_manager()
                 if lifecycle_mgr.is_running(server_id):

code_puppy/command_line/mcp/stop_all_command.py

@@ -6,7 +6,7 @@ import logging
 import time
 from typing import List, Optional
 
-from code_puppy.mcp.managed_server import ServerState
+from code_puppy.mcp_.managed_server import ServerState
 from code_puppy.messaging import emit_info
 
 from .base import MCPCommandBase

code_puppy/command_line/mcp/utils.py

@@ -8,7 +8,7 @@ from typing import Optional
 
 from rich.text import Text
 
-from code_puppy.mcp.managed_server import ServerState
+from code_puppy.mcp_.managed_server import ServerState
 
 
 def format_state_indicator(state: ServerState) -> Text:

code_puppy/command_line/mcp/wizard_utils.py

@@ -118,7 +118,7 @@ def interactive_server_selection(group_id: str):
     # This is a simplified version - the full implementation would have
     # category browsing, search, etc. For now, we'll just show popular servers
     try:
-        from code_puppy.mcp.server_registry_catalog import catalog
+        from code_puppy.mcp_.server_registry_catalog import catalog
 
         servers = catalog.get_popular(10)
         if not servers:
@@ -256,7 +256,7 @@ def install_server_from_catalog(
         import os
 
         from code_puppy.config import MCP_SERVERS_FILE
-        from code_puppy.mcp.managed_server import ServerConfig
+        from code_puppy.mcp_.managed_server import ServerConfig
 
         # Set environment variables in the current environment
         for var, value in env_vars.items():

code_puppy/config.py

@@ -14,6 +14,12 @@ AGENTS_DIR = os.path.join(CONFIG_DIR, "agents")
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
 
+# Cache containers for model validation and defaults
+_model_validation_cache = {}
+_default_model_cache = None
+_default_vision_model_cache = None
+_default_vqa_model_cache = None
+
 
 def ensure_config_exists():
     """
@@ -156,9 +162,6 @@ def load_mcp_server_configs():
         return {}
 
 
-# Cache for model validation to prevent hitting ModelFactory on every call
-_model_validation_cache = {}
-_default_model_cache = None
 
 
 def _default_model_from_models_json():
@@ -169,30 +172,107 @@ def _default_model_from_models_json():
     """
     global _default_model_cache
 
-    # Return cached default if we have one
     if _default_model_cache is not None:
         return _default_model_cache
 
     try:
-        # Local import to avoid potential circular dependency on module import
         from code_puppy.model_factory import ModelFactory
 
         models_config = ModelFactory.load_config()
         if models_config:
-            # Get the first key from the models config
             first_key = next(iter(models_config))
             _default_model_cache = first_key
             return first_key
-        else:
-            # If models_config is empty, fall back to gpt-5
-            _default_model_cache = "gpt-5"
-            return "gpt-5"
+        _default_model_cache = "gpt-5"
+        return "gpt-5"
     except Exception:
-        # Any problem (network, file missing, empty dict, etc.) => fall back to gpt-5
         _default_model_cache = "gpt-5"
         return "gpt-5"
 
 
+def _default_vision_model_from_models_json() -> str:
+    """Select a default vision-capable model from models.json with caching."""
+    global _default_vision_model_cache
+
+    if _default_vision_model_cache is not None:
+        return _default_vision_model_cache
+
+    try:
+        from code_puppy.model_factory import ModelFactory
+
+        models_config = ModelFactory.load_config()
+        if models_config:
+            # Prefer explicitly tagged vision models
+            for name, config in models_config.items():
+                if config.get("supports_vision"):
+                    _default_vision_model_cache = name
+                    return name
+
+            # Fallback heuristic: common multimodal models
+            preferred_candidates = (
+                "gpt-4.1",
+                "gpt-4.1-mini",
+                "gpt-4.1-nano",
+                "claude-4-0-sonnet",
+                "gemini-2.5-flash-preview-05-20",
+            )
+            for candidate in preferred_candidates:
+                if candidate in models_config:
+                    _default_vision_model_cache = candidate
+                    return candidate
+
+            # Last resort: use the general default model
+            _default_vision_model_cache = _default_model_from_models_json()
+            return _default_vision_model_cache
+
+        _default_vision_model_cache = "gpt-4.1"
+        return "gpt-4.1"
+    except Exception:
+        _default_vision_model_cache = "gpt-4.1"
+        return "gpt-4.1"
+
+
+def _default_vqa_model_from_models_json() -> str:
+    """Select a default VQA-capable model, preferring vision-ready options."""
+    global _default_vqa_model_cache
+
+    if _default_vqa_model_cache is not None:
+        return _default_vqa_model_cache
+
+    try:
+        from code_puppy.model_factory import ModelFactory
+
+        models_config = ModelFactory.load_config()
+        if models_config:
+            # Allow explicit VQA hints if present
+            for name, config in models_config.items():
+                if config.get("supports_vqa"):
+                    _default_vqa_model_cache = name
+                    return name
+
+            # Reuse multimodal heuristics before falling back to generic default
+            preferred_candidates = (
+                "gpt-4.1",
+                "gpt-4.1-mini",
+                "claude-4-0-sonnet",
+                "gemini-2.5-flash-preview-05-20",
+                "gpt-4.1-nano",
+            )
+            for candidate in preferred_candidates:
+                if candidate in models_config:
+                    _default_vqa_model_cache = candidate
+                    return candidate
+
+            _default_vqa_model_cache = _default_model_from_models_json()
+            return _default_vqa_model_cache
+
+        _default_vqa_model_cache = "gpt-4.1"
+        return "gpt-4.1"
+    except Exception:
+        _default_vqa_model_cache = "gpt-4.1"
+        return "gpt-4.1"
+
+
 def _validate_model_exists(model_name: str) -> bool:
     """Check if a model exists in models.json with caching to avoid redundant calls."""
     global _model_validation_cache
@@ -218,9 +298,11 @@ def _validate_model_exists(model_name: str) -> bool:
 
 def clear_model_cache():
     """Clear the model validation cache. Call this when models.json changes."""
-    global _model_validation_cache, _default_model_cache
+    global _model_validation_cache, _default_model_cache, _default_vision_model_cache, _default_vqa_model_cache
     _model_validation_cache.clear()
     _default_model_cache = None
+    _default_vision_model_cache = None
+    _default_vqa_model_cache = None
 
 
 def get_model_name():
@@ -258,6 +340,20 @@ def set_model_name(model: str):
     clear_model_cache()
 
 
+def get_vqa_model_name() -> str:
+    """Return the configured VQA model, falling back to an inferred default."""
+    stored_model = get_value("vqa_model_name")
+    if stored_model and _validate_model_exists(stored_model):
+        return stored_model
+    return _default_vqa_model_from_models_json()
+
+
+def set_vqa_model_name(model: str):
+    """Persist the configured VQA model name and refresh caches."""
+    set_config_value("vqa_model_name", model or "")
+    clear_model_cache()
+
+
 def get_puppy_token():
     """Returns the puppy_token from config, or None if not set."""
     return get_value("puppy_token")
@@ -493,3 +589,36 @@ def save_command_to_history(command: str):
             f"❌ An unexpected error occurred while saving command history: {str(e)}"
         )
         direct_console.print(f"[bold red]{error_msg}[/bold red]")
+
+
+def get_agent_pinned_model(agent_name: str) -> str:
+    """Get the pinned model for a specific agent.
+
+    Args:
+        agent_name: Name of the agent to get the pinned model for.
+
+    Returns:
+        Pinned model name, or None if no model is pinned for this agent.
+    """
+    return get_value(f"agent_model_{agent_name}")
+
+
+def set_agent_pinned_model(agent_name: str, model_name: str):
+    """Set the pinned model for a specific agent.
+
+    Args:
+        agent_name: Name of the agent to pin the model for.
+        model_name: Model name to pin to this agent.
+    """
+    set_config_value(f"agent_model_{agent_name}", model_name)
+
+
+def clear_agent_pinned_model(agent_name: str):
+    """Clear the pinned model for a specific agent.
+
+    Args:
+        agent_name: Name of the agent to clear the pinned model for.
+    """
+    # We can't easily delete keys from configparser, so set to empty string
+    # which will be treated as None by get_agent_pinned_model
+    set_config_value(f"agent_model_{agent_name}", "")

code_puppy/http_utils.py

@@ -10,7 +10,7 @@ from typing import Dict, Optional, Union
 
 import httpx
 import requests
-from tenacity import retry_if_exception_type, stop_after_attempt, wait_exponential
+from tenacity import stop_after_attempt, wait_exponential
 
 try:
     from pydantic_ai.retries import (
@@ -57,26 +57,32 @@ def create_client(
 
     # If retry components are available, create a client with retry transport
     if TenacityTransport and RetryConfig and wait_retry_after:
+
         def should_retry_status(response):
             """Raise exceptions for retryable HTTP status codes."""
             if response.status_code in retry_status_codes:
-                emit_info(f"HTTP retry: Retrying request due to status code {response.status_code}")
+                emit_info(
+                    f"HTTP retry: Retrying request due to status code {response.status_code}"
+                )
                 response.raise_for_status()
 
         transport = TenacityTransport(
             config=RetryConfig(
-                retry=lambda e: isinstance(e, httpx.HTTPStatusError) and e.response.status_code in retry_status_codes,
+                retry=lambda e: isinstance(e, httpx.HTTPStatusError)
+                and e.response.status_code in retry_status_codes,
                 wait=wait_retry_after(
                     fallback_strategy=wait_exponential(multiplier=1, max=60),
-                    max_wait=300
+                    max_wait=300,
                 ),
                 stop=stop_after_attempt(10),
-                reraise=True
+                reraise=True,
             ),
-            validate_response=should_retry_status
+            validate_response=should_retry_status,
+        )
+
+        return httpx.Client(
+            transport=transport, verify=verify, headers=headers or {}, timeout=timeout
         )
-        
-        return httpx.Client(transport=transport, verify=verify, headers=headers or {}, timeout=timeout)
     else:
         # Fallback to regular client if retry components are not available
         return httpx.Client(verify=verify, headers=headers or {}, timeout=timeout)
@@ -93,26 +99,32 @@ def create_async_client(
 
     # If retry components are available, create a client with retry transport
     if AsyncTenacityTransport and RetryConfig and wait_retry_after:
+
         def should_retry_status(response):
             """Raise exceptions for retryable HTTP status codes."""
             if response.status_code in retry_status_codes:
-                emit_info(f"HTTP retry: Retrying request due to status code {response.status_code}")
+                emit_info(
+                    f"HTTP retry: Retrying request due to status code {response.status_code}"
+                )
                 response.raise_for_status()
 
         transport = AsyncTenacityTransport(
             config=RetryConfig(
-                retry=lambda e: isinstance(e, httpx.HTTPStatusError) and e.response.status_code in retry_status_codes,
+                retry=lambda e: isinstance(e, httpx.HTTPStatusError)
+                and e.response.status_code in retry_status_codes,
                 wait=wait_retry_after(
                     fallback_strategy=wait_exponential(multiplier=1, max=60),
-                    max_wait=300
+                    max_wait=300,
                 ),
                 stop=stop_after_attempt(10),
-                reraise=True
+                reraise=True,
             ),
-            validate_response=should_retry_status
+            validate_response=should_retry_status,
+        )
+
+        return httpx.AsyncClient(
+            transport=transport, verify=verify, headers=headers or {}, timeout=timeout
         )
-        
-        return httpx.AsyncClient(transport=transport, verify=verify, headers=headers or {}, timeout=timeout)
     else:
         # Fallback to regular client if retry components are not available
         return httpx.AsyncClient(verify=verify, headers=headers or {}, timeout=timeout)
@@ -169,32 +181,44 @@ def create_reopenable_async_client(
 
     # If retry components are available, create a client with retry transport
     if AsyncTenacityTransport and RetryConfig and wait_retry_after:
+
         def should_retry_status(response):
             """Raise exceptions for retryable HTTP status codes."""
             if response.status_code in retry_status_codes:
-                emit_info(f"HTTP retry: Retrying request due to status code {response.status_code}")
+                emit_info(
+                    f"HTTP retry: Retrying request due to status code {response.status_code}"
+                )
                 response.raise_for_status()
 
         transport = AsyncTenacityTransport(
             config=RetryConfig(
-                retry=lambda e: isinstance(e, httpx.HTTPStatusError) and e.response.status_code in retry_status_codes,
+                retry=lambda e: isinstance(e, httpx.HTTPStatusError)
+                and e.response.status_code in retry_status_codes,
                 wait=wait_retry_after(
                     fallback_strategy=wait_exponential(multiplier=1, max=60),
-                    max_wait=300
+                    max_wait=300,
                 ),
                 stop=stop_after_attempt(10),
-                reraise=True
+                reraise=True,
             ),
-            validate_response=should_retry_status
+            validate_response=should_retry_status,
         )
-        
+
         if ReopenableAsyncClient is not None:
             return ReopenableAsyncClient(
-                transport=transport, verify=verify, headers=headers or {}, timeout=timeout
+                transport=transport,
+                verify=verify,
+                headers=headers or {},
+                timeout=timeout,
             )
         else:
             # Fallback to regular AsyncClient if ReopenableAsyncClient is not available
-            return httpx.AsyncClient(transport=transport, verify=verify, headers=headers or {}, timeout=timeout)
+            return httpx.AsyncClient(
+                transport=transport,
+                verify=verify,
+                headers=headers or {},
+                timeout=timeout,
+            )
     else:
         # Fallback to regular clients if retry components are not available
         if ReopenableAsyncClient is not None:
@@ -203,7 +227,9 @@ def create_reopenable_async_client(
             )
         else:
             # Fallback to regular AsyncClient if ReopenableAsyncClient is not available
-            return httpx.AsyncClient(verify=verify, headers=headers or {}, timeout=timeout)
+            return httpx.AsyncClient(
+                verify=verify, headers=headers or {}, timeout=timeout
+            )
 
 
 def is_cert_bundle_available() -> bool:

code_puppy/main.py

@@ -29,7 +29,8 @@ from code_puppy.message_history_processor import (
     message_history_accumulator,
     prune_interrupted_tool_calls,
 )
-from code_puppy.state_management import is_tui_mode, set_message_history, set_tui_mode
+from code_puppy.state_management import set_message_history
+from code_puppy.tui_state import is_tui_mode, set_tui_mode
 from code_puppy.tools.common import console
 from code_puppy.version_checker import default_version_mismatch_behavior