mcp-mesh 0.8.0__tar.gz → 0.8.0b1__tar.gz

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/.gitignore

@@ -255,11 +255,3 @@ rust-core-implementation.org
 src/runtime/core/index.js
 src/runtime/core/index.d.ts
 test/
-scaffold-test/
-
-# Test suite build outputs
-tests/src-tests/out/
-tests/lib-tests/out/
-
-# Allow test suite build artifacts
-!tests/**/build/

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.8.0
+Version: 0.8.0b1
 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
@@ -18,7 +18,6 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
@@ -31,7 +30,7 @@ Requires-Dist: fastmcp<3.0.0,>=2.8.0
 Requires-Dist: httpx<1.0.0,>=0.25.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: litellm>=1.30.0
-Requires-Dist: mcp-mesh-core>=0.8.0
+Requires-Dist: mcp-mesh-core>=0.8.0b1
 Requires-Dist: mcp<2.0.0,>=1.9.0
 Requires-Dist: prometheus-client<1.0.0,>=0.19.0
 Requires-Dist: pydantic<3.0.0,>=2.4.0
@@ -79,7 +78,7 @@ pip install mcp-mesh
 import mesh
 
 # Import types from public API
-from mesh.types import McpMeshTool
+from mesh.types import McpMeshAgent
 
 # Define your agent
 @mesh.agent(name="hello-world", http_port=9090)
@@ -93,11 +92,11 @@ class HelloWorldAgent:
     dependencies=["date_service"],
     description="Greeting function with date dependency injection"
 )
-def greet(name: str = "World", date_tool: McpMeshTool = None) -> str:
+def greet(name: str = "World", systemDate: McpMeshAgent = None) -> str:
     """Greeting function with automatic dependency injection."""
-    if date_tool is not None:
+    if systemDate is not None:
         try:
-            current_date = date_tool()
+            current_date = systemDate()
             return f"Hello, {name}! Today is {current_date}"
         except Exception:
             pass

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/README.md

@@ -14,7 +14,7 @@ pip install mcp-mesh
 import mesh
 
 # Import types from public API
-from mesh.types import McpMeshTool
+from mesh.types import McpMeshAgent
 
 # Define your agent
 @mesh.agent(name="hello-world", http_port=9090)
@@ -28,11 +28,11 @@ class HelloWorldAgent:
     dependencies=["date_service"],
     description="Greeting function with date dependency injection"
 )
-def greet(name: str = "World", date_tool: McpMeshTool = None) -> str:
+def greet(name: str = "World", systemDate: McpMeshAgent = None) -> str:
     """Greeting function with automatic dependency injection."""
-    if date_tool is not None:
+    if systemDate is not None:
         try:
-            current_date = date_tool()
+            current_date = systemDate()
             return f"Hello, {name}! Today is {current_date}"
         except Exception:
             pass

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/_mcp_mesh/__init__.py

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

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/_mcp_mesh/engine/dependency_injector.py

@@ -27,8 +27,8 @@ def analyze_injection_strategy(func: Callable, dependencies: list[str]) -> list[
     Analyze function signature and determine injection strategy.
 
     Rules:
-    1. Single parameter: inject regardless of typing (with warning if not McpMeshTool)
-    2. Multiple parameters: only inject into McpMeshTool typed parameters
+    1. Single parameter: inject regardless of typing (with warning if not McpMeshAgent)
+    2. Multiple parameters: only inject into McpMeshAgent typed parameters
     3. Log warnings for mismatches and edge cases
 
     Args:
@@ -60,17 +60,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 McpMeshTool for clarity)"
+                f"(consider typing as McpMeshAgent for clarity)"
             )
         return [0]  # Inject into the single parameter
 
-    # Multiple parameters rule: only inject into McpMeshTool typed parameters
+    # Multiple parameters rule: only inject into McpMeshAgent 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 McpMeshTool. Skipping injection of {len(dependencies)} dependencies. "
-                f"Consider typing dependency parameters as McpMeshTool."
+                f"typed as McpMeshAgent. Skipping injection of {len(dependencies)} dependencies. "
+                f"Consider typing dependency parameters as McpMeshAgent."
             )
             return []
 
