mcp-mesh 0.5.0__py3-none-any.whl → 0.5.1__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.1"
 
 # 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

@@ -288,9 +288,45 @@ 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):
+                    # Execute with telemetry tracing even for async functions without dependencies
+                    try:
+                        from ..tracing.execution_tracer import ExecutionTracer
+                        
+                        # Use ExecutionTracer for minimal async wrapper (no dependencies)
+                        return await ExecutionTracer.trace_function_execution_async(
+                            func, args, kwargs, [], [], 0, wrapper_logger
+                        )
+                    except ImportError:
+                        # Fallback if tracing is unavailable - never fail user function
+                        wrapper_logger.debug("🔇 Tracing unavailable, executing without telemetry")
+                        return await func(*args, **kwargs)
+                    except Exception as e:
+                        # Never fail user function due to tracing errors
+                        wrapper_logger.warning(f"⚠️ Telemetry failed, executing without: {e}")
+                        return await func(*args, **kwargs)
+            else:
+                @functools.wraps(func)
+                def minimal_wrapper(*args, **kwargs):
+                    # Execute with telemetry tracing even for functions without dependencies
+                    try:
+                        from ..tracing.execution_tracer import ExecutionTracer
+                        
+                        # Use ExecutionTracer for minimal wrapper (no dependencies)
+                        return ExecutionTracer.trace_original_function(
+                            func, args, kwargs, wrapper_logger
+                        )
+                    except ImportError:
+                        # Fallback if tracing is unavailable - never fail user function
+                        wrapper_logger.debug("🔇 Tracing unavailable, executing without telemetry")
+                        return func(*args, **kwargs)
+                    except Exception as e:
+                        # Never fail user function due to tracing errors
+                        wrapper_logger.warning(f"⚠️ Telemetry failed, executing without: {e}")
+                        return func(*args, **kwargs)
 
             # Add minimal metadata for compatibility
             minimal_wrapper._mesh_injected_deps = {}
@@ -390,17 +426,51 @@ class DependencyInjector:
                     f"🔧 DEPENDENCY_WRAPPER: final_kwargs={final_kwargs}"
                 )
 
-                # ===== EXECUTE WITH DEPENDENCY INJECTION =====
-                # Call the original function with injected dependencies
+                # ===== EXECUTE WITH TELEMETRY AND DEPENDENCY INJECTION =====
+                # Call the original function with telemetry tracing and injected dependencies
                 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)
+                # Execute with telemetry tracing
+                try:
+                    from ..tracing.execution_tracer import ExecutionTracer
+                    
+                    # Use ExecutionTracer for comprehensive telemetry
+                    if inspect.iscoroutinefunction(original_func):
+                        # For async functions, await the result directly
+                        result = await ExecutionTracer.trace_function_execution_async(
+                            original_func,
+                            args,
+                            final_kwargs,
+                            dependencies,
+                            mesh_positions,
+                            injected_count,
+                            wrapper_logger,
+                        )
+                    else:
+                        # For sync functions, call directly
+                        result = ExecutionTracer.trace_function_execution(
+                            original_func,
+                            args,
+                            final_kwargs,
+                            dependencies,
+                            mesh_positions,
+                            injected_count,
+                            wrapper_logger,
+                        )
+                except ImportError:
+                    # Fallback if tracing is unavailable - never fail user function
+                    wrapper_logger.debug("🔇 Tracing unavailable, executing without telemetry")
+                    if inspect.iscoroutinefunction(original_func):
+                        result = await original_func(*args, **final_kwargs)
+                    else:
+                        result = original_func(*args, **final_kwargs)
+                except Exception as e:
+                    # Never fail user function due to tracing errors
+                    wrapper_logger.warning(f"⚠️ Telemetry failed, executing without: {e}")
+                    if inspect.iscoroutinefunction(original_func):
+                        result = await original_func(*args, **final_kwargs)
+                    else:
+                        result = original_func(*args, **final_kwargs)
 
                 wrapper_logger.debug(
                     f"🔧 DEPENDENCY_WRAPPER: Original returned: {type(result)}"
@@ -454,8 +524,29 @@ 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 TELEMETRY AND DEPENDENCY INJECTION =====
+                # Call the original function with telemetry tracing and injected dependencies
+                try:
+                    from ..tracing.execution_tracer import ExecutionTracer
+                    
+                    # Use ExecutionTracer for comprehensive telemetry
+                    return ExecutionTracer.trace_function_execution(
+                        func._mesh_original_func,
+                        args,
+                        final_kwargs,
+                        dependencies,
+                        mesh_positions,
+                        injected_count,
+                        wrapper_logger,
+                    )
+                except ImportError:
+                    # Fallback if tracing is unavailable - never fail user function
+                    wrapper_logger.debug("🔇 Tracing unavailable, executing without telemetry")
+                    return func._mesh_original_func(*args, **final_kwargs)
+                except Exception as e:
+                    # Never fail user function due to tracing errors
+                    wrapper_logger.warning(f"⚠️ Telemetry failed, executing without: {e}")
+                    return func._mesh_original_func(*args, **final_kwargs)
 
         # 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,6 +395,12 @@ class HttpMcpWrapper:
         from starlette.responses import Response
 
         class MCPSessionRoutingMiddleware(BaseHTTPMiddleware):
+            """Session routing middleware for MCP requests.
+            
+            Handles session affinity by routing requests to appropriate pods
+            based on session ID. Telemetry/tracing is now handled in the
+            DI function wrapper for unified coverage of both MCP and API calls.
+            """
             def __init__(self, app, http_wrapper):
                 super().__init__(app)
                 self.http_wrapper = http_wrapper
@@ -402,26 +408,9 @@ class HttpMcpWrapper:
 
             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
-
-                    # Use helper class for trace context extraction and setup
-                    trace_context = (
-                        await TraceContextHelper.extract_trace_context_from_request(
-                            request
-                        )
-                    )
-                    TraceContextHelper.setup_request_trace_context(
-                        trace_context, self.logger
-                    )
-                except Exception as e:
-                    import logging
-
-                    logger = logging.getLogger(__name__)
-                    logger.warning(f"Failed to set trace context: {e}")
-                    pass
+                
+                # Note: Telemetry/tracing now handled in DI function wrapper for unified approach
+                # This middleware focuses purely on session routing
 
                 # Extract session ID from request
                 session_id = await self.http_wrapper._extract_session_id(request)

_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