mcp-mesh 0.3.0__tar.gz → 0.7.15__tar.gz

{mcp_mesh-0.3.0 → mcp_mesh-0.7.15}/.gitignore

@@ -163,19 +163,26 @@ cython_debug/
 # VS Code
 .vscode/
 
+# Other IDEs/Tools
+.emigo_repomap/
+.windsurf/
+.windsurfrules
+
 # MCP Mesh specific
 *.mcpconfig
 .mcpconfig/
 logs/
 .logs/
 capability_store/
+prompts/
 *.db
+*.pid
 
 # Go binaries
 mcp-mesh-dev
-mcp-mesh-registry
-meshctl
-bin/meshctl
+/mcp-mesh-registry
+/meshctl
+bin/
 *.exe
 *.dll
 *.dylib
@@ -229,3 +236,12 @@ packaging/pypi/src/
 packaging/pypi/README.md
 packaging/pypi/LICENSE
 packaging/pypi/dist/
+MEDIUM-POST-MULTI-AGENT-POC.md
+
+# Helm chart dependency packages (regenerate with: helm dependency update)
+helm/*/charts/*.tgz
+
+# Helm chart files copied during release (generated from observability/)
+helm/mcp-mesh-grafana/files/
+helm/mcp-mesh-tempo/files/
+*.DS_Store

{mcp_mesh-0.3.0 → mcp_mesh-0.7.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.3.0
+Version: 0.7.15
 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
@@ -23,10 +23,13 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.11
 Requires-Dist: aiohttp<4.0.0,>=3.8.0
+Requires-Dist: cachetools>=5.3.0
 Requires-Dist: click<9.0.0,>=8.1.0
 Requires-Dist: fastapi<1.0.0,>=0.104.0
 Requires-Dist: fastmcp<3.0.0,>=2.8.0
 Requires-Dist: httpx<1.0.0,>=0.25.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: litellm>=1.30.0
 Requires-Dist: mcp<2.0.0,>=1.9.0
 Requires-Dist: prometheus-client<1.0.0,>=0.19.0
 Requires-Dist: pydantic<3.0.0,>=2.4.0

{mcp_mesh-0.3.0 → mcp_mesh-0.7.15}/_mcp_mesh/__init__.py

@@ -31,7 +31,7 @@ from .engine.decorator_registry import (
     get_decorator_stats,
 )
 
-__version__ = "0.3.0"
+__version__ = "0.7.15"
 
 # Store reference to runtime processor if initialized
 _runtime_processor = None
@@ -48,7 +48,7 @@ def initialize_runtime():
         # Legacy processor system has been replaced by pipeline architecture
 
         # Use pipeline-based runtime
-        from .pipeline.startup import start_runtime
+        from .pipeline.mcp_startup import start_runtime
 
         start_runtime()
 
@@ -59,8 +59,22 @@ def initialize_runtime():
 
 
 # Auto-initialize runtime if enabled
-if os.getenv("MCP_MESH_ENABLED", "true").lower() == "true":
-    initialize_runtime()
+if (
+    os.getenv("MCP_MESH_ENABLED", "true").lower() == "true"
+    and os.getenv("MCP_MESH_AUTO_RUN", "true").lower() == "true"
+):
+    # Use debounced initialization instead of immediate MCP startup
+    # This allows the system to determine MCP vs API pipeline based on decorators
+    try:
+        from .pipeline.mcp_startup import start_runtime
+
+        # Start the debounced runtime (sets up coordinator, no immediate pipeline execution)
+        start_runtime()
+
+        sys.stderr.write("MCP Mesh debounced runtime initialized\n")
+    except Exception as e:
+        # Log but don't fail - allows graceful degradation
+        sys.stderr.write(f"MCP Mesh runtime initialization failed: {e}\n")
 
 
 __all__ = [

{mcp_mesh-0.3.0 → mcp_mesh-0.7.15}/_mcp_mesh/engine/__init__.py

@@ -18,11 +18,9 @@ __all__ = [
     "DependencyInjector",
     "get_global_injector",
     # MCP client proxies
-    "MCPClientProxy",
-    "EnhancedMCPClientProxy",
-    "FullMCPProxy",
-    "EnhancedFullMCPProxy",
     "AsyncMCPClient",
+    "UnifiedMCPProxy",
+    "EnhancedUnifiedMCPProxy",
     # Self-dependency proxy
     "SelfDependencyProxy",
     # Decorator registry
@@ -56,26 +54,18 @@ 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
 
         return AsyncMCPClient
+    elif name == "UnifiedMCPProxy":
+        from .unified_mcp_proxy import UnifiedMCPProxy
+
+        return UnifiedMCPProxy
+    elif name == "EnhancedUnifiedMCPProxy":
+        from .unified_mcp_proxy import EnhancedUnifiedMCPProxy
+
+        return EnhancedUnifiedMCPProxy
     # Self-dependency proxy
     elif name == "SelfDependencyProxy":
         from .self_dependency_proxy import SelfDependencyProxy

{mcp_mesh-0.3.0 → mcp_mesh-0.7.15}/_mcp_mesh/engine/async_mcp_client.py

@@ -1,22 +1,80 @@
 """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
 
 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 = {
@@ -36,51 +94,38 @@ class AsyncMCPClient:
             raise
 
     async def _make_request(self, payload: dict) -> dict:
-        """Make async HTTP request to MCP endpoint."""
-        url = f"{self.endpoint}/mcp/"
+        """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)
+
+            response = await client.post(
+                url,
+                json=payload,
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json, text/event-stream",
+                },
+            )
+
+            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}"
                 )
 
-                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
-
-                # Handle Server-Sent Events format from FastMCP
-                if response_text.startswith("event:"):
-                    # Parse SSE format: extract JSON from "data:" lines
-                    json_data = None
-                    for line in response_text.split("\n"):
-                        if line.startswith("data:"):
-                            json_str = line[5:].strip()  # Remove 'data:' prefix
-                            try:
-                                json_data = json.loads(json_str)
-                                break
-                            except json.JSONDecodeError:
-                                continue
-
-                    if json_data is None:
-                        raise RuntimeError("Could not parse SSE response from FastMCP")
-                    data = json_data
-                else:
-                    # Plain JSON response
-                    data = response.json()
+            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:
@@ -104,7 +149,7 @@ class AsyncMCPClient:
 
     async def _make_request_sync(self, payload: dict) -> dict:
         """Fallback sync HTTP request using urllib."""
-        url = f"{self.endpoint}/mcp/"
+        url = f"{self.endpoint}/mcp"
         data = json.dumps(payload).encode("utf-8")
 
         # Create request
@@ -182,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.15/_mcp_mesh/engine/base_injector.py

@@ -0,0 +1,171 @@
+"""
+Base injector class with shared wrapper creation logic.
+
+Provides common functionality for DependencyInjector and MeshLlmAgentInjector.
+"""
+
+import functools
+import inspect
+import logging
+import weakref
+from collections.abc import Callable
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class BaseInjector:
+    """
+    Base class for injection systems.
+
+    Provides shared functionality for creating and managing function wrappers
+    that support dynamic injection with two-phase updates.
+
+    Two-Phase Injection Pattern:
+    1. Phase 1 (decorator time): Create wrapper with initial state (None)
+    2. Phase 2 (runtime): Update wrapper with actual instances via update method
+
+    Subclasses must implement:
+    - Wrapper logic (what to inject and how)
+    - Update method signature
+    """
+
+    def __init__(self):
+        """Initialize base injector with function registry."""
+        self._function_registry: weakref.WeakValueDictionary = (
+            weakref.WeakValueDictionary()
+        )
+        logger.debug(f"🔧 {self.__class__.__name__} initialized")
+
+    def _register_wrapper(self, function_id: str, wrapper: Callable) -> None:
+        """
+        Register a wrapper in the function registry.
+
+        Args:
+            function_id: Unique function identifier
+            wrapper: Wrapper function to register
+        """
+        self._function_registry[function_id] = wrapper
+        logger.debug(f"🔧 Registered wrapper for {function_id} at {hex(id(wrapper))}")
+
+    def _create_async_wrapper(
+        self,
+        func: Callable,
+        function_id: str,
+        injection_logic: Callable[[Callable, tuple, dict], tuple],
+        metadata: dict[str, Any],
+    ) -> Callable:
+        """
+        Create async wrapper with injection logic.
+
+        Args:
+            func: Original async function to wrap
+            function_id: Unique function identifier
+            injection_logic: Callable that takes (func, args, kwargs) and returns (args, kwargs)
+                            This function should modify kwargs to inject dependencies
+            metadata: Additional metadata to store on wrapper
+
+        Returns:
+            Async wrapper function
+        """
+
+        @functools.wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            # Apply injection logic to modify kwargs
+            args, kwargs = injection_logic(func, args, kwargs)
+
+            # Execute original function
+            return await func(*args, **kwargs)
+
+        # Store metadata on wrapper
+        async_wrapper._mesh_original_func = func
+        async_wrapper._mesh_function_id = function_id
+
+        # Store additional metadata
+        for key, value in metadata.items():
+            setattr(async_wrapper, key, value)
+
+        return async_wrapper
+
+    def _create_sync_wrapper(
+        self,
+        func: Callable,
+        function_id: str,
+        injection_logic: Callable[[Callable, tuple, dict], tuple],
+        metadata: dict[str, Any],
+    ) -> Callable:
+        """
+        Create sync wrapper with injection logic.
+
+        Args:
+            func: Original sync function to wrap
+            function_id: Unique function identifier
+            injection_logic: Callable that takes (func, args, kwargs) and returns (args, kwargs)
+                            This function should modify kwargs to inject dependencies
+            metadata: Additional metadata to store on wrapper
+
+        Returns:
+            Sync wrapper function
+        """
+
+        @functools.wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            # Apply injection logic to modify kwargs
+            args, kwargs = injection_logic(func, args, kwargs)
+
+            # Execute original function
+            return func(*args, **kwargs)
+
+        # Store metadata on wrapper
+        sync_wrapper._mesh_original_func = func
+        sync_wrapper._mesh_function_id = function_id
+
+        # Store additional metadata
+        for key, value in metadata.items():
+            setattr(sync_wrapper, key, value)
+
+        return sync_wrapper
+
+    def create_wrapper_with_injection(
+        self,
+        func: Callable,
+        function_id: str,
+        injection_logic: Callable[[Callable, tuple, dict], tuple],
+        metadata: dict[str, Any],
+        register: bool = True,
+    ) -> Callable:
+        """
+        Create wrapper (async or sync) based on function type.
+
+        This is the main entry point for creating wrappers. It automatically
+        detects if the function is async or sync and creates the appropriate wrapper.
+
+        Args:
+            func: Function to wrap
+            function_id: Unique function identifier
+            injection_logic: Callable that takes (func, args, kwargs) and returns (args, kwargs)
+            metadata: Additional metadata to store on wrapper
+            register: Whether to register wrapper in function_registry (default: True)
+
+        Returns:
+            Wrapped function with injection capability
+        """
+        # Detect async vs sync
+        is_async = inspect.iscoroutinefunction(func)
+
+        if is_async:
+            wrapper = self._create_async_wrapper(
+                func, function_id, injection_logic, metadata
+            )
+            logger.debug(f"✅ Created async wrapper for {function_id}")
+        else:
+            wrapper = self._create_sync_wrapper(
+                func, function_id, injection_logic, metadata
+            )
+            logger.debug(f"✅ Created sync wrapper for {function_id}")
+
+        # Register wrapper if requested
+        if register:
+            self._register_wrapper(function_id, wrapper)
+
+        return wrapper