code-puppy 0.0.169__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/http_utils.py

@@ -4,27 +4,82 @@ HTTP utilities module for code-puppy.
 This module provides functions for creating properly configured HTTP clients.
 """
 
+import asyncio
 import os
 import socket
-from typing import Dict, Optional, Union
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, Optional, Union
 
 import httpx
-import requests
-from tenacity import retry_if_exception_type, stop_after_attempt, wait_exponential
 
-try:
-    from pydantic_ai.retries import (
-        AsyncTenacityTransport,
-        RetryConfig,
-        TenacityTransport,
-        wait_retry_after,
+if TYPE_CHECKING:
+    import requests
+from code_puppy.config import get_http2
+
+
+@dataclass
+class ProxyConfig:
+    """Configuration for proxy and SSL settings."""
+
+    verify: Union[bool, str, None]
+    trust_env: bool
+    proxy_url: str | None
+    disable_retry: bool
+    http2_enabled: bool
+
+
+def _resolve_proxy_config(verify: Union[bool, str, None] = None) -> ProxyConfig:
+    """Resolve proxy, SSL, and retry settings from environment.
+
+    This centralizes the logic for detecting proxies, determining SSL verification,
+    and checking if retry transport should be disabled.
+    """
+    if verify is None:
+        verify = get_cert_bundle_path()
+
+    http2_enabled = get_http2()
+
+    disable_retry = os.environ.get(
+        "CODE_PUPPY_DISABLE_RETRY_TRANSPORT", ""
+    ).lower() in ("1", "true", "yes")
+
+    has_proxy = bool(
+        os.environ.get("HTTP_PROXY")
+        or os.environ.get("HTTPS_PROXY")
+        or os.environ.get("http_proxy")
+        or os.environ.get("https_proxy")
+    )
+
+    # Determine trust_env and verify based on proxy/retry settings
+    if disable_retry:
+        # Test mode: disable SSL verification for proxy testing
+        verify = False
+        trust_env = True
+    elif has_proxy:
+        # Production proxy: keep SSL verification enabled
+        trust_env = True
+    else:
+        trust_env = False
+
+    # Extract proxy URL
+    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 ProxyConfig(
+        verify=verify,
+        trust_env=trust_env,
+        proxy_url=proxy_url,
+        disable_retry=disable_retry,
+        http2_enabled=http2_enabled,
     )
-except ImportError:
-    # Fallback if pydantic_ai.retries is not available
-    AsyncTenacityTransport = None
-    RetryConfig = None
-    TenacityTransport = None
-    wait_retry_after = None
+
 
 try:
     from .reopenable_async_client import ReopenableAsyncClient
@@ -32,14 +87,104 @@ 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
 
-def get_cert_bundle_path() -> str:
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = await super().send(request, **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 | None:
     # First check if SSL_CERT_FILE environment variable is set
     ssl_cert_file = os.environ.get("SSL_CERT_FILE")
     if ssl_cert_file and os.path.exists(ssl_cert_file):
@@ -55,31 +200,18 @@ def create_client(
     if verify is None:
         verify = get_cert_bundle_path()
 
+    # Check if HTTP/2 is enabled in config
+    http2_enabled = get_http2()
+
     # 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}")
-                response.raise_for_status()
-
-        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)
-    else:
-        # Fallback to regular client if retry components are not available
-        return httpx.Client(verify=verify, headers=headers or {}, timeout=timeout)
+    # 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(
@@ -88,41 +220,36 @@ def create_async_client(
     headers: Optional[Dict[str, str]] = None,
     retry_status_codes: tuple = (429, 502, 503, 504),
 ) -> httpx.AsyncClient:
-    if verify is None:
-        verify = get_cert_bundle_path()
-
-    # 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}")
-                response.raise_for_status()
-
-        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
+    config = _resolve_proxy_config(verify)
+
+    if not config.disable_retry:
+        return RetryingAsyncClient(
+            retry_status_codes=retry_status_codes,
+            proxy=config.proxy_url,
+            verify=config.verify,
+            headers=headers or {},
+            timeout=timeout,
+            http2=config.http2_enabled,
+            trust_env=config.trust_env,
         )
-        
-        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)
+        return httpx.AsyncClient(
+            proxy=config.proxy_url,
+            verify=config.verify,
+            headers=headers or {},
+            timeout=timeout,
+            http2=config.http2_enabled,
+            trust_env=config.trust_env,
+        )
 
 
 def create_requests_session(
     timeout: float = 5.0,
     verify: Union[bool, str] = None,
     headers: Optional[Dict[str, str]] = None,
-) -> requests.Session:
+) -> "requests.Session":
+    import requests
+
     session = requests.Session()
 
     if verify is None:
@@ -164,50 +291,39 @@ def create_reopenable_async_client(
     headers: Optional[Dict[str, str]] = None,
     retry_status_codes: tuple = (429, 502, 503, 504),
 ) -> Union[ReopenableAsyncClient, httpx.AsyncClient]:
-    if verify is None:
-        verify = get_cert_bundle_path()
-
-    # 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}")
-                response.raise_for_status()
-
-        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
+    config = _resolve_proxy_config(verify)
+
+    base_kwargs = {
+        "proxy": config.proxy_url,
+        "verify": config.verify,
+        "headers": headers or {},
+        "timeout": timeout,
+        "http2": config.http2_enabled,
+        "trust_env": config.trust_env,
+    }
+
+    if ReopenableAsyncClient is not None:
+        client_class = (
+            RetryingAsyncClient if not config.disable_retry else httpx.AsyncClient
         )
-        
-        if ReopenableAsyncClient is not None:
-            return ReopenableAsyncClient(
-                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)
+        kwargs = {**base_kwargs, "client_class": client_class}
+        if not config.disable_retry:
+            kwargs["retry_status_codes"] = retry_status_codes
+        return ReopenableAsyncClient(**kwargs)
     else:
-        # Fallback to regular clients if retry components are not available
-        if ReopenableAsyncClient is not None:
-            return ReopenableAsyncClient(
-                verify=verify, headers=headers or {}, timeout=timeout
+        # Fallback to RetryingAsyncClient or plain AsyncClient
+        if not config.disable_retry:
+            return RetryingAsyncClient(
+                retry_status_codes=retry_status_codes, **base_kwargs
             )
         else:
-            # Fallback to regular AsyncClient if ReopenableAsyncClient is not available
-            return httpx.AsyncClient(verify=verify, headers=headers or {}, timeout=timeout)
+            return httpx.AsyncClient(**base_kwargs)
 
 
 def is_cert_bundle_available() -> bool:
     cert_path = get_cert_bundle_path()
+    if cert_path is None:
+        return False
     return os.path.exists(cert_path) and os.path.isfile(cert_path)
 
 

code_puppy/keymap.py

@@ -0,0 +1,128 @@
+"""Keymap configuration for code-puppy.
+
+This module handles configurable keyboard shortcuts, starting with the
+cancel_agent_key feature that allows users to override Ctrl+C with a
+different key for cancelling agent tasks.
+"""
+
+# Character codes for Ctrl+letter combinations (Ctrl+A = 0x01, Ctrl+Z = 0x1A)
+KEY_CODES: dict[str, str] = {
+    "ctrl+a": "\x01",
+    "ctrl+b": "\x02",
+    "ctrl+c": "\x03",
+    "ctrl+d": "\x04",
+    "ctrl+e": "\x05",
+    "ctrl+f": "\x06",
+    "ctrl+g": "\x07",
+    "ctrl+h": "\x08",
+    "ctrl+i": "\x09",
+    "ctrl+j": "\x0a",
+    "ctrl+k": "\x0b",
+    "ctrl+l": "\x0c",
+    "ctrl+m": "\x0d",
+    "ctrl+n": "\x0e",
+    "ctrl+o": "\x0f",
+    "ctrl+p": "\x10",
+    "ctrl+q": "\x11",
+    "ctrl+r": "\x12",
+    "ctrl+s": "\x13",
+    "ctrl+t": "\x14",
+    "ctrl+u": "\x15",
+    "ctrl+v": "\x16",
+    "ctrl+w": "\x17",
+    "ctrl+x": "\x18",
+    "ctrl+y": "\x19",
+    "ctrl+z": "\x1a",
+    "escape": "\x1b",
+}
+
+# Valid keys for cancel_agent_key configuration
+# NOTE: "escape" is excluded because it conflicts with ANSI escape sequences
+# (arrow keys, F-keys, etc. all start with \x1b)
+VALID_CANCEL_KEYS: set[str] = {
+    "ctrl+c",
+    "ctrl+k",
+    "ctrl+q",
+}
+
+DEFAULT_CANCEL_AGENT_KEY: str = "ctrl+c"
+
+
+class KeymapError(Exception):
+    """Exception raised for keymap configuration errors."""
+
+
+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() == "":
+        return DEFAULT_CANCEL_AGENT_KEY
+    return key.strip().lower()
+
+
+def validate_cancel_agent_key() -> None:
+    """Validate the configured cancel agent key.
+
+    Raises:
+        KeymapError: If the configured key is invalid.
+    """
+    key = get_cancel_agent_key()
+    if key not in VALID_CANCEL_KEYS:
+        valid_keys_str = ", ".join(sorted(VALID_CANCEL_KEYS))
+        raise KeymapError(
+            f"Invalid cancel_agent_key '{key}' in puppy.cfg. "
+            f"Valid options are: {valid_keys_str}"
+        )
+
+
+def cancel_agent_uses_signal() -> bool:
+    """Check if the cancel agent key uses SIGINT (Ctrl+C).
+
+    Returns:
+        True if the cancel key is ctrl+c (uses SIGINT handler),
+        False if it uses keyboard listener approach.
+    """
+    return get_cancel_agent_key() == "ctrl+c"
+
+
+def get_cancel_agent_char_code() -> str:
+    """Get the character code for the cancel agent key.
+
+    Returns:
+        The character code (e.g., "\x0b" for ctrl+k).
+
+    Raises:
+        KeymapError: If the key is not found in KEY_CODES.
+    """
+    key = get_cancel_agent_key()
+    if key not in KEY_CODES:
+        raise KeymapError(f"Unknown key '{key}' - no character code mapping found.")
+    return KEY_CODES[key]
+
+
+def get_cancel_agent_display_name() -> str:
+    """Get a human-readable display name for the cancel agent key.
+
+    Returns:
+        A formatted display name like "Ctrl+K".
+    """
+    key = get_cancel_agent_key()
+    if key.startswith("ctrl+"):
+        letter = key.split("+")[1].upper()
+        return f"Ctrl+{letter}"
+    return key.upper()