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

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

@@ -41,7 +41,7 @@ class FastMCPServerDiscoveryStep(PipelineStep):
             server_info = []
             total_registered_functions = 0
 
-            for server_name, server_instance in discovered_servers.items():
+            for server_name, server_instance in list(discovered_servers.items()):
                 info = self._extract_server_info(server_name, server_instance)
                 server_info.append(info)
                 total_registered_functions += info.get("function_count", 0)
@@ -119,7 +119,7 @@ class FastMCPServerDiscoveryStep(PipelineStep):
                 "pkgutil",
             }
 
-            for module_name, module in sys.modules.items():
+            for module_name, module in list(sys.modules.items()):
                 if (
                     module
                     and not module_name.startswith("_")
@@ -166,7 +166,7 @@ class FastMCPServerDiscoveryStep(PipelineStep):
             module_globals = vars(module)
             # Only log if we find FastMCP instances to reduce noise
 
-            for var_name, var_value in module_globals.items():
+            for var_name, var_value in list(module_globals.items()):
                 if self._is_fastmcp_instance(var_value):
                     instance_key = f"{module_name}.{var_name}"
                     found[instance_key] = var_value
@@ -230,7 +230,7 @@ class FastMCPServerDiscoveryStep(PipelineStep):
                     info["function_count"] += len(tools)
 
                     self.logger.debug(f"Server '{server_name}' has {len(tools)} tools:")
-                    for tool_name, tool in tools.items():
+                    for tool_name, tool in list(tools.items()):
                         function_ptr = getattr(tool, "fn", None)
                         self.logger.debug(f"  - {tool_name}: {function_ptr}")
 

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

@@ -49,7 +49,7 @@ class HeartbeatLoopStep(PipelineStep):
             standalone_mode = self._get_standalone_mode()
 
             # Import heartbeat task function
-            from ..heartbeat import heartbeat_lifespan_task
+            from ..mcp_heartbeat import heartbeat_lifespan_task
 
             # Create heartbeat config - registry connection will be attempted in heartbeat pipeline
             heartbeat_config = {

_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/shared/sse_parser.py

@@ -0,0 +1,217 @@
+"""Server-Sent Events (SSE) parsing utilities for MCP responses."""
+
+import json
+import logging
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class SSEParser:
+    """Utility class for parsing Server-Sent Events responses from FastMCP servers.
+
+    Handles the common issue where large JSON responses get split across multiple
+    SSE 'data:' lines, which would cause JSON parsing failures if processed line-by-line.
+    """
+
+    @staticmethod
+    def parse_sse_response(
+        response_text: str, context: str = "unknown"
+    ) -> dict[str, Any]:
+        """
+        Parse SSE response text and extract JSON data.
+
+        Handles multi-line JSON responses by accumulating all 'data:' lines
+        before attempting to parse JSON.
+
+        Args:
+            response_text: Raw SSE response text
+            context: Context string for error logging
+
+        Returns:
+            Parsed JSON data as dictionary
+
+        Raises:
+            RuntimeError: If SSE response cannot be parsed
+        """
+        logger.debug(f"🔧 SSEParser.parse_sse_response called from {context}")
+        logger.debug(
+            f"🔧 Response text length: {len(response_text)}, starts with 'event:': {response_text.startswith('event:')}"
+        )
+        logger.debug(f"🔧 Response preview: {repr(response_text[:100])}...")
+
+        # Check if this is SSE format (can be malformed and not start with "event:")
+        is_sse_format = (
+            response_text.startswith("event:")
+            or "event: message" in response_text
+            or "data: " in response_text
+        )
+
+        if not is_sse_format:
+            # Not an SSE response, try parsing as plain JSON
+            logger.debug(f"🔧 {context}: Parsing as plain JSON (not SSE format)")
+            logger.debug(
+                f"🔧 {context}: Response preview: {repr(response_text[:200])}..."
+            )
+            try:
+                result = json.loads(response_text)
+                logger.debug(f"🔧 {context}: Plain JSON parsed successfully")
+                return result
+            except json.JSONDecodeError as e:
+                logger.error(f"🔧 {context}: Plain JSON parse failed: {e}")
+                logger.error(
+                    f"🔧 {context}: Invalid response content (first 500 chars): {repr(response_text[:500])}"
+                )
+                raise RuntimeError(f"Invalid JSON response in {context}: {e}")
+
+        # Parse SSE format: find first valid JSON in data lines
+        logger.debug(f"🔧 {context}: Parsing SSE format - looking for first valid JSON")
+        data_line_count = 0
+        first_valid_json = None
+
+        for line in response_text.split("\n"):
+            if line.startswith("data:"):
+                data_content = line[5:].strip()  # Remove 'data:' prefix and whitespace
+                if data_content:
+                    data_line_count += 1
+                    try:
+                        # Try to parse this line as JSON
+                        parsed_json = json.loads(data_content)
+                        if first_valid_json is None:
+                            first_valid_json = parsed_json
+                            logger.debug(f"🔧 {context}: Found first valid JSON in data line {data_line_count}")
+                    except json.JSONDecodeError:
+                        # Skip invalid JSON lines - this is expected behavior
+                        logger.debug(f"🔧 {context}: Skipping invalid JSON in data line {data_line_count}: {data_content[:50]}...")
+                        continue
+
+        logger.debug(
+            f"🔧 {context}: Processed {data_line_count} data lines"
+        )
+
+        # Return first valid JSON found
+        if first_valid_json is None:
+            logger.error(f"🔧 {context}: No valid JSON found in SSE response")
+            raise RuntimeError(f"Could not parse SSE response from FastMCP")
+
+        logger.debug(
+            f"🔧 {context}: SSE parsing successful! Result type: {type(first_valid_json)}"
+        )
+        return first_valid_json
+
+    @staticmethod
+    def parse_streaming_sse_chunk(chunk_data: str) -> Optional[dict[str, Any]]:
+        """
+        Parse a single streaming SSE chunk.
+
+        Used for processing individual chunks in streaming responses.
+
+        Args:
+            chunk_data: Single data line content (without 'data:' prefix)
+
+        Returns:
+            Parsed JSON if valid and complete, None if should be skipped
+        """
+        if not chunk_data.strip():
+            return None
+
+        # Quick validation for complete JSON structures
+        chunk_data = chunk_data.strip()
+
+        # Must be complete JSON structures
+        if (
+            (chunk_data.startswith("{") and not chunk_data.endswith("}"))
+            or (chunk_data.startswith("[") and not chunk_data.endswith("]"))
+            or (chunk_data.startswith('"') and not chunk_data.endswith('"'))
+        ):
+            # Incomplete JSON structure - should be accumulated elsewhere
+            return None
+
+        try:
+            return json.loads(chunk_data)
+        except json.JSONDecodeError:
+            # Invalid JSON - skip this chunk
+            return None
+
+
+class SSEStreamProcessor:
+    """Processor for streaming SSE responses with proper buffering."""
+
+    def __init__(self, context: str = "streaming"):
+        self.context = context
+        self.buffer = ""
+        self.logger = logger.getChild(f"sse_stream.{context}")
+
+    def process_chunk(self, chunk_bytes: bytes) -> list[dict[str, Any]]:
+        """
+        Process a chunk of bytes and return any complete JSON objects found.
+
+        Args:
+            chunk_bytes: Raw bytes from streaming response
+
+        Returns:
+            List of complete JSON objects found in this chunk
+        """
+        self.logger.debug(
+            f"🌊 SSEStreamProcessor.process_chunk called for {self.context}, chunk size: {len(chunk_bytes)}"
+        )
+
+        try:
+            chunk_text = chunk_bytes.decode("utf-8")
+            self.buffer += chunk_text
+            self.logger.debug(
+                f"🌊 {self.context}: Buffer size after chunk: {len(self.buffer)}"
+            )
+        except UnicodeDecodeError:
+            self.logger.warning(
+                f"🌊 {self.context}: Skipping chunk with unicode decode error"
+            )
+            return []
+
+        results = []
+        events_processed = 0
+
+        # Process complete SSE events (end with \n\n)
+        while True:
+            event_end = self.buffer.find("\n\n")
+            if event_end == -1:
+                break  # No complete event yet
+
+            event_block = self.buffer[:event_end]
+            self.buffer = self.buffer[event_end + 2 :]  # Remove processed event
+            events_processed += 1
+
+            # Extract data from SSE event
+            for line in event_block.split("\n"):
+                if line.startswith("data: "):
+                    data_str = line[6:].strip()  # Remove "data: " prefix
+                    if data_str:
+                        parsed = SSEParser.parse_streaming_sse_chunk(data_str)
+                        if parsed:
+                            results.append(parsed)
+
+        self.logger.debug(
+            f"🌊 {self.context}: Processed {events_processed} complete SSE events, yielding {len(results)} JSON objects"
+        )
+        return results
+
+    def finalize(self) -> list[dict[str, Any]]:
+        """
+        Process any remaining data in buffer.
+
+        Returns:
+            List of any final JSON objects found
+        """
+        results = []
+
+        if self.buffer.strip():
+            for line in self.buffer.split("\n"):
+                if line.startswith("data: "):
+                    data_str = line[6:].strip()
+                    if data_str:
+                        parsed = SSEParser.parse_streaming_sse_chunk(data_str)
+                        if parsed:
+                            results.append(parsed)
+
+        self.buffer = ""  # Clear buffer
+        return results

{mcp_mesh-0.4.1.dist-info → mcp_mesh-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.4.1
+Version: 0.5.0
 Summary: Kubernetes-native platform for distributed MCP applications
 Project-URL: Homepage, https://github.com/dhyansraj/mcp-mesh
 Project-URL: Documentation, https://github.com/dhyansraj/mcp-mesh/tree/main/docs