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

_mcp_mesh/engine/dependency_injector.py

@@ -14,7 +14,7 @@ import weakref
 from collections.abc import Callable
 from typing import Any
 
-from .signature_analyzer import get_agent_parameter_types, get_mesh_agent_positions
+from .signature_analyzer import get_mesh_agent_positions, has_llm_agent_parameter
 
 logger = logging.getLogger(__name__)
 
@@ -57,17 +57,17 @@ def analyze_injection_strategy(func: Callable, dependencies: list[str]) -> list[
             logger.warning(
                 f"Single parameter '{param_name}' in function '{func_name}' found, "
                 f"injecting {dependencies[0] if dependencies else 'dependency'} proxy "
-                f"(consider typing as McpMeshAgent or McpAgent for clarity)"
+                f"(consider typing as McpMeshAgent for clarity)"
             )
         return [0]  # Inject into the single parameter
 
-    # Multiple parameters rule: only inject into McpMeshAgent or McpAgent typed parameters
+    # Multiple parameters rule: only inject into McpMeshAgent typed parameters
     if param_count > 1:
         if not mesh_positions:
             logger.warning(
                 f"⚠️ Function '{func_name}' has {param_count} parameters but none are "
-                f"typed as McpMeshAgent or McpAgent. Skipping injection of {len(dependencies)} dependencies. "
-                f"Consider typing dependency parameters as McpMeshAgent or McpAgent."
+                f"typed as McpMeshAgent. Skipping injection of {len(dependencies)} dependencies. "
+                f"Consider typing dependency parameters as McpMeshAgent."
             )
             return []
 
@@ -77,7 +77,7 @@ def analyze_injection_strategy(func: Callable, dependencies: list[str]) -> list[
                 excess_deps = dependencies[len(mesh_positions) :]
                 logger.warning(
                     f"Function '{func_name}' has {len(dependencies)} dependencies "
-                    f"but only {len(mesh_positions)} McpMeshAgent/McpAgent parameters. "
+                    f"but only {len(mesh_positions)} McpMeshAgent parameters. "
                     f"Dependencies {excess_deps} will not be injected."
                 )
             else:
@@ -85,7 +85,7 @@ def analyze_injection_strategy(func: Callable, dependencies: list[str]) -> list[
                     params[pos].name for pos in mesh_positions[len(dependencies) :]
                 ]
                 logger.warning(
-                    f"Function '{func_name}' has {len(mesh_positions)} McpMeshAgent/McpAgent parameters "
+                    f"Function '{func_name}' has {len(mesh_positions)} McpMeshAgent parameters "
                     f"but only {len(dependencies)} dependencies declared. "
                     f"Parameters {excess_params} will remain None."
                 )
@@ -101,10 +101,11 @@ class DependencyInjector:
     Manages dynamic dependency injection for mesh agents.
 
     This class:
-    1. Maintains a registry of available dependencies
-    2. Tracks which functions depend on which services
-    3. Updates function bindings when topology changes
-    4. Handles graceful degradation when dependencies unavailable
+    1. Maintains a registry of available dependencies (McpMeshAgent)
+    2. Coordinates with MeshLlmAgentInjector for LLM agent injection
+    3. Tracks which functions depend on which services
+    4. Updates function bindings when topology changes
+    5. Handles graceful degradation when dependencies unavailable
     """
 
     def __init__(self):
@@ -117,6 +118,12 @@ class DependencyInjector:
         )  # dep_name -> set of function_ids
         self._lock = asyncio.Lock()
 
+        # LLM agent injector for MeshLlmAgent parameters
+        from .mesh_llm_agent_injector import get_global_llm_injector
+
+        self._llm_injector = get_global_llm_injector()
+        logger.debug("🤖 DependencyInjector initialized with MeshLlmAgentInjector")
+
     async def register_dependency(self, name: str, instance: Any) -> None:
         """Register a new dependency or update existing one.
 
@@ -282,6 +289,49 @@ class DependencyInjector:
         )
         return None
 
+    def process_llm_tools(self, llm_tools: dict[str, list[dict[str, Any]]]) -> None:
+        """
+        Process llm_tools from registry response and delegate to MeshLlmAgentInjector.
+
+        Args:
+            llm_tools: Dict mapping function_id -> list of tool metadata
+                      Format: {"function_id": [{"function_name": "...", "endpoint": {...}, ...}]}
+        """
+        logger.info(
+            f"🤖 DependencyInjector processing llm_tools for {len(llm_tools)} functions"
+        )
+        self._llm_injector.process_llm_tools(llm_tools)
+
+    def update_llm_tools(self, llm_tools: dict[str, list[dict[str, Any]]]) -> None:
+        """
+        Update llm_tools when topology changes (heartbeat updates).
+
+        Args:
+            llm_tools: Updated llm_tools dict from registry
+        """
+        logger.info(
+            f"🔄 DependencyInjector updating llm_tools for {len(llm_tools)} functions"
+        )
+        self._llm_injector.update_llm_tools(llm_tools)
+
+    def create_llm_injection_wrapper(
+        self, func: Callable, function_id: str
+    ) -> Callable:
+        """
+        Create wrapper for function with MeshLlmAgent parameter.
+
+        Delegates to MeshLlmAgentInjector.
+
+        Args:
+            func: Function to wrap
+            function_id: Unique function ID from @mesh.llm decorator
+
+        Returns:
+            Wrapped function with MeshLlmAgent injection
+        """
+        logger.debug(f"🤖 Creating LLM injection wrapper for {function_id}")
+        return self._llm_injector.create_injection_wrapper(func, function_id)
+
     def create_injection_wrapper(
         self, func: Callable, dependencies: list[str]
     ) -> Callable:
@@ -300,9 +350,6 @@ class DependencyInjector:
         # Use new smart injection strategy
         mesh_positions = analyze_injection_strategy(func, dependencies)
 
-        # Get parameter type information for proxy selection
-        parameter_types = get_agent_parameter_types(func)
-
         # Track which dependencies this function needs (using composite keys)
         for dep_index, dep in enumerate(dependencies):
             dep_key = f"{func_id}:dep_{dep_index}"
@@ -365,7 +412,6 @@ class DependencyInjector:
             minimal_wrapper._mesh_injected_deps = [None] * len(dependencies)
             minimal_wrapper._mesh_dependencies = dependencies
             minimal_wrapper._mesh_positions = mesh_positions
-            minimal_wrapper._mesh_parameter_types = get_agent_parameter_types(func)
             minimal_wrapper._mesh_original_func = func
 
             def update_dependency(dep_index: int, instance: Any | None) -> None:
@@ -463,6 +509,21 @@ class DependencyInjector:
                     f"🔧 DEPENDENCY_WRAPPER: final_kwargs={final_kwargs}"
                 )
 
