mcp-mesh 0.7.12__tar.gz → 0.7.13__tar.gz

{mcp_mesh-0.7.12 → mcp_mesh-0.7.13}/PKG-INFO

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

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

{mcp_mesh-0.7.12 → mcp_mesh-0.7.13}/_mcp_mesh/engine/__init__.py

@@ -17,13 +17,8 @@ __all__ = [
     # Dependency injection
     "DependencyInjector",
     "get_global_injector",
-    # MCP client proxies (legacy)
-    "MCPClientProxy",
-    "EnhancedMCPClientProxy",
-    "FullMCPProxy",
-    "EnhancedFullMCPProxy",
+    # MCP client proxies
     "AsyncMCPClient",
-    # Unified MCP proxy (recommended)
     "UnifiedMCPProxy",
     "EnhancedUnifiedMCPProxy",
     # Self-dependency proxy
@@ -59,22 +54,6 @@ def __getattr__(name):
 
         return get_global_injector
     # MCP client proxies
-    elif name == "MCPClientProxy":
-        from .mcp_client_proxy import MCPClientProxy
-
-        return MCPClientProxy
-    elif name == "EnhancedMCPClientProxy":
-        from .mcp_client_proxy import EnhancedMCPClientProxy
-
-        return EnhancedMCPClientProxy
-    elif name == "FullMCPProxy":
-        from .full_mcp_proxy import FullMCPProxy
-
-        return FullMCPProxy
-    elif name == "EnhancedFullMCPProxy":
-        from .full_mcp_proxy import EnhancedFullMCPProxy
-
-        return EnhancedFullMCPProxy
     elif name == "AsyncMCPClient":
         from .async_mcp_client import AsyncMCPClient
 

{mcp_mesh-0.7.12 → mcp_mesh-0.7.13}/_mcp_mesh/engine/async_mcp_client.py

@@ -1,10 +1,12 @@
 """Async HTTP client for MCP JSON-RPC protocol."""
 
+import asyncio
+import atexit
 import json
 import logging
 import urllib.error
 import urllib.request
-from typing import Any
+from typing import Any, ClassVar, Optional
 
 from ..shared.sse_parser import SSEParser
 
@@ -12,13 +14,67 @@ logger = logging.getLogger(__name__)
 
 
 class AsyncMCPClient:
-    """Async HTTP client for MCP JSON-RPC protocol."""
+    """Async HTTP client for MCP JSON-RPC protocol.
+
+    Uses connection pooling to reuse HTTP connections across requests,
+    reducing TCP/SSL handshake overhead and preventing port exhaustion.
+    """
+
+    # Class-level connection pool (shared across instances for same endpoint)
+    _client_pool: ClassVar[dict[str, "httpx.AsyncClient"]] = {}
+    _pool_lock: ClassVar[Optional[asyncio.Lock]] = None
+
+    # Default connection limits for pooling
+    DEFAULT_MAX_CONNECTIONS = 100
+    DEFAULT_MAX_KEEPALIVE_CONNECTIONS = 20
 
     def __init__(self, endpoint: str, timeout: float = 30.0):
         self.endpoint = endpoint
         self.timeout = timeout
         self.logger = logger.getChild(f"client.{endpoint}")
 
+    @classmethod
+    def _get_lock(cls) -> asyncio.Lock:
+        """Get or create the class-level lock (handles event loop creation)."""
+        if cls._pool_lock is None:
+            cls._pool_lock = asyncio.Lock()
+        return cls._pool_lock
+
+    @classmethod
+    async def _get_pooled_client(
+        cls, endpoint: str, timeout: float
+    ) -> "httpx.AsyncClient":
+        """Get or create a pooled httpx client for the endpoint.
+
+        This enables connection reuse across multiple requests to the same endpoint,
+        significantly reducing overhead from TCP connection establishment and SSL handshakes.
+        """
+        import httpx
+
+        async with cls._get_lock():
+            if endpoint not in cls._client_pool:
+                cls._client_pool[endpoint] = httpx.AsyncClient(
+                    timeout=timeout,
+                    limits=httpx.Limits(
+                        max_connections=cls.DEFAULT_MAX_CONNECTIONS,
+                        max_keepalive_connections=cls.DEFAULT_MAX_KEEPALIVE_CONNECTIONS,
+                    ),
+                )
+                logger.debug(f"Created pooled client for endpoint: {endpoint}")
+            return cls._client_pool[endpoint]
+
+    @classmethod
+    async def close_all_clients(cls) -> None:
+        """Close all pooled clients. Call during application shutdown."""
+        async with cls._get_lock():
+            for endpoint, client in list(cls._client_pool.items()):
+                try:
+                    await client.aclose()
+                    logger.debug(f"Closed pooled client for: {endpoint}")
+                except Exception as e:
+                    logger.warning(f"Error closing client for {endpoint}: {e}")
+            cls._client_pool.clear()
+
     async def call_tool(self, tool_name: str, arguments: dict) -> Any:
         """Call remote tool using MCP JSON-RPC protocol."""
         payload = {
@@ -38,37 +94,39 @@ class AsyncMCPClient:
             raise
 
     async def _make_request(self, payload: dict) -> dict:
-        """Make async HTTP request to MCP endpoint."""
+        """Make async HTTP request to MCP endpoint using pooled connections."""
         url = f"{self.endpoint}/mcp"
 
         try:
-            # Use httpx for proper async HTTP requests (better threading support than aiohttp)
+            # Use httpx with connection pooling for better resource management
             import httpx
 
-            async with httpx.AsyncClient(timeout=self.timeout) as client:
-                response = await client.post(
-                    url,
-                    json=payload,
-                    headers={
-                        "Content-Type": "application/json",
-                        "Accept": "application/json, text/event-stream",
-                    },
-                )
+            # Get pooled client (reuses connections across requests)
+            client = await self._get_pooled_client(self.endpoint, self.timeout)
 
-                if response.status_code == 404:
-                    raise RuntimeError(f"MCP endpoint not found at {url}")
-                elif response.status_code >= 400:
-                    raise RuntimeError(
-                        f"HTTP error {response.status_code}: {response.reason_phrase}"
-                    )
+            response = await client.post(
+                url,
+                json=payload,
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json, text/event-stream",
+                },
+            )
 
-                response_text = response.text
-
-                # Use shared SSE parser
-                data = SSEParser.parse_sse_response(
-                    response_text, f"AsyncMCPClient.{self.endpoint}"
+            if response.status_code == 404:
+                raise RuntimeError(f"MCP endpoint not found at {url}")
+            elif response.status_code >= 400:
+                raise RuntimeError(
+                    f"HTTP error {response.status_code}: {response.reason_phrase}"
                 )
 
+            response_text = response.text
+
+            # Use shared SSE parser
+            data = SSEParser.parse_sse_response(
+                response_text, f"AsyncMCPClient.{self.endpoint}"
+            )
+
             # Check for JSON-RPC error
             if "error" in data:
                 error = data["error"]
@@ -169,5 +227,10 @@ class AsyncMCPClient:
         return result
 
     async def close(self):
-        """Close client (no persistent connection to close)."""
+        """Close client instance (no-op as connections are pooled at class level).
+
+        Connection pooling is managed at the class level for efficiency.
+        To close all pooled connections during shutdown, use:
+            await AsyncMCPClient.close_all_clients()
+        """
         pass

{mcp_mesh-0.7.12 → mcp_mesh-0.7.13}/_mcp_mesh/engine/decorator_registry.py

@@ -664,27 +664,28 @@ class DecoratorRegistry:
         cls._immediate_uvicorn_server = None
         logger.debug("🔄 REGISTRY: Cleared immediate uvicorn server reference")
 
-    # Health check result storage
-    _health_check_result: dict | None = None
+    # Health check result storage (delegated to health_check_manager)
 
     @classmethod
     def store_health_check_result(cls, result: dict) -> None:
         """Store health check result for /health endpoint."""
-        cls._health_check_result = result
-        logger.debug(
-            f"💾 REGISTRY: Stored health check result: {result.get('status', 'unknown')}"
-        )
+        from ..shared.health_check_manager import store_health_check_result
+
+        store_health_check_result(result)
 
     @classmethod
     def get_health_check_result(cls) -> dict | None:
         """Get stored health check result."""
-        return cls._health_check_result
+        from ..shared.health_check_manager import get_health_check_result
+
+        return get_health_check_result()
 
     @classmethod
     def clear_health_check_result(cls) -> None:
         """Clear stored health check result."""
-        cls._health_check_result = None
-        logger.debug("🗑️ REGISTRY: Cleared health check result")
+        from ..shared.health_check_manager import clear_health_check_result
+
+        clear_health_check_result()
 
     @classmethod
     def store_fastmcp_lifespan(cls, lifespan: Any) -> None:

{mcp_mesh-0.7.12 → mcp_mesh-0.7.13}/_mcp_mesh/engine/dependency_injector.py

@@ -14,6 +14,11 @@ import weakref
 from collections.abc import Callable
 from typing import Any
 
+from ..shared.logging_config import (
+    format_log_value,
+    format_result_summary,
+    get_trace_prefix,
+)
 from .signature_analyzer import get_mesh_agent_positions, has_llm_agent_parameter
 
 logger = logging.getLogger(__name__)
@@ -448,17 +453,17 @@ class DependencyInjector:
 
             @functools.wraps(func)
             async def dependency_wrapper(*args, **kwargs):
+                # Get trace prefix if available
+                tp = get_trace_prefix()
+
+                # Log tool invocation - summary line
+                arg_keys = list(kwargs.keys()) if kwargs else []
                 wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: Function {func.__name__} called"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: args={args}, kwargs={kwargs}"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: mesh_positions={mesh_positions}"
+                    f"{tp}🔧 Tool '{func.__name__}' called with kwargs={arg_keys}"
                 )
+                # Log full args (will be TRACE later)
                 wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}"
