code-puppy 0.0.170__py3-none-any.whl → 0.0.172__py3-none-any.whl

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():
     """
@@ -109,6 +115,7 @@ def get_config_keys():
     default_keys = [
         "yolo_mode",
         "model",
+        "vqa_model_name",
         "compaction_strategy",
         "protected_token_count",
         "compaction_threshold",
@@ -156,9 +163,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 +173,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 +299,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 +341,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 +590,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/{mcp → mcp_}/config_wizard.py

@@ -11,7 +11,7 @@ from urllib.parse import urlparse
 
 from rich.console import Console
 
-from code_puppy.mcp.manager import ServerConfig, get_mcp_manager
+from code_puppy.mcp_.manager import ServerConfig, get_mcp_manager
 from code_puppy.messaging import (
     emit_error,
     emit_info,

code_puppy/{mcp → mcp_}/examples/retry_example.py

@@ -17,7 +17,7 @@ from typing import Any
 project_root = Path(__file__).parents[3]
 sys.path.insert(0, str(project_root))
 
-from code_puppy.mcp.retry_manager import get_retry_manager, retry_mcp_call  # noqa: E402
+from code_puppy.mcp_.retry_manager import get_retry_manager, retry_mcp_call  # noqa: E402
 
 logger = logging.getLogger(__name__)
 

code_puppy/{mcp → mcp_}/managed_server.py

@@ -24,7 +24,7 @@ from pydantic_ai.mcp import (
 )
 
 from code_puppy.http_utils import create_async_client
-from code_puppy.mcp.blocking_startup import BlockingMCPServerStdio
+from code_puppy.mcp_.blocking_startup import BlockingMCPServerStdio
 from code_puppy.messaging import emit_info
 
 # Configure logging

code_puppy/{mcp → mcp_}/server_registry_catalog.py

@@ -794,9 +794,7 @@ MCP_SERVER_REGISTRY: List[MCPServerTemplate] = [
         type="http",
         config={
             "url": "https://mcp.context7.com/mcp",
-             "headers": {
-                "Authorization": "Bearer $CONTEXT7_API_KEY"
-             }
+            "headers": {"Authorization": "Bearer $CONTEXT7_API_KEY"},
         },
         verified=True,
         popular=True,