mcp-mesh 0.6.3__tar.gz → 0.7.0__tar.gz

{mcp_mesh-0.6.3 → mcp_mesh-0.7.0}/.gitignore

@@ -180,7 +180,7 @@ capability_store/
 # Go binaries
 mcp-mesh-dev
 /mcp-mesh-registry
-meshctl
+/meshctl
 bin/meshctl
 *.exe
 *.dll

{mcp_mesh-0.6.3 → mcp_mesh-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.6.3
+Version: 0.7.0
 Summary: Kubernetes-native platform for distributed MCP applications
 Project-URL: Homepage, https://github.com/dhyansraj/mcp-mesh
 Project-URL: Documentation, https://github.com/dhyansraj/mcp-mesh/tree/main/docs
@@ -23,10 +23,13 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.11
 Requires-Dist: aiohttp<4.0.0,>=3.8.0
+Requires-Dist: cachetools>=5.3.0
 Requires-Dist: click<9.0.0,>=8.1.0
 Requires-Dist: fastapi<1.0.0,>=0.104.0
 Requires-Dist: fastmcp<3.0.0,>=2.8.0
 Requires-Dist: httpx<1.0.0,>=0.25.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: litellm>=1.30.0
 Requires-Dist: mcp<2.0.0,>=1.9.0
 Requires-Dist: prometheus-client<1.0.0,>=0.19.0
 Requires-Dist: pydantic<3.0.0,>=2.4.0

{mcp_mesh-0.6.3 → mcp_mesh-0.7.0}/_mcp_mesh/__init__.py

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

{mcp_mesh-0.6.3 → mcp_mesh-0.7.0}/_mcp_mesh/engine/decorator_registry.py

@@ -38,7 +38,7 @@ class LLMAgentMetadata:
 
     function: Callable
     config: dict[str, Any]  # LLM configuration (provider, model, filter, etc.)
-    output_type: Optional[type]  # Pydantic model type from return annotation
+    output_type: type | None  # Pydantic model type from return annotation
     param_name: str  # Name of MeshLlmAgent parameter
     function_id: str  # Unique function ID for registry
     registered_at: datetime
@@ -70,16 +70,55 @@ class DecoratorRegistry:
     _custom_decorators: dict[str, dict[str, DecoratedFunction]] = {}
 
     # Immediate uvicorn server storage (for preventing shutdown state)
-    _immediate_uvicorn_server: Optional[dict[str, Any]] = None
+    _immediate_uvicorn_server: dict[str, Any] | None = None
 
     # FastMCP lifespan storage (for proper integration with FastAPI)
-    _fastmcp_lifespan: Optional[Any] = None
+    _fastmcp_lifespan: Any | None = None
 
     # FastMCP HTTP app storage (the same app instance whose lifespan was extracted)
-    _fastmcp_http_app: Optional[Any] = None
+    _fastmcp_http_app: Any | None = None
 
     # FastMCP server info storage (for schema extraction during heartbeat)
-    _fastmcp_server_info: Optional[dict[str, Any]] = None
+    _fastmcp_server_info: dict[str, Any] | None = None
+
+    # Route-to-wrapper mapping for @mesh.route dependency injection
+    # Key: "METHOD:path" (e.g., "GET:/api/v1/benchmark-services")
+    # Value: {"wrapper": Callable, "dependencies": list[str]}
+    _route_wrapper_registry: dict[str, dict[str, Any]] = {}
+
+    @classmethod
+    def register_route_wrapper(
+        cls, method: str, path: str, wrapper: Callable, dependencies: list[str]
+    ) -> None:
+        """
+        Register a route's wrapper function for dependency injection.
+
+        Args:
+            method: HTTP method (e.g., "GET", "POST")
+            path: Route path (e.g., "/api/v1/benchmark-services")
+            wrapper: The injection wrapper function
+            dependencies: List of dependency capability names
+        """
+        route_id = f"{method}:{path}"
+        cls._route_wrapper_registry[route_id] = {
+            "wrapper": wrapper,
+            "dependencies": dependencies,
+            "method": method,
+            "path": path,
+        }
+        logger.debug(
+            f"📝 Registered route wrapper: {route_id} with {len(dependencies)} dependencies"
+        )
+
+    @classmethod
+    def get_route_wrapper(cls, route_id: str) -> dict[str, Any] | None:
+        """Get route wrapper info by route ID (METHOD:path)."""
+        return cls._route_wrapper_registry.get(route_id)
+
+    @classmethod
+    def get_all_route_wrappers(cls) -> dict[str, dict[str, Any]]:
+        """Get all registered route wrappers."""
+        return cls._route_wrapper_registry.copy()
 
     @classmethod
     def register_mesh_agent(cls, func: Callable, metadata: dict[str, Any]) -> None:
@@ -154,7 +193,7 @@ class DecoratorRegistry:
         cls,
         func: Callable,
         config: dict[str, Any],
-        output_type: Optional[type],
+        output_type: type | None,
         param_name: str,
         function_id: str,
     ) -> None:
