mcp-mesh 0.7.21__py3-none-any.whl → 0.8.0__py3-none-any.whl

_mcp_mesh/pipeline/api_startup/api_server_setup.py

@@ -11,12 +11,12 @@ from ..shared import PipelineResult, PipelineStatus, PipelineStep
 class APIServerSetupStep(PipelineStep):
     """
     Minimal API server setup for FastAPI integration.
-    
+
     This step prepares the binding configuration and service registration
     metadata for the user's existing FastAPI application. It does NOT create
     or modify the FastAPI app - it only prepares the configuration needed
     to run the app with uvicorn and register it with the mesh registry.
-    
+
     Our job is ONLY dependency injection - the user owns their FastAPI app.
     """
 
@@ -37,7 +37,7 @@ class APIServerSetupStep(PipelineStep):
             # Verify we have FastAPI apps to work with
             fastapi_apps = context.get("fastapi_apps", {})
             integration_results = context.get("integration_results", {})
-            
+
             if not fastapi_apps:
                 result.status = PipelineStatus.FAILED
                 result.message = "No FastAPI applications found"
@@ -60,35 +60,45 @@ class APIServerSetupStep(PipelineStep):
             primary_app_id = list(fastapi_apps.keys())[0]
             primary_app_info = fastapi_apps[primary_app_id]
             primary_app = primary_app_info["instance"]
-            
+
             self.logger.info(
                 f"🎯 Using FastAPI app: '{primary_app_info['title']}' as primary app"
             )
 
             # Prepare display configuration for registry (NOT binding configuration)
             display_config = self._prepare_display_config()
-            
+
             # Prepare service registration metadata
             service_metadata = self._prepare_service_metadata(
-                primary_app_info, integration_results.get(primary_app_id, {}), display_config
+                primary_app_info,
+                integration_results.get(primary_app_id, {}),
+                display_config,
             )
-            
+
             # Prepare heartbeat configuration
             heartbeat_config = self._prepare_heartbeat_config(
                 primary_app_info, display_config, service_metadata
             )
-            
+
             # Store configuration in context
             result.add_context("primary_fastapi_app", primary_app)
-            result.add_context("fastapi_app", primary_app)  # For heartbeat compatibility
+            result.add_context(
+                "fastapi_app", primary_app
+            )  # For heartbeat compatibility
             result.add_context("api_display_config", display_config)
-            result.add_context("display_config", display_config)  # For heartbeat compatibility
+            result.add_context(
+                "display_config", display_config
+            )  # For heartbeat compatibility
             result.add_context("api_service_metadata", service_metadata)
-            result.add_context("service_type", "api")  # Important for registry registration
+            result.add_context(
+                "service_type", "api"
+            )  # Important for registry registration
             result.add_context("heartbeat_config", heartbeat_config)
-            
+
             # Update result message
