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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.5.3
+Version: 0.5.4
 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.3 → mcp_mesh-0.5.4}/_mcp_mesh/__init__.py

@@ -31,7 +31,7 @@ from .engine.decorator_registry import (
     get_decorator_stats,
 )
 
-__version__ = "0.5.3"
+__version__ = "0.5.4"
 
 # Store reference to runtime processor if initialized
 _runtime_processor = None

{mcp_mesh-0.5.3 → mcp_mesh-0.5.4}/_mcp_mesh/engine/mcp_client_proxy.py

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

mcp_mesh-0.5.4/_mcp_mesh/engine/threading_utils.py

@@ -0,0 +1,223 @@
+"""Threading utilities for sync-to-async bridging with atexit bug fixes.
+
+Provides a consolidated implementation for running async operations from sync contexts
+while avoiding the Python 3.8+ atexit bug that occurs in daemon thread contexts.
+"""
+
+import asyncio
+import logging
+import queue
+import threading
+from collections.abc import Callable
+from typing import Any, Union
+
+logger = logging.getLogger(__name__)
+
+
+class ThreadingUtils:
+    """Utilities for safe sync-to-async bridging avoiding Python 3.8+ atexit issues."""
+
+    @staticmethod
+    def run_sync_from_async(
+        coro_or_func: Union[Any, Callable],
+        timeout: float = 60.0,
+        context_name: str = "operation",
+    ) -> Any:
+        """Convert async coroutine to sync call avoiding atexit bug.
+
+        Handles both coroutines and coroutine creation functions safely.
+
+        Args:
+            coro_or_func: Either a coroutine object or a function that returns a coroutine
+            timeout: Operation timeout in seconds
+            context_name: Name for logging/debugging context
+
+        Returns:
+            The result of the async operation
+
+        Raises:
+            TimeoutError: If operation exceeds timeout
+            RuntimeError: If operation fails or returns no result
+        """
+        import inspect
+
+        # If it's a function, call it to get the coroutine
+        if callable(coro_or_func) and not inspect.iscoroutine(coro_or_func):
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    # In running loop context, use thread-safe approach
+                    return ThreadingUtils._run_in_thread_safe(
+                        coro_or_func, timeout, context_name
+                    )
+                else:
+                    # No running loop, create coroutine and run directly
+                    coro = coro_or_func()
+                    return loop.run_until_complete(coro)
+            except RuntimeError:
+                # No event loop, use thread-safe approach
+                return ThreadingUtils._run_in_thread_safe(
+                    coro_or_func, timeout, context_name
+                )
+
+        # It's already a coroutine, handle it
+        coro = coro_or_func
+
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # Use thread-safe approach for running loops
+                return ThreadingUtils._run_coroutine_in_thread(
+                    coro, timeout, context_name
+                )
+            else:
+                # No running loop, safe to use directly
+                return loop.run_until_complete(coro)
+        except RuntimeError:
+            # No event loop exists, use thread-safe approach
+            return ThreadingUtils._run_coroutine_in_thread(coro, timeout, context_name)
+
+    @staticmethod
+    def _run_in_thread_safe(
+        coro_func: Callable, timeout: float, context_name: str
+    ) -> Any:
+        """Run coroutine creation function in thread-safe manner."""
+        result_queue: queue.Queue = queue.Queue()
+
+        def _thread_runner():
+            """Execute coroutine function in isolated thread context."""
+            try:
+                # Apply atexit bypass for this thread
+                ThreadingUtils._apply_atexit_bypass()
+
+                # Create fresh event loop
+                new_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(new_loop)
+
+                try:
+                    # Create coroutine in this thread's context
+                    coro = coro_func()
+                    result = new_loop.run_until_complete(coro)
+                    result_queue.put(("success", result))
+                except Exception as e:
+                    logger.error(
+                        f"❌ {context_name} failed in thread: {e}", exc_info=True
+                    )
+                    result_queue.put(("error", e))
+                finally:
+                    # Manual cleanup without relying on atexit
+                    try:
+                        new_loop.close()
+                    finally:
+                        asyncio.set_event_loop(None)
+
+            except Exception as e:
+                logger.error(
+                    f"❌ {context_name} thread setup failed: {e}", exc_info=True
+                )
+                result_queue.put(("error", e))
+
+        # Use non-daemon thread to avoid atexit issues
+        thread = threading.Thread(
+            target=_thread_runner, daemon=False, name=f"MCPMesh-{context_name}"
+        )
+        thread.start()
+        thread.join(timeout=timeout)
+
+        if thread.is_alive():
+            logger.error(f"⏰ {context_name} timed out after {timeout}s")
+            raise TimeoutError(f"{context_name} timed out after {timeout}s")
+
+        if result_queue.empty():
+            raise RuntimeError(f"No result from {context_name}")
+
+        status, result = result_queue.get()
+        if status == "error":
+            raise result
+
+        logger.debug(f"✅ {context_name} completed successfully in thread")
+        return result
+
+    @staticmethod
+    def _run_coroutine_in_thread(coro: Any, timeout: float, context_name: str) -> Any:
+        """Run existing coroutine in thread-safe manner."""
+        result_queue: queue.Queue = queue.Queue()
+
+        def _thread_runner():
+            """Execute coroutine in isolated thread context."""
+            try:
+                # Apply atexit bypass for this thread
+                ThreadingUtils._apply_atexit_bypass()
+
+                # Create fresh event loop
+                new_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(new_loop)
+
+                try:
+                    result = new_loop.run_until_complete(coro)
+                    result_queue.put(("success", result))
+                except Exception as e:
+                    logger.error(
+                        f"❌ {context_name} coroutine failed: {e}", exc_info=True
+                    )
+                    result_queue.put(("error", e))
+                finally:
+                    # Manual cleanup without relying on atexit
+                    try:
+                        new_loop.close()
+                    finally:
+                        asyncio.set_event_loop(None)
+
+            except Exception as e:
+                logger.error(
+                    f"❌ {context_name} thread setup failed: {e}", exc_info=True
+                )
+                result_queue.put(("error", e))
+
+        # Use non-daemon thread to avoid atexit issues
+        thread = threading.Thread(
+            target=_thread_runner, daemon=False, name=f"MCPMesh-{context_name}"
+        )
+        thread.start()
+        thread.join(timeout=timeout)
+
+        if thread.is_alive():
+            logger.error(f"⏰ {context_name} timed out after {timeout}s")
+            raise TimeoutError(f"{context_name} timed out after {timeout}s")
+
+        if result_queue.empty():
+            raise RuntimeError(f"No result from {context_name}")
+
+        status, result = result_queue.get()
+        if status == "error":
+            raise result
+
+        logger.debug(f"✅ {context_name} completed successfully in thread")
+        return result
+
+    @staticmethod
+    def _apply_atexit_bypass():
+        """Apply atexit bypass for current thread to prevent registration errors."""
+        try:
+            import atexit
+            import threading
+
+            # Store originals
+            original_atexit_register = atexit.register
+            original_thread_register = getattr(threading, "_register_atexit", None)
+
+            # Apply temporary bypass
+            def _noop_register(*args, **kwargs):
+                """No-op atexit registration to prevent threading issues."""
+                pass
+
+            atexit.register = _noop_register
+            if original_thread_register:
+                threading._register_atexit = _noop_register
+
+            # Store cleanup function for potential restoration
+            # (In practice, these threads are short-lived so restoration isn't critical)
+
+        except Exception as e:
+            # If atexit bypass fails, log but continue
+            logger.warning(f"⚠️ Failed to apply atexit bypass: {e}")

