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

_mcp_mesh/__init__.py

@@ -31,7 +31,7 @@ from .engine.decorator_registry import (
     get_decorator_stats,
 )
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"
 
 # Store reference to runtime processor if initialized
 _runtime_processor = None

_mcp_mesh/engine/decorator_registry.py

@@ -117,11 +117,13 @@ class DecoratorRegistry:
         if func_name in cls._mesh_tools:
             old_func = cls._mesh_tools[func_name].function
             cls._mesh_tools[func_name].function = new_func
-            print(
+            logger.debug(
                 f"🔄 DecoratorRegistry: Updated '{func_name}' from {hex(id(old_func))} to {hex(id(new_func))}"
             )
         else:
-            print(f"⚠️ DecoratorRegistry: Function '{func_name}' not found for update")
+            logger.debug(
+                f"⚠️ DecoratorRegistry: Function '{func_name}' not found for update"
+            )
 
     @classmethod
     def register_mesh_resource(cls, func: Callable, metadata: dict[str, Any]) -> None:
@@ -623,6 +625,28 @@ class DecoratorRegistry:
         cls._immediate_uvicorn_server = None
         logger.debug("🔄 REGISTRY: Cleared immediate uvicorn server reference")
 
+    # Health check result storage
+    _health_check_result: dict | None = None
+
+    @classmethod
+    def store_health_check_result(cls, result: dict) -> None:
+        """Store health check result for /health endpoint."""
+        cls._health_check_result = result
+        logger.debug(
+            f"💾 REGISTRY: Stored health check result: {result.get('status', 'unknown')}"
+        )
+
+    @classmethod
+    def get_health_check_result(cls) -> dict | None:
+        """Get stored health check result."""
+        return cls._health_check_result
+
+    @classmethod
+    def clear_health_check_result(cls) -> None:
+        """Clear stored health check result."""
+        cls._health_check_result = None
+        logger.debug("🗑️ REGISTRY: Cleared health check result")
+
     @classmethod
     def store_fastmcp_lifespan(cls, lifespan: Any) -> None:
         """

_mcp_mesh/engine/dependency_injector.py

@@ -132,7 +132,7 @@ class DependencyInjector:
             instance: Proxy instance to register
         """
         async with self._lock:
-            logger.info(f"📦 Registering dependency: {name}")
+            logger.debug(f"📦 Registering dependency: {name}")
             self._dependencies[name] = instance
 
             # Notify all functions that depend on this (using composite keys)
@@ -302,6 +302,19 @@ class DependencyInjector:
         )
         self._llm_injector.process_llm_tools(llm_tools)
 
+    def process_llm_providers(self, llm_providers: dict[str, dict[str, Any]]) -> None:
+        """
+        Process llm_providers from registry response and delegate to MeshLlmAgentInjector (v0.6.1).
+
+        Args:
+            llm_providers: Dict mapping function_name -> ResolvedLLMProvider
+                          Format: {"function_name": {"agent_id": "...", "endpoint": "...", ...}}
+        """
+        logger.info(
+            f"🔌 DependencyInjector processing llm_providers for {len(llm_providers)} functions"
+        )
+        self._llm_injector.process_llm_providers(llm_providers)
+
     def update_llm_tools(self, llm_tools: dict[str, list[dict[str, Any]]]) -> None:
         """
         Update llm_tools when topology changes (heartbeat updates).

_mcp_mesh/engine/llm_config.py

@@ -5,7 +5,7 @@ Consolidates LLM-related configuration into a single type-safe structure.
 """
 
 from dataclasses import dataclass
-from typing import Optional
+from typing import Any, Dict, Optional, Union
 
 
 @dataclass
@@ -14,16 +14,18 @@ class LLMConfig:
     Configuration for MeshLlmAgent.
 
     Consolidates provider, model, and runtime settings into a single type-safe structure.
