mcp-mesh 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

_mcp_mesh/pipeline/mcp_startup/fastapiserver_setup.py

@@ -54,7 +54,7 @@ class FastAPIServerSetupStep(PipelineStep):
 
             # Handle existing server case - mount FastMCP with proper lifespan integration
             if server_reuse and existing_server:
-                self.logger.info(
+                self.logger.debug(
                     "🔄 SERVER REUSE: Found existing server, will mount FastMCP with proper lifespan integration"
                 )
                 return await self._handle_existing_server(
@@ -103,7 +103,9 @@ class FastAPIServerSetupStep(PipelineStep):
             )
 
             # Add K8s health endpoints
-            self._add_k8s_endpoints(fastapi_app, agent_config, mcp_wrappers)
+            await self._add_k8s_endpoints(
+                fastapi_app, agent_config, mcp_wrappers, context
+            )
 
             # Integrate MCP wrappers into the main FastAPI app
             for server_key, wrapper_data in mcp_wrappers.items():
@@ -235,7 +237,7 @@ class FastAPIServerSetupStep(PipelineStep):
             import asyncio
             from contextlib import asynccontextmanager
 
-            from fastapi import FastAPI
+            from fastapi import FastAPI, Response
 
             agent_name = agent_config.get("name", "mcp-mesh-agent")
             agent_description = agent_config.get(
@@ -420,34 +422,113 @@ class FastAPIServerSetupStep(PipelineStep):
         except ImportError as e:
             raise Exception(f"FastAPI not available: {e}")
 
-    def _add_k8s_endpoints(
-        self, app: Any, agent_config: dict[str, Any], mcp_wrappers: dict[str, Any]
+    async def _add_k8s_endpoints(
+        self,
+        app: Any,
+        agent_config: dict[str, Any],
+        mcp_wrappers: dict[str, Any],
+        context: dict[str, Any],
     ) -> None:
-        """Add Kubernetes health and metrics endpoints."""
+        """
+        Set up health check result updates for K8s endpoints.
+
+        Note: The /health endpoint is already registered by immediate uvicorn.
+        We just need to update the result it returns via DecoratorRegistry.
+        """
+        from fastapi import Response
+
         agent_name = agent_config.get("name", "mcp-mesh-agent")
+        health_check_fn = agent_config.get("health_check")
+        health_check_ttl = agent_config.get("health_check_ttl", 15)
+
+        # Create a background task to update health check results periodically
+        async def update_health_result():
+            """Update health check result in DecoratorRegistry."""
+            if health_check_fn:
+                # Use health check cache if configured
+                from ...engine.decorator_registry import DecoratorRegistry
+                from ...shared.health_check_cache import get_health_status_with_cache
+
+                health_status = await get_health_status_with_cache(
+                    agent_id=agent_name,
+                    health_check_fn=health_check_fn,
+                    agent_config=agent_config,
+                    startup_context=context,
+                    ttl=health_check_ttl,
+                )
 
-        @app.get("/health")
-        @app.head("/health")
-        async def health():
-            """Basic health check endpoint for Kubernetes."""
-            return {
-                "status": "healthy",
-                "agent": agent_name,
-                "timestamp": self._get_timestamp(),
-            }
+                result = {
+                    "status": health_status.status.value,
+                    "agent": agent_name,
+                    "checks": health_status.checks,
+                    "errors": health_status.errors,
+                    "timestamp": health_status.timestamp.isoformat(),
+                }
+            else:
+                # No health check configured - return default healthy status
+                result = {
+                    "status": "healthy",
+                    "agent": agent_name,
+                    "timestamp": self._get_timestamp(),
+                }
+
+            # Store result for /health endpoint to use
+            from ...engine.decorator_registry import DecoratorRegistry
+
+            DecoratorRegistry.store_health_check_result(result)
+
+        # Run once immediately to populate initial result
+        # We're already in an async context (called from execute()), so just await it
+
+        await update_health_result()
+
+        # Note: /health endpoint is already registered by immediate uvicorn
+        # It will call DecoratorRegistry.get_health_check_result() to get this data
 
         @app.get("/ready")
         @app.head("/ready")
-        async def ready():
-            """Readiness check for Kubernetes."""
-            # Simple readiness check - always ready for now
-            # TODO: Update this to check MCP wrapper status
-            return {
-                "ready": True,
-                "agent": agent_name,
-                "mcp_wrappers": len(mcp_wrappers),
-                "timestamp": self._get_timestamp(),
-            }
+        async def ready(response: Response):
+            """
+            Readiness check for Kubernetes.
+
+            Returns 200 when the service is ready to serve traffic.
+            Returns 503 when unhealthy - K8s will remove pod from service endpoints.
+            """
+            # Get health check result if available
+            from ...engine.decorator_registry import DecoratorRegistry
+
+            custom_health = DecoratorRegistry.get_health_check_result()
+
+            if custom_health:
+                status = custom_health.get("status", "starting")
+                if status == "healthy":
+                    response.status_code = 200
+                    return {
+                        "ready": True,
+                        "agent": agent_name,
+                        "status": status,
+                        "mcp_wrappers": len(mcp_wrappers),
+                        "timestamp": self._get_timestamp(),
+                    }
+                else:
+                    # Not ready to serve traffic
+                    response.status_code = 503
+                    return {
+                        "ready": False,
+                        "agent": agent_name,
+                        "status": status,
+                        "reason": f"Service is {status}",
+                        "errors": custom_health.get("errors", []),
+                    }
+            else:
+                # No custom health check - assume ready
+                response.status_code = 200
+                return {
+                    "ready": True,
+                    "agent": agent_name,
+                    "mcp_wrappers": len(mcp_wrappers),
+                    "timestamp": self._get_timestamp(),
+                }
 
         @app.get("/livez")
         @app.head("/livez")
@@ -771,7 +852,7 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
         mount FastMCP endpoints on it instead of starting a new server.
         """
         try:
-            self.logger.info("🔄 SERVER REUSE: Mounting FastMCP on existing server")
+            self.logger.debug("🔄 SERVER REUSE: Mounting FastMCP on existing server")
 
             # Get the existing minimal FastAPI app that's already running
             existing_app = None
@@ -792,7 +873,7 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
             if not existing_app:
                 raise ValueError("No existing FastAPI app found for server reuse")
 
-            self.logger.info(
+            self.logger.debug(
                 f"🔄 SERVER REUSE: Using existing FastAPI app '{existing_app.title}' for FastMCP mounting"
             )
 
@@ -805,7 +886,7 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
             mcp_wrappers = {}
             if fastmcp_servers:
                 if fastmcp_lifespan and fastmcp_http_app:
-                    self.logger.info(
+                    self.logger.debug(
                         "✅ SERVER REUSE: FastMCP lifespan already integrated, mounting same HTTP app"
                     )
 
@@ -815,7 +896,7 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
                             # Mount the same FastMCP HTTP app that was used for lifespan integration
                             # This ensures the session manager is shared between lifespan and routes
                             existing_app.mount("", fastmcp_http_app)
-                            self.logger.info(
+                            self.logger.debug(
                                 f"🔌 SERVER REUSE: Mounted FastMCP server '{server_key}' using stored HTTP app (lifespan already integrated)"
                             )
 
@@ -833,7 +914,7 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
                                 f"Failed to mount server '{server_key}': {e}"
                             )
                 else:
-                    self.logger.info(
+                    self.logger.debug(
                         "🔄 SERVER REUSE: No FastMCP lifespan integrated, using HttpMcpWrapper"
                     )
 
@@ -850,7 +931,7 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
                             if mcp_wrapper._mcp_app:
                                 # Mount at root since FastMCP creates its own /mcp routes internally
                                 existing_app.mount("", mcp_wrapper._mcp_app)
-                                self.logger.info(
+                                self.logger.debug(
                                     f"🔌 SERVER REUSE: Mounted FastMCP server '{server_key}' via HttpMcpWrapper at root (provides /mcp routes)"
                                 )
 
@@ -868,10 +949,12 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
                             )
 
                 # Add K8s health endpoints to existing app (if not already present)
-                self._add_k8s_endpoints(existing_app, agent_config, mcp_wrappers)
+                await self._add_k8s_endpoints(
+                    existing_app, agent_config, mcp_wrappers, context
+                )
 
                 # FastMCP servers are already mounted directly - no additional integration needed
-                self.logger.info(
+                self.logger.debug(
                     "🔌 SERVER REUSE: All FastMCP servers mounted successfully"
                 )
 
@@ -889,7 +972,7 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
             self._current_context["mcp_wrappers"] = mcp_wrappers
 
             # FastMCP is now mounted directly - no server replacement needed
-            self.logger.info(
+            self.logger.debug(
                 "🔄 SERVER REUSE: FastMCP routes mounted to existing app successfully"
             )
 
@@ -911,7 +994,7 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
             )
 
             result.message = f"FastAPI app mounted on existing server {bind_host}:{bind_port} (external: {external_endpoint})"
-            self.logger.info(
+            self.logger.debug(
                 f"✅ SERVER REUSE: FastMCP mounted on existing server with {len(mcp_wrappers)} MCP wrappers"
             )
 

_mcp_mesh/pipeline/mcp_startup/fastmcpserver_discovery.py

@@ -46,7 +46,7 @@ class FastMCPServerDiscoveryStep(PipelineStep):
                 server_info.append(info)
                 total_registered_functions += info.get("function_count", 0)
 
-                self.logger.info(
+                self.logger.debug(
                     f"📡 Discovered FastMCP server '{server_name}': "
                     f"{info.get('function_count', 0)} functions"
                 )

_mcp_mesh/pipeline/mcp_startup/heartbeat_preparation.py

@@ -117,8 +117,9 @@ class HeartbeatPreparationStep(PipelineStep):
 
             # Check if this function has @mesh.llm decorator (Phase 3)
             llm_filter_data = None
+            llm_provider_data = None
             llm_agents = DecoratorRegistry.get_mesh_llm_agents()
-            self.logger.info(
+            self.logger.debug(
                 f"🤖 Checking for LLM filter: function={func_name}, total_llm_agents_registered={len(llm_agents)}"
             )
 
@@ -147,21 +148,65 @@ class HeartbeatPreparationStep(PipelineStep):
                         "filter": normalized_filter,
                         "filter_mode": filter_mode,
                     }
-                    self.logger.info(
+                    self.logger.debug(
                         f"🤖 LLM filter found for {func_name}: {len(normalized_filter)} filters, mode={filter_mode}, raw_filter={raw_filter}"
                     )
+
+                    # Check if provider is a dict (mesh delegation mode - v0.6.1)
+                    # If so, add it as llm_provider field (NOT in dependencies array)
+                    provider = llm_metadata.config.get("provider")
+                    if isinstance(provider, dict):
+                        self.logger.debug(
+                            f"🔌 LLM provider is dict (mesh delegation) for {func_name}: {provider}"
+                        )
+                        # Set llm_provider field (separate from dependencies)
+                        # Registry will resolve this to an actual provider agent
+                        llm_provider_data = {
+                            "capability": provider.get("capability", "llm"),
+                            "tags": provider.get("tags", []),
+                            "version": provider.get("version", ""),
+                            "namespace": provider.get("namespace", "default"),
+                        }
+                        self.logger.debug(
+                            f"✅ LLM provider spec prepared for {func_name}: {llm_provider_data}"
+                        )
+
                     break
 
             # Build tool registration data
+            self.logger.debug(
+                f"Building tool_data for {func_name}, dependencies={dependencies}"
+            )
+            processed_deps = self._process_dependencies(dependencies)
+            self.logger.debug(
+                f"Processed dependencies for {func_name}: {processed_deps}"
+            )
+
+            # Extract kwargs (any extra fields not in standard set)
+            standard_fields = {
+                "capability",
+                "tags",
+                "version",
+                "description",
+                "dependencies",
+            }
+            kwargs_data = {
+                k: v for k, v in metadata.items() if k not in standard_fields
+            }
+
             tool_data = {
                 "function_name": func_name,
                 "capability": metadata.get("capability"),
                 "tags": metadata.get("tags", []),
                 "version": metadata.get("version", "1.0.0"),
                 "description": metadata.get("description"),
-                "dependencies": self._process_dependencies(dependencies),
+                "dependencies": processed_deps,
                 "input_schema": input_schema,  # Add inputSchema for LLM integration (Phase 2)
                 "llm_filter": llm_filter_data,  # Add LLM filter for LLM integration (Phase 3)
+                "llm_provider": llm_provider_data,  # Add LLM provider for mesh delegation (v0.6.1)
+                "kwargs": (
+                    kwargs_data if kwargs_data else None
+                ),  # Add kwargs for vendor and other metadata
             }
 
             # Add debug pointer information only if debug flag is enabled

_mcp_mesh/pipeline/mcp_startup/server_discovery.py

@@ -8,14 +8,14 @@ in @mesh.agent decorators to prevent Python interpreter shutdown.
 import logging
 from typing import Any, Dict, Optional
 
-from ..shared import PipelineResult, PipelineStatus, PipelineStep
 from ...shared.server_discovery import ServerDiscoveryUtil
+from ..shared import PipelineResult, PipelineStatus, PipelineStep
 
 
 class ServerDiscoveryStep(PipelineStep):
     """
     Discovers existing uvicorn servers that may be running.
-    
+
     This step checks if there's already a uvicorn server running on the target port,
     which could happen when @mesh.agent(auto_run=True) starts an immediate uvicorn
     server to prevent Python interpreter shutdown.
@@ -39,77 +39,100 @@ class ServerDiscoveryStep(PipelineStep):
             agent_config = context.get("agent_config", {})
             target_port = agent_config.get("http_port", 8080)
             target_host = agent_config.get("http_host", "0.0.0.0")
-            
-            self.logger.info(f"🔍 DISCOVERY: Looking for immediate uvicorn server from DecoratorRegistry")
+
+            self.logger.debug(
+                "🔍 DISCOVERY: Looking for immediate uvicorn server from DecoratorRegistry"
+            )
 
             # Check DecoratorRegistry for immediate uvicorn server (much more reliable)
             from ...engine.decorator_registry import DecoratorRegistry
+
             existing_server = DecoratorRegistry.get_immediate_uvicorn_server()
 
             # Debug: Show what we found
             if existing_server:
                 server_status = existing_server.get("status", "unknown")
                 server_type = existing_server.get("type", "unknown")
-                self.logger.info(f"🔍 DISCOVERY: Found server - status='{server_status}', type='{server_type}'")
+                self.logger.debug(
+                    f"🔍 DISCOVERY: Found server - status='{server_status}', type='{server_type}'"
+                )
             else:
-                self.logger.info(f"🔍 DISCOVERY: No immediate uvicorn server found in registry")
-            
+                self.logger.debug(
+                    "🔍 DISCOVERY: No immediate uvicorn server found in registry"
+                )
+
             if existing_server:
                 # Found existing immediate uvicorn server
-                server_host = existing_server.get('host', 'unknown')
-                server_port = existing_server.get('port', 0)
-                
+                server_host = existing_server.get("host", "unknown")
+                server_port = existing_server.get("port", 0)
+
                 result.add_context("existing_server", existing_server)
                 result.add_context("server_reuse", True)
-                
+
                 # Get the FastAPI app directly from server info
-                existing_app = existing_server.get('app')
+                existing_app = existing_server.get("app")
                 if existing_app:
                     app_info = {
-                        'instance': existing_app,
-                        'title': getattr(existing_app, 'title', 'MCP Mesh Agent (Starting)'),
-                        'version': getattr(existing_app, 'version', 'unknown'),
-                        'object_id': id(existing_app),
-                        'type': 'immediate_uvicorn'
+                        "instance": existing_app,
+                        "title": getattr(
+                            existing_app, "title", "MCP Mesh Agent (Starting)"
+                        ),
+                        "version": getattr(existing_app, "version", "unknown"),
+                        "object_id": id(existing_app),
+                        "type": "immediate_uvicorn",
                     }
                     result.add_context("existing_fastapi_app", app_info)
                     result.message = (
                         f"Found immediate uvicorn server on {server_host}:{server_port} "
                         f"with FastAPI app '{app_info.get('title', 'Unknown')}'"
                     )
-                    self.logger.info(
+                    self.logger.debug(
                         f"✅ DISCOVERY: Found immediate uvicorn server on {server_host}:{server_port} "
                         f"with FastAPI app '{app_info.get('title', 'Unknown')}'"
                     )
                 else:
                     result.message = f"Found immediate uvicorn server on {server_host}:{server_port} (no FastAPI app reference)"
-                    self.logger.warning(f"⚠️ DISCOVERY: Found immediate uvicorn server but no FastAPI app reference")
-                
+                    self.logger.warning(
+                        "⚠️ DISCOVERY: Found immediate uvicorn server but no FastAPI app reference"
+                    )
+
             else:
                 # No existing server found
                 result.add_context("existing_server", None)
                 result.add_context("server_reuse", False)
-                result.message = f"No immediate uvicorn server found in DecoratorRegistry"
-                self.logger.info(f"🔍 DISCOVERY: No immediate uvicorn server found - pipeline will start new server")
+                result.message = (
+                    "No immediate uvicorn server found in DecoratorRegistry"
+                )
+                self.logger.info(
+                    "🔍 DISCOVERY: No immediate uvicorn server found - pipeline will start new server"
+                )
 
             # Only discover FastAPI apps if no immediate uvicorn server was found
             if not existing_server:
-                self.logger.debug("🔍 DISCOVERY: No immediate uvicorn server found, discovering FastAPI apps via garbage collection")
+                self.logger.debug(
+                    "🔍 DISCOVERY: No immediate uvicorn server found, discovering FastAPI apps via garbage collection"
+                )
                 fastapi_apps = ServerDiscoveryUtil.discover_fastapi_instances()
                 result.add_context("discovered_fastapi_apps", fastapi_apps)
-                
+
                 if fastapi_apps:
                     app_count = len(fastapi_apps)
                     result.message += f" | Discovered {app_count} FastAPI app(s)"
-                    self.logger.info(f"📦 DISCOVERY: Discovered {app_count} FastAPI application(s) for potential mounting")
-                    
+                    self.logger.info(
+                        f"📦 DISCOVERY: Discovered {app_count} FastAPI application(s) for potential mounting"
+                    )
+
                     # Log details about discovered apps
                     for app_id, app_info in fastapi_apps.items():
                         app_title = app_info.get("title", "Unknown")
                         route_count = len(app_info.get("routes", []))
-                        self.logger.debug(f"  📦 App '{app_title}' ({app_id}): {route_count} routes")
+                        self.logger.debug(
+                            f"  📦 App '{app_title}' ({app_id}): {route_count} routes"
+                        )
             else:
-                self.logger.debug("🔍 DISCOVERY: Using FastAPI app from immediate uvicorn server, skipping garbage collection discovery")
+                self.logger.debug(
+                    "🔍 DISCOVERY: Using FastAPI app from immediate uvicorn server, skipping garbage collection discovery"
+                )
 
         except Exception as e:
             result.status = PipelineStatus.FAILED
@@ -119,46 +142,52 @@ class ServerDiscoveryStep(PipelineStep):
 
         return result
 
-    def _find_associated_fastapi_app(self, server_info: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    def _find_associated_fastapi_app(
+        self, server_info: dict[str, Any]
+    ) -> Optional[dict[str, Any]]:
         """
         Try to find the FastAPI app associated with the existing server.
-        
+
         Args:
             server_info: Server information from discovery
-            
+
         Returns:
             FastAPI app info if found, None otherwise
         """
         try:
             # Check if server info already has an app
-            if 'app' in server_info:
-                app = server_info['app']
+            if "app" in server_info:
+                app = server_info["app"]
                 return {
-                    'instance': app,
-                    'title': getattr(app, 'title', 'Unknown'),
-                    'version': getattr(app, 'version', 'unknown'),
-                    'routes': ServerDiscoveryUtil._extract_route_info(app),
-                    'object_id': id(app),
+                    "instance": app,
+                    "title": getattr(app, "title", "Unknown"),
+                    "version": getattr(app, "version", "unknown"),
+                    "routes": ServerDiscoveryUtil._extract_route_info(app),
+                    "object_id": id(app),
                 }
-            
+
             # If not, discover all FastAPI apps and try to match
             fastapi_apps = ServerDiscoveryUtil.discover_fastapi_instances()
-            
+
             # For immediate uvicorn servers, look for apps with specific titles
             for app_id, app_info in fastapi_apps.items():
-                app_title = app_info.get('title', '')
-                if 'MCP Mesh Agent' in app_title and 'Starting' in app_title:
+                app_title = app_info.get("title", "")
+                if "MCP Mesh Agent" in app_title and "Starting" in app_title:
                     # This looks like our immediate uvicorn app
-                    self.logger.debug(f"🔍 DISCOVERY: Found immediate uvicorn FastAPI app: {app_title}")
+                    self.logger.debug(
+                        f"🔍 DISCOVERY: Found immediate uvicorn FastAPI app: {app_title}"
+                    )
                     return app_info
-            
+
             # If no immediate uvicorn app found, return the first available app
             if fastapi_apps:
                 first_app = next(iter(fastapi_apps.values()))
-                self.logger.debug(f"🔍 DISCOVERY: Using first available FastAPI app: {first_app.get('title', 'Unknown')}")
+                self.logger.debug(
+                    f"🔍 DISCOVERY: Using first available FastAPI app: {first_app.get('title', 'Unknown')}"
+                )
                 return first_app
-                
+
         except Exception as e:
             self.logger.warning(f"Error finding associated FastAPI app: {e}")
-        
-        return None
+
+        return None

_mcp_mesh/pipeline/mcp_startup/startup_orchestrator.py

@@ -228,7 +228,7 @@ class DebounceCoordinator:
                                     fastapi_app, binding_config
                                 )
                         elif server_status == "running":
-                            self.logger.info(
+                            self.logger.debug(
                                 "🔄 RUNNING SERVER: Server already running with proper lifecycle, pipeline skipping uvicorn.run()"
                             )
                             self.logger.info(
@@ -493,7 +493,7 @@ class MeshOrchestrator:
 
         This replaces the background polling with explicit execution.
         """
-        self.logger.info(f"🚀 Starting single pipeline execution: {self.name}")
+        self.logger.debug(f"🚀 Starting single pipeline execution: {self.name}")
 
         result = await self.pipeline.execute()