mcp-mesh 0.5.5__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.5"
+__version__ = "0.5.6"
 
 # Store reference to runtime processor if initialized
 _runtime_processor = None

_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/fastapiserver_setup.py

@@ -96,6 +96,8 @@ class FastAPIServerSetupStep(PipelineStep):
                         result.add_error(f"Failed to wrap server '{server_key}': {e}")
 
             # Create FastAPI application with proper FastMCP lifespan integration (AFTER wrappers)
+            # Store context for shutdown coordination
+            self._current_context = context
             fastapi_app = self._create_fastapi_app(
                 agent_config, fastmcp_servers, heartbeat_config, mcp_wrappers
             )
@@ -333,8 +335,24 @@ class FastAPIServerSetupStep(PipelineStep):
                         try:
                             yield
                         finally:
-                            # Graceful shutdown - unregister from registry
-                            await self._graceful_shutdown(main_app)
+                            # Registry cleanup using simple shutdown
+                            context = getattr(self, "_current_context", {})
+                            registry_url = context.get(
+                                "registry_url", "http://localhost:8001"
+                            )
+                            agent_id = context.get("agent_id", "unknown")
+
+                            try:
+                                from ...shared.simple_shutdown import (
+                                    _simple_shutdown_coordinator,
+                                )
+
+                                _simple_shutdown_coordinator.set_shutdown_context(
+                                    registry_url, agent_id
+                                )
+                                await _simple_shutdown_coordinator.perform_registry_cleanup()
+                            except Exception as e:
+                                self.logger.error(f"❌ Registry cleanup error: {e}")
 
                             # Clean up all lifespans in reverse order
                             for ctx in reversed(lifespan_contexts):
@@ -359,8 +377,24 @@ class FastAPIServerSetupStep(PipelineStep):
                     try:
                         yield
                     finally:
-                        # Graceful shutdown - unregister from registry
-                        await self._graceful_shutdown(main_app)
+                        # Registry cleanup using simple shutdown
+                        context = getattr(self, "_current_context", {})
+                        registry_url = context.get(
+                            "registry_url", "http://localhost:8001"
+                        )
+                        agent_id = context.get("agent_id", "unknown")
+
+                        try:
+                            from ...shared.simple_shutdown import (
+                                _simple_shutdown_coordinator,
+                            )
+
+                            _simple_shutdown_coordinator.set_shutdown_context(
+                                registry_url, agent_id
+                            )
+                            await _simple_shutdown_coordinator.perform_registry_cleanup()
+                        except Exception as e:
+                            self.logger.error(f"❌ Registry cleanup error: {e}")
 
                 primary_lifespan = graceful_shutdown_only_lifespan
 
@@ -373,6 +407,8 @@ class FastAPIServerSetupStep(PipelineStep):
                 lifespan=primary_lifespan,
             )
 
+            # Registry cleanup is now integrated directly into the lifespan above
+
             # Store app reference for global shutdown coordination
             app.state.shutdown_step = self
 

_mcp_mesh/pipeline/mcp_startup/startup_orchestrator.py

@@ -305,10 +305,8 @@ class DebounceCoordinator:
 
         except KeyboardInterrupt:
             self.logger.info(
-                "🔴 Received KeyboardInterrupt, performing graceful shutdown..."
+                "🔴 Received KeyboardInterrupt, shutdown will be handled by FastAPI lifespan"
             )
-            # Perform graceful shutdown before exiting
-            self._perform_graceful_shutdown()
         except Exception as e:
             self.logger.error(f"❌ FastAPI server error: {e}")
             raise
@@ -427,64 +425,7 @@ class DebounceCoordinator:
             self.logger.warning(f"⚠️ Could not setup MCP heartbeat: {e}")
             # Don't fail - heartbeat is optional for MCP agents
 
-    def _perform_graceful_shutdown(self) -> None:
-        """Perform graceful shutdown by unregistering from registry."""
-        try:
-            # Run graceful shutdown asynchronously
-            import asyncio
-
-            asyncio.run(self._graceful_shutdown_async())
-        except Exception as e:
-            self.logger.error(f"❌ Graceful shutdown failed: {e}")
-
-    async def _graceful_shutdown_async(self) -> None:
-        """Async graceful shutdown implementation."""
-        try:
-            # Get the latest pipeline context from the orchestrator
-            if self._orchestrator is None:
-                self.logger.warning(
-                    "🚨 No orchestrator available for graceful shutdown"
-                )
-                return
-
-            # Access the pipeline context through the orchestrator
-            pipeline_context = getattr(self._orchestrator.pipeline, "_last_context", {})
-
-            # Get registry configuration
-            registry_url = pipeline_context.get("registry_url")
-            agent_id = pipeline_context.get("agent_id")
-
-            if not registry_url or not agent_id:
-                self.logger.warning(
-                    f"🚨 Cannot perform graceful shutdown: missing registry_url={registry_url} or agent_id={agent_id}"
-                )
-                return
-
-            # Create registry client for shutdown
-            from ...generated.mcp_mesh_registry_client.api_client import ApiClient
-            from ...generated.mcp_mesh_registry_client.configuration import (
-                Configuration,
-            )
-            from ...shared.registry_client_wrapper import RegistryClientWrapper
-
-            config = Configuration(host=registry_url)
-            api_client = ApiClient(configuration=config)
-            registry_wrapper = RegistryClientWrapper(api_client)
-
-            # Perform graceful unregistration
-            success = await registry_wrapper.unregister_agent(agent_id)
-            if success:
-                self.logger.info(
-                    f"🏁 Graceful shutdown completed for agent '{agent_id}'"
-                )
-            else:
-                self.logger.warning(
-                    f"⚠️ Graceful shutdown failed for agent '{agent_id}' - continuing shutdown"
-                )
-
-        except Exception as e:
-            # Don't fail the shutdown process due to unregistration errors
-            self.logger.error(f"❌ Graceful shutdown error: {e} - continuing shutdown")
+    # Graceful shutdown is now handled by FastAPI lifespan in simple_shutdown.py
 
     def _check_auto_run_enabled(self) -> bool:
         """Check if auto-run is enabled (defaults to True for persistent service behavior)."""
@@ -703,9 +644,7 @@ def start_runtime() -> None:
 
     logger.info("🔧 Starting MCP Mesh runtime with debouncing")
 
-    # Install minimal signal handlers for graceful shutdown
-    # This restores the DELETE /heartbeats call that was removed during DNS fix
-    _install_minimal_signal_handlers()
+    # Signal handlers removed - cleanup now handled by FastAPI lifespan
 
     # Create orchestrator and set up debouncing
     orchestrator = get_global_orchestrator()
@@ -722,96 +661,7 @@ def start_runtime() -> None:
     # through the debounce coordinator
 
 
