mcp-mesh 0.8.0b5__tar.gz → 0.8.0b7__tar.gz

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/.gitignore

@@ -255,3 +255,4 @@ rust-core-implementation.org
 src/runtime/core/index.js
 src/runtime/core/index.d.ts
 test/
+scaffold-test/

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.8.0b5
+Version: 0.8.0b7
 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
@@ -30,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.0b5
+Requires-Dist: mcp-mesh-core>=0.8.0b7
 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
@@ -78,7 +78,7 @@ pip install mcp-mesh
 import mesh
 
 # Import types from public API
-from mesh.types import McpMeshAgent
+from mesh.types import McpMeshTool
 
 # Define your agent
 @mesh.agent(name="hello-world", http_port=9090)
@@ -92,11 +92,11 @@ class HelloWorldAgent:
     dependencies=["date_service"],
     description="Greeting function with date dependency injection"
 )
-def greet(name: str = "World", systemDate: McpMeshAgent = None) -> str:
+def greet(name: str = "World", date_tool: McpMeshTool = None) -> str:
     """Greeting function with automatic dependency injection."""
-    if systemDate is not None:
+    if date_tool is not None:
         try:
-            current_date = systemDate()
+            current_date = date_tool()
             return f"Hello, {name}! Today is {current_date}"
         except Exception:
             pass

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/README.md

@@ -14,7 +14,7 @@ pip install mcp-mesh
 import mesh
 
 # Import types from public API
-from mesh.types import McpMeshAgent
+from mesh.types import McpMeshTool
 
 # 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", systemDate: McpMeshAgent = None) -> str:
+def greet(name: str = "World", date_tool: McpMeshTool = None) -> str:
     """Greeting function with automatic dependency injection."""
-    if systemDate is not None:
+    if date_tool is not None:
         try:
-            current_date = systemDate()
+            current_date = date_tool()
             return f"Hello, {name}! Today is {current_date}"
         except Exception:
             pass

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/_mcp_mesh/__init__.py

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

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/_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 McpMeshAgent)
-    2. Multiple parameters: only inject into McpMeshAgent typed parameters
+    1. Single parameter: inject regardless of typing (with warning if not McpMeshTool)
+    2. Multiple parameters: only inject into McpMeshTool 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 McpMeshAgent for clarity)"
+                f"(consider typing as McpMeshTool for clarity)"
             )
         return [0]  # Inject into the single parameter
 
-    # Multiple parameters rule: only inject into McpMeshAgent typed parameters
+    # Multiple parameters rule: only inject into McpMeshTool 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 McpMeshTool. Skipping injection of {len(dependencies)} dependencies. "
+                f"Consider typing dependency parameters as McpMeshTool."
             )
             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)} McpMeshAgent parameters. "
+                    f"but only {len(mesh_positions)} McpMeshTool 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)} McpMeshAgent parameters "
+                    f"Function '{func_name}' has {len(mesh_positions)} McpMeshTool 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 (McpMeshAgent)
+    1. Maintains a registry of available dependencies (McpMeshTool)
     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.0b5 → mcp_mesh-0.8.0b7}/_mcp_mesh/engine/mesh_llm_agent_injector.py

@@ -380,7 +380,7 @@ class MeshLlmAgentInjector(BaseInjector):
         """
         Create wrapper that injects MeshLlmAgent into function parameters.
 
-        Like McpMeshAgent injection, this creates a wrapper at decorator time with llm_agent=None,
+        Like McpMeshTool injection, this creates a wrapper at decorator time with llm_agent=None,
         which gets updated during heartbeat when tools arrive from registry.
 
         Args:

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

@@ -5,21 +5,67 @@ Function signature analysis for MCP Mesh dependency injection.
 import inspect
 from typing import Any, get_type_hints
 
-from mesh.types import McpMeshAgent, MeshLlmAgent
+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
 
 
 def get_mesh_agent_positions(func: Any) -> list[int]:
     """
-    Get positions of McpMeshAgent parameters in function signature.
+    Get positions of McpMeshTool parameters in function signature.
 
     Args:
         func: Function to analyze
 
     Returns:
-        List of parameter positions (0-indexed) that are McpMeshAgent types
+        List of parameter positions (0-indexed) that are McpMeshTool types
 
     Example:
