mcp-mesh 0.7.12__py3-none-any.whl → 0.7.13__py3-none-any.whl

_mcp_mesh/pipeline/api_heartbeat/api_heartbeat_pipeline.py

@@ -1,8 +1,8 @@
 """
 API heartbeat pipeline for FastAPI service health monitoring.
 
-Provides structured execution of API service heartbeat operations with proper 
-error handling and logging. Runs periodically to maintain registry communication 
+Provides structured execution of API service heartbeat operations with proper
+error handling and logging. Runs periodically to maintain registry communication
 and service health status for FastAPI applications using @mesh.route decorators.
 """
 
@@ -12,11 +12,11 @@ from typing import Any
 from ...shared.fast_heartbeat_status import FastHeartbeatStatus, FastHeartbeatStatusUtil
 from ..shared.mesh_pipeline import MeshPipeline
 from ..shared.pipeline_types import PipelineStatus
-from .api_registry_connection import APIRegistryConnectionStep
-from .api_health_check import APIHealthCheckStep  
+from .api_dependency_resolution import APIDependencyResolutionStep
 from .api_fast_heartbeat_check import APIFastHeartbeatStep
+from .api_health_check import APIHealthCheckStep
 from .api_heartbeat_send import APIHeartbeatSendStep
-from .api_dependency_resolution import APIDependencyResolutionStep
+from .api_registry_connection import APIRegistryConnectionStep
 
 logger = logging.getLogger(__name__)
 
@@ -50,23 +50,21 @@ class APIHeartbeatPipeline(MeshPipeline):
         """Setup the API heartbeat pipeline steps with fast optimization."""
         # API heartbeat steps with fast optimization pattern
         steps = [
-            APIRegistryConnectionStep(),    # Prepare registry communication
-            APIHealthCheckStep(),           # Check FastAPI app health status
-            APIFastHeartbeatStep(),         # Fast heartbeat check (HEAD request)
-            APIHeartbeatSendStep(),         # Conditional heartbeat send (POST request)
+            APIRegistryConnectionStep(),  # Prepare registry communication
+            APIHealthCheckStep(),  # Check FastAPI app health status
+            APIFastHeartbeatStep(),  # Fast heartbeat check (HEAD request)
+            APIHeartbeatSendStep(),  # Conditional heartbeat send (POST request)
             APIDependencyResolutionStep(),  # Conditional dependency resolution
         ]
 
         self.add_steps(steps)
-        self.logger.debug(f"API heartbeat pipeline configured with {len(steps)} steps")
-        
+        self.logger.trace(f"API heartbeat pipeline configured with {len(steps)} steps")
+
         # Log the pipeline strategy
         self.logger.info(
-            f"🌐 API Heartbeat Pipeline initialized: fast optimization for FastAPI apps"
-        )
-        self.logger.debug(
-            f"📋 Pipeline steps: {[step.name for step in steps]}"
+            "🌐 API Heartbeat Pipeline initialized: fast optimization for FastAPI apps"
         )
