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

_mcp_mesh/shared/server_discovery.py

@@ -0,0 +1,312 @@
+"""
+Shared utilities for discovering existing FastAPI and uvicorn server instances.
+
+This module provides utilities to discover running servers that have been started
+outside the pipeline, such as by immediate uvicorn start in decorators.
+"""
+
+import gc
+import logging
+import socket
+from typing import Any, Dict, List, Optional, Tuple
+import threading
+
+logger = logging.getLogger(__name__)
+
+
+class ServerDiscoveryUtil:
+    """Utility class for discovering existing FastAPI apps and uvicorn servers."""
+
+    @staticmethod
+    def discover_fastapi_instances() -> 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:
+            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 = ServerDiscoveryUtil._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 ServerDiscoveryUtil._routes_are_identical(routes, existing_routes):
+                        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": ServerDiscoveryUtil._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
+                
+                logger.debug(
+                    f"Found FastAPI app: '{title}' (module: {app_info['module']}) with "
+                    f"{len(routes)} routes"
+                )
+                
+            except Exception as e:
+                logger.warning(f"Error analyzing FastAPI app: {e}")
+                continue
+
+        return fastapi_apps
+
+    @staticmethod
+    def discover_running_servers() -> List[Dict[str, Any]]:
+        """
+        Discover running uvicorn servers by scanning threads and checking port bindings.
+        
+        Returns:
+            List of server info dictionaries containing:
+            - 'type': 'uvicorn' or 'unknown'
+            - 'host': Server host
+            - 'port': Server port
+            - 'thread': Thread object if found
+            - 'app': FastAPI app if discoverable
+        """
+        running_servers = []
+        
+        # Look for uvicorn server threads
+        for thread in threading.enumerate():
+            if hasattr(thread, '_target'):
+                # Check if thread target looks like a uvicorn server
+                target_name = getattr(thread._target, '__name__', '') if thread._target else ''
+                if 'server' in target_name.lower() or 'uvicorn' in target_name.lower():
+                    server_info = {
+                        'type': 'uvicorn',
+                        'thread': thread,
+                        'target_name': target_name,
+                        'daemon': thread.daemon,
+                        'alive': thread.is_alive(),
+                    }
+                    
+                    # Try to extract server details from thread
+                    server_details = ServerDiscoveryUtil._extract_server_details_from_thread(thread)
+                    server_info.update(server_details)
+                    
+                    running_servers.append(server_info)
+                    logger.debug(f"Found running server thread: {target_name} (daemon={thread.daemon})")
+        
+        # Also check for bound ports that might indicate running servers
+        bound_ports = ServerDiscoveryUtil._discover_bound_ports()
+        for port_info in bound_ports:
+            # Only add if we haven't already found this port via thread discovery
+            existing_ports = [s.get('port') for s in running_servers if s.get('port')]
+            if port_info['port'] not in existing_ports:
+                port_info['type'] = 'unknown'
+                running_servers.append(port_info)
+                logger.debug(f"Found bound port: {port_info['host']}:{port_info['port']}")
+        
+        return running_servers
+
+    @staticmethod
+    def _extract_server_details_from_thread(thread) -> Dict[str, Any]:
+        """Extract server details from a thread if possible."""
+        details = {}
+        
+        try:
+            # Try to access thread local variables or target args
+            if hasattr(thread, '_args') and thread._args:
+                # Some uvicorn servers might have args with host/port
+                args = thread._args
+                if len(args) >= 2:
+                    # Common pattern: (app, host, port) or similar
+                    if isinstance(args[0], str) and ':' in args[0]:
+                        # Might be "host:port" format
+                        try:
+                            host, port = args[0].split(':')
+                            details['host'] = host
+                            details['port'] = int(port)
+                        except (ValueError, IndexError):
+                            pass
+            
+            # Try to find FastAPI app in thread target or args
+            if hasattr(thread, '_target') and thread._target:
+                # Check if target has app attribute or if it's in closure
+                target = thread._target
+                if hasattr(target, '__closure__') and target.__closure__:
+                    for cell in target.__closure__:
+                        try:
+                            cell_contents = cell.cell_contents
+                            from fastapi import FastAPI
+                            if isinstance(cell_contents, FastAPI):
+                                details['app'] = cell_contents
+                                details['app_title'] = getattr(cell_contents, 'title', 'Unknown')
+                                break
+                        except (ImportError, AttributeError):
+                            continue
+                            
+        except Exception as e:
+            logger.debug(f"Could not extract server details from thread: {e}")
+        
+        return details
+
+    @staticmethod
+    def _discover_bound_ports() -> List[Dict[str, Any]]:
+        """Discover ports that are currently bound by this process."""
+        bound_ports = []
+        
+        try:
+            # Common port ranges for web servers
+            common_ports = [8000, 8080, 8090, 9090, 9091, 3000, 3001, 4000, 5000]
+            
+            for port in common_ports:
+                for host in ['127.0.0.1', '0.0.0.0', 'localhost']:
+                    try:
+                        # Try to connect to see if port is bound
+                        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                        sock.settimeout(0.1)  # Very short timeout
+                        result = sock.connect_ex((host, port))
+                        sock.close()
+                        
+                        if result == 0:  # Connection successful = port is bound
+                            bound_ports.append({
+                                'host': host,
+                                'port': port,
+                                'status': 'bound'
+                            })
+                            break  # Don't check other hosts for same port
+                    except Exception:
+                        continue
+                        
+        except Exception as e:
+            logger.debug(f"Error discovering bound ports: {e}")
+        
+        return bound_ports
+
+    @staticmethod
+    def find_server_on_port(target_port: int, target_host: str = None) -> Optional[Dict[str, Any]]:
+        """
+        Find if there's already a server running on the specified port.
+        
+        Args:
+            target_port: Port to check
+            target_host: Host to check (optional)
+            
+        Returns:
+            Server info dict if found, None otherwise
+        """
+        running_servers = ServerDiscoveryUtil.discover_running_servers()
+        
+        for server in running_servers:
+            server_port = server.get('port')
+            server_host = server.get('host')
+            
+            # Check port match
+            if server_port == target_port:
+                # If target_host is specified, check host match too
+                if target_host is None or server_host == target_host or server_host in ['0.0.0.0', '127.0.0.1']:
+                    logger.info(f"🔍 DISCOVERY: Found existing server on {server_host}:{server_port}")
+                    return server
+        
+        logger.debug(f"🔍 DISCOVERY: No existing server found on port {target_port}")
+        return None
+
+    @staticmethod
+    def _routes_are_identical(routes1: List[Dict[str, Any]], routes2: List[Dict[str, Any]]) -> bool:
+        """Compare two route lists to see if they're identical."""
+        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
+
+    @staticmethod
+    def _extract_route_info(app) -> List[Dict[str, Any]]:
+        """Extract route information from FastAPI app without modifying it."""
+        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:
+            logger.warning(f"Error extracting route info: {e}")
+            
+        return routes
+
+    @staticmethod
+    def _get_app_module(app) -> Optional[str]:
+        """Try to determine which module the FastAPI app belongs to."""
+        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

