code-puppy 0.0.378__tar.gz → 0.0.380__tar.gz

{code_puppy-0.0.378 → code_puppy-0.0.380}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.378
+Version: 0.0.380
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.378 → code_puppy-0.0.380}/code_puppy/agents/base_agent.py

@@ -3,8 +3,11 @@
 import asyncio
 import json
 import math
+import pathlib
 import signal
 import threading
+import time
+import traceback
 import uuid
 from abc import ABC, abstractmethod
 from typing import (
@@ -37,6 +40,7 @@ from pydantic_ai.durable_exec.dbos import DBOSAgent
 from pydantic_ai.messages import (
     ModelMessage,
     ModelRequest,
+    ModelResponse,
     TextPart,
     ThinkingPart,
     ToolCallPart,
@@ -88,6 +92,49 @@ _delayed_compaction_requested = False
 _reload_count = 0
 
 
+def _log_error_to_file(exc: Exception) -> Optional[str]:
+    """Log detailed error information to ~/.code_puppy/error_logs/log_{timestamp}.txt.
+
+    Args:
+        exc: The exception to log.
+
+    Returns:
+        The path to the log file if successful, None otherwise.
+    """
+    try:
+        error_logs_dir = pathlib.Path.home() / ".code_puppy" / "error_logs"
+        error_logs_dir.mkdir(parents=True, exist_ok=True)
+
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        log_file = error_logs_dir / f"log_{timestamp}.txt"
+
+        with open(log_file, "w", encoding="utf-8") as f:
+            f.write(f"Timestamp: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write(f"Exception Type: {type(exc).__name__}\n")
+            f.write(f"Exception Message: {str(exc)}\n")
+            f.write(f"Exception Args: {exc.args}\n")
+            f.write("\n--- Full Traceback ---\n")
+            f.write(traceback.format_exc())
+            f.write("\n--- Exception Chain ---\n")
+            # Walk the exception chain for chained exceptions
+            current = exc
+            chain_depth = 0
+            while current is not None and chain_depth < 10:
+                f.write(
+                    f"\n[Cause {chain_depth}] {type(current).__name__}: {current}\n"
+                )
+                f.write("".join(traceback.format_tb(current.__traceback__)))
+                current = (
+                    current.__cause__ if current.__cause__ else current.__context__
+                )
+                chain_depth += 1
+
+        return str(log_file)
+    except Exception:
+        # Don't let logging errors break the main flow
+        return None
+
+
 class BaseAgent(ABC):
     """Base class for all agent configurations."""
 
@@ -264,6 +311,33 @@ class BaseAgent(ABC):
             cleaned.append(message)
         return cleaned
 
+    def ensure_history_ends_with_request(
+        self, messages: List[ModelMessage]
+    ) -> List[ModelMessage]:
+        """Ensure message history ends with a ModelRequest.
+
+        pydantic_ai requires that processed message history ends with a ModelRequest.
+        This can fail when swapping models mid-conversation if the history ends with
+        a ModelResponse from the previous model.
+
+        This method trims trailing ModelResponse messages to ensure compatibility.
+
+        Args:
+            messages: List of messages to validate/fix.
+
+        Returns:
+            List of messages guaranteed to end with ModelRequest, or empty list
+            if no ModelRequest is found.
+        """
+        if not messages:
+            return messages
+
+        # Trim trailing ModelResponse messages
+        while messages and isinstance(messages[-1], ModelResponse):
+            messages = messages[:-1]
+
+        return messages
+
     # Message history processing methods (moved from state_management.py and message_history_processor.py)
     def _stringify_part(self, part: Any) -> str:
         """Create a stable string representation for a message part.
@@ -372,10 +446,10 @@ class BaseAgent(ABC):
 
     def estimate_token_count(self, text: str) -> int:
         """
-        Simple token estimation using len(message) / 3.
+        Simple token estimation using len(message) / 2.5.
         This replaces tiktoken with a much simpler approach.
         """
-        return max(1, math.floor((len(text) / 3)))
+        return max(1, math.floor((len(text) / 2.5)))
 
     def estimate_tokens_for_message(self, message: ModelMessage) -> int:
         """

{code_puppy-0.0.378 → code_puppy-0.0.380}/code_puppy/callbacks.py

@@ -27,6 +27,7 @@ PhaseType = Literal[
     "get_model_system_prompt",
     "agent_run_start",
     "agent_run_end",
+    "register_mcp_catalog_servers",
 ]
 CallbackFunc = Callable[..., Any]
 
@@ -54,6 +55,7 @@ _callbacks: Dict[PhaseType, List[CallbackFunc]] = {
     "get_model_system_prompt": [],
     "agent_run_start": [],
     "agent_run_end": [],
+    "register_mcp_catalog_servers": [],
 }
 
 logger = logging.getLogger(__name__)
@@ -517,3 +519,15 @@ async def on_agent_run_end(
         response_text,
         metadata,
     )
+
+
+def on_register_mcp_catalog_servers() -> List[Any]:
+    """Trigger callbacks to register additional MCP catalog servers.
+
+    Plugins can register callbacks that return List[MCPServerTemplate] to add
+    servers to the MCP catalog/marketplace.
+
+    Returns:
+        List of results from all registered callbacks (each should be a list of MCPServerTemplate).
+    """
+    return _trigger_callbacks_sync("register_mcp_catalog_servers")

{code_puppy-0.0.378 → code_puppy-0.0.380}/code_puppy/config.py

@@ -144,6 +144,19 @@ def set_universal_constructor_enabled(enabled: bool) -> None:
     set_value("enable_universal_constructor", "true" if enabled else "false")
 
 
+def get_enable_streaming() -> bool:
+    """
+    Get the enable_streaming configuration value.
+    Controls whether streaming (SSE) is used for model responses.
+    Returns True if streaming is enabled, False otherwise.
+    Defaults to True.
+    """
+    val = get_value("enable_streaming")
+    if val is None:
+        return True  # Default to True for better UX
+    return str(val).lower() in ("1", "true", "yes", "on")
+
+
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
 
@@ -289,6 +302,8 @@ def get_config_keys():
     default_keys.append("enable_pack_agents")
     # Add universal constructor control key
     default_keys.append("enable_universal_constructor")
+    # Add streaming control key
+    default_keys.append("enable_streaming")
     # Add cancel agent key configuration
     default_keys.append("cancel_agent_key")
     # Add banner color keys

{code_puppy-0.0.378 → code_puppy-0.0.380}/code_puppy/http_utils.py

@@ -102,17 +102,24 @@ class RetryingAsyncClient(httpx.AsyncClient):
 
     This replaces the Tenacity transport with a more direct subclass implementation,
     which plays nicer with proxies and custom transports (like Antigravity).
+
+    Special handling for Cerebras: Their Retry-After headers are absurdly aggressive
+    (often 60s), so we ignore them and use a 3s base backoff instead.
     """
 
     def __init__(
         self,
         retry_status_codes: tuple = (429, 502, 503, 504),
         max_retries: int = 5,
+        model_name: str = "",
         **kwargs,
     ):
         super().__init__(**kwargs)
         self.retry_status_codes = retry_status_codes
         self.max_retries = max_retries
+        self.model_name = model_name.lower() if model_name else ""
+        # Cerebras sends crazy aggressive Retry-After headers (60s), ignore them
+        self._ignore_retry_headers = "cerebras" in self.model_name
 
     async def send(self, request: httpx.Request, **kwargs: Any) -> httpx.Response:
         """Send request with automatic retries for rate limits and server errors."""
@@ -131,32 +138,39 @@ class RetryingAsyncClient(httpx.AsyncClient):
                 # 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
+                # Determine wait time - Cerebras gets special treatment
+                if self._ignore_retry_headers:
+                    # Cerebras: 3s base with exponential backoff (3s, 6s, 12s...)
+                    wait_time = 3.0 * (2**attempt)
+                else:
+                    # Default exponential backoff: 1s, 2s, 4s...
+                    wait_time = 1.0 * (2**attempt)
 
+                    # Check Retry-After header (only for non-Cerebras)
+                    retry_after = response.headers.get("Retry-After")
+                    if retry_after:
                         try:
-                            date = parsedate_to_datetime(retry_after)
-                            wait_time = date.timestamp() - time.time()
-                        except Exception:
-                            pass
+                            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:
+                    provider_note = (
+                        " (ignoring header)" if self._ignore_retry_headers else ""
+                    )
                     emit_info(
-                        f"HTTP retry: {response.status_code} received. Waiting {wait_time:.1f}s (attempt {attempt + 1}/{self.max_retries})"
+                        f"HTTP retry: {response.status_code} received{provider_note}. "
+                        f"Waiting {wait_time:.1f}s (attempt {attempt + 1}/{self.max_retries})"
                     )
                     await asyncio.sleep(wait_time)
 
@@ -219,12 +233,14 @@ def create_async_client(
     verify: Union[bool, str] = None,
     headers: Optional[Dict[str, str]] = None,
     retry_status_codes: tuple = (429, 502, 503, 504),
+    model_name: str = "",
 ) -> httpx.AsyncClient:
     config = _resolve_proxy_config(verify)
 
     if not config.disable_retry:
         return RetryingAsyncClient(
             retry_status_codes=retry_status_codes,
+            model_name=model_name,
             proxy=config.proxy_url,
             verify=config.verify,
             headers=headers or {},
@@ -290,6 +306,7 @@ def create_reopenable_async_client(
     verify: Union[bool, str] = None,
     headers: Optional[Dict[str, str]] = None,
     retry_status_codes: tuple = (429, 502, 503, 504),
+    model_name: str = "",
 ) -> Union[ReopenableAsyncClient, httpx.AsyncClient]:
     config = _resolve_proxy_config(verify)
 
@@ -309,12 +326,15 @@ def create_reopenable_async_client(
         kwargs = {**base_kwargs, "client_class": client_class}
         if not config.disable_retry:
             kwargs["retry_status_codes"] = retry_status_codes
+            kwargs["model_name"] = model_name
         return ReopenableAsyncClient(**kwargs)
     else:
         # Fallback to RetryingAsyncClient or plain AsyncClient
         if not config.disable_retry:
             return RetryingAsyncClient(
-                retry_status_codes=retry_status_codes, **base_kwargs
+                retry_status_codes=retry_status_codes,
+                model_name=model_name,
+                **base_kwargs,
             )
         else:
             return httpx.AsyncClient(**base_kwargs)

{code_puppy-0.0.378 → code_puppy-0.0.380}/code_puppy/mcp_/server_registry_catalog.py

@@ -1025,7 +1025,20 @@ class MCPServerCatalog:
     """Catalog for searching and managing pre-configured MCP servers."""
 
     def __init__(self):
-        self.servers = MCP_SERVER_REGISTRY
+        # Start with built-in servers
+        self.servers = list(MCP_SERVER_REGISTRY)
+
+        # Let plugins add their own catalog entries
+        try:
+            from code_puppy.callbacks import on_register_mcp_catalog_servers
+
+            plugin_results = on_register_mcp_catalog_servers()
+            for result in plugin_results:
+                if isinstance(result, list):
+                    self.servers.extend(result)
+        except Exception:
+            pass  # Don't break catalog if plugins fail
+
         self._build_index()
 
     def _build_index(self):

{code_puppy-0.0.378 → code_puppy-0.0.380}/code_puppy/model_factory.py

@@ -585,7 +585,12 @@ class ModelFactory:
                 return None
             # Add Cerebras 3rd party integration header
             headers["X-Cerebras-3rd-Party-Integration"] = "code-puppy"
-            client = create_async_client(headers=headers, verify=verify)
+            # Pass "cerebras" so RetryingAsyncClient knows to ignore Cerebras's
+            # absurdly aggressive Retry-After headers (they send 60s!)
+            # Note: model_config["name"] is "zai-glm-4.7", not "cerebras"
+            client = create_async_client(
+                headers=headers, verify=verify, model_name="cerebras"
+            )
             provider_args = dict(
                 api_key=api_key,
                 http_client=client,

{code_puppy-0.0.378 → code_puppy-0.0.380}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.378"
+version = "0.0.380"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"