code-puppy 0.0.315__tar.gz → 0.0.316__tar.gz

{code_puppy-0.0.315 → code_puppy-0.0.316}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.315
+Version: 0.0.316
 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.315 → code_puppy-0.0.316}/code_puppy/agents/base_agent.py

@@ -47,11 +47,10 @@ from code_puppy.config import (
     get_protected_token_count,
     get_use_dbos,
     get_value,
-    load_mcp_server_configs,
 )
 from code_puppy.error_logging import log_error
 from code_puppy.keymap import cancel_agent_uses_signal, get_cancel_agent_char_code
-from code_puppy.mcp_ import ServerConfig, get_mcp_manager
+from code_puppy.mcp_ import get_mcp_manager
 from code_puppy.messaging import (
     emit_error,
     emit_info,
@@ -989,45 +988,31 @@ class BaseAgent(ABC):
         return self._puppy_rules
 
     def load_mcp_servers(self, extra_headers: Optional[Dict[str, str]] = None):
-        """Load MCP servers through the manager and return pydantic-ai compatible servers."""
+        """Load MCP servers through the manager and return pydantic-ai compatible servers.
+
+        Note: The manager automatically syncs from mcp_servers.json during initialization,
+        so we don't need to sync here. Use reload_mcp_servers() to force a re-sync.
+        """
 
         mcp_disabled = get_value("disable_mcp_servers")
         if mcp_disabled and str(mcp_disabled).lower() in ("1", "true", "yes", "on"):
             return []
 
         manager = get_mcp_manager()
-        configs = load_mcp_server_configs()
-        if not configs:
-            existing_servers = manager.list_servers()
-            if not existing_servers:
-                return []
-        else:
-            for name, conf in configs.items():
-                try:
-                    server_config = ServerConfig(
-                        id=conf.get("id", f"{name}_{hash(name)}"),
-                        name=name,
-                        type=conf.get("type", "sse"),
-                        enabled=conf.get("enabled", True),
-                        config=conf,
-                    )
-                    existing = manager.get_server_by_name(name)
-                    if not existing:
-                        manager.register_server(server_config)
-                    else:
-                        if existing.config != server_config.config:
-                            manager.update_server(existing.id, server_config)
-                except Exception:
-                    continue
-
         return manager.get_servers_for_agent()
 
     def reload_mcp_servers(self):
-        """Reload MCP servers and return updated servers."""
+        """Reload MCP servers and return updated servers.
+
+        Forces a re-sync from mcp_servers.json to pick up any configuration changes.
+        """
         # Clear the MCP tool cache when servers are reloaded
         self._mcp_tool_definitions_cache = []
-        self.load_mcp_servers()
+
+        # Force re-sync from mcp_servers.json
         manager = get_mcp_manager()
+        manager.sync_from_config()
+
         return manager.get_servers_for_agent()
 
     def _load_model_with_fallback(

{code_puppy-0.0.315 → code_puppy-0.0.316}/code_puppy/mcp_/blocking_startup.py

@@ -201,15 +201,23 @@ class BlockingMCPServerStdio(SimpleCapturedMCPServerStdio):
 
             return result
 
-        except Exception as e:
+        except BaseException as e:
             # Store error and mark as initialized (with error)
-            self._init_error = e
+            # Unwrap ExceptionGroup if present (Python 3.11+)
+            if type(e).__name__ == "ExceptionGroup" and hasattr(e, "exceptions"):
+                # Use the first exception as the primary cause
+                self._init_error = e.exceptions[0]
+                error_details = f"{e.exceptions[0]}"
+            else:
+                self._init_error = e
+                error_details = str(e)
+
             self._initialized.set()
 
             # Emit error message
             server_name = getattr(self, "tool_prefix", self.command)
             emit_info(
-                f"❌ MCP Server '{server_name}' failed to initialize: {e}",
+                f"❌ MCP Server '{server_name}' failed to initialize: {error_details}",
                 style="red",
                 message_group=self.message_group,
             )

{code_puppy-0.0.315 → code_puppy-0.0.316}/code_puppy/mcp_/managed_server.py

@@ -6,6 +6,7 @@ that adds management capabilities while maintaining 100% compatibility.
 """
 
 import json
+import os
 import uuid
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
@@ -222,7 +223,16 @@ class ManagedMCPServer:
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
                 if "headers" in config:
-                    http_kwargs["headers"] = config.get("headers")
+                    # Expand environment variables in headers
+                    headers = config.get("headers")
+                    resolved_headers = {}
+                    if isinstance(headers, dict):
+                        for k, v in headers.items():
+                            if isinstance(v, str):
+                                resolved_headers[k] = os.path.expandvars(v)
+                            else:
+                                resolved_headers[k] = v
+                    http_kwargs["headers"] = resolved_headers
                     # Create HTTP client if headers are provided but no client specified
 
                 self._pydantic_server = MCPServerStreamableHTTP(
@@ -243,8 +253,18 @@ class ManagedMCPServer:
             Configured async HTTP client with custom headers
         """
         headers = self.config.config.get("headers", {})
+
+        # Expand environment variables in headers
+        resolved_headers = {}
+        if isinstance(headers, dict):
+            for k, v in headers.items():
+                if isinstance(v, str):
+                    resolved_headers[k] = os.path.expandvars(v)
+                else:
+                    resolved_headers[k] = v
+
         timeout = self.config.config.get("timeout", 30)
-        client = create_async_client(headers=headers, timeout=timeout)
+        client = create_async_client(headers=resolved_headers, timeout=timeout)
         return client
 
     def enable(self) -> None:

{code_puppy-0.0.315 → code_puppy-0.0.316}/code_puppy/mcp_/manager.py

@@ -78,11 +78,76 @@ class MCPManager:
         # Active managed servers (server_id -> ManagedMCPServer)
         self._managed_servers: Dict[str, ManagedMCPServer] = {}
 
+        # Sync servers from mcp_servers.json into registry
+        self.sync_from_config()
+
         # Load existing servers from registry
         self._initialize_servers()
 
         logger.info("MCPManager initialized with core components")
 
+    def sync_from_config(self) -> None:
+        """Sync servers from mcp_servers.json into the registry.
+
+        This public method ensures that servers defined in the user's
+        configuration file are automatically registered with the manager.
+        It can be called during initialization or manually to reload
+        server configurations.
+
+        This is the single source of truth for syncing mcp_servers.json
+        into the registry, avoiding duplication with base_agent.py.
+        """
+        try:
+            from code_puppy.config import load_mcp_server_configs
+
+            configs = load_mcp_server_configs()
+            if not configs:
+                logger.debug("No servers found in mcp_servers.json")
+                return
+
+            synced_count = 0
+            updated_count = 0
+
+            for name, conf in configs.items():
+                try:
+                    # Create ServerConfig from the loaded configuration
+                    server_config = ServerConfig(
+                        id=conf.get("id", ""),  # Empty ID will be auto-generated
+                        name=name,
+                        type=conf.get("type", "sse"),
+                        enabled=conf.get("enabled", True),
+                        config=conf,
+                    )
+
+                    # Check if server already exists by name
+                    existing = self.registry.get_by_name(name)
+
+                    if not existing:
+                        # Register new server
+                        self.registry.register(server_config)
+                        synced_count += 1
+                        logger.debug(f"Synced new server from config: {name}")
+                    else:
+                        # Update existing server if config has changed
+                        if existing.config != server_config.config:
+                            server_config.id = existing.id  # Keep existing ID
+                            self.registry.update(existing.id, server_config)
+                            updated_count += 1
+                            logger.debug(f"Updated server from config: {name}")
+
+                except Exception as e:
+                    logger.warning(f"Failed to sync server '{name}' from config: {e}")
+                    continue
+
+            if synced_count > 0 or updated_count > 0:
+                logger.info(
+                    f"Synced {synced_count} new and updated {updated_count} servers from mcp_servers.json"
+                )
+
+        except Exception as e:
+            logger.error(f"Failed to sync from mcp_servers.json: {e}")
+            # Don't fail initialization if sync fails
+
     def _initialize_servers(self) -> None:
         """Initialize managed servers from registry configurations."""
         configs = self.registry.list_all()

{code_puppy-0.0.315 → code_puppy-0.0.316}/pyproject.toml

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