@@ -80,7 +80,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)} McpMeshTool parameters. "
+                    f"but only {len(mesh_positions)} McpMeshAgent parameters. "
                     f"Dependencies {excess_deps} will not be injected."
                 )
             else:
@@ -88,7 +88,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)} McpMeshTool parameters "
+                    f"Function '{func_name}' has {len(mesh_positions)} McpMeshAgent parameters "
                     f"but only {len(dependencies)} dependencies declared. "
                     f"Parameters {excess_params} will remain None."
                 )
@@ -104,7 +104,7 @@ class DependencyInjector:
     Manages dynamic dependency injection for mesh agents.
 
     This class:
-    1. Maintains a registry of available dependencies (McpMeshTool)
+    1. Maintains a registry of available dependencies (McpMeshAgent)
     2. Coordinates with MeshLlmAgentInjector for LLM agent injection
     3. Tracks which functions depend on which services
     4. Updates function bindings when topology changes

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/_mcp_mesh/engine/mesh_llm_agent.py

@@ -14,12 +14,8 @@ from typing import Any, Dict, List, Literal, Optional, Union
 from pydantic import BaseModel
 
 from .llm_config import LLMConfig
-from .llm_errors import (
-    LLMAPIError,
-    MaxIterationsError,
-    ResponseParseError,
-    ToolExecutionError,
-)
+from .llm_errors import (LLMAPIError, MaxIterationsError, ResponseParseError,
+                         ToolExecutionError)
 from .provider_handlers import ProviderHandlerRegistry
 from .response_parser import ResponseParser
 from .tool_executor import ToolExecutor
@@ -27,7 +23,8 @@ from .tool_schema_builder import ToolSchemaBuilder
 
 # Import Jinja2 for template rendering
 try:
-    from jinja2 import Environment, FileSystemLoader, Template, TemplateSyntaxError
+    from jinja2 import (Environment, FileSystemLoader, Template,
+                        TemplateSyntaxError)
 except ImportError:
     Environment = None
     FileSystemLoader = None
@@ -636,14 +633,12 @@ IMPORTANT TOOL CALLING RULES:
             # Multi-turn conversation - use provided messages array
             messages = message.copy()
 
-            # Only add/update system message if we have non-empty content
-            # (Claude API rejects empty system messages - though decorator provides default)
-            if system_content:
-                if not messages or messages[0].get("role") != "system":
-                    messages.insert(0, {"role": "system", "content": system_content})
-                else:
-                    # Replace existing system message with our constructed one
-                    messages[0] = {"role": "system", "content": system_content}
+            # Ensure system prompt is prepended if not already present
+            if not messages or messages[0].get("role") != "system":
+                messages.insert(0, {"role": "system", "content": system_content})
+            else:
+                # Replace existing system message with our constructed one
+                messages[0] = {"role": "system", "content": system_content}
 
             # Log conversation history
             logger.info(
@@ -651,17 +646,10 @@ IMPORTANT TOOL CALLING RULES:
             )
         else:
             # Single-turn - build messages array from string
-            # Only include system message if non-empty (Claude API rejects empty system messages)
-            if system_content:
-                messages = [
-                    {"role": "system", "content": system_content},
-                    {"role": "user", "content": message},
-                ]
-            else:
-                # Fallback for edge case where system_content is explicitly empty
-                messages = [
-                    {"role": "user", "content": message},
-                ]
+            messages = [
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": message},
+            ]
 
             logger.info(f"🚀 Starting agentic loop for message: {message[:100]}...")
 
@@ -717,16 +705,6 @@ IMPORTANT TOOL CALLING RULES:
                         if self.model:
                             model_params["model"] = self.model
 