-            integrated_routes = integration_results.get(primary_app_id, {}).get("integrated_count", 0)
+            integrated_routes = integration_results.get(primary_app_id, {}).get(
+                "integrated_count", 0
+            )
             result.message = (
                 f"API server config prepared for '{primary_app_info['title']}' "
                 f"with {integrated_routes} dependency-injected routes"
@@ -110,65 +120,68 @@ class APIServerSetupStep(PipelineStep):
     def _prepare_display_config(self) -> Dict[str, Any]:
         """
         Prepare display configuration for service registration.
-        
+
         This is ONLY for registry display purposes since FastAPI services
         are consumers (nobody needs to communicate TO them in mesh network).
         Users configure their actual uvicorn host/port separately.
         """
         # Get external host for display (what others would see this service as)
         external_host = HostResolver.get_external_host()
-        
+
         # Get port for display - users can override via env var
         display_port = get_config_value(
-            "MCP_MESH_HTTP_PORT", 
+            "MCP_MESH_HTTP_PORT",
             default=8080,  # FastAPI convention
             rule=ValidationRule.PORT_RULE,
         )
-        
+
         # Also check if user provided host override
         display_host = get_config_value(
             "MCP_MESH_HTTP_HOST",
             default=external_host,
             rule=ValidationRule.STRING_RULE,
         )
-        
+
         display_config = {
             "display_host": display_host,
             "display_port": display_port,
             "external_host": external_host,
         }
-        
+
         self.logger.debug(
             f"📍 Display config: {display_host}:{display_port} "
             f"(for registry display only - user controls actual uvicorn binding)"
         )
-        
+
         return display_config
 
     def _prepare_service_metadata(
-        self, app_info: Dict[str, Any], integration_results: Dict[str, Any], display_config: Dict[str, Any]
+        self,
+        app_info: Dict[str, Any],
+        integration_results: Dict[str, Any],
+        display_config: Dict[str, Any],
     ) -> Dict[str, Any]:
         """
         Prepare service registration metadata for mesh registry.
-        
+
         This metadata tells the mesh registry about our API service
         and what capabilities it provides (routes, not MCP tools).
         """
         # Extract route information for registry
         route_capabilities = []
         route_details = integration_results.get("route_details", {})
-        
+
         for route_name, details in route_details.items():
             if details.get("status") == "integrated":
                 # Create capability entry for each dependency-injected route
                 capability_info = {
                     "name": route_name,
-                    "type": "api_route", 
+                    "type": "api_route",
                     "dependencies": details.get("dependencies", []),
                     "dependency_count": details.get("dependency_count", 0),
                 }
                 route_capabilities.append(capability_info)
-        
+
         # Build service metadata
         service_metadata = {
             "service_name": app_info.get("title", "FastAPI Service"),
@@ -184,43 +197,46 @@ class APIServerSetupStep(PipelineStep):
             "display_port": display_config["display_port"],
             "external_host": display_config["external_host"],
         }
-        
+
         self.logger.debug(
             f"📋 Service metadata: {service_metadata['service_name']} "
             f"({len(route_capabilities)} capabilities)"
         )
-        
+
         return service_metadata
 
     def _prepare_heartbeat_config(
-        self, app_info: Dict[str, Any], display_config: Dict[str, Any], service_metadata: Dict[str, Any]
+        self,
+        app_info: Dict[str, Any],
+        display_config: Dict[str, Any],
+        service_metadata: Dict[str, Any],
     ) -> Dict[str, Any]:
         """
         Prepare heartbeat configuration for API service.
-        
+
         This configuration will be used to start the heartbeat pipeline
         for periodic service registration and health monitoring.
         """
         # Check if we already have a service ID in the decorator registry
         # If so, and it's in API format, reuse it to avoid ID changes
         service_id = self._get_or_generate_api_service_id(app_info)
-        
+
         # Get heartbeat interval using centralized defaults (consistent with MCP heartbeat)
         from ...shared.defaults import MeshDefaults
-        
+
         heartbeat_interval = get_config_value(
             "MCP_MESH_HEALTH_INTERVAL",
             default=MeshDefaults.HEALTH_INTERVAL,
             rule=ValidationRule.NONZERO_RULE,
         )
-        
+
         # Check if standalone mode (no registry communication)
         standalone_mode = get_config_value(
             "MCP_MESH_STANDALONE",
             default=False,
             rule=ValidationRule.TRUTHY_RULE,
         )
-        
+
         heartbeat_config = {
             "service_id": service_id,
             "interval": heartbeat_interval,
@@ -228,18 +244,17 @@ class APIServerSetupStep(PipelineStep):
             "context": {
                 # Context will be populated during heartbeat execution
                 # with current pipeline context including fastapi_app, display_config, etc.
-            }
+            },
         }
-        
+
         # Store the generated service ID back to decorator registry for telemetry
         try:
             from ...engine.decorator_registry import DecoratorRegistry
-            
-            DecoratorRegistry.update_agent_config({
-                "agent_id": service_id,
-                "name": app_info.get("title", "api-service")
-            })
-            
+
+            DecoratorRegistry.update_agent_config(
+                {"agent_id": service_id, "name": app_info.get("title", "api-service")}
+            )
+
             self.logger.debug(
                 f"🔧 Stored API service ID '{service_id}' in decorator registry for telemetry"
             )
@@ -247,56 +262,58 @@ class APIServerSetupStep(PipelineStep):
             self.logger.warning(
                 f"⚠️ Failed to store API service ID in decorator registry: {e}"
             )
-        
+
         self.logger.info(
             f"💓 API heartbeat config created: service_id='{service_id}', "
             f"interval={heartbeat_interval}s, standalone={standalone_mode}"
         )
-        
+
         return heartbeat_config
 
-    def _generate_api_service_id(self, app_info: Optional[Dict[str, Any]] = None) -> str:
+    def _generate_api_service_id(
+        self, app_info: Optional[Dict[str, Any]] = None
+    ) -> str:
         """
         Generate API service ID using same priority logic as MCP agents.
-        
+
         Priority order:
-        1. MCP_MESH_API_NAME environment variable 
+        1. MCP_MESH_API_NAME environment variable
         2. MCP_MESH_AGENT_NAME environment variable (fallback)
         3. Default to "api-{uuid8}"
-        
+
         Args:
             app_info: FastAPI app information (optional, not used in simplified logic)
-            
+
         Returns:
             Generated service ID with UUID suffix
         """
         import uuid