{mcp_mesh-0.5.3 → mcp_mesh-0.5.4}/_mcp_mesh/engine/unified_mcp_proxy.py

@@ -10,6 +10,8 @@ import uuid
 from collections.abc import AsyncIterator
 from typing import Any, Optional
 
+from .threading_utils import ThreadingUtils
+
 logger = logging.getLogger(__name__)
 
 
@@ -829,6 +831,15 @@ class EnhancedUnifiedMCPProxy(UnifiedMCPProxy):
             f"auth_required: {self.auth_required}"
         )
 
+    def __call__(self, **kwargs) -> Any:
+        """Synchronous callable interface for dependency injection.
+
+        This method provides a sync interface for dependency injection.
+        Returns the actual result, not a coroutine.
+        """
+        # Use the enhanced tool call with proper sync-to-async bridging
+        return self.call_tool_auto(self.function_name, kwargs)
+
     async def call_tool_enhanced(self, name: str, arguments: dict = None) -> Any:
         """Enhanced tool call with retry logic and custom configuration."""
         last_exception = None
@@ -858,8 +869,19 @@ class EnhancedUnifiedMCPProxy(UnifiedMCPProxy):
         raise last_exception
 
     def call_tool_auto(self, name: str, arguments: dict = None) -> Any:
-        """Automatically choose streaming vs non-streaming based on configuration."""
-        if self.streaming_capable:
-            return self.call_tool_streaming(name, arguments)
-        else:
-            return self.call_tool_enhanced(name, arguments)
+        """Automatically choose streaming vs non-streaming based on configuration.
+
+        Uses shared ThreadingUtils for consistent DNS-safe threading behavior.
+        """
+        # Create coroutine function based on streaming capability
+        def coro_func():
+            if self.streaming_capable:
+                return self.call_tool_streaming(name, arguments)
+            else:
+                return self.call_tool_enhanced(name, arguments)
+
+        return ThreadingUtils.run_sync_from_async(
+            coro_func,
+            timeout=self.timeout or 60.0,
+            context_name=f"UnifiedMCPProxy.{name}",
+        )

{mcp_mesh-0.5.3 → mcp_mesh-0.5.4}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mcp-mesh"
-version = "0.5.3"
+version = "0.5.4"
 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.3"
+target-version = "0.5.4"
 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.3"
+python_version = "0.5.4"
 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.3"
+minversion = "0.5.4"
 addopts = "-ra -q --strict-markers --strict-config"
 testpaths = [
     "tests",