mcp-mesh 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

_mcp_mesh/pipeline/{startup → mcp_startup}/startup_orchestrator.py

@@ -72,6 +72,36 @@ class DebounceCoordinator:
                 f"⏰ Scheduled processing in {self.delay_seconds} seconds"
             )
 
+    def _determine_pipeline_type(self) -> str:
+        """
+        Determine which pipeline to execute based on registered decorators.
+        
+        Returns:
+            "mcp": Only MCP agents/tools found
+            "api": Only API routes found  
+            "mixed": Both MCP and API decorators found (throws exception)
+            "none": No decorators found
+        """
+        from ...engine.decorator_registry import DecoratorRegistry
+        
+        agents = DecoratorRegistry.get_mesh_agents()
+        tools = DecoratorRegistry.get_mesh_tools()
+        routes = DecoratorRegistry.get_all_by_type("mesh_route")
+        
+        has_mcp = len(agents) > 0 or len(tools) > 0
+        has_api = len(routes) > 0
+        
+        self.logger.debug(f"🔍 Pipeline type detection: MCP={has_mcp} ({len(agents)} agents, {len(tools)} tools), API={has_api} ({len(routes)} routes)")
+        
+        if has_api and has_mcp:
+            return "mixed"
+        elif has_api:
+            return "api"
+        elif has_mcp:
+            return "mcp"
+        else:
+            return "none"
+
     def _execute_processing(self) -> None:
         """Execute the processing (called by timer)."""
         try:
@@ -83,6 +113,21 @@ class DebounceCoordinator:
                 f"🚀 Debounce delay ({self.delay_seconds}s) complete, processing all decorators"
             )
 
+            # Determine which pipeline to execute
+            pipeline_type = self._determine_pipeline_type()
+            
+            if pipeline_type == "mixed":
+                error_msg = (
+                    "❌ Mixed mode not supported: Cannot use @mesh.route decorators "
+                    "together with @mesh.tool/@mesh.agent decorators in the same process. "
+                    "Please use either MCP agent decorators OR API route decorators, not both."
+                )
+                self.logger.error(error_msg)
+                raise RuntimeError(error_msg)
+            elif pipeline_type == "none":
+                self.logger.warning("⚠️ No decorators found - nothing to process")
+                return
+            
             # Execute the pipeline using asyncio.run
             import asyncio
 
@@ -90,18 +135,36 @@ class DebounceCoordinator:
             auto_run_enabled = self._check_auto_run_enabled()
 
             self.logger.debug(f"🔍 Auto-run enabled: {auto_run_enabled}")
+            self.logger.info(f"🎯 Pipeline type: {pipeline_type}")
 
             if auto_run_enabled:
                 self.logger.info("🔄 Auto-run enabled - using FastAPI natural blocking")
-                # Phase 1: Run async pipeline setup
-                result = asyncio.run(self._orchestrator.process_once())
+                
+                # Execute appropriate pipeline based on type
+                if pipeline_type == "mcp":
+                    # Phase 1: Run async MCP pipeline setup
+                    result = asyncio.run(self._orchestrator.process_once())
+                elif pipeline_type == "api":
+                    # Phase 1: Run async API pipeline setup
+                    result = asyncio.run(self._orchestrator.process_api_once())
+                else:
+                    raise RuntimeError(f"Unsupported pipeline type: {pipeline_type}")
 
                 # Phase 2: Extract FastAPI app and start synchronous server
                 pipeline_context = result.get("context", {}).get("pipeline_context", {})
                 fastapi_app = pipeline_context.get("fastapi_app")
                 binding_config = pipeline_context.get("fastapi_binding_config", {})