+                # ===== INJECT LLM AGENT IF PRESENT (Option A) =====
+                # Check if this function has @mesh.llm metadata attached (on the original function)
+                if hasattr(func, "_mesh_llm_param_name"):
+                    llm_param = func._mesh_llm_param_name
+                    # Only inject if not already provided
+                    if (
+                        llm_param not in final_kwargs
+                        or final_kwargs.get(llm_param) is None
+                    ):
+                        llm_agent = getattr(func, "_mesh_llm_agent", None)
+                        final_kwargs[llm_param] = llm_agent
+                        wrapper_logger.debug(
+                            f"🤖 LLM_INJECTION: Injected {llm_param}={llm_agent}"
+                        )
+
                 # ===== EXECUTE WITH DEPENDENCY INJECTION AND TRACING =====
                 # Use ExecutionTracer for comprehensive execution logging (v0.4.0 style)
                 from ..tracing.execution_tracer import ExecutionTracer
@@ -540,6 +601,21 @@ class DependencyInjector:
                             final_kwargs[param_name] = dependency
                             injected_count += 1
 
+                # ===== INJECT LLM AGENT IF PRESENT (Option A) =====
+                # Check if this function has @mesh.llm metadata attached (on the original function)
+                if hasattr(func, "_mesh_llm_param_name"):
+                    llm_param = func._mesh_llm_param_name
+                    # Only inject if not already provided
+                    if (
+                        llm_param not in final_kwargs
+                        or final_kwargs.get(llm_param) is None
+                    ):
+                        llm_agent = getattr(func, "_mesh_llm_agent", None)
+                        final_kwargs[llm_param] = llm_agent
+                        wrapper_logger.debug(
+                            f"🤖 LLM_INJECTION: Injected {llm_param}={llm_agent}"
+                        )
+
                 # ===== EXECUTE WITH DEPENDENCY INJECTION AND TRACING =====
                 # Use ExecutionTracer for comprehensive execution logging (v0.4.0 style)
                 from ..tracing.execution_tracer import ExecutionTracer