+        self.logger.trace(f"📋 Pipeline steps: {[step.name for step in steps]}")
 
     async def execute_api_heartbeat_cycle(
         self, heartbeat_context: dict[str, Any]
@@ -75,13 +73,13 @@ class APIHeartbeatPipeline(MeshPipeline):
         Execute a complete API heartbeat cycle with fast optimization and enhanced error handling.
 
         Args:
-            heartbeat_context: Context containing registry_wrapper, service_id, 
+            heartbeat_context: Context containing registry_wrapper, service_id,
                               health_status, fastapi_app, etc.
 
         Returns:
             PipelineResult with execution status and any context updates
         """
-        self.logger.debug("Starting API heartbeat pipeline execution")
+        self.logger.trace("Starting API heartbeat pipeline execution")
 
         # Initialize pipeline context with heartbeat-specific data
         self.context.clear()
@@ -92,7 +90,7 @@ class APIHeartbeatPipeline(MeshPipeline):
             result = await self._execute_with_conditional_logic()
 
             if result.is_success():
-                self.logger.debug("✅ API heartbeat pipeline completed successfully")
+                self.logger.trace("✅ API heartbeat pipeline completed successfully")
             elif result.status == PipelineStatus.PARTIAL:
                 self.logger.warning(
                     f"⚠️ API heartbeat pipeline completed partially: {result.message}"
@@ -113,7 +111,7 @@ class APIHeartbeatPipeline(MeshPipeline):
         except Exception as e:
             # Log detailed error information for debugging
             import traceback
-            
+
             self.logger.error(
                 f"❌ API heartbeat pipeline failed with exception: {e}\n"
                 f"Context keys: {list(self.context.keys())}\n"
@@ -122,7 +120,7 @@ class APIHeartbeatPipeline(MeshPipeline):
 
             # Create failure result with detailed context
             from ..shared.pipeline_types import PipelineResult
-            
+
             failure_result = PipelineResult(
                 status=PipelineStatus.FAILED,
                 message=f"API heartbeat pipeline exception: {str(e)[:200]}...",
@@ -138,7 +136,7 @@ class APIHeartbeatPipeline(MeshPipeline):
 
         Always executes:
         - APIRegistryConnectionStep
-        - APIHealthCheckStep  
+        - APIHealthCheckStep
         - APIFastHeartbeatStep
 
         Conditionally executes based on fast heartbeat status:
@@ -150,7 +148,7 @@ class APIHeartbeatPipeline(MeshPipeline):
             PipelineResult with execution status and context
         """
         from ..shared.pipeline_types import PipelineResult
-        
+
         overall_result = PipelineResult(
             message="API heartbeat pipeline execution completed"
         )
@@ -170,7 +168,7 @@ class APIHeartbeatPipeline(MeshPipeline):
 
             # Execute mandatory steps
             for step in mandatory_steps:
-                self.logger.debug(f"Executing mandatory step: {step.name}")
+                self.logger.trace(f"Executing mandatory step: {step.name}")
 
                 step_result = await step.execute(self.context)
                 executed_steps.append(step.name)
@@ -226,7 +224,9 @@ class APIHeartbeatPipeline(MeshPipeline):
                 # TOPOLOGY_CHANGED, AGENT_UNKNOWN - execute full pipeline
                 should_execute_remaining = True
                 reason = "changes detected or re-registration needed"
-                self.logger.info(f"🔄 API heartbeat: Executing remaining steps: {reason}")
+                self.logger.info(
+                    f"🔄 API heartbeat: Executing remaining steps: {reason}"
+                )
             else:
                 # Unknown status - fallback to full execution
                 self.logger.warning(
@@ -238,7 +238,7 @@ class APIHeartbeatPipeline(MeshPipeline):
             # Execute or skip conditional steps based on decision
             if should_execute_remaining:
                 for step in conditional_steps:
-                    self.logger.debug(f"Executing conditional step: {step.name}")
+                    self.logger.trace(f"Executing conditional step: {step.name}")
 
                     step_result = await step.execute(self.context)
                     executed_steps.append(step.name)
@@ -269,7 +269,7 @@ class APIHeartbeatPipeline(MeshPipeline):
                 # Mark skipped steps
                 for step in conditional_steps:
                     skipped_steps.append(step.name)
-                
+
                 # For skipped heartbeat due to NO_CHANGES, set success context
                 if fast_heartbeat_status == FastHeartbeatStatus.NO_CHANGES:
                     overall_result.add_context("heartbeat_success", True)
@@ -300,10 +300,12 @@ class APIHeartbeatPipeline(MeshPipeline):
         except Exception as e:
             # Handle unexpected exceptions
             overall_result.status = PipelineStatus.FAILED
-            overall_result.message = f"API pipeline execution failed with exception: {e}"
+            overall_result.message = (
+                f"API pipeline execution failed with exception: {e}"
+            )
             overall_result.add_error(str(e))
             for key, value in self.context.items():
                 overall_result.add_context(key, value)
 
             self.logger.error(f"❌ API conditional pipeline execution failed: {e}")
-            return overall_result
+            return overall_result

_mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py

@@ -34,7 +34,7 @@ class DependencyResolutionStep(PipelineStep):
 
     async def execute(self, context: dict[str, Any]) -> PipelineResult:
         """Process dependency resolution with hash-based change detection."""
-        self.logger.debug("Processing dependency resolution...")
+        self.logger.trace("Processing dependency resolution...")
 
         result = PipelineResult(message="Dependency resolution processed")
 
@@ -68,7 +68,7 @@ class DependencyResolutionStep(PipelineStep):
             result.add_context("dependencies_resolved", dependencies_resolved)
 
             result.message = "Dependency resolution completed (efficient hash-based)"
-            self.logger.debug(
+            self.logger.trace(
                 "🔗 Dependency resolution step completed using hash-based change detection"
             )
 
@@ -147,7 +147,7 @@ class DependencyResolutionStep(PipelineStep):
             if not heartbeat_response:
                 # No response from registry (connection error, timeout, 5xx)
                 # → Skip entirely for resilience (keep existing dependencies)
-                self.logger.debug(
+                self.logger.trace(
                     "No heartbeat response - skipping rewiring for resilience"
                 )
                 return
@@ -164,7 +164,7 @@ class DependencyResolutionStep(PipelineStep):
             # Compare with previous state (use global variable)
             global _last_dependency_hash
             if current_hash == _last_dependency_hash:
-                self.logger.debug(
+                self.logger.trace(
                     f"🔄 Dependency state unchanged (hash: {current_hash}), skipping rewiring"
                 )
                 return
@@ -255,29 +255,27 @@ class DependencyResolutionStep(PipelineStep):
                         # Get current agent ID for self-dependency detection
                         import os
 
-                        from ...engine.self_dependency_proxy import \
-                            SelfDependencyProxy
+                        from ...engine.self_dependency_proxy import SelfDependencyProxy
 
                         # Get current agent ID from DecoratorRegistry (single source of truth)
                         current_agent_id = None
                         try:
-                            from ...engine.decorator_registry import \
-                                DecoratorRegistry
+                            from ...engine.decorator_registry import DecoratorRegistry
 
                             config = DecoratorRegistry.get_resolved_agent_config()
                             current_agent_id = config["agent_id"]
-                            self.logger.debug(
+                            self.logger.trace(
                                 f"🔍 Current agent ID from DecoratorRegistry: '{current_agent_id}'"
                             )
                         except Exception as e:
                             # Fallback to environment variable
                             current_agent_id = os.getenv("MCP_MESH_AGENT_ID")
-                            self.logger.debug(
+                            self.logger.trace(
                                 f"🔍 Current agent ID from environment: '{current_agent_id}' (fallback due to: {e})"
                             )
 
                         target_agent_id = dep_info.get("agent_id")
-                        self.logger.debug(
+                        self.logger.trace(
                             f"🔍 Target agent ID from registry: '{target_agent_id}'"
                         )
 
@@ -288,7 +286,7 @@ class DependencyResolutionStep(PipelineStep):
                             and current_agent_id == target_agent_id
                         )
 
-                        self.logger.debug(
+                        self.logger.trace(
                             f"🔍 Self-dependency check for '{capability}': "
                             f"current='{current_agent_id}' vs target='{target_agent_id}' "
                             f"→ {'SELF' if is_self_dependency else 'CROSS'}-dependency"
@@ -301,7 +299,7 @@ class DependencyResolutionStep(PipelineStep):
                             wrapper_func = None
                             if dep_function_name in mesh_tools:
                                 wrapper_func = mesh_tools[dep_function_name].function
-                                self.logger.debug(
+                                self.logger.trace(
                                     f"🔍 Found wrapper for '{dep_function_name}' in DecoratorRegistry"
                                 )
 
@@ -309,7 +307,7 @@ class DependencyResolutionStep(PipelineStep):
                                 new_proxy = SelfDependencyProxy(
                                     wrapper_func, dep_function_name
                                 )
-                                self.logger.info(
+                                self.logger.debug(
                                     f"🔄 SELF-DEPENDENCY: Using wrapper for '{capability}' "
                                     f"(local call with full DI support)"
                                 )
@@ -337,7 +335,7 @@ class DependencyResolutionStep(PipelineStep):
                                         dep_function_name,
                                         kwargs_config=kwargs_config,
                                     )
-                                    self.logger.debug(
+                                    self.logger.trace(
                                         f"🔧 Created EnhancedUnifiedMCPProxy (fallback): {kwargs_config}"
                                     )
                         else:
@@ -347,7 +345,7 @@ class DependencyResolutionStep(PipelineStep):
                                 dep_function_name,
                                 kwargs_config=kwargs_config,
                             )
-                            self.logger.info(
+                            self.logger.debug(
                                 f"🔄 Updated to EnhancedUnifiedMCPProxy: '{capability}' -> {endpoint}/{dep_function_name}, "
                                 f"timeout={kwargs_config.get('timeout', 30)}s, streaming={kwargs_config.get('streaming', False)}"
                             )
@@ -356,12 +354,12 @@ class DependencyResolutionStep(PipelineStep):
                         dep_key = f"{func_id}:dep_{dep_index}"
                         await injector.register_dependency(dep_key, new_proxy)
                         updated_count += 1
-                        self.logger.debug(
+                        self.logger.trace(
                             f"🔗 Registered dependency '{capability}' at position {dep_index} with key '{dep_key}' (func_id: {func_id})"
                         )
                     else:
                         if status != "available":
-                            self.logger.debug(
+                            self.logger.trace(
                                 f"⚠️ Dependency '{capability}' at position {dep_index} not available: {status}"
                             )
                         else:

_mcp_mesh/pipeline/mcp_heartbeat/fast_heartbeat_check.py

@@ -41,7 +41,7 @@ class FastHeartbeatStep(PipelineStep):
         Returns:
             PipelineResult with fast_heartbeat_status in context
         """
-        self.logger.debug("Starting fast heartbeat check...")
+        self.logger.trace("Starting fast heartbeat check...")
 
         result = PipelineResult(message="Fast heartbeat check completed")
 
@@ -56,7 +56,7 @@ class FastHeartbeatStep(PipelineStep):
             if not registry_wrapper:
                 raise ValueError("registry_wrapper is required in context")
 
-            self.logger.debug(
+            self.logger.trace(
                 f"🚀 Performing fast heartbeat check for agent '{agent_id}'"
             )
 
@@ -72,15 +72,15 @@ class FastHeartbeatStep(PipelineStep):
 
             # Log status and action
             if status == FastHeartbeatStatus.NO_CHANGES:
-                self.logger.debug(
+                self.logger.trace(
                     f"✅ Fast heartbeat: No changes detected for agent '{agent_id}'"
                 )
             elif status == FastHeartbeatStatus.TOPOLOGY_CHANGED:
-                self.logger.debug(
+                self.logger.trace(
                     f"🔄 Fast heartbeat: Topology changed for agent '{agent_id}' - full refresh needed"
                 )
             elif status == FastHeartbeatStatus.AGENT_UNKNOWN:
-                self.logger.debug(
+                self.logger.trace(
                     f"❓ Fast heartbeat: Agent '{agent_id}' unknown - re-registration needed"
                 )
             elif status == FastHeartbeatStatus.REGISTRY_ERROR:

_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_orchestrator.py

@@ -68,7 +68,7 @@ class HeartbeatOrchestrator:
             self._log_heartbeat_request(heartbeat_context, self._heartbeat_count)
 
             # Execute heartbeat pipeline with timeout protection
-            self.logger.info(
+            self.logger.trace(
                 f"💓 Executing heartbeat #{self._heartbeat_count} for agent '{agent_id}'"
             )
 
@@ -173,7 +173,7 @@ class HeartbeatOrchestrator:
 
         # If health check is configured, use the cache
         if health_check_fn:
-            from ...shared.health_check_cache import get_health_status_with_cache
+            from ...shared.health_check_manager import get_health_status_with_cache
 
             return await get_health_status_with_cache(
                 agent_id=agent_id,
@@ -260,7 +260,7 @@ class HeartbeatOrchestrator:
                 fast_heartbeat_status
             ):
                 # Fast heartbeat optimization - no changes detected
-                self.logger.info(
+                self.logger.debug(
                     f"🚀 Heartbeat #{heartbeat_count} optimized for agent '{agent_id}' - no changes detected"
                 )
                 return True

_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_pipeline.py

@@ -51,7 +51,7 @@ class HeartbeatPipeline(MeshPipeline):
         ]
 
         self.add_steps(steps)
-        self.logger.debug(f"Heartbeat pipeline configured with {len(steps)} steps")
+        self.logger.trace(f"Heartbeat pipeline configured with {len(steps)} steps")
 
     async def execute_heartbeat_cycle(
         self, heartbeat_context: dict[str, Any]
@@ -65,7 +65,7 @@ class HeartbeatPipeline(MeshPipeline):
         Returns:
             PipelineResult with execution status and any context updates
         """
-        self.logger.debug("Starting heartbeat pipeline execution")
+        self.logger.trace("Starting heartbeat pipeline execution")
 
         # Initialize pipeline context with heartbeat-specific data
         self.context.clear()
@@ -76,7 +76,7 @@ class HeartbeatPipeline(MeshPipeline):
             result = await self._execute_with_conditional_logic()
 
             if result.is_success():
-                self.logger.debug("✅ Heartbeat pipeline completed successfully")
+                self.logger.trace("✅ Heartbeat pipeline completed successfully")
             elif result.status == PipelineStatus.PARTIAL:
                 self.logger.warning(
                     f"⚠️ Heartbeat pipeline completed partially: {result.message}"
@@ -149,7 +149,7 @@ class HeartbeatPipeline(MeshPipeline):
 
             # Execute mandatory steps
             for step in mandatory_steps:
-                self.logger.debug(f"Executing mandatory step: {step.name}")
+                self.logger.trace(f"Executing mandatory step: {step.name}")
 
                 step_result = await step.execute(self.context)
                 executed_steps.append(step.name)
@@ -189,7 +189,7 @@ class HeartbeatPipeline(MeshPipeline):
                 # NO_CHANGES - skip for optimization
                 should_execute_remaining = False
                 reason = "optimization (no changes detected)"
-                self.logger.debug(
+                self.logger.trace(
                     f"🚀 Skipping remaining steps for optimization: {reason}"
                 )
             elif FastHeartbeatStatusUtil.should_skip_for_resilience(
@@ -217,7 +217,7 @@ class HeartbeatPipeline(MeshPipeline):
             # Execute or skip conditional steps based on decision
             if should_execute_remaining:
                 for step in conditional_steps:
-                    self.logger.debug(f"Executing conditional step: {step.name}")
+                    self.logger.trace(f"Executing conditional step: {step.name}")
 
                     step_result = await step.execute(self.context)
                     executed_steps.append(step.name)

_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_send.py

@@ -41,7 +41,7 @@ class HeartbeatSendStep(PipelineStep):
                 raise ValueError("Health status not available in context")
 
             # Prepare heartbeat for registry
-            self.logger.debug(f"🔍 Preparing heartbeat for agent '{agent_id}'")
+            self.logger.trace(f"🔍 Preparing heartbeat for agent '{agent_id}'")
 
             # Send actual HTTP request to registry
             registry_wrapper = context.get("registry_wrapper")

_mcp_mesh/pipeline/mcp_heartbeat/llm_tools_resolution.py

@@ -39,7 +39,7 @@ class LLMToolsResolutionStep(PipelineStep):
 
     async def execute(self, context: dict[str, Any]) -> PipelineResult:
         """Process LLM tools resolution with hash-based change detection."""
-        self.logger.debug("Processing LLM tools resolution...")
+        self.logger.trace("Processing LLM tools resolution...")
 
         result = PipelineResult(message="LLM tools resolution processed")
 
@@ -50,7 +50,7 @@ class LLMToolsResolutionStep(PipelineStep):
             if heartbeat_response is None:
                 result.status = PipelineStatus.SUCCESS
                 result.message = "No heartbeat response - completed successfully"
-                self.logger.debug("ℹ️ No heartbeat response to process - this is normal")
+                self.logger.trace("ℹ️ No heartbeat response to process - this is normal")
                 return result
 
             # Use hash-based change detection and processing logic
@@ -73,14 +73,16 @@ class LLMToolsResolutionStep(PipelineStep):
             result.add_context("llm_tools", llm_tools)
             result.add_context("llm_providers", llm_providers)
 
-            result.message = "LLM tools and providers resolution completed (efficient hash-based)"
+            result.message = (
+                "LLM tools and providers resolution completed (efficient hash-based)"
+            )
 
             if function_count > 0 or provider_count > 0:
                 self.logger.info(
                     f"🤖 LLM state resolved: {function_count} functions, {tool_count} tools, {provider_count} providers"
                 )
 
-            self.logger.debug(
+            self.logger.trace(
                 "🤖 LLM tools and providers resolution step completed using hash-based change detection"
             )
 
@@ -113,14 +115,16 @@ class LLMToolsResolutionStep(PipelineStep):
             llm_tools = {}
 
         if not isinstance(llm_providers, dict):
-            self.logger.warning(f"llm_providers is not a dict, type={type(llm_providers)}")
+            self.logger.warning(
+                f"llm_providers is not a dict, type={type(llm_providers)}"
+            )
             llm_providers = {}
 
         # Build state with both llm_tools and llm_providers
         # This ensures hash changes when EITHER tools OR providers change
         state = {
             "llm_tools": {},
-            "llm_providers": llm_providers  # Include providers directly
+            "llm_providers": llm_providers,  # Include providers directly
         }
 
         # Filter out non-list values for llm_tools
@@ -165,7 +169,7 @@ class LLMToolsResolutionStep(PipelineStep):
             if not heartbeat_response:
                 # No response from registry (connection error, timeout, 5xx)
                 # → Skip entirely for resilience (keep existing LLM tools and providers)
-                self.logger.debug(
+                self.logger.trace(
                     "No heartbeat response - skipping LLM state processing for resilience"
                 )
                 return
@@ -182,7 +186,7 @@ class LLMToolsResolutionStep(PipelineStep):
             # Compare with previous state (use global variable)
             global _last_llm_tools_hash
             if current_hash == _last_llm_tools_hash:
-                self.logger.debug(
+                self.logger.trace(
                     f"🔄 LLM state unchanged (hash: {current_hash}), skipping processing"
                 )
                 return
@@ -222,13 +226,13 @@ class LLMToolsResolutionStep(PipelineStep):
             # Determine if this is initial processing or an update
             if _last_llm_tools_hash is None:
                 # Initial processing - use process_llm_tools
-                self.logger.debug(
+                self.logger.trace(
                     "🤖 Initial LLM tools processing - calling process_llm_tools()"
                 )
                 injector.process_llm_tools(llm_tools)
             else:
                 # Update - use update_llm_tools
-                self.logger.debug("🤖 LLM tools update - calling update_llm_tools()")
+                self.logger.trace("🤖 LLM tools update - calling update_llm_tools()")
                 injector.update_llm_tools(llm_tools)
 
             # Process LLM providers (v0.6.1 mesh delegation)
@@ -239,7 +243,7 @@ class LLMToolsResolutionStep(PipelineStep):
                 )
                 injector.process_llm_providers(llm_providers)
             else:
-                self.logger.debug("🔌 No llm_providers in current state")
+                self.logger.trace("🔌 No llm_providers in current state")
 
             # Store new hash for next comparison (use global variable)
             _last_llm_tools_hash = current_hash

_mcp_mesh/pipeline/mcp_heartbeat/registry_connection.py

@@ -33,7 +33,7 @@ class RegistryConnectionStep(PipelineStep):
 
     async def execute(self, context: dict[str, Any]) -> PipelineResult:
         """Establish registry connection or reuse existing one."""
-        self.logger.debug("Checking registry connection...")
+        self.logger.trace("Checking registry connection...")
 
         result = PipelineResult(message="Registry connection ready")
 
@@ -45,7 +45,7 @@ class RegistryConnectionStep(PipelineStep):
                 # Reuse existing connection for efficiency
                 result.add_context("registry_wrapper", existing_wrapper)
                 result.message = "Reusing existing registry connection"
-                self.logger.debug("🔄 Reusing existing registry connection")
+                self.logger.trace("🔄 Reusing existing registry connection")
                 return result
 
             # Create new connection if none exists
@@ -64,7 +64,7 @@ class RegistryConnectionStep(PipelineStep):
             result.add_context("registry_wrapper", registry_wrapper)
 
             result.message = f"Connected to registry at {registry_url}"
-            self.logger.info(f"🔗 Registry connection established: {registry_url}")
+            self.logger.trace(f"🔗 Registry connection established: {registry_url}")
 
         except Exception as e:
             result.status = PipelineStatus.FAILED