mcp-mesh 0.6.1__tar.gz → 0.6.2__tar.gz

{mcp_mesh-0.6.1 → mcp_mesh-0.6.2}/.gitignore

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

{mcp_mesh-0.6.1 → mcp_mesh-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.6.1
+Version: 0.6.2
 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.1 → mcp_mesh-0.6.2}/_mcp_mesh/__init__.py

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

{mcp_mesh-0.6.1 → mcp_mesh-0.6.2}/_mcp_mesh/engine/mesh_llm_agent_injector.py

@@ -19,6 +19,35 @@ from .unified_mcp_proxy import UnifiedMCPProxy
 logger = logging.getLogger(__name__)
 
 
+def extract_vendor_from_model(model: str) -> str | None:
+    """
+    Extract vendor name from LiteLLM model string.
+
+    LiteLLM uses vendor/model format (e.g., "anthropic/claude-sonnet-4-5").
+    This extracts the vendor for provider handler selection.
+
+    Args:
+        model: LiteLLM model string
+
+    Returns:
+        Vendor name (e.g., "anthropic", "openai") or None if not extractable
+
+    Examples:
+        "anthropic/claude-sonnet-4-5" -> "anthropic"
+        "openai/gpt-4o" -> "openai"
+        "gpt-4" -> None (no vendor prefix)
+    """
+    if not model:
+        return None
+
+    if "/" in model:
+        vendor = model.split("/")[0].lower().strip()
+        logger.debug(f"🔍 Extracted vendor '{vendor}' from model '{model}'")
+        return vendor
+
+    return None
+
+
 class MeshLlmAgentInjector(BaseInjector):
     """
     Manages dynamic injection of MeshLlmAgent proxies.
@@ -86,9 +115,7 @@ class MeshLlmAgentInjector(BaseInjector):
                     exc_info=True,
                 )
 
-    def process_llm_providers(
-        self, llm_providers: dict[str, dict[str, Any]]
-    ) -> None:
+    def process_llm_providers(self, llm_providers: dict[str, dict[str, Any]]) -> None:
         """
         Process llm_providers from registry response (v0.6.1 mesh delegation).
 