_mcp_mesh/shared/simple_shutdown.py

@@ -0,0 +1,217 @@
+"""
+Simple shutdown coordination for MCP Mesh agents.
+
+Provides clean shutdown via FastAPI lifespan events and basic signal handling.
+"""
+
+import asyncio
+import logging
+import signal
+from contextlib import asynccontextmanager
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class SimpleShutdownCoordinator:
+    """Lightweight shutdown coordination using FastAPI lifespan."""
+
+    def __init__(self):
+        self._shutdown_requested = False
+        self._registry_url: Optional[str] = None
+        self._agent_id: Optional[str] = None
+        self._shutdown_complete = False  # Flag to prevent race conditions
+
+    def set_shutdown_context(self, registry_url: str, agent_id: str) -> None:
+        """Set context for shutdown cleanup."""
+        self._registry_url = registry_url
+        self._agent_id = agent_id
+        logger.debug(
+            f"🔧 Shutdown context set: agent_id={agent_id}, registry_url={registry_url}"
+        )
+
+    def install_signal_handlers(self) -> None:
+        """Install minimal signal handlers as backup."""
+
+        def shutdown_signal_handler(signum, frame):
+            # Avoid logging in signal handler to prevent reentrant call issues
+            self._shutdown_requested = True
+
+        signal.signal(signal.SIGINT, shutdown_signal_handler)
+        signal.signal(signal.SIGTERM, shutdown_signal_handler)
+        logger.debug("📡 Signal handlers installed")
+
+    def is_shutdown_requested(self) -> bool:
+        """Check if shutdown was requested via signal."""
+        return self._shutdown_requested
+
+    def is_shutdown_complete(self) -> bool:
+        """Check if shutdown cleanup is complete."""
+        return self._shutdown_complete
+
+    def mark_shutdown_complete(self) -> None:
+        """Mark shutdown cleanup as complete to prevent further operations."""
+        self._shutdown_complete = True
+        logger.debug("🏁 Shutdown marked as complete")
+
+    async def perform_registry_cleanup(self) -> None:
+        """Perform registry cleanup by calling DELETE /agents/{agent_id}."""
+        # Try to get the actual agent_id from DecoratorRegistry if available
+        actual_agent_id = self._agent_id
+        try:
+            from _mcp_mesh.engine.decorator_registry import DecoratorRegistry
+
+            agent_config = DecoratorRegistry.get_resolved_agent_config()
+            if agent_config and "agent_id" in agent_config:
+                resolved_agent_id = agent_config["agent_id"]
+                if resolved_agent_id and resolved_agent_id != "unknown":
+                    actual_agent_id = resolved_agent_id
+                    logger.debug(
+                        f"🔧 Using resolved agent_id from DecoratorRegistry: {actual_agent_id}"
+                    )
+        except Exception as e:
+            logger.debug(f"Could not get agent_id from DecoratorRegistry: {e}")
+
+        if (
+            not self._registry_url
+            or not actual_agent_id
+            or actual_agent_id == "unknown"
+        ):
+            logger.warning(
+                f"⚠️ Missing registry URL or agent ID for cleanup: registry_url={self._registry_url}, agent_id={actual_agent_id}"
+            )
+            return
+
+        try:
+            from _mcp_mesh.generated.mcp_mesh_registry_client.api_client import (
+                ApiClient,
+            )
+            from _mcp_mesh.generated.mcp_mesh_registry_client.configuration import (
+                Configuration,
+            )
+            from _mcp_mesh.shared.registry_client_wrapper import RegistryClientWrapper
+
+            config = Configuration(host=self._registry_url)
+            api_client = ApiClient(configuration=config)
+            registry_wrapper = RegistryClientWrapper(api_client)
+
+            success = await registry_wrapper.unregister_agent(actual_agent_id)
+            if success:
+                logger.info(f"✅ Agent '{actual_agent_id}' unregistered from registry")
+                self.mark_shutdown_complete()
+            else:
+                logger.warning(f"⚠️ Failed to unregister agent '{actual_agent_id}'")
+                self.mark_shutdown_complete()  # Mark complete even on failure to prevent loops
+
+        except Exception as e:
+            logger.error(f"❌ Registry cleanup error: {e}")
+            self.mark_shutdown_complete()  # Mark complete even on error to prevent loops
+
+    def create_shutdown_lifespan(self, original_lifespan=None):
+        """Create lifespan function that includes registry cleanup."""
+
+        @asynccontextmanager
+        async def shutdown_lifespan(app):
+            # Startup phase
+            if original_lifespan:
+                # If user had a lifespan, run their startup code
+                async with original_lifespan(app):
+                    yield
+            else:
+                yield
+
+            # Shutdown phase
+            logger.info("🔄 FastAPI shutdown initiated, performing registry cleanup...")
+            await self.perform_registry_cleanup()
+            logger.info("🏁 Registry cleanup completed")
+
+        return shutdown_lifespan
+
+    def inject_shutdown_lifespan(self, app, registry_url: str, agent_id: str) -> None:
+        """Inject shutdown lifespan into FastAPI app."""
+        self.set_shutdown_context(registry_url, agent_id)
+
+        # Store original lifespan if it exists
+        original_lifespan = getattr(app, "router", {}).get("lifespan", None)
+
+        # Replace with our shutdown-aware lifespan
+        new_lifespan = self.create_shutdown_lifespan(original_lifespan)
+        app.router.lifespan = new_lifespan
+
+        logger.info(f"🔌 Shutdown lifespan injected for agent '{agent_id}'")
+
+
+# Global instance
+_simple_shutdown_coordinator = SimpleShutdownCoordinator()
+
+
+def inject_shutdown_lifespan(app, registry_url: str, agent_id: str) -> None:
+    """Inject shutdown lifespan into FastAPI app (module-level function)."""
+    _simple_shutdown_coordinator.inject_shutdown_lifespan(app, registry_url, agent_id)
+
+
+def install_signal_handlers() -> None:
+    """Install signal handlers (module-level function)."""
+    _simple_shutdown_coordinator.install_signal_handlers()
+
+
+def should_stop_heartbeat() -> bool:
+    """Check if heartbeat should stop due to shutdown."""
+    return _simple_shutdown_coordinator.is_shutdown_complete()
+
+
+def start_blocking_loop_with_shutdown_support(thread) -> None:
+    """
+    Keep main thread alive while uvicorn in the thread handles requests.
+
+    Install signal handlers in main thread for proper registry cleanup since
+    signals to threads can be unreliable for FastAPI lifespan shutdown.
+    """
+    logger.info("🔒 MAIN THREAD: Installing signal handlers for registry cleanup")
+
+    # Install signal handlers for proper registry cleanup
+    _simple_shutdown_coordinator.install_signal_handlers()
+
+    logger.info(
+        "🔒 MAIN THREAD: Waiting for uvicorn thread - signals handled by main thread"
+    )
+
+    try:
+        # Wait for thread while handling signals in main thread
+        while thread.is_alive():
+            thread.join(timeout=1.0)
+
+            # Check if shutdown was requested via signal
+            if _simple_shutdown_coordinator.is_shutdown_requested():
+                logger.info(
+                    "🔄 MAIN THREAD: Shutdown requested, performing registry cleanup..."
+                )
+
+                # Perform registry cleanup in main thread
+                import asyncio
+
+                try:
+                    # Run cleanup in main thread
+                    asyncio.run(_simple_shutdown_coordinator.perform_registry_cleanup())
+                except Exception as e:
+                    logger.error(f"❌ Registry cleanup error: {e}")
+
+                logger.info("🏁 MAIN THREAD: Registry cleanup completed, exiting")
+                break
+
+    except KeyboardInterrupt:
+        logger.info(
+            "🔄 MAIN THREAD: KeyboardInterrupt received, performing registry cleanup..."
+        )
+
+        # Perform registry cleanup on Ctrl+C
+        import asyncio
+
+        try:
+            asyncio.run(_simple_shutdown_coordinator.perform_registry_cleanup())
+        except Exception as e:
+            logger.error(f"❌ Registry cleanup error: {e}")
+
+        logger.info("🏁 MAIN THREAD: Registry cleanup completed")
+
+    logger.info("🏁 MAIN THREAD: Uvicorn thread completed")

{mcp_mesh-0.5.4.dist-info → mcp_mesh-0.5.6.dist-info}/METADATA

@@ -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.dist-info → mcp_mesh-0.5.6.dist-info}/RECORD

@@ -1,17 +1,16 @@
-_mcp_mesh/__init__.py,sha256=oKxTjy-zjkUN12K-L9eYnWb7ZKGieCTyRvS2s-STPoc,2646
+_mcp_mesh/__init__.py,sha256=uw4Yj9HoBfp-_CyH8izKGYKrrCI-dF9uwMLMNgkIMN0,2719
 _mcp_mesh/engine/__init__.py,sha256=2ennzbo7yJcpkXO9BqN69TruLjJfmJY4Y5VEsG644K4,3630
 _mcp_mesh/engine/async_mcp_client.py,sha256=UcbQjxtgVfeRw6DHTZhAzN1gkcKlTg-lUPEePRPQWAU,6306
-_mcp_mesh/engine/decorator_registry.py,sha256=Dy3de-CQa3T4-BRV5Xx6Ks3s6gvgL-lcxCYLsfrTdX0,19085
+_mcp_mesh/engine/decorator_registry.py,sha256=0-GI7DILpbB6GRLIYhZu0DcdHEA62d89jDYxkK1ywiM,22422
 _mcp_mesh/engine/dependency_injector.py,sha256=B1iRxtIXq_z4LnJ6NTs0ZPdEIlijrMJv5KbDpQbq9iw,23752
 _mcp_mesh/engine/full_mcp_proxy.py,sha256=PlRv7GSKqn5riOCqeCVulVdtq3z1Ug76mOkwMsOFHXw,25297
 _mcp_mesh/engine/http_wrapper.py,sha256=PeYR7HkJVX7Hb0W-uYSMO-Y14VqCyrPlWzA6vnwf1Tw,21640
