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

_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/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.dist-info → mcp_mesh-0.6.3.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-_mcp_mesh/__init__.py,sha256=clPVaqkd4Zh5UgF9PBvxKDtvAoWj5PIizG_AxykX15g,2719
+_mcp_mesh/__init__.py,sha256=4Pk7c0F7B-b6m0mHql0kvKWn6HEFWJmd-mRFEkin6VY,2719
 _mcp_mesh/engine/__init__.py,sha256=2ennzbo7yJcpkXO9BqN69TruLjJfmJY4Y5VEsG644K4,3630
 _mcp_mesh/engine/async_mcp_client.py,sha256=UcbQjxtgVfeRw6DHTZhAzN1gkcKlTg-lUPEePRPQWAU,6306
 _mcp_mesh/engine/base_injector.py,sha256=qzRLZqFP2VvEFagVovkpdldvDmm3VwPHm6tHwV58a2k,5648
@@ -6,12 +6,12 @@ _mcp_mesh/engine/decorator_registry.py,sha256=sb4Ng2y0hZovFzmrLdRCiwIEdwCm57WUD9
 _mcp_mesh/engine/dependency_injector.py,sha256=1bjeJ7pHUPEF_IoTF-7_Wm1pDLHphtfcFfSrUPWrWI4,31230
 _mcp_mesh/engine/full_mcp_proxy.py,sha256=PlRv7GSKqn5riOCqeCVulVdtq3z1Ug76mOkwMsOFHXw,25297
 _mcp_mesh/engine/http_wrapper.py,sha256=T9VQ2LZbGgCzyOVXVwdqas7-W3Wid0EwRboFUpdYWtM,20718
-_mcp_mesh/engine/llm_config.py,sha256=UOOfQbhYcljT9TsJJg_edwpk_5H4ZXQ6L1QARgiy8oc,1649
+_mcp_mesh/engine/llm_config.py,sha256=95bOsGWro5E1JGq7oZtEYhVdrzcIJqjht_r5vEdJVz4,2049
 _mcp_mesh/engine/llm_errors.py,sha256=h7BiI14u-jL8vtvBfFbFDDrN7gIw8PQjXIl5AP1SBuA,3276
 _mcp_mesh/engine/mcp_client_proxy.py,sha256=eJStwy_VQJexYYD8bOh_m4Ld3Bb8Ae_dt8N1CC41qBc,17625
-_mcp_mesh/engine/mesh_llm_agent.py,sha256=h83F7ZJWGv048tnXmNsD8HnmA0_t7D-aEWuCfke7psI,24038
-_mcp_mesh/engine/mesh_llm_agent_injector.py,sha256=Mh4dndOMfd_K-XWFSuuPFHo6u4tHyyTKq4GjdvX6mu8,24777
-_mcp_mesh/engine/response_parser.py,sha256=4_yEnxvHGvfgo7oqikgpjEjHuZRpBqBPJ_1QTH9YZOs,6943
+_mcp_mesh/engine/mesh_llm_agent.py,sha256=CcS2WX0ku1DSwUSx0H9YdV7oIiPNMs1jbxSPJvScRao,24679
+_mcp_mesh/engine/mesh_llm_agent_injector.py,sha256=isufzCBExli8tdLUZOaPuea3uQs3C_yeVXbOVSF0YIU,27270
+_mcp_mesh/engine/response_parser.py,sha256=NsOuGD7HJ0BFiiDUCp9v9cjLzVaU86HShVKzsrNnulk,8786
 _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
@@ -21,9 +21,9 @@ _mcp_mesh/engine/tool_schema_builder.py,sha256=SQCxQIrSfdLu9-dLqiFurQLK7dhl0dc0x
 _mcp_mesh/engine/unified_mcp_proxy.py,sha256=SmhLWXdjmgvJWOLGQk-cXrvYjGSzx98HzL0Q5jpMNIY,36326
 _mcp_mesh/engine/provider_handlers/__init__.py,sha256=LLTCOgnuM3dlogbLmrpiMK3oB5L22eAmDC4BfxJ-L2I,593
 _mcp_mesh/engine/provider_handlers/base_provider_handler.py,sha256=J-SPFFFG1eFSUVvfsv7y4EuNM4REjSxaYWC5E_lC6Pc,4195