-                        # Issue #459: Include output_schema for provider to apply vendor-specific handling
-                        # (e.g., OpenAI needs response_format, not prompt-based JSON instructions)
-                        if self.output_type is not str and hasattr(
-                            self.output_type, "model_json_schema"
-                        ):
-                            model_params["output_schema"] = (
-                                self.output_type.model_json_schema()
-                            )
-                            model_params["output_type_name"] = self.output_type.__name__
-
                         logger.debug(
                             f"📤 Delegating to mesh provider with handler-prepared params: "
                             f"keys={list(model_params.keys())}"

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/_mcp_mesh/engine/mesh_llm_agent_injector.py

@@ -161,70 +161,36 @@ class MeshLlmAgentInjector(BaseInjector):
         # Create UnifiedMCPProxy for the provider
         provider_proxy = self._create_provider_proxy(provider_data)
 
-        # Update only provider-related fields, preserving tool data if already set.
-        # This avoids race conditions where provider and tools updates can arrive in any order.
-        if function_id not in self._llm_agents:
-            self._llm_agents[function_id] = {}
+        # Update llm_agents data with provider_proxy and vendor (Phase 2)
+        if function_id in self._llm_agents:
+            self._llm_agents[function_id]["provider_proxy"] = provider_proxy
 
-        # Phase 2: Extract vendor from provider_data for handler selection
-        vendor = provider_data.get("vendor", "unknown")
+            # Phase 2: Extract vendor from provider_data for handler selection
+            vendor = provider_data.get("vendor", "unknown")
+            self._llm_agents[function_id]["vendor"] = vendor
 
-        self._llm_agents[function_id]["provider_proxy"] = provider_proxy
-        self._llm_agents[function_id]["vendor"] = vendor
-
-        logger.info(
-            f"✅ Set provider proxy for '{function_id}': {provider_proxy.function_name} at {provider_proxy.endpoint} (vendor={vendor})"
-        )
-
-        # Re-create and update MeshLlmAgent with new provider
-        # Get the function wrapper and metadata from DecoratorRegistry
-        llm_agents = DecoratorRegistry.get_mesh_llm_agents()
-        wrapper = None
-        llm_metadata = None
-        for agent_func_id, metadata in llm_agents.items():
-            if metadata.function_id == function_id:
-                wrapper = metadata.function
-                llm_metadata = metadata
-                break
-
-        # Check if tools are required (filter is specified)
-        has_filter = False
-        if llm_metadata and llm_metadata.config:
-            filter_config = llm_metadata.config.get("filter")
-            has_filter = filter_config is not None and len(filter_config) > 0
-
-        # If no filter specified, initialize empty tools data so we can create LLM agent without tools
-        # This supports simple LLM calls (text generation) that don't need tool calling
-        if not has_filter and "tools_metadata" not in self._llm_agents[function_id]:
-            self._llm_agents[function_id].update(
-                {
-                    "config": llm_metadata.config if llm_metadata else {},
-                    "output_type": llm_metadata.output_type if llm_metadata else None,
-                    "param_name": llm_metadata.param_name if llm_metadata else "llm",
-                    "tools_metadata": [],  # No tools for simple LLM calls
-                    "tools_proxies": {},  # No tool proxies needed
-                    "function": llm_metadata.function if llm_metadata else None,
-                }
-            )
             logger.info(
-                f"✅ Initialized empty tools for '{function_id}' (no filter specified - simple LLM mode)"
+                f"✅ Set provider proxy for '{function_id}': {provider_proxy.function_name} at {provider_proxy.endpoint} (vendor={vendor})"
             )
 
-        # Update wrapper if we have tools data (either from filter matching or initialized empty)
-        if (
-            wrapper
-            and hasattr(wrapper, "_mesh_update_llm_agent")
-            and "tools_metadata" in self._llm_agents[function_id]
-        ):
-            llm_agent = self._create_llm_agent(function_id)
-            wrapper._mesh_update_llm_agent(llm_agent)
-            logger.info(
-                f"🔄 Updated wrapper with MeshLlmAgent for '{function_id}'"
-                + (" (with tools)" if has_filter else " (simple LLM mode)")
-            )
-        elif wrapper and hasattr(wrapper, "_mesh_update_llm_agent") and has_filter:
-            logger.debug(
-                f"⏳ Provider set for '{function_id}', waiting for tools before updating wrapper"
+            # Re-create and update MeshLlmAgent with new provider
+            # Get the function wrapper from DecoratorRegistry
+            llm_agents = DecoratorRegistry.get_mesh_llm_agents()
+            wrapper = None
+            for agent_func_id, metadata in llm_agents.items():
+                if metadata.function_id == function_id:
+                    wrapper = metadata.function
+                    break
+
+            if wrapper and hasattr(wrapper, "_mesh_update_llm_agent"):
+                llm_agent = self._create_llm_agent(function_id)
+                wrapper._mesh_update_llm_agent(llm_agent)
+                logger.info(
+                    f"🔄 Updated wrapper with new MeshLlmAgent (with provider) for '{function_id}'"
+                )
+        else:
+            logger.warning(
+                f"⚠️ Function '{function_id}' not found in _llm_agents, cannot set provider proxy"
             )
 
     def _create_provider_proxy(self, provider_data: dict[str, Any]) -> UnifiedMCPProxy:
@@ -307,23 +273,21 @@ class MeshLlmAgentInjector(BaseInjector):
                 logger.error(f"❌ Error creating proxy for tool {tool_name}: {e}")
                 # Continue processing other tools
 
-        # Update only tool-related fields, preserving provider_proxy if already set.
-        # Provider proxy is managed separately by process_llm_providers().
-        # This avoids race conditions where tools update wipes out provider resolution.
-        if function_id not in self._llm_agents:
-            self._llm_agents[function_id] = {}
-
-        self._llm_agents[function_id].update(
-            {
-                "config": llm_metadata.config,
-                "output_type": llm_metadata.output_type,
-                "param_name": llm_metadata.param_name,
-                "tools_metadata": tools,  # Original metadata for schema building
-                "tools_proxies": tool_proxies_map,  # Proxies for execution
-                "function": llm_metadata.function,
-                # Note: provider_proxy is NOT set here - managed by _process_function_provider
-            }
-        )
+        # Provider proxy will be set separately via process_llm_providers()
+        # (v0.6.1 - providers come from llm_providers field, not dependencies)
+        provider_proxy = None
+
+        # Store LLM agent data with both metadata and proxies
+        # Keep original tool metadata for schema building
+        self._llm_agents[function_id] = {
+            "config": llm_metadata.config,
+            "output_type": llm_metadata.output_type,
+            "param_name": llm_metadata.param_name,
+            "tools_metadata": tools,  # Original metadata for schema building
+            "tools_proxies": tool_proxies_map,  # Proxies for execution
+            "function": llm_metadata.function,
+            "provider_proxy": provider_proxy,  # Provider proxy for mesh delegation
+        }
 
         logger.info(
             f"✅ Processed {len(tool_proxies_map)} tools for LLM function '{function_id}'"
@@ -416,7 +380,7 @@ class MeshLlmAgentInjector(BaseInjector):
         """
         Create wrapper that injects MeshLlmAgent into function parameters.
 
-        Like McpMeshTool injection, this creates a wrapper at decorator time with llm_agent=None,
+        Like McpMeshAgent injection, this creates a wrapper at decorator time with llm_agent=None,
         which gets updated during heartbeat when tools arrive from registry.
 
         Args:
@@ -467,7 +431,8 @@ class MeshLlmAgentInjector(BaseInjector):
                     if is_template:
                         # Templates enabled - create per-call agent with context
                         # Import signature analyzer for context detection
-                        from .signature_analyzer import get_context_parameter_name
+                        from .signature_analyzer import \
+                            get_context_parameter_name
 
                         # Detect context parameter
                         context_param_name = config_dict.get("context_param")

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/_mcp_mesh/engine/signature_analyzer.py

@@ -5,67 +5,21 @@ Function signature analysis for MCP Mesh dependency injection.
 import inspect
 from typing import Any, get_type_hints
 
-from mesh.types import McpMeshTool, MeshLlmAgent
-
-# Also support deprecated McpMeshAgent for backwards compatibility
-try:
-    from mesh.types import McpMeshAgent
-except ImportError:
-    McpMeshAgent = McpMeshTool  # type: ignore
-
-
-def _is_mesh_tool_type(param_type: Any) -> bool:
-    """Check if a type is McpMeshTool or deprecated McpMeshAgent."""
-    # Direct McpMeshTool type
-    if (
-        param_type == McpMeshTool
-        or (hasattr(param_type, "__name__") and param_type.__name__ == "McpMeshTool")
-        or (
-            hasattr(param_type, "__origin__")
-            and param_type.__origin__ == type(McpMeshTool)
-        )
-    ):
-        return True
-
-    # Support deprecated McpMeshAgent
-    if (
-        param_type == McpMeshAgent
-        or (hasattr(param_type, "__name__") and param_type.__name__ == "McpMeshAgent")
-        or (
-            hasattr(param_type, "__origin__")
-            and param_type.__origin__ == type(McpMeshAgent)
-        )
-    ):
-        return True
-
-    # Union type (e.g., McpMeshTool | None)
-    if hasattr(param_type, "__args__"):
-        for arg in param_type.__args__:
-            if arg == McpMeshTool or (
-                hasattr(arg, "__name__") and arg.__name__ == "McpMeshTool"
-            ):
-                return True
-            # Support deprecated McpMeshAgent in unions
-            if arg == McpMeshAgent or (
-                hasattr(arg, "__name__") and arg.__name__ == "McpMeshAgent"
-            ):
-                return True
-
-    return False
+from mesh.types import McpMeshAgent, MeshLlmAgent
 
 
 def get_mesh_agent_positions(func: Any) -> list[int]:
     """
-    Get positions of McpMeshTool parameters in function signature.
+    Get positions of McpMeshAgent parameters in function signature.
 
     Args:
         func: Function to analyze
 
     Returns:
-        List of parameter positions (0-indexed) that are McpMeshTool types
+        List of parameter positions (0-indexed) that are McpMeshAgent types
 
     Example:
-        def greet(name: str, date_svc: McpMeshTool, file_svc: McpMeshTool):
+        def greet(name: str, date_svc: McpMeshAgent, file_svc: McpMeshAgent):
             pass
 
         get_mesh_agent_positions(greet) → [1, 2]
@@ -78,12 +32,40 @@ def get_mesh_agent_positions(func: Any) -> list[int]:
         sig = inspect.signature(func)
         param_names = list(sig.parameters.keys())
 
-        # Find positions of McpMeshTool parameters
+        # Find positions of McpMeshAgent parameters
         mesh_positions = []
         for i, param_name in enumerate(param_names):
             if param_name in type_hints:
                 param_type = type_hints[param_name]
-                if _is_mesh_tool_type(param_type):
+
+                # Check if it's McpMeshAgent type (handle different import paths and Union types)
+                is_agent = False
+
+                # Direct McpMeshAgent type
+                if (
+                    param_type == McpMeshAgent
+                    or (
+                        hasattr(param_type, "__name__")
+                        and param_type.__name__ == "McpMeshAgent"
+                    )
+                    or (
+                        hasattr(param_type, "__origin__")
+                        and param_type.__origin__ == type(McpMeshAgent)
+                    )
+                ):
+                    is_agent = True
+
+                # Union type (e.g., McpMeshAgent | None)
+                elif hasattr(param_type, "__args__"):
+                    # Check if any arg in the union is McpMeshAgent
+                    for arg in param_type.__args__:
+                        if arg == McpMeshAgent or (
+                            hasattr(arg, "__name__") and arg.__name__ == "McpMeshAgent"
+                        ):
+                            is_agent = True
+                            break
+
+                if is_agent:
                     mesh_positions.append(i)
 
         return mesh_positions
@@ -99,13 +81,13 @@ def get_mesh_agent_positions(func: Any) -> list[int]:
 
 def get_mesh_agent_parameter_names(func: Any) -> list[str]:
     """
-    Get names of McpMeshTool parameters in function signature.
+    Get names of McpMeshAgent parameters in function signature.
 
     Args:
         func: Function to analyze
 
     Returns:
-        List of parameter names that are McpMeshTool types
+        List of parameter names that are McpMeshAgent types
     """
     try:
         type_hints = get_type_hints(func)
@@ -115,7 +97,35 @@ def get_mesh_agent_parameter_names(func: Any) -> list[str]:
         for param_name, param in sig.parameters.items():
             if param_name in type_hints:
                 param_type = type_hints[param_name]
-                if _is_mesh_tool_type(param_type):
+
+                # Check if it's McpMeshAgent type (handle different import paths and Union types)
+                is_mesh_agent = False
+
+                # Direct McpMeshAgent type
+                if (
+                    param_type == McpMeshAgent
+                    or (
+                        hasattr(param_type, "__name__")
+                        and param_type.__name__ == "McpMeshAgent"
+                    )
+                    or (
+                        hasattr(param_type, "__origin__")
+                        and param_type.__origin__ == type(McpMeshAgent)
+                    )
+                ):
+                    is_mesh_agent = True
+
+                # Union type (e.g., McpMeshAgent | None)
+                elif hasattr(param_type, "__args__"):
+                    # Check if any arg in the union is McpMeshAgent
+                    for arg in param_type.__args__:
+                        if arg == McpMeshAgent or (
+                            hasattr(arg, "__name__") and arg.__name__ == "McpMeshAgent"
+                        ):
+                            is_mesh_agent = True
+                            break
+
+                if is_mesh_agent:
                     mesh_param_names.append(param_name)
 
         return mesh_param_names
@@ -126,7 +136,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 McpMeshTool parameters.
+    Validate that the number of dependencies matches McpMeshAgent parameters.
 
     Args:
         func: Function to validate
@@ -139,9 +149,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)} McpMeshTool parameters "
+            f"Function {func.__name__} has {len(mesh_positions)} McpMeshAgent parameters "
             f"but {len(dependencies)} dependencies declared. "
-            f"Each McpMeshTool parameter needs a corresponding dependency."
+            f"Each McpMeshAgent parameter needs a corresponding dependency."
         )
 
     return True, ""

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/_mcp_mesh/engine/unified_mcp_proxy.py