-def _install_minimal_signal_handlers() -> None:
-    """
-    Install minimal signal handlers that only perform graceful shutdown.
-
-    This restores the DELETE /heartbeats functionality that was removed during
-    the DNS threading fix while avoiding complex operations that could conflict
-    with DNS resolution in containerized environments.
-    """
-    import signal
-
-    def graceful_shutdown_signal_handler(signum, frame):
-        """Handle shutdown signals by performing graceful unregistration."""
-        try:
-            logger.info(f"🚨 Received signal {signum}, performing graceful shutdown...")
-
-            # Get the global orchestrator to access pipeline context
-            orchestrator = get_global_orchestrator()
-            if orchestrator and hasattr(orchestrator.pipeline, "_last_context"):
-                pipeline_context = orchestrator.pipeline._last_context
-
-                # Get registry configuration
-                registry_url = pipeline_context.get("registry_url")
-                agent_id = pipeline_context.get("agent_id")
-
-                if registry_url and agent_id:
-                    # Perform synchronous graceful shutdown
-                    import asyncio
-
-                    try:
-                        # Create new event loop for shutdown
-                        loop = asyncio.new_event_loop()
-                        asyncio.set_event_loop(loop)
-
-                        # Run graceful shutdown
-                        loop.run_until_complete(
-                            _perform_signal_graceful_shutdown(registry_url, agent_id)
-                        )
-                        loop.close()
-
-                        logger.info(
-                            f"🏁 Graceful shutdown completed for agent '{agent_id}'"
-                        )
-                    except Exception as e:
-                        logger.error(f"❌ Graceful shutdown error: {e}")
-                else:
-                    logger.warning(
-                        f"🚨 Cannot perform graceful shutdown: missing registry_url={registry_url} or agent_id={agent_id}"
-                    )
-            else:
-                logger.warning(
-                    "🚨 No orchestrator context available for graceful shutdown"
-                )
-
-        except Exception as e:
-            logger.error(f"❌ Signal handler error: {e}")
-        finally:
-            # Exit cleanly
-            logger.info("🛑 Exiting...")
-            sys.exit(0)
-
-    # Install handlers for common termination signals
-    signal.signal(signal.SIGTERM, graceful_shutdown_signal_handler)
-    signal.signal(signal.SIGINT, graceful_shutdown_signal_handler)
-
-    logger.debug("🛡️ Minimal signal handlers installed for graceful shutdown")
-
-
-async def _perform_signal_graceful_shutdown(registry_url: str, agent_id: str) -> None:
-    """Perform graceful shutdown from signal handler context."""
-    try:
-        # Create registry client for shutdown
-        from ...generated.mcp_mesh_registry_client.api_client import ApiClient
-        from ...generated.mcp_mesh_registry_client.configuration import Configuration
-        from ...shared.registry_client_wrapper import RegistryClientWrapper
-
-        config = Configuration(host=registry_url)
-        api_client = ApiClient(configuration=config)
-        registry_wrapper = RegistryClientWrapper(api_client)
-
-        # Perform graceful unregistration (this sends DELETE /heartbeats)
-        success = await registry_wrapper.unregister_agent(agent_id)
-        if success:
-            logger.info(
-                f"✅ Agent '{agent_id}' successfully unregistered from registry"
-            )
-        else:
-            logger.warning(f"⚠️ Failed to unregister agent '{agent_id}' from registry")
-
-    except Exception as e:
-        logger.error(f"❌ Signal graceful shutdown error: {e}")
+# Signal handlers removed - cleanup now handled by FastAPI lifespan in simple_shutdown.py
 
 
 # Minimal signal handlers restored to provide graceful shutdown with DELETE /heartbeats

_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.5.dist-info → mcp_mesh-0.5.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.5.5
+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.5.dist-info → mcp_mesh-0.5.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-_mcp_mesh/__init__.py,sha256=nHqtNT23PCrZB_z_T1tH7X9lMXSB2G3j0_ZGa5NtCz0,2719
+_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=0-GI7DILpbB6GRLIYhZu0DcdHEA62d89jDYxkK1ywiM,22422
@@ -78,17 +78,17 @@ _mcp_mesh/pipeline/mcp_heartbeat/fast_heartbeat_check.py,sha256=QTzYdL81WERkOaBV
 _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=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=pxw-_mJ74bKmI3dD-Goi-eXBZxHnNNWcP6X9zc65n7A,38408
+_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/server_discovery.py,sha256=i3t12Dd2nEg3nbifyMGvm2SYr3WYiYJbicBakS3ZeuM,8007
-_mcp_mesh/pipeline/mcp_startup/startup_orchestrator.py,sha256=oaXHBo-p8eh1r3so3BWzdMtpMqPFFO1zISt0TPBKoqo,33103
+_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
@@ -101,11 +101,11 @@ _mcp_mesh/shared/content_extractor.py,sha256=culjhieFl_J6EMDv1VFKvS38O3IMhWMs8fH
 _mcp_mesh/shared/defaults.py,sha256=5qazybkn7QHi418dXCS0b6QlNQl3DMg97ItzNGkc8d4,1851
 _mcp_mesh/shared/fast_heartbeat_status.py,sha256=OquEsX9ZTbxY1lIsll0Mbb2KDzSJD76sLMOlr3Z73Sc,5188
 _mcp_mesh/shared/fastapi_middleware_manager.py,sha256=_h10dSL9mgQstpJW_ZM2cpkU6yTKaYKlZaKXMk2i6IA,14638
-_mcp_mesh/shared/graceful_shutdown_manager.py,sha256=wH7iz9TNDr-lMnmvQH6UFSu-VrG6WgHB47Cu98icnGk,9239
 _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
@@ -116,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=9fhQFk5Ud34nYteRNc6FXOD_cVLLhlIOp9r9vtmJPjs,36186
+mesh/decorators.py,sha256=oBWoRE-FA3qUGygAUtk3-eAYBckwTGfTzvXOgCag4ys,36678
 mesh/types.py,sha256=g37DXAzya-xGPa1_WKlW3T3_VqyTn8ZVepIDSrhBTkc,10815
