mcp-mesh 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

_mcp_mesh/__init__.py

@@ -31,7 +31,7 @@ from .engine.decorator_registry import (
     get_decorator_stats,
 )
 
-__version__ = "0.5.4"
+__version__ = "0.5.6"
 
 # Store reference to runtime processor if initialized
 _runtime_processor = None
@@ -59,7 +59,10 @@ def initialize_runtime():
 
 
 # Auto-initialize runtime if enabled
-if os.getenv("MCP_MESH_ENABLED", "true").lower() == "true":
+if (
+    os.getenv("MCP_MESH_ENABLED", "true").lower() == "true"
+    and os.getenv("MCP_MESH_AUTO_RUN", "true").lower() == "true"
+):
     # Use debounced initialization instead of immediate MCP startup
     # This allows the system to determine MCP vs API pipeline based on decorators
     try:

_mcp_mesh/engine/decorator_registry.py

@@ -55,6 +55,15 @@ class DecoratorRegistry:
 
     # Registry for new decorator types (extensibility)
     _custom_decorators: dict[str, dict[str, DecoratedFunction]] = {}
+    
+    # Immediate uvicorn server storage (for preventing shutdown state)
+    _immediate_uvicorn_server: Optional[dict[str, Any]] = None
+    
+    # FastMCP lifespan storage (for proper integration with FastAPI)
+    _fastmcp_lifespan: Optional[Any] = None
+    
+    # FastMCP HTTP app storage (the same app instance whose lifespan was extracted)
+    _fastmcp_http_app: Optional[Any] = None
 
     @classmethod
     def register_mesh_agent(cls, func: Callable, metadata: dict[str, Any]) -> None:
@@ -508,6 +517,92 @@ class DecoratorRegistry:
 
         return {}
 
+    @classmethod
+    def store_immediate_uvicorn_server(cls, server_info: dict[str, Any]) -> None:
+        """
+        Store reference to immediate uvicorn server started in decorator.
+        
+        Args:
+            server_info: Dictionary containing server information:
+                - 'app': FastAPI app instance
+                - 'host': Server host
+                - 'port': Server port  
+                - 'thread': Thread object
+                - Any other relevant server metadata
+        """
+        cls._immediate_uvicorn_server = server_info
+        logger.debug(f"🔄 REGISTRY: Stored immediate uvicorn server reference: {server_info.get('host')}:{server_info.get('port')}")
+
+    @classmethod
+    def get_immediate_uvicorn_server(cls) -> Optional[dict[str, Any]]:
+        """
+        Get stored immediate uvicorn server reference.
+        
+        Returns:
+            Server info dict if available, None otherwise
+        """
+        return cls._immediate_uvicorn_server
+
+    @classmethod
+    def clear_immediate_uvicorn_server(cls) -> None:
+        """Clear stored immediate uvicorn server reference."""
+        cls._immediate_uvicorn_server = None
+        logger.debug("🔄 REGISTRY: Cleared immediate uvicorn server reference")
+
+    @classmethod
+    def store_fastmcp_lifespan(cls, lifespan: Any) -> None:
+        """
+        Store FastMCP lifespan for integration with FastAPI.
+        
+        Args:
+            lifespan: FastMCP lifespan function
+        """
+        cls._fastmcp_lifespan = lifespan
+        logger.debug("🔄 REGISTRY: Stored FastMCP lifespan for FastAPI integration")
+
+    @classmethod
+    def get_fastmcp_lifespan(cls) -> Optional[Any]:
+        """
+        Get stored FastMCP lifespan.
+        
+        Returns:
+            FastMCP lifespan if available, None otherwise
+        """
+        return cls._fastmcp_lifespan
+
+    @classmethod
+    def clear_fastmcp_lifespan(cls) -> None:
+        """Clear stored FastMCP lifespan reference."""
+        cls._fastmcp_lifespan = None
+        logger.debug("🔄 REGISTRY: Cleared FastMCP lifespan reference")
+
+    @classmethod
+    def store_fastmcp_http_app(cls, http_app: Any) -> None:
+        """
+        Store FastMCP HTTP app (the same instance whose lifespan was extracted).
+        
+        Args:
+            http_app: FastMCP HTTP app instance
+        """
+        cls._fastmcp_http_app = http_app
+        logger.debug("🔄 REGISTRY: Stored FastMCP HTTP app for mounting")
+
+    @classmethod
+    def get_fastmcp_http_app(cls) -> Optional[Any]:
+        """
+        Get stored FastMCP HTTP app.
+        
+        Returns:
+            FastMCP HTTP app if available, None otherwise
+        """
+        return cls._fastmcp_http_app
+
+    @classmethod
+    def clear_fastmcp_http_app(cls) -> None:
+        """Clear stored FastMCP HTTP app reference."""
+        cls._fastmcp_http_app = None
+        logger.debug("🔄 REGISTRY: Cleared FastMCP HTTP app reference")
+
 
 # Convenience functions for external access
 def get_all_mesh_agents() -> dict[str, DecoratedFunction]:

_mcp_mesh/engine/mcp_client_proxy.py

@@ -12,7 +12,6 @@ from typing import Any, Optional
 from ..shared.content_extractor import ContentExtractor
 from ..shared.sse_parser import SSEParser
 from .async_mcp_client import AsyncMCPClient
-from .threading_utils import ThreadingUtils
 
 logger = logging.getLogger(__name__)
 
@@ -48,13 +47,24 @@ class MCPClientProxy:
             )
 
     def _run_async(self, coro):
-        """Convert async coroutine to sync call avoiding atexit bug.
+        """Convert async coroutine to sync call."""
 
-        Uses shared ThreadingUtils for consistent DNS-safe threading behavior.
-        """
-        return ThreadingUtils.run_sync_from_async(
-            coro, timeout=60.0, context_name=f"MCPClient.{self.function_name}"
-        )
+        try:
+            # Try to get existing event loop
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # We're in an async context, need to run in thread
+                import concurrent.futures
+
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(asyncio.run, coro)
+                    return future.result()
+            else:
+                # No running loop, safe to use loop.run_until_complete
+                return loop.run_until_complete(coro)
+        except RuntimeError:
+            # No event loop exists, create new one
+            return asyncio.run(coro)
 
     def __call__(self, **kwargs) -> Any:
         """Callable interface for dependency injection.

_mcp_mesh/engine/unified_mcp_proxy.py

@@ -10,8 +10,6 @@ import uuid
 from collections.abc import AsyncIterator
 from typing import Any, Optional
 
-from .threading_utils import ThreadingUtils
-
 logger = logging.getLogger(__name__)
 
 
@@ -58,11 +56,27 @@ class UnifiedMCPProxy:
                 f"🔧 UnifiedMCPProxy initialized with kwargs: {self.kwargs_config}"
             )
 
+    def _is_ip_address(self, hostname: str) -> bool:
+        """Check if hostname is an IP address vs DNS name.
+        
+        Args:
+            hostname: Hostname to check
+            
+        Returns:
+            True if IP address, False if DNS name
+        """
+        import ipaddress
+        try:
+            ipaddress.ip_address(hostname)
+            return True
+        except ValueError:
+            return False
+
     def _create_fastmcp_client(self, endpoint: str):
-        """Create FastMCP client with automatic trace header injection.
+        """Create FastMCP client with DNS detection for threading conflict avoidance.
 
-        This method automatically detects trace context and adds distributed tracing
-        headers when available, while maintaining full backward compatibility.
+        This method detects DNS names vs IP addresses and forces HTTP fallback for DNS names
+        to avoid FastMCP client threading conflicts in containerized environments.
 
         Args:
             endpoint: MCP endpoint URL
@@ -71,6 +85,14 @@ class UnifiedMCPProxy:
             FastMCP Client instance with or without trace headers
         """
         try:
+            # Extract hostname from endpoint URL for DNS detection  
+            from urllib.parse import urlparse
+            parsed = urlparse(endpoint)
+            hostname = parsed.hostname or parsed.netloc.split(':')[0]
+            
+            # DNS resolution works perfectly with FastMCP - no need to force HTTP fallback
+            self.logger.debug(f"✅ Using FastMCP client for endpoint: {hostname}")
+            
             from fastmcp import Client
             from fastmcp.client.transports import StreamableHttpTransport
 
@@ -85,16 +107,14 @@ class UnifiedMCPProxy:
                 # Create standard client when no trace context available
                 return Client(endpoint)
 
-        except ImportError:
-            # If StreamableHttpTransport not available, fall back to standard client
-            from fastmcp import Client
-
-            return Client(endpoint)
+        except ImportError as e:
+            # DNS names or FastMCP not available - this will trigger HTTP fallback
+            self.logger.debug(f"🔄 FastMCP client unavailable: {e}")
+            raise  # Re-raise to trigger _fallback_http_call
         except Exception as e:
-            # Any other error, fall back to standard client
-            from fastmcp import Client
-
-            return Client(endpoint)
+            # Any other error - this will trigger HTTP fallback  
+            self.logger.debug(f"🔄 FastMCP client error: {e}")
+            raise ImportError(f"FastMCP client failed: {e}")  # Convert to ImportError to trigger fallback
 
     def _get_trace_headers(self) -> dict[str, str]:
         """Extract trace headers from current context for distributed tracing.
@@ -341,6 +361,7 @@ class UnifiedMCPProxy:
         """
         import time
 
+
         start_time = time.time()
 
         try:
@@ -350,6 +371,7 @@ class UnifiedMCPProxy:
 
             # Create client with automatic trace header injection
             client_instance = self._create_fastmcp_client(mcp_endpoint)
+
             async with client_instance as client:
 
                 # Use FastMCP's call_tool which returns CallToolResult object
@@ -394,7 +416,8 @@ class UnifiedMCPProxy:
             self.logger.warning(f"FastMCP Client failed: {e}, falling back to HTTP")
             # Try HTTP fallback
             try:
-                return await self._fallback_http_call(name, arguments)
+                result = await self._fallback_http_call(name, arguments)
+                return result
             except Exception as fallback_error:
                 raise RuntimeError(
                     f"Tool call to '{name}' failed: {e}, fallback also failed: {fallback_error}"
@@ -831,15 +854,6 @@ class EnhancedUnifiedMCPProxy(UnifiedMCPProxy):
             f"auth_required: {self.auth_required}"
         )
 
-    def __call__(self, **kwargs) -> Any:
-        """Synchronous callable interface for dependency injection.
-
-        This method provides a sync interface for dependency injection.
-        Returns the actual result, not a coroutine.
-        """
-        # Use the enhanced tool call with proper sync-to-async bridging
-        return self.call_tool_auto(self.function_name, kwargs)
-
     async def call_tool_enhanced(self, name: str, arguments: dict = None) -> Any:
         """Enhanced tool call with retry logic and custom configuration."""
         last_exception = None
@@ -869,19 +883,8 @@ class EnhancedUnifiedMCPProxy(UnifiedMCPProxy):
         raise last_exception
 
     def call_tool_auto(self, name: str, arguments: dict = None) -> Any:
-        """Automatically choose streaming vs non-streaming based on configuration.
-
-        Uses shared ThreadingUtils for consistent DNS-safe threading behavior.
-        """
-        # Create coroutine function based on streaming capability
-        def coro_func():
-            if self.streaming_capable:
-                return self.call_tool_streaming(name, arguments)
-            else:
-                return self.call_tool_enhanced(name, arguments)
-
-        return ThreadingUtils.run_sync_from_async(
-            coro_func,
-            timeout=self.timeout or 60.0,
-            context_name=f"UnifiedMCPProxy.{name}",
-        )
+        """Automatically choose streaming vs non-streaming based on configuration."""
+        if self.streaming_capable:
+            return self.call_tool_streaming(name, arguments)
+        else:
+            return self.call_tool_enhanced(name, arguments)

_mcp_mesh/pipeline/api_startup/fastapi_discovery.py

@@ -1,8 +1,8 @@
-import gc
 import logging
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List
 
 from ..shared import PipelineResult, PipelineStatus, PipelineStep
+from ...shared.server_discovery import ServerDiscoveryUtil
 
 
 class FastAPIAppDiscoveryStep(PipelineStep):
