mcp-mesh 0.6.4__py3-none-any.whl → 0.7.0__py3-none-any.whl

_mcp_mesh/pipeline/api_startup/route_integration.py

@@ -1,6 +1,7 @@
 import logging
-from typing import Any, Dict
+from typing import Any
 
+from ...engine.decorator_registry import DecoratorRegistry
 from ...engine.dependency_injector import get_global_injector
 from ..shared import PipelineResult, PipelineStatus, PipelineStep
 
@@ -8,11 +9,11 @@ from ..shared import PipelineResult, PipelineStatus, PipelineStep
 class RouteIntegrationStep(PipelineStep):
     """
     Integrates dependency injection into FastAPI route handlers.
-    
+
     This step takes the discovered FastAPI apps and @mesh.route decorated handlers,
     then applies dependency injection by replacing the route.endpoint with a
     dependency injection wrapper.
-    
+
     Uses the existing dependency injection engine from MCP tools - route handlers
     are just functions, so the same injection logic applies perfectly.
     """
@@ -34,13 +35,13 @@ class RouteIntegrationStep(PipelineStep):
             # Get discovery results from context
             fastapi_apps = context.get("fastapi_apps", {})
             route_mapping = context.get("route_mapping", {})
-            
+
             if not fastapi_apps:
                 result.status = PipelineStatus.SKIPPED
                 result.message = "No FastAPI applications found"
                 self.logger.warning("⚠️ No FastAPI applications to integrate")
                 return result
-            
+
             if not route_mapping:
                 result.status = PipelineStatus.SKIPPED
                 result.message = "No @mesh.route handlers found"
@@ -50,26 +51,26 @@ class RouteIntegrationStep(PipelineStep):
             # Apply dependency injection to each app's routes
             integration_results = {}
             total_integrated = 0
-            
+
             for app_id, app_info in fastapi_apps.items():
                 if app_id not in route_mapping:
                     continue
-                    
+
                 app_results = self._integrate_app_routes(
                     app_info, route_mapping[app_id]
                 )
                 integration_results[app_id] = app_results
                 total_integrated += app_results["integrated_count"]
-                
-                self.logger.info(
-                    f"📝 Integrated {app_results['integrated_count']} routes in "
+
+                self.logger.debug(
+                    f"Integrated {app_results['integrated_count']} routes in "
                     f"'{app_info['title']}'"
                 )
 
             # Store integration results in context
             result.add_context("integration_results", integration_results)
             result.add_context("total_integrated_routes", total_integrated)
-            
+
             # Update result message
             result.message = f"Integrated {total_integrated} route handlers with dependency injection"
 
@@ -86,22 +87,22 @@ class RouteIntegrationStep(PipelineStep):
         return result
 
     def _integrate_app_routes(
-        self, app_info: Dict[str, Any], route_mapping: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, app_info: dict[str, Any], route_mapping: dict[str, Any]
+    ) -> dict[str, Any]:
         """
         Apply dependency injection to routes in a single FastAPI app.
-        
+
         Args:
             app_info: FastAPI app information from discovery
             route_mapping: Route mapping for this specific app
-            
+
         Returns:
             Integration results for this app
         """
         app = app_info["instance"]
         app_title = app_info["title"]
         injector = get_global_injector()
-        
+
         integration_results = {
             "app_title": app_title,
             "integrated_count": 0,
@@ -109,45 +110,41 @@ class RouteIntegrationStep(PipelineStep):
             "error_count": 0,
             "route_details": {},
         }
-        
+
         # Process each @mesh.route decorated handler
         for route_name, route_info in route_mapping.items():
             try:
-                result_detail = self._integrate_single_route(
-                    app, route_info, injector
-                )
+                result_detail = self._integrate_single_route(app, route_info, injector)
                 integration_results["route_details"][route_name] = result_detail
-                
+
                 if result_detail["status"] == "integrated":
                     integration_results["integrated_count"] += 1
                 elif result_detail["status"] == "skipped":
                     integration_results["skipped_count"] += 1
                 else:
                     integration_results["error_count"] += 1
-                    
+
             except Exception as e:
-                self.logger.error(
-                    f"❌ Failed to integrate route '{route_name}': {e}"
-                )
+                self.logger.error(f"❌ Failed to integrate route '{route_name}': {e}")
                 integration_results["error_count"] += 1
                 integration_results["route_details"][route_name] = {
                     "status": "error",
-                    "error": str(e)
+                    "error": str(e),
                 }
-                
+
         return integration_results
 
     def _integrate_single_route(
-        self, app, route_info: Dict[str, Any], injector
-    ) -> Dict[str, Any]:
+        self, app, route_info: dict[str, Any], injector
+    ) -> dict[str, Any]:
         """
         Apply dependency injection to a single route handler.
-        
+
         Args:
             app: FastAPI application instance
             route_info: Route information including dependencies
             injector: Dependency injector instance
-            
+
         Returns:
             Integration result details
         """
