mcp-mesh 0.5.6__py3-none-any.whl → 0.5.7__py3-none-any.whl

_mcp_mesh/__init__.py

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

_mcp_mesh/engine/dependency_injector.py

@@ -2,7 +2,7 @@
 Dynamic dependency injection system for MCP Mesh.
 
 Handles both initial injection and runtime updates when topology changes.
-Focused purely on dependency injection - telemetry/tracing is handled at 
+Focused purely on dependency injection - telemetry/tracing is handled at
 the HTTP middleware layer for unified approach across MCP agents and FastAPI apps.
 """
 
@@ -57,17 +57,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 McpMeshAgent or McpAgent for clarity)"
             )
         return [0]  # Inject into the single parameter
 
-    # Multiple parameters rule: only inject into McpMeshAgent typed parameters
+    # Multiple parameters rule: only inject into McpMeshAgent or McpAgent 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 McpMeshAgent or McpAgent. Skipping injection of {len(dependencies)} dependencies. "
+                f"Consider typing dependency parameters as McpMeshAgent or McpAgent."
             )
             return []
 
@@ -77,7 +77,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)} McpMeshAgent/McpAgent parameters. "
                     f"Dependencies {excess_deps} will not be injected."
                 )
             else:
@@ -85,7 +85,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)} McpMeshAgent/McpAgent parameters "
                     f"but only {len(dependencies)} dependencies declared. "
                     f"Parameters {excess_params} will remain None."
                 )
@@ -118,12 +118,17 @@ class DependencyInjector:
         self._lock = asyncio.Lock()
 
     async def register_dependency(self, name: str, instance: Any) -> None:
-        """Register a new dependency or update existing one."""
+        """Register a new dependency or update existing one.
+
+        Args:
+            name: Composite key in format "function_id:dep_N" or legacy capability name
+            instance: Proxy instance to register
+        """
         async with self._lock:
             logger.info(f"📦 Registering dependency: {name}")
             self._dependencies[name] = instance
 
-            # Notify all functions that depend on this
+            # Notify all functions that depend on this (using composite keys)
             if name in self._dependency_mapping:
                 for func_id in self._dependency_mapping[name]:
                     if func_id in self._function_registry:
@@ -132,10 +137,28 @@ class DependencyInjector:
                             f"🔄 UPDATING dependency '{name}' for {func_id} -> {func} at {hex(id(func))}"
                         )
                         if hasattr(func, "_mesh_update_dependency"):
-                            func._mesh_update_dependency(name, instance)
+                            # Extract dep_index from composite key (format: "function_id:dep_N")
+                            if ":dep_" in name:
+                                dep_index_str = name.split(":dep_")[-1]
+                                try:
+                                    dep_index = int(dep_index_str)
+                                    func._mesh_update_dependency(dep_index, instance)
+                                except ValueError:
+                                    logger.warning(
+                                        f"⚠️ Invalid dep_index in key '{name}', skipping update"
+                                    )
+                            else:
+                                # Legacy format (shouldn't happen with new code)
+                                logger.warning(
+                                    f"⚠️ Legacy dependency key format '{name}' not supported in array-based injection"
+                                )
 
     async def unregister_dependency(self, name: str) -> None:
-        """Remove a dependency (e.g., service went down)."""
+        """Remove a dependency (e.g., service went down).
+
+        Args:
+            name: Composite key in format "function_id:dep_N" or legacy capability name
+        """
         async with self._lock:
             logger.info(f"🗑️ INJECTOR: Unregistering dependency: {name}")
             if name in self._dependencies:
@@ -156,7 +179,21 @@ class DependencyInjector:
                                 logger.info(
                                     f"🗑️ INJECTOR: Removing {name} from function {func_id}"
                                 )
-                                func._mesh_update_dependency(name, None)
+                                # Extract dep_index from composite key
+                                if ":dep_" in name:
+                                    dep_index_str = name.split(":dep_")[-1]
+                                    try:
+                                        dep_index = int(dep_index_str)
+                                        func._mesh_update_dependency(dep_index, None)
+                                    except ValueError:
+                                        logger.warning(
+                                            f"⚠️ Invalid dep_index in key '{name}', skipping removal"
+                                        )
+                                else:
+                                    # Legacy format
+                                    logger.warning(
+                                        f"⚠️ Legacy dependency key format '{name}' not supported in array-based injection"
+                                    )
                             else:
                                 logger.warning(
                                     f"🗑️ INJECTOR: Function {func_id} has no _mesh_update_dependency method"
@@ -266,15 +303,16 @@ class DependencyInjector:
         # Get parameter type information for proxy selection
         parameter_types = get_agent_parameter_types(func)
 
-        # Track which dependencies this function needs
-        for dep in dependencies:
-            if dep not in self._dependency_mapping:
-                self._dependency_mapping[dep] = set()
-            self._dependency_mapping[dep].add(func_id)
+        # Track which dependencies this function needs (using composite keys)
+        for dep_index, dep in enumerate(dependencies):
+            dep_key = f"{func_id}:dep_{dep_index}"
+            if dep_key not in self._dependency_mapping:
+                self._dependency_mapping[dep_key] = set()
+            self._dependency_mapping[dep_key].add(func_id)
 
-        # Store current dependency values on the function itself
+        # Store current dependency values as array (indexed by position)
         if not hasattr(func, "_mesh_injected_deps"):
-            func._mesh_injected_deps = {}
+            func._mesh_injected_deps = [None] * len(dependencies)
 
         # Store original implementation if not already stored
         if not hasattr(func, "_mesh_original_func"):
@@ -292,34 +330,45 @@ class DependencyInjector:
 
             # Check if we need async wrapper for minimal case
             if inspect.iscoroutinefunction(func):
+
                 @functools.wraps(func)
                 async def minimal_wrapper(*args, **kwargs):
                     # Use ExecutionTracer for functions without dependencies (v0.4.0 style)
                     from ..tracing.execution_tracer import ExecutionTracer
-                    wrapper_logger.debug(f"🔧 DI: Executing async function {func.__name__} (no dependencies)")
-                    
+
+                    wrapper_logger.debug(
+                        f"🔧 DI: Executing async function {func.__name__} (no dependencies)"
+                    )
+
                     # For async functions without dependencies, use the async tracer
                     return await ExecutionTracer.trace_function_execution_async(
                         func, args, kwargs, [], [], 0, wrapper_logger
                     )
+
             else:
+
                 @functools.wraps(func)
                 def minimal_wrapper(*args, **kwargs):
                     # Use ExecutionTracer for functions without dependencies (v0.4.0 style)
                     from ..tracing.execution_tracer import ExecutionTracer
-                    wrapper_logger.debug(f"🔧 DI: Executing sync function {func.__name__} (no dependencies)")
-                    
+
+                    wrapper_logger.debug(
+                        f"🔧 DI: Executing sync function {func.__name__} (no dependencies)"
+                    )
+
                     # Use original function tracer for functions without dependencies
-                    return ExecutionTracer.trace_original_function(func, args, kwargs, wrapper_logger)
+                    return ExecutionTracer.trace_original_function(
+                        func, args, kwargs, wrapper_logger
+                    )
 
-            # Add minimal metadata for compatibility
-            minimal_wrapper._mesh_injected_deps = {}
+            # Add minimal metadata for compatibility (use array for consistency)
+            minimal_wrapper._mesh_injected_deps = [None] * len(dependencies)
             minimal_wrapper._mesh_dependencies = dependencies
             minimal_wrapper._mesh_positions = mesh_positions
             minimal_wrapper._mesh_parameter_types = get_agent_parameter_types(func)
             minimal_wrapper._mesh_original_func = func
 
-            def update_dependency(name: str, instance: Any | None) -> None:
+            def update_dependency(dep_index: int, instance: Any | None) -> None:
                 """No-op update for functions without injection positions."""
                 pass
 
@@ -363,7 +412,7 @@ class DependencyInjector:
                 wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: params={params}")
                 wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: original kwargs={kwargs}")
 
-                # Inject dependencies as kwargs
+                # Inject dependencies as kwargs (using array-based lookup)
                 injected_count = 0
                 for dep_index, param_position in enumerate(mesh_positions):
                     if dep_index < len(dependencies):
@@ -379,24 +428,28 @@ class DependencyInjector:
                             param_name not in final_kwargs
                             or final_kwargs.get(param_name) is None
                         ):
-                            # Get the dependency from wrapper's storage
-                            dependency = dependency_wrapper._mesh_injected_deps.get(
-                                dep_name
-                            )
+                            # Get the dependency from wrapper's array storage (by index)
+                            dependency = None
+                            if dep_index < len(dependency_wrapper._mesh_injected_deps):
+                                dependency = dependency_wrapper._mesh_injected_deps[
+                                    dep_index
+                                ]
                             wrapper_logger.debug(
-                                f"🔧 DEPENDENCY_WRAPPER: From wrapper storage: {dependency}"
+                                f"🔧 DEPENDENCY_WRAPPER: From wrapper storage[{dep_index}]: {dependency}"
                             )
 
                             if dependency is None:
-                                dependency = self.get_dependency(dep_name)
+                                # 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: {dependency}"
+                                    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} as {param_name}"
+                                f"🔧 DEPENDENCY_WRAPPER: Injected {dep_name} from index {dep_index} as {param_name}"
                             )
                         else:
                             wrapper_logger.debug(
@@ -413,7 +466,7 @@ class DependencyInjector:
                 # ===== EXECUTE WITH DEPENDENCY INJECTION AND TRACING =====
                 # Use ExecutionTracer for comprehensive execution logging (v0.4.0 style)
                 from ..tracing.execution_tracer import ExecutionTracer
-                
+
                 original_func = func._mesh_original_func
 
                 wrapper_logger.debug(
@@ -460,7 +513,7 @@ class DependencyInjector:
                 params = list(sig.parameters.keys())
                 final_kwargs = kwargs.copy()
 
-                # Inject dependencies as kwargs
+                # Inject dependencies as kwargs (using array-based lookup)
                 injected_count = 0
                 for dep_index, param_position in enumerate(mesh_positions):
                     if dep_index < len(dependencies):
@@ -472,13 +525,17 @@ class DependencyInjector:
                             param_name not in final_kwargs
                             or final_kwargs.get(param_name) is None
                         ):
-                            # Get the dependency from wrapper's storage
-                            dependency = dependency_wrapper._mesh_injected_deps.get(
-                                dep_name
-                            )
+                            # Get the dependency from wrapper's array storage (by index)
+                            dependency = None
+                            if dep_index < len(dependency_wrapper._mesh_injected_deps):
+                                dependency = dependency_wrapper._mesh_injected_deps[
+                                    dep_index
+                                ]
 
                             if dependency is None:
-                                dependency = self.get_dependency(dep_name)
+                                # Fallback to global storage with composite key
+                                dep_key = f"{func.__module__}.{func.__qualname__}:dep_{dep_index}"
+                                dependency = self.get_dependency(dep_key)
 
                             final_kwargs[param_name] = dependency
                             injected_count += 1
@@ -486,7 +543,7 @@ class DependencyInjector:
                 # ===== 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"
                 )
@@ -502,20 +559,28 @@ class DependencyInjector:
                     wrapper_logger,
                 )
 
-        # Store dependency state on wrapper
-        dependency_wrapper._mesh_injected_deps = {}
-
-        # Add update method to wrapper
-        def update_dependency(name: str, instance: Any | None) -> None:
-            """Called when a dependency changes."""
-            if instance is None:
-                dependency_wrapper._mesh_injected_deps.pop(name, None)
-                wrapper_logger.debug(f"Removed {name} from {func_id}")
+        # Store dependency state on wrapper as array (indexed by position)
+        dependency_wrapper._mesh_injected_deps = [None] * len(dependencies)
+
+        # Add update method to wrapper (now uses index-based updates)
+        def update_dependency(dep_index: int, instance: Any | None) -> None:
+            """Called when a dependency changes (index-based for duplicate capability support)."""
+            if dep_index < len(dependency_wrapper._mesh_injected_deps):
+                dependency_wrapper._mesh_injected_deps[dep_index] = instance
+                if instance is None:
+                    wrapper_logger.debug(
+                        f"Removed dependency at index {dep_index} from {func_id}"
+                    )
+                else:
+                    wrapper_logger.debug(
+                        f"Updated dependency at index {dep_index} for {func_id}"
+                    )
+                    wrapper_logger.debug(
+                        f"🔗 Wrapper pointer receiving dependency: {dependency_wrapper} at {hex(id(dependency_wrapper))}"
+                    )
             else:
-                dependency_wrapper._mesh_injected_deps[name] = instance
-                wrapper_logger.debug(f"Updated {name} for {func_id}")
-                wrapper_logger.debug(
-                    f"🔗 Wrapper pointer receiving dependency: {dependency_wrapper} at {hex(id(dependency_wrapper))}"
+                wrapper_logger.warning(
+                    f"⚠️ Attempted to update dependency at index {dep_index} but wrapper only has {len(dependency_wrapper._mesh_injected_deps)} dependencies"
                 )
 
         # Store update method on wrapper

_mcp_mesh/engine/signature_analyzer.py

@@ -151,13 +151,13 @@ def get_mesh_agent_positions(func: Any) -> list[int]:
 
 def get_mesh_agent_parameter_names(func: Any) -> list[str]:
     """
-    Get names of McpMeshAgent parameters in function signature.
+    Get names of McpMeshAgent/McpAgent parameters in function signature.
 
     Args:
         func: Function to analyze
 
     Returns:
-        List of parameter names that are McpMeshAgent types
+        List of parameter names that are McpMeshAgent or McpAgent types
     """
     try:
         type_hints = get_type_hints(func)
@@ -168,22 +168,31 @@ def get_mesh_agent_parameter_names(func: Any) -> list[str]:
             if param_name in type_hints:
                 param_type = type_hints[param_name]
 
-                # Check if it's McpMeshAgent type (handle different import paths and Union types)
+                # Check if it's McpAgent or McpMeshAgent type (handle different import paths and Union types)
                 is_mesh_agent = False
 
-                # Direct McpMeshAgent type
-                if param_type == McpMeshAgent or (
-                    hasattr(param_type, "__origin__")
-                    and param_type.__origin__ is type(McpMeshAgent)
+                # Direct McpAgent or McpMeshAgent type
+                if (
+                    param_type in (McpAgent, McpMeshAgent)
+                    or (
+                        hasattr(param_type, "__name__")
+                        and param_type.__name__ in ("McpAgent", "McpMeshAgent")
+                    )
+                    or (
+                        hasattr(param_type, "__origin__")
+                        and param_type.__origin__
+                        in (type(McpAgent), type(McpMeshAgent))
+                    )
                 ):
                     is_mesh_agent = True
 
-                # Union type (e.g., McpMeshAgent | None)
+                # Union type (e.g., McpAgent | None, McpMeshAgent | None)
                 elif hasattr(param_type, "__args__"):
-                    # Check if any arg in the union is McpMeshAgent
+                    # Check if any arg in the union is McpAgent or McpMeshAgent
                     for arg in param_type.__args__:
-                        if arg == McpMeshAgent or (
-                            hasattr(arg, "__name__") and arg.__name__ == "McpMeshAgent"
+                        if arg in (McpAgent, McpMeshAgent) or (
+                            hasattr(arg, "__name__")
+                            and arg.__name__ in ("McpAgent", "McpMeshAgent")
                         ):
                             is_mesh_agent = True
                             break
@@ -199,7 +208,7 @@ def get_mesh_agent_parameter_names(func: Any) -> list[str]:
 
 def validate_mesh_dependencies(func: Any, dependencies: list[dict]) -> tuple[bool, str]:
     """
-    Validate that the number of dependencies matches McpMeshAgent parameters.
+    Validate that the number of dependencies matches McpMeshAgent/McpAgent parameters.
 
     Args:
         func: Function to validate
@@ -212,9 +221,9 @@ def validate_mesh_dependencies(func: Any, dependencies: list[dict]) -> tuple[boo
 
     if len(dependencies) != len(mesh_positions):
         return False, (
-            f"Function {func.__name__} has {len(mesh_positions)} McpMeshAgent parameters "
+            f"Function {func.__name__} has {len(mesh_positions)} McpMeshAgent/McpAgent parameters "
             f"but {len(dependencies)} dependencies declared. "
-            f"Each McpMeshAgent parameter needs a corresponding dependency."
+            f"Each McpMeshAgent/McpAgent parameter needs a corresponding dependency."
         )
 
     return True, ""

_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py

@@ -14,7 +14,7 @@ from ..shared import PipelineResult, PipelineStatus, PipelineStep
 
 logger = logging.getLogger(__name__)
 
-# Global state for dependency hash tracking across heartbeat cycles  
+# Global state for dependency hash tracking across heartbeat cycles
 _last_api_dependency_hash = None
 
 
@@ -24,7 +24,7 @@ class APIDependencyResolutionStep(PipelineStep):
 
     Takes the dependencies_resolved data from the heartbeat response
     and updates dependency injection for FastAPI route handlers.
-    
+
     Similar to MCP dependency resolution but adapted for:
     - FastAPI route handlers instead of MCP tools
     - Single "api_endpoint_handler" function instead of multiple tools
@@ -54,7 +54,9 @@ 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.info(
+                    "ℹ️ No heartbeat response to process - this is normal for API services"
+                )
                 return result
 
             # Use the same hash-based change detection pattern as MCP
@@ -72,23 +74,31 @@ class APIDependencyResolutionStep(PipelineStep):
             # Store processed dependencies info for context
             result.add_context("dependency_count", dependency_count)
             result.add_context("dependencies_resolved", dependencies_resolved)
-            
-            result.message = "API dependency resolution completed (efficient hash-based)"
-            
+
+            result.message = (
+                "API dependency resolution completed (efficient hash-based)"
+            )
+
             if dependency_count > 0:
                 self.logger.info(f"🔗 Dependencies resolved: {dependency_count} items")
-                
+
             # 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:")
+            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")
+                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"
+            )
 
         except Exception as e:
             result.status = PipelineStatus.FAILED
@@ -100,14 +110,17 @@ class APIDependencyResolutionStep(PipelineStep):
 
     def _extract_dependency_state(
         self, heartbeat_response: dict[str, Any]
-    ) -> dict[str, dict[str, dict[str, str]]]:
+    ) -> dict[str, list[dict[str, Any]]]:
         """Extract dependency state structure from heartbeat response.
 
+        Preserves array structure and order from registry to support multiple
+        dependencies with the same capability name (e.g., different versions/tags).
+
         For API services, dependencies are typically under a single function
         (usually "api_endpoint_handler") but we still follow the same pattern.
 
         Returns:
-            {function_name: {capability: {endpoint, function_name, status}}}
+            {function_name: [{capability, endpoint, function_name, status, agent_id, kwargs}, ...]}
         """
         state = {}
         dependencies_resolved = heartbeat_response.get("dependencies_resolved", {})
@@ -116,7 +129,7 @@ class APIDependencyResolutionStep(PipelineStep):
             if not isinstance(dependency_list, list):
                 continue
 
-            state[function_name] = {}
+            state[function_name] = []
             for dep_resolution in dependency_list:
                 if (
                     not isinstance(dep_resolution, dict)
@@ -124,14 +137,17 @@ class APIDependencyResolutionStep(PipelineStep):
                 ):
                     continue
 
-                capability = dep_resolution["capability"]
-                state[function_name][capability] = {
-                    "endpoint": dep_resolution.get("endpoint", ""),
-                    "function_name": dep_resolution.get("function_name", ""),
-                    "status": dep_resolution.get("status", ""),
-                    "agent_id": dep_resolution.get("agent_id", ""),
-                    "kwargs": dep_resolution.get("kwargs", {}),  # Include kwargs config
-                }
+                # Preserve array structure to maintain order and support duplicate capabilities
+                state[function_name].append(
+                    {
+                        "capability": dep_resolution["capability"],
+                        "endpoint": dep_resolution.get("endpoint", ""),
+                        "function_name": dep_resolution.get("function_name", ""),
+                        "status": dep_resolution.get("status", ""),
+                        "agent_id": dep_resolution.get("agent_id", ""),
+                        "kwargs": dep_resolution.get("kwargs", {}),
+                    }
+                )
 
         return state
 
@@ -220,44 +236,61 @@ class APIDependencyResolutionStep(PipelineStep):
 
             injector = get_global_injector()
 
-            # Step 1: Collect all capabilities that should exist according to registry
-            target_capabilities = set()
-            for function_name, dependencies in current_state.items():
-                for capability in dependencies.keys():
-                    target_capabilities.add(capability)
-
-            # Step 2: Find existing capabilities that need to be removed (unwired)
+            # Step 1: Collect all dependency keys (func_id:dep_index) that should exist
+            # Map tool names to func_ids first
+            from ...engine.decorator_registry import DecoratorRegistry
+
+            tool_name_to_func_id = {}
+            mesh_tools = DecoratorRegistry.get_mesh_tools()
+            for tool_name, decorated_func in mesh_tools.items():
+                func = decorated_func.function
+                func_id = f"{func.__module__}.{func.__qualname__}"
+                tool_name_to_func_id[tool_name] = func_id
+
+            target_dependency_keys = set()
+            for function_name, dependency_list in current_state.items():
+                # Map tool name to func_id
+                func_id = tool_name_to_func_id.get(function_name, function_name)
+                for dep_index in range(len(dependency_list)):
+                    dep_key = f"{func_id}:dep_{dep_index}"
+                    target_dependency_keys.add(dep_key)
+
+            # Step 2: Find existing dependency keys that need to be removed (unwired)
             # This handles the case where registry stops reporting some dependencies
-            existing_capabilities = (
+            existing_dependency_keys = (
                 set(injector._dependencies.keys())
                 if hasattr(injector, "_dependencies")
                 else set()
             )
-            capabilities_to_remove = existing_capabilities - target_capabilities
+            keys_to_remove = existing_dependency_keys - target_dependency_keys
 
             unwired_count = 0
-            for capability in capabilities_to_remove:
-                await injector.unregister_dependency(capability)
+            for dep_key in keys_to_remove:
+                await injector.unregister_dependency(dep_key)
                 unwired_count += 1
                 self.logger.info(
-                    f"🗑️ Unwired API dependency '{capability}' (no longer reported by registry)"
+                    f"🗑️ Unwired API dependency '{dep_key}' (no longer reported by registry)"
                 )
 
-            # Step 3: Apply all dependency updates for capabilities that should exist
+            # Step 3: Apply all dependency updates using positional indexing
             updated_count = 0
-            for function_name, dependencies in current_state.items():
-                for capability, dep_info in dependencies.items():
+            for function_name, dependency_list in current_state.items():
+                # Map tool name to func_id (using mapping from Step 1)
+                func_id = tool_name_to_func_id.get(function_name, function_name)
+
+                for dep_index, dep_info in enumerate(dependency_list):
                     status = dep_info["status"]
                     endpoint = dep_info["endpoint"]
                     dep_function_name = dep_info["function_name"]
-                    kwargs_config = dep_info.get("kwargs", {})  # Extract kwargs config
+                    capability = dep_info["capability"]
+                    kwargs_config = dep_info.get("kwargs", {})
 
                     if status == "available" and endpoint and dep_function_name:
                         # Import here to avoid circular imports
                         import os
 
-                        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
@@ -315,27 +348,37 @@ class APIDependencyResolutionStep(PipelineStep):
                                 kwargs_config=kwargs_config,
                             )
 
-                        # Update in injector (this will update ALL route handlers that depend on this capability)
-                        self.logger.debug(f"🔄 Before update: registering {capability} = {type(new_proxy).__name__}")
-                        await injector.register_dependency(capability, new_proxy)
+                        # 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(capability, set())
-                        self.logger.debug(f"🎯 Functions affected by '{capability}' update: {list(affected_functions)}")
-                        
+                        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}' → {endpoint}/{dep_function_name} "
+                            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})"
+                        )
                     else:
                         if status != "available":
                             self.logger.debug(
-                                f"⚠️ API dependency '{capability}' not available: {status}"
+                                f"⚠️ API dependency '{capability}' at position {dep_index} not available: {status}"
                             )
                         else:
                             self.logger.warning(
-                                f"⚠️ Cannot update API dependency '{capability}': 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)
@@ -364,10 +407,12 @@ class APIDependencyResolutionStep(PipelineStep):
             )
             # Don't raise - this should not break the heartbeat loop
 
-    def _determine_api_proxy_type_for_capability(self, capability: str, injector) -> str:
+    def _determine_api_proxy_type_for_capability(
+        self, capability: str, injector
+    ) -> str:
         """
         Determine which proxy type to use for API route handlers.
-        
+
         For API services, we need to check the parameter types used in FastAPI route handlers
         that depend on this capability. This is different from MCP tools because route handlers
         are wrapped differently.
@@ -449,17 +494,21 @@ class APIDependencyResolutionStep(PipelineStep):
             return "MCPClientProxy"  # Safe default
 
     def _create_proxy_for_api(
-        self, proxy_type: str, endpoint: str, dep_function_name: str, kwargs_config: dict
+        self,
+        proxy_type: str,
+        endpoint: str,
+        dep_function_name: str,
+        kwargs_config: dict,
     ):
         """
         Create the appropriate proxy instance for API route handlers.
-        
+
         Args:
             proxy_type: "FullMCPProxy" or "MCPClientProxy"
             endpoint: Target endpoint URL
             dep_function_name: Target function name
             kwargs_config: Additional configuration (timeout, retry, etc.)
-            
+
         Returns:
             Proxy instance
         """
@@ -503,4 +552,4 @@ class APIDependencyResolutionStep(PipelineStep):
                     kwargs_config=kwargs_config,
                 )
                 self.logger.debug("🔧 Created MCPClientProxy for API (no kwargs)")
-            return proxy
+            return proxy

_mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py

@@ -82,11 +82,14 @@ class DependencyResolutionStep(PipelineStep):
 
     def _extract_dependency_state(
         self, heartbeat_response: dict[str, Any]
-    ) -> dict[str, dict[str, dict[str, str]]]:
+    ) -> dict[str, list[dict[str, Any]]]:
         """Extract dependency state structure from heartbeat response.
 
+        Preserves array structure and order from registry to support multiple
+        dependencies with the same capability name (e.g., different versions/tags).
+
         Returns:
-            {function_name: {capability: {endpoint, function_name, status}}}
+            {function_name: [{capability, endpoint, function_name, status, agent_id, kwargs}, ...]}
         """
         state = {}
         dependencies_resolved = heartbeat_response.get("dependencies_resolved", {})
@@ -95,7 +98,7 @@ class DependencyResolutionStep(PipelineStep):
             if not isinstance(dependency_list, list):
                 continue
 
-            state[function_name] = {}
+            state[function_name] = []
             for dep_resolution in dependency_list:
                 if (
                     not isinstance(dep_resolution, dict)
@@ -103,13 +106,17 @@ class DependencyResolutionStep(PipelineStep):
                 ):
                     continue
 
-                capability = dep_resolution["capability"]
-                state[function_name][capability] = {
-                    "endpoint": dep_resolution.get("endpoint", ""),
-                    "function_name": dep_resolution.get("function_name", ""),
-                    "status": dep_resolution.get("status", ""),
-                    "agent_id": dep_resolution.get("agent_id", ""),
-                }
+                # Preserve array structure to maintain order and support duplicate capabilities
+                state[function_name].append(
+                    {
+                        "capability": dep_resolution["capability"],
+                        "endpoint": dep_resolution.get("endpoint", ""),
+                        "function_name": dep_resolution.get("function_name", ""),
+                        "status": dep_resolution.get("status", ""),
+                        "agent_id": dep_resolution.get("agent_id", ""),
+                        "kwargs": dep_resolution.get("kwargs", {}),
+                    }
+                )
 
         return state
 
@@ -194,37 +201,54 @@ class DependencyResolutionStep(PipelineStep):
 
             injector = get_global_injector()
 
-            # Step 1: Collect all capabilities that should exist according to registry
-            target_capabilities = set()
-            for function_name, dependencies in current_state.items():
-                for capability in dependencies.keys():
-                    target_capabilities.add(capability)
-
-            # Step 2: Find existing capabilities that need to be removed (unwired)
+            # Step 1: Collect all dependency keys (func_id:dep_index) that should exist
+            # Map tool names to func_ids first
+            from ...engine.decorator_registry import DecoratorRegistry
+
+            tool_name_to_func_id = {}
+            mesh_tools = DecoratorRegistry.get_mesh_tools()
+            for tool_name, decorated_func in mesh_tools.items():
+                func = decorated_func.function
+                func_id = f"{func.__module__}.{func.__qualname__}"
+                tool_name_to_func_id[tool_name] = func_id
+
+            target_dependency_keys = set()
+            for function_name, dependency_list in current_state.items():
+                # Map tool name to func_id
+                func_id = tool_name_to_func_id.get(function_name, function_name)
+                for dep_index in range(len(dependency_list)):
+                    dep_key = f"{func_id}:dep_{dep_index}"
+                    target_dependency_keys.add(dep_key)
+
+            # Step 2: Find existing dependency keys that need to be removed (unwired)
             # This handles the case where registry stops reporting some dependencies
-            existing_capabilities = (
+            existing_dependency_keys = (
                 set(injector._dependencies.keys())
                 if hasattr(injector, "_dependencies")
                 else set()
             )
-            capabilities_to_remove = existing_capabilities - target_capabilities
+            keys_to_remove = existing_dependency_keys - target_dependency_keys
 
             unwired_count = 0
-            for capability in capabilities_to_remove:
-                await injector.unregister_dependency(capability)
+            for dep_key in keys_to_remove:
+                await injector.unregister_dependency(dep_key)
                 unwired_count += 1
                 self.logger.info(
-                    f"🗑️ Unwired dependency '{capability}' (no longer reported by registry)"
+                    f"🗑️ Unwired dependency '{dep_key}' (no longer reported by registry)"
                 )
 
-            # Step 3: Apply all dependency updates for capabilities that should exist
+            # Step 3: Apply all dependency updates using positional indexing
             updated_count = 0
-            for function_name, dependencies in current_state.items():
-                for capability, dep_info in dependencies.items():
+            for function_name, dependency_list in current_state.items():
+                # Map tool name to func_id (using mapping from Step 1)
+                func_id = tool_name_to_func_id.get(function_name, function_name)
+
+                for dep_index, dep_info in enumerate(dependency_list):
                     status = dep_info["status"]
                     endpoint = dep_info["endpoint"]
                     dep_function_name = dep_info["function_name"]
-                    kwargs_config = dep_info.get("kwargs", {})  # NEW: Extract kwargs
+                    capability = dep_info["capability"]
+                    kwargs_config = dep_info.get("kwargs", {})
 
                     if status == "available" and endpoint and dep_function_name:
                         # Import here to avoid circular imports
@@ -311,17 +335,21 @@ class DependencyResolutionStep(PipelineStep):
                                 f"timeout={kwargs_config.get('timeout', 30)}s, streaming={kwargs_config.get('streaming', False)}"
                             )
 
-                        # Update in injector (this will update ALL functions that depend on this capability)
-                        await injector.register_dependency(capability, new_proxy)
+                        # Register with composite key using func_id (not tool name) to match injector lookup
+                        dep_key = f"{func_id}:dep_{dep_index}"
+                        await injector.register_dependency(dep_key, new_proxy)
                         updated_count += 1
+                        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"⚠️ Dependency '{capability}' not available: {status}"
+                                f"⚠️ Dependency '{capability}' at position {dep_index} not available: {status}"
                             )
                         else:
                             self.logger.warning(
-                                f"⚠️ Cannot update dependency '{capability}': missing endpoint or function_name"
+                                f"⚠️ Cannot update dependency '{capability}' at position {dep_index}: missing endpoint or function_name"
                             )
 
             # Store new hash for next comparison (use global variable)

{mcp_mesh-0.5.6.dist-info → mcp_mesh-0.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.5.6
+Version: 0.5.7
 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.5.6.dist-info → mcp_mesh-0.5.7.dist-info}/RECORD

@@ -1,15 +1,15 @@
-_mcp_mesh/__init__.py,sha256=uw4Yj9HoBfp-_CyH8izKGYKrrCI-dF9uwMLMNgkIMN0,2719
+_mcp_mesh/__init__.py,sha256=CTRyqemXkVmKL85NBmkaOB9AN-FOZxseOKEnV_s7AMk,2719
 _mcp_mesh/engine/__init__.py,sha256=2ennzbo7yJcpkXO9BqN69TruLjJfmJY4Y5VEsG644K4,3630
 _mcp_mesh/engine/async_mcp_client.py,sha256=UcbQjxtgVfeRw6DHTZhAzN1gkcKlTg-lUPEePRPQWAU,6306
 _mcp_mesh/engine/decorator_registry.py,sha256=0-GI7DILpbB6GRLIYhZu0DcdHEA62d89jDYxkK1ywiM,22422
-_mcp_mesh/engine/dependency_injector.py,sha256=B1iRxtIXq_z4LnJ6NTs0ZPdEIlijrMJv5KbDpQbq9iw,23752
+_mcp_mesh/engine/dependency_injector.py,sha256=k6PzG9te1J5DbuDV2OrErXM3AcV1X6_ZvCy5KFYo1nk,27496
 _mcp_mesh/engine/full_mcp_proxy.py,sha256=PlRv7GSKqn5riOCqeCVulVdtq3z1Ug76mOkwMsOFHXw,25297
 _mcp_mesh/engine/http_wrapper.py,sha256=PeYR7HkJVX7Hb0W-uYSMO-Y14VqCyrPlWzA6vnwf1Tw,21640
 _mcp_mesh/engine/mcp_client_proxy.py,sha256=eJStwy_VQJexYYD8bOh_m4Ld3Bb8Ae_dt8N1CC41qBc,17625
 _mcp_mesh/engine/self_dependency_proxy.py,sha256=OkKt0-B_ADnJlWtHiHItoZCBZ7Su0iz2unEPFfXvrs4,3302
 _mcp_mesh/engine/session_aware_client.py,sha256=mc9eh-aCvUvfllORiXTf_X8_jPqV-32QdWKlr8tHLkU,10600
 _mcp_mesh/engine/session_manager.py,sha256=MCr0_fXBaUjXM51WU5EhDkiGvBdfzYQFVNb9DCXXL0A,10418
-_mcp_mesh/engine/signature_analyzer.py,sha256=AxBuFq8_TCT2afw_XDF4AjWPqdG6ST5jfbw2BDdp9Mo,7482
+_mcp_mesh/engine/signature_analyzer.py,sha256=w5mvnRo1cc31the6OZln5keOVJphL26V6jDAHVNA29A,7946
 _mcp_mesh/engine/unified_mcp_proxy.py,sha256=33xm-jABTYUwr_uIB6mx4yNlNJrsvstCHJOMTdcm-pg,36365
 _mcp_mesh/generated/.openapi-generator-ignore,sha256=-d-Y-RVAZRrHw36jO0b79oDXpfA8rZdBGPCG4Vs_rUs,227
 _mcp_mesh/generated/.openapi-generator/FILES,sha256=BXFXHe4FTV5GFUTNjMhmvOrVcYVlHJc5O-3UXyp8OCY,2169
@@ -57,7 +57,7 @@ _mcp_mesh/generated/mcp_mesh_registry_client/models/standardized_dependency.py,s
 _mcp_mesh/generated/mcp_mesh_registry_client/models/trace_event.py,sha256=9Q_8WaVl0MxswRnHpkqq9GKnvOW54HW4tkrTM9oda14,4461
 _mcp_mesh/pipeline/__init__.py,sha256=9Aplh4m1z-rYTQys0JQLYlq9wTPdI72eSOhUPqcnvpA,1557
 _mcp_mesh/pipeline/api_heartbeat/__init__.py,sha256=IXTLoQLAPqQEWZ8VMWc5W_cQJkDv95rlVGXyXoQDjHk,473
-_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py,sha256=EcWfqZ2IWcagt0pGkVa944uW7KePABVXn6CPAAspjYo,23582
+_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py,sha256=uVv7KjEfVO_5Ny3fgC_DD9B8dg_IIUdJmtGVrTaSStU,25312
 _mcp_mesh/pipeline/api_heartbeat/api_fast_heartbeat_check.py,sha256=PY4bbuZgxy3r0ccuBl-OuJvcPSMhyGz4FomxwYFhuvM,4821
 _mcp_mesh/pipeline/api_heartbeat/api_health_check.py,sha256=kDmFeOG_4tyqyJSBZjPcc7xTzGpP4vq6ObW_WBqXvzM,5130
 _mcp_mesh/pipeline/api_heartbeat/api_heartbeat_orchestrator.py,sha256=uBswzWOBzU8p_C0AE2DF8UwIWG4rP2zecHfPqKzNuC0,10367
@@ -73,7 +73,7 @@ _mcp_mesh/pipeline/api_startup/middleware_integration.py,sha256=ybImXZlmIR6yA-wY
 _mcp_mesh/pipeline/api_startup/route_collection.py,sha256=UjA-F5_RbGVU5TfDT19Np5_x2PtYkNn2mGFyivDsk24,2031
 _mcp_mesh/pipeline/api_startup/route_integration.py,sha256=aMT7p7cwK8N3tZBRqeGQF8upc7tU-Exj6Dz0a4cSBhU,13441
 _mcp_mesh/pipeline/mcp_heartbeat/__init__.py,sha256=nRNjZ3VD_9bPLQuJ6Nc02gE7KSLcMP7TMquB0hP6hHs,844
-_mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py,sha256=nHjKSM4Yyn05wnfw1dI4VGroHZy8lRkDihnZfFHeF8U,16217
+_mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py,sha256=qQ1KhrRYroYL2nnjLufXsXaaAO593GnuvJrRy_Ws97k,17764
 _mcp_mesh/pipeline/mcp_heartbeat/fast_heartbeat_check.py,sha256=QTzYdL81WERkOaBVOgNbFQh1ddTn70urNtyIgtFTudA,4465
 _mcp_mesh/pipeline/mcp_heartbeat/heartbeat_orchestrator.py,sha256=uB9o298X7GbOaKUw4ij_fUAOCpK0n2brx_oWqWGTXFY,11296
 _mcp_mesh/pipeline/mcp_heartbeat/heartbeat_pipeline.py,sha256=Jb7EVJO13trUVO3aCSgzGqAtoc4vie5kDrYLZtOkiXg,11601
@@ -118,7 +118,7 @@ _mcp_mesh/tracing/utils.py,sha256=t9lJuTH7CeuzAiiAaD0WxsJMFJPdzZFR0w6-vyR9f2E,38
 mesh/__init__.py,sha256=l5RSMV8Kx0h7cvku8YkZPbTHjEPWciGT0bcEB2O_eNU,3242
 mesh/decorators.py,sha256=oBWoRE-FA3qUGygAUtk3-eAYBckwTGfTzvXOgCag4ys,36678
 mesh/types.py,sha256=g37DXAzya-xGPa1_WKlW3T3_VqyTn8ZVepIDSrhBTkc,10815
-mcp_mesh-0.5.6.dist-info/METADATA,sha256=Mh8nwL5wjm53WMFPOqcVHCRmcvbPa4sgMmX7bQV-yiw,4879
-mcp_mesh-0.5.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_mesh-0.5.6.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
-mcp_mesh-0.5.6.dist-info/RECORD,,
+mcp_mesh-0.5.7.dist-info/METADATA,sha256=mouhZmaO4Ce2rGSiCRXJXVNA-aRxBc-seygYUCKmJhI,4879
+mcp_mesh-0.5.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_mesh-0.5.7.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
+mcp_mesh-0.5.7.dist-info/RECORD,,