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

_mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py

@@ -255,12 +255,14 @@ 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"]
@@ -293,36 +295,51 @@ class DependencyResolutionStep(PipelineStep):
                         )
 
                         if is_self_dependency:
-                            # Create self-dependency proxy with cached function reference
-                            original_func = injector.find_original_function(
-                                dep_function_name
-                            )
-                            if original_func:
-                                new_proxy = SelfDependencyProxy(
-                                    original_func, dep_function_name
+                            # Create self-dependency proxy with WRAPPER function (not original)
+                            # The wrapper has dependency injection logic, so calling it ensures
+                            # the target function's dependencies are also injected properly.
+                            wrapper_func = None
+                            if dep_function_name in mesh_tools:
+                                wrapper_func = mesh_tools[dep_function_name].function
+                                self.logger.debug(
+                                    f"🔍 Found wrapper for '{dep_function_name}' in DecoratorRegistry"
                                 )
-                                self.logger.warning(
-                                    f"⚠️ SELF-DEPENDENCY: Using direct function call for '{capability}' "
-                                    f"instead of HTTP to avoid deadlock. Consider refactoring to "
-                                    f"eliminate self-dependencies if possible."
+
+                            if wrapper_func:
+                                new_proxy = SelfDependencyProxy(
+                                    wrapper_func, dep_function_name
                                 )
                                 self.logger.info(
-                                    f"🔄 Updated to SelfDependencyProxy: '{capability}'"
+                                    f"🔄 SELF-DEPENDENCY: Using wrapper for '{capability}' "
+                                    f"(local call with full DI support)"
                                 )
                             else:
-                                self.logger.error(
-                                    f"❌ Cannot create SelfDependencyProxy for '{capability}': "
-                                    f"original function '{dep_function_name}' not found, falling back to HTTP"
-                                )
-                                # Use unified proxy for fallback
-                                new_proxy = EnhancedUnifiedMCPProxy(
-                                    endpoint,
-                                    dep_function_name,
-                                    kwargs_config=kwargs_config,
-                                )
-                                self.logger.debug(
-                                    f"🔧 Created EnhancedUnifiedMCPProxy (fallback): {kwargs_config}"
+                                # Fallback to original function if wrapper not found
+                                original_func = injector.find_original_function(
+                                    dep_function_name
                                 )
+                                if original_func:
+                                    new_proxy = SelfDependencyProxy(
+                                        original_func, dep_function_name
+                                    )
+                                    self.logger.warning(
+                                        f"⚠️ SELF-DEPENDENCY: Using original function for '{capability}' "
+                                        f"(wrapper not found, DI may not work for nested deps)"
+                                    )
+                                else:
+                                    self.logger.error(
+                                        f"❌ Cannot create SelfDependencyProxy for '{capability}': "
+                                        f"neither wrapper nor original function '{dep_function_name}' found, falling back to HTTP"
+                                    )
+                                    # Use unified proxy for fallback
+                                    new_proxy = EnhancedUnifiedMCPProxy(
+                                        endpoint,
+                                        dep_function_name,
+                                        kwargs_config=kwargs_config,
+                                    )
+                                    self.logger.debug(
+                                        f"🔧 Created EnhancedUnifiedMCPProxy (fallback): {kwargs_config}"
+                                    )
                         else:
                             # Create cross-service proxy using unified proxy
                             new_proxy = EnhancedUnifiedMCPProxy(

_mcp_mesh/pipeline/mcp_heartbeat/fast_heartbeat_check.py

@@ -72,15 +72,15 @@ class FastHeartbeatStep(PipelineStep):
 
             # Log status and action
             if status == FastHeartbeatStatus.NO_CHANGES:
-                self.logger.info(
+                self.logger.debug(
                     f"✅ Fast heartbeat: No changes detected for agent '{agent_id}'"
                 )
             elif status == FastHeartbeatStatus.TOPOLOGY_CHANGED:
-                self.logger.info(
+                self.logger.debug(
                     f"🔄 Fast heartbeat: Topology changed for agent '{agent_id}' - full refresh needed"
                 )
             elif status == FastHeartbeatStatus.AGENT_UNKNOWN:
-                self.logger.info(
+                self.logger.debug(
                     f"❓ Fast heartbeat: Agent '{agent_id}' unknown - re-registration needed"
                 )
             elif status == FastHeartbeatStatus.REGISTRY_ERROR:

_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_orchestrator.py

@@ -8,7 +8,7 @@ context management and error handling.
 import json
 import logging
 from datetime import UTC, datetime
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 from ...shared.support_types import HealthStatus, HealthStatusType
 from .heartbeat_pipeline import HeartbeatPipeline
@@ -44,9 +44,8 @@ class HeartbeatOrchestrator:
 
         try:
 
-
             # Prepare heartbeat context with validation
-            heartbeat_context = self._prepare_heartbeat_context(agent_id, context)
+            heartbeat_context = await self._prepare_heartbeat_context(agent_id, context)
 
             # Validate required context before proceeding
             if not self._validate_heartbeat_context(heartbeat_context):
@@ -55,6 +54,16 @@ class HeartbeatOrchestrator:
                 )
                 return False
 
+            # Check if health status is unhealthy - skip heartbeat if so
+            health_status = heartbeat_context.get("health_status")
+            if health_status and health_status.status == HealthStatusType.UNHEALTHY:
+                self.logger.warning(
+                    f"⚠️ Heartbeat #{self._heartbeat_count} skipped for agent '{agent_id}': Health status is UNHEALTHY"
+                )
+                self.logger.warning(f"   Health checks failed: {health_status.checks}")
+                self.logger.warning(f"   Errors: {health_status.errors}")
+                return False
+
             # Log heartbeat request details for debugging
             self._log_heartbeat_request(heartbeat_context, self._heartbeat_count)
 
@@ -104,13 +113,13 @@ class HeartbeatOrchestrator:
             )
             return False
 
-    def _prepare_heartbeat_context(
+    async def _prepare_heartbeat_context(
         self, agent_id: str, startup_context: dict[str, Any]
     ) -> dict[str, Any]:
         """Prepare context for heartbeat pipeline execution."""
 
         # Build health status from startup context
-        health_status = self._build_health_status_from_context(
+        health_status = await self._build_health_status_from_context(
             startup_context, agent_id
         )
 
@@ -151,12 +160,30 @@ class HeartbeatOrchestrator:
 
         return True
 
-    def _build_health_status_from_context(
+    async def _build_health_status_from_context(
         self, startup_context: dict[str, Any], agent_id: str
     ) -> HealthStatus:
-        """Build health status object from startup context."""
+        """Build health status object from startup context with optional user health check."""
+
+        agent_config = startup_context.get("agent_config", {})
 
-        # Get existing health status from context or build from current state
+        # Check if user provided a health_check function
+        health_check_fn = agent_config.get("health_check")
+        health_check_ttl = agent_config.get("health_check_ttl", 15)
+
+        # If health check is configured, use the cache
+        if health_check_fn:
+            from ...shared.health_check_cache import get_health_status_with_cache
+
+            return await get_health_status_with_cache(
+                agent_id=agent_id,
+                health_check_fn=health_check_fn,
+                agent_config=agent_config,
+                startup_context=startup_context,
+                ttl=health_check_ttl,
+            )
+
+        # No health check configured - use existing logic
         existing_health_status = startup_context.get("health_status")
 
         if existing_health_status:
@@ -166,8 +193,6 @@ class HeartbeatOrchestrator:
             return existing_health_status
 
         # Build minimal health status from context if none exists
-        agent_config = startup_context.get("agent_config", {})
-
         return HealthStatus(
             agent_name=agent_id,
             status=HealthStatusType.HEALTHY,

_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_pipeline.py

@@ -189,7 +189,7 @@ class HeartbeatPipeline(MeshPipeline):
                 # NO_CHANGES - skip for optimization
                 should_execute_remaining = False
                 reason = "optimization (no changes detected)"
-                self.logger.info(
+                self.logger.debug(
                     f"🚀 Skipping remaining steps for optimization: {reason}"
                 )
             elif FastHeartbeatStatusUtil.should_skip_for_resilience(

_mcp_mesh/pipeline/mcp_heartbeat/llm_tools_resolution.py

@@ -56,28 +56,32 @@ class LLMToolsResolutionStep(PipelineStep):
             # Use hash-based change detection and processing logic
             await self.process_llm_tools_from_heartbeat(heartbeat_response)
 
-            # Extract LLM tools count for context
+            # Extract LLM tools and providers count for context
             llm_tools = heartbeat_response.get("llm_tools", {})
+            llm_providers = heartbeat_response.get("llm_providers", {})
             function_count = len(llm_tools)
             tool_count = sum(
                 len(tools) if isinstance(tools, list) else 0
                 for tools in llm_tools.values()
             )
+            provider_count = len(llm_providers)
 
-            # Store processed LLM tools info for context
+            # Store processed LLM tools and providers info for context
             result.add_context("llm_function_count", function_count)
             result.add_context("llm_tool_count", tool_count)
+            result.add_context("llm_provider_count", provider_count)
             result.add_context("llm_tools", llm_tools)
+            result.add_context("llm_providers", llm_providers)
 
-            result.message = "LLM tools resolution completed (efficient hash-based)"
+            result.message = "LLM tools and providers resolution completed (efficient hash-based)"
 
-            if function_count > 0:
+            if function_count > 0 or provider_count > 0:
                 self.logger.info(
-                    f"🤖 LLM tools resolved: {function_count} functions, {tool_count} tools"
+                    f"🤖 LLM state resolved: {function_count} functions, {tool_count} tools, {provider_count} providers"
                 )
 
             self.logger.debug(
-                "🤖 LLM tools resolution step completed using hash-based change detection"
+                "🤖 LLM tools and providers resolution step completed using hash-based change detection"
             )
 
         except Exception as e:
@@ -90,31 +94,48 @@ class LLMToolsResolutionStep(PipelineStep):
 
     def _extract_llm_tools_state(
         self, heartbeat_response: dict[str, Any]
-    ) -> dict[str, list[dict[str, Any]]]:
-        """Extract LLM tools state structure from heartbeat response.
+    ) -> dict[str, Any]:
+        """Extract LLM tools and providers state structure from heartbeat response.
 
         Preserves array structure and order from registry.
 
         Returns:
-            {function_id: [{function_name, capability, endpoint, input_schema, ...}, ...]}
+            {
+                "llm_tools": {function_id: [{function_name, capability, endpoint, input_schema, ...}, ...]},
+                "llm_providers": {function_id: {name, endpoint, agent_id, capability, tags, ...}}
+            }
         """
         llm_tools = heartbeat_response.get("llm_tools", {})
+        llm_providers = heartbeat_response.get("llm_providers", {})
 
         if not isinstance(llm_tools, dict):
             self.logger.warning(f"llm_tools is not a dict, type={type(llm_tools)}")
-            return {}
+            llm_tools = {}
 
-        # Return as-is since registry already provides the correct structure
-        # Filter out non-dict or non-list values for safety
-        state = {}
+        if not isinstance(llm_providers, dict):
+            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
+        }
+
+        # Filter out non-list values for llm_tools
         for function_id, tools in llm_tools.items():
             if isinstance(tools, list):
-                state[function_id] = tools
+                state["llm_tools"][function_id] = tools
 
         return state
 
     def _hash_llm_tools_state(self, state: dict) -> str:
-        """Create hash of LLM tools state structure."""
+        """Create hash of LLM tools and providers state structure.
+
+        This hash includes BOTH llm_tools and llm_providers to ensure
+        rewiring happens when either changes.
+        """
         import hashlib
 
         # Convert to sorted JSON string for consistent hashing
@@ -129,64 +150,71 @@ class LLMToolsResolutionStep(PipelineStep):
     ) -> None:
         """Process heartbeat response to update LLM agent injection.
 
-        Uses hash-based comparison to efficiently detect when ANY LLM tools change
+        Uses hash-based comparison to efficiently detect when ANY LLM tools OR providers change
         and then updates ALL affected LLM agents in one operation.
 
         Resilience logic:
-        - No response (connection error, 5xx) → Skip entirely (keep existing tools)
-        - 2xx response with empty llm_tools → Clear all LLM tools
-        - 2xx response with partial llm_tools → Update to match registry exactly
+        - No response (connection error, 5xx) → Skip entirely (keep existing state)
+        - 2xx response with empty llm_tools/llm_providers → Clear all LLM state
+        - 2xx response with partial llm_tools/llm_providers → Update to match registry exactly
+
+        The hash includes both llm_tools and llm_providers to ensure rewiring happens
+        when either changes (e.g., provider failover from Claude to OpenAI).
         """
         try:
             if not heartbeat_response:
                 # No response from registry (connection error, timeout, 5xx)
-                # → Skip entirely for resilience (keep existing LLM tools)
+                # → Skip entirely for resilience (keep existing LLM tools and providers)
                 self.logger.debug(
-                    "No heartbeat response - skipping LLM tools processing for resilience"
+                    "No heartbeat response - skipping LLM state processing for resilience"
                 )
                 return
 
-            # Extract current LLM tools state
+            # Extract current LLM tools and providers state
             current_state = self._extract_llm_tools_state(heartbeat_response)
 
-            # IMPORTANT: Empty state from successful response means "no LLM tools"
+            # IMPORTANT: Empty state from successful response means "no LLM tools or providers"
             # This is different from "no response" which means "keep existing for resilience"
 
-            # Hash the current state (including empty state)
+            # Hash the current state (including both llm_tools and llm_providers)
             current_hash = self._hash_llm_tools_state(current_state)
 
             # Compare with previous state (use global variable)
             global _last_llm_tools_hash
             if current_hash == _last_llm_tools_hash:
                 self.logger.debug(
-                    f"🔄 LLM tools state unchanged (hash: {current_hash}), skipping processing"
+                    f"🔄 LLM state unchanged (hash: {current_hash}), skipping processing"
                 )
                 return
 
             # State changed - determine what changed
-            function_count = len(current_state)
-            total_tools = sum(len(tools) for tools in current_state.values())
+            llm_tools = current_state.get("llm_tools", {})
+            llm_providers = current_state.get("llm_providers", {})
+
+            function_count = len(llm_tools)
+            total_tools = sum(len(tools) for tools in llm_tools.values())
+            provider_count = len(llm_providers)
 
             if _last_llm_tools_hash is None:
-                if function_count > 0:
+                if function_count > 0 or provider_count > 0:
                     self.logger.info(
-                        f"🤖 Initial LLM tools state detected: {function_count} functions, {total_tools} tools"
+                        f"🤖 Initial LLM state detected: {function_count} functions, {total_tools} tools, {provider_count} providers"
                     )
                 else:
                     self.logger.info(
-                        "🤖 Initial LLM tools state detected: no LLM tools"
+                        "🤖 Initial LLM state detected: no LLM tools or providers"
                     )
             else:
                 self.logger.info(
-                    f"🤖 LLM tools state changed (hash: {_last_llm_tools_hash} → {current_hash})"
+                    f"🤖 LLM state changed (hash: {_last_llm_tools_hash} → {current_hash})"
                 )
-                if function_count > 0:
+                if function_count > 0 or provider_count > 0:
                     self.logger.info(
-                        f"🤖 Updating LLM tools for {function_count} functions ({total_tools} total tools)"
+                        f"🤖 Updating LLM state: {function_count} functions ({total_tools} tools), {provider_count} providers"
                     )
                 else:
                     self.logger.info(
-                        "🤖 Registry reports no LLM tools - clearing all existing LLM tools"
+                        "🤖 Registry reports no LLM tools or providers - clearing all existing state"
                     )
 
             injector = get_global_injector()
@@ -197,22 +225,32 @@ class LLMToolsResolutionStep(PipelineStep):
                 self.logger.debug(
                     "🤖 Initial LLM tools processing - calling process_llm_tools()"
                 )
-                injector.process_llm_tools(current_state)
+                injector.process_llm_tools(llm_tools)
             else:
                 # Update - use update_llm_tools
                 self.logger.debug("🤖 LLM tools update - calling update_llm_tools()")
-                injector.update_llm_tools(current_state)
+                injector.update_llm_tools(llm_tools)
+
+            # Process LLM providers (v0.6.1 mesh delegation)
+            # Now part of hash-based change detection, so this always runs when state changes
+            if llm_providers:
+                self.logger.info(
+                    f"🔌 Processing LLM providers for {len(llm_providers)} functions"
+                )
+                injector.process_llm_providers(llm_providers)
+            else:
+                self.logger.debug("🔌 No llm_providers in current state")
 
             # Store new hash for next comparison (use global variable)
             _last_llm_tools_hash = current_hash
 
-            if function_count > 0:
+            if function_count > 0 or provider_count > 0:
                 self.logger.info(
-                    f"✅ Successfully processed LLM tools for {function_count} functions ({total_tools} tools, state hash: {current_hash})"
+                    f"✅ Successfully processed LLM state: {function_count} functions ({total_tools} tools), {provider_count} providers (hash: {current_hash})"
                 )
             else:
                 self.logger.info(
-                    f"✅ LLM tools state synchronized (no tools, state hash: {current_hash})"
+                    f"✅ LLM state synchronized (no tools or providers, hash: {current_hash})"
                 )
 
         except Exception as e: