mcp-mesh 0.5.4__tar.gz → 0.5.6__tar.gz

{mcp_mesh-0.5.4 → mcp_mesh-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.5.4
+Version: 0.5.6
 Summary: Kubernetes-native platform for distributed MCP applications
 Project-URL: Homepage, https://github.com/dhyansraj/mcp-mesh
 Project-URL: Documentation, https://github.com/dhyansraj/mcp-mesh/tree/main/docs

{mcp_mesh-0.5.4 → mcp_mesh-0.5.6}/_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-0.5.4 → mcp_mesh-0.5.6}/_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-0.5.4 → mcp_mesh-0.5.6}/_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-0.5.4 → mcp_mesh-0.5.6}/_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-0.5.6/_mcp_mesh/pipeline/api_startup/fastapi_discovery.py

@@ -0,0 +1,139 @@
+import logging
+from typing import Any, Dict, List
+
+from ..shared import PipelineResult, PipelineStatus, PipelineStep
+from ...shared.server_discovery import ServerDiscoveryUtil
+
+
+class FastAPIAppDiscoveryStep(PipelineStep):
+    """
+    Discovers existing FastAPI application instances in the user's code.
+    
+    This step scans the Python runtime to find FastAPI applications that
+    have been instantiated by the user, without modifying them in any way.
+    
+    The goal is minimal intervention - we only discover what exists,
+    we don't create or modify anything.
+    """
+
+    def __init__(self):
+        super().__init__(
+            name="fastapi-discovery",
+            required=True,
+            description="Discover existing FastAPI application instances",
+        )
+
+    async def execute(self, context: dict[str, Any]) -> PipelineResult:
+        """Discover FastAPI applications."""
+        self.logger.debug("Discovering FastAPI applications...")
+
+        result = PipelineResult(message="FastAPI discovery completed")
+
+        try:
+            # Get route decorators from context (from RouteCollectionStep)
+            mesh_routes = context.get("mesh_routes", {})
+            
+            if not mesh_routes:
+                result.status = PipelineStatus.SKIPPED
+                result.message = "No @mesh.route decorators found"
+                self.logger.info("⚠️ No @mesh.route decorators found to process")
+                return result
+
+            # 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
+                result.status = PipelineStatus.FAILED
+                result.message = "No FastAPI applications found"
+                result.add_error("No FastAPI applications discovered in runtime")
+                self.logger.error(
+                    "❌ No FastAPI applications found. @mesh.route decorators require "
+                    "an existing FastAPI app instance. Please create a FastAPI app before "
+                    "using @mesh.route decorators."
+                )
+                return result
+
+            # Analyze which routes belong to which apps
+            route_mapping = self._map_routes_to_apps(fastapi_apps, mesh_routes)
+            
+            # Store discovery results in context
+            result.add_context("fastapi_apps", fastapi_apps)
+            result.add_context("route_mapping", route_mapping)
+            result.add_context("discovered_app_count", len(fastapi_apps))
+            
+            # Update result message
+            route_count = sum(len(routes) for routes in route_mapping.values())
+            result.message = (
+                f"Discovered {len(fastapi_apps)} FastAPI app(s) with "
+                f"{route_count} @mesh.route decorated handlers"
+            )
+
+            self.logger.info(
+                f"📦 FastAPI Discovery: {len(fastapi_apps)} app(s), "
+                f"{route_count} @mesh.route handlers, {len(mesh_routes)} total routes"
+            )
+
+            # Log details for debugging
+            for app_id, app_info in fastapi_apps.items():
+                app_title = app_info.get("title", "Unknown")
+                routes_in_app = len(route_mapping.get(app_id, {}))
+                self.logger.debug(
+                    f"  App '{app_title}' ({app_id}): {routes_in_app} @mesh.route handlers"
+                )
+
+        except Exception as e:
+            result.status = PipelineStatus.FAILED
+            result.message = f"FastAPI discovery failed: {e}"
+            result.add_error(str(e))
+            self.logger.error(f"❌ FastAPI discovery failed: {e}")
+
+        return result
+
+
+    def _map_routes_to_apps(
+        self, 
+        fastapi_apps: Dict[str, Dict[str, Any]], 
+        mesh_routes: Dict[str, Any]
+    ) -> Dict[str, Dict[str, Any]]:
+        """
+        Map @mesh.route decorated functions to their FastAPI applications.
+        
+        Args:
+            fastapi_apps: Discovered FastAPI applications
+            mesh_routes: @mesh.route decorated functions from DecoratorRegistry
+            
+        Returns:
+            Dict mapping app_id -> {route_name -> route_info} for routes that have @mesh.route
+        """
+        route_mapping = {}
+        
+        for app_id, app_info in fastapi_apps.items():
+            app_routes = {}
+            
+            for route_info in app_info["routes"]:
+                endpoint_name = route_info["endpoint_name"]
+                
+                # Check if this route handler has @mesh.route decorator
+                if endpoint_name in mesh_routes:
+                    mesh_route_data = mesh_routes[endpoint_name]
+                    
+                    # Combine FastAPI route info with @mesh.route metadata
+                    combined_info = {
+                        **route_info,  # FastAPI route info
+                        "mesh_metadata": mesh_route_data.metadata,  # @mesh.route metadata
+                        "dependencies": mesh_route_data.metadata.get("dependencies", []),
+                        "mesh_decorator": mesh_route_data,  # Full DecoratedFunction object
+                    }
+                    
+                    app_routes[endpoint_name] = combined_info
+                    
+                    self.logger.debug(
+                        f"Mapped route '{endpoint_name}' to app '{app_info['title']}' "
+                        f"with {len(combined_info['dependencies'])} dependencies"
+                    )
+            
+            if app_routes:
+                route_mapping[app_id] = app_routes
+                
+        return route_mapping

{mcp_mesh-0.5.4 → mcp_mesh-0.5.6}/_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-0.5.4 → mcp_mesh-0.5.6}/_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-0.5.4 → mcp_mesh-0.5.6}/_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",