@@ -156,163 +153,165 @@ class RouteIntegrationStep(PipelineStep):
         dependencies = route_info["dependencies"]
         path = route_info["path"]
         methods = route_info["methods"]
-        
+
         # Extract dependency names for injector
         dependency_names = [dep["capability"] for dep in dependencies]
-        
+
         self.logger.debug(
-            f"🔧 Integrating route {methods} {path} -> {endpoint_name}() "
+            f"Integrating route {methods} {path} -> {endpoint_name}() "
             f"with dependencies: {dependency_names}"
         )
-        self.logger.debug(f"🔍 Route integration processing: {original_handler} at {hex(id(original_handler))}")
-        
+
         # Skip if no dependencies
         if not dependency_names:
-            self.logger.debug(f"⚠️ Route '{endpoint_name}' has no dependencies, skipping")
+            self.logger.debug(f"Route '{endpoint_name}' has no dependencies, skipping")
             return {
                 "status": "skipped",
                 "reason": "no_dependencies",
-                "dependency_count": 0
+                "dependency_count": 0,
             }
-        
+
         # Check if function already has an injection wrapper (from @mesh.route decorator)
         # The function might be the wrapper itself (if decorator order is correct)
-        is_already_wrapper = getattr(original_handler, '_mesh_is_injection_wrapper', False)
-        existing_wrapper = getattr(original_handler, '_mesh_injection_wrapper', None)
-        
-        self.logger.debug(
-            f"🔍 Checking function {original_handler} at {hex(id(original_handler))}: "
-            f"is_wrapper={is_already_wrapper}, has_wrapper_ref={'yes' if existing_wrapper else 'no'}"
+        is_already_wrapper = getattr(
+            original_handler, "_mesh_is_injection_wrapper", False
         )
-        
+        existing_wrapper = getattr(original_handler, "_mesh_injection_wrapper", None)
+
         if is_already_wrapper:
             self.logger.debug(
-                f"🔄 Function '{endpoint_name}' is already an injection wrapper from @mesh.route decorator"
+                f"Function '{endpoint_name}' is already an injection wrapper from @mesh.route decorator"
             )
             wrapped_handler = original_handler  # Use the function as-is
         elif existing_wrapper:
-            self.logger.debug(f"🔍 Existing wrapper: {existing_wrapper} at {hex(id(existing_wrapper))}")
             self.logger.debug(
-                f"🔄 Route '{endpoint_name}' already has injection wrapper from @mesh.route decorator, using existing wrapper"
+                f"Route '{endpoint_name}' already has injection wrapper from @mesh.route decorator, using existing wrapper"
             )
             wrapped_handler = existing_wrapper
         else:
             # Create dependency injection wrapper using existing engine
             self.logger.debug(
-                f"🔧 Creating new injection wrapper for route '{endpoint_name}'"
+                f"Creating new injection wrapper for route '{endpoint_name}'"
             )
             try:
                 wrapped_handler = injector.create_injection_wrapper(
                     original_handler, dependency_names
                 )
-                
+
                 # Preserve original handler metadata on wrapper
                 wrapped_handler._mesh_route_metadata = getattr(
-                    original_handler, '_mesh_route_metadata', {}
+                    original_handler, "_mesh_route_metadata", {}
                 )
                 wrapped_handler._original_handler = original_handler
                 wrapped_handler._mesh_dependencies = dependency_names
             except Exception as e:
-                self.logger.error(f"Failed to create injection wrapper for {endpoint_name}: {e}")
+                self.logger.error(
+                    f"Failed to create injection wrapper for {endpoint_name}: {e}"
+                )
                 return {
                     "status": "failed",
                     "reason": f"wrapper_creation_failed: {e}",
-                    "dependency_count": len(dependency_names)
+                    "dependency_count": len(dependency_names),
                 }
-        
+
         # CRITICAL FIX: Check if there are multiple wrapper instances for this function
         # If so, use the one that actually receives dependency updates
         from ...engine.dependency_injector import get_global_injector
+
         injector = get_global_injector()
-        
+
         # Find all functions that depend on the first dependency of this route
         if dependency_names:
-            first_dep = dependency_names[0]  # Use first dependency to find all instances
+            first_dep = dependency_names[
+                0
+            ]  # Use first dependency to find all instances
             affected_functions = injector._dependency_mapping.get(first_dep, set())
-            self.logger.debug(f"🎯 All functions with '{first_dep}' dependency: {list(affected_functions)}")
-            
+
             # Check if there are multiple instances and if so, prefer the one that's NOT __main__
             if len(affected_functions) > 1:
-                non_main_functions = [f for f in affected_functions if not f.startswith('__main__.')]
+                non_main_functions = [
+                    f for f in affected_functions if not f.startswith("__main__.")
+                ]
                 if non_main_functions:
                     # Found a non-main instance, try to get that wrapper instead
                     preferred_func_id = non_main_functions[0]  # Take first non-main
-                    preferred_wrapper = injector._function_registry.get(preferred_func_id)
+                    preferred_wrapper = injector._function_registry.get(
+                        preferred_func_id
+                    )
                     if preferred_wrapper:
-                        self.logger.debug(
-                            f"🔄 SWITCHING to preferred wrapper '{preferred_func_id}': "
-                            f"{preferred_wrapper} at {hex(id(preferred_wrapper))}"
-                        )
                         wrapped_handler = preferred_wrapper
-        
+
+        # Register the route wrapper in DecoratorRegistry for path-based dependency resolution
+        # This creates a mapping from METHOD:path -> wrapper function
+        for method in methods:
+            DecoratorRegistry.register_route_wrapper(
+                method=method,
+                path=path,
+                wrapper=wrapped_handler,
+                dependencies=dependency_names,
+            )
+
         # Find and replace the route handler in FastAPI
         route_replaced = self._replace_route_handler(
             app, path, methods, original_handler, wrapped_handler
         )
-        
+
         if route_replaced:
             self.logger.debug(
-                f"✅ Route '{endpoint_name}' integrated successfully with "
-                f"{len(dependency_names)} dependencies"
+                f"Route '{endpoint_name}' integrated with {len(dependency_names)} dependencies"
             )
             return {
                 "status": "integrated",
                 "dependency_count": len(dependency_names),
                 "dependencies": dependency_names,
                 "original_handler": original_handler,
-                "wrapped_handler": wrapped_handler
+                "wrapped_handler": wrapped_handler,
             }
         else:
             self.logger.warning(
                 f"⚠️ Failed to find route to replace for '{endpoint_name}'"
             )
-            return {
-                "status": "error",
-                "error": "route_not_found_for_replacement"
-            }
+            return {"status": "error", "error": "route_not_found_for_replacement"}
 
     def _replace_route_handler(
         self, app, path: str, methods: list, original_handler, wrapped_handler
     ) -> bool:
         """
         Replace the route handler in FastAPI's router.
-        
+
         Args:
             app: FastAPI application instance
             path: Route path to find
             methods: HTTP methods for the route
             original_handler: Original handler function
             wrapped_handler: New wrapped handler function
-            
+
         Returns:
             True if replacement was successful, False otherwise
         """
         try:
             # Find the matching route in FastAPI's router
             for route in app.router.routes:
-                if (hasattr(route, 'endpoint') and 
-                    hasattr(route, 'path') and 
-                    hasattr(route, 'methods')):
-                    
+                if (
+                    hasattr(route, "endpoint")
+                    and hasattr(route, "path")
+                    and hasattr(route, "methods")
+                ):
+
                     # Match by path and endpoint function
-                    if (route.path == path and 
-                        route.endpoint is original_handler):
-                        
+                    if route.path == path and route.endpoint is original_handler:
+
                         # Replace the endpoint with our wrapped version
                         route.endpoint = wrapped_handler
-                        
-                        self.logger.debug(
-                            f"🔄 Replaced handler for {methods} {path}: "
-                            f"{original_handler.__name__} -> wrapped version"
-                        )
+
                         return True
-            
+
             # If we get here, we didn't find the route
             self.logger.warning(
-                f"⚠️ Could not find route {methods} {path} to replace handler"
+                f"Could not find route {methods} {path} to replace handler"
             )
             return False
-            
+
         except Exception as e:
             self.logger.error(f"❌ Error replacing route handler: {e}")
-            return False
+            return False

_mcp_mesh/pipeline/mcp_startup/fastapiserver_setup.py

@@ -422,6 +422,10 @@ class FastAPIServerSetupStep(PipelineStep):
         except ImportError as e:
             raise Exception(f"FastAPI not available: {e}")
 
+    # Note: Trace context middleware for distributed tracing is added in
+    # mesh/decorators.py BEFORE the FastAPI app starts. This ensures the middleware
+    # is properly registered since middleware cannot be added after the app starts.
+
     async def _add_k8s_endpoints(
         self,
         app: Any,
@@ -890,6 +894,9 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
                         "✅ SERVER REUSE: FastMCP lifespan already integrated, mounting same HTTP app"
                     )
 
+                    # Note: Trace context middleware is added in decorators.py BEFORE the app starts
+                    # We cannot add middleware after the application has started
+
                     # FastMCP lifespan is already integrated, mount the same HTTP app that was used for lifespan
                     for server_key, server_instance in fastmcp_servers.items():
                         try:

_mcp_mesh/tracing/execution_tracer.py

@@ -26,8 +26,8 @@ class ExecutionTracer:
     def __init__(self, function_name: str, logger_instance: logging.Logger):
         self.function_name = function_name
         self.logger = logger_instance
-        self.start_time: Optional[float] = None
-        self.trace_context: Optional[Any] = None
+        self.start_time: float | None = None
+        self.trace_context: Any | None = None
         self.execution_metadata: dict = {}
 
     def start_execution(
@@ -41,6 +41,7 @@ class ExecutionTracer:
         """Start execution tracking and log function start."""
         try:
             from .context import TraceContext
+            from .utils import generate_trace_id
 
             self.start_time = time.time()
             self.trace_context = TraceContext.get_current()
@@ -60,31 +61,58 @@ class ExecutionTracer:
             agent_metadata = get_agent_metadata_with_fallback(self.logger)
             self.execution_metadata.update(agent_metadata)
 
-            if self.trace_context:
-                # Generate a new child span ID for this function execution
-                # Keep the same trace_id but create unique span_id per function call
-                function_span_id = generate_span_id()
-
+            # Generate a new child span ID for this function execution
+            function_span_id = generate_span_id()
 
+            if self.trace_context:
+                # Have trace context - use existing trace_id, create child span
+                # Current trace's span_id becomes this function's parent_span
                 self.execution_metadata.update(
                     {
                         "trace_id": self.trace_context.trace_id,
                         "span_id": function_span_id,  # New child span for this function
-                        "parent_span": (
-                            self.trace_context.span_id
-                            if self.trace_context.parent_span is not None
-                            else None
-                        ),  # HTTP middleware span becomes parent only if not root
+                        "parent_span": self.trace_context.span_id,  # Parent's span becomes our parent
+                    }
+                )
+
+                # Update TraceContext for nested calls - this span becomes the new current span
+                TraceContext.set_current(
+                    trace_id=self.trace_context.trace_id,
+                    span_id=function_span_id,
+                    parent_span=self.trace_context.span_id,
+                )
+            else:
+                # No trace context (FastMCP context propagation issue) - generate root trace
+                # This ensures traces always have IDs even when contextvar propagation fails
+                root_trace_id = generate_trace_id()
+                self.execution_metadata.update(
+                    {
+                        "trace_id": root_trace_id,
+                        "span_id": function_span_id,
+                        "parent_span": None,  # Root span has no parent
                     }
                 )
 
+                # CRITICAL: Set the TraceContext so outgoing cross-agent calls can propagate it
+                # Without this, inject_trace_headers_to_request() won't find the trace context
+                # and cross-agent traces won't be linked with parent_span
+                TraceContext.set_current(
+                    trace_id=root_trace_id,
+                    span_id=function_span_id,
+                    parent_span=None,
+                )
+
+                self.logger.debug(
+                    f"Generated root trace for {self.function_name}: trace_id={root_trace_id}"
+                )
+
         except Exception as e:
             self.logger.warning(
                 f"Failed to setup execution logging for {self.function_name}: {e}"
             )
 
     def end_execution(
-        self, result: Any = None, success: bool = True, error: Optional[str] = None
+        self, result: Any = None, success: bool = True, error: str | None = None
     ) -> None:
         """End execution tracking and log function completion."""
         try:

{mcp_mesh-0.6.4.dist-info → mcp_mesh-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.6.4
+Version: 0.7.0
 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

{mcp_mesh-0.6.4.dist-info → mcp_mesh-0.7.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
-_mcp_mesh/__init__.py,sha256=38W7vaKh5qDOVTJ6vfwtwGJDjwLGJ33t1GCO9UfH34s,2719
+_mcp_mesh/__init__.py,sha256=36WTfOMQ0KFZoAeTSzWMK8W0lxHcWj1Fpk5n3_xXqbI,2719
 _mcp_mesh/engine/__init__.py,sha256=2ennzbo7yJcpkXO9BqN69TruLjJfmJY4Y5VEsG644K4,3630
 _mcp_mesh/engine/async_mcp_client.py,sha256=UcbQjxtgVfeRw6DHTZhAzN1gkcKlTg-lUPEePRPQWAU,6306
 _mcp_mesh/engine/base_injector.py,sha256=qzRLZqFP2VvEFagVovkpdldvDmm3VwPHm6tHwV58a2k,5648
-_mcp_mesh/engine/decorator_registry.py,sha256=sb4Ng2y0hZovFzmrLdRCiwIEdwCm57WUD99cXJShTFk,26745
+_mcp_mesh/engine/decorator_registry.py,sha256=zXuER3Sh-4NpqlLMtTxSxn93xBcZTDdEEjKWSCauU2U,28206
 _mcp_mesh/engine/dependency_injector.py,sha256=1bjeJ7pHUPEF_IoTF-7_Wm1pDLHphtfcFfSrUPWrWI4,31230
 _mcp_mesh/engine/full_mcp_proxy.py,sha256=PlRv7GSKqn5riOCqeCVulVdtq3z1Ug76mOkwMsOFHXw,25297
-_mcp_mesh/engine/http_wrapper.py,sha256=T9VQ2LZbGgCzyOVXVwdqas7-W3Wid0EwRboFUpdYWtM,20718
+_mcp_mesh/engine/http_wrapper.py,sha256=OHbbxHBLyUGDoamHZ2hpYnFKapW_djQ60Y_vMOL6J70,21173
 _mcp_mesh/engine/llm_config.py,sha256=95bOsGWro5E1JGq7oZtEYhVdrzcIJqjht_r5vEdJVz4,2049
 _mcp_mesh/engine/llm_errors.py,sha256=h7BiI14u-jL8vtvBfFbFDDrN7gIw8PQjXIl5AP1SBuA,3276
 _mcp_mesh/engine/mcp_client_proxy.py,sha256=eJStwy_VQJexYYD8bOh_m4Ld3Bb8Ae_dt8N1CC41qBc,17625
-_mcp_mesh/engine/mesh_llm_agent.py,sha256=CcS2WX0ku1DSwUSx0H9YdV7oIiPNMs1jbxSPJvScRao,24679
+_mcp_mesh/engine/mesh_llm_agent.py,sha256=AMW6Tu64aujFYwM0p0ZSd9YYaOikKZUN3utnqI0kT38,29015
 _mcp_mesh/engine/mesh_llm_agent_injector.py,sha256=isufzCBExli8tdLUZOaPuea3uQs3C_yeVXbOVSF0YIU,27270
 _mcp_mesh/engine/response_parser.py,sha256=NsOuGD7HJ0BFiiDUCp9v9cjLzVaU86HShVKzsrNnulk,8786
 _mcp_mesh/engine/self_dependency_proxy.py,sha256=OkKt0-B_ADnJlWtHiHItoZCBZ7Su0iz2unEPFfXvrs4,3302
@@ -18,7 +18,7 @@ _mcp_mesh/engine/session_manager.py,sha256=MCr0_fXBaUjXM51WU5EhDkiGvBdfzYQFVNb9D
 _mcp_mesh/engine/signature_analyzer.py,sha256=ftn9XsX0ZHWIaACdjgBVtCuIdqVU_4ST8cvcpzu4HTk,12339
 _mcp_mesh/engine/tool_executor.py,sha256=Bf_9d02EEY9_yHm1p1-5YZ4rY6MPxn4SVpI6-3sm1uo,5456
 _mcp_mesh/engine/tool_schema_builder.py,sha256=SQCxQIrSfdLu9-dLqiFurQLK7dhl0dc0xa0ibaxU-iE,3644
-_mcp_mesh/engine/unified_mcp_proxy.py,sha256=SmhLWXdjmgvJWOLGQk-cXrvYjGSzx98HzL0Q5jpMNIY,36326
+_mcp_mesh/engine/unified_mcp_proxy.py,sha256=RIkYQGf04xxKui4kLa6N-L7KvH7XTrOy6I2AeMY9imY,36762
 _mcp_mesh/engine/provider_handlers/__init__.py,sha256=LLTCOgnuM3dlogbLmrpiMK3oB5L22eAmDC4BfxJ-L2I,593
 _mcp_mesh/engine/provider_handlers/base_provider_handler.py,sha256=J-SPFFFG1eFSUVvfsv7y4EuNM4REjSxaYWC5E_lC6Pc,4195
 _mcp_mesh/engine/provider_handlers/claude_handler.py,sha256=CCmlsWiCfIcgrLbAZzeSnl0g2pq0uDffT8zOj4F-sPQ,15727
@@ -78,12 +78,12 @@ _mcp_mesh/generated/mcp_mesh_registry_client/models/standardized_dependency.py,s
 _mcp_mesh/generated/mcp_mesh_registry_client/models/trace_event.py,sha256=9Q_8WaVl0MxswRnHpkqq9GKnvOW54HW4tkrTM9oda14,4461
 _mcp_mesh/pipeline/__init__.py,sha256=9Aplh4m1z-rYTQys0JQLYlq9wTPdI72eSOhUPqcnvpA,1557
 _mcp_mesh/pipeline/api_heartbeat/__init__.py,sha256=IXTLoQLAPqQEWZ8VMWc5W_cQJkDv95rlVGXyXoQDjHk,473
-_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py,sha256=Q96auBnbypPnxTjiThtKMIezuZ_hUj30JaPNOZc87ng,24096
+_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py,sha256=IvkvVQNyZr0Uqe2lViRpdj9kaLrxtTJ8io-gwjtK5FI,23247
 _mcp_mesh/pipeline/api_heartbeat/api_fast_heartbeat_check.py,sha256=PY4bbuZgxy3r0ccuBl-OuJvcPSMhyGz4FomxwYFhuvM,4821
 _mcp_mesh/pipeline/api_heartbeat/api_health_check.py,sha256=kDmFeOG_4tyqyJSBZjPcc7xTzGpP4vq6ObW_WBqXvzM,5130
 _mcp_mesh/pipeline/api_heartbeat/api_heartbeat_orchestrator.py,sha256=uBswzWOBzU8p_C0AE2DF8UwIWG4rP2zecHfPqKzNuC0,10367
 _mcp_mesh/pipeline/api_heartbeat/api_heartbeat_pipeline.py,sha256=so8IyKT-Wg7lQk3ULdox9CAOrowzxpUs76e93PQnCik,13520
-_mcp_mesh/pipeline/api_heartbeat/api_heartbeat_send.py,sha256=0Qy6zau_3a2qtQdd2wzjXv-QhhzR6bwAaEun8Re9hXo,14546
+_mcp_mesh/pipeline/api_heartbeat/api_heartbeat_send.py,sha256=vszesutlAFXv9B4XXFutEMEBBhN54hF8eztTtDudLaI,15785
 _mcp_mesh/pipeline/api_heartbeat/api_lifespan_integration.py,sha256=WBo2crcaGfxi8Q46TU-i5OMhAv0sQKz7Z9jps-GLkvM,5183
 _mcp_mesh/pipeline/api_heartbeat/api_registry_connection.py,sha256=6N0JdXdnLkaXau4t8syt9DLgv9Y51SPfTXYK3DefBk8,3846
 _mcp_mesh/pipeline/api_startup/__init__.py,sha256=eivolkSKot2bJTWP2BV8-RKRT1Zm7SGQYuEUiTxusOQ,577
@@ -92,7 +92,7 @@ _mcp_mesh/pipeline/api_startup/api_server_setup.py,sha256=Qy0wbXyIWIQYA7CjiGVZwn
 _mcp_mesh/pipeline/api_startup/fastapi_discovery.py,sha256=MV3hvDXvX7r1Mrn6LAReu9W3hKt-5-jDhPpPYwZXnco,5770
 _mcp_mesh/pipeline/api_startup/middleware_integration.py,sha256=ybImXZlmIR6yA-wYg5Zy_ZMFF9YgToLkk4jnBeZJ7WY,6267
 _mcp_mesh/pipeline/api_startup/route_collection.py,sha256=UjA-F5_RbGVU5TfDT19Np5_x2PtYkNn2mGFyivDsk24,2031
-_mcp_mesh/pipeline/api_startup/route_integration.py,sha256=aMT7p7cwK8N3tZBRqeGQF8upc7tU-Exj6Dz0a4cSBhU,13441
+_mcp_mesh/pipeline/api_startup/route_integration.py,sha256=qq1AVaWna-CWEXyehyDL3EyeYKgo5aMtei8uBNdvkZ8,12448
 _mcp_mesh/pipeline/mcp_heartbeat/__init__.py,sha256=nRNjZ3VD_9bPLQuJ6Nc02gE7KSLcMP7TMquB0hP6hHs,844
 _mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py,sha256=vW-qrpneBLxxQtUEwEjE7aUTv5cIO9rjDg3Bxv7nj4I,18846
 _mcp_mesh/pipeline/mcp_heartbeat/fast_heartbeat_check.py,sha256=2SKHHFTxlYwad_D8a6E7NNtWfH89jBrIO5dQAwM3Xdw,4468
@@ -105,7 +105,7 @@ _mcp_mesh/pipeline/mcp_heartbeat/registry_connection.py,sha256=4abbOKN3echwX82PV
 _mcp_mesh/pipeline/mcp_startup/__init__.py,sha256=gS0xNmVx66bkLUMw64olMsN40ZLPH3ymwlLixZ4NuTs,1239
 _mcp_mesh/pipeline/mcp_startup/configuration.py,sha256=6LRLIxrqFMU76qrBb6GjGknUlKPZZ9iqOlxE7F9ZhLs,2808
 _mcp_mesh/pipeline/mcp_startup/decorator_collection.py,sha256=RHC6MHtfP9aP0hZ-IJjISZu72e0Pml3LU0qr7dc284w,2294
-_mcp_mesh/pipeline/mcp_startup/fastapiserver_setup.py,sha256=AoH3Mb79mPKvSCYH8WusJwG_LUg7HVgqK59lcyVp110,43649
+_mcp_mesh/pipeline/mcp_startup/fastapiserver_setup.py,sha256=O3q3ZNZQsNZ0pL5SkkgQoOxfofzD202H0boshiT2FzI,44074
 _mcp_mesh/pipeline/mcp_startup/fastmcpserver_discovery.py,sha256=Pm24wrSuRGsgeUrHvMPDnNh6RhIZoznnMAUwAkllohk,10661
 _mcp_mesh/pipeline/mcp_startup/heartbeat_loop.py,sha256=v85B0ynomvYu87eIvLe-aSZ7-Iwov2VtM4Fg3PkmrZs,3865
 _mcp_mesh/pipeline/mcp_startup/heartbeat_preparation.py,sha256=sOpzxRc0kYiXwSW9lvv8DSjliT85oZCWPODeJRuiqgg,15635
@@ -133,17 +133,17 @@ _mcp_mesh/shared/sse_parser.py,sha256=OEPnfL9xL3rsjQrbyvfUO82WljPSDeO6Z61uUwN1NA
 _mcp_mesh/shared/support_types.py,sha256=k-ICF_UwDkHxQ1D5LwFZrp-UrNb4E5dzw02CRuLW9iI,7264
 _mcp_mesh/tracing/agent_context_helper.py,sha256=BIJ3Kc4Znd6emMAu97aUhSoxSIza3qYUmObLgc9ONiA,4765
 _mcp_mesh/tracing/context.py,sha256=2ozqKEYfx4Qxj64DnbwoVIbMkhNLbaV8BNWtkzAPA7I,2516
-_mcp_mesh/tracing/execution_tracer.py,sha256=lJu7Uk2F4hT8W7ChJbmZUl_6DGvrndGEFes3cnYPZho,7785
+_mcp_mesh/tracing/execution_tracer.py,sha256=H28EhZPb7Lyz2fG_toAbsQ7_zKANFxyBsIFlWBZg4FY,9167
 _mcp_mesh/tracing/fastapi_tracing_middleware.py,sha256=o-xyAb1hB_GIFXv0hqUeTwhDDEoFj3_brygmhSComkE,6848
 _mcp_mesh/tracing/redis_metadata_publisher.py,sha256=F78E34qnI3D0tOmbHUTBsLbDst2G7Su2-0F37Rq0rcM,4652
 _mcp_mesh/tracing/trace_context_helper.py,sha256=6tEkwjWFqMBe45zBlhacktmIpzJWTF950ph3bwL3cNc,5994
 _mcp_mesh/tracing/utils.py,sha256=t9lJuTH7CeuzAiiAaD0WxsJMFJPdzZFR0w6-vyR9f2E,3849
 _mcp_mesh/utils/fastmcp_schema_extractor.py,sha256=M54ffesC-56zl_fNJHj9dZxElDQaWFf1MXdSLCuFStg,17253
 mesh/__init__.py,sha256=0zequaBtd_9NLOLsr9sNONuwWa_fT_-G4LnJ1CHTEY0,3808
-mesh/decorators.py,sha256=QTd1wJ8XV0Pfjq2ejyXjyeXBtyodbj1gbs5WKG9AFTs,55632
+mesh/decorators.py,sha256=_3yVrEvGHZ5MKX_pf7Zn-vLdOH68iE7o6EIvxKcGOds,57636
 mesh/helpers.py,sha256=c3FhSy9U4KBHEH6WH6MjCVrPMw9li5JAgBLUTIoamz4,9472
 mesh/types.py,sha256=9TqbJSxlybLQaPVjugcKwPiIrVnJEzqAOvPRhlX1zmo,15559
-mcp_mesh-0.6.4.dist-info/METADATA,sha256=AWReBPZPJbrPJOrxCIXYJRN7nkkQLegtg3aiwljW-Io,4972
-mcp_mesh-0.6.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mcp_mesh-0.6.4.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
-mcp_mesh-0.6.4.dist-info/RECORD,,
+mcp_mesh-0.7.0.dist-info/METADATA,sha256=ikNiCCs-EczkiR8EWKveRVmEdpQ0ovkxd7iyymQA3ic,4972
+mcp_mesh-0.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mcp_mesh-0.7.0.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
+mcp_mesh-0.7.0.dist-info/RECORD,,

mesh/decorators.py

@@ -76,6 +76,49 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
             app = FastAPI(title="MCP Mesh Agent (Starting)")
             logger.debug("📦 IMMEDIATE UVICORN: Created minimal FastAPI app")
 
+        # Add trace context middleware for distributed tracing BEFORE app starts
+        # This must be done before uvicorn.run() since middleware can't be added after start
+        try:
+            import os
+
+            tracing_enabled = os.getenv(
+                "MCP_MESH_DISTRIBUTED_TRACING_ENABLED", "false"
+            ).lower() in ("true", "1", "yes")
+            if tracing_enabled:
+                from starlette.middleware.base import BaseHTTPMiddleware
+                from starlette.requests import Request
+
+                class TraceContextMiddleware(BaseHTTPMiddleware):
+                    """Middleware to extract trace headers and set up trace context."""
+
+                    async def dispatch(self, request: Request, call_next):
+                        try:
+                            from _mcp_mesh.tracing.trace_context_helper import (
+                                TraceContextHelper,
+                            )
+
+                            # Extract and set trace context from headers for distributed tracing
+                            trace_context = await TraceContextHelper.extract_trace_context_from_request(
+                                request
+                            )
+                            TraceContextHelper.setup_request_trace_context(
+                                trace_context, logger
+                            )
+                        except Exception as e:
+                            # Never fail request due to tracing issues
+                            logger.warning(f"Failed to set trace context: {e}")
+
+                        return await call_next(request)
+
+                app.add_middleware(TraceContextMiddleware)
+                logger.debug(
+                    "📦 IMMEDIATE UVICORN: Added trace context middleware for distributed tracing"
+                )
+        except Exception as e:
+            logger.warning(
+                f"⚠️ IMMEDIATE UVICORN: Failed to add trace context middleware: {e}"
+            )
+
         # Add health endpoint that can be updated by pipeline
         # Store health check result in a shared location that can be updated
         health_result = {"status": "starting", "message": "Agent is starting"}