mcp-mesh 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

_mcp_mesh/__init__.py

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

_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/engine/async_mcp_client.py

@@ -39,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)
@@ -91,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/engine/decorator_registry.py

@@ -277,6 +277,28 @@ class DecoratorRegistry:
     # Cache for resolved agent configuration to avoid repeated work
     _cached_agent_config: Optional[dict[str, Any]] = None
 
+    @classmethod
+    def update_agent_config(cls, updates: dict[str, Any]) -> None:
+        """
+        Update the cached agent configuration with new values.
+        
+        This is useful for API services that generate their agent ID
+        during pipeline execution and need to store it for telemetry.
+        
+        Args:
+            updates: Dictionary of config values to update
+        """
+        if cls._cached_agent_config is None:
+            # Initialize with current resolved config if not cached yet
+            cls._cached_agent_config = cls.get_resolved_agent_config().copy()
+        
+        # Update with new values
+        cls._cached_agent_config.update(updates)
+        
+        logger.debug(
+            f"🔧 Updated cached agent configuration with: {updates}"
+        )
+
     @classmethod
     def get_resolved_agent_config(cls) -> dict[str, Any]:
         """
@@ -288,11 +310,14 @@ class DecoratorRegistry:
         Returns:
             dict: Pre-resolved configuration with consistent agent_id
         """
-        # Return cached configuration if available
-        if cls._cached_agent_config is not None:
+        # Step 1: Check if cached configuration already has agent_id (from API pipeline)
+        if cls._cached_agent_config is not None and cls._cached_agent_config.get('agent_id'):
+            logger.debug(
+                f"🔧 Using cached agent configuration: agent_id='{cls._cached_agent_config.get('agent_id')}'"
+            )
             return cls._cached_agent_config
 
-        # If we have explicit @mesh.agent configuration, use it
+        # Step 2: If we have explicit @mesh.agent configuration, use it
         if cls._mesh_agents:
             for agent_name, decorated_func in cls._mesh_agents.items():
                 # Return the already-resolved configuration from decorator
@@ -306,14 +331,23 @@ class DecoratorRegistry:
                 )
                 return resolved_config
 
-        # Fallback: Synthetic defaults when no @mesh.agent decorator exists
-        # This happens when only @mesh.tool decorators are used
-        from mesh.decorators import _get_or_create_agent_id
-
+        # Step 3: Fallback to synthetic defaults when no @mesh.agent decorator exists
+        # This happens when only @mesh.tool decorators are used and no cached agent_id
         from ..shared.config_resolver import ValidationRule, get_config_value
         from ..shared.defaults import MeshDefaults
 
