mcp-mesh 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

_mcp_mesh/pipeline/api_startup/fastapi_discovery.py

@@ -0,0 +1,302 @@
+import gc
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+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.
+    """
+
+    def __init__(self):
+        super().__init__(
+            name="fastapi-discovery",
+            required=True,
+            description="Discover existing FastAPI application instances",
+        )
+
+    async def execute(self, context: dict[str, Any]) -> PipelineResult:
+        """Discover FastAPI applications."""
+        self.logger.debug("Discovering FastAPI applications...")
+
+        result = PipelineResult(message="FastAPI discovery completed")
+
+        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"
+                self.logger.info("⚠️ No @mesh.route decorators found to process")
+                return result
+
+            # Discover FastAPI instances
+            fastapi_apps = self._discover_fastapi_instances()
+            
+            if not fastapi_apps:
+                # This is not necessarily an error - user might be using FastAPI differently
+                result.status = PipelineStatus.FAILED
+                result.message = "No FastAPI applications found"
+                result.add_error("No FastAPI applications discovered in runtime")
+                self.logger.error(
+                    "❌ No FastAPI applications found. @mesh.route decorators require "
+                    "an existing FastAPI app instance. Please create a FastAPI app before "
+                    "using @mesh.route decorators."
+                )
+                return result
+
+            # 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 = (
+                f"Discovered {len(fastapi_apps)} FastAPI app(s) with "
+                f"{route_count} @mesh.route decorated handlers"
+            )
+
+            self.logger.info(
+                f"📦 FastAPI Discovery: {len(fastapi_apps)} app(s), "
+                f"{route_count} @mesh.route handlers, {len(mesh_routes)} total routes"
+            )
+
+            # Log details for debugging
+            for app_id, app_info in fastapi_apps.items():
+                app_title = app_info.get("title", "Unknown")
+                routes_in_app = len(route_mapping.get(app_id, {}))
+                self.logger.debug(
+                    f"  App '{app_title}' ({app_id}): {routes_in_app} @mesh.route handlers"
+                )
+
+        except Exception as e:
+            result.status = PipelineStatus.FAILED
+            result.message = f"FastAPI discovery failed: {e}"
+            result.add_error(str(e))
+            self.logger.error(f"❌ FastAPI discovery failed: {e}")
+
+        return result
+
+    def _discover_fastapi_instances(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Discover FastAPI application instances in the Python runtime.
+        
+        Uses intelligent deduplication to handle standard uvicorn patterns where
+        the same app might be imported multiple times (e.g., "module:app" pattern).
+        
+        Returns:
+            Dict mapping app_id -> app_info where app_info contains:
+            - 'instance': The FastAPI app instance
+            - 'title': App title from FastAPI
+            - 'routes': List of route information
+            - 'module': Module where app was found
+        """
+        fastapi_apps = {}
+        seen_apps = {}  # For deduplication: title -> app_info
+        
+        try:
+            # Import FastAPI here to avoid dependency if not used
+            from fastapi import FastAPI
+        except ImportError:
+            self.logger.warning("FastAPI not installed - cannot discover FastAPI apps")
+            return {}
+
+        # Scan garbage collector for FastAPI instances
+        candidate_apps = []
+        for obj in gc.get_objects():
+            if isinstance(obj, FastAPI):
+                candidate_apps.append(obj)
+
+        # Deduplicate apps with identical configurations
+        for obj in candidate_apps:
+            try:
+                title = getattr(obj, "title", "FastAPI App")
+                version = getattr(obj, "version", "unknown")
+                routes = self._extract_route_info(obj)
+                route_count = len(routes)
+                
+                # Create a signature for deduplication
+                app_signature = (title, version, route_count)
+                
+                # Check if we've seen an identical app
+                if app_signature in seen_apps:
+                    existing_app = seen_apps[app_signature]
+                    # Compare route details to ensure they're truly identical
+                    existing_routes = existing_app["routes"]
+                    
+                    if self._routes_are_identical(routes, existing_routes):
+                        self.logger.debug(
+                            f"Skipping duplicate FastAPI app: '{title}' (same title, version, and routes)"
+                        )
+                        continue  # Skip this duplicate
+                
+                # This is a unique app, add it
+                app_id = f"app_{id(obj)}"
+                app_info = {
+                    "instance": obj,
+                    "title": title,
+                    "version": version,
+                    "routes": routes,
+                    "module": self._get_app_module(obj),
+                    "object_id": id(obj),
+                    "router_routes_count": len(obj.router.routes) if hasattr(obj, 'router') else 0,
+                }
+                
+                fastapi_apps[app_id] = app_info
+                seen_apps[app_signature] = app_info
+                
+                self.logger.debug(
+                    f"Found FastAPI app: '{title}' (module: {app_info['module']}) with "
+                    f"{len(routes)} routes"
+                )
+                
+            except Exception as e:
+                self.logger.warning(f"Error analyzing FastAPI app: {e}")
+                continue
+
+        return fastapi_apps
+
+    def _routes_are_identical(self, routes1: List[Dict[str, Any]], routes2: List[Dict[str, Any]]) -> bool:
+        """
+        Compare two route lists to see if they're identical.
+        
+        Args:
+            routes1: First route list 
+            routes2: Second route list
+            
+        Returns:
+            True if routes are identical, False otherwise
+        """
+        if len(routes1) != len(routes2):
+            return False
+            
+        # Create comparable signatures for each route
+        def route_signature(route):
+            return (
+                tuple(sorted(route.get('methods', []))),  # Sort methods for consistent comparison
+                route.get('path', ''),
+                route.get('endpoint_name', '')
+            )
+        
+        # Sort routes by signature for consistent comparison
+        sig1 = sorted([route_signature(r) for r in routes1])
+        sig2 = sorted([route_signature(r) for r in routes2])
+        
+        return sig1 == sig2
+
+    def _extract_route_info(self, app) -> List[Dict[str, Any]]:
+        """
+        Extract route information from FastAPI app without modifying it.
+        
+        Args:
+            app: FastAPI application instance
+            
+        Returns:
+            List of route information dictionaries
+        """
+        routes = []
+        
+        try:
+            for route in app.router.routes:
+                if hasattr(route, 'endpoint') and hasattr(route, 'path'):
+                    route_info = {
+                        "path": route.path,
+                        "methods": list(route.methods) if hasattr(route, 'methods') else [],
+                        "endpoint": route.endpoint,
+                        "endpoint_name": getattr(route.endpoint, '__name__', 'unknown'),
+                        "has_mesh_route": hasattr(route.endpoint, '_mesh_route_metadata'),
+                    }
+                    routes.append(route_info)
+                    
+        except Exception as e:
+            self.logger.warning(f"Error extracting route info: {e}")
+            
+        return routes
+
+    def _get_app_module(self, app) -> Optional[str]:
+        """
+        Try to determine which module the FastAPI app belongs to.
+        
+        Args:
+            app: FastAPI application instance
+            
+        Returns:
+            Module name or None if unknown
+        """
+        try:
+            # Try to get module from the app's stack frame when it was created
+            # This is best-effort - may not always work
+            import inspect
+            
+            frame = inspect.currentframe()
+            while frame:
+                frame_globals = frame.f_globals
+                for name, obj in frame_globals.items():
+                    if obj is app:
+                        return frame_globals.get('__name__', 'unknown')
+                frame = frame.f_back
+                
+        except Exception:
+            pass
+            
+        return None
+
+    def _map_routes_to_apps(
+        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", []),
+                        "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

_mcp_mesh/pipeline/api_startup/route_collection.py

@@ -0,0 +1,56 @@
+import logging
+from typing import Any
+
+from ...engine.decorator_registry import DecoratorRegistry
+from ..shared import PipelineResult, PipelineStatus, PipelineStep
+
+
+class RouteCollectionStep(PipelineStep):
+    """
+    Collects all registered @mesh.route decorators from DecoratorRegistry.
+
+    This step reads the current state of route decorator registrations and
+    makes them available for subsequent processing steps.
+    """
+
+    def __init__(self):
+        super().__init__(
+            name="route-collection",
+            required=True,
+            description="Collect all registered @mesh.route decorators",
+        )
+
+    async def execute(self, context: dict[str, Any]) -> PipelineResult:
+        """Collect route decorators from registry."""
+        self.logger.debug("Collecting route decorators from DecoratorRegistry...")
+
+        result = PipelineResult(message="Route collection completed")
+
+        try:
+            # Get all registered route decorators
+            mesh_routes = DecoratorRegistry.get_all_by_type("mesh_route")
+
+            # Store in context for subsequent steps
+            result.add_context("mesh_routes", mesh_routes)
+            result.add_context("route_count", len(mesh_routes))
+
+            # Update result message
+            result.message = f"Collected {len(mesh_routes)} routes"
+
+            self.logger.info(
+                f"📦 Collected decorators: {len(mesh_routes)} @mesh.route"
+            )
+
+            # Validate we have routes to process
+            if len(mesh_routes) == 0:
+                result.status = PipelineStatus.SKIPPED
+                result.message = "No route decorators found to process"
+                self.logger.warning("⚠️ No route decorators found in registry")
+
+        except Exception as e:
+            result.status = PipelineStatus.FAILED
+            result.message = f"Failed to collect route decorators: {e}"
+            result.add_error(str(e))
+            self.logger.error(f"❌ Route collection failed: {e}")
+
+        return result

_mcp_mesh/pipeline/api_startup/route_integration.py

@@ -0,0 +1,318 @@
+import logging
+from typing import Any, Dict
+
+from ...engine.dependency_injector import get_global_injector
+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.
+    """
+
+    def __init__(self):
+        super().__init__(
+            name="route-integration",
+            required=True,
+            description="Apply dependency injection to @mesh.route decorated handlers",
+        )
+
+    async def execute(self, context: dict[str, Any]) -> PipelineResult:
+        """Apply dependency injection to route handlers."""
+        self.logger.debug("Applying dependency injection to route handlers...")
+
+        result = PipelineResult(message="Route integration completed")
+
+        try:
+            # 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"
+                self.logger.warning("⚠️ No @mesh.route handlers to integrate")
+                return result
+
+            # 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 "
+                    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"
+
+            self.logger.info(
+                f"✅ Route Integration: {total_integrated} handlers now have dependency injection"
+            )
+
+        except Exception as e:
+            result.status = PipelineStatus.FAILED
+            result.message = f"Route integration failed: {e}"
+            result.add_error(str(e))
+            self.logger.error(f"❌ Route integration failed: {e}")
+
+        return result
+
+    def _integrate_app_routes(
+        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,
+            "skipped_count": 0,
+            "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
+                )
+                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}"
+                )
+                integration_results["error_count"] += 1
+                integration_results["route_details"][route_name] = {
+                    "status": "error",
+                    "error": str(e)
+                }
+                
+        return integration_results
+
+    def _integrate_single_route(
+        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
+        """
+        endpoint_name = route_info["endpoint_name"]
+        original_handler = route_info["endpoint"]
+        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"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")
+            return {
+                "status": "skipped",
+                "reason": "no_dependencies",
+                "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'}"
+        )
+        
+        if is_already_wrapper:
+            self.logger.debug(
+                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"
+            )
+            wrapped_handler = existing_wrapper
+        else:
+            # Create dependency injection wrapper using existing engine
+            self.logger.debug(
+                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', {}
+                )
+                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}")
+                return {
+                    "status": "failed",
+                    "reason": f"wrapper_creation_failed: {e}",
+                    "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
+            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__.')]
+                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)
+                    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
+        
+        # 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"
+            )
+            return {
+                "status": "integrated",
+                "dependency_count": len(dependency_names),
+                "dependencies": dependency_names,
+                "original_handler": original_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"
+            }
+
+    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')):
+                    
+                    # Match by path and endpoint function
+                    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"
+            )
+            return False
+            
+        except Exception as e:
+            self.logger.error(f"❌ Error replacing route handler: {e}")
+            return False