@@ -39,8 +39,8 @@ class FastAPIAppDiscoveryStep(PipelineStep):
                 self.logger.info("⚠️ No @mesh.route decorators found to process")
                 return result
 
-            # Discover FastAPI instances
-            fastapi_apps = self._discover_fastapi_instances()
+            # Discover FastAPI instances using shared utility
+            fastapi_apps = ServerDiscoveryUtil.discover_fastapi_instances()
             
             if not fastapi_apps:
                 # This is not necessarily an error - user might be using FastAPI differently
@@ -90,169 +90,6 @@ class FastAPIAppDiscoveryStep(PipelineStep):
 
         return result
 
-    def _discover_fastapi_instances(self) -> Dict[str, Dict[str, Any]]:
-        """
-        Discover FastAPI application instances in the Python runtime.
-        
-        Uses intelligent deduplication to handle standard uvicorn patterns where
-        the same app might be imported multiple times (e.g., "module:app" pattern).
-        
-        Returns:
-            Dict mapping app_id -> app_info where app_info contains:
-            - 'instance': The FastAPI app instance
-            - 'title': App title from FastAPI
-            - 'routes': List of route information
-            - 'module': Module where app was found
-        """
-        fastapi_apps = {}
-        seen_apps = {}  # For deduplication: title -> app_info
-        
-        try:
-            # Import FastAPI here to avoid dependency if not used
-            from fastapi import FastAPI
-        except ImportError:
-            self.logger.warning("FastAPI not installed - cannot discover FastAPI apps")
-            return {}
-
-        # Scan garbage collector for FastAPI instances
-        candidate_apps = []
-        for obj in gc.get_objects():
-            if isinstance(obj, FastAPI):
-                candidate_apps.append(obj)
-
-        # Deduplicate apps with identical configurations
-        for obj in candidate_apps:
-            try:
-                title = getattr(obj, "title", "FastAPI App")
-                version = getattr(obj, "version", "unknown")
-                routes = self._extract_route_info(obj)
-                route_count = len(routes)
-                
-                # Create a signature for deduplication
-                app_signature = (title, version, route_count)
-                
-                # Check if we've seen an identical app
-                if app_signature in seen_apps:
-                    existing_app = seen_apps[app_signature]
-                    # Compare route details to ensure they're truly identical
-                    existing_routes = existing_app["routes"]
-                    
-                    if self._routes_are_identical(routes, existing_routes):
-                        self.logger.debug(
-                            f"Skipping duplicate FastAPI app: '{title}' (same title, version, and routes)"
-                        )
-                        continue  # Skip this duplicate
-                
-                # This is a unique app, add it
-                app_id = f"app_{id(obj)}"
-                app_info = {
-                    "instance": obj,
-                    "title": title,
-                    "version": version,
-                    "routes": routes,
-                    "module": self._get_app_module(obj),
-                    "object_id": id(obj),
-                    "router_routes_count": len(obj.router.routes) if hasattr(obj, 'router') else 0,
-                }
-                
-                fastapi_apps[app_id] = app_info
-                seen_apps[app_signature] = app_info
-                
-                self.logger.debug(
-                    f"Found FastAPI app: '{title}' (module: {app_info['module']}) with "
-                    f"{len(routes)} routes"
-                )
-                
-            except Exception as e:
-                self.logger.warning(f"Error analyzing FastAPI app: {e}")
-                continue
-
-        return fastapi_apps
-
-    def _routes_are_identical(self, routes1: List[Dict[str, Any]], routes2: List[Dict[str, Any]]) -> bool:
-        """
-        Compare two route lists to see if they're identical.
-        
-        Args:
-            routes1: First route list 
-            routes2: Second route list
-            
-        Returns:
-            True if routes are identical, False otherwise
-        """
-        if len(routes1) != len(routes2):
-            return False
-            
-        # Create comparable signatures for each route
-        def route_signature(route):
-            return (
-                tuple(sorted(route.get('methods', []))),  # Sort methods for consistent comparison
-                route.get('path', ''),
-                route.get('endpoint_name', '')
-            )
-        
-        # Sort routes by signature for consistent comparison
-        sig1 = sorted([route_signature(r) for r in routes1])
-        sig2 = sorted([route_signature(r) for r in routes2])
-        
-        return sig1 == sig2
-
-    def _extract_route_info(self, app) -> List[Dict[str, Any]]:
-        """
-        Extract route information from FastAPI app without modifying it.
-        
-        Args:
-            app: FastAPI application instance
-            
-        Returns:
-            List of route information dictionaries
-        """
-        routes = []
-        
-        try:
-            for route in app.router.routes:
-                if hasattr(route, 'endpoint') and hasattr(route, 'path'):
-                    route_info = {
-                        "path": route.path,
-                        "methods": list(route.methods) if hasattr(route, 'methods') else [],
-                        "endpoint": route.endpoint,
-                        "endpoint_name": getattr(route.endpoint, '__name__', 'unknown'),
-                        "has_mesh_route": hasattr(route.endpoint, '_mesh_route_metadata'),
-                    }
-                    routes.append(route_info)
-                    
-        except Exception as e:
-            self.logger.warning(f"Error extracting route info: {e}")
-            
-        return routes
-
-    def _get_app_module(self, app) -> Optional[str]:
-        """
-        Try to determine which module the FastAPI app belongs to.
-        
-        Args:
-            app: FastAPI application instance
-            
-        Returns:
-            Module name or None if unknown
-        """
-        try:
-            # Try to get module from the app's stack frame when it was created
-            # This is best-effort - may not always work
-            import inspect
-            
-            frame = inspect.currentframe()
-            while frame:
-                frame_globals = frame.f_globals
-                for name, obj in frame_globals.items():
-                    if obj is app:
-                        return frame_globals.get('__name__', 'unknown')
-                frame = frame.f_back
-                
-        except Exception:
-            pass
-            
-        return None
 
     def _map_routes_to_apps(
         self, 

_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_orchestrator.py

@@ -43,6 +43,8 @@ class HeartbeatOrchestrator:
         self._heartbeat_count += 1
 
         try:
+
+
             # Prepare heartbeat context with validation
             heartbeat_context = self._prepare_heartbeat_context(agent_id, context)
 
@@ -65,10 +67,12 @@ class HeartbeatOrchestrator:
             import asyncio
 
             try:
+
                 result = await asyncio.wait_for(
                     self.pipeline.execute_heartbeat_cycle(heartbeat_context),
                     timeout=30.0,
                 )
+
             except TimeoutError:
                 self.logger.error(
                     f"❌ Heartbeat #{self._heartbeat_count} timed out after 30 seconds"

_mcp_mesh/pipeline/mcp_heartbeat/lifespan_integration.py

@@ -44,6 +44,19 @@ async def heartbeat_lifespan_task(heartbeat_config: dict[str, Any]) -> None:
 
     try:
         while True:
+            # Check if shutdown is complete before executing heartbeat
+            try:
+                from ...shared.simple_shutdown import should_stop_heartbeat
+
+                if should_stop_heartbeat():
+                    logger.info(
+                        f"🛑 Heartbeat stopped for agent '{agent_id}' due to shutdown"
+                    )
+                    break
+            except ImportError:
+                # If simple_shutdown is not available, continue normally
+                pass
+
             try:
                 # Execute heartbeat pipeline
                 success = await heartbeat_orchestrator.execute_heartbeat(

_mcp_mesh/pipeline/mcp_startup/__init__.py

@@ -13,6 +13,7 @@ from .heartbeat_loop import HeartbeatLoopStep
 from .heartbeat_preparation import HeartbeatPreparationStep
 from .startup_orchestrator import (
                                    MeshOrchestrator,
+                                   clear_debounce_coordinator,
                                    get_debounce_coordinator,
                                    get_global_orchestrator,
                                    start_runtime,
@@ -28,6 +29,7 @@ __all__ = [
     "HeartbeatPreparationStep",
     "MeshOrchestrator",
     "StartupPipeline",
+    "clear_debounce_coordinator",
     "get_global_orchestrator",
     "get_debounce_coordinator",
     "start_runtime",