+    Supports both direct LiteLLM providers (string) and mesh delegation (dict).
     """
 
-    provider: str = "claude"
-    """LLM provider (e.g., 'claude', 'openai', 'gemini')"""
+    provider: Union[str, Dict[str, Any]] = "claude"
+    """LLM provider - string for direct LiteLLM (e.g., 'claude', 'openai') or dict for mesh delegation
+       Mesh delegation format: {"capability": "llm", "tags": ["claude"], "version": ">=1.0.0"}"""
 
     model: str = "claude-3-5-sonnet-20241022"
-    """Model name for the provider"""
+    """Model name for the provider (only used with string provider for direct LiteLLM)"""
 
     api_key: str = ""
-    """API key for the provider (uses environment variable if empty)"""
+    """API key for the provider (uses environment variable if empty, only used with string provider)"""
 
     max_iterations: int = 10
     """Maximum iterations for the agentic loop"""
@@ -37,5 +39,7 @@ class LLMConfig:
             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")
+
+        # Only validate model for string providers (not needed for mesh delegation)
+        if isinstance(self.provider, str) and not self.model:
+            raise ValueError("model cannot be empty when using string provider")

_mcp_mesh/engine/mesh_llm_agent.py

@@ -8,7 +8,7 @@ import asyncio
 import json
 import logging
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
@@ -19,6 +19,7 @@ from .llm_errors import (
     ResponseParseError,
     ToolExecutionError,
 )
+from .provider_handlers import ProviderHandlerRegistry
 from .response_parser import ResponseParser
 from .tool_executor import ToolExecutor
 from .tool_schema_builder import ToolSchemaBuilder
@@ -61,6 +62,8 @@ class MeshLlmAgent:
         tool_proxies: Optional[dict[str, Any]] = None,
         template_path: Optional[str] = None,
         context_value: Optional[Any] = None,
+        provider_proxy: Optional[Any] = None,
+        vendor: Optional[str] = None,
     ):
         """
         Initialize MeshLlmAgent proxy.
@@ -72,6 +75,8 @@ class MeshLlmAgent:
             tool_proxies: Optional map of function_name -> proxy for tool execution
             template_path: Optional path to Jinja2 template file for system prompt
             context_value: Optional context for template rendering (MeshContextModel, dict, or None)
+            provider_proxy: Optional pre-resolved provider proxy for mesh delegation
+            vendor: Optional vendor name for handler selection (e.g., "anthropic", "openai")
         """
         self.config = config
         self.provider = config.provider
@@ -84,6 +89,10 @@ class MeshLlmAgent:
         self.system_prompt = config.system_prompt  # Public attribute for tests
         self._iteration_count = 0
 
+        # Detect if using mesh delegation (provider is dict)
+        self._is_mesh_delegated = isinstance(self.provider, dict)
+        self._mesh_provider_proxy = provider_proxy  # Pre-resolved by heartbeat
+
         # Template rendering support (Phase 3)
         self._template_path = template_path
         self._context_value = context_value
@@ -96,7 +105,15 @@ class MeshLlmAgent:
         # Build tool schemas for LLM (OpenAI format used by LiteLLM)
         self._tool_schemas = ToolSchemaBuilder.build_schemas(self.tools_metadata)
 
-        # Cache tool calling instructions to prevent XML-style invocations
+        # Phase 2: Get provider-specific handler
+        # This enables vendor-optimized behavior (e.g., OpenAI response_format)
+        self._provider_handler = ProviderHandlerRegistry.get_handler(vendor)
+        logger.debug(
+            f"🎯 Using provider handler: {self._provider_handler} for vendor: {vendor}"
+        )
+
+        # DEPRECATED: Legacy cached instructions (now handled by provider handlers)
+        # Kept for backward compatibility with tests
         self._cached_tool_instructions = """
 
 IMPORTANT TOOL CALLING RULES:
