mcp-mesh 0.7.20__py3-none-any.whl → 0.8.0__py3-none-any.whl

_mcp_mesh/__init__.py

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

_mcp_mesh/engine/dependency_injector.py

@@ -14,12 +14,10 @@ import weakref
 from collections.abc import Callable
 from typing import Any
 
-from ..shared.logging_config import (
-    format_log_value,
-    format_result_summary,
-    get_trace_prefix,
-)
-from .signature_analyzer import get_mesh_agent_positions, has_llm_agent_parameter
+from ..shared.logging_config import (format_log_value, format_result_summary,
+                                     get_trace_prefix)
+from .signature_analyzer import (get_mesh_agent_positions,
+                                 has_llm_agent_parameter)
 
 logger = logging.getLogger(__name__)
 
@@ -29,8 +27,8 @@ def analyze_injection_strategy(func: Callable, dependencies: list[str]) -> list[
     Analyze function signature and determine injection strategy.
 
     Rules:
-    1. Single parameter: inject regardless of typing (with warning if not McpMeshAgent)
-    2. Multiple parameters: only inject into McpMeshAgent typed parameters
+    1. Single parameter: inject regardless of typing (with warning if not McpMeshTool)
+    2. Multiple parameters: only inject into McpMeshTool typed parameters
     3. Log warnings for mismatches and edge cases
 
     Args:
@@ -62,17 +60,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 for clarity)"
+                f"(consider typing as McpMeshTool for clarity)"
             )
         return [0]  # Inject into the single parameter
 
-    # Multiple parameters rule: only inject into McpMeshAgent typed parameters
+    # Multiple parameters rule: only inject into McpMeshTool 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. Skipping injection of {len(dependencies)} dependencies. "
-                f"Consider typing dependency parameters as McpMeshAgent."
+                f"typed as McpMeshTool. Skipping injection of {len(dependencies)} dependencies. "
+                f"Consider typing dependency parameters as McpMeshTool."
             )
             return []
 
@@ -82,7 +80,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 parameters. "
+                    f"but only {len(mesh_positions)} McpMeshTool parameters. "
                     f"Dependencies {excess_deps} will not be injected."
                 )
             else:
@@ -90,7 +88,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 parameters "
+                    f"Function '{func_name}' has {len(mesh_positions)} McpMeshTool parameters "
                     f"but only {len(dependencies)} dependencies declared. "
                     f"Parameters {excess_params} will remain None."
                 )
@@ -106,7 +104,7 @@ class DependencyInjector:
     Manages dynamic dependency injection for mesh agents.
 
     This class:
-    1. Maintains a registry of available dependencies (McpMeshAgent)
+    1. Maintains a registry of available dependencies (McpMeshTool)
     2. Coordinates with MeshLlmAgentInjector for LLM agent injection
     3. Tracks which functions depend on which services
     4. Updates function bindings when topology changes

_mcp_mesh/engine/http_wrapper.py

@@ -387,8 +387,13 @@ class HttpMcpWrapper:
                 self.logger = logger
 
             async def dispatch(self, request: Request, call_next):
-                # Extract and set trace context from headers for distributed tracing
+                # Read body once for processing
+                body = await request.body()
+                modified_body = body
+
+                # Extract and set trace context from headers and arguments
                 try:
+                    from ..tracing.context import TraceContext
                     from ..tracing.trace_context_helper import TraceContextHelper
 
                     # DEBUG: Log incoming headers for trace propagation debugging
@@ -399,22 +404,67 @@ class HttpMcpWrapper:
                         f"X-Parent-Span={parent_span_header}, path={request.url.path}"
                     )
 