@@ -355,7 +394,7 @@ class DecoratorRegistry:
         return stats
 
     # Cache for resolved agent configuration to avoid repeated work
-    _cached_agent_config: Optional[dict[str, Any]] = None
+    _cached_agent_config: dict[str, Any] | None = None
 
     @classmethod
     def update_agent_config(cls, updates: dict[str, Any]) -> None:
@@ -610,7 +649,7 @@ class DecoratorRegistry:
         )
 
     @classmethod
-    def get_immediate_uvicorn_server(cls) -> Optional[dict[str, Any]]:
+    def get_immediate_uvicorn_server(cls) -> dict[str, Any] | None:
         """
         Get stored immediate uvicorn server reference.
 
@@ -659,7 +698,7 @@ class DecoratorRegistry:
         logger.debug("🔄 REGISTRY: Stored FastMCP lifespan for FastAPI integration")
 
     @classmethod
-    def get_fastmcp_lifespan(cls) -> Optional[Any]:
+    def get_fastmcp_lifespan(cls) -> Any | None:
         """
         Get stored FastMCP lifespan.
 
@@ -686,7 +725,7 @@ class DecoratorRegistry:
         logger.debug("🔄 REGISTRY: Stored FastMCP HTTP app for mounting")
 
     @classmethod
-    def get_fastmcp_http_app(cls) -> Optional[Any]:
+    def get_fastmcp_http_app(cls) -> Any | None:
         """
         Get stored FastMCP HTTP app.
 
@@ -715,7 +754,7 @@ class DecoratorRegistry:
         )
 
     @classmethod
-    def get_fastmcp_server_info(cls) -> Optional[dict[str, Any]]:
+    def get_fastmcp_server_info(cls) -> dict[str, Any] | None:
         """
         Get stored FastMCP server info.
 

{mcp_mesh-0.6.3 → mcp_mesh-0.7.0}/_mcp_mesh/engine/http_wrapper.py

@@ -132,7 +132,7 @@ class HttpMcpWrapper:
 
         # Phase 3: Metadata caching
         self._metadata_cache: dict[str, Any] = {}
-        self._cache_timestamp: Optional[datetime] = None
+        self._cache_timestamp: datetime | None = None
         self._cache_ttl: timedelta = timedelta(minutes=5)  # Cache for 5 minutes
 
         # Phase 5: Session storage and pod info
@@ -254,7 +254,7 @@ class HttpMcpWrapper:
         self._cache_timestamp = datetime.now()
         logger.debug(f"📋 Metadata cache updated with {len(metadata)} entries")
 
-    def get_cached_metadata(self) -> Optional[dict[str, Any]]:
+    def get_cached_metadata(self) -> dict[str, Any] | None:
         """Get cached metadata if available and valid."""
         if self._is_cache_valid():
             logger.debug("✅ Returning cached metadata")
@@ -391,6 +391,14 @@ class HttpMcpWrapper:
                 try:
                     from ..tracing.trace_context_helper import TraceContextHelper
 
+                    # DEBUG: Log incoming headers for trace propagation debugging
+                    trace_id_header = request.headers.get("X-Trace-ID")
+                    parent_span_header = request.headers.get("X-Parent-Span")
+                    self.logger.info(
+                        f"🔍 INCOMING_HEADERS: X-Trace-ID={trace_id_header}, "
+                        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(

{mcp_mesh-0.6.3 → mcp_mesh-0.7.0}/_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, Dict, List, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel
 
@@ -41,6 +41,9 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
+# Sentinel value to distinguish "context not provided" from "explicitly None/empty"
+_CONTEXT_NOT_PROVIDED = object()
+
 
 class MeshLlmAgent:
     """
@@ -241,7 +244,56 @@ IMPORTANT TOOL CALLING RULES:
             f"Expected MeshContextModel, dict, or None."
         )
 
-    def _render_system_prompt(self) -> str:
+    def _resolve_context(
+        self,
+        runtime_context: Union[dict, None, object],
+        context_mode: Literal["replace", "append", "prepend"],
+    ) -> dict:
+        """
+        Resolve effective context for template rendering.
+
+        Merges auto-populated context (from decorator's context_param) with
+        runtime context passed to __call__(), based on the context_mode.
+
+        Args:
+            runtime_context: Context passed at call time, or _CONTEXT_NOT_PROVIDED
+            context_mode: How to merge contexts - "replace", "append", or "prepend"
+
+        Returns:
+            Resolved context dictionary for template rendering
+
+        Behavior:
+            - If runtime_context is _CONTEXT_NOT_PROVIDED: use auto-populated context
+            - If context_mode is "replace": use runtime_context entirely
+            - If context_mode is "append": auto_context | runtime_context (runtime wins)
+            - If context_mode is "prepend": runtime_context | auto_context (auto wins)
+
+        Note:
+            Empty dict {} with "replace" mode explicitly clears context.
+            Empty dict {} with "append"/"prepend" is a no-op (keeps auto context).
+        """
+        # Get auto-populated context from decorator
+        auto_context = self._prepare_context(self._context_value)
+
+        # If no runtime context provided, use auto-populated context unchanged
+        if runtime_context is _CONTEXT_NOT_PROVIDED:
+            return auto_context
+
+        # Prepare runtime context (handles MeshContextModel, dict, None)
+        runtime_dict = self._prepare_context(runtime_context)
+
+        # Apply context_mode
+        if context_mode == "replace":
+            # Replace entirely with runtime context (even if empty)
+            return runtime_dict
+        elif context_mode == "prepend":
+            # Runtime first, auto overwrites (auto wins on conflicts)
+            return {**runtime_dict, **auto_context}
+        else:  # "append" (default)
+            # Auto first, runtime overwrites (runtime wins on conflicts)
+            return {**auto_context, **runtime_dict}
+
+    def _render_system_prompt(self, effective_context: Optional[dict] = None) -> str:
         """
         Render system prompt from template or return literal.
 
@@ -249,6 +301,10 @@ IMPORTANT TOOL CALLING RULES:
         If system_prompt was set via set_system_prompt(), uses that override.
         Otherwise, uses config.system_prompt as literal.
 
+        Args:
+            effective_context: Optional pre-resolved context dict for template rendering.
+                               If None, uses auto-populated _context_value.
+
         Returns:
             Rendered system prompt string
 
@@ -261,7 +317,12 @@ IMPORTANT TOOL CALLING RULES:
 
         # If template provided, render it
         if self._template is not None:
-            context = self._prepare_context(self._context_value)
+            # Use provided effective_context or fall back to auto-populated context
+            context = (
+                effective_context
+                if effective_context is not None
+                else self._prepare_context(self._context_value)
+            )
             try:
                 rendered = self._template.render(**context)
                 logger.debug(
@@ -412,7 +473,12 @@ IMPORTANT TOOL CALLING RULES:
             raise RuntimeError(f"Mesh LLM provider invocation failed: {e}") from e
 
     async def __call__(
-        self, message: Union[str, list[dict[str, Any]]], **kwargs
+        self,
+        message: Union[str, list[dict[str, Any]]],
+        *,
+        context: Union[dict, None, object] = _CONTEXT_NOT_PROVIDED,
+        context_mode: Literal["replace", "append", "prepend"] = "append",
+        **kwargs,
     ) -> Any:
         """
         Execute automatic agentic loop and return typed response.
@@ -422,6 +488,13 @@ IMPORTANT TOOL CALLING RULES:
                 - 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": "..."}]
+            context: Optional runtime context for system prompt template rendering.
+                     Can be dict, MeshContextModel, or None. If not provided,
+                     uses the auto-populated context from decorator's context_param.
+            context_mode: How to merge runtime context with auto-populated context:
+                - "append" (default): auto_context | runtime_context (runtime wins on conflicts)
+                - "prepend": runtime_context | auto_context (auto wins on conflicts)
+                - "replace": use runtime_context entirely (ignores auto-populated)
             **kwargs: Additional arguments passed to LLM
 
         Returns:
@@ -431,6 +504,22 @@ IMPORTANT TOOL CALLING RULES:
             MaxIterationsError: If max iterations exceeded
             ToolExecutionError: If tool execution fails
             ValidationError: If response doesn't match output_type schema
+
+        Examples:
+            # Use auto-populated context (default behavior)
+            result = await llm("What is the answer?")
+
+            # Append extra context (runtime wins on key conflicts)
+            result = await llm("What is the answer?", context={"extra": "info"})
+
+            # Prepend context (auto wins on key conflicts)
+            result = await llm("What is the answer?", context={"extra": "info"}, context_mode="prepend")
+
+            # Replace context entirely
+            result = await llm("What is the answer?", context={"only": "this"}, context_mode="replace")
+
+            # Explicitly clear context
+            result = await llm("What is the answer?", context={}, context_mode="replace")
         """
         self._iteration_count = 0
 
@@ -440,8 +529,11 @@ IMPORTANT TOOL CALLING RULES:
                 "litellm is required for MeshLlmAgent. Install with: pip install litellm"
             )
 
-        # Render base system prompt (from template or literal)
-        base_system_prompt = self._render_system_prompt()
+        # Resolve effective context (merge auto-populated with runtime context)
+        effective_context = self._resolve_context(context, context_mode)
+
+        # Render base system prompt (from template or literal) with effective context
+        base_system_prompt = self._render_system_prompt(effective_context)
 
         # Phase 2: Use provider handler to format system prompt
         # This allows vendor-specific optimizations (e.g., OpenAI skips JSON instructions)

{mcp_mesh-0.6.3 → mcp_mesh-0.7.0}/_mcp_mesh/engine/unified_mcp_proxy.py

@@ -29,7 +29,7 @@ class UnifiedMCPProxy:
     """
 
     def __init__(
-        self, endpoint: str, function_name: str, kwargs_config: Optional[dict] = None
+        self, endpoint: str, function_name: str, kwargs_config: dict | None = None
     ):
         """Initialize Unified MCP Proxy.
 
@@ -134,12 +134,20 @@ class UnifiedMCPProxy:
                     "X-Trace-ID": current_trace.trace_id,
                     "X-Parent-Span": current_trace.span_id,  # Current span becomes parent for downstream
                 }
+                self.logger.info(
+                    f"🔗 TRACE_PROPAGATION: Injecting headers trace_id={current_trace.trace_id[:8]}... "
+                    f"parent_span={current_trace.span_id[:8]}..."
+                )
                 return headers
             else:
+                self.logger.warning("🔗 TRACE_PROPAGATION: No trace context available")
                 return {}
 
         except Exception as e:
             # Never fail MCP calls due to tracing issues
+            self.logger.warning(
+                f"🔗 TRACE_PROPAGATION: Exception getting trace context: {e}"
+            )
             return {}
 
     def _configure_from_kwargs(self):
@@ -826,7 +834,7 @@ class EnhancedUnifiedMCPProxy(UnifiedMCPProxy):
     """
 
     def __init__(
-        self, endpoint: str, function_name: str, kwargs_config: Optional[dict] = None
+        self, endpoint: str, function_name: str, kwargs_config: dict | None = None
     ):
         """Initialize Enhanced Unified MCP Proxy."""
         super().__init__(endpoint, function_name, kwargs_config)