-_mcp_mesh/engine/mcp_client_proxy.py,sha256=dNkAIOeOG0U8_tGgaI06nAML6HtGvozlz6MvlNQqQF4,17231
+_mcp_mesh/engine/mcp_client_proxy.py,sha256=eJStwy_VQJexYYD8bOh_m4Ld3Bb8Ae_dt8N1CC41qBc,17625
 _mcp_mesh/engine/self_dependency_proxy.py,sha256=OkKt0-B_ADnJlWtHiHItoZCBZ7Su0iz2unEPFfXvrs4,3302
 _mcp_mesh/engine/session_aware_client.py,sha256=mc9eh-aCvUvfllORiXTf_X8_jPqV-32QdWKlr8tHLkU,10600
 _mcp_mesh/engine/session_manager.py,sha256=MCr0_fXBaUjXM51WU5EhDkiGvBdfzYQFVNb9DCXXL0A,10418
 _mcp_mesh/engine/signature_analyzer.py,sha256=AxBuFq8_TCT2afw_XDF4AjWPqdG6ST5jfbw2BDdp9Mo,7482
-_mcp_mesh/engine/threading_utils.py,sha256=TAot2lLxSO_0QeAO8c0XBvZeJ6Ho6ljKtR0WINV7o7o,8244
-_mcp_mesh/engine/unified_mcp_proxy.py,sha256=r1nbJ_adRAbblDK8f-4AffxszJqkqtwvEwRKw-tczPA,36095
+_mcp_mesh/engine/unified_mcp_proxy.py,sha256=33xm-jABTYUwr_uIB6mx4yNlNJrsvstCHJOMTdcm-pg,36365
 _mcp_mesh/generated/.openapi-generator-ignore,sha256=-d-Y-RVAZRrHw36jO0b79oDXpfA8rZdBGPCG4Vs_rUs,227
 _mcp_mesh/generated/.openapi-generator/FILES,sha256=BXFXHe4FTV5GFUTNjMhmvOrVcYVlHJc5O-3UXyp8OCY,2169
 _mcp_mesh/generated/.openapi-generator/VERSION,sha256=nMm490YXJUW3_vAdeAsg7E3yRgUqVwk5-50PuaFonM8,7