-                    # Use helper class for trace context extraction and setup
-                    trace_context = (
-                        await TraceContextHelper.extract_trace_context_from_request(
-                            request
+                    # Extract trace context from both headers AND arguments
+                    trace_id = trace_id_header
+                    parent_span = parent_span_header
+
+                    # Try extracting from JSON-RPC body arguments as fallback
+                    # Also strip trace fields from arguments to avoid Pydantic validation errors
+                    if body:
+                        try:
+                            payload = json.loads(body.decode("utf-8"))
+                            if payload.get("method") == "tools/call":
+                                arguments = payload.get("params", {}).get(
+                                    "arguments", {}
+                                )
+
+                                # Extract trace context from arguments (TypeScript uses _trace_id/_parent_span)
+                                if not trace_id and arguments.get("_trace_id"):
+                                    trace_id = arguments.get("_trace_id")
+                                if not parent_span and arguments.get("_parent_span"):
+                                    parent_span = arguments.get("_parent_span")
+
+                                # Strip trace context fields from arguments before passing to FastMCP
+                                if (
+                                    "_trace_id" in arguments
+                                    or "_parent_span" in arguments
+                                ):
+                                    arguments.pop("_trace_id", None)
+                                    arguments.pop("_parent_span", None)
+                                    # Update payload with cleaned arguments
+                                    modified_body = json.dumps(payload).encode("utf-8")
+                                    self.logger.debug(
+                                        f"🔗 Stripped trace fields from arguments, "
+                                        f"trace_id={trace_id[:8] if trace_id else None}..."
+                                    )
+                        except Exception as e:
+                            self.logger.debug(
+                                f"Failed to process body for trace context: {e}"
+                            )
+
+                    # Setup trace context if we have a trace_id
+                    if trace_id:
+                        trace_context = {
+                            "trace_id": trace_id,
+                            "parent_span": parent_span,
+                        }
+                        TraceContextHelper.setup_request_trace_context(
+                            trace_context, self.logger
                         )
-                    )
-                    TraceContextHelper.setup_request_trace_context(
-                        trace_context, self.logger
-                    )
                 except Exception as e:
                     # Never fail request due to tracing issues
                     self.logger.warning(f"Failed to set trace context: {e}")
                     pass
 
+                # Create a new request scope with the modified body
+                async def receive():
+                    return {"type": "http.request", "body": modified_body}
+
+                # Update request with modified receive
+                request._receive = receive
+
                 # Extract session ID from request
-                session_id = await self.http_wrapper._extract_session_id(request)
+                session_id = await self.http_wrapper._extract_session_id_from_body(body)
 
                 if session_id:
                     # Check for existing session assignment
@@ -458,6 +508,15 @@ class HttpMcpWrapper:
         # Try extracting from JSON-RPC body
         try:
             body = await request.body()
+            return await self._extract_session_id_from_body(body)
+        except Exception:
+            pass
+
+        return None
+
+    async def _extract_session_id_from_body(self, body: bytes) -> str:
+        """Extract session ID from already-read request body."""
+        try:
             if body:
                 payload = json.loads(body.decode("utf-8"))
                 if payload.get("method") == "tools/call":

_mcp_mesh/engine/mesh_llm_agent.py

@@ -636,12 +636,14 @@ IMPORTANT TOOL CALLING RULES:
             # Multi-turn conversation - use provided messages array
             messages = message.copy()
 
-            # 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}
+            # Only add/update system message if we have non-empty content
+            # (Claude API rejects empty system messages - though decorator provides default)
+            if system_content:
+                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}
 
             # Log conversation history
             logger.info(
@@ -649,10 +651,17 @@ IMPORTANT TOOL CALLING RULES:
             )
         else:
             # Single-turn - build messages array from string
-            messages = [
-                {"role": "system", "content": system_content},
-                {"role": "user", "content": message},
-            ]
+            # Only include system message if non-empty (Claude API rejects empty system messages)
+            if system_content:
+                messages = [
+                    {"role": "system", "content": system_content},
+                    {"role": "user", "content": message},
+                ]
+            else:
+                # Fallback for edge case where system_content is explicitly empty
+                messages = [
+                    {"role": "user", "content": message},
+                ]
 
             logger.info(f"🚀 Starting agentic loop for message: {message[:100]}...")
 
@@ -708,6 +717,16 @@ IMPORTANT TOOL CALLING RULES:
                         if self.model:
                             model_params["model"] = self.model
 