-        
+
         # Check for API-specific environment variable first
         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", 
+                "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  
+
+        # Generate UUID suffix
         uuid_suffix = str(uuid.uuid4())[:8]
-        
+
         # Apply naming logic
         if not cleaned_name:
             # No name provided: default to "api-{uuid8}"
@@ -307,39 +324,41 @@ class APIServerSetupStep(PipelineStep):
         else:
             # Name doesn't contain "api": use "{name}-api-{uuid8}"
             service_id = f"{cleaned_name}-api-{uuid_suffix}"
-        
+
         self.logger.debug(
             f"Generated API service ID: '{service_id}' from env name: '{api_name}'"
         )
-        
+
         return service_id
 
-    def _get_or_generate_api_service_id(self, app_info: Optional[Dict[str, Any]] = None) -> str:
+    def _get_or_generate_api_service_id(
+        self, app_info: Optional[Dict[str, Any]] = None
+    ) -> str:
         """
         Get existing service ID from decorator registry or generate a new one.
-        
-        Since both the fallback and API pipeline now use identical logic based on 
+
+        Since both the fallback and API pipeline now use identical logic based on
         environment variables, we can simply reuse any existing API service ID.
-        
+
         Args:
             app_info: FastAPI app information (optional, not used in simplified logic)
-            
+
         Returns:
             Service ID (existing or newly generated)
         """
         try:
             from ...engine.decorator_registry import DecoratorRegistry
-            
+
             # Get current cached config to see if we already have an ID
             current_config = DecoratorRegistry.get_resolved_agent_config()
             existing_id = current_config.get("agent_id", "")
-            
+
             # Check if existing ID looks like an API service ID
             is_api_format = (
-                existing_id.startswith("api-") or  # api-{uuid}
-                "-api-" in existing_id  # {name}-api-{uuid}
+                existing_id.startswith("api-")  # api-{uuid}
+                or "-api-" in existing_id  # {name}-api-{uuid}
             )
-            
+
             if existing_id and is_api_format:
                 # Reuse existing API service ID (fallback and pipeline use same logic now)
                 self.logger.info(
@@ -353,9 +372,11 @@ class APIServerSetupStep(PipelineStep):
                     f"🆕 Generated new API service ID: '{new_id}' (no existing API format ID found)"
                 )
                 return new_id
-                
+
         except Exception as e:
-            self.logger.warning(f"⚠️ Error checking existing service ID, generating new one: {e}")
+            self.logger.warning(
+                f"⚠️ Error checking existing service ID, generating new one: {e}"
+            )
             return self._generate_api_service_id(app_info)
 
     def _is_http_enabled(self) -> bool:
@@ -364,4 +385,4 @@ class APIServerSetupStep(PipelineStep):
             "MCP_MESH_HTTP_ENABLED",
             default=True,
             rule=ValidationRule.TRUTHY_RULE,
-        )
+        )

_mcp_mesh/pipeline/api_startup/fastapi_discovery.py

@@ -1,17 +1,17 @@
 import logging
 from typing import Any, Dict, List
 
-from ..shared import PipelineResult, PipelineStatus, PipelineStep
 from ...shared.server_discovery import ServerDiscoveryUtil
+from ..shared import PipelineResult, PipelineStatus, PipelineStep
 
 
 class FastAPIAppDiscoveryStep(PipelineStep):
     """
     Discovers existing FastAPI application instances in the user's code.
-    
+
     This step scans the Python runtime to find FastAPI applications that
     have been instantiated by the user, without modifying them in any way.
-    
+
     The goal is minimal intervention - we only discover what exists,
     we don't create or modify anything.
     """
@@ -32,7 +32,7 @@ class FastAPIAppDiscoveryStep(PipelineStep):
         try:
             # Get route decorators from context (from RouteCollectionStep)
             mesh_routes = context.get("mesh_routes", {})
-            
+
             if not mesh_routes:
                 result.status = PipelineStatus.SKIPPED
                 result.message = "No @mesh.route decorators found"
@@ -41,7 +41,7 @@ class FastAPIAppDiscoveryStep(PipelineStep):
 
             # Discover FastAPI instances using shared utility
             fastapi_apps = ServerDiscoveryUtil.discover_fastapi_instances()