@@ -69,30 +68,31 @@ _mcp_mesh/pipeline/api_heartbeat/api_registry_connection.py,sha256=6N0JdXdnLkaXa
 _mcp_mesh/pipeline/api_startup/__init__.py,sha256=eivolkSKot2bJTWP2BV8-RKRT1Zm7SGQYuEUiTxusOQ,577
 _mcp_mesh/pipeline/api_startup/api_pipeline.py,sha256=w4m7LP7qnpLxYYWy4moa_8inAWFT0jWy9i7G9WGWOCM,2546
 _mcp_mesh/pipeline/api_startup/api_server_setup.py,sha256=Qy0wbXyIWIQYA7CjiGVZwn0nWCKK85ZzFTRI2JDA9Aw,15099
-_mcp_mesh/pipeline/api_startup/fastapi_discovery.py,sha256=BOo7_cBwABNpk_3Y-Lh_3ygwAOQ_254dwblPyO_vLIw,11991
+_mcp_mesh/pipeline/api_startup/fastapi_discovery.py,sha256=MV3hvDXvX7r1Mrn6LAReu9W3hKt-5-jDhPpPYwZXnco,5770
 _mcp_mesh/pipeline/api_startup/middleware_integration.py,sha256=ybImXZlmIR6yA-wYg5Zy_ZMFF9YgToLkk4jnBeZJ7WY,6267
 _mcp_mesh/pipeline/api_startup/route_collection.py,sha256=UjA-F5_RbGVU5TfDT19Np5_x2PtYkNn2mGFyivDsk24,2031
 _mcp_mesh/pipeline/api_startup/route_integration.py,sha256=aMT7p7cwK8N3tZBRqeGQF8upc7tU-Exj6Dz0a4cSBhU,13441
 _mcp_mesh/pipeline/mcp_heartbeat/__init__.py,sha256=nRNjZ3VD_9bPLQuJ6Nc02gE7KSLcMP7TMquB0hP6hHs,844
 _mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py,sha256=nHjKSM4Yyn05wnfw1dI4VGroHZy8lRkDihnZfFHeF8U,16217
 _mcp_mesh/pipeline/mcp_heartbeat/fast_heartbeat_check.py,sha256=QTzYdL81WERkOaBVOgNbFQh1ddTn70urNtyIgtFTudA,4465