+                    f"{tp}🔧 Tool '{func.__name__}' args: {format_log_value(kwargs)}"
                 )
 
                 # We know mesh_positions is not empty since we checked above
@@ -468,20 +473,14 @@ class DependencyInjector:
                 params = list(sig.parameters.keys())
                 final_kwargs = kwargs.copy()
 
-                wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: params={params}")
-                wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: original kwargs={kwargs}")
-
                 # Inject dependencies as kwargs (using array-based lookup)
                 injected_count = 0
+                injected_deps = []  # Track what was injected for logging
                 for dep_index, param_position in enumerate(mesh_positions):
                     if dep_index < len(dependencies):
                         dep_name = dependencies[dep_index]
                         param_name = params[param_position]
 
-                        wrapper_logger.debug(
-                            f"🔧 DEPENDENCY_WRAPPER: Processing dep {dep_index}: {dep_name} -> {param_name}"
-                        )
-
                         # Only inject if the parameter wasn't explicitly provided
                         if (
                             param_name not in final_kwargs
@@ -493,34 +492,25 @@ class DependencyInjector:
                                 dependency = dependency_wrapper._mesh_injected_deps[
                                     dep_index
                                 ]
-                            wrapper_logger.debug(
-                                f"🔧 DEPENDENCY_WRAPPER: From wrapper storage[{dep_index}]: {dependency}"
-                            )
 
                             if dependency is None:
                                 # Fallback to global storage with composite key
                                 dep_key = f"{func.__module__}.{func.__qualname__}:dep_{dep_index}"
                                 dependency = self.get_dependency(dep_key)
-                                wrapper_logger.debug(
-                                    f"🔧 DEPENDENCY_WRAPPER: From global storage[{dep_key}]: {dependency}"
-                                )
 
                             final_kwargs[param_name] = dependency
                             injected_count += 1
-                            wrapper_logger.debug(
-                                f"🔧 DEPENDENCY_WRAPPER: Injected {dep_name} from index {dep_index} as {param_name}"
-                            )
-                        else:
-                            wrapper_logger.debug(
-                                f"🔧 DEPENDENCY_WRAPPER: Skipping {param_name} - already provided"
+                            # Track for consolidated logging
+                            proxy_type = (
+                                type(dependency).__name__ if dependency else "None"
                             )
+                            injected_deps.append(f"{dep_name} → {proxy_type}")
 
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: Injected {injected_count} dependencies"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: final_kwargs={final_kwargs}"
-                )
+                # Log consolidated dependency injection summary
+                if injected_count > 0:
+                    wrapper_logger.debug(
+                        f"{tp}🔧 Injected {injected_count} dependencies: {', '.join(injected_deps)}"
+                    )
 
                 # ===== INJECT LLM AGENT IF PRESENT (Option A) =====
                 # Check if this function has @mesh.llm metadata attached (on the original function)
@@ -534,7 +524,7 @@ class DependencyInjector:
                         llm_agent = getattr(func, "_mesh_llm_agent", None)
                         final_kwargs[llm_param] = llm_agent
                         wrapper_logger.debug(
-                            f"🤖 LLM_INJECTION: Injected {llm_param}={llm_agent}"
+                            f"{tp}🤖 LLM_INJECTION: Injected {llm_param}={llm_agent}"
                         )
 
                 # ===== EXECUTE WITH DEPENDENCY INJECTION AND TRACING =====
@@ -543,10 +533,6 @@ class DependencyInjector:
 
                 original_func = func._mesh_original_func
 
-                wrapper_logger.debug(
-                    f"🔧 DI: Executing async function {original_func.__name__} with {injected_count} injected dependencies"
-                )
-
                 # Use ExecutionTracer's async method for clean tracing
                 result = await ExecutionTracer.trace_function_execution_async(
                     original_func,
@@ -558,26 +544,32 @@ class DependencyInjector:
                     wrapper_logger,
                 )
 
+                # Log result - summary line
                 wrapper_logger.debug(
-                    f"🔧 DI: Function {original_func.__name__} returned: {type(result)}"
+                    f"{tp}🔧 Tool '{func.__name__}' returned: {format_result_summary(result)}"
                 )
+                # Log full result (will be TRACE later)
+                wrapper_logger.debug(
+                    f"{tp}🔧 Tool '{func.__name__}' result: {format_log_value(result)}"
+                )
+
                 return result
 
         else:
             # Create sync wrapper for sync functions without dependencies
             @functools.wraps(func)
             def dependency_wrapper(*args, **kwargs):
+                # Get trace prefix if available
+                tp = get_trace_prefix()
+
+                # Log tool invocation - summary line
+                arg_keys = list(kwargs.keys()) if kwargs else []
                 wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: Function {func.__name__} called"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: args={args}, kwargs={kwargs}"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: mesh_positions={mesh_positions}"
+                    f"{tp}🔧 Tool '{func.__name__}' called with kwargs={arg_keys}"
                 )