-        def greet(name: str, date_svc: McpMeshAgent, file_svc: McpMeshAgent):
+        def greet(name: str, date_svc: McpMeshTool, file_svc: McpMeshTool):
             pass
 
         get_mesh_agent_positions(greet) → [1, 2]
@@ -32,40 +78,12 @@ def get_mesh_agent_positions(func: Any) -> list[int]:
         sig = inspect.signature(func)
         param_names = list(sig.parameters.keys())
 
-        # Find positions of McpMeshAgent parameters
+        # Find positions of McpMeshTool parameters
         mesh_positions = []
         for i, param_name in enumerate(param_names):
             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)
-                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:
+                if _is_mesh_tool_type(param_type):
                     mesh_positions.append(i)
 
         return mesh_positions
@@ -81,13 +99,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 McpMeshTool parameters in function signature.
 
     Args:
         func: Function to analyze
 
     Returns:
-        List of parameter names that are McpMeshAgent types
+        List of parameter names that are McpMeshTool types
     """
     try:
         type_hints = get_type_hints(func)
@@ -97,35 +115,7 @@ 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]
-
-                # 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:
+                if _is_mesh_tool_type(param_type):
                     mesh_param_names.append(param_name)
 
         return mesh_param_names
@@ -136,7 +126,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 McpMeshTool parameters.
 
     Args:
         func: Function to validate
@@ -149,9 +139,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)} McpMeshTool parameters "
             f"but {len(dependencies)} dependencies declared. "
-            f"Each McpMeshAgent parameter needs a corresponding dependency."
+            f"Each McpMeshTool parameter needs a corresponding dependency."
         )
 
     return True, ""

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/_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 McpMeshAgent type parameters,
+    This provides the implementation for McpMeshTool type parameters,
     offering all MCP protocol features using FastMCP's superior client.
 
     Features:

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/_mcp_mesh/pipeline/mcp_heartbeat/rust_heartbeat.py

@@ -73,6 +73,18 @@ def _build_agent_spec(context: dict[str, Any]) -> Any:
     # Get HTTP config
     http_host = agent_config.get("http_host", "localhost")
     http_port = agent_config.get("http_port", 0)
+
+    # If port=0 (auto-assign), check for detected port from server discovery
+    if http_port == 0:
+        existing_server = context.get("existing_server")
+        if existing_server:
+            detected_port = existing_server.get("port", 0)
+            if detected_port > 0:
+                logger.info(
+                    f"Using detected port {detected_port} (agent_config had port=0)"
+                )
+                http_port = detected_port
+
     namespace = agent_config.get("namespace", "default")
     version = agent_config.get("version", "1.0.0")
     description = agent_config.get("description", "")
@@ -335,13 +347,13 @@ async def _handle_mesh_event(event: Any, context: dict[str, Any]) -> None:
 
 async def _handle_dependency_change(
     capability: str,
-    endpoint: Optional[str],
-    function_name: Optional[str],
-    agent_id: Optional[str],
+    endpoint: str | None,
+    function_name: str | None,
+    agent_id: str | None,
     available: bool,
     context: dict[str, Any],
-    requesting_function: Optional[str] = None,
-    dep_index: Optional[int] = None,
+    requesting_function: str | None = None,
+    dep_index: int | None = None,
 ) -> None:
     """
     Handle dependency availability change.

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/_mcp_mesh/pipeline/mcp_startup/fastapiserver_setup.py

@@ -198,10 +198,15 @@ class FastAPIServerSetupStep(PipelineStep):
         # Use centralized binding host resolution (always 0.0.0.0 for all interfaces)
         bind_host = HostResolver.get_binding_host()
 