-_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_orchestrator.py,sha256=56IK5p8xlppJ5i6oMMh12fin3XwrOTcppTuVO2CnlV8,11292
+_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_orchestrator.py,sha256=uB9o298X7GbOaKUw4ij_fUAOCpK0n2brx_oWqWGTXFY,11296
 _mcp_mesh/pipeline/mcp_heartbeat/heartbeat_pipeline.py,sha256=Jb7EVJO13trUVO3aCSgzGqAtoc4vie5kDrYLZtOkiXg,11601
 _mcp_mesh/pipeline/mcp_heartbeat/heartbeat_send.py,sha256=ydVx-Vb_RgW1WPCboHVdZfEwNbgDngFV6Y9elZIBrAw,3602
-_mcp_mesh/pipeline/mcp_heartbeat/lifespan_integration.py,sha256=yCt731vgniSfxuClIcMvlMtDrubTu_9crgwiOwOYoBQ,2510
+_mcp_mesh/pipeline/mcp_heartbeat/lifespan_integration.py,sha256=4XPPlaJ6rz-FkDO3bxzVxHmVF-aq1CCaTW4vIBXrB0c,3016
 _mcp_mesh/pipeline/mcp_heartbeat/registry_connection.py,sha256=4abbOKN3echwX82PV0RvxF6cJZUu0pMgisOpILZ_ZzY,2875
-_mcp_mesh/pipeline/mcp_startup/__init__.py,sha256=_Y25DgT9eYJ_7Qe7x1Z7y4VFUIaFEmCBS9YD9QIlo7k,1142
+_mcp_mesh/pipeline/mcp_startup/__init__.py,sha256=gS0xNmVx66bkLUMw64olMsN40ZLPH3ymwlLixZ4NuTs,1239
 _mcp_mesh/pipeline/mcp_startup/configuration.py,sha256=6LRLIxrqFMU76qrBb6GjGknUlKPZZ9iqOlxE7F9ZhLs,2808
 _mcp_mesh/pipeline/mcp_startup/decorator_collection.py,sha256=RHC6MHtfP9aP0hZ-IJjISZu72e0Pml3LU0qr7dc284w,2294
-_mcp_mesh/pipeline/mcp_startup/fastapiserver_setup.py,sha256=pQIrEc70qeWP732S9LF5A2qWq0CZ5wK-bxls7AjX_2o,33346
+_mcp_mesh/pipeline/mcp_startup/fastapiserver_setup.py,sha256=ktCn1IB8J3Iz7T0iUJF_ytwwO_RRbJN3dNQ6qZLY6iI,40229
 _mcp_mesh/pipeline/mcp_startup/fastmcpserver_discovery.py,sha256=ktsE9EZYdyZbCtCKB6HVdzGFMQ0E9n0-7I55LRO99sE,10270
 _mcp_mesh/pipeline/mcp_startup/heartbeat_loop.py,sha256=v85B0ynomvYu87eIvLe-aSZ7-Iwov2VtM4Fg3PkmrZs,3865
 _mcp_mesh/pipeline/mcp_startup/heartbeat_preparation.py,sha256=v3Fl0PvW5s7Ib_Cy7WtXA7gDvsFGiz54a-IlQRTcLPg,10410
-_mcp_mesh/pipeline/mcp_startup/startup_orchestrator.py,sha256=W9o_d0xTOAqK5i8Xd7BJgiUJou1uPZwsygslM3I9HYo,25149
-_mcp_mesh/pipeline/mcp_startup/startup_pipeline.py,sha256=E-kmmfkdtRMhpEAF-_qFLAdaY3sLo165SUHjlRXwqC4,2069
+_mcp_mesh/pipeline/mcp_startup/server_discovery.py,sha256=i3t12Dd2nEg3nbifyMGvm2SYr3WYiYJbicBakS3ZeuM,8007
+_mcp_mesh/pipeline/mcp_startup/startup_orchestrator.py,sha256=KldSG3xfGNm0iexnCMPkDsi3nuIVXBwneDBuoT5gJO4,26756
+_mcp_mesh/pipeline/mcp_startup/startup_pipeline.py,sha256=Y_VeZcvyT3y9phWtGD7cX92NzKZIzF2J6kRJUO8q-9U,2291
 _mcp_mesh/pipeline/shared/__init__.py,sha256=s9xmdf6LkoetrVRGd7Zp3NUxcJCW6YZ_yNKzUBcnYys,352
 _mcp_mesh/pipeline/shared/base_step.py,sha256=kyPbNUX79NyGrE_0Q-e-Aek7m1J0TW036njWfv0iZ0I,1080