-
-                if fastapi_app and binding_config:
+                heartbeat_config = pipeline_context.get("heartbeat_config", {})
+
+                if pipeline_type == "api":
+                    # For API services, ONLY do dependency injection - user controls their FastAPI server
+                    # Dependency injection is already complete from pipeline execution
+                    # Optionally start heartbeat in background (non-blocking)
+                    self._setup_api_heartbeat_background(heartbeat_config, pipeline_context)
+                    self.logger.info("✅ API dependency injection complete - user's FastAPI server can now start")
+                    return  # Don't block - let user's uvicorn run
+                elif fastapi_app and binding_config:
+                    # For MCP agents with FastAPI server
                     self._start_blocking_fastapi_server(fastapi_app, binding_config)
                 else:
                     self.logger.warning(
@@ -110,11 +173,20 @@ class DebounceCoordinator:
             else:
                 # Single execution mode (for testing/debugging)
                 self.logger.info("🏁 Auto-run disabled - single execution mode")
-                result = asyncio.run(self._orchestrator.process_once())
+                
+                if pipeline_type == "mcp":
+                    result = asyncio.run(self._orchestrator.process_once())
+                elif pipeline_type == "api":
+                    result = asyncio.run(self._orchestrator.process_api_once())
+                else:
+                    raise RuntimeError(f"Unsupported pipeline type: {pipeline_type}")
+                    
                 self.logger.info("✅ Pipeline execution completed, exiting")
 
         except Exception as e:
             self.logger.error(f"❌ Error in debounced processing: {e}")
+            # Re-raise to ensure the system exits on mixed mode or other critical errors
+            raise
 
     def _start_blocking_fastapi_server(
         self, app: Any, binding_config: dict[str, Any]
@@ -148,6 +220,58 @@ class DebounceCoordinator:
             self.logger.error(f"❌ FastAPI server error: {e}")
             raise
 
+    def _setup_api_heartbeat_background(
+        self, heartbeat_config: dict[str, Any], pipeline_context: dict[str, Any]
+    ) -> None:
+        """Setup API heartbeat to run in background - non-blocking."""
+        try:
+            # Populate heartbeat context with current pipeline context
+            heartbeat_config["context"] = pipeline_context
+            service_id = heartbeat_config.get("service_id", "unknown")
+            standalone_mode = heartbeat_config.get("standalone_mode", False)
+            
+            if standalone_mode:
+                self.logger.info(
+                    f"📝 API service '{service_id}' configured in standalone mode - no heartbeat"
+                )
+                return
+            
+            self.logger.info(
+                f"🔗 Setting up background API heartbeat for service '{service_id}'"
+            )
+            
+            # Import heartbeat functionality
+            from ..api_heartbeat.api_lifespan_integration import api_heartbeat_lifespan_task
+            import threading
+            import asyncio
+            
+            def run_heartbeat():
+                """Run heartbeat in separate thread with its own event loop."""
+                self.logger.debug(f"Starting background heartbeat thread for {service_id}")
+                try:
+                    # Create new event loop for this thread
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    
+                    # Run heartbeat task
+                    loop.run_until_complete(api_heartbeat_lifespan_task(heartbeat_config))
+                except Exception as e:
+                    self.logger.error(f"❌ Background heartbeat error: {e}")
+                finally:
+                    loop.close()
+            
+            # Start heartbeat in daemon thread (won't prevent process exit)
+            heartbeat_thread = threading.Thread(target=run_heartbeat, daemon=True)
+            heartbeat_thread.start()
+            
+            self.logger.info(
+                f"💓 Background API heartbeat thread started for service '{service_id}'"
+            )
+
+        except Exception as e:
+            self.logger.warning(f"⚠️ Could not setup API heartbeat: {e}")
+            # Don't fail - heartbeat is optional for API services
+
     def _perform_graceful_shutdown(self) -> None:
         """Perform graceful shutdown by unregistering from registry."""
         try:
@@ -272,6 +396,43 @@ class MeshOrchestrator:
             "timestamp": result.timestamp.isoformat(),
         }
 
+    async def process_api_once(self) -> dict:
+        """
+        Execute the API pipeline once for @mesh.route decorators.
+        
+        This handles FastAPI route integration and dependency injection setup.
+        """
+        self.logger.info(f"🚀 Starting API pipeline execution: {self.name}")
+        
+        try:
+            # Import API pipeline here to avoid circular imports
+            from ..api_startup import APIPipeline
+            
+            # Create and execute API pipeline
+            api_pipeline = APIPipeline(name=f"{self.name}-api")
+            result = await api_pipeline.execute()
+            
+            # Convert result to dict for return type (same format as MCP pipeline)
+            return {
+                "status": result.status.value,
+                "message": result.message,
+                "errors": result.errors,
+                "context": result.context,
+                "timestamp": result.timestamp.isoformat(),
+            }
+            
+        except Exception as e:
+            error_msg = f"API pipeline execution failed: {e}"
+            self.logger.error(f"❌ {error_msg}")
+            
+            return {
+                "status": "failed", 
+                "message": error_msg,
+                "errors": [str(e)],
+                "context": {},
+                "timestamp": "unknown",
+            }
+
     async def start_service(self, auto_run_config: Optional[dict] = None) -> None:
         """
         Start the service with optional auto-run behavior.
@@ -366,6 +527,10 @@ def start_runtime() -> None:
     Actual pipeline execution will be triggered by decorator registration
     with a configurable delay to ensure all decorators are captured.
     """
+    # Configure logging FIRST before any log messages
+    from ...shared.logging_config import configure_logging
+    configure_logging()
+    
     logger.info("🔧 Starting MCP Mesh runtime with debouncing")
 
     # Install signal handlers in main thread FIRST (before any threading)

_mcp_mesh/shared/config_resolver.py

@@ -71,12 +71,9 @@ def get_config_value(
         raw_value = default
         source = "default"
 
-    logger.debug(f"Config {env_var}: raw_value={raw_value} (from {source})")
-
     # Step 2: Validate and convert the value
     try:
         validated_value = _validate_value(raw_value, rule, env_var)
-        logger.debug(f"Config {env_var}: validated_value={validated_value}")
         return validated_value
 
     except ConfigResolutionError as e:

_mcp_mesh/shared/logging_config.py

@@ -69,8 +69,9 @@ def configure_logging():
     root_logger.addHandler(handler)
     root_logger.setLevel(log_level)
 
-    # Set level for all mcp_mesh loggers
+    # Set level for all mcp_mesh loggers (both mcp_mesh and _mcp_mesh namespaces)
     logging.getLogger("mcp_mesh").setLevel(log_level)
+    logging.getLogger("_mcp_mesh").setLevel(log_level)
 
     # Return the configured level for reference
     return log_level

_mcp_mesh/tracing/agent_context_helper.py

@@ -41,7 +41,7 @@ class AgentContextHelper:
             from ..engine.decorator_registry import DecoratorRegistry
 
             agent_config = DecoratorRegistry.get_resolved_agent_config()
-
+            
             # Extract core configuration fields using proper resolution
             context["agent_id"] = agent_config.get("agent_id", "unknown")
             context["agent_name"] = agent_config.get("name") or os.getenv(

_mcp_mesh/tracing/execution_tracer.py

@@ -191,3 +191,44 @@ class ExecutionTracer:
         except Exception as e:
             tracer.end_execution(error=str(e), success=False)
             raise  # Re-raise the exception
+
+    @staticmethod
+    async def trace_function_execution_async(
+        func: Callable,
+        args: tuple,
+        kwargs: dict,
+        dependencies: list[str],
+        mesh_positions: list[int],
+        injected_count: int,
+        logger_instance: logging.Logger,
+    ) -> Any:
+        """
+        Trace async function execution with comprehensive logging.
+
+        This is a static method that handles the complete execution flow with proper
+        exception handling and cleanup. If tracing is disabled, calls function directly.
+        """
+        import inspect
+        
+        # If tracing is disabled, call function directly without any overhead
+        if not _is_tracing_enabled():
+            if inspect.iscoroutinefunction(func):
+                return await func(*args, **kwargs)
+            else:
+                return func(*args, **kwargs)
+
+        tracer = ExecutionTracer(func.__name__, logger_instance)
+        tracer.start_execution(
+            args, kwargs, dependencies, mesh_positions, injected_count
+        )
+
+        try:
+            if inspect.iscoroutinefunction(func):
+                result = await func(*args, **kwargs)
+            else:
+                result = func(*args, **kwargs)
+            tracer.end_execution(result, success=True)
+            return result
+        except Exception as e:
+            tracer.end_execution(error=str(e), success=False)
+            raise  # Re-raise the exception

{mcp_mesh-0.4.2.dist-info → mcp_mesh-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.4.2
+Version: 0.5.1
 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.4.2.dist-info → mcp_mesh-0.5.1.dist-info}/RECORD

@@ -1,30 +1,32 @@
-_mcp_mesh/__init__.py,sha256=4YFRyw3RwxKNKMPP9rmT4enhGSe8ceAG8AgOKbU5ITY,2103
-_mcp_mesh/engine/__init__.py,sha256=o4axdnjeUnUTsukZFacMNnxd6LRX2D46qJzMzUfEZUI,3259
-_mcp_mesh/engine/async_mcp_client.py,sha256=IdcCsswl1WXnzIWGb686Morgjf4CROm411EiDeE0cac,6308
-_mcp_mesh/engine/decorator_registry.py,sha256=w_-10yBkgYAu_u-SUrTaZcCOv1t_MqlHPg0vFQGdy2I,15506
-_mcp_mesh/engine/dependency_injector.py,sha256=RbXa9ap1PYRc7G3-ZnJkWQOcibQfecQDGIU-_7O2Raw,17310
-_mcp_mesh/engine/full_mcp_proxy.py,sha256=fJyU5mbmvqDXaSgnT00eVb9EnumTHP2QMwAPB_IfIQc,25301
-_mcp_mesh/engine/http_wrapper.py,sha256=NFKCcUPwSLeyLuTc1TwWpBRrlsbgkzBoiZiZixhOias,21453
-_mcp_mesh/engine/mcp_client_proxy.py,sha256=RpHdwCjC6mwiZ5idv7h8OchFRbufyC2NLaHxzU2kKyo,17623
+_mcp_mesh/__init__.py,sha256=BAOIf5sCRsdTxO-EgvzGKGN24_NRdv21wYj6uKjSHYM,2646
+_mcp_mesh/engine/__init__.py,sha256=2ennzbo7yJcpkXO9BqN69TruLjJfmJY4Y5VEsG644K4,3630
+_mcp_mesh/engine/async_mcp_client.py,sha256=UcbQjxtgVfeRw6DHTZhAzN1gkcKlTg-lUPEePRPQWAU,6306
+_mcp_mesh/engine/decorator_registry.py,sha256=Dy3de-CQa3T4-BRV5Xx6Ks3s6gvgL-lcxCYLsfrTdX0,19085
+_mcp_mesh/engine/dependency_injector.py,sha256=tzsv10U_EG8GjhTvlF2fsoXkKQ2x52_WYQCOaLlgWfs,26568
+_mcp_mesh/engine/full_mcp_proxy.py,sha256=PlRv7GSKqn5riOCqeCVulVdtq3z1Ug76mOkwMsOFHXw,25297
+_mcp_mesh/engine/http_wrapper.py,sha256=7Djx5zreai4c644sDpwpV_Kn35Ie6_ulUhqFOWoU_kU,21110
+_mcp_mesh/engine/mcp_client_proxy.py,sha256=eJStwy_VQJexYYD8bOh_m4Ld3Bb8Ae_dt8N1CC41qBc,17625
 _mcp_mesh/engine/self_dependency_proxy.py,sha256=OkKt0-B_ADnJlWtHiHItoZCBZ7Su0iz2unEPFfXvrs4,3302
 _mcp_mesh/engine/session_aware_client.py,sha256=mc9eh-aCvUvfllORiXTf_X8_jPqV-32QdWKlr8tHLkU,10600
 _mcp_mesh/engine/session_manager.py,sha256=MCr0_fXBaUjXM51WU5EhDkiGvBdfzYQFVNb9DCXXL0A,10418
 _mcp_mesh/engine/signature_analyzer.py,sha256=AxBuFq8_TCT2afw_XDF4AjWPqdG6ST5jfbw2BDdp9Mo,7482
+_mcp_mesh/engine/unified_mcp_proxy.py,sha256=pKKwfe5qEKa_JwKelHw6t0hJyYpBMHGYdZ3mFuo3QxY,32748
 _mcp_mesh/generated/.openapi-generator-ignore,sha256=-d-Y-RVAZRrHw36jO0b79oDXpfA8rZdBGPCG4Vs_rUs,227
-_mcp_mesh/generated/.openapi-generator/FILES,sha256=S08v94ANDOk4-N-dprHSrXaqWwHp_D2mvVMQl3j283A,2078
+_mcp_mesh/generated/.openapi-generator/FILES,sha256=BXFXHe4FTV5GFUTNjMhmvOrVcYVlHJc5O-3UXyp8OCY,2169
 _mcp_mesh/generated/.openapi-generator/VERSION,sha256=nMm490YXJUW3_vAdeAsg7E3yRgUqVwk5-50PuaFonM8,7
-_mcp_mesh/generated/mcp_mesh_registry_client/__init__.py,sha256=dz-3o3W3r_hDAFAGOXr4UCeVvXWqkZyCx4KtfI4xYHY,5433
+_mcp_mesh/generated/mcp_mesh_registry_client/__init__.py,sha256=C_J51kNjdAQ2ikcXQzaIC0x9HQgbibT02x1rmWpeKGw,5604
 _mcp_mesh/generated/mcp_mesh_registry_client/api_client.py,sha256=SLzm-p1vhbhufVDn7sNKjq9aSBkZUXTdwRIf7Ne57l8,28104
 _mcp_mesh/generated/mcp_mesh_registry_client/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
 _mcp_mesh/generated/mcp_mesh_registry_client/configuration.py,sha256=PCZ03PQGCEG0lfIn4s1tk8WrB9HpQ-LCXIUK110F1gY,18544
 _mcp_mesh/generated/mcp_mesh_registry_client/exceptions.py,sha256=wMmZWaCPfoAloDVS4u9MkRKG0oUjXl_B-3KAOrFQbUM,6921
 _mcp_mesh/generated/mcp_mesh_registry_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 _mcp_mesh/generated/mcp_mesh_registry_client/rest.py,sha256=myEMrqhlSTaYUu52NlhUqFFTTMkhBI4V5cXaxjciWSI,9948
-_mcp_mesh/generated/mcp_mesh_registry_client/api/__init__.py,sha256=61J3DpxqJfJ91WPD6gw_ngZEqtGzCFydc9hsqPKucd0,212
+_mcp_mesh/generated/mcp_mesh_registry_client/api/__init__.py,sha256=CP4BRsWFhioEIcU_fXbONaCa222wnWB8fTwADfqGUsc,296
 _mcp_mesh/generated/mcp_mesh_registry_client/api/agents_api.py,sha256=rHY0h_wcv9eLRzOitkRZ7PDKtgWr5xism3azkZpuI6I,46445
 _mcp_mesh/generated/mcp_mesh_registry_client/api/health_api.py,sha256=BJsqdNHz-dZXJsvQmYdZLLM_vf1Lf6DKRH9xzpyfkuU,30552
-_mcp_mesh/generated/mcp_mesh_registry_client/models/__init__.py,sha256=dVazgBm35vuNmYFfb1nJooMT0GHu9VNwGuysjKWzNYM,3881
-_mcp_mesh/generated/mcp_mesh_registry_client/models/agent_info.py,sha256=Yh57CvFPjiaNLy-ub81kYPcm1eqc8Fpn9OXQZGtgZxg,4845
+_mcp_mesh/generated/mcp_mesh_registry_client/api/tracing_api.py,sha256=2FmSDoWiAfx404kB5mkWvYviE37QVY-Cb-kA90o1rn8,13179
+_mcp_mesh/generated/mcp_mesh_registry_client/models/__init__.py,sha256=s54kd3wYhgltJgOFD0RLQX7prcuI4uDibwVXXo5SrTs,3968
+_mcp_mesh/generated/mcp_mesh_registry_client/models/agent_info.py,sha256=ZD3qwc7GlKYV3Jlxbc79gEJWf-2_H0m07GVyHL4cCVw,5293
 _mcp_mesh/generated/mcp_mesh_registry_client/models/agent_metadata.py,sha256=_ixbM8wlhL5C7jx-NXoA0zdJSK88-TX8URuCIOv7_E8,6520
 _mcp_mesh/generated/mcp_mesh_registry_client/models/agent_metadata_dependencies_inner.py,sha256=LiO2JfFwasidNJ859LKmDHa6kV1boGIlTdhFwmpgoxw,6303
 _mcp_mesh/generated/mcp_mesh_registry_client/models/agent_metadata_dependencies_inner_one_of.py,sha256=aQ7h5TloM-FvBrQ0uzH0m9iba4EbX--djxh8etcXids,3615
@@ -42,7 +44,7 @@ _mcp_mesh/generated/mcp_mesh_registry_client/models/heartbeat_request.py,sha256=
 _mcp_mesh/generated/mcp_mesh_registry_client/models/heartbeat_request_metadata.py,sha256=A-L6mFz19Pa-QExvCihCHrJDHIlIV18w290usgD6_Yo,4317
 _mcp_mesh/generated/mcp_mesh_registry_client/models/heartbeat_response.py,sha256=dPJxz5XQukw4QejkeP7F3FAm8m0wW-5gm9xpajlkGqQ,4907
 _mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_agent_register_metadata.py,sha256=HGABUatJp_mu2uFWzC7HBEZACHXIKFmIeegFYfHEcN4,4820
-_mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_agent_registration.py,sha256=9LylYbX2tI-59H-WzTwz1elrKELALAia9UGi83pDD9s,6139
+_mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_agent_registration.py,sha256=qZiljiQH877iBN35poelxDPPnHwpjbu9J2yCwKmZgg8,6182
 _mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_registration_response.py,sha256=tKG2maoADs_cXc2IdU-Pycsf0jyfOLnqeGZJtLXwf3E,5075
 _mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_registration_response_dependencies_resolved_value_inner.py,sha256=tmcFBO8rbB_F-TfpU2lsG29CKTpQPfiuJqE62r81p0k,4071
 _mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_tool_dependency_registration.py,sha256=PkY1rWdS3y5TTxRRFpATWmm3dhw_Qw2_4QBzCv_7ZuU,3658
@@ -52,48 +54,64 @@ _mcp_mesh/generated/mcp_mesh_registry_client/models/registration_response.py,sha
 _mcp_mesh/generated/mcp_mesh_registry_client/models/rich_dependency.py,sha256=Y6TB1Zvfkq2U8YMSmWUmIcOZMU6ZZxRFmifUGwdRwa0,3591
 _mcp_mesh/generated/mcp_mesh_registry_client/models/root_response.py,sha256=Das3mRHvgqDJVuWsoWLtwUTv_I5nFejhV10U0JZ_CZM,3221
 _mcp_mesh/generated/mcp_mesh_registry_client/models/standardized_dependency.py,sha256=fm1tmP0f07ziGMz0zYvpIvMGeIcfff2wrS6jlWgvm9A,3650
-_mcp_mesh/pipeline/__init__.py,sha256=MMTikEB9V7JkYsVG_sf78vNv0fdO2d_9CLawdqyMToo,1549
-_mcp_mesh/pipeline/heartbeat/__init__.py,sha256=nRNjZ3VD_9bPLQuJ6Nc02gE7KSLcMP7TMquB0hP6hHs,844
-_mcp_mesh/pipeline/heartbeat/dependency_resolution.py,sha256=SMSwoB0MvXV-TrgCbAXB59AotIZYQW9Dinrkhsircdw,25145
-_mcp_mesh/pipeline/heartbeat/fast_heartbeat_check.py,sha256=QTzYdL81WERkOaBVOgNbFQh1ddTn70urNtyIgtFTudA,4465
-_mcp_mesh/pipeline/heartbeat/heartbeat_orchestrator.py,sha256=56IK5p8xlppJ5i6oMMh12fin3XwrOTcppTuVO2CnlV8,11292
-_mcp_mesh/pipeline/heartbeat/heartbeat_pipeline.py,sha256=Jb7EVJO13trUVO3aCSgzGqAtoc4vie5kDrYLZtOkiXg,11601
-_mcp_mesh/pipeline/heartbeat/heartbeat_send.py,sha256=ydVx-Vb_RgW1WPCboHVdZfEwNbgDngFV6Y9elZIBrAw,3602
-_mcp_mesh/pipeline/heartbeat/lifespan_integration.py,sha256=yCt731vgniSfxuClIcMvlMtDrubTu_9crgwiOwOYoBQ,2510
-_mcp_mesh/pipeline/heartbeat/registry_connection.py,sha256=4abbOKN3echwX82PV0RvxF6cJZUu0pMgisOpILZ_ZzY,2875
+_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=EcWfqZ2IWcagt0pGkVa944uW7KePABVXn6CPAAspjYo,23582
+_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_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
+_mcp_mesh/pipeline/api_startup/api_pipeline.py,sha256=9KMyryefhaPBkGJylNoFcFr5Ezh6NJWKBOJfVJaVJ5A,2302
+_mcp_mesh/pipeline/api_startup/api_server_setup.py,sha256=Qy0wbXyIWIQYA7CjiGVZwn0nWCKK85ZzFTRI2JDA9Aw,15099
+_mcp_mesh/pipeline/api_startup/fastapi_discovery.py,sha256=BOo7_cBwABNpk_3Y-Lh_3ygwAOQ_254dwblPyO_vLIw,11991
+_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/mcp_heartbeat/__init__.py,sha256=nRNjZ3VD_9bPLQuJ6Nc02gE7KSLcMP7TMquB0hP6hHs,844
+_mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py,sha256=nHjKSM4Yyn05wnfw1dI4VGroHZy8lRkDihnZfFHeF8U,16217
+_mcp_mesh/pipeline/mcp_heartbeat/fast_heartbeat_check.py,sha256=QTzYdL81WERkOaBVOgNbFQh1ddTn70urNtyIgtFTudA,4465
+_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_orchestrator.py,sha256=56IK5p8xlppJ5i6oMMh12fin3XwrOTcppTuVO2CnlV8,11292
+_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_pipeline.py,sha256=Jb7EVJO13trUVO3aCSgzGqAtoc4vie5kDrYLZtOkiXg,11601
+_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_send.py,sha256=ydVx-Vb_RgW1WPCboHVdZfEwNbgDngFV6Y9elZIBrAw,3602
+_mcp_mesh/pipeline/mcp_heartbeat/lifespan_integration.py,sha256=yCt731vgniSfxuClIcMvlMtDrubTu_9crgwiOwOYoBQ,2510
+_mcp_mesh/pipeline/mcp_heartbeat/registry_connection.py,sha256=4abbOKN3echwX82PV0RvxF6cJZUu0pMgisOpILZ_ZzY,2875
+_mcp_mesh/pipeline/mcp_startup/__init__.py,sha256=_Y25DgT9eYJ_7Qe7x1Z7y4VFUIaFEmCBS9YD9QIlo7k,1142
+_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=pQIrEc70qeWP732S9LF5A2qWq0CZ5wK-bxls7AjX_2o,33346
+_mcp_mesh/pipeline/mcp_startup/fastmcpserver_discovery.py,sha256=ktsE9EZYdyZbCtCKB6HVdzGFMQ0E9n0-7I55LRO99sE,10270
+_mcp_mesh/pipeline/mcp_startup/heartbeat_loop.py,sha256=v85B0ynomvYu87eIvLe-aSZ7-Iwov2VtM4Fg3PkmrZs,3865
+_mcp_mesh/pipeline/mcp_startup/heartbeat_preparation.py,sha256=v3Fl0PvW5s7Ib_Cy7WtXA7gDvsFGiz54a-IlQRTcLPg,10410
+_mcp_mesh/pipeline/mcp_startup/startup_orchestrator.py,sha256=W9o_d0xTOAqK5i8Xd7BJgiUJou1uPZwsygslM3I9HYo,25149
+_mcp_mesh/pipeline/mcp_startup/startup_pipeline.py,sha256=E-kmmfkdtRMhpEAF-_qFLAdaY3sLo165SUHjlRXwqC4,2069
 _mcp_mesh/pipeline/shared/__init__.py,sha256=s9xmdf6LkoetrVRGd7Zp3NUxcJCW6YZ_yNKzUBcnYys,352
 _mcp_mesh/pipeline/shared/base_step.py,sha256=kyPbNUX79NyGrE_0Q-e-Aek7m1J0TW036njWfv0iZ0I,1080
 _mcp_mesh/pipeline/shared/mesh_pipeline.py,sha256=wTODlMb7ByhzsT3DnM0lzY3gS9fKLDUxL0yDEozCVeo,6494
 _mcp_mesh/pipeline/shared/pipeline_types.py,sha256=iKSgzCoYu3bpIwLViw6lE7T7irEzOm7gpie29lyy7SQ,1504
 _mcp_mesh/pipeline/shared/registry_connection.py,sha256=jmlgULixRM1NMNyMc-8SJN3RpCtV9hUf76vn9nciAN4,2904
-_mcp_mesh/pipeline/startup/__init__.py,sha256=_Y25DgT9eYJ_7Qe7x1Z7y4VFUIaFEmCBS9YD9QIlo7k,1142
-_mcp_mesh/pipeline/startup/configuration.py,sha256=6LRLIxrqFMU76qrBb6GjGknUlKPZZ9iqOlxE7F9ZhLs,2808
-_mcp_mesh/pipeline/startup/decorator_collection.py,sha256=RHC6MHtfP9aP0hZ-IJjISZu72e0Pml3LU0qr7dc284w,2294
-_mcp_mesh/pipeline/startup/fastapiserver_setup.py,sha256=pQIrEc70qeWP732S9LF5A2qWq0CZ5wK-bxls7AjX_2o,33346
-_mcp_mesh/pipeline/startup/fastmcpserver_discovery.py,sha256=ktsE9EZYdyZbCtCKB6HVdzGFMQ0E9n0-7I55LRO99sE,10270
-_mcp_mesh/pipeline/startup/heartbeat_loop.py,sha256=0IX2Q-OJvTVsNILUKxl7v3-BM8DdAW3UB-W-Z2gAWrc,3861
-_mcp_mesh/pipeline/startup/heartbeat_preparation.py,sha256=v3Fl0PvW5s7Ib_Cy7WtXA7gDvsFGiz54a-IlQRTcLPg,10410
-_mcp_mesh/pipeline/startup/startup_orchestrator.py,sha256=r0po5cQKe9F5nO6ey5PmYGjYKHe5u8pNEFy7Da0Lh5w,17835
-_mcp_mesh/pipeline/startup/startup_pipeline.py,sha256=E-kmmfkdtRMhpEAF-_qFLAdaY3sLo165SUHjlRXwqC4,2069
 _mcp_mesh/shared/__init__.py,sha256=L0detgEWjnc_XfxA_5vIBcaGTuLcT6AARKkUpUBIaH4,1116
-_mcp_mesh/shared/config_resolver.py,sha256=aEsb9mMciQUjpdOpmPpwjgSRESjqZTvzKscoYoUKBhQ,7935
+_mcp_mesh/shared/config_resolver.py,sha256=r8WcO8lrd4XBHhH9IkAM7iy-QeCmTiVLmKhnJ47pFP0,7780
 _mcp_mesh/shared/content_extractor.py,sha256=culjhieFl_J6EMDv1VFKvS38O3IMhWMs8fHhNuR2rVk,3656
 _mcp_mesh/shared/defaults.py,sha256=5qazybkn7QHi418dXCS0b6QlNQl3DMg97ItzNGkc8d4,1851
 _mcp_mesh/shared/fast_heartbeat_status.py,sha256=OquEsX9ZTbxY1lIsll0Mbb2KDzSJD76sLMOlr3Z73Sc,5188
 _mcp_mesh/shared/host_resolver.py,sha256=ycs6gXnI1zJX5KiqiLJPX5GkHX8r4j8NMHQOlG2J2X8,2964
-_mcp_mesh/shared/logging_config.py,sha256=m_eW5ub01mjjoLdF55lv9JwSK9y52rqpVTRN8jNz_6s,2381
+_mcp_mesh/shared/logging_config.py,sha256=n9AqShZ5BZgyrkoTlvux6ECRVpM9dUYvmGB0NPMl-Ak,2477
 _mcp_mesh/shared/registry_client_wrapper.py,sha256=d8yL-MiCrQr_WYdRFStOd531qaLv9kZjh0zJAmCJ-Cc,16976
 _mcp_mesh/shared/sse_parser.py,sha256=OEPnfL9xL3rsjQrbyvfUO82WljPSDeO6Z61uUwN1NAo,8035
 _mcp_mesh/shared/support_types.py,sha256=k-ICF_UwDkHxQ1D5LwFZrp-UrNb4E5dzw02CRuLW9iI,7264
-_mcp_mesh/tracing/agent_context_helper.py,sha256=XR3OyVT40lWyXaSWYBWdOhs0ZqTj3Xa49BSG8EUzrjI,4595
+_mcp_mesh/tracing/agent_context_helper.py,sha256=gODirjGf80vTLoHaVZgOOLlf068Tfxg-3GBn2GOBUaY,4607
 _mcp_mesh/tracing/context.py,sha256=yZtTZXVKltX2BUBrWeeNfQ8Y4n6L_2ywFVlFP-wU9og,2353
-_mcp_mesh/tracing/execution_tracer.py,sha256=rAyAhSMy7Mr5KpZcQUfDcQ5QW8bj-g-H6wVB3tvkkR4,6852
+_mcp_mesh/tracing/execution_tracer.py,sha256=Wx6cE7CskZqBPsrn4Fmkyd3DLR9R_E4j_BCLVx1cOWE,8293
 _mcp_mesh/tracing/redis_metadata_publisher.py,sha256=5U5GojBFYZdxJJ1RvmdxXHC-VuPQz4kMla6n0xdZxKc,5371
 _mcp_mesh/tracing/trace_context_helper.py,sha256=xPDygKrXcoJbrr7013Av_I0ajammWEq68ihdP7DZ-Zo,6072
-mesh/__init__.py,sha256=XtquSwwLeVJwQZjg8jO4_vRNSQZtWo_Mv2tixI1_Yzg,3171
-mesh/decorators.py,sha256=_WLqfMXQgi_4Xarci-sRa3zxqKWIf-2HYELh9MAitYY,18397
-mesh/types.py,sha256=cR8oRKHZjZXNkbHPYdRfLNDyCE4yEz_Fbrmdc08NY6k,8775
-mcp_mesh-0.4.2.dist-info/METADATA,sha256=clX_rcn6hz6Q3wSbA4Wx2fkqNSm4LWmbOVL0nhojKA8,4879
-mcp_mesh-0.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_mesh-0.4.2.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
-mcp_mesh-0.4.2.dist-info/RECORD,,
+mesh/__init__.py,sha256=l5RSMV8Kx0h7cvku8YkZPbTHjEPWciGT0bcEB2O_eNU,3242
+mesh/decorators.py,sha256=UWNfykDBCChpIqqljcjAAzlJphv5TMZLEBCNzwfl478,24264
+mesh/types.py,sha256=g37DXAzya-xGPa1_WKlW3T3_VqyTn8ZVepIDSrhBTkc,10815
+mcp_mesh-0.5.1.dist-info/METADATA,sha256=8R-o_N6olx0pnUwDUij1I2PN2IYFkd9Mmrg-ocBL3ls,4879
+mcp_mesh-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_mesh-0.5.1.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
+mcp_mesh-0.5.1.dist-info/RECORD,,

mesh/__init__.py

@@ -87,12 +87,14 @@ def create_server(name: str | None = None) -> "FastMCP":
     return FastMCP(name=name)
 
 
-# Make decorators available as mesh.tool and mesh.agent
+# Make decorators available as mesh.tool, mesh.agent, and mesh.route
 def __getattr__(name):
     if name == "tool":
         return decorators.tool
     elif name == "agent":
         return decorators.agent
+    elif name == "route":
+        return decorators.route
     elif name == "McpMeshAgent":
         return McpMeshAgent
     elif name == "McpAgent":

mesh/decorators.py

@@ -32,7 +32,7 @@ def _trigger_debounced_processing():
     all decorators are captured before processing begins.
     """
     try:
-        from _mcp_mesh.pipeline.startup import get_debounce_coordinator
+        from _mcp_mesh.pipeline.mcp_startup import get_debounce_coordinator
 
         coordinator = get_debounce_coordinator()
         coordinator.trigger_processing()
@@ -485,3 +485,145 @@ def agent(
         return target
 
     return decorator
+
+
+def route(
+    *,
+    dependencies: list[dict[str, Any]] | list[str] | None = None,
+    **kwargs: Any,
+) -> Callable[[T], T]:
+    """
+    FastAPI route handler decorator for dependency injection.
+    
+    Enables automatic dependency injection of MCP agents into FastAPI route handlers,
+    eliminating the need for manual MCP client management in backend services.
+    
+    Args:
+        dependencies: Optional list of agent capabilities to inject (default: [])
+        **kwargs: Additional metadata for the route
+        
+    Returns:
+        The original route handler function with dependency injection enabled
+        
+    Example:
+        @app.post("/upload")
+        @mesh.route(dependencies=["pdf-extractor", "user-service"])
+        async def upload_resume(
+            request: Request,
+            file: UploadFile = File(...),
+            pdf_agent: McpAgent = None,    # Injected by MCP Mesh
+            user_service: McpAgent = None  # Injected by MCP Mesh
+        ):
+            result = await pdf_agent.extract_text_from_pdf(file)
+            await user_service.update_profile(user_data, result)
+            return {"success": True}
+    """
+    
+    def decorator(target: T) -> T:
+        # Validate and process dependencies (reuse logic from tool decorator)
+        if dependencies is not None:
+            if not isinstance(dependencies, list):
+                raise ValueError("dependencies must be a list")
+            
+            validated_dependencies = []
+            for dep in dependencies:
+                if isinstance(dep, str):
+                    # Simple string dependency
+                    validated_dependencies.append({
+                        "capability": dep,
+                        "tags": [],
+                    })
+                elif isinstance(dep, dict):
+                    # Complex dependency with metadata
+                    if "capability" not in dep:
+                        raise ValueError("dependency must have 'capability' field")
+                    if not isinstance(dep["capability"], str):
+                        raise ValueError("dependency capability must be a string")
+                    
+                    # Validate optional dependency fields
+                    dep_tags = dep.get("tags", [])
+                    if not isinstance(dep_tags, list):
+                        raise ValueError("dependency tags must be a list")
+                    for tag in dep_tags:
+                        if not isinstance(tag, str):
+                            raise ValueError("all dependency tags must be strings")
+                    
+                    dep_version = dep.get("version")
+                    if dep_version is not None and not isinstance(dep_version, str):
+                        raise ValueError("dependency version must be a string")
+                    
+                    dependency_dict = {
+                        "capability": dep["capability"],
+                        "tags": dep_tags,
+                    }
+                    if dep_version is not None:
+                        dependency_dict["version"] = dep_version
+                    validated_dependencies.append(dependency_dict)
+                else:
+                    raise ValueError("dependencies must be strings or dictionaries")
+        else:
+            validated_dependencies = []
+        
+        # Build route metadata
+        metadata = {
+            "dependencies": validated_dependencies,
+            "description": getattr(target, "__doc__", None),
+            **kwargs,
+        }
+        
+        # Store metadata on function
+        target._mesh_route_metadata = metadata
+        
+        # Register with DecoratorRegistry using custom decorator type
+        DecoratorRegistry.register_custom_decorator("mesh_route", target, metadata)
+        
+        logger.debug(
+            f"🔍 Route '{target.__name__}' registered with {len(validated_dependencies)} dependencies"
+        )
+        
+        try:
+            # Import here to avoid circular imports
+            from _mcp_mesh.engine.dependency_injector import get_global_injector
+
+            # Extract dependency names for injector 
+            dependency_names = [dep["capability"] for dep in validated_dependencies]
+
+            # Log the original function pointer
+            logger.debug(f"🔸 ORIGINAL route function pointer: {target} at {hex(id(target))}")
+
+            injector = get_global_injector()
+            wrapped = injector.create_injection_wrapper(target, dependency_names)
+
+            # Log the wrapper function pointer
+            logger.debug(
+                f"🔹 WRAPPER route function pointer: {wrapped} at {hex(id(wrapped))}"
+            )
+
+            # Preserve metadata on wrapper
+            wrapped._mesh_route_metadata = metadata
+
+            # Store the wrapper on the original function for reference
+            target._mesh_injection_wrapper = wrapped
+            
+            # Also store a flag on the wrapper itself so route integration can detect it
+            wrapped._mesh_is_injection_wrapper = True
+
+            # Return the wrapped function - FastAPI will register this wrapper when it runs
+            logger.debug(f"✅ Returning injection wrapper for route '{target.__name__}'")
+            logger.debug(f"🔹 Returning WRAPPER: {wrapped} at {hex(id(wrapped))}")
+
+            # Trigger debounced processing before returning
+            _trigger_debounced_processing()
+            return wrapped
+
+        except Exception as e:
+            # Log but don't fail - graceful degradation
+            logger.error(
+                f"Route dependency injection setup failed for {target.__name__}: {e}"
+            )
+            
+            # Fallback: return original function and trigger processing
+            _trigger_debounced_processing()
+            return target
+    
+    return decorator