code-puppy 0.0.302__py3-none-any.whl → 0.0.335__py3-none-any.whl

code_puppy/config.py

@@ -53,6 +53,7 @@ _DEFAULT_SQLITE_FILE = os.path.join(DATA_DIR, "dbos_store.sqlite")
 GEMINI_MODELS_FILE = os.path.join(DATA_DIR, "gemini_models.json")
 CHATGPT_MODELS_FILE = os.path.join(DATA_DIR, "chatgpt_models.json")
 CLAUDE_MODELS_FILE = os.path.join(DATA_DIR, "claude_models.json")
+ANTIGRAVITY_MODELS_FILE = os.path.join(DATA_DIR, "antigravity_models.json")
 
 # Cache files (XDG_CACHE_HOME)
 AUTOSAVE_DIR = os.path.join(CACHE_DIR, "autosaves")
@@ -212,6 +213,9 @@ def get_config_keys():
     default_keys.append("enable_dbos")
     # Add cancel agent key configuration
     default_keys.append("cancel_agent_key")
+    # Add banner color keys
+    for banner_name in DEFAULT_BANNER_COLORS:
+        default_keys.append(f"banner_color_{banner_name}")
 
     config = configparser.ConfigParser()
     config.read(CONFIG_FILE)
@@ -256,9 +260,8 @@ def load_mcp_server_configs():
 def _default_model_from_models_json():
     """Load the default model name from models.json.
 
-    Prefers synthetic-GLM-4.6 as the default model.
-    Falls back to the first model in models.json if synthetic-GLM-4.6 is not available.
-    As a last resort, falls back to ``gpt-5`` if the file cannot be read.
+    Returns the first model in models.json as the default.
+    Falls back to ``gpt-5`` if the file cannot be read.
     """
     global _default_model_cache
 
@@ -270,11 +273,7 @@ def _default_model_from_models_json():
 
         models_config = ModelFactory.load_config()
         if models_config:
-            # Prefer synthetic-GLM-4.6 as default
-            if "synthetic-GLM-4.6" in models_config:
-                _default_model_cache = "synthetic-GLM-4.6"
-                return "synthetic-GLM-4.6"
-            # Fall back to first model if synthetic-GLM-4.6 is not available
+            # Use first model in models.json as default
             first_key = next(iter(models_config))
             _default_model_cache = first_key
             return first_key
@@ -497,8 +496,8 @@ def set_puppy_token(token: str):
 
 
 def get_openai_reasoning_effort() -> str:
-    """Return the configured OpenAI reasoning effort (low, medium, high)."""
-    allowed_values = {"low", "medium", "high"}
+    """Return the configured OpenAI reasoning effort (minimal, low, medium, high, xhigh)."""
+    allowed_values = {"minimal", "low", "medium", "high", "xhigh"}
     configured = (get_value("openai_reasoning_effort") or "medium").strip().lower()
     if configured not in allowed_values:
         return "medium"
@@ -507,7 +506,7 @@ def get_openai_reasoning_effort() -> str:
 
 def set_openai_reasoning_effort(value: str) -> None:
     """Persist the OpenAI reasoning effort ensuring it remains within allowed values."""
