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

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

@@ -163,6 +163,11 @@ cython_debug/
 # VS Code
 .vscode/
 
+# Other IDEs/Tools
+.emigo_repomap/
+.windsurf/
+.windsurfrules
+
 # MCP Mesh specific
 *.mcpconfig
 .mcpconfig/
@@ -170,10 +175,11 @@ logs/
 .logs/
 capability_store/
 *.db
+*.pid
 
 # Go binaries
 mcp-mesh-dev
-mcp-mesh-registry
+/mcp-mesh-registry
 meshctl
 bin/meshctl
 *.exe
@@ -229,3 +235,4 @@ packaging/pypi/src/
 packaging/pypi/README.md
 packaging/pypi/LICENSE
 packaging/pypi/dist/
+MEDIUM-POST-MULTI-AGENT-POC.md

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.3.0
+Version: 0.6.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
@@ -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.6.4}/_mcp_mesh/__init__.py

@@ -31,7 +31,7 @@ from .engine.decorator_registry import (
     get_decorator_stats,
 )
 
-__version__ = "0.3.0"
+__version__ = "0.6.4"
 
 # 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.6.4}/_mcp_mesh/engine/__init__.py

@@ -17,12 +17,15 @@ __all__ = [
     # Dependency injection
     "DependencyInjector",
     "get_global_injector",
-    # MCP client proxies
+    # MCP client proxies (legacy)
     "MCPClientProxy",
     "EnhancedMCPClientProxy",
     "FullMCPProxy",
     "EnhancedFullMCPProxy",
     "AsyncMCPClient",
+    # Unified MCP proxy (recommended)
+    "UnifiedMCPProxy",
+    "EnhancedUnifiedMCPProxy",
     # Self-dependency proxy
     "SelfDependencyProxy",
     # Decorator registry
@@ -76,6 +79,14 @@ def __getattr__(name):
         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.6.4}/_mcp_mesh/engine/async_mcp_client.py

@@ -6,6 +6,8 @@ import urllib.error
 import urllib.request
 from typing import Any
 
+from ..shared.sse_parser import SSEParser
+
 logger = logging.getLogger(__name__)
 
 
@@ -37,7 +39,7 @@ class AsyncMCPClient:
 
     async def _make_request(self, payload: dict) -> dict:
         """Make async HTTP request to MCP endpoint."""
-        url = f"{self.endpoint}/mcp/"
+        url = f"{self.endpoint}/mcp"
 
         try:
             # Use httpx for proper async HTTP requests (better threading support than aiohttp)
@@ -62,25 +64,10 @@ class AsyncMCPClient:
 
                 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()
+                # 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 +91,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

mcp_mesh-0.6.4/_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