-_mcp_mesh/pipeline/shared/mesh_pipeline.py,sha256=wTODlMb7ByhzsT3DnM0lzY3gS9fKLDUxL0yDEozCVeo,6494
+_mcp_mesh/pipeline/shared/mesh_pipeline.py,sha256=UlQBrPWqbruFiUdVYgFKgPOpp_sMVsO97nZsWX90k9U,6498
 _mcp_mesh/pipeline/shared/pipeline_types.py,sha256=iKSgzCoYu3bpIwLViw6lE7T7irEzOm7gpie29lyy7SQ,1504
 _mcp_mesh/pipeline/shared/registry_connection.py,sha256=jmlgULixRM1NMNyMc-8SJN3RpCtV9hUf76vn9nciAN4,2904
 _mcp_mesh/shared/__init__.py,sha256=L0detgEWjnc_XfxA_5vIBcaGTuLcT6AARKkUpUBIaH4,1116
@@ -104,6 +104,8 @@ _mcp_mesh/shared/fastapi_middleware_manager.py,sha256=_h10dSL9mgQstpJW_ZM2cpkU6y
 _mcp_mesh/shared/host_resolver.py,sha256=ycs6gXnI1zJX5KiqiLJPX5GkHX8r4j8NMHQOlG2J2X8,2964
 _mcp_mesh/shared/logging_config.py,sha256=n9AqShZ5BZgyrkoTlvux6ECRVpM9dUYvmGB0NPMl-Ak,2477
 _mcp_mesh/shared/registry_client_wrapper.py,sha256=d8yL-MiCrQr_WYdRFStOd531qaLv9kZjh0zJAmCJ-Cc,16976
+_mcp_mesh/shared/server_discovery.py,sha256=W5nsN-GvEVFD-7XkbMTxh-9FUIEiyWOxP3GYr8GNi3E,13142
+_mcp_mesh/shared/simple_shutdown.py,sha256=jnF1rTR2yR619LZnEjNlu-ZdKlB3PovxKqG0VZ3HDgE,8319
 _mcp_mesh/shared/sse_parser.py,sha256=OEPnfL9xL3rsjQrbyvfUO82WljPSDeO6Z61uUwN1NAo,8035
 _mcp_mesh/shared/support_types.py,sha256=k-ICF_UwDkHxQ1D5LwFZrp-UrNb4E5dzw02CRuLW9iI,7264
 _mcp_mesh/tracing/agent_context_helper.py,sha256=BIJ3Kc4Znd6emMAu97aUhSoxSIza3qYUmObLgc9ONiA,4765
@@ -114,9 +116,9 @@ _mcp_mesh/tracing/redis_metadata_publisher.py,sha256=F78E34qnI3D0tOmbHUTBsLbDst2
 _mcp_mesh/tracing/trace_context_helper.py,sha256=6tEkwjWFqMBe45zBlhacktmIpzJWTF950ph3bwL3cNc,5994
 _mcp_mesh/tracing/utils.py,sha256=t9lJuTH7CeuzAiiAaD0WxsJMFJPdzZFR0w6-vyR9f2E,3849
 mesh/__init__.py,sha256=l5RSMV8Kx0h7cvku8YkZPbTHjEPWciGT0bcEB2O_eNU,3242
-mesh/decorators.py,sha256=Ncpov2Up8EW_3n6_uMvKN613BqVWkdfWesd3SoufGDs,25673
+mesh/decorators.py,sha256=oBWoRE-FA3qUGygAUtk3-eAYBckwTGfTzvXOgCag4ys,36678
 mesh/types.py,sha256=g37DXAzya-xGPa1_WKlW3T3_VqyTn8ZVepIDSrhBTkc,10815
-mcp_mesh-0.5.4.dist-info/METADATA,sha256=rAqRHewsG0BBTs2tMiwg1khm3XIPIHb3-X8YgzC5BRE,4879
-mcp_mesh-0.5.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_mesh-0.5.4.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
-mcp_mesh-0.5.4.dist-info/RECORD,,
+mcp_mesh-0.5.6.dist-info/METADATA,sha256=Mh8nwL5wjm53WMFPOqcVHCRmcvbPa4sgMmX7bQV-yiw,4879
+mcp_mesh-0.5.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_mesh-0.5.6.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
+mcp_mesh-0.5.6.dist-info/RECORD,,