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

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

@@ -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 → mcp_mesh-0.5.6}/_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-0.5.5 → 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.5 → mcp_mesh-0.5.6}/_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-0.5.5 → mcp_mesh-0.5.6}/_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-0.5.6/_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 → mcp_mesh-0.5.6}/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-0.5.5 → mcp_mesh-0.5.6}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mcp-mesh"
-version = "0.5.5"
+version = "0.5.6"
 description = "Kubernetes-native platform for distributed MCP applications"
 readme = "README.md"
 license = { text = "MIT" }
@@ -117,7 +117,7 @@ extend-exclude = '''
 '''
 
 [tool.ruff]
-target-version = "0.5.5"
+target-version = "0.5.6"
 line-length = 88
 
 [tool.ruff.lint]
@@ -154,7 +154,7 @@ ignore = [
 "tests/**" = ["E712", "F841", "B007", "C401", "F401"]  # Relax style requirements for test files
 
 [tool.mypy]
-python_version = "0.5.5"
+python_version = "0.5.6"
 check_untyped_defs = false  # Temporarily relaxed
 disallow_any_generics = false  # Temporarily relaxed
 disallow_incomplete_defs = false  # Temporarily relaxed
@@ -166,7 +166,7 @@ warn_return_any = false  # Temporarily relaxed
 exclude = ["tests/", ".*agent_server_generated.*", ".*registry_client_generated.*"]  # Skip type checking for test and generated files
 
 [tool.pytest.ini_options]
-minversion = "0.5.5"
+minversion = "0.5.6"
 addopts = "-ra -q --strict-markers --strict-config"
 testpaths = [
     "tests",