-_mcp_mesh/engine/provider_handlers/claude_handler.py,sha256=woTDtrDgv0UlXgbDxnOxE92i7VWTDWCG5NRwZitm6Cs,4875
+_mcp_mesh/engine/provider_handlers/claude_handler.py,sha256=CCmlsWiCfIcgrLbAZzeSnl0g2pq0uDffT8zOj4F-sPQ,15727
 _mcp_mesh/engine/provider_handlers/generic_handler.py,sha256=ewcwxWMmNEFEeBJ_2m16Oc3SnhCKpc0PVDtKy7TsLv0,5153
-_mcp_mesh/engine/provider_handlers/openai_handler.py,sha256=YKLnY1epdnoFDOm8LsuwGOIvkyJ4bSaEdArNxyHyaYQ,5511
+_mcp_mesh/engine/provider_handlers/openai_handler.py,sha256=rpHvnOfZkk73uICgU4pKe-BsWts4cQeykm_UXkAA3Rk,7754
 _mcp_mesh/engine/provider_handlers/provider_handler_registry.py,sha256=d2G3vndANzTiNl2ApfJuE2bmOlUI88y42144PjVst4s,5605
 _mcp_mesh/generated/.openapi-generator-ignore,sha256=5opOTZ_fahF3ctMAmN-i3PzJXM0d9Tnji_uAET2ZyEw,162
 _mcp_mesh/generated/.openapi-generator/FILES,sha256=Jpd-j6le0SjEvwdAJ51SWdZrlOUrUAFLtQ4sCHZVdKk,2571
@@ -78,7 +78,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=jo5SmI52T7Vz9yEz5O78SHYh-HyJtpzdOxoa5EylHsI,22011
+_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py,sha256=Q96auBnbypPnxTjiThtKMIezuZ_hUj30JaPNOZc87ng,24096
 _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
@@ -94,7 +94,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=qQ1KhrRYroYL2nnjLufXsXaaAO593GnuvJrRy_Ws97k,17764
+_mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py,sha256=vW-qrpneBLxxQtUEwEjE7aUTv5cIO9rjDg3Bxv7nj4I,18846
 _mcp_mesh/pipeline/mcp_heartbeat/fast_heartbeat_check.py,sha256=2SKHHFTxlYwad_D8a6E7NNtWfH89jBrIO5dQAwM3Xdw,4468
 _mcp_mesh/pipeline/mcp_heartbeat/heartbeat_orchestrator.py,sha256=DYX35H3edra_1qbnNzjmtnYit0oVLDIHidLoQUjeULU,12556
 _mcp_mesh/pipeline/mcp_heartbeat/heartbeat_pipeline.py,sha256=BzoZK9PmE6vQEt8vs8_oiKBiTa9ba3IruBHebnvWaGI,11767
@@ -140,10 +140,10 @@ _mcp_mesh/tracing/trace_context_helper.py,sha256=6tEkwjWFqMBe45zBlhacktmIpzJWTF9
 _mcp_mesh/tracing/utils.py,sha256=t9lJuTH7CeuzAiiAaD0WxsJMFJPdzZFR0w6-vyR9f2E,3849
 _mcp_mesh/utils/fastmcp_schema_extractor.py,sha256=M54ffesC-56zl_fNJHj9dZxElDQaWFf1MXdSLCuFStg,17253
 mesh/__init__.py,sha256=0zequaBtd_9NLOLsr9sNONuwWa_fT_-G4LnJ1CHTEY0,3808
