mcp-mesh 0.4.2__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.4.2"
+__version__ = "0.5.1"
 
 # 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()
 
@@ -60,7 +60,18 @@ def initialize_runtime():
 
 # Auto-initialize runtime if enabled
 if os.getenv("MCP_MESH_ENABLED", "true").lower() == "true":
-    initialize_runtime()
+    # 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/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

@@ -126,6 +126,9 @@ class DependencyInjector:
                 for func_id in self._dependency_mapping[name]:
                     if func_id in self._function_registry:
                         func = self._function_registry[func_id]
+                        logger.debug(
+                            f"🔄 UPDATING dependency '{name}' for {func_id} -> {func} at {hex(id(func))}"
+                        )
                         if hasattr(func, "_mesh_update_dependency"):
                             func._mesh_update_dependency(name, instance)
 
@@ -279,99 +282,271 @@ class DependencyInjector:
         # Capture logger in local scope to avoid NameError
         wrapper_logger = logger
 
-        @functools.wraps(func)
-        def dependency_wrapper(*args, **kwargs):
-            wrapper_logger.debug(
-                f"🔧 DEPENDENCY_WRAPPER: Function {func.__name__} called"
+        # If no mesh positions to inject, create minimal wrapper for tracking
+        if not mesh_positions:
+            logger.debug(
+                f"🔧 No injection positions for {func.__name__}, creating minimal wrapper for tracking"
             )
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: args={args}, kwargs={kwargs}")
-            wrapper_logger.debug(
-                f"🔧 DEPENDENCY_WRAPPER: mesh_positions={mesh_positions}"
+
+            # 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 = {}
+            minimal_wrapper._mesh_dependencies = dependencies
+            minimal_wrapper._mesh_positions = mesh_positions
+            minimal_wrapper._mesh_parameter_types = get_agent_parameter_types(func)
+            minimal_wrapper._mesh_original_func = func
+
+            def update_dependency(name: str, instance: Any | None) -> None:
+                """No-op update for functions without injection positions."""
+                pass
+
+            minimal_wrapper._mesh_update_dependency = update_dependency
+
+            # Register this wrapper for dependency updates (even though it won't use them)
+            logger.debug(
+                f"🔧 REGISTERING minimal wrapper: {func_id} -> {minimal_wrapper} at {hex(id(minimal_wrapper))}"
             )
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}")
+            self._function_registry[func_id] = minimal_wrapper
+
+            return minimal_wrapper
 
-            # If no mesh positions to inject into, still do execution logging but call original function
-            if not mesh_positions:
+        # Determine if we need async wrapper
+        need_async_wrapper = inspect.iscoroutinefunction(func)
+
+        if need_async_wrapper:
+
+            @functools.wraps(func)
+            async def dependency_wrapper(*args, **kwargs):
                 wrapper_logger.debug(
-                    "🔧 DEPENDENCY_WRAPPER: No mesh positions, calling original with execution logging"
+                    f"🔧 DEPENDENCY_WRAPPER: Function {func.__name__} called"
                 )
-                from ..tracing.execution_tracer import ExecutionTracer
-
-                return ExecutionTracer.trace_original_function(
-                    func._mesh_original_func, args, kwargs, wrapper_logger
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: args={args}, kwargs={kwargs}"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: mesh_positions={mesh_positions}"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}"
                 )
 
-            # Get function signature
-            sig = inspect.signature(func)
-            params = list(sig.parameters.keys())
-            final_kwargs = kwargs.copy()
+                # We know mesh_positions is not empty since we checked above
 
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: params={params}")
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: original kwargs={kwargs}")
+                # Get function signature
+                sig = inspect.signature(func)
+                params = list(sig.parameters.keys())
+                final_kwargs = kwargs.copy()
 
-            # Inject dependencies as kwargs
-            injected_count = 0
-            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: params={params}")
+                wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: original kwargs={kwargs}")
 
-                    wrapper_logger.debug(
-                        f"🔧 DEPENDENCY_WRAPPER: Processing dep {dep_index}: {dep_name} -> {param_name}"
-                    )
+                # Inject dependencies as kwargs
+                injected_count = 0
+                for dep_index, param_position in enumerate(mesh_positions):
+                    if dep_index < len(dependencies):
+                        dep_name = dependencies[dep_index]
+                        param_name = params[param_position]
 
-                    # Only inject if the parameter wasn't explicitly provided
-                    if (
-                        param_name not in final_kwargs
-                        or final_kwargs.get(param_name) is None
-                    ):
-                        # Get the dependency from wrapper's storage
-                        dependency = dependency_wrapper._mesh_injected_deps.get(
-                            dep_name
-                        )
                         wrapper_logger.debug(
-                            f"🔧 DEPENDENCY_WRAPPER: From wrapper storage: {dependency}"
+                            f"🔧 DEPENDENCY_WRAPPER: Processing dep {dep_index}: {dep_name} -> {param_name}"
                         )
 
-                        if dependency is None:
-                            dependency = self.get_dependency(dep_name)
+                        # Only inject if the parameter wasn't explicitly provided
+                        if (
+                            param_name not in final_kwargs
+                            or final_kwargs.get(param_name) is None
+                        ):
+                            # Get the dependency from wrapper's storage
+                            dependency = dependency_wrapper._mesh_injected_deps.get(
+                                dep_name
+                            )
                             wrapper_logger.debug(
-                                f"🔧 DEPENDENCY_WRAPPER: From global storage: {dependency}"
+                                f"🔧 DEPENDENCY_WRAPPER: From wrapper storage: {dependency}"
                             )
 
-                        final_kwargs[param_name] = dependency
-                        injected_count += 1
-                        wrapper_logger.debug(
-                            f"🔧 DEPENDENCY_WRAPPER: Injected {dep_name} as {param_name}"
+                            if dependency is None:
+                                dependency = self.get_dependency(dep_name)
+                                wrapper_logger.debug(
+                                    f"🔧 DEPENDENCY_WRAPPER: From global storage: {dependency}"
+                                )
+
+                            final_kwargs[param_name] = dependency
+                            injected_count += 1
+                            wrapper_logger.debug(
+                                f"🔧 DEPENDENCY_WRAPPER: Injected {dep_name} as {param_name}"
+                            )
+                        else:
+                            wrapper_logger.debug(
+                                f"🔧 DEPENDENCY_WRAPPER: Skipping {param_name} - already provided"
+                            )
+
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: Injected {injected_count} dependencies"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: final_kwargs={final_kwargs}"
+                )
+
+                # ===== EXECUTE WITH TELEMETRY AND DEPENDENCY INJECTION =====
+                # Call the original function with telemetry tracing and injected dependencies
+                original_func = func._mesh_original_func
+
+                # 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:
-                        wrapper_logger.debug(
-                            f"🔧 DEPENDENCY_WRAPPER: Skipping {param_name} - already provided"
+                        # 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: Injected {injected_count} dependencies"
-            )
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: final_kwargs={final_kwargs}")
-
-            # ===== EXECUTE WITH DEPENDENCY INJECTION AND TRACING =====
-            from ..tracing.execution_tracer import ExecutionTracer
-
-            # Use helper class for clean execution tracing
-            result = ExecutionTracer.trace_function_execution(
-                func._mesh_original_func,
-                args,
-                final_kwargs,
-                dependencies,
-                mesh_positions,
-                injected_count,
-                wrapper_logger,
-            )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: Original returned: {type(result)}"
+                )
+                return result
 
-            wrapper_logger.debug(
-                f"🔧 DEPENDENCY_WRAPPER: Original returned: {type(result)}"
-            )
-            return result
+        else:
+            # Create sync wrapper for sync functions without dependencies
+            @functools.wraps(func)
+            def dependency_wrapper(*args, **kwargs):
+                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}"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}"
+                )
+
+                # We know mesh_positions is not empty since we checked above
+
+                # Handle dependency injection for sync functions
+                sig = inspect.signature(func)
+                params = list(sig.parameters.keys())
+                final_kwargs = kwargs.copy()
+
+                # Inject dependencies as kwargs
+                injected_count = 0
+                for dep_index, param_position in enumerate(mesh_positions):
+                    if dep_index < len(dependencies):
+                        dep_name = dependencies[dep_index]
+                        param_name = params[param_position]
+
+                        # Only inject if the parameter wasn't explicitly provided
+                        if (
+                            param_name not in final_kwargs
+                            or final_kwargs.get(param_name) is None
+                        ):
+                            # Get the dependency from wrapper's storage
+                            dependency = dependency_wrapper._mesh_injected_deps.get(
+                                dep_name
+                            )
+
+                            if dependency is None:
+                                dependency = self.get_dependency(dep_name)
+
+                            final_kwargs[param_name] = dependency
+                            injected_count += 1
+
+                # ===== 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 = {}
@@ -399,6 +574,9 @@ class DependencyInjector:
         dependency_wrapper._mesh_original_func = func
 
         # Register this wrapper for dependency updates
+        logger.debug(
+            f"🔧 REGISTERING in function_registry: {func_id} -> {dependency_wrapper} at {hex(id(dependency_wrapper))}"
+        )
         self._function_registry[func_id] = dependency_wrapper
 
         # Return the wrapper (which FastMCP will register)

_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)