mcp-mesh 0.6.4__tar.gz → 0.7.15__tar.gz

{mcp_mesh-0.6.4 → mcp_mesh-0.7.15}/.gitignore

@@ -174,14 +174,15 @@ cython_debug/
 logs/
 .logs/
 capability_store/
+prompts/
 *.db
 *.pid
 
 # Go binaries
 mcp-mesh-dev
 /mcp-mesh-registry
-meshctl
-bin/meshctl
+/meshctl
+bin/
 *.exe
 *.dll
 *.dylib
@@ -236,3 +237,11 @@ packaging/pypi/README.md
 packaging/pypi/LICENSE
 packaging/pypi/dist/
 MEDIUM-POST-MULTI-AGENT-POC.md
+
+# Helm chart dependency packages (regenerate with: helm dependency update)
+helm/*/charts/*.tgz
+
+# Helm chart files copied during release (generated from observability/)
+helm/mcp-mesh-grafana/files/
+helm/mcp-mesh-tempo/files/
+*.DS_Store

{mcp_mesh-0.6.4 → mcp_mesh-0.7.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.6.4
+Version: 0.7.15
 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

{mcp_mesh-0.6.4 → mcp_mesh-0.7.15}/_mcp_mesh/__init__.py

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

{mcp_mesh-0.6.4 → mcp_mesh-0.7.15}/_mcp_mesh/engine/__init__.py

@@ -17,13 +17,8 @@ __all__ = [
     # Dependency injection
     "DependencyInjector",
     "get_global_injector",
-    # MCP client proxies (legacy)
-    "MCPClientProxy",
-    "EnhancedMCPClientProxy",
-    "FullMCPProxy",
-    "EnhancedFullMCPProxy",
+    # MCP client proxies
     "AsyncMCPClient",
-    # Unified MCP proxy (recommended)
     "UnifiedMCPProxy",
     "EnhancedUnifiedMCPProxy",
     # Self-dependency proxy
@@ -59,22 +54,6 @@ def __getattr__(name):
 
         return get_global_injector
     # MCP client proxies
-    elif name == "MCPClientProxy":
-        from .mcp_client_proxy import MCPClientProxy
-
-        return MCPClientProxy
-    elif name == "EnhancedMCPClientProxy":
-        from .mcp_client_proxy import EnhancedMCPClientProxy
-
-        return EnhancedMCPClientProxy
-    elif name == "FullMCPProxy":
-        from .full_mcp_proxy import FullMCPProxy
-
-        return FullMCPProxy
-    elif name == "EnhancedFullMCPProxy":
-        from .full_mcp_proxy import EnhancedFullMCPProxy
-
-        return EnhancedFullMCPProxy
     elif name == "AsyncMCPClient":
         from .async_mcp_client import AsyncMCPClient
 

{mcp_mesh-0.6.4 → mcp_mesh-0.7.15}/_mcp_mesh/engine/async_mcp_client.py

@@ -1,10 +1,12 @@
 """Async HTTP client for MCP JSON-RPC protocol."""
 
+import asyncio
+import atexit
 import json
 import logging
 import urllib.error
 import urllib.request
-from typing import Any
+from typing import Any, ClassVar, Optional
 
 from ..shared.sse_parser import SSEParser
 
@@ -12,13 +14,67 @@ logger = logging.getLogger(__name__)
 
 
 class AsyncMCPClient:
-    """Async HTTP client for MCP JSON-RPC protocol."""
+    """Async HTTP client for MCP JSON-RPC protocol.
+
+    Uses connection pooling to reuse HTTP connections across requests,
+    reducing TCP/SSL handshake overhead and preventing port exhaustion.
+    """
+
+    # Class-level connection pool (shared across instances for same endpoint)
+    _client_pool: ClassVar[dict[str, "httpx.AsyncClient"]] = {}
+    _pool_lock: ClassVar[Optional[asyncio.Lock]] = None
+
+    # Default connection limits for pooling
+    DEFAULT_MAX_CONNECTIONS = 100
+    DEFAULT_MAX_KEEPALIVE_CONNECTIONS = 20
 
     def __init__(self, endpoint: str, timeout: float = 30.0):
         self.endpoint = endpoint
         self.timeout = timeout
         self.logger = logger.getChild(f"client.{endpoint}")
 
+    @classmethod
+    def _get_lock(cls) -> asyncio.Lock:
+        """Get or create the class-level lock (handles event loop creation)."""
+        if cls._pool_lock is None:
+            cls._pool_lock = asyncio.Lock()
+        return cls._pool_lock
+
+    @classmethod
+    async def _get_pooled_client(
+        cls, endpoint: str, timeout: float
+    ) -> "httpx.AsyncClient":
+        """Get or create a pooled httpx client for the endpoint.
+
+        This enables connection reuse across multiple requests to the same endpoint,
+        significantly reducing overhead from TCP connection establishment and SSL handshakes.
+        """
+        import httpx
+
+        async with cls._get_lock():
+            if endpoint not in cls._client_pool:
+                cls._client_pool[endpoint] = httpx.AsyncClient(
+                    timeout=timeout,
+                    limits=httpx.Limits(
+                        max_connections=cls.DEFAULT_MAX_CONNECTIONS,
+                        max_keepalive_connections=cls.DEFAULT_MAX_KEEPALIVE_CONNECTIONS,
+                    ),
+                )
+                logger.debug(f"Created pooled client for endpoint: {endpoint}")
+            return cls._client_pool[endpoint]
+
+    @classmethod
+    async def close_all_clients(cls) -> None:
+        """Close all pooled clients. Call during application shutdown."""
+        async with cls._get_lock():
+            for endpoint, client in list(cls._client_pool.items()):
+                try:
+                    await client.aclose()
+                    logger.debug(f"Closed pooled client for: {endpoint}")
+                except Exception as e:
+                    logger.warning(f"Error closing client for {endpoint}: {e}")
+            cls._client_pool.clear()
+
     async def call_tool(self, tool_name: str, arguments: dict) -> Any:
         """Call remote tool using MCP JSON-RPC protocol."""
         payload = {
@@ -38,37 +94,39 @@ class AsyncMCPClient:
             raise
 
     async def _make_request(self, payload: dict) -> dict:
-        """Make async HTTP request to MCP endpoint."""
+        """Make async HTTP request to MCP endpoint using pooled connections."""
         url = f"{self.endpoint}/mcp"
 
         try:
-            # Use httpx for proper async HTTP requests (better threading support than aiohttp)
+            # Use httpx with connection pooling for better resource management
             import httpx
 
-            async with httpx.AsyncClient(timeout=self.timeout) as client:
-                response = await client.post(
-                    url,
-                    json=payload,
-                    headers={
-                        "Content-Type": "application/json",
-                        "Accept": "application/json, text/event-stream",
-                    },
-                )
+            # Get pooled client (reuses connections across requests)
+            client = await self._get_pooled_client(self.endpoint, self.timeout)
 
-                if response.status_code == 404:
-                    raise RuntimeError(f"MCP endpoint not found at {url}")
-                elif response.status_code >= 400:
-                    raise RuntimeError(
-                        f"HTTP error {response.status_code}: {response.reason_phrase}"
-                    )
+            response = await client.post(
+                url,
+                json=payload,
+                headers={
+                    "Content-Type": "application/json",
+                    "Accept": "application/json, text/event-stream",
+                },
+            )
 
-                response_text = response.text
-
-                # Use shared SSE parser
-                data = SSEParser.parse_sse_response(
-                    response_text, f"AsyncMCPClient.{self.endpoint}"
+            if response.status_code == 404:
+                raise RuntimeError(f"MCP endpoint not found at {url}")
+            elif response.status_code >= 400:
+                raise RuntimeError(
+                    f"HTTP error {response.status_code}: {response.reason_phrase}"
                 )
 
+            response_text = response.text
+
+            # Use shared SSE parser
+            data = SSEParser.parse_sse_response(
+                response_text, f"AsyncMCPClient.{self.endpoint}"
+            )
+
             # Check for JSON-RPC error
             if "error" in data:
                 error = data["error"]
@@ -169,5 +227,10 @@ class AsyncMCPClient:
         return result
 
     async def close(self):
-        """Close client (no persistent connection to close)."""
+        """Close client instance (no-op as connections are pooled at class level).
+
+        Connection pooling is managed at the class level for efficiency.
+        To close all pooled connections during shutdown, use:
+            await AsyncMCPClient.close_all_clients()
+        """
         pass

{mcp_mesh-0.6.4 → mcp_mesh-0.7.15}/_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.
 
@@ -625,27 +664,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
+    # Health check result storage (delegated to health_check_manager)
 
     @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')}"
-        )
+        from ..shared.health_check_manager import store_health_check_result
+
+        store_health_check_result(result)
 
     @classmethod
     def get_health_check_result(cls) -> dict | None:
         """Get stored health check result."""
-        return cls._health_check_result
+        from ..shared.health_check_manager import get_health_check_result
+
+        return get_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")
+        from ..shared.health_check_manager import clear_health_check_result
+
+        clear_health_check_result()
 
     @classmethod
     def store_fastmcp_lifespan(cls, lifespan: Any) -> None:
@@ -659,7 +699,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 +726,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 +755,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.4 → mcp_mesh-0.7.15}/_mcp_mesh/engine/dependency_injector.py

@@ -14,6 +14,11 @@ 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
 
 logger = logging.getLogger(__name__)
@@ -448,17 +453,17 @@ class DependencyInjector:
 
             @functools.wraps(func)
             async def dependency_wrapper(*args, **kwargs):
+                # Get trace prefix if available
+                tp = get_trace_prefix()
+
+                # Log tool invocation - summary line
+                arg_keys = list(kwargs.keys()) if kwargs else []
                 wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: Function {func.__name__} called"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: args={args}, kwargs={kwargs}"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: mesh_positions={mesh_positions}"
+                    f"{tp}🔧 Tool '{func.__name__}' called with kwargs={arg_keys}"
                 )
+                # Log full args (will be TRACE later)
                 wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}"
+                    f"{tp}🔧 Tool '{func.__name__}' args: {format_log_value(kwargs)}"
                 )
 
                 # We know mesh_positions is not empty since we checked above
@@ -468,20 +473,14 @@ class DependencyInjector:
                 params = list(sig.parameters.keys())
                 final_kwargs = kwargs.copy()
 
-                wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: params={params}")
-                wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: original kwargs={kwargs}")
-
                 # Inject dependencies as kwargs (using array-based lookup)
                 injected_count = 0
+                injected_deps = []  # Track what was injected for logging
                 for dep_index, param_position in enumerate(mesh_positions):
                     if dep_index < len(dependencies):
                         dep_name = dependencies[dep_index]
                         param_name = params[param_position]
 
-                        wrapper_logger.debug(
-                            f"🔧 DEPENDENCY_WRAPPER: Processing dep {dep_index}: {dep_name} -> {param_name}"
-                        )
-
                         # Only inject if the parameter wasn't explicitly provided
                         if (
                             param_name not in final_kwargs
@@ -493,34 +492,25 @@ class DependencyInjector:
                                 dependency = dependency_wrapper._mesh_injected_deps[
                                     dep_index
                                 ]
-                            wrapper_logger.debug(
-                                f"🔧 DEPENDENCY_WRAPPER: From wrapper storage[{dep_index}]: {dependency}"
-                            )
 
                             if dependency is None:
                                 # Fallback to global storage with composite key
                                 dep_key = f"{func.__module__}.{func.__qualname__}:dep_{dep_index}"
                                 dependency = self.get_dependency(dep_key)
-                                wrapper_logger.debug(
-                                    f"🔧 DEPENDENCY_WRAPPER: From global storage[{dep_key}]: {dependency}"
-                                )
 
                             final_kwargs[param_name] = dependency
                             injected_count += 1
-                            wrapper_logger.debug(
-                                f"🔧 DEPENDENCY_WRAPPER: Injected {dep_name} from index {dep_index} as {param_name}"
-                            )
-                        else:
-                            wrapper_logger.debug(
-                                f"🔧 DEPENDENCY_WRAPPER: Skipping {param_name} - already provided"
+                            # Track for consolidated logging
+                            proxy_type = (
+                                type(dependency).__name__ if dependency else "None"
                             )
+                            injected_deps.append(f"{dep_name} → {proxy_type}")
 
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: Injected {injected_count} dependencies"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: final_kwargs={final_kwargs}"
-                )
+                # Log consolidated dependency injection summary
+                if injected_count > 0:
+                    wrapper_logger.debug(
+                        f"{tp}🔧 Injected {injected_count} dependencies: {', '.join(injected_deps)}"
+                    )
 
                 # ===== INJECT LLM AGENT IF PRESENT (Option A) =====
                 # Check if this function has @mesh.llm metadata attached (on the original function)
@@ -534,7 +524,7 @@ class DependencyInjector:
                         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}"
+                            f"{tp}🤖 LLM_INJECTION: Injected {llm_param}={llm_agent}"
                         )
 
                 # ===== EXECUTE WITH DEPENDENCY INJECTION AND TRACING =====
@@ -543,10 +533,6 @@ class DependencyInjector:
 
                 original_func = func._mesh_original_func
 
-                wrapper_logger.debug(
-                    f"🔧 DI: Executing async function {original_func.__name__} with {injected_count} injected dependencies"
-                )
-
                 # Use ExecutionTracer's async method for clean tracing
                 result = await ExecutionTracer.trace_function_execution_async(
                     original_func,
@@ -558,26 +544,32 @@ class DependencyInjector:
                     wrapper_logger,
                 )
 
+                # Log result - summary line
                 wrapper_logger.debug(
-                    f"🔧 DI: Function {original_func.__name__} returned: {type(result)}"
+                    f"{tp}🔧 Tool '{func.__name__}' returned: {format_result_summary(result)}"
                 )
+                # Log full result (will be TRACE later)
+                wrapper_logger.debug(
+                    f"{tp}🔧 Tool '{func.__name__}' result: {format_log_value(result)}"
+                )
+
                 return result
 
         else:
             # Create sync wrapper for sync functions without dependencies
             @functools.wraps(func)
             def dependency_wrapper(*args, **kwargs):
+                # Get trace prefix if available
+                tp = get_trace_prefix()
+
+                # Log tool invocation - summary line
+                arg_keys = list(kwargs.keys()) if kwargs else []
                 wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: Function {func.__name__} called"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: args={args}, kwargs={kwargs}"
-                )
-                wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: mesh_positions={mesh_positions}"
+                    f"{tp}🔧 Tool '{func.__name__}' called with kwargs={arg_keys}"
                 )
+                # Log full args (will be TRACE later)
                 wrapper_logger.debug(
-                    f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}"
+                    f"{tp}🔧 Tool '{func.__name__}' args: {format_log_value(kwargs)}"
                 )
 
                 # We know mesh_positions is not empty since we checked above
@@ -589,6 +581,7 @@ class DependencyInjector:
 
                 # Inject dependencies as kwargs (using array-based lookup)
                 injected_count = 0
+                injected_deps = []  # Track what was injected for logging
                 for dep_index, param_position in enumerate(mesh_positions):
                     if dep_index < len(dependencies):
                         dep_name = dependencies[dep_index]
@@ -613,6 +606,17 @@ class DependencyInjector:
 
                             final_kwargs[param_name] = dependency
                             injected_count += 1
+                            # Track for consolidated logging
+                            proxy_type = (
+                                type(dependency).__name__ if dependency else "None"
+                            )
+                            injected_deps.append(f"{dep_name} → {proxy_type}")
+
+                # Log consolidated dependency injection summary
+                if injected_count > 0:
+                    wrapper_logger.debug(
+                        f"{tp}🔧 Injected {injected_count} dependencies: {', '.join(injected_deps)}"
+                    )
 
                 # ===== INJECT LLM AGENT IF PRESENT (Option A) =====
                 # Check if this function has @mesh.llm metadata attached (on the original function)
@@ -626,19 +630,15 @@ class DependencyInjector:
                         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}"
+                            f"{tp}🤖 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
 
-                wrapper_logger.debug(
-                    f"🔧 DI: Executing sync function {func._mesh_original_func.__name__} with {injected_count} injected dependencies"
-                )
-
                 # Use ExecutionTracer for clean execution tracing
-                return ExecutionTracer.trace_function_execution(
+                result = ExecutionTracer.trace_function_execution(
                     func._mesh_original_func,
                     args,
                     final_kwargs,
@@ -648,6 +648,17 @@ class DependencyInjector:
                     wrapper_logger,
                 )
 
+                # Log result - summary line
+                wrapper_logger.debug(
+                    f"{tp}🔧 Tool '{func.__name__}' returned: {format_result_summary(result)}"
+                )
+                # Log full result (will be TRACE later)
+                wrapper_logger.debug(
+                    f"{tp}🔧 Tool '{func.__name__}' result: {format_log_value(result)}"
+                )
+
+                return result
+
         # Store dependency state on wrapper as array (indexed by position)
         dependency_wrapper._mesh_injected_deps = [None] * len(dependencies)
 

{mcp_mesh-0.6.4 → mcp_mesh-0.7.15}/_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(