code-puppy 0.0.171__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,

code_puppy/message_history_processor.py

@@ -192,64 +192,6 @@ def split_messages_for_protected_summarization(
     return messages_to_summarize, protected_messages
 
 
-def deduplicate_tool_returns(messages: List[ModelMessage]) -> List[ModelMessage]:
-    """
-    Remove duplicate tool returns while preserving the first occurrence for each tool_call_id.
-
-    This function identifies tool-return parts that share the same tool_call_id and
-    removes duplicates, keeping only the first return for each id. This prevents
-    conversation corruption from duplicate tool_result blocks.
-    """
-    if not messages:
-        return messages
-
-    seen_tool_returns: Set[str] = set()
-    deduplicated: List[ModelMessage] = []
-    removed_count = 0
-
-    for msg in messages:
-        if not hasattr(msg, "parts") or not msg.parts:
-            deduplicated.append(msg)
-            continue
-
-        filtered_parts = []
-        msg_had_duplicates = False
-
-        for part in msg.parts:
-            tool_call_id = getattr(part, "tool_call_id", None)
-            if tool_call_id and _is_tool_return_part(part):
-                if tool_call_id in seen_tool_returns:
-                    msg_had_duplicates = True
-                    removed_count += 1
-                    continue
-                seen_tool_returns.add(tool_call_id)
-            filtered_parts.append(part)
-
-        if not filtered_parts:
-            continue
-
-        if msg_had_duplicates:
-            new_msg = type(msg)(parts=filtered_parts)
-            for attr_name in dir(msg):
-                if (
-                    not attr_name.startswith("_")
-                    and attr_name != "parts"
-                    and hasattr(msg, attr_name)
-                ):
-                    try:
-                        setattr(new_msg, attr_name, getattr(msg, attr_name))
-                    except (AttributeError, TypeError):
-                        pass
-            deduplicated.append(new_msg)
-        else:
-            deduplicated.append(msg)
-
-    if removed_count > 0:
-        emit_warning(f"Removed {removed_count} duplicate tool-return part(s)")
-
-    return deduplicated
-
-
 def summarize_messages(
     messages: List[ModelMessage], with_protection: bool = True
 ) -> Tuple[List[ModelMessage], List[ModelMessage]]:
@@ -412,9 +354,7 @@ def prune_interrupted_tool_calls(messages: List[ModelMessage]) -> List[ModelMess
 
 
 def message_history_processor(messages: List[ModelMessage]) -> List[ModelMessage]:
-    cleaned_history = prune_interrupted_tool_calls(
-        deduplicate_tool_returns(messages)
-    )
+    cleaned_history = prune_interrupted_tool_calls(messages)
 
     total_current_tokens = sum(
         estimate_tokens_for_message(msg) for msg in cleaned_history

code_puppy/state_management.py

@@ -4,6 +4,8 @@ from typing import Any, List, Set
 
 import pydantic
 
+from code_puppy.messaging import emit_info
+
 _tui_mode: bool = False
 _tui_app_instance: Any = None
 
@@ -138,8 +140,8 @@ def _stringify_part(part: Any) -> str:
         attributes.append(f"content={json.dumps(content, sort_keys=True)}")
     else:
         attributes.append(f"content={repr(content)}")
-
-    return "|".join(attributes)
+    result = "|".join(attributes)
+    return result
 
 
 def hash_message(message: Any) -> int:

code_puppy/tools/__init__.py

@@ -1,20 +1,71 @@
 from code_puppy.messaging import emit_warning
-from code_puppy.tools.agent_tools import (
-    register_list_agents,
-    register_invoke_agent,
+from code_puppy.tools.agent_tools import register_invoke_agent, register_list_agents
+
+# Browser automation tools
+from code_puppy.tools.browser.browser_control import (
+    register_close_browser,
+    register_create_new_page,
+    register_get_browser_status,
+    register_initialize_browser,
+    register_list_pages,
+)
+from code_puppy.tools.browser.browser_interactions import (
+    register_browser_check,
+    register_browser_uncheck,
+    register_click_element,
+    register_double_click_element,
+    register_get_element_text,
+    register_get_element_value,
+    register_hover_element,
+    register_select_option,
+    register_set_element_text,
+)
+from code_puppy.tools.browser.browser_locators import (
+    register_find_buttons,
+    register_find_by_label,
+    register_find_by_placeholder,
+    register_find_by_role,
+    register_find_by_test_id,
+    register_find_by_text,
+    register_find_links,
+    register_run_xpath_query,
+)
+from code_puppy.tools.browser.browser_navigation import (
+    register_browser_go_back,
+    register_browser_go_forward,
+    register_get_page_info,
+    register_navigate_to_url,
+    register_reload_page,
+    register_wait_for_load_state,
+)
+from code_puppy.tools.browser.browser_screenshot import (
+    register_take_screenshot_and_analyze,
+)
+from code_puppy.tools.browser.browser_scripts import (
+    register_browser_clear_highlights,
+    register_browser_highlight_element,
+    register_execute_javascript,
+    register_scroll_page,
+    register_scroll_to_element,
+    register_set_viewport_size,
+    register_wait_for_element,
+)
+from code_puppy.tools.browser.browser_workflows import (
+    register_list_workflows,
+    register_read_workflow,
+    register_save_workflow,
 )
 from code_puppy.tools.command_runner import (
     register_agent_run_shell_command,
     register_agent_share_your_reasoning,
 )
-from code_puppy.tools.file_modifications import register_edit_file, register_delete_file
+from code_puppy.tools.file_modifications import register_delete_file, register_edit_file
 from code_puppy.tools.file_operations import (
+    register_grep,
     register_list_files,
     register_read_file,
-    register_grep,
 )
 
-
 # Map of tool names to their individual registration functions
 TOOL_REGISTRY = {
     # Agent Tools
@@ -30,6 +81,52 @@ TOOL_REGISTRY = {
     # Command Runner
     "agent_run_shell_command": register_agent_run_shell_command,
     "agent_share_your_reasoning": register_agent_share_your_reasoning,
+    # Browser Control
+    "browser_initialize": register_initialize_browser,
+    "browser_close": register_close_browser,
+    "browser_status": register_get_browser_status,
+    "browser_new_page": register_create_new_page,
+    "browser_list_pages": register_list_pages,
+    # Browser Navigation
+    "browser_navigate": register_navigate_to_url,
+    "browser_get_page_info": register_get_page_info,
+    "browser_go_back": register_browser_go_back,
+    "browser_go_forward": register_browser_go_forward,
+    "browser_reload": register_reload_page,
+    "browser_wait_for_load": register_wait_for_load_state,
+    # Browser Element Discovery
+    "browser_find_by_role": register_find_by_role,
+    "browser_find_by_text": register_find_by_text,
+    "browser_find_by_label": register_find_by_label,
+    "browser_find_by_placeholder": register_find_by_placeholder,
+    "browser_find_by_test_id": register_find_by_test_id,
+    "browser_xpath_query": register_run_xpath_query,
+    "browser_find_buttons": register_find_buttons,
+    "browser_find_links": register_find_links,
+    # Browser Element Interactions
+    "browser_click": register_click_element,
+    "browser_double_click": register_double_click_element,
+    "browser_hover": register_hover_element,
+    "browser_set_text": register_set_element_text,
+    "browser_get_text": register_get_element_text,
+    "browser_get_value": register_get_element_value,
+    "browser_select_option": register_select_option,
+    "browser_check": register_browser_check,
+    "browser_uncheck": register_browser_uncheck,
+    # Browser Scripts and Advanced Features
+    "browser_execute_js": register_execute_javascript,
+    "browser_scroll": register_scroll_page,
+    "browser_scroll_to_element": register_scroll_to_element,
+    "browser_set_viewport": register_set_viewport_size,
+    "browser_wait_for_element": register_wait_for_element,
+    "browser_highlight_element": register_browser_highlight_element,
+    "browser_clear_highlights": register_browser_clear_highlights,
+    # Browser Screenshots and VQA
+    "browser_screenshot_analyze": register_take_screenshot_and_analyze,
+    # Browser Workflows
+    "browser_save_workflow": register_save_workflow,
+    "browser_list_workflows": register_list_workflows,
+    "browser_read_workflow": register_read_workflow,
 }