-        # Port from agent config or environment
-        bind_port = int(os.getenv("MCP_MESH_HTTP_PORT", 0)) or agent_config.get(
-            "http_port", 8080
-        )
+        # Port from environment or agent config
+        # Note: port=0 means auto-assign, so we must not treat it as falsy
+        env_port = os.getenv("MCP_MESH_HTTP_PORT")
+        if env_port is not None:
+            bind_port = int(env_port)
+        elif "http_port" in agent_config:
+            bind_port = agent_config["http_port"]
+        else:
+            bind_port = 8080  # Default only if nothing specified
 
         return {
             "bind_host": bind_host,
@@ -236,9 +241,11 @@ class FastAPIServerSetupStep(PipelineStep):
         try:
             from fastapi import FastAPI
 
-            from .lifespan_factory import (create_minimal_lifespan,
-                                           create_multiple_fastmcp_lifespan,
-                                           create_single_fastmcp_lifespan)
+            from .lifespan_factory import (
+                create_minimal_lifespan,
+                create_multiple_fastmcp_lifespan,
+                create_single_fastmcp_lifespan,
+            )
 
             agent_name = agent_config.get("name", "mcp-mesh-agent")
             agent_description = agent_config.get(
@@ -328,8 +335,7 @@ class FastAPIServerSetupStep(PipelineStep):
             if health_check_fn:
                 # Use health check cache if configured
                 from ...engine.decorator_registry import DecoratorRegistry
-                from ...shared.health_check_manager import \
-                    get_health_status_with_cache
+                from ...shared.health_check_manager import get_health_status_with_cache
 
                 health_status = await get_health_status_with_cache(
                     agent_id=agent_name,
@@ -567,11 +573,29 @@ mcp_mesh_up{{agent="{agent_name}"}} 1
 
             server_task = asyncio.create_task(run_server())
 
-            # Give server a moment to start up
-            await asyncio.sleep(0.2)
+            # Wait for server to start and get actual port
+            # uvicorn sets server.started = True when ready
+            for _ in range(50):  # Max 5 seconds
+                await asyncio.sleep(0.1)
+                if server.started:
+                    break
 
-            # Determine actual port (for now, assume it started on requested port)
-            actual_port = bind_port if bind_port != 0 else 8080
+            # Get actual port from uvicorn sockets (critical for port=0 auto-assign)
+            actual_port = bind_port
+            if server.started and server.servers:
+                try:
+                    sock = server.servers[0].sockets[0]
+                    actual_port = sock.getsockname()[1]
+                    if actual_port != bind_port:
+                        self.logger.info(
+                            f"Auto-assigned port {actual_port} (requested: {bind_port})"
+                        )
+                except (IndexError, AttributeError, OSError) as e:
+                    self.logger.warning(f"Could not get actual port from uvicorn: {e}")
+                    actual_port = bind_port if bind_port != 0 else 8080
+            elif bind_port == 0:
+                self.logger.warning("Server not started, falling back to port 8080")
+                actual_port = 8080
 
             # Build external endpoint
             final_external_endpoint = (

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/_mcp_mesh/pipeline/mcp_startup/startup_orchestrator.py

@@ -38,8 +38,8 @@ class DebounceCoordinator:
         import threading
 
         self.delay_seconds = delay_seconds
-        self._pending_timer: Optional[threading.Timer] = None
-        self._orchestrator: Optional[MeshOrchestrator] = None
+        self._pending_timer: threading.Timer | None = None
+        self._orchestrator: MeshOrchestrator | None = None
         self._lock = threading.Lock()
         self.logger = logging.getLogger(f"{__name__}.DebounceCoordinator")
 
@@ -181,8 +181,9 @@ class DebounceCoordinator:
                     # For API services, ONLY do dependency injection - user controls their FastAPI server
                     # Dependency injection is already complete from pipeline execution
                     # Optionally start heartbeat in background (non-blocking)
-                    from ..api_heartbeat.api_lifespan_integration import \
-                        api_heartbeat_lifespan_task
+                    from ..api_heartbeat.api_lifespan_integration import (
+                        api_heartbeat_lifespan_task,
+                    )
 
                     self._setup_heartbeat_background(
                         heartbeat_config,
@@ -207,8 +208,7 @@ class DebounceCoordinator:
                                 f"heartbeat_task_fn from config is not callable: {type(heartbeat_task_fn)}, using Rust heartbeat"
                             )
                         # Rust heartbeat is required - no Python fallback
-                        from ..mcp_heartbeat.rust_heartbeat import \
-                            rust_heartbeat_task
+                        from ..mcp_heartbeat.rust_heartbeat import rust_heartbeat_task
 
                         heartbeat_task_fn = rust_heartbeat_task
 
@@ -422,7 +422,7 @@ class DebounceCoordinator:
 
 
 # Global debounce coordinator instance
-_debounce_coordinator: Optional[DebounceCoordinator] = None
+_debounce_coordinator: DebounceCoordinator | None = None
 
 
 def get_debounce_coordinator() -> DebounceCoordinator:
@@ -520,7 +520,7 @@ class MeshOrchestrator:
                 "timestamp": "unknown",
             }
 
-    async def start_service(self, auto_run_config: Optional[dict] = None) -> None:
+    async def start_service(self, auto_run_config: dict | None = None) -> None:
         """
         Start the service with optional auto-run behavior.
 
@@ -582,7 +582,7 @@ class MeshOrchestrator:
 
 
 # Global orchestrator instance
-_global_orchestrator: Optional[MeshOrchestrator] = None
+_global_orchestrator: MeshOrchestrator | None = None
 
 
 def get_global_orchestrator() -> MeshOrchestrator:

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/_mcp_mesh/utils/fastmcp_schema_extractor.py

@@ -24,7 +24,7 @@ class FastMCPSchemaExtractor:
     This class extracts those schemas so they can be sent to the registry
     for LLM tool discovery.
 
-    Phase 2.5: Filters out McpMeshAgent parameters from schemas since
+    Phase 2.5: Filters out McpMeshTool parameters from schemas since
     they are dependency injection parameters and should not be visible to LLMs.
 
     Phase 0: Enhances schemas with MeshContextModel Field descriptions for
@@ -239,7 +239,7 @@ class FastMCPSchemaExtractor:
         schema: dict[str, Any], function: Any
     ) -> dict[str, Any]:
         """
-        Filter out McpMeshAgent dependency injection parameters from schema.
+        Filter out McpMeshTool dependency injection parameters from schema.
 
         Phase 2.5: Remove dependency injection parameters from LLM-facing schemas.
         These parameters are injected at runtime by MCP Mesh and should not be
@@ -273,7 +273,7 @@ class FastMCPSchemaExtractor:
         if not schema or not isinstance(schema, dict):
             return schema
 
-        # Get McpMeshAgent parameter names from signature analysis
+        # Get McpMeshTool parameter names from signature analysis
         from _mcp_mesh.engine.signature_analyzer import \
             get_mesh_agent_parameter_names
 

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/mesh/__init__.py

@@ -19,8 +19,8 @@ Use 'import mesh' and then '@mesh.tool()' for consistency with MCP patterns.
 """
 
 from . import decorators
-from .types import (LlmMeta, McpMeshAgent, MeshContextModel, MeshLlmAgent,
-                    MeshLlmRequest)
+from .types import (LlmMeta, McpMeshAgent, McpMeshTool, MeshContextModel,
+                    MeshLlmAgent, MeshLlmRequest)
 
 # Note: helpers.llm_provider is imported lazily in __getattr__ to avoid
 # initialization timing issues with @mesh.agent auto_run in tests
@@ -93,6 +93,8 @@ def create_server(name: str | None = None) -> "FastMCP":
 
 # Make decorators available as mesh.tool, mesh.agent, mesh.route, mesh.llm, and mesh.llm_provider
 def __getattr__(name):
+    import warnings
+
     if name == "tool":
         return decorators.tool
     elif name == "agent":
@@ -106,7 +108,15 @@ def __getattr__(name):
         from .helpers import llm_provider
 
         return llm_provider
+    elif name == "McpMeshTool":
+        return McpMeshTool
     elif name == "McpMeshAgent":
+        warnings.warn(
+            "McpMeshAgent is deprecated, use McpMeshTool instead. "
+            "McpMeshAgent will be removed in a future version.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
         return McpMeshAgent
     elif name == "MeshContextModel":
         return MeshContextModel

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/mesh/decorators.py

@@ -299,8 +299,12 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
 
         logger.debug("📦 IMMEDIATE UVICORN: Added status endpoints")
 
-        # Determine port (0 means auto-assign)
-        port = http_port if http_port > 0 else 8080
+        # Port handling:
+        # - http_port=0 explicitly means auto-assign (let uvicorn choose)
+        # - http_port>0 means use that specific port
+        # Note: The default is 8080 only if http_port was never specified,
+        # which is handled upstream in the @mesh.agent decorator
+        port = http_port
 
         logger.debug(
             f"🚀 IMMEDIATE UVICORN: Starting uvicorn server on {http_host}:{port}"
@@ -366,8 +370,53 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
         # Give server a moment to start
         time.sleep(1)
 
+        # Detect actual port if port=0 (auto-assign)
+        actual_port = port
+        if port == 0:
+            import socket
+
+            # Try to detect actual port by scanning for listening sockets
+            try:
+                import subprocess
+
+                # Use lsof to find the port bound by this process
+                result = subprocess.run(
+                    ["lsof", "-i", "-P", "-n", f"-p{os.getpid()}"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                )
+                for line in result.stdout.split("\n"):
+                    if "LISTEN" in line and "python" in line.lower():
+                        # Parse port from line like "python  1234  user  5u  IPv4 ... TCP *:54321 (LISTEN)"
+                        parts = line.split()
+                        for part in parts:
+                            if ":" in part and "(LISTEN)" not in part:
+                                try:
+                                    port_str = part.split(":")[-1]
+                                    detected_port = int(port_str)
+                                    if detected_port > 0:
+                                        actual_port = detected_port
+                                        logger.info(
+                                            f"🎯 IMMEDIATE UVICORN: Detected auto-assigned port {actual_port}"
+                                        )
+                                        # Update server_info with actual port
+                                        server_info["port"] = actual_port
+                                        server_info["requested_port"] = (
+                                            0  # Remember original request
+                                        )
+                                        break
+                                except (ValueError, IndexError):
+                                    pass
+                        if actual_port > 0:
+                            break
+            except Exception as e:
+                logger.warning(
+                    f"⚠️ IMMEDIATE UVICORN: Could not detect auto-assigned port: {e}"
+                )
+
         logger.debug(
-            f"✅ IMMEDIATE UVICORN: Uvicorn server running on {http_host}:{port} (daemon thread)"
+            f"✅ IMMEDIATE UVICORN: Uvicorn server running on {http_host}:{actual_port} (daemon thread)"
         )
 
         # Set up registry context for shutdown cleanup (use defaults initially)
@@ -982,10 +1031,10 @@ def route(
         async def upload_resume(
             request: Request,
             file: UploadFile = File(...),
-            pdf_agent: mesh.McpMeshAgent = None,    # Injected by MCP Mesh
-            user_service: mesh.McpMeshAgent = None  # Injected by MCP Mesh
+            pdf_tool: mesh.McpMeshTool = None,    # Injected by MCP Mesh
+            user_service: mesh.McpMeshTool = None  # Injected by MCP Mesh
         ):
-            result = await pdf_agent.extract_text_from_pdf(file)
+            result = await pdf_tool.extract_text_from_pdf(file)
             await user_service.update_profile(user_data, result)
             return {"success": True}
     """

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/mesh/types.py

@@ -2,6 +2,7 @@
 MCP Mesh type definitions for dependency injection.
 """
 
+import warnings
 from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Protocol
@@ -14,24 +15,24 @@ except ImportError:
     PYDANTIC_AVAILABLE = False
 
 
-class McpMeshAgent(Protocol):
+class McpMeshTool(Protocol):
     """
-    Unified MCP Mesh agent proxy using FastMCP's built-in client.
+    MCP Mesh tool proxy for dependency injection.
 
-    This protocol now provides all MCP protocol features using FastMCP's superior client
-    implementation, replacing both the old basic and advanced proxy types.
+    This protocol defines the interface for injected tool dependencies. When you declare
+    a dependency on a remote tool, MCP Mesh injects a proxy that implements this interface.
 
     Features:
-    - All MCP protocol methods (tools, resources, prompts)
+    - Simple callable interface for tool invocation
+    - Full MCP protocol methods (tools, resources, prompts)
     - Streaming support with FastMCP's StreamableHttpTransport
     - Session management with notifications
-    - Automatic redirect handling (fixes /mcp/ → /mcp issue)
+    - Automatic redirect handling
     - CallToolResult objects with structured content parsing
-    - Enhanced proxy configuration via kwargs
 
     Usage Examples:
         @mesh.tool(dependencies=["date-service"])
-        def greet(name: str, date_service: McpMeshAgent) -> str:
+        def greet(name: str, date_service: McpMeshTool) -> str:
             # Simple call - proxy knows which remote function to invoke
             current_date = date_service()
 
@@ -44,7 +45,7 @@ class McpMeshAgent(Protocol):
             return f"Hello {name}, today is {current_date}"
 
         @mesh.tool(dependencies=["file-service"])
-        async def process_files(file_service: McpMeshAgent) -> str:
+        async def process_files(file_service: McpMeshTool) -> str:
             # Full MCP Protocol usage
             tools = await file_service.list_tools()
             resources = await file_service.list_resources()
@@ -62,7 +63,7 @@ class McpMeshAgent(Protocol):
 
             return "Processing complete"
 
-    The unified proxy provides all MCP protocol features while maintaining simple callable interface.
+    The proxy provides all MCP protocol features while maintaining a simple callable interface.
     """
 
     def __call__(self, arguments: Optional[dict[str, Any]] = None) -> Any:
@@ -156,15 +157,15 @@ class McpMeshAgent(Protocol):
             handler: Any,
         ) -> core_schema.CoreSchema:
             """
-            Custom Pydantic core schema for McpMeshAgent.
+            Custom Pydantic core schema for McpMeshTool.
 
-            This makes McpMeshAgent parameters appear as optional/nullable in MCP schemas,
+            This makes McpMeshTool parameters appear as optional/nullable in MCP schemas,
             preventing serialization errors while maintaining type safety for dependency injection.
 
             The dependency injection system will replace None values with actual proxy objects
             at runtime, so MCP callers never need to provide these parameters.
             """
-            # Treat McpMeshAgent as an optional Any type for MCP serialization
+            # Treat McpMeshTool as an optional Any type for MCP serialization
             return core_schema.with_default_schema(
                 core_schema.nullable_schema(core_schema.any_schema()),
                 default=None,
@@ -181,6 +182,32 @@ class McpMeshAgent(Protocol):
             }
 
 
+def _create_deprecated_mcpmeshagent():
+    """Create McpMeshAgent as a deprecated alias for McpMeshTool."""
+
+    class McpMeshAgent(McpMeshTool, Protocol):
+        """
+        Deprecated: Use McpMeshTool instead.
+
+        This is a backwards-compatible alias that will be removed in a future version.
+        """
+
+        def __init_subclass__(cls, **kwargs):
+            warnings.warn(
+                "McpMeshAgent is deprecated, use McpMeshTool instead. "
+                "McpMeshAgent will be removed in a future version.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            super().__init_subclass__(**kwargs)
+
+    return McpMeshAgent
+
+
+# Deprecated alias for backwards compatibility
+McpMeshAgent = _create_deprecated_mcpmeshagent()
+
+
 class MeshLlmAgent(Protocol):
     """
     LLM agent proxy with automatic agentic loop.

{mcp_mesh-0.8.0b5 → mcp_mesh-0.8.0b7}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mcp-mesh"
-version = "0.8.0b5"
+version = "0.8.0b7"
 description = "Kubernetes-native platform for distributed MCP applications"
 readme = "README.md"
 license = { text = "MIT" }
@@ -37,7 +37,7 @@ classifiers = [
 requires-python = ">=3.11"
 dependencies = [
     # Rust core runtime (required - no Python fallback)
-    "mcp-mesh-core>=0.8.0b5",
+    "mcp-mesh-core>=0.8.0b7",
     "fastapi>=0.104.0,<1.0.0",
     "uvicorn>=0.24.0,<1.0.0",
     "httpx>=0.25.0,<1.0.0",
@@ -123,7 +123,7 @@ extend-exclude = '''
 '''
 
 [tool.ruff]
-target-version = "0.8.0b5"
+target-version = "0.8.0b7"
 line-length = 88
 
 [tool.ruff.lint]
@@ -160,7 +160,7 @@ ignore = [
 "tests/**" = ["E712", "F841", "B007", "C401", "F401"]  # Relax style requirements for test files
 
 [tool.mypy]
-python_version = "0.8.0b5"
+python_version = "0.8.0b7"
 check_untyped_defs = false  # Temporarily relaxed
 disallow_any_generics = false  # Temporarily relaxed
 disallow_incomplete_defs = false  # Temporarily relaxed
@@ -172,7 +172,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.8.0b5"
+minversion = "0.8.0b7"
 addopts = "-ra -q --strict-markers --strict-config"
 testpaths = [
     "tests",