-mcp_mesh-0.5.5.dist-info/METADATA,sha256=pwYxy23zDrf8A0AfF4Gh8beldtvt0KJ3TGR309BL4ss,4879
-mcp_mesh-0.5.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_mesh-0.5.5.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
-mcp_mesh-0.5.5.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,,

mesh/decorators.py

@@ -12,6 +12,7 @@ from typing import Any, TypeVar
 # Import from _mcp_mesh for registry and runtime integration
 from _mcp_mesh.engine.decorator_registry import DecoratorRegistry
 from _mcp_mesh.shared.config_resolver import ValidationRule, get_config_value
+from _mcp_mesh.shared.simple_shutdown import start_blocking_loop_with_shutdown_support
 
 logger = logging.getLogger(__name__)
 
@@ -98,50 +99,49 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
             f"🚀 IMMEDIATE UVICORN: Starting uvicorn server on {http_host}:{port}"
         )
 
-        # Create uvicorn config and server but DON'T start it with asyncio.run()
-        # This prevents the dual event loop conflict
+        # Use uvicorn.run() for proper signal handling (enables FastAPI lifespan shutdown)
         logger.info(
-            "⚡ IMMEDIATE UVICORN: Creating uvicorn config without starting event loop"
-        )
-
-        config = uvicorn.Config(app=app, host=http_host, port=port, log_level="info")
-        server = uvicorn.Server(config)
-
-        # DON'T start the server here - let the pipeline handle the event loop
-        logger.info(
-            "✅ IMMEDIATE UVICORN: Uvicorn server configured (will be started by pipeline)"
+            "⚡ IMMEDIATE UVICORN: Starting server with uvicorn.run() for proper signal handling"
         )
 
         # Start uvicorn server in background thread (NON-daemon to keep process alive)
         def run_server():
-            """Run uvicorn server in background thread - keeps process alive."""
+            """Run uvicorn server in background thread with proper signal handling."""
             try:
                 logger.info(
                     f"🌟 IMMEDIATE UVICORN: Starting server on {http_host}:{port}"
                 )
-                server.run()  # This blocks and keeps the thread alive
+                # Use uvicorn.run() instead of Server().run() for proper signal handling
+                uvicorn.run(
+                    app,
+                    host=http_host,
+                    port=port,
+                    log_level="info",
+                    timeout_graceful_shutdown=30,  # Allow time for registry cleanup
+                    access_log=False,  # Reduce noise
+                )
             except Exception as e:
                 logger.error(f"❌ IMMEDIATE UVICORN: Server failed: {e}")
                 import traceback
 
                 logger.error(f"Server traceback: {traceback.format_exc()}")
 
-        # Start server in daemon thread (matches working test setup pattern)
-        thread = threading.Thread(target=run_server, daemon=True)
+        # Start server in non-daemon thread so it can handle signals properly
+        thread = threading.Thread(target=run_server, daemon=False)
         thread.start()
 
         logger.info(
-            "🔒 IMMEDIATE UVICORN: Server thread started (daemon=True) - matches working test setup"
+            "🔒 IMMEDIATE UVICORN: Server thread started (daemon=False) - can handle signals"
         )
 
         # Store server reference in DecoratorRegistry BEFORE starting (critical timing)
         server_info = {
             "app": app,
-            "server": server,  # Include uvicorn server object
-            "config": config,  # Include config for reference
+            "server": None,  # No server object with uvicorn.run()
+            "config": None,  # No config object needed
             "host": http_host,
             "port": port,
-            "thread": thread,  # Server thread (daemon)
+            "thread": thread,  # Server thread (non-daemon)
             "type": "immediate_uvicorn_running",
             "status": "running",  # Server is now running in background thread
         }
@@ -162,9 +162,18 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
             f"✅ IMMEDIATE UVICORN: Uvicorn server running on {http_host}:{port} (daemon thread)"
         )
 
+        # Set up registry context for shutdown cleanup (use defaults initially)
+        import os
+
+        from _mcp_mesh.shared.simple_shutdown import _simple_shutdown_coordinator
+
+        registry_url = os.getenv("MCP_MESH_REGISTRY_URL", "http://localhost:8000")
+        agent_id = "unknown"  # Will be updated by pipeline when available
+        _simple_shutdown_coordinator.set_shutdown_context(registry_url, agent_id)
+
         # CRITICAL FIX: Keep main thread alive to prevent shutdown state
         # This matches the working test setup pattern that prevents DNS resolution failures