-        agent_id = _get_or_create_agent_id()
+        # Check if we're in an API context (have mesh_route decorators)
+        mesh_routes = cls.get_all_by_type("mesh_route")
+        is_api_context = len(mesh_routes) > 0
+        
+        if is_api_context:
+            # Use API service ID generation logic for consistency
+            agent_id = cls._generate_api_service_id_fallback()
+        else:
+            # Use standard MCP agent ID generation
+            from mesh.decorators import _get_or_create_agent_id
+            agent_id = _get_or_create_agent_id()
+        
         fallback_config = {
             "name": None,
             "version": get_config_value(
@@ -368,6 +402,62 @@ class DecoratorRegistry:
         )
         return fallback_config
 
+    @classmethod
+    def _generate_api_service_id_fallback(cls) -> str:
+        """
+        Generate API service ID as fallback using same priority logic as API pipeline.
+        
+        Priority order:
+        1. MCP_MESH_API_NAME environment variable 
+        2. MCP_MESH_AGENT_NAME environment variable (fallback)
+        3. Default to "api-{uuid8}"
+        
+        Returns:
+            Generated service ID with UUID suffix matching API service format
+        """
+        import uuid
+        
+        from ..shared.config_resolver import ValidationRule, get_config_value
+        
+        # Check for API-specific environment variable first (same as API pipeline)
+        api_name = get_config_value(
+            "MCP_MESH_API_NAME",
+            default=None,
+            rule=ValidationRule.STRING_RULE,
+        )
+        
+        # Fallback to general agent name env var
+        if not api_name:
+            api_name = get_config_value(
+                "MCP_MESH_AGENT_NAME", 
+                default=None,
+                rule=ValidationRule.STRING_RULE,
+            )
+        
+        # Clean the service name if provided
+        if api_name:
+            cleaned_name = api_name.lower().replace(" ", "-").replace("_", "-")
+            cleaned_name = "-".join(part for part in cleaned_name.split("-") if part)
+        else:
+            cleaned_name = ""
+        
+        # Generate UUID suffix
+        uuid_suffix = str(uuid.uuid4())[:8]
+        
+        # Apply same naming logic as API pipeline
+        if not cleaned_name:
+            # No name provided: default to "api-{uuid8}"
+            service_id = f"api-{uuid_suffix}"
+        elif "api" in cleaned_name.lower():
+            # Name already contains "api": use "{name}-{uuid8}"
+            service_id = f"{cleaned_name}-{uuid_suffix}"
+        else:
+            # Name doesn't contain "api": use "{name}-api-{uuid8}"
+            service_id = f"{cleaned_name}-api-{uuid_suffix}"
+        
+        logger.debug(f"Generated fallback API service ID: '{service_id}' from env name: '{api_name}'")
+        return service_id
+
     @classmethod
     def get_all_agents(cls) -> list[tuple[Any, dict[str, Any]]]:
         """

_mcp_mesh/engine/dependency_injector.py

@@ -2,6 +2,8 @@
 Dynamic dependency injection system for MCP Mesh.
 
 Handles both initial injection and runtime updates when topology changes.
+Focused purely on dependency injection - telemetry/tracing is handled at 
+the HTTP middleware layer for unified approach across MCP agents and FastAPI apps.
 """
 
 import asyncio
@@ -288,9 +290,27 @@ class DependencyInjector:
                 f"🔧 No injection positions for {func.__name__}, creating minimal wrapper for tracking"
             )
 
-            @functools.wraps(func)
-            def minimal_wrapper(*args, **kwargs):
-                return func(*args, **kwargs)
+            # Check if we need async wrapper for minimal case
+            if inspect.iscoroutinefunction(func):
+                @functools.wraps(func)
+                async def minimal_wrapper(*args, **kwargs):
+                    # Use ExecutionTracer for functions without dependencies (v0.4.0 style)
+                    from ..tracing.execution_tracer import ExecutionTracer
+                    wrapper_logger.debug(f"🔧 DI: Executing async function {func.__name__} (no dependencies)")
+                    
+                    # For async functions without dependencies, use the async tracer
+                    return await ExecutionTracer.trace_function_execution_async(
+                        func, args, kwargs, [], [], 0, wrapper_logger
+                    )
+            else:
+                @functools.wraps(func)
+                def minimal_wrapper(*args, **kwargs):
+                    # Use ExecutionTracer for functions without dependencies (v0.4.0 style)
+                    from ..tracing.execution_tracer import ExecutionTracer
+                    wrapper_logger.debug(f"🔧 DI: Executing sync function {func.__name__} (no dependencies)")
+                    
+                    # Use original function tracer for functions without dependencies
+                    return ExecutionTracer.trace_original_function(func, args, kwargs, wrapper_logger)
 
             # Add minimal metadata for compatibility
             minimal_wrapper._mesh_injected_deps = {}
@@ -390,20 +410,29 @@ class DependencyInjector:
                     f"🔧 DEPENDENCY_WRAPPER: final_kwargs={final_kwargs}"
                 )
 
-                # ===== EXECUTE WITH DEPENDENCY INJECTION =====
-                # Call the original function with injected dependencies
+                # ===== EXECUTE WITH DEPENDENCY INJECTION AND TRACING =====
+                # Use ExecutionTracer for comprehensive execution logging (v0.4.0 style)
+                from ..tracing.execution_tracer import ExecutionTracer
+                
                 original_func = func._mesh_original_func
 
-                # Check if the function is async and handle accordingly
-                if inspect.iscoroutinefunction(original_func):
-                    # For async functions, await the result directly
-                    result = await original_func(*args, **final_kwargs)
-                else:
-                    # For sync functions, call directly
-                    result = original_func(*args, **final_kwargs)
+                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,
+                    args,
+                    final_kwargs,
+                    dependencies,
+                    mesh_positions,
+                    injected_count,
+                    wrapper_logger,
+                )
 
                 wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: Original returned: {type(result)}"