@@ -181,9 +208,7 @@ class MeshLlmAgentInjector(BaseInjector):
         """
         function_name = provider_data.get("name")
         if not function_name:
-            raise ValueError(
-                f"Provider missing required 'name' field: {provider_data}"
-            )
+            raise ValueError(f"Provider missing required 'name' field: {provider_data}")
 
         endpoint = provider_data.get("endpoint")
         if not endpoint:
@@ -493,6 +518,19 @@ class MeshLlmAgentInjector(BaseInjector):
         is_template = config_dict.get("is_template", False)
         template_path = config_dict.get("template_path")
 
+        # Determine vendor for provider handler selection
+        # Priority: 1) From registry (mesh delegation), 2) From model name, 3) None
+        vendor = llm_agent_data.get("vendor")
+        if not vendor:
+            # For direct LiteLLM calls, extract vendor from model name
+            # e.g., "anthropic/claude-sonnet-4-5" -> "anthropic"
+            model = config_dict.get("model", "")
+            vendor = extract_vendor_from_model(model)
+            if vendor:
+                logger.info(
+                    f"🔍 Extracted vendor '{vendor}' from model '{model}' for handler selection"
+                )
+
         # Create MeshLlmAgent with both metadata and proxies
         llm_agent = MeshLlmAgent(
             config=llm_config,
@@ -503,14 +541,20 @@ class MeshLlmAgentInjector(BaseInjector):
             tool_proxies=llm_agent_data["tools_proxies"],  # Proxies for execution
             template_path=template_path if is_template else None,
             context_value=context_value if is_template else None,
-            provider_proxy=llm_agent_data.get("provider_proxy"),  # Provider proxy for mesh delegation
-            vendor=llm_agent_data.get("vendor"),  # Phase 2: Vendor for provider handler selection
+            provider_proxy=llm_agent_data.get(
+                "provider_proxy"
+            ),  # Provider proxy for mesh delegation
+            vendor=vendor,  # Vendor for provider handler selection (from registry or model name)
         )
 
         logger.debug(
             f"🤖 Created MeshLlmAgent for {function_id} with {len(llm_agent_data['tools_metadata'])} tools"
             + (f", template={template_path}" if is_template else "")
-            + (f", provider_proxy={llm_agent_data.get('provider_proxy').function_name if llm_agent_data.get('provider_proxy') else 'None'}" if isinstance(config_dict.get("provider"), dict) else "")
+            + (
+                f", provider_proxy={llm_agent_data.get('provider_proxy').function_name if llm_agent_data.get('provider_proxy') else 'None'}"
+                if isinstance(config_dict.get("provider"), dict)
+                else ""
+            )
         )
 
         return llm_agent

{mcp_mesh-0.6.1 → mcp_mesh-0.6.2}/_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py

@@ -228,11 +228,10 @@ class APIDependencyResolutionStep(PipelineStep):
 
             # 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()
 
@@ -289,13 +288,16 @@ 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"]
@@ -328,18 +330,48 @@ class APIDependencyResolutionStep(PipelineStep):
                         )
 
                         if is_self_dependency:
-                            # Note: Self-dependencies are unusual for API services but we handle them
-                            self.logger.warning(
-                                f"⚠️ API SELF-DEPENDENCY detected for '{capability}' - "
-                                f"this is unusual for API services. Consider refactoring."
-                            )
-                            # For API services, we don't have access to original functions in the same way
-                            # Fall back to unified proxy (same as cross-service)
-                            new_proxy = EnhancedUnifiedMCPProxy(
-                                endpoint,
-                                dep_function_name,
-                                kwargs_config=kwargs_config,
-                            )
+                            # Create self-dependency proxy with WRAPPER function (not original)
+                            # The wrapper has dependency injection logic, so calling it ensures
+                            # the target function's dependencies are also injected properly.
+                            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}' "
+                                    f"(local call with full DI support)"
+                                )
+                            else:
+                                # Fallback to original function if wrapper not found
+                                original_func = injector.find_original_function(
+                                    dep_function_name
+                                )
+                                if original_func:
+                                    new_proxy = SelfDependencyProxy(
+                                        original_func, dep_function_name
+                                    )
+                                    self.logger.warning(
+                                        f"⚠️ API SELF-DEPENDENCY: Using original function for '{capability}' "
+                                        f"(wrapper not found, DI may not work for nested deps)"
+                                    )
+                                else:
+                                    self.logger.warning(
+                                        f"⚠️ API SELF-DEPENDENCY: Cannot create SelfDependencyProxy for '{capability}', "
+                                        f"falling back to HTTP (may cause issues)"
+                                    )
+                                    # Fall back to unified proxy (same as cross-service)
+                                    new_proxy = EnhancedUnifiedMCPProxy(
+                                        endpoint,
+                                        dep_function_name,
+                                        kwargs_config=kwargs_config,
+                                    )
                         else:
                             # Create cross-service proxy using unified proxy (same as MCP pipeline)
                             new_proxy = EnhancedUnifiedMCPProxy(
@@ -450,7 +482,8 @@ 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

{mcp_mesh-0.6.1 → mcp_mesh-0.6.2}/_mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py

@@ -255,12 +255,14 @@ class DependencyResolutionStep(PipelineStep):
                         # Get current agent ID for self-dependency detection
                         import os
 
-                        from ...engine.self_dependency_proxy import SelfDependencyProxy
+                        from ...engine.self_dependency_proxy import \
+                            SelfDependencyProxy
 
                         # Get current agent ID from DecoratorRegistry (single source of truth)
                         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"]
@@ -293,36 +295,51 @@ class DependencyResolutionStep(PipelineStep):
                         )
 
                         if is_self_dependency:
-                            # Create self-dependency proxy with cached function reference
-                            original_func = injector.find_original_function(
-                                dep_function_name
-                            )
-                            if original_func:
-                                new_proxy = SelfDependencyProxy(
-                                    original_func, dep_function_name
+                            # Create self-dependency proxy with WRAPPER function (not original)
+                            # The wrapper has dependency injection logic, so calling it ensures
+                            # the target function's dependencies are also injected properly.
+                            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"
                                 )
-                                self.logger.warning(
-                                    f"⚠️ SELF-DEPENDENCY: Using direct function call for '{capability}' "
-                                    f"instead of HTTP to avoid deadlock. Consider refactoring to "
-                                    f"eliminate self-dependencies if possible."
+
+                            if wrapper_func:
+                                new_proxy = SelfDependencyProxy(
+                                    wrapper_func, dep_function_name
                                 )
                                 self.logger.info(
-                                    f"🔄 Updated to SelfDependencyProxy: '{capability}'"
+                                    f"🔄 SELF-DEPENDENCY: Using wrapper for '{capability}' "
+                                    f"(local call with full DI support)"
                                 )
                             else:
-                                self.logger.error(
-                                    f"❌ Cannot create SelfDependencyProxy for '{capability}': "
-                                    f"original function '{dep_function_name}' not found, falling back to HTTP"
-                                )
-                                # Use unified proxy for fallback
-                                new_proxy = EnhancedUnifiedMCPProxy(
-                                    endpoint,
-                                    dep_function_name,
-                                    kwargs_config=kwargs_config,
-                                )
-                                self.logger.debug(
-                                    f"🔧 Created EnhancedUnifiedMCPProxy (fallback): {kwargs_config}"
+                                # Fallback to original function if wrapper not found
+                                original_func = injector.find_original_function(
+                                    dep_function_name
                                 )
+                                if original_func:
+                                    new_proxy = SelfDependencyProxy(
+                                        original_func, dep_function_name
+                                    )
+                                    self.logger.warning(
+                                        f"⚠️ SELF-DEPENDENCY: Using original function for '{capability}' "
+                                        f"(wrapper not found, DI may not work for nested deps)"
+                                    )
+                                else:
+                                    self.logger.error(
+                                        f"❌ Cannot create SelfDependencyProxy for '{capability}': "
+                                        f"neither wrapper nor original function '{dep_function_name}' found, falling back to HTTP"
+                                    )
+                                    # Use unified proxy for fallback
+                                    new_proxy = EnhancedUnifiedMCPProxy(
+                                        endpoint,
+                                        dep_function_name,
+                                        kwargs_config=kwargs_config,
+                                    )
+                                    self.logger.debug(
+                                        f"🔧 Created EnhancedUnifiedMCPProxy (fallback): {kwargs_config}"
+                                    )
                         else:
                             # Create cross-service proxy using unified proxy
                             new_proxy = EnhancedUnifiedMCPProxy(

{mcp_mesh-0.6.1 → mcp_mesh-0.6.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mcp-mesh"
-version = "0.6.1"
+version = "0.6.2"
 description = "Kubernetes-native platform for distributed MCP applications"
 readme = "README.md"
 license = { text = "MIT" }
@@ -117,7 +117,7 @@ extend-exclude = '''
 '''
 
 [tool.ruff]
-target-version = "0.6.1"
+target-version = "0.6.2"
 line-length = 88
 
 [tool.ruff.lint]
@@ -154,7 +154,7 @@ ignore = [
 "tests/**" = ["E712", "F841", "B007", "C401", "F401"]  # Relax style requirements for test files
 
 [tool.mypy]
-python_version = "0.6.1"
+python_version = "0.6.2"
 check_untyped_defs = false  # Temporarily relaxed
 disallow_any_generics = false  # Temporarily relaxed
 disallow_incomplete_defs = false  # Temporarily relaxed
@@ -166,7 +166,7 @@ warn_return_any = false  # Temporarily relaxed
 exclude = ["tests/", ".*agent_server_generated.*", ".*registry_client_generated.*"]  # Skip type checking for test and generated files
 
 [tool.pytest.ini_options]
-minversion = "0.6.1"
+minversion = "0.6.2"
 addopts = "-ra -q --strict-markers --strict-config"
 testpaths = [
     "tests",