-        # Uses graceful shutdown manager for clean code organization
+        # Uses simple shutdown with signal handlers for clean registry cleanup
         start_blocking_loop_with_shutdown_support(thread)
 
     except Exception as e:

_mcp_mesh/shared/graceful_shutdown_manager.py

@@ -1,236 +0,0 @@
-"""
-Graceful Shutdown Manager for MCP Mesh agents.
-
-This utility class manages graceful shutdown functionality, including signal handlers,
-shutdown context management, and coordination with FastAPI lifecycle and registry.
-"""
-
-import asyncio
-import logging
-import os
-import signal
-import sys
-from typing import Any, Optional
-
-logger = logging.getLogger(__name__)
-
-
-class GracefulShutdownManager:
-    """Manages graceful shutdown for MCP Mesh agents."""
-
-    def __init__(self):
-        self._shutdown_requested: bool = False
-        self._shutdown_context: dict[str, Any] = {}
-
-    def set_shutdown_context(self, context: dict[str, Any]) -> None:
-        """Set context for graceful shutdown (called from pipeline)."""
-        self._shutdown_context.update(context)
-
-        # Extract FastAPI app from context for coordinated shutdown
-        fastapi_app = context.get("fastapi_app")
-        if fastapi_app:
-            self._shutdown_context["fastapi_app"] = fastapi_app
-            logger.debug(
-                f"🔧 FastAPI app stored for coordinated shutdown: {type(fastapi_app)}"
-            )
-
-        logger.debug(
-            f"🔧 Shutdown context updated: agent_id={context.get('agent_id')}, registry_url={context.get('registry_url')}"
-        )
-
-    def install_signal_handlers(self) -> None:
-        """Install signal handlers that set the shutdown flag."""
-
-        def shutdown_signal_handler(signum, frame):
-            """Handle shutdown signals by setting the shutdown flag."""
-            logger.info(
-                f"🚨 SIGNAL HANDLER: Received signal {signum}, setting shutdown flag"
-            )
-            self._shutdown_requested = True
-
-        # Install handlers for common termination signals
-        signal.signal(signal.SIGTERM, shutdown_signal_handler)
-        signal.signal(signal.SIGINT, shutdown_signal_handler)
-
-        logger.info("🛡️ Signal handlers installed for graceful shutdown")
-
-    def is_shutdown_requested(self) -> bool:
-        """Check if shutdown has been requested."""
-        return self._shutdown_requested
-
-    def perform_graceful_shutdown_from_main_thread(self) -> None:
-        """Perform graceful shutdown from main thread (non-async context)."""
-        try:
-            # Check if we have FastAPI app for coordinated shutdown
-            fastapi_app = self._shutdown_context.get("fastapi_app")
-
-            if (
-                fastapi_app
-                and hasattr(fastapi_app, "state")
-                and hasattr(fastapi_app.state, "shutdown_step")
-            ):
-                # Use FastAPI lifespan shutdown mechanism
-                logger.info("🚨 Triggering coordinated FastAPI shutdown...")
-                shutdown_step = fastapi_app.state.shutdown_step
-
-                # Create minimal context and call the existing graceful shutdown
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-
-                try:
-                    loop.run_until_complete(
-                        shutdown_step._graceful_shutdown(fastapi_app)
-                    )
-                    logger.info("✅ FastAPI coordinated shutdown completed")
-                    return
-                finally:
-                    loop.close()
-
-            # Fallback: Direct registry call if no FastAPI coordination available
-            logger.info("🚨 Using fallback direct registry shutdown...")
-
-            # Get registry_url from context or environment (with default)
-            registry_url = self._shutdown_context.get("registry_url")
-            if not registry_url:
-                registry_url = os.getenv(
-                    "MCP_MESH_REGISTRY_URL", "http://localhost:8000"
-                )
-                logger.debug(
-                    f"🔧 Using registry URL from environment/default: {registry_url}"
-                )
-
-            # Get agent_id from context or generate the same one used for registration
-            agent_id = self._shutdown_context.get("agent_id")
-            if not agent_id:
-                agent_id = self._get_or_create_agent_id()
-                logger.debug(f"🔧 Using agent ID from shared state: {agent_id}")
-
-            if not registry_url or not agent_id:
-                logger.warning(
-                    f"⚠️ Cannot perform graceful shutdown: missing registry_url={registry_url} or agent_id={agent_id}"
-                )
-                return
-
-            # Create registry client and perform shutdown synchronously
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-            try:
-                loop.run_until_complete(
-                    self._perform_graceful_shutdown_async(registry_url, agent_id)
-                )
-            finally:
-                loop.close()
-
-        except Exception as e:
-            logger.error(f"❌ Graceful shutdown error: {e}")
-
-    async def _perform_graceful_shutdown_async(
-        self, registry_url: str, agent_id: str
-    ) -> None:
-        """Async graceful shutdown implementation."""
-        try:
-            # Create registry client for shutdown
-            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=registry_url)
-            api_client = ApiClient(configuration=config)
-            registry_wrapper = RegistryClientWrapper(api_client)
-
-            # Perform graceful unregistration (this sends DELETE /heartbeats)
-            success = await registry_wrapper.unregister_agent(agent_id)
-            if success:
-                logger.info(
-                    f"✅ Agent '{agent_id}' successfully unregistered from registry"
-                )
-            else:
-                logger.warning(
-                    f"⚠️ Failed to unregister agent '{agent_id}' from registry"
-                )
-
-        except Exception as e:
-            logger.error(f"❌ Graceful shutdown error: {e}")
-
-    def _get_or_create_agent_id(self) -> str:
-        """Get agent ID using the existing decorator registry function."""
-        from mesh.decorators import _get_or_create_agent_id
-
-        return _get_or_create_agent_id()
-
-    def start_blocking_loop_with_shutdown_support(self, thread) -> None:
-        """
-        Start the main thread blocking loop with graceful shutdown support.
-
-        This keeps the main thread alive while monitoring for shutdown signals
-        and maintaining the server thread.
-        """
-        logger.info(
-            "🔒 MAIN THREAD: Blocking to keep alive (prevents threading shutdown state)"
-        )
-
-        # Install signal handlers
-        self.install_signal_handlers()
-
-        try:
-            while True:
-                # Check shutdown flag (set by signal handlers)
-                if self.is_shutdown_requested():
-                    logger.info(
-                        "🚨 MAIN THREAD: Shutdown requested, performing graceful cleanup..."
-                    )
-                    self.perform_graceful_shutdown_from_main_thread()
-                    break
-
-                if thread.is_alive():
-                    thread.join(timeout=1)  # Check every second
-                else:
-                    logger.warning("⚠️ Server thread died, exiting...")
-                    break
-        except KeyboardInterrupt:
-            logger.info("👋 MAIN THREAD: Received interrupt, shutting down gracefully")
-            self.perform_graceful_shutdown_from_main_thread()
-        except Exception as e:
-            logger.error(f"❌ MAIN THREAD: Error in blocking loop: {e}")
-
-        logger.info("🏁 MAIN THREAD: Exiting blocking loop")
-
-
-# Global instance for backward compatibility with existing decorators.py usage
-_global_shutdown_manager = GracefulShutdownManager()
-
-
-def get_global_shutdown_manager() -> GracefulShutdownManager:
-    """Get the global shutdown manager instance."""
-    return _global_shutdown_manager
-
-
-# Convenience functions for backward compatibility
-def set_shutdown_context(context: dict[str, Any]) -> None:
-    """Set context for graceful shutdown (global convenience function)."""
-    _global_shutdown_manager.set_shutdown_context(context)
-
-
-def install_graceful_shutdown_handlers() -> None:
-    """Install signal handlers that set the shutdown flag (global convenience function)."""
-    _global_shutdown_manager.install_signal_handlers()
-
-
-def is_shutdown_requested() -> bool:
-    """Check if shutdown has been requested (global convenience function)."""
-    return _global_shutdown_manager.is_shutdown_requested()
-
-
-def perform_graceful_shutdown_from_main_thread() -> None:
-    """Perform graceful shutdown from main thread (global convenience function)."""
-    _global_shutdown_manager.perform_graceful_shutdown_from_main_thread()
-
-
-def start_blocking_loop_with_shutdown_support(thread) -> None:
-    """Start the main thread blocking loop with graceful shutdown support (global convenience function)."""
-    _global_shutdown_manager.start_blocking_loop_with_shutdown_support(thread)