+                    f"🔧 DI: Function {original_func.__name__} returned: {type(result)}"
                 )
                 return result
 
@@ -454,8 +483,24 @@ class DependencyInjector:
                             final_kwargs[param_name] = dependency
                             injected_count += 1
 
-                # Call the original function with injected dependencies
-                return func._mesh_original_func(*args, **final_kwargs)
+                # ===== 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(
+                    func._mesh_original_func,
+                    args,
+                    final_kwargs,
+                    dependencies,
+                    mesh_positions,
+                    injected_count,
+                    wrapper_logger,
+                )
 
         # Store dependency state on wrapper
         dependency_wrapper._mesh_injected_deps = {}

_mcp_mesh/engine/full_mcp_proxy.py

@@ -85,7 +85,7 @@ class FullMCPProxy(MCPClientProxy):
             try:
                 import httpx
 
-                url = f"{self.endpoint}/mcp/"
+                url = f"{self.endpoint}/mcp"
 
                 # Build headers with trace context
                 headers = {
@@ -234,7 +234,7 @@ class FullMCPProxy(MCPClientProxy):
             }
 
             # URL for MCP protocol endpoint
-            url = f"{self.endpoint.rstrip('/')}/mcp/"
+            url = f"{self.endpoint.rstrip('/')}/mcp"
 
             # Add session ID to headers for session routing
             headers = {
@@ -500,7 +500,7 @@ class EnhancedFullMCPProxy(FullMCPProxy):
         # Inject trace context headers
         headers = self._inject_trace_headers(headers)
 
-        url = f"{self.endpoint}/mcp/"
+        url = f"{self.endpoint}/mcp"
 
         try:
             import httpx
@@ -580,7 +580,7 @@ class EnhancedFullMCPProxy(FullMCPProxy):
         # Inject trace context headers
         headers = self._inject_trace_headers(headers)
 
-        url = f"{self.endpoint}/mcp/"
+        url = f"{self.endpoint}/mcp"
 
         try:
             import httpx

_mcp_mesh/engine/http_wrapper.py

@@ -395,14 +395,17 @@ class HttpMcpWrapper:
         from starlette.responses import Response
 
         class MCPSessionRoutingMiddleware(BaseHTTPMiddleware):
+            """Clean session routing middleware for MCP requests (v0.4.0 style).
+            
+            Handles session affinity and basic trace context setup only.
+            Function execution tracing is handled by ExecutionTracer in DependencyInjector.
+            """
             def __init__(self, app, http_wrapper):
                 super().__init__(app)
                 self.http_wrapper = http_wrapper
                 self.logger = logger
 
             async def dispatch(self, request: Request, call_next):
-                # Only handle MCP requests (FastMCP app already only handles /mcp)
-
                 # Extract and set trace context from headers for distributed tracing
                 try:
                     from ..tracing.trace_context_helper import TraceContextHelper
@@ -417,10 +420,8 @@ class HttpMcpWrapper:
                         trace_context, self.logger
                     )
                 except Exception as e:
-                    import logging
-
-                    logger = logging.getLogger(__name__)
-                    logger.warning(f"Failed to set trace context: {e}")
+                    # Never fail request due to tracing issues
+                    self.logger.warning(f"Failed to set trace context: {e}")
                     pass
 
                 # Extract session ID from request
@@ -454,7 +455,7 @@ class HttpMcpWrapper:
 
         # Add the middleware to FastMCP app
         self._mcp_app.add_middleware(MCPSessionRoutingMiddleware, http_wrapper=self)
-        logger.info("✅ Session routing middleware added to FastMCP app")
+        logger.info("✅ Clean session routing middleware added to FastMCP app (v0.4.0 style)")
 
     async def _extract_session_id(self, request) -> str:
         """Extract session ID from request headers or body."""

_mcp_mesh/engine/mcp_client_proxy.py

@@ -93,7 +93,7 @@ class MCPClientProxy:
                 "params": {"name": self.function_name, "arguments": kwargs},
             }
 
-            url = f"{self.endpoint}/mcp/"  # Use trailing slash to avoid 307 redirect
+            url = f"{self.endpoint}/mcp"  # Remove trailing slash to avoid 307 redirect
             data = json.dumps(payload).encode("utf-8")
 
             # Build headers with trace context injection