@@ -25,7 +25,7 @@ logger = logging.getLogger(__name__)
 class UnifiedMCPProxy:
     """Unified MCP proxy using FastMCP's built-in client.
 
-    This provides the implementation for McpMeshTool type parameters,
+    This provides the implementation for McpMeshAgent type parameters,
     offering all MCP protocol features using FastMCP's superior client.
 
     Features:

{mcp_mesh-0.8.0 → mcp_mesh-0.8.0b1}/_mcp_mesh/pipeline/api_heartbeat/rust_api_heartbeat.py

@@ -104,10 +104,9 @@ def _build_api_agent_spec(context: dict[str, Any], service_id: str = None) -> An
         # Build dependency specs
         deps = []
         for dep_cap in dependencies:
-            # Tags must be serialized to JSON string (Rust core expects string, not list)
             dep_spec = core.DependencySpec(
                 capability=dep_cap,
-                tags=json.dumps([]),
+                tags=[],
                 version=None,
             )
             deps.append(dep_spec)
@@ -137,7 +136,6 @@ def _build_api_agent_spec(context: dict[str, Any], service_id: str = None) -> An
         http_port=http_port,
         http_host=http_host,
         namespace=namespace,
-        agent_type="api",  # API services only consume capabilities, not provide them
         tools=tools if tools else None,
         llm_agents=None,  # API services don't have LLM agents
         heartbeat_interval=heartbeat_interval,
@@ -274,8 +272,6 @@ async def _handle_api_dependency_change(
                 )
                 if not current_service_id:
                     # Use config resolver for consistent env var handling
-                    from ...shared.config_resolver import get_config_value
-
                     current_service_id = get_config_value("MCP_MESH_AGENT_ID")
 
                 is_self_dependency = (