mcp-mesh 0.6.3__py3-none-any.whl → 0.7.0__py3-none-any.whl

_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/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/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/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/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)

_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py

@@ -54,8 +54,8 @@ class APIDependencyResolutionStep(PipelineStep):
                 result.message = (
                     "No heartbeat response or registry wrapper - completed successfully"
                 )
-                self.logger.info(
-                    "ℹ️ No heartbeat response to process - this is normal for API services"
+                self.logger.debug(
+                    "No heartbeat response to process - this is normal for API services"
                 )
                 return result
 
@@ -85,20 +85,7 @@ class APIDependencyResolutionStep(PipelineStep):
             # Log function registry status for debugging
             injector = get_global_injector()
             function_count = len(injector._function_registry)
-            self.logger.debug(
-                f"🔍 Function registry contains {function_count} functions:"
-            )
-            for func_id, wrapper_func in injector._function_registry.items():
-                original_func = getattr(wrapper_func, "_mesh_original_func", None)
-                func_name = original_func.__name__ if original_func else "unknown"
-                dependencies = getattr(wrapper_func, "_mesh_dependencies", [])
-                self.logger.debug(
-                    f"  📋 {func_id} -> {func_name} (deps: {dependencies})"
-                )
-
-            self.logger.debug(
-                "🔗 API dependency resolution step completed using hash-based change detection"
-            )
+            self.logger.debug(f"Function registry contains {function_count} functions")
 
         except Exception as e:
             result.status = PipelineStatus.FAILED
@@ -206,32 +193,33 @@ class APIDependencyResolutionStep(PipelineStep):
 
             if _last_api_dependency_hash is None:
                 if function_count > 0:
-                    self.logger.info(
-                        f"🔄 Initial API dependency state detected: {function_count} functions, {total_deps} dependencies"
+                    self.logger.debug(
+                        f"Initial API dependency state detected: {function_count} functions, {total_deps} dependencies"
                     )
                 else:
-                    self.logger.info(
-                        "🔄 Initial API dependency state detected: no dependencies"
+                    self.logger.debug(
+                        "Initial API dependency state detected: no dependencies"
                     )
             else:
-                self.logger.info(
-                    f"🔄 API dependency state changed (hash: {_last_api_dependency_hash} → {current_hash})"
+                self.logger.debug(
+                    f"API dependency state changed (hash: {_last_api_dependency_hash} → {current_hash})"
                 )
                 if function_count > 0:
-                    self.logger.info(
-                        f"🔄 Updating API dependencies for {function_count} functions ({total_deps} total dependencies)"
+                    self.logger.debug(
+                        f"Updating API dependencies for {function_count} functions ({total_deps} total dependencies)"
                     )
                 else:
-                    self.logger.info(
-                        "🔄 Registry reports no API dependencies - unwiring all existing dependencies"
+                    self.logger.debug(
+                        "Registry reports no API dependencies - unwiring all existing dependencies"
                     )
 
             # Import here to avoid circular imports
             from ...engine.dependency_injector import get_global_injector
-            from ...engine.full_mcp_proxy import (EnhancedFullMCPProxy,
-                                                  FullMCPProxy)
-            from ...engine.mcp_client_proxy import (EnhancedMCPClientProxy,
-                                                    MCPClientProxy)
+            from ...engine.full_mcp_proxy import EnhancedFullMCPProxy, FullMCPProxy
+            from ...engine.mcp_client_proxy import (
+                EnhancedMCPClientProxy,
+                MCPClientProxy,
+            )
 
             injector = get_global_injector()
 
@@ -267,16 +255,32 @@ class APIDependencyResolutionStep(PipelineStep):
             for dep_key in keys_to_remove:
                 await injector.unregister_dependency(dep_key)
                 unwired_count += 1
-                self.logger.info(
-                    f"🗑️ Unwired API dependency '{dep_key}' (no longer reported by registry)"
+                self.logger.debug(
+                    f"Unwired API dependency '{dep_key}' (no longer reported by registry)"
                 )
 
             # Step 3: Apply all dependency updates using positional indexing
             updated_count = 0
             for function_name, dependency_list in current_state.items():
+                # Check if function_name is a route path (METHOD:path format)
+                # Route paths contain "/" and look like "GET:/api/v1/benchmark-services"
+                is_route_path = "/" in function_name
+
                 # Map tool name to func_id (using mapping from Step 1)
+                # For route paths, use the route_id directly as it won't be in tool_name_to_func_id
                 func_id = tool_name_to_func_id.get(function_name, function_name)
 
+                # Get route wrapper if this is a route path
+                route_wrapper_info = None
+                if is_route_path:
+                    route_wrapper_info = DecoratorRegistry.get_route_wrapper(
+                        function_name
+                    )
+                    if not route_wrapper_info:
+                        self.logger.warning(
+                            f"No route wrapper found for '{function_name}' - dependency injection may fail"
+                        )
+
                 for dep_index, dep_info in enumerate(dependency_list):
                     status = dep_info["status"]
                     endpoint = dep_info["endpoint"]
@@ -288,33 +292,21 @@ class APIDependencyResolutionStep(PipelineStep):
                         # Import here to avoid circular imports
                         import os
 
-                        from ...engine.self_dependency_proxy import \
-                            SelfDependencyProxy
-                        from ...engine.unified_mcp_proxy import \
-                            EnhancedUnifiedMCPProxy
+                        from ...engine.self_dependency_proxy import SelfDependencyProxy
+                        from ...engine.unified_mcp_proxy import EnhancedUnifiedMCPProxy
 
                         # Get current agent ID for self-dependency detection
                         current_agent_id = None
                         try:
-                            from ...engine.decorator_registry import \
-                                DecoratorRegistry
+                            from ...engine.decorator_registry import DecoratorRegistry
 
                             config = DecoratorRegistry.get_resolved_agent_config()
                             current_agent_id = config["agent_id"]
-                            self.logger.debug(
-                                f"🔍 Current API service ID from DecoratorRegistry: '{current_agent_id}'"
-                            )
-                        except Exception as e:
+                        except Exception:
                             # For API services, try environment variable fallback
                             current_agent_id = os.getenv("MCP_MESH_AGENT_ID")
-                            self.logger.debug(
-                                f"🔍 Current API service ID from environment: '{current_agent_id}' (fallback due to: {e})"
-                            )
 
                         target_agent_id = dep_info.get("agent_id")
-                        self.logger.debug(
-                            f"🔍 Target agent ID from registry: '{target_agent_id}'"
-                        )
 
                         # Determine if this is a self-dependency (less common for API services)
                         is_self_dependency = (
@@ -323,12 +315,6 @@ class APIDependencyResolutionStep(PipelineStep):
                             and current_agent_id == target_agent_id
                         )
 
-                        self.logger.debug(
-                            f"🔍 Self-dependency check for '{capability}': "
-                            f"current='{current_agent_id}' vs target='{target_agent_id}' "
-                            f"→ {'SELF' if is_self_dependency else 'CROSS'}-dependency"
-                        )
-
                         if is_self_dependency:
                             # Create self-dependency proxy with WRAPPER function (not original)
                             # The wrapper has dependency injection logic, so calling it ensures
@@ -336,16 +322,13 @@ class APIDependencyResolutionStep(PipelineStep):
                             wrapper_func = None
                             if dep_function_name in mesh_tools:
                                 wrapper_func = mesh_tools[dep_function_name].function
-                                self.logger.debug(
-                                    f"🔍 Found wrapper for '{dep_function_name}' in DecoratorRegistry"
-                                )
 
                             if wrapper_func:
                                 new_proxy = SelfDependencyProxy(
                                     wrapper_func, dep_function_name
                                 )
-                                self.logger.info(
-                                    f"🔄 API SELF-DEPENDENCY: Using wrapper for '{capability}' "
+                                self.logger.debug(
+                                    f"API SELF-DEPENDENCY: Using wrapper for '{capability}' "
                                     f"(local call with full DI support)"
                                 )
                             else:
@@ -380,57 +363,57 @@ class APIDependencyResolutionStep(PipelineStep):
                                 kwargs_config=kwargs_config,
                             )
 
-                        # Register with composite key using func_id (not tool name) to match injector lookup
-                        dep_key = f"{func_id}:dep_{dep_index}"
-                        self.logger.debug(
-                            f"🔄 Before update: registering {dep_key} = {type(new_proxy).__name__}"
-                        )
-                        await injector.register_dependency(dep_key, new_proxy)
-                        updated_count += 1
-
-                        # Log which functions will be affected
-                        affected_functions = injector._dependency_mapping.get(
-                            dep_key, set()
-                        )
-                        self.logger.debug(
-                            f"🎯 Functions affected by '{capability}' at position {dep_index}: {list(affected_functions)}"
-                        )
+                        # For route paths, directly update the wrapper's dependencies
+                        # This bypasses the injector key-based lookup which doesn't work for routes
+                        if route_wrapper_info:
+                            wrapper = route_wrapper_info.get("wrapper")
+                            if wrapper and hasattr(wrapper, "_mesh_update_dependency"):
+                                wrapper._mesh_update_dependency(dep_index, new_proxy)
+                                updated_count += 1
+                                self.logger.debug(
+                                    f"Updated route dependency '{capability}' at position {dep_index} "
+                                    f"→ {endpoint}/{dep_function_name} for route '{function_name}'"
+                                )
+                            else:
+                                self.logger.warning(
+                                    f"Route wrapper for '{function_name}' doesn't have _mesh_update_dependency method"
+                                )
+                        else:
+                            # Fallback: Register with composite key using func_id for MCP tools
+                            dep_key = f"{func_id}:dep_{dep_index}"
+                            await injector.register_dependency(dep_key, new_proxy)
+                            updated_count += 1
+
+                            # Log which functions will be affected
+                            affected_functions = injector._dependency_mapping.get(
+                                dep_key, set()
+                            )
+                            self.logger.debug(
+                                f"Functions affected by '{capability}' at position {dep_index}: {list(affected_functions)}"
+                            )
 
-                        self.logger.info(
-                            f"🔄 Updated API dependency '{capability}' at position {dep_index} → {endpoint}/{dep_function_name} "
-                            f"(proxy: EnhancedUnifiedMCPProxy - consistent with MCP pipeline)"
-                        )
-                        self.logger.debug(
-                            f"🔗 Registered dependency '{capability}' at position {dep_index} with key '{dep_key}' (func_id: {func_id})"
-                        )
+                            self.logger.debug(
+                                f"Updated API dependency '{capability}' at position {dep_index} → {endpoint}/{dep_function_name}"
+                            )
+                            self.logger.debug(
+                                f"Registered dependency '{capability}' at position {dep_index} with key '{dep_key}' (func_id: {func_id})"
+                            )
                     else:
                         if status != "available":
                             self.logger.debug(
-                                f"⚠️ API dependency '{capability}' at position {dep_index} not available: {status}"
+                                f"API dependency '{capability}' at position {dep_index} not available: {status}"
                             )
                         else:
                             self.logger.warning(
-                                f"⚠️ Cannot update API dependency '{capability}' at position {dep_index}: missing endpoint or function_name"
+                                f"Cannot update API dependency '{capability}' at position {dep_index}: missing endpoint or function_name"
                             )
 
             # Store new hash for next comparison (use global variable)
             _last_api_dependency_hash = current_hash
 
-            if unwired_count > 0 and updated_count > 0:
-                self.logger.info(
-                    f"✅ Successfully unwired {unwired_count} and updated {updated_count} API dependencies (state hash: {current_hash})"
-                )
-            elif unwired_count > 0:
-                self.logger.info(
-                    f"✅ Successfully unwired {unwired_count} API dependencies (state hash: {current_hash})"
-                )
-            elif updated_count > 0:
-                self.logger.info(
-                    f"✅ Successfully updated {updated_count} API dependencies (state hash: {current_hash})"
-                )
-            else:
-                self.logger.info(
-                    f"✅ API dependency state synchronized (state hash: {current_hash})"
+            if unwired_count > 0 or updated_count > 0:
+                self.logger.debug(
+                    f"API dependency sync: unwired={unwired_count}, updated={updated_count} (hash: {current_hash})"
                 )
 
         except Exception as e:
@@ -482,8 +465,7 @@ class APIDependencyResolutionStep(PipelineStep):
             Proxy instance
         """
         from ...engine.full_mcp_proxy import EnhancedFullMCPProxy, FullMCPProxy
-        from ...engine.mcp_client_proxy import (EnhancedMCPClientProxy,
-                                                MCPClientProxy)
+        from ...engine.mcp_client_proxy import EnhancedMCPClientProxy, MCPClientProxy
 
         if proxy_type == "FullMCPProxy":
             # Use enhanced proxy if kwargs available