-            
+
             if not fastapi_apps:
                 # This is not necessarily an error - user might be using FastAPI differently
                 result.status = PipelineStatus.FAILED
@@ -56,12 +56,12 @@ class FastAPIAppDiscoveryStep(PipelineStep):
 
             # Analyze which routes belong to which apps
             route_mapping = self._map_routes_to_apps(fastapi_apps, mesh_routes)
-            
+
             # Store discovery results in context
             result.add_context("fastapi_apps", fastapi_apps)
             result.add_context("route_mapping", route_mapping)
             result.add_context("discovered_app_count", len(fastapi_apps))
-            
+
             # Update result message
             route_count = sum(len(routes) for routes in route_mapping.values())
             result.message = (
@@ -90,50 +90,49 @@ class FastAPIAppDiscoveryStep(PipelineStep):
 
         return result
 
-
     def _map_routes_to_apps(
-        self, 
-        fastapi_apps: Dict[str, Dict[str, Any]], 
-        mesh_routes: Dict[str, Any]
+        self, fastapi_apps: Dict[str, Dict[str, Any]], mesh_routes: Dict[str, Any]
     ) -> Dict[str, Dict[str, Any]]:
         """
         Map @mesh.route decorated functions to their FastAPI applications.
-        
+
         Args:
             fastapi_apps: Discovered FastAPI applications
             mesh_routes: @mesh.route decorated functions from DecoratorRegistry
-            
+
         Returns:
             Dict mapping app_id -> {route_name -> route_info} for routes that have @mesh.route
         """
         route_mapping = {}
-        
+
         for app_id, app_info in fastapi_apps.items():
             app_routes = {}
-            
+
             for route_info in app_info["routes"]:
                 endpoint_name = route_info["endpoint_name"]
-                
+
                 # Check if this route handler has @mesh.route decorator
                 if endpoint_name in mesh_routes:
                     mesh_route_data = mesh_routes[endpoint_name]
-                    
+
                     # Combine FastAPI route info with @mesh.route metadata
                     combined_info = {
                         **route_info,  # FastAPI route info
                         "mesh_metadata": mesh_route_data.metadata,  # @mesh.route metadata
-                        "dependencies": mesh_route_data.metadata.get("dependencies", []),
+                        "dependencies": mesh_route_data.metadata.get(
+                            "dependencies", []
+                        ),
                         "mesh_decorator": mesh_route_data,  # Full DecoratedFunction object
                     }
-                    
+
                     app_routes[endpoint_name] = combined_info
-                    
+
                     self.logger.debug(
                         f"Mapped route '{endpoint_name}' to app '{app_info['title']}' "
                         f"with {len(combined_info['dependencies'])} dependencies"
                     )
-            
+
             if app_routes:
                 route_mapping[app_id] = app_routes
-                
-        return route_mapping
+
+        return route_mapping

_mcp_mesh/pipeline/api_startup/middleware_integration.py

@@ -2,7 +2,7 @@
 Tracing Middleware Integration for FastAPI Applications.
 
 This module provides automatic injection of tracing middleware into discovered
-FastAPI applications, ensuring unified telemetry collection across both MCP 
+FastAPI applications, ensuring unified telemetry collection across both MCP
 agents and FastAPI apps without requiring user intervention.
 """
 
@@ -17,10 +17,10 @@ logger = logging.getLogger(__name__)
 class TracingMiddlewareIntegrationStep(PipelineStep):
     """
     Programmatically adds tracing middleware to discovered FastAPI applications.
-    
-    This ensures consistent telemetry collection across both MCP agents 
+
+    This ensures consistent telemetry collection across both MCP agents
     (via HTTP wrapper middleware) and FastAPI apps (via injected middleware).
-    
+
     The middleware handles:
     - Extracting trace headers (X-Trace-ID, X-Parent-Span) from requests
     - Setting up trace context for the request lifecycle
@@ -36,36 +36,40 @@ class TracingMiddlewareIntegrationStep(PipelineStep):
 
     async def execute(self, context: dict[str, Any]) -> PipelineResult:
         """Add tracing middleware to discovered FastAPI applications."""
-        self.logger.debug("🔍 TRACING: Starting middleware integration for FastAPI apps...")
+        self.logger.debug(
+            "🔍 TRACING: Starting middleware integration for FastAPI apps..."
+        )
 
         result = PipelineResult(message="Tracing middleware integration completed")
 
         try:
             fastapi_apps = context.get("fastapi_apps", {})
-            
+
             if not fastapi_apps:
                 result.status = PipelineStatus.SKIPPED
-                result.message = "No FastAPI applications found for middleware injection"
+                result.message = (
+                    "No FastAPI applications found for middleware injection"
+                )
                 self.logger.debug("🔍 TRACING: No FastAPI apps to add middleware to")
                 return result
 
             # Add middleware to each discovered FastAPI app
             middleware_added = 0
             skipped_count = 0
-            
+
             for app_id, app_info in fastapi_apps.items():
                 fastapi_app = app_info["instance"]
                 app_title = app_info.get("title", "Unknown App")
-                
+
                 self.logger.debug(
                     f"🔍 TRACING: Checking app '{app_title}' ({app_id}) for middleware injection"
                 )
-                
+
                 # Check if middleware already exists to avoid duplicates
                 if not self._has_tracing_middleware(fastapi_app):
                     self._add_tracing_middleware(fastapi_app, app_title)
                     middleware_added += 1
-                    
+
                     self.logger.info(
                         f"🔍 TRACING: Added tracing middleware to FastAPI app '{app_title}'"
                     )
@@ -99,29 +103,32 @@ class TracingMiddlewareIntegrationStep(PipelineStep):
     def _has_tracing_middleware(self, app) -> bool:
         """
         Check if FastAPI app already has MCP Mesh tracing middleware.
-        
+
         Args:
             app: FastAPI application instance
-            
+
         Returns:
             True if tracing middleware already exists, False otherwise
         """
         try:
             # Check user_middleware stack for our specific middleware classes
-            if hasattr(app, 'user_middleware'):
+            if hasattr(app, "user_middleware"):
                 for middleware in app.user_middleware:
-                    if hasattr(middleware, 'cls'):
+                    if hasattr(middleware, "cls"):
                         middleware_name = middleware.cls.__name__
                         # Check for both old and new middleware names
-                        if middleware_name in ('MCPMeshTracingMiddleware', 'FastAPITracingMiddleware'):
+                        if middleware_name in (
+                            "MCPMeshTracingMiddleware",
+                            "FastAPITracingMiddleware",
+                        ):
                             self.logger.debug(
                                 f"🔍 TRACING: Found existing {middleware_name} in app"
                             )
                             return True
-                            
+
             self.logger.debug("🔍 TRACING: No existing tracing middleware found")
             return False
-            
+
         except Exception as e:
             # If we can't check middleware stack, assume it doesn't exist
             self.logger.debug(f"🔍 TRACING: Error checking middleware stack: {e}")
@@ -130,24 +137,25 @@ class TracingMiddlewareIntegrationStep(PipelineStep):
     def _add_tracing_middleware(self, app, app_title: str) -> None:
         """
         Add dedicated FastAPI tracing middleware to FastAPI app.
-        
+
         Args:
             app: FastAPI application instance
             app_title: Human-readable app title for logging
         """
         try:
-            from ....tracing.fastapi_tracing_middleware import FastAPITracingMiddleware
-            
+            from ....tracing.fastapi_tracing_middleware import \
+                FastAPITracingMiddleware
+
             # Add the dedicated FastAPI tracing middleware
             app.add_middleware(FastAPITracingMiddleware, logger_instance=self.logger)
-            
+
             self.logger.debug(
                 f"🔍 TRACING: Successfully added FastAPITracingMiddleware to '{app_title}'"
             )
-            
+
         except Exception as e:
             # Log error but don't fail the entire pipeline
             self.logger.error(
                 f"🔍 TRACING: Failed to add middleware to '{app_title}': {e}"
             )
-            raise  # Re-raise so pipeline can handle the error appropriately
+            raise  # Re-raise so pipeline can handle the error appropriately

_mcp_mesh/pipeline/api_startup/route_collection.py

@@ -37,9 +37,7 @@ class RouteCollectionStep(PipelineStep):
             # Update result message
             result.message = f"Collected {len(mesh_routes)} routes"
 
-            self.logger.info(
-                f"📦 Collected decorators: {len(mesh_routes)} @mesh.route"
-            )
+            self.logger.info(f"📦 Collected decorators: {len(mesh_routes)} @mesh.route")
 
             # Validate we have routes to process
             if len(mesh_routes) == 0:
@@ -53,4 +51,4 @@ class RouteCollectionStep(PipelineStep):
             result.add_error(str(e))
             self.logger.error(f"❌ Route collection failed: {e}")
 
-        return result
+        return result