-    allowed_values = {"low", "medium", "high"}
+    allowed_values = {"minimal", "low", "medium", "high", "xhigh"}
     normalized = (value or "").strip().lower()
     if normalized not in allowed_values:
         raise ValueError(
@@ -658,10 +657,22 @@ def get_all_model_settings(model_name: str) -> dict:
         for key, val in config[DEFAULT_SECTION].items():
             if key.startswith(prefix) and val.strip():
                 setting_name = key[len(prefix) :]
-                try:
-                    settings[setting_name] = float(val)
-                except (ValueError, TypeError):
-                    pass
+                # Handle different value types
+                val_stripped = val.strip()
+                # Check for boolean values first
+                if val_stripped.lower() in ("true", "false"):
+                    settings[setting_name] = val_stripped.lower() == "true"
+                else:
+                    # Try to parse as number (int first, then float)
+                    try:
+                        # Try int first for cleaner values like budget_tokens
+                        if "." not in val_stripped:
+                            settings[setting_name] = int(val_stripped)
+                        else:
+                            settings[setting_name] = float(val_stripped)
+                    except (ValueError, TypeError):
+                        # Keep as string if not a number
+                        settings[setting_name] = val_stripped
 
     return settings
 
@@ -1041,11 +1052,11 @@ def set_enable_dbos(enabled: bool) -> None:
     set_config_value("enable_dbos", "true" if enabled else "false")
 
 
-def get_message_limit(default: int = 100) -> int:
+def get_message_limit(default: int = 1000) -> int:
     """
     Returns the user-configured message/request limit for the agent.
     This controls how many steps/requests the agent can take.
-    Defaults to 100 if unset or misconfigured.
+    Defaults to 1000 if unset or misconfigured.
     Configurable by 'message_limit' key.
     """
     val = get_value("message_limit")
@@ -1257,6 +1268,84 @@ def set_diff_deletion_color(color: str):
     set_config_value("highlight_deletion_color", color)
 
 
+# =============================================================================
+# Banner Color Configuration
+# =============================================================================
+
+# Default banner colors (Rich color names)
+# A beautiful jewel-tone palette with semantic meaning:
+#   - Blues/Teals: Reading & navigation (calm, informational)
+#   - Warm tones: Actions & changes (edits, shell commands)
+#   - Purples: AI thinking & reasoning (the "brain" colors)
+#   - Greens: Completions & success
+#   - Neutrals: Search & listings
+DEFAULT_BANNER_COLORS = {
+    "thinking": "deep_sky_blue4",  # Sapphire - contemplation
+    "agent_response": "medium_purple4",  # Amethyst - main AI output
+    "shell_command": "dark_orange3",  # Amber - system commands
+    "read_file": "steel_blue",  # Steel - reading files
+    "edit_file": "dark_goldenrod",  # Gold - modifications
+    "grep": "grey37",  # Silver - search results
+    "directory_listing": "dodger_blue2",  # Sky - navigation
+    "agent_reasoning": "dark_violet",  # Violet - deep thought
+    "invoke_agent": "deep_pink4",  # Ruby - agent invocation
+    "subagent_response": "sea_green3",  # Emerald - sub-agent success
+    "list_agents": "dark_slate_gray3",  # Slate - neutral listing
+}
+
+
+def get_banner_color(banner_name: str) -> str:
+    """Get the background color for a specific banner.
+
+    Args:
+        banner_name: The banner identifier (e.g., 'thinking', 'agent_response')
+
+    Returns:
+        Rich color name or hex code for the banner background
+    """
+    config_key = f"banner_color_{banner_name}"
+    val = get_value(config_key)
+    if val:
+        return val
+    return DEFAULT_BANNER_COLORS.get(banner_name, "blue")
+
+
+def set_banner_color(banner_name: str, color: str):
+    """Set the background color for a specific banner.
+
+    Args:
+        banner_name: The banner identifier (e.g., 'thinking', 'agent_response')
+        color: Rich color name or hex code
+    """
+    config_key = f"banner_color_{banner_name}"
+    set_config_value(config_key, color)
+
+
+def get_all_banner_colors() -> dict:
+    """Get all banner colors (configured or default).
+
+    Returns:
+        Dict mapping banner names to their colors
+    """
+    return {name: get_banner_color(name) for name in DEFAULT_BANNER_COLORS}
+
+
+def reset_banner_color(banner_name: str):
+    """Reset a banner color to its default.
+
+    Args:
+        banner_name: The banner identifier to reset
+    """
+    default_color = DEFAULT_BANNER_COLORS.get(banner_name, "blue")
+    set_banner_color(banner_name, default_color)
+
+
+def reset_all_banner_colors():
+    """Reset all banner colors to their defaults."""
+    for name, color in DEFAULT_BANNER_COLORS.items():
+        set_banner_color(name, color)
+
+
 def get_current_autosave_id() -> str:
     """Get or create the current autosave session ID for this process."""
     global _CURRENT_AUTOSAVE_ID

code_puppy/http_utils.py

@@ -4,29 +4,19 @@ HTTP utilities module for code-puppy.
 This module provides functions for creating properly configured HTTP clients.
 """
 
+import asyncio
+import logging
 import os
 import socket
-from typing import Dict, Optional, Union
+import time
+from typing import Any, Dict, Optional, Union
 
 import httpx
 import requests
-from tenacity import stop_after_attempt, wait_exponential
 
 from code_puppy.config import get_http2
 
-try:
-    from pydantic_ai.retries import (
-        AsyncTenacityTransport,
-        RetryConfig,
-        TenacityTransport,
-        wait_retry_after,
-    )
-except ImportError:
-    # Fallback if pydantic_ai.retries is not available
-    AsyncTenacityTransport = None
-    RetryConfig = None
-    TenacityTransport = None
-    wait_retry_after = None
+logger = logging.getLogger(__name__)
 
 try:
     from .reopenable_async_client import ReopenableAsyncClient
@@ -34,12 +24,109 @@ except ImportError:
     ReopenableAsyncClient = None
 
 try:
-    from .messaging import emit_info
+    from .messaging import emit_info, emit_warning
 except ImportError:
     # Fallback if messaging system is not available
     def emit_info(content: str, **metadata):
         pass  # No-op if messaging system is not available
 
+    def emit_warning(content: str, **metadata):
+        pass
+
+
+class RetryingAsyncClient(httpx.AsyncClient):
+    """AsyncClient with built-in rate limit handling (429) and retries.
+
+    This replaces the Tenacity transport with a more direct subclass implementation,
+    which plays nicer with proxies and custom transports (like Antigravity).
+    """
+
+    def __init__(
+        self,
+        retry_status_codes: tuple = (429, 502, 503, 504),
+        max_retries: int = 5,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.retry_status_codes = retry_status_codes
+        self.max_retries = max_retries
+
+    async def send(self, request: httpx.Request, **kwargs: Any) -> httpx.Response:
+        """Send request with automatic retries for rate limits and server errors."""
+        last_response = None
+        last_exception = None
+
+        for attempt in range(self.max_retries + 1):
+            try:
+                # Clone request for retry (streams might be consumed)
+                # But only if it's not the first attempt
+                req_to_send = request
+                if attempt > 0:
+                    # httpx requests are reusable, but we need to be careful with streams
+                    pass
+
+                response = await super().send(req_to_send, **kwargs)
+                last_response = response
+
+                # Check for retryable status
+                if response.status_code not in self.retry_status_codes:
+                    return response
+
+                # Close response if we're going to retry
+                await response.aclose()
+
+                # Determine wait time
+                wait_time = 1.0 * (
+                    2**attempt
+                )  # Default exponential backoff: 1s, 2s, 4s...
+
+                # Check Retry-After header
+                retry_after = response.headers.get("Retry-After")
+                if retry_after:
+                    try:
+                        wait_time = float(retry_after)
+                    except ValueError:
+                        # Try parsing http-date
+                        from email.utils import parsedate_to_datetime
+
+                        try:
+                            date = parsedate_to_datetime(retry_after)
+                            wait_time = date.timestamp() - time.time()
+                        except Exception:
+                            pass
+
+                # Cap wait time
+                wait_time = max(0.5, min(wait_time, 60.0))
+
+                if attempt < self.max_retries:
+                    emit_info(
+                        f"HTTP retry: {response.status_code} received. Waiting {wait_time:.1f}s (attempt {attempt + 1}/{self.max_retries})"
+                    )
+                    await asyncio.sleep(wait_time)
+
+            except (httpx.ConnectError, httpx.ReadTimeout, httpx.PoolTimeout) as e:
+                last_exception = e
+                wait_time = 1.0 * (2**attempt)
+                if attempt < self.max_retries:
+                    emit_warning(
+                        f"HTTP connection error: {e}. Retrying in {wait_time}s..."
+                    )
+                    await asyncio.sleep(wait_time)
+                else:
+                    raise
+            except Exception:
+                raise
+
+        # Return last response (even if it's an error status)
+        if last_response:
+            return last_response
+
+        # Should catch this in loop, but just in case
+        if last_exception:
+            raise last_exception
+
+        return last_response
+
 
 def get_cert_bundle_path() -> str:
     # First check if SSL_CERT_FILE environment variable is set
@@ -60,53 +147,15 @@ def create_client(
     # Check if HTTP/2 is enabled in config
     http2_enabled = get_http2()
 
-    # Check if custom retry transport should be disabled (e.g., for integration tests with proxies)
-    disable_retry_transport = os.environ.get(
-        "CODE_PUPPY_DISABLE_RETRY_TRANSPORT", ""
-    ).lower() in ("1", "true", "yes")
-
     # If retry components are available, create a client with retry transport
-    if (
-        TenacityTransport
-        and RetryConfig
-        and wait_retry_after
-        and not disable_retry_transport
-    ):
-
-        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}"
-                )
-                return True
-
-        transport = TenacityTransport(
-            config=RetryConfig(
-                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,
-                ),
-                stop=stop_after_attempt(10),
-                reraise=True,
-            ),
-            validate_response=should_retry_status,
-        )
-
-        return httpx.Client(
-            transport=transport,
-            verify=verify,
-            headers=headers or {},
-            timeout=timeout,
-            http2=http2_enabled,
-        )
-    else:
-        # Fallback to regular client if retry components are not available
-        return httpx.Client(
-            verify=verify, headers=headers or {}, timeout=timeout, http2=http2_enabled
-        )
+    # Note: TenacityTransport was removed. For now we just return a standard client.
+    # Future TODO: Implement RetryingClient(httpx.Client) if needed.
+    return httpx.Client(
+        verify=verify,
+        headers=headers or {},
+        timeout=timeout,
+        http2=http2_enabled,
+    )
 
 
 def create_async_client(
@@ -145,52 +194,21 @@ def create_async_client(
     else:
         trust_env = False
 
-    # If retry components are available, create a client with retry transport
-    # BUT: disable retry transport when proxies are detected because custom transports
-    # don't play nicely with proxy configuration
-    if (
-        AsyncTenacityTransport
-        and RetryConfig
-        and wait_retry_after
-        and not disable_retry_transport
-        and not has_proxy
-    ):
-
-        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}"
-                )
-                return True
-
-        # Create transport (with or without proxy base)
-        if has_proxy:
-            # Extract proxy URL from environment
-            proxy_url = (
-                os.environ.get("HTTPS_PROXY")
-                or os.environ.get("https_proxy")
-                or os.environ.get("HTTP_PROXY")
-                or os.environ.get("http_proxy")
-            )
-        else:
-            proxy_url = None
-
-        # Create retry transport wrapper
-        transport = AsyncTenacityTransport(
-            config=RetryConfig(
-                retry=lambda e: isinstance(e, httpx.HTTPStatusError)
-                and e.response.status_code in retry_status_codes,
-                wait=wait_retry_after(10),
-                stop=stop_after_attempt(10),
-                reraise=True,
-            ),
-            validate_response=should_retry_status,
+    # Extract proxy URL if needed
+    proxy_url = None
+    if has_proxy:
+        proxy_url = (
+            os.environ.get("HTTPS_PROXY")
+            or os.environ.get("https_proxy")
+            or os.environ.get("HTTP_PROXY")
+            or os.environ.get("http_proxy")
         )
 
-        return httpx.AsyncClient(
-            transport=transport,
-            proxy=proxy_url,  # Pass proxy to client, not transport
+    # Use RetryingAsyncClient if retries are enabled
+    if not disable_retry_transport:
+        return RetryingAsyncClient(
+            retry_status_codes=retry_status_codes,
+            proxy=proxy_url,
             verify=verify,
             headers=headers or {},
             timeout=timeout,
@@ -198,19 +216,7 @@ def create_async_client(
             trust_env=trust_env,
         )
     else:
-        # Fallback to regular client if retry components are not available,
-        # when retry transport is explicitly disabled, or when proxies are detected
-        # Extract proxy URL if needed
-        if has_proxy:
-            proxy_url = (
-                os.environ.get("HTTPS_PROXY")
-                or os.environ.get("https_proxy")
-                or os.environ.get("HTTP_PROXY")
-                or os.environ.get("http_proxy")
-            )
-        else:
-            proxy_url = None
-
+        # Regular client for testing
         return httpx.AsyncClient(
             proxy=proxy_url,
             verify=verify,
@@ -295,87 +301,41 @@ def create_reopenable_async_client(
     else:
         trust_env = False
 
-    # If retry components are available, create a client with retry transport
-    # BUT: disable retry transport when proxies are detected because custom transports
-    # don't play nicely with proxy configuration
-    if (
-        AsyncTenacityTransport
-        and RetryConfig
-        and wait_retry_after
-        and not disable_retry_transport
-        and not has_proxy
-    ):
+    # Extract proxy URL if needed
+    proxy_url = None
+    if has_proxy:
+        proxy_url = (
+            os.environ.get("HTTPS_PROXY")
+            or os.environ.get("https_proxy")
+            or os.environ.get("HTTP_PROXY")
+            or os.environ.get("http_proxy")
+        )
 
-        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}"
-                )
-                return True
-
-        transport = AsyncTenacityTransport(
-            config=RetryConfig(
-                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,
-                ),
-                stop=stop_after_attempt(10),
-                reraise=True,
-            ),
-            validate_response=should_retry_status,
+    if ReopenableAsyncClient is not None:
+        # Use RetryingAsyncClient if retries are enabled
+        client_class = (
+            RetryingAsyncClient if not disable_retry_transport else httpx.AsyncClient
         )
 
-        # Extract proxy URL if needed
-        if has_proxy:
-            proxy_url = (
-                os.environ.get("HTTPS_PROXY")
-                or os.environ.get("https_proxy")
-                or os.environ.get("HTTP_PROXY")
-                or os.environ.get("http_proxy")
-            )
-        else:
-            proxy_url = None
+        # Pass retry config only if using RetryingAsyncClient
+        kwargs = {
+            "proxy": proxy_url,
+            "verify": verify,
+            "headers": headers or {},
+            "timeout": timeout,
+            "http2": http2_enabled,
+            "trust_env": trust_env,
+        }
 
-        if ReopenableAsyncClient is not None:
-            return ReopenableAsyncClient(
-                transport=transport,
-                proxy=proxy_url,
-                verify=verify,
-                headers=headers or {},
-                timeout=timeout,
-                http2=http2_enabled,
-                trust_env=trust_env,
-            )
-        else:
-            # Fallback to regular AsyncClient if ReopenableAsyncClient is not available
-            return httpx.AsyncClient(
-                transport=transport,
-                proxy=proxy_url,
-                verify=verify,
-                headers=headers or {},
-                timeout=timeout,
-                http2=http2_enabled,
-                trust_env=trust_env,
-            )
-    else:
-        # Fallback to regular clients if retry components are not available
-        # or when proxies are detected
-        # Extract proxy URL if needed
-        if has_proxy:
-            proxy_url = (
-                os.environ.get("HTTPS_PROXY")
-                or os.environ.get("https_proxy")
-                or os.environ.get("HTTP_PROXY")
-                or os.environ.get("http_proxy")
-            )
-        else:
-            proxy_url = None
+        if not disable_retry_transport:
+            kwargs["retry_status_codes"] = retry_status_codes
 
-        if ReopenableAsyncClient is not None:
-            return ReopenableAsyncClient(
+        return ReopenableAsyncClient(client_class=client_class, **kwargs)
+    else:
+        # Fallback to RetryingAsyncClient
+        if not disable_retry_transport:
+            return RetryingAsyncClient(
+                retry_status_codes=retry_status_codes,
                 proxy=proxy_url,
                 verify=verify,
                 headers=headers or {},
@@ -384,7 +344,6 @@ def create_reopenable_async_client(
                 trust_env=trust_env,
             )
         else:
-            # Fallback to regular AsyncClient if ReopenableAsyncClient is not available
             return httpx.AsyncClient(
                 proxy=proxy_url,
                 verify=verify,

code_puppy/keymap.py

@@ -55,11 +55,19 @@ class KeymapError(Exception):
 def get_cancel_agent_key() -> str:
     """Get the configured cancel agent key from config.
 
+    On Windows when launched via uvx, this automatically returns "ctrl+k"
+    to work around uvx capturing Ctrl+C before it reaches Python.
+
     Returns:
         The key name (e.g., "ctrl+c", "ctrl+k") from config,
         or the default if not configured.
     """
     from code_puppy.config import get_value
+    from code_puppy.uvx_detection import should_use_alternate_cancel_key
+
+    # On Windows + uvx, force ctrl+k to bypass uvx's SIGINT capture
+    if should_use_alternate_cancel_key():
+        return "ctrl+k"
 
     key = get_value("cancel_agent_key")
     if key is None or key.strip() == "":