@@ -587,9 +663,6 @@ class DependencyInjector:
         dependency_wrapper._mesh_update_dependency = update_dependency
         dependency_wrapper._mesh_dependencies = dependencies
         dependency_wrapper._mesh_positions = mesh_positions
-        dependency_wrapper._mesh_parameter_types = (
-            parameter_types  # Store for proxy selection
-        )
         dependency_wrapper._mesh_original_func = func
 
         # Register this wrapper for dependency updates

_mcp_mesh/engine/http_wrapper.py

@@ -170,32 +170,12 @@ class HttpMcpWrapper:
     async def setup(self):
         """Set up FastMCP app for integration (no separate wrapper app)."""
 
-        # Debug the FastMCP server instance first
-        logger.debug(f"🔍 DEBUG: FastMCP server type: {type(self.mcp_server)}")
-        logger.debug(
-            f"🔍 DEBUG: FastMCP server module: {type(self.mcp_server).__module__}"
-        )
-
         # Using FastMCP library (fastmcp>=2.8.0)
         logger.info(
             "🆕 HTTP Wrapper: Server instance is from FastMCP library (fastmcp)"
         )
 
-        logger.debug(
-            f"🔍 DEBUG: FastMCP server dir: {[attr for attr in dir(self.mcp_server) if 'app' in attr.lower()]}"
-        )
-        logger.debug(f"🔍 DEBUG: Has http_app: {hasattr(self.mcp_server, 'http_app')}")
-
         if self._mcp_app is not None:
-            logger.debug("🔍 DEBUG: FastMCP app prepared for integration")
-            logger.debug(f"🔍 DEBUG: FastMCP app type: {type(self._mcp_app)}")
-
-            # Debug: Check what routes the FastMCP app has
-            if hasattr(self._mcp_app, "routes"):
-                logger.debug(
-                    f"🔍 DEBUG: FastMCP app routes: {[route.path for route in self._mcp_app.routes if hasattr(route, 'path')]}"
-                )
-
             # Phase 5: Add session routing middleware to FastMCP app
             self._add_session_routing_middleware()
 
@@ -396,10 +376,11 @@ class HttpMcpWrapper:
 
         class MCPSessionRoutingMiddleware(BaseHTTPMiddleware):
             """Clean session routing middleware for MCP requests (v0.4.0 style).
-            
+
             Handles session affinity and basic trace context setup only.
             Function execution tracing is handled by ExecutionTracer in DependencyInjector.
             """
+
             def __init__(self, app, http_wrapper):
                 super().__init__(app)
                 self.http_wrapper = http_wrapper
@@ -455,7 +436,9 @@ class HttpMcpWrapper:
 
         # Add the middleware to FastMCP app
         self._mcp_app.add_middleware(MCPSessionRoutingMiddleware, http_wrapper=self)
-        logger.info("✅ Clean session routing middleware added to FastMCP app (v0.4.0 style)")
+        logger.info(
+            "✅ Clean session routing middleware added to FastMCP app (v0.4.0 style)"
+        )
 
     async def _extract_session_id(self, request) -> str:
         """Extract session ID from request headers or body."""

_mcp_mesh/engine/llm_config.py

@@ -0,0 +1,41 @@
+"""
+LLM configuration dataclass.
+
+Consolidates LLM-related configuration into a single type-safe structure.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class LLMConfig:
+    """
+    Configuration for MeshLlmAgent.
+
+    Consolidates provider, model, and runtime settings into a single type-safe structure.
+    """
+
+    provider: str = "claude"
+    """LLM provider (e.g., 'claude', 'openai', 'gemini')"""
+
+    model: str = "claude-3-5-sonnet-20241022"
+    """Model name for the provider"""
+
+    api_key: str = ""
+    """API key for the provider (uses environment variable if empty)"""
+
+    max_iterations: int = 10
+    """Maximum iterations for the agentic loop"""
+
+    system_prompt: Optional[str] = None
+    """Optional system prompt to prepend to all interactions"""
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if self.max_iterations < 1:
+            raise ValueError("max_iterations must be >= 1")
+        if not self.provider:
+            raise ValueError("provider cannot be empty")
+        if not self.model:
+            raise ValueError("model cannot be empty")

_mcp_mesh/engine/llm_errors.py

@@ -0,0 +1,115 @@
+"""
+Enhanced error classes for LLM engine with structured context.
+
+Provides rich debugging information for better troubleshooting and telemetry.
+"""
+
+from typing import Any, Optional
+
+
+class MaxIterationsError(Exception):
+    """
+    Raised when max iterations are exceeded in agentic loop.
+
+    Attributes:
+        iteration_count: Number of iterations that were attempted
+        max_allowed: Maximum iterations allowed
+        function_id: Optional function ID for debugging
+    """
+
+    def __init__(
+        self,
+        iteration_count: int,
+        max_allowed: int,
+        function_id: Optional[str] = None,
+    ):
+        self.iteration_count = iteration_count
+        self.max_allowed = max_allowed
+        self.function_id = function_id
+
+        message = (
+            f"Exceeded maximum {max_allowed} iterations without reaching final response"
+        )
+        if function_id:
+            message += f" (function_id={function_id})"
+        super().__init__(message)
+
+
+class LLMAPIError(Exception):
+    """
+    Raised when LLM API call fails.
+
+    Attributes:
+        provider: LLM provider name (e.g., 'claude', 'openai')
+        model: Model name
+        original_error: The underlying exception
+        status_code: HTTP status code if available
+    """
+
+    def __init__(
+        self,
+        provider: str,
+        model: str,
+        original_error: Exception,
+        status_code: Optional[int] = None,
+    ):
+        self.provider = provider
+        self.model = model
+        self.original_error = original_error
+        self.status_code = status_code
+
+        message = f"LLM API call failed: {original_error}"
+        if status_code:
+            message = f"LLM API call failed (HTTP {status_code}): {original_error}"
+        message += f" [provider={provider}, model={model}]"
+        super().__init__(message)
+
+
+class ToolExecutionError(Exception):
+    """
+    Raised when a tool execution fails.
+
+    Attributes:
+        tool_name: Name of the tool that failed
+        arguments: Arguments passed to the tool
+        original_error: The underlying exception
+    """
+
+    def __init__(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any],
+        original_error: Exception,
+    ):
+        self.tool_name = tool_name
+        self.arguments = arguments
+        self.original_error = original_error
+
+        message = f"Tool '{tool_name}' execution failed: {original_error}"
+        super().__init__(message)
+
+
+class ResponseParseError(Exception):
+    """
+    Raised when response parsing or validation fails.
+
+    Attributes:
+        raw_content: Raw response content (truncated to 500 chars)
+        expected_schema: Expected Pydantic schema name
+        validation_errors: Pydantic validation errors if available
+    """
+
+    def __init__(
+        self,
+        raw_content: str,
+        expected_schema: str,
+        validation_errors: Optional[str] = None,
+    ):
+        self.raw_content = raw_content[:500]  # Truncate for logging
+        self.expected_schema = expected_schema
+        self.validation_errors = validation_errors
+
+        message = f"Response validation failed for schema '{expected_schema}'"
+        if validation_errors:
+            message += f": {validation_errors}"
+        super().__init__(message)