+                # Log full args (will be TRACE later)
                 wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}"
+                    f"{tp}🔧 Tool '{func.__name__}' args: {format_log_value(kwargs)}"
                 )
 
                 # We know mesh_positions is not empty since we checked above
@@ -589,6 +581,7 @@ class DependencyInjector:
 
                 # Inject dependencies as kwargs (using array-based lookup)
                 injected_count = 0
+                injected_deps = []  # Track what was injected for logging
                 for dep_index, param_position in enumerate(mesh_positions):
                     if dep_index < len(dependencies):
                         dep_name = dependencies[dep_index]
@@ -613,6 +606,17 @@ class DependencyInjector:
 
                             final_kwargs[param_name] = dependency
                             injected_count += 1
+                            # Track for consolidated logging
+                            proxy_type = (
+                                type(dependency).__name__ if dependency else "None"
+                            )
+                            injected_deps.append(f"{dep_name} → {proxy_type}")
+
+                # Log consolidated dependency injection summary
+                if injected_count > 0:
+                    wrapper_logger.debug(
+                        f"{tp}🔧 Injected {injected_count} dependencies: {', '.join(injected_deps)}"
+                    )
 
                 # ===== INJECT LLM AGENT IF PRESENT (Option A) =====
                 # Check if this function has @mesh.llm metadata attached (on the original function)
@@ -626,19 +630,15 @@ class DependencyInjector:
                         llm_agent = getattr(func, "_mesh_llm_agent", None)
                         final_kwargs[llm_param] = llm_agent
                         wrapper_logger.debug(
-                            f"🤖 LLM_INJECTION: Injected {llm_param}={llm_agent}"
+                            f"{tp}🤖 LLM_INJECTION: Injected {llm_param}={llm_agent}"
                         )
 
                 # ===== EXECUTE WITH DEPENDENCY INJECTION AND TRACING =====
                 # Use ExecutionTracer for comprehensive execution logging (v0.4.0 style)
                 from ..tracing.execution_tracer import ExecutionTracer
 
-                wrapper_logger.debug(
-                    f"🔧 DI: Executing sync function {func._mesh_original_func.__name__} with {injected_count} injected dependencies"
-                )
-
                 # Use ExecutionTracer for clean execution tracing
-                return ExecutionTracer.trace_function_execution(
+                result = ExecutionTracer.trace_function_execution(
                     func._mesh_original_func,
                     args,
                     final_kwargs,
@@ -648,6 +648,17 @@ class DependencyInjector:
                     wrapper_logger,
                 )
 
+                # Log result - summary line
+                wrapper_logger.debug(
+                    f"{tp}🔧 Tool '{func.__name__}' returned: {format_result_summary(result)}"
+                )
+                # Log full result (will be TRACE later)
+                wrapper_logger.debug(
+                    f"{tp}🔧 Tool '{func.__name__}' result: {format_log_value(result)}"
+                )
+
+                return result
+
         # Store dependency state on wrapper as array (indexed by position)
         dependency_wrapper._mesh_injected_deps = [None] * len(dependencies)