+                        # Issue #459: Include output_schema for provider to apply vendor-specific handling
+                        # (e.g., OpenAI needs response_format, not prompt-based JSON instructions)
+                        if self.output_type is not str and hasattr(
+                            self.output_type, "model_json_schema"
+                        ):
+                            model_params["output_schema"] = (
+                                self.output_type.model_json_schema()
+                            )
+                            model_params["output_type_name"] = self.output_type.__name__
+
                         logger.debug(
                             f"📤 Delegating to mesh provider with handler-prepared params: "
                             f"keys={list(model_params.keys())}"

_mcp_mesh/engine/mesh_llm_agent_injector.py

@@ -161,36 +161,70 @@ class MeshLlmAgentInjector(BaseInjector):
         # Create UnifiedMCPProxy for the provider
         provider_proxy = self._create_provider_proxy(provider_data)
 
-        # Update llm_agents data with provider_proxy and vendor (Phase 2)
-        if function_id in self._llm_agents:
-            self._llm_agents[function_id]["provider_proxy"] = provider_proxy
+        # Update only provider-related fields, preserving tool data if already set.
+        # This avoids race conditions where provider and tools updates can arrive in any order.
+        if function_id not in self._llm_agents:
+            self._llm_agents[function_id] = {}
 
-            # Phase 2: Extract vendor from provider_data for handler selection
-            vendor = provider_data.get("vendor", "unknown")
-            self._llm_agents[function_id]["vendor"] = vendor
+        # Phase 2: Extract vendor from provider_data for handler selection
+        vendor = provider_data.get("vendor", "unknown")
 
+        self._llm_agents[function_id]["provider_proxy"] = provider_proxy
+        self._llm_agents[function_id]["vendor"] = vendor
+
+        logger.info(
+            f"✅ Set provider proxy for '{function_id}': {provider_proxy.function_name} at {provider_proxy.endpoint} (vendor={vendor})"
+        )
+
+        # Re-create and update MeshLlmAgent with new provider
+        # Get the function wrapper and metadata from DecoratorRegistry
+        llm_agents = DecoratorRegistry.get_mesh_llm_agents()
+        wrapper = None
+        llm_metadata = None
+        for agent_func_id, metadata in llm_agents.items():
+            if metadata.function_id == function_id:
+                wrapper = metadata.function
+                llm_metadata = metadata
+                break
+
+        # Check if tools are required (filter is specified)
+        has_filter = False
+        if llm_metadata and llm_metadata.config:
+            filter_config = llm_metadata.config.get("filter")
+            has_filter = filter_config is not None and len(filter_config) > 0
+
+        # If no filter specified, initialize empty tools data so we can create LLM agent without tools
+        # This supports simple LLM calls (text generation) that don't need tool calling
+        if not has_filter and "tools_metadata" not in self._llm_agents[function_id]:
+            self._llm_agents[function_id].update(
+                {
+                    "config": llm_metadata.config if llm_metadata else {},
+                    "output_type": llm_metadata.output_type if llm_metadata else None,
+                    "param_name": llm_metadata.param_name if llm_metadata else "llm",
+                    "tools_metadata": [],  # No tools for simple LLM calls
+                    "tools_proxies": {},  # No tool proxies needed
+                    "function": llm_metadata.function if llm_metadata else None,
+                }
+            )
             logger.info(
-                f"✅ Set provider proxy for '{function_id}': {provider_proxy.function_name} at {provider_proxy.endpoint} (vendor={vendor})"
+                f"✅ Initialized empty tools for '{function_id}' (no filter specified - simple LLM mode)"
             )
 
-            # Re-create and update MeshLlmAgent with new provider
-            # Get the function wrapper from DecoratorRegistry
-            llm_agents = DecoratorRegistry.get_mesh_llm_agents()
-            wrapper = None
-            for agent_func_id, metadata in llm_agents.items():
-                if metadata.function_id == function_id:
-                    wrapper = metadata.function
-                    break
-
-            if wrapper and hasattr(wrapper, "_mesh_update_llm_agent"):
-                llm_agent = self._create_llm_agent(function_id)
-                wrapper._mesh_update_llm_agent(llm_agent)
-                logger.info(
-                    f"🔄 Updated wrapper with new MeshLlmAgent (with provider) for '{function_id}'"
-                )
-        else:
-            logger.warning(
-                f"⚠️ Function '{function_id}' not found in _llm_agents, cannot set provider proxy"
+        # Update wrapper if we have tools data (either from filter matching or initialized empty)
+        if (
+            wrapper
+            and hasattr(wrapper, "_mesh_update_llm_agent")
+            and "tools_metadata" in self._llm_agents[function_id]
+        ):
+            llm_agent = self._create_llm_agent(function_id)
+            wrapper._mesh_update_llm_agent(llm_agent)
+            logger.info(
+                f"🔄 Updated wrapper with MeshLlmAgent for '{function_id}'"
+                + (" (with tools)" if has_filter else " (simple LLM mode)")
+            )
+        elif wrapper and hasattr(wrapper, "_mesh_update_llm_agent") and has_filter:
+            logger.debug(
+                f"⏳ Provider set for '{function_id}', waiting for tools before updating wrapper"
             )
 
     def _create_provider_proxy(self, provider_data: dict[str, Any]) -> UnifiedMCPProxy:
@@ -273,21 +307,23 @@ class MeshLlmAgentInjector(BaseInjector):
                 logger.error(f"❌ Error creating proxy for tool {tool_name}: {e}")
                 # Continue processing other tools
 
-        # Provider proxy will be set separately via process_llm_providers()
-        # (v0.6.1 - providers come from llm_providers field, not dependencies)
-        provider_proxy = None
-
-        # Store LLM agent data with both metadata and proxies
-        # Keep original tool metadata for schema building
-        self._llm_agents[function_id] = {
-            "config": llm_metadata.config,
-            "output_type": llm_metadata.output_type,
-            "param_name": llm_metadata.param_name,
-            "tools_metadata": tools,  # Original metadata for schema building
-            "tools_proxies": tool_proxies_map,  # Proxies for execution
-            "function": llm_metadata.function,
-            "provider_proxy": provider_proxy,  # Provider proxy for mesh delegation
-        }
+        # Update only tool-related fields, preserving provider_proxy if already set.
+        # Provider proxy is managed separately by process_llm_providers().
+        # This avoids race conditions where tools update wipes out provider resolution.
+        if function_id not in self._llm_agents:
+            self._llm_agents[function_id] = {}
+
+        self._llm_agents[function_id].update(
+            {
+                "config": llm_metadata.config,
+                "output_type": llm_metadata.output_type,
+                "param_name": llm_metadata.param_name,
+                "tools_metadata": tools,  # Original metadata for schema building
+                "tools_proxies": tool_proxies_map,  # Proxies for execution
+                "function": llm_metadata.function,
+                # Note: provider_proxy is NOT set here - managed by _process_function_provider
+            }
+        )
 
         logger.info(
             f"✅ Processed {len(tool_proxies_map)} tools for LLM function '{function_id}'"
@@ -380,7 +416,7 @@ class MeshLlmAgentInjector(BaseInjector):
         """
         Create wrapper that injects MeshLlmAgent into function parameters.
 
-        Like McpMeshAgent injection, this creates a wrapper at decorator time with llm_agent=None,
+        Like McpMeshTool injection, this creates a wrapper at decorator time with llm_agent=None,
         which gets updated during heartbeat when tools arrive from registry.
 
         Args:

_mcp_mesh/engine/provider_handlers/__init__.py

@@ -5,15 +5,28 @@ This package provides vendor-specific customization for different LLM providers
 (Claude, OpenAI, Gemini, etc.) to optimize API calls and response handling.
 """
 
-from .base_provider_handler import BaseProviderHandler
+from .base_provider_handler import (
+    BASE_TOOL_INSTRUCTIONS,
+    CLAUDE_ANTI_XML_INSTRUCTION,
+    BaseProviderHandler,
+    make_schema_strict,
+)
 from .claude_handler import ClaudeHandler
+from .gemini_handler import GeminiHandler
 from .generic_handler import GenericHandler
 from .openai_handler import OpenAIHandler
 from .provider_handler_registry import ProviderHandlerRegistry
 
 __all__ = [
+    # Constants
+    "BASE_TOOL_INSTRUCTIONS",
+    "CLAUDE_ANTI_XML_INSTRUCTION",
+    # Utilities
+    "make_schema_strict",
+    # Handlers
     "BaseProviderHandler",
     "ClaudeHandler",
+    "GeminiHandler",
     "OpenAIHandler",
     "GenericHandler",
     "ProviderHandlerRegistry",

_mcp_mesh/engine/provider_handlers/base_provider_handler.py

@@ -5,11 +5,117 @@ This module defines the abstract base class for provider-specific handlers
 that customize how different LLM vendors (Claude, OpenAI, Gemini, etc.) are called.
 """
 
+import copy
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
+# ============================================================================
+# Shared Constants
+# ============================================================================
+
+# Base tool calling instructions shared across all providers.
+# Claude handler adds anti-XML instruction on top of this.
+BASE_TOOL_INSTRUCTIONS = """
+IMPORTANT TOOL CALLING RULES:
+- You have access to tools that you can call to gather information
+- Make ONE tool call at a time
+- After receiving tool results, you can make additional calls if needed
+- Once you have all needed information, provide your final response
+"""
+
+# Anti-XML instruction for Claude (prevents <invoke> style tool calls).
+CLAUDE_ANTI_XML_INSTRUCTION = (
+    '- NEVER use XML-style syntax like <invoke name="tool_name"/>'
+)
+
+
+# ============================================================================
+# Shared Schema Utilities
+# ============================================================================
+
+
+def make_schema_strict(
+    schema: dict[str, Any],
+    add_all_required: bool = True,
+) -> dict[str, Any]:
+    """
+    Make a JSON schema strict for structured output.
+
+    This is a shared utility used by OpenAI, Gemini, and Claude handlers.
+    Adds additionalProperties: false to all object types and optionally
+    ensures 'required' includes all property keys.
+
+    Args:
+        schema: JSON schema to make strict
+        add_all_required: If True, set 'required' to include ALL property keys.
+                         OpenAI and Gemini require this; Claude does not.
+                         Default: True
+
+    Returns:
+        New schema with strict constraints (original not mutated)
+    """
+    result = copy.deepcopy(schema)
+    _add_strict_constraints_recursive(result, add_all_required)
+    return result
+
+
+def _add_strict_constraints_recursive(obj: Any, add_all_required: bool) -> None:
+    """
+    Recursively add strict constraints to a schema object.
+
+    Args:
+        obj: Schema object to process (mutated in place)
+        add_all_required: Whether to set required to all property keys
+    """
+    if not isinstance(obj, dict):
+        return
+
+    # If this is an object type, add additionalProperties: false
+    if obj.get("type") == "object":
+        obj["additionalProperties"] = False
+
+        # Optionally set required to include all property keys
+        if add_all_required and "properties" in obj:
+            obj["required"] = list(obj["properties"].keys())
+
+    # Process $defs (Pydantic uses this for nested models)
+    if "$defs" in obj:
+        for def_schema in obj["$defs"].values():
+            _add_strict_constraints_recursive(def_schema, add_all_required)
+
+    # Process properties
+    if "properties" in obj:
+        for prop_schema in obj["properties"].values():
+            _add_strict_constraints_recursive(prop_schema, add_all_required)
+
+    # Process items (for arrays)
+    # items can be an object (single schema) or a list (tuple validation in older drafts)
+    if "items" in obj:
+        items = obj["items"]
+        if isinstance(items, dict):
+            _add_strict_constraints_recursive(items, add_all_required)
+        elif isinstance(items, list):
+            for item in items:
+                _add_strict_constraints_recursive(item, add_all_required)
+
+    # Process prefixItems (tuple validation in JSON Schema draft 2020-12)
+    if "prefixItems" in obj:
+        for item in obj["prefixItems"]:
+            _add_strict_constraints_recursive(item, add_all_required)
+
+    # Process anyOf, oneOf, allOf
+    for key in ("anyOf", "oneOf", "allOf"):
+        if key in obj:
+            for item in obj[key]:
+                _add_strict_constraints_recursive(item, add_all_required)
+
+
+# ============================================================================
+# Base Provider Handler
+# ============================================================================
+
 
 class BaseProviderHandler(ABC):
     """
@@ -43,11 +149,11 @@ class BaseProviderHandler(ABC):
     @abstractmethod
     def prepare_request(
         self,
-        messages: List[Dict[str, Any]],
-        tools: Optional[List[Dict[str, Any]]],
+        messages: list[dict[str, Any]],
+        tools: Optional[list[dict[str, Any]]],
         output_type: type[BaseModel],
-        **kwargs: Any
-    ) -> Dict[str, Any]:
+        **kwargs: Any,
+    ) -> dict[str, Any]:
         """
         Prepare vendor-specific request parameters.
 
@@ -74,8 +180,8 @@ class BaseProviderHandler(ABC):
     def format_system_prompt(
         self,
         base_prompt: str,
-        tool_schemas: Optional[List[Dict[str, Any]]],
-        output_type: type[BaseModel]
+        tool_schemas: Optional[list[dict[str, Any]]],
+        output_type: type[BaseModel],
     ) -> str:
         """
         Format system prompt for vendor-specific requirements.
@@ -95,7 +201,7 @@ class BaseProviderHandler(ABC):
         """
         pass
 
-    def get_vendor_capabilities(self) -> Dict[str, bool]:
+    def get_vendor_capabilities(self) -> dict[str, bool]:
         """
         Return vendor-specific capability flags.