-mesh/decorators.py,sha256=iCneI4xgihw1cc22mx0K-OnMIOLbh47EtwgTvPGTRzk,54126
+mesh/decorators.py,sha256=QTd1wJ8XV0Pfjq2ejyXjyeXBtyodbj1gbs5WKG9AFTs,55632
 mesh/helpers.py,sha256=c3FhSy9U4KBHEH6WH6MjCVrPMw9li5JAgBLUTIoamz4,9472
 mesh/types.py,sha256=9TqbJSxlybLQaPVjugcKwPiIrVnJEzqAOvPRhlX1zmo,15559
-mcp_mesh-0.6.1.dist-info/METADATA,sha256=sZTDo2nBovUuMEgTpPX0Su81EnyUR3XHSsxEuh52g0w,4879
-mcp_mesh-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_mesh-0.6.1.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
-mcp_mesh-0.6.1.dist-info/RECORD,,
+mcp_mesh-0.6.3.dist-info/METADATA,sha256=6xLJu280gn5O2D1OUOZYAwOVGtQVf0g2tHDk3XnRXz8,4879
+mcp_mesh-0.6.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mcp_mesh-0.6.3.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
+mcp_mesh-0.6.3.dist-info/RECORD,,

{mcp_mesh-0.6.1.dist-info → mcp_mesh-0.6.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

mesh/decorators.py

@@ -989,6 +989,39 @@ def set_shutdown_context(context: dict[str, Any]):
     set_global_shutdown_context(context)
 
 
+def _get_llm_agent_for_injection(
+    wrapper: Any, param_name: str, kwargs: dict, func_name: str
+) -> Any:
+    """
+    Get the appropriate LLM agent for injection based on template mode.
+
+    Handles both template-based (per-call context) and non-template (cached) modes.
+
+    Args:
+        wrapper: The wrapper function with _mesh_llm_* attributes
+        param_name: Name of the LLM parameter to inject
+        kwargs: Current call kwargs (may contain context value)
+        func_name: Function name for logging
+
+    Returns:
+        MeshLlmAgent instance (either per-call with context or cached)
+    """
+    config = getattr(wrapper, "_mesh_llm_config", {})
+    is_template = config.get("is_template", False)
+    context_param_name = config.get("context_param")
+    create_context_agent = getattr(wrapper, "_mesh_create_context_agent", None)
+
+    if is_template and context_param_name and create_context_agent:
+        # Template mode: create per-call agent with context
+        context_value = kwargs.get(context_param_name)
+        if context_value is not None:
+            logger.debug(f"🎯 Created per-call LLM agent with context for {func_name}")
+            return create_context_agent(context_value)
+
+    # Non-template mode or no context provided: use cached agent
+    return wrapper._mesh_llm_agent
+
+
 def llm(
     filter: dict[str, Any] | list[dict[str, Any] | str] | str | None = None,
     *,
@@ -1247,7 +1280,9 @@ def llm(
                 """Wrapper that injects both MeshLlmAgent and DI parameters."""
                 # Inject LLM parameter if not provided or if it's None
                 if param_name not in kwargs or kwargs.get(param_name) is None:
-                    kwargs[param_name] = combined_injection_wrapper._mesh_llm_agent
+                    kwargs[param_name] = _get_llm_agent_for_injection(
+                        combined_injection_wrapper, param_name, kwargs, func.__name__
+                    )
                 # Then call the original wrapper (which handles DI injection)
                 return original_call(*args, **kwargs)
 
@@ -1310,7 +1345,9 @@ def llm(
                 """Wrapper that injects MeshLlmAgent parameter."""
                 # Inject llm parameter if not provided or if it's None
                 if param_name not in kwargs or kwargs.get(param_name) is None:
-                    kwargs[param_name] = llm_injection_wrapper._mesh_llm_agent
+                    kwargs[param_name] = _get_llm_agent_for_injection(
+                        llm_injection_wrapper, param_name, kwargs, func.__name__
+                    )
                 return func(*args, **kwargs)
 
             # Create update method for heartbeat - updates the wrapper, not func