@@ -109,8 +126,6 @@ IMPORTANT TOOL CALLING RULES:
 - Once you have gathered all necessary information, provide your final response
 """
 
-        # Cache JSON schema instructions (output_type never changes after init)
-        # This avoids regenerating the schema on every __call__
         schema = self.output_type.model_json_schema()
         schema_str = json.dumps(schema, indent=2)
         self._cached_json_instructions = (
@@ -120,7 +135,7 @@ IMPORTANT TOOL CALLING RULES:
 
         logger.debug(
             f"🤖 MeshLlmAgent initialized: provider={config.provider}, model={config.model}, "
-            f"tools={len(filtered_tools)}, max_iterations={config.max_iterations}"
+            f"tools={len(filtered_tools)}, max_iterations={config.max_iterations}, handler={self._provider_handler}"
         )
 
     def set_system_prompt(self, prompt: str) -> None:
@@ -205,9 +220,7 @@ IMPORTANT TOOL CALLING RULES:
             return {}
 
         # Check if it's a MeshContextModel (has model_dump method)
-        if hasattr(context_value, "model_dump") and callable(
-            context_value.model_dump
-        ):
+        if hasattr(context_value, "model_dump") and callable(context_value.model_dump):
             return context_value.model_dump()
 
         # Check if it's a dict
@@ -254,12 +267,153 @@ IMPORTANT TOOL CALLING RULES:
         # Otherwise, use literal system prompt from config
         return self.system_prompt or ""
 
-    async def __call__(self, message: str, **kwargs) -> Any:
+    async def _get_mesh_provider(self) -> Any:
+        """
+        Get the mesh provider proxy (already resolved during heartbeat).
+
+        Returns:
+            UnifiedMCPProxy for the mesh provider agent
+
+        Raises:
+            RuntimeError: If provider proxy not resolved
+        """
+        if self._mesh_provider_proxy is None:
+            raise RuntimeError(
+                f"Mesh provider not resolved. Provider filter: {self.provider}. "
+                f"The provider should have been resolved during heartbeat. "
+                f"Check that a matching provider is registered in the mesh."
+            )
+
+        return self._mesh_provider_proxy
+
+    async def _call_mesh_provider(
+        self, messages: list, tools: list | None = None, **kwargs
+    ) -> Any:
+        """
+        Call mesh-delegated LLM provider agent.
+
+        Args:
+            messages: List of message dicts
+            tools: Optional list of tool schemas
+            **kwargs: Additional model parameters
+
+        Returns:
+            LiteLLM-compatible response object
+
+        Raises:
+            RuntimeError: If provider proxy not available or invocation fails
+        """
+        # Get the pre-resolved provider proxy
+        provider_proxy = await self._get_mesh_provider()
+
+        # Import MeshLlmRequest type
+        from mesh.types import MeshLlmRequest
+
+        # Build MeshLlmRequest
+        request = MeshLlmRequest(
+            messages=messages, tools=tools, model_params=kwargs if kwargs else None
+        )
+
+        logger.debug(
+            f"📤 Delegating to mesh provider: {len(messages)} messages, {len(tools) if tools else 0} tools"
+        )
+
+        # Call provider's process_chat tool
+        try:
+            # provider_proxy is UnifiedMCPProxy, call it with request dict
+            # Convert dataclass to dict for MCP call
+            request_dict = {
+                "messages": request.messages,
+                "tools": request.tools,
+                "model_params": request.model_params,
+                "context": request.context,
+                "request_id": request.request_id,
+                "caller_agent": request.caller_agent,
+            }
+
+            result = await provider_proxy(request=request_dict)
+
+            # Result is a message dict with content, role, and optionally tool_calls
+            # Parse it to create LiteLLM-compatible response
+            message_dict = result
+
+            # Create mock LiteLLM response structure
+            # This mimics litellm.completion() response format
+            class MockToolCall:
+                """Mock tool call object matching LiteLLM structure."""
+
+                def __init__(self, tc_dict):
+                    self.id = tc_dict["id"]
+                    self.type = tc_dict["type"]
+                    # Create function object
+                    self.function = type(
+                        "Function",
+                        (),
+                        {
+                            "name": tc_dict["function"]["name"],
+                            "arguments": tc_dict["function"]["arguments"],
+                        },
+                    )()
+
+            class MockMessage:
+                def __init__(self, message_dict):
+                    self.content = message_dict.get("content")
+                    self.role = message_dict.get("role", "assistant")
+                    # Extract tool_calls if present (critical for agentic loop!)
+                    self.tool_calls = None
+                    if "tool_calls" in message_dict and message_dict["tool_calls"]:
+                        self.tool_calls = [
+                            MockToolCall(tc) for tc in message_dict["tool_calls"]
+                        ]
+
+                def model_dump(self):
+                    dump = {"role": self.role, "content": self.content}
+                    if self.tool_calls:
+                        dump["tool_calls"] = [
+                            {
+                                "id": tc.id,
+                                "type": tc.type,
+                                "function": {
+                                    "name": tc.function.name,
+                                    "arguments": tc.function.arguments,
+                                },
+                            }
+                            for tc in self.tool_calls
+                        ]
+                    return dump
+
+            class MockChoice:
+                def __init__(self, message):
+                    self.message = message
+                    self.finish_reason = "stop"
+
+            class MockResponse:
+                def __init__(self, message_dict):
+                    self.choices = [MockChoice(MockMessage(message_dict))]
+
+            logger.debug(
+                f"📥 Received response from mesh provider: "
+                f"content={message_dict.get('content', '')[:200]}..., "
+                f"tool_calls={len(message_dict.get('tool_calls', []))}"
+            )
+
+            return MockResponse(message_dict)
+
+        except Exception as e:
+            logger.error(f"❌ Mesh provider call failed: {e}")
+            raise RuntimeError(f"Mesh LLM provider invocation failed: {e}") from e
+
+    async def __call__(
+        self, message: Union[str, list[dict[str, Any]]], **kwargs
+    ) -> Any:
         """
         Execute automatic agentic loop and return typed response.
 
         Args:
-            message: User message to process
+            message: Either:
+                - str: Single user message (will be wrapped in messages array)
+                - List[Dict[str, Any]]: Full conversation history with messages
+                  in format [{"role": "user|assistant|system", "content": "..."}]
             **kwargs: Additional arguments passed to LLM
 
         Returns:
@@ -278,29 +432,46 @@ IMPORTANT TOOL CALLING RULES:
                 "litellm is required for MeshLlmAgent. Install with: pip install litellm"
             )
 
-        # Build initial messages
-        messages = []
-
-        # Render system prompt (from template or literal)
+        # Render base system prompt (from template or literal)
         base_system_prompt = self._render_system_prompt()
 
-        # Build system prompt with tool calling and JSON schema instructions
-        system_content = base_system_prompt
+        # Phase 2: Use provider handler to format system prompt
+        # This allows vendor-specific optimizations (e.g., OpenAI skips JSON instructions)
+        system_content = self._provider_handler.format_system_prompt(
+            base_prompt=base_system_prompt,
+            tool_schemas=self._tool_schemas,
+            output_type=self.output_type,
+        )
 
-        # Add tool calling instructions if tools are available
-        if self._tool_schemas:
-            system_content += self._cached_tool_instructions
+        # Debug: Log system prompt (truncated for privacy)
+        logger.debug(
+            f"📝 System prompt (formatted by {self._provider_handler}): {system_content[:200]}..."
+        )
 
-        # Add JSON schema instructions for final response
-        system_content += self._cached_json_instructions
+        # Build messages array based on input type
+        if isinstance(message, list):
+            # Multi-turn conversation - use provided messages array
+            messages = message.copy()
 
-        # Debug: Log system prompt (truncated for privacy)
-        logger.debug(f"📝 System prompt: {system_content[:200]}...")
+            # Ensure system prompt is prepended if not already present
+            if not messages or messages[0].get("role") != "system":
+                messages.insert(0, {"role": "system", "content": system_content})
+            else:
+                # Replace existing system message with our constructed one
+                messages[0] = {"role": "system", "content": system_content}
 
-        messages.append({"role": "system", "content": system_content})
-        messages.append({"role": "user", "content": message})
+            # Log conversation history
+            logger.info(
+                f"🚀 Starting agentic loop with {len(messages)} messages in history"
+            )
+        else:
+            # Single-turn - build messages array from string
+            messages = [
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": message},
+            ]
 
-        logger.info(f"🚀 Starting agentic loop for message: {message[:100]}...")
+            logger.info(f"🚀 Starting agentic loop for message: {message[:100]}...")
 
         # Agentic loop
         while self._iteration_count < self.max_iterations:
@@ -310,21 +481,61 @@ IMPORTANT TOOL CALLING RULES:
             )
 
             try:
-                # Call LLM with tools
+                # Call LLM (either direct LiteLLM or mesh-delegated)
                 try:
-                    response = await asyncio.to_thread(
-                        completion,
-                        model=self.model,
-                        messages=messages,
-                        tools=self._tool_schemas if self._tool_schemas else None,
-                        api_key=self.api_key,
-                        **kwargs,
-                    )
+                    if self._is_mesh_delegated:
+                        # Mesh delegation: use provider handler to prepare vendor-specific request
+                        # Phase 2: Handler prepares params including response_format for OpenAI, etc.
+                        request_params = self._provider_handler.prepare_request(
+                            messages=messages,
+                            tools=self._tool_schemas if self._tool_schemas else None,
+                            output_type=self.output_type,
+                            **kwargs,
+                        )
+
+                        # Extract model_params to send to provider
+                        # Don't send messages/tools (already separate params) or model/api_key (provider has them)
+                        model_params = {
+                            k: v
+                            for k, v in request_params.items()
+                            if k not in ["messages", "tools", "model", "api_key"]
+                        }
+
+                        logger.debug(
+                            f"📤 Delegating to mesh provider with handler-prepared params: "
+                            f"keys={list(model_params.keys())}"
+                        )
+
+                        response = await self._call_mesh_provider(
+                            messages=messages,
+                            tools=self._tool_schemas if self._tool_schemas else None,
+                            **model_params,  # Now includes response_format!
+                        )
+                    else:
+                        # Direct LiteLLM call
+                        # Phase 2: Use provider handler to prepare vendor-specific request
+                        request_params = self._provider_handler.prepare_request(
+                            messages=messages,
+                            tools=self._tool_schemas if self._tool_schemas else None,
+                            output_type=self.output_type,
+                            **kwargs,
+                        )
+
+                        # Add model and API key (common to all vendors)
+                        request_params["model"] = self.model
+                        request_params["api_key"] = self.api_key
+
+                        logger.debug(
+                            f"📤 Calling LLM with handler-prepared params: "
+                            f"keys={list(request_params.keys())}"
+                        )
+
+                        response = await asyncio.to_thread(completion, **request_params)
                 except Exception as e:
                     # Any exception from completion call is an LLM API error
                     logger.error(f"❌ LLM API error: {e}")
                     raise LLMAPIError(
-                        provider=self.provider,
+                        provider=str(self.provider),
                         model=self.model,
                         original_error=e,
                     ) from e
@@ -359,31 +570,6 @@ IMPORTANT TOOL CALLING RULES:
                     f"📥 Raw LLM response: {assistant_message.content[:500]}..."
                 )
 
-                # REMOVE_LATER: Debug full LLM response
-                logger.warning(
-                    f"🔍 REMOVE_LATER: assistant_message type: {type(assistant_message)}"
-                )
-                logger.warning(
-                    f"🔍 REMOVE_LATER: assistant_message.content type: {type(assistant_message.content)}"
-                )
-                logger.warning(
-                    f"🔍 REMOVE_LATER: assistant_message.content is None: {assistant_message.content is None}"
-                )
-                if assistant_message.content:
-                    logger.warning(
-                        f"🔍 REMOVE_LATER: Full LLM response length: {len(assistant_message.content)}"
-                    )
-                    logger.warning(
-                        f"🔍 REMOVE_LATER: Full LLM response: {assistant_message.content!r}"
-                    )
-                else:
-                    logger.warning(
-                        "🔍 REMOVE_LATER: assistant_message.content is empty or None!"
-                    )
-                    logger.warning(
-                        f"🔍 REMOVE_LATER: Full assistant_message: {assistant_message}"
-                    )
-
                 return self._parse_response(assistant_message.content)
 
             except LLMAPIError: