mcp-mesh 0.7.21__py3-none-any.whl → 0.8.0b1__py3-none-any.whl

_mcp_mesh/pipeline/mcp_startup/__init__.py

@@ -11,13 +11,10 @@ from .fastapiserver_setup import FastAPIServerSetupStep
 from .fastmcpserver_discovery import FastMCPServerDiscoveryStep
 from .heartbeat_loop import HeartbeatLoopStep
 from .heartbeat_preparation import HeartbeatPreparationStep
-from .startup_orchestrator import (
-                                   MeshOrchestrator,
+from .startup_orchestrator import (MeshOrchestrator,
                                    clear_debounce_coordinator,
                                    get_debounce_coordinator,
-                                   get_global_orchestrator,
-                                   start_runtime,
-)
+                                   get_global_orchestrator, start_runtime)
 from .startup_pipeline import StartupPipeline
 
 __all__ = [

_mcp_mesh/pipeline/mcp_startup/configuration.py

@@ -37,10 +37,10 @@ class ConfigurationStep(PipelineStep):
             has_explicit_agent = bool(mesh_agents)
 
             # Resolve registry URL (not part of agent parameters)
+            # Default is handled by Rust core
             registry_url = get_config_value(
                 "MCP_MESH_REGISTRY_URL",
                 override=None,  # No decorator override for registry URL
-                default="http://localhost:8000",
                 rule=ValidationRule.URL_RULE,
             )
 

_mcp_mesh/pipeline/mcp_startup/fastapiserver_setup.py

@@ -236,11 +236,9 @@ 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(
@@ -330,7 +328,8 @@ 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,

_mcp_mesh/pipeline/mcp_startup/heartbeat_loop.py

@@ -1,10 +1,9 @@
 import asyncio
 import logging
 import os
-from typing import Any, Dict, Optional
+from typing import Any
 
 from ...shared.config_resolver import ValidationRule, get_config_value
-from ...shared.registry_client_wrapper import RegistryClientWrapper
 from ..shared import PipelineResult, PipelineStatus, PipelineStep
 
 
@@ -48,16 +47,16 @@ class HeartbeatLoopStep(PipelineStep):
             # Check for explicit standalone mode configuration
             standalone_mode = self._get_standalone_mode()
 
-            # Import heartbeat task function
-            from ..mcp_heartbeat import heartbeat_lifespan_task
+            # Import Rust-backed heartbeat task (required - raises RuntimeError if Rust core missing)
+            from ..mcp_heartbeat.rust_heartbeat import rust_heartbeat_task
 
-            # Create heartbeat config - registry connection will be attempted in heartbeat pipeline
+            # Create heartbeat config - Rust core handles registry connection
             heartbeat_config = {
-                "registry_wrapper": None,  # Will be created in heartbeat pipeline
+                "registry_wrapper": None,  # Rust core manages registry connection
                 "agent_id": agent_id,
                 "interval": heartbeat_interval,
                 "context": context,  # Pass full context for health status building
-                "heartbeat_task_fn": heartbeat_lifespan_task,  # Pass function to avoid cross-imports
+                "heartbeat_task_fn": rust_heartbeat_task,  # Use Rust-backed heartbeat
                 "standalone_mode": standalone_mode,
             }
 

_mcp_mesh/pipeline/mcp_startup/startup_orchestrator.py

@@ -181,9 +181,8 @@ 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,
@@ -197,15 +196,26 @@ class DebounceCoordinator:
                     )
                     return  # Don't block - let user's uvicorn run
                 elif fastapi_app and binding_config:
-                    # For MCP agents - use same daemon thread pattern as API apps
-                    from ..mcp_heartbeat.lifespan_integration import (
-                        heartbeat_lifespan_task,
-                    )
+                    # For MCP agents - use Rust-backed heartbeat task from config
+                    # HeartbeatLoopStep sets this to rust_heartbeat_task
+                    heartbeat_task_fn = heartbeat_config.get("heartbeat_task_fn")
+
+                    # Validate heartbeat_task_fn is callable, fall back to Rust heartbeat if not
+                    if heartbeat_task_fn is None or not callable(heartbeat_task_fn):
+                        if heartbeat_task_fn is not None:
+                            self.logger.warning(
+                                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
+
+                        heartbeat_task_fn = rust_heartbeat_task
 
                     self._setup_heartbeat_background(
                         heartbeat_config,
                         pipeline_context,
-                        heartbeat_lifespan_task,
+                        heartbeat_task_fn,
                     )
 
                     # Check if server was already reused from immediate uvicorn start
@@ -370,7 +380,9 @@ class DebounceCoordinator:
 
             def run_heartbeat():
                 """Run heartbeat in separate thread with its own event loop."""
-                self.logger.debug(f"Starting background heartbeat thread for {entity_id}")
+                self.logger.debug(
+                    f"Starting background heartbeat thread for {entity_id}"
+                )
                 try:
                     loop = asyncio.new_event_loop()
                     asyncio.set_event_loop(loop)

_mcp_mesh/pipeline/mcp_startup/startup_pipeline.py

@@ -9,14 +9,9 @@ and FastAPI server preparation.
 import logging
 
 from ..shared.mesh_pipeline import MeshPipeline
-from . import (
-    ConfigurationStep,
-    DecoratorCollectionStep,
-    FastAPIServerSetupStep,
-    FastMCPServerDiscoveryStep,
-    HeartbeatLoopStep,
-    HeartbeatPreparationStep,
-)
+from . import (ConfigurationStep, DecoratorCollectionStep,
+               FastAPIServerSetupStep, FastMCPServerDiscoveryStep,
+               HeartbeatLoopStep, HeartbeatPreparationStep)
 from .server_discovery import ServerDiscoveryStep
 
 logger = logging.getLogger(__name__)

_mcp_mesh/pipeline/shared/mesh_pipeline.py

@@ -78,7 +78,6 @@ class MeshPipeline:
                     step_result = await step.execute(self.context)
                     executed_steps += 1
 
-
                     # Log step result
                     if step_result.is_success():
                         self.logger.info(
@@ -113,7 +112,6 @@ class MeshPipeline:
                 except Exception as e:
                     executed_steps += 1
 
-
                     error_msg = f"Step '{step.name}' threw exception: {e}"
                     overall_result.add_error(error_msg)
                     self.logger.error(

_mcp_mesh/reload.py

@@ -103,9 +103,7 @@ def terminate_process(process: subprocess.Popen, timeout: int = 3) -> None:
     try:
         process.wait(timeout=timeout)
     except subprocess.TimeoutExpired:
-        logger.warning(
-            f"Process {pid} didn't terminate gracefully, force killing..."
-        )
+        logger.warning(f"Process {pid} didn't terminate gracefully, force killing...")
         # Force kill the entire process group
         try:
             os.killpg(pid, signal.SIGKILL)

_mcp_mesh/shared/__init__.py

@@ -5,6 +5,7 @@ Shared utilities and types built on the official MCP SDK.
 Common functionality used across server and client components.
 
 Core mesh processing infrastructure has been moved to mcp_mesh.engine.
+Registry communication is handled by the Rust core.
 """
 
 # Import only non-circular dependencies at module level
@@ -13,7 +14,6 @@ from .support_types import DependencyConfig, HealthStatus
 __all__ = [
     "HealthStatus",
     "DependencyConfig",
-    "RegistryClient",
     "ContentExtractor",
     "configure_logging",
 ]
@@ -22,13 +22,7 @@ __all__ = [
 # Lazy imports for circular dependency resolution
 def __getattr__(name):
     """Lazy import to avoid circular dependencies."""
-    if name == "RegistryClient":
-        from ..generated.mcp_mesh_registry_client.api_client import (
-            ApiClient as RegistryClient,
-        )
-
-        return RegistryClient
-    elif name == "ContentExtractor":
+    if name == "ContentExtractor":
         from .content_extractor import ContentExtractor
 
         return ContentExtractor

_mcp_mesh/shared/config_resolver.py

@@ -1,18 +1,46 @@
 """
 Configuration value resolver with validation rules.
 
-Provides centralized environment variable handling with consistent validation
-and graceful error handling with fallback to defaults.
+Delegates config resolution to Rust core for MCP Mesh config keys to ensure
+consistent behavior across all language SDKs. Non-mesh config uses Python fallback.
+
+Resolution priority (handled by Rust core): ENV > override > default
 """
 
 import logging
-import os
 from enum import Enum
-from typing import Any, Union
+from typing import Any
 from urllib.parse import urlparse
 
 logger = logging.getLogger(__name__)
 
+# Try to import the Rust core module for config resolution
+# Falls back to Python-only resolution if not available
+try:
+    import mcp_mesh_core
+
+    _RUST_CORE_AVAILABLE = True
+except ImportError as e:
+    mcp_mesh_core = None  # type: ignore[assignment]
+    _RUST_CORE_AVAILABLE = False
+    logger.warning(
+        "mcp_mesh_core not available - falling back to Python-only config resolution. "
+        "Build/install mcp-mesh-core for full functionality: cd src/runtime/core && maturin develop"
+    )
+
+# Map env var names to Rust config key names
+_ENV_TO_RUST_KEY: dict[str, str] = {
+    "MCP_MESH_REGISTRY_URL": "registry_url",
+    "MCP_MESH_HTTP_HOST": "http_host",
+    "MCP_MESH_HTTP_PORT": "http_port",
+    "MCP_MESH_NAMESPACE": "namespace",
+    "MCP_MESH_AGENT_NAME": "agent_name",
+    "MCP_MESH_AGENT_ID": "agent_id",
+    "MCP_MESH_HEALTH_INTERVAL": "health_interval",
+    "MCP_MESH_DISTRIBUTED_TRACING_ENABLED": "distributed_tracing_enabled",
+    "REDIS_URL": "redis_url",
+}
+
 
 class ValidationRule(Enum):
     """Validation rules for configuration values."""
@@ -41,6 +69,9 @@ def get_config_value(
     Resolve configuration value with precedence: ENV > override > default
     Then validate against the specified rule.
 
+    For MCP Mesh config keys (MCP_MESH_*, REDIS_URL), resolution is delegated
+    to Rust core for consistency across all language SDKs.
+
     Args:
         env_var: Environment variable name
         override: Programmatic override value
@@ -48,92 +79,105 @@ def get_config_value(
         rule: Validation rule to apply
 
     Returns:
-        Validated configuration value
+        Validated configuration value, or None if no default was provided
+        and the resolved value failed validation.
 
     Raises:
-        ConfigResolutionError: If validation fails and no valid default
+        ConfigResolutionError: If both the resolved value and an explicit
+            default fail validation (indicates a programming error).
     """
-    # Step 1: Determine raw value following precedence order
-    raw_value = None
-    source = "default"
-
-    # Check environment variable first (highest precedence)
-    env_value = os.environ.get(env_var)
-    if env_value is not None:
-        raw_value = env_value
-        source = "environment"
-    # Check override value second
-    elif override is not None:
-        raw_value = override
-        source = "override"
-    # Use default value last
+    # Check if this is a known mesh config key - delegate to Rust core if available
+    rust_key = _ENV_TO_RUST_KEY.get(env_var)
+    if rust_key is not None and _RUST_CORE_AVAILABLE:
+        raw_value = _resolve_via_rust(rust_key, override, default, rule)
     else:
-        raw_value = default
-        source = "default"
+        # Non-mesh config or Rust core unavailable - use Python fallback
+        raw_value = _resolve_via_python(env_var, override, default)
 
-    # Step 2: Validate and convert the value
+    # Validate and convert the value
     try:
-        validated_value = _validate_value(raw_value, rule, env_var)
-        return validated_value
-
+        return _validate_value(raw_value, rule, env_var)
     except ConfigResolutionError as e:
-        # If validation fails, log error and try to fall back following precedence order
         logger.error(f"Config validation failed for {env_var}: {e}")
-
-        # Try fallback in precedence order: env > override > default
-        if source == "environment" and override is not None:
-            # Environment failed, try override
+        # Try fallback to default if validation failed
+        if default is not None and raw_value != default:
             try:
-                logger.warning(
-                    f"Falling back to override value for {env_var}: {override}"
-                )
-                validated_override = _validate_value(override, rule, env_var)
-                return validated_override
-            except ConfigResolutionError:
-                # Override also failed, try default
-                if default is not None:
-                    try:
-                        logger.warning(
-                            f"Falling back to default value for {env_var}: {default}"
-                        )
-                        validated_default = _validate_value(default, rule, env_var)
-                        return validated_default
-                    except ConfigResolutionError:
-                        logger.error(
-                            f"All values for {env_var} are invalid, using None"
-                        )
-                        return None
-                else:
-                    logger.error(
-                        f"Override and default values for {env_var} are invalid, using None"
-                    )
-                    return None
-        elif source == "environment" and default is not None:
-            # Environment failed and no override, try default
-            try:
-                logger.warning(
-                    f"Falling back to default value for {env_var}: {default}"
-                )
-                validated_default = _validate_value(default, rule, env_var)
-                return validated_default
-            except ConfigResolutionError:
-                logger.error(f"Default value for {env_var} is also invalid, using None")
-                return None
-        elif source == "override" and default is not None:
-            # Override failed, try default
+                return _validate_value(default, rule, env_var)
+            except ConfigResolutionError as default_error:
+                # Both raw_value and explicit default failed validation - this is a programming error
+                raise ConfigResolutionError(
+                    f"{env_var}: both resolved value '{raw_value}' and default '{default}' failed validation"
+                ) from default_error
+        # No default provided or raw_value == default, return None for optional config
+        return None
+
+
+def _resolve_via_rust(
+    rust_key: str, override: Any, default: Any, rule: ValidationRule
+) -> Any:
+    """Resolve config value via Rust core.
+
+    Maintains ENV > override > default precedence by always calling Rust resolver.
+    Invalid overrides are treated as None so Rust can fall back to ENV vars.
+    """
+    if mcp_mesh_core is None:
+        raise RuntimeError(
+            "mcp_mesh_core is not available - this function should not be called"
+        )
+
+    # Convert override to string for Rust (it expects Option<String>)
+    param_str = str(override) if override is not None else None
+
+    # Use appropriate Rust function based on validation rule
+    if rule == ValidationRule.TRUTHY_RULE:
+        # Boolean resolution - try to coerce override, use None if invalid
+        # This ensures Rust can still check ENV vars when override is invalid
+        param_bool = None
+        if override is not None:
+            if isinstance(override, bool):
+                param_bool = override
+            elif isinstance(override, str):
+                lower_val = override.lower()
+                if lower_val in ("true", "1", "yes", "on"):
+                    param_bool = True
+                elif lower_val in ("false", "0", "no", "off"):
+                    param_bool = False
+                # else: invalid string - leave param_bool as None, let Rust check ENV
+            else:
+                param_bool = bool(override)
+        return mcp_mesh_core.resolve_config_bool_py(rust_key, param_bool)
+
+    elif rule in (ValidationRule.PORT_RULE, ValidationRule.NONZERO_RULE):
+        # Integer resolution - try to coerce override, use None if invalid
+        # This ensures Rust can still check ENV vars when override is invalid
+        param_int = None
+        if override is not None:
             try:
-                logger.warning(
-                    f"Falling back to default value for {env_var}: {default}"
-                )
-                validated_default = _validate_value(default, rule, env_var)
-                return validated_default
-            except ConfigResolutionError:
-                logger.error(f"Default value for {env_var} is also invalid, using None")
-                return None
-        else:
-            # Already tried the last option or no fallbacks available
-            logger.error(f"No valid fallback for {env_var}, using None")
-            return None
+                param_int = int(override)
+            except (ValueError, TypeError):
+                # Invalid override - leave param_int as None, let Rust check ENV
+                pass
+        result = mcp_mesh_core.resolve_config_int_py(rust_key, param_int)
+        return result if result is not None else default
+
+    else:
+        # String resolution (default)
+        # Rust core returns empty string when no value found, treat as None
+        result = mcp_mesh_core.resolve_config_py(rust_key, param_str)
+        return result if result else default
+
+
+def _resolve_via_python(env_var: str, override: Any, default: Any) -> Any:
+    """Resolve config value via Python os.environ (fallback for non-mesh config)."""
+    import os
+
+    env_value = os.environ.get(env_var)
+    if env_value is not None:
+        return env_value
+    elif override is not None:
+        return override
+    else:
+        return default
 
 
 def _validate_value(value: Any, rule: ValidationRule, env_var: str) -> Any:

_mcp_mesh/shared/defaults.py

@@ -1,32 +1,103 @@
 """
 Centralized system defaults for MCP Mesh.
 
-This module provides a single source of truth for all default configuration values
-in the MCP Mesh system. All defaults should be defined here and accessed through
-the config_resolver system to ensure consistent precedence handling.
+This module provides access to default configuration values. For config keys
+that exist in Rust core (registry_url, namespace, health_interval, etc.),
+defaults are fetched from Rust to ensure consistency across all SDKs.
+
+Python-specific defaults (like AUTO_RUN, HTTP_ENABLED) remain here as they
+are not applicable to other language SDKs.
 """
 
+import logging
 from typing import Any
 
+logger = logging.getLogger(__name__)
+
+# Try to import the Rust core module for defaults
+try:
+    import mcp_mesh_core
+
+    _RUST_CORE_AVAILABLE = True
+except ImportError:
+    mcp_mesh_core = None  # type: ignore[assignment]
+    _RUST_CORE_AVAILABLE = False
+    logger.debug("mcp_mesh_core not available - using Python-only defaults")
+
+
+def _get_rust_default(key: str, fallback: Any = None) -> Any:
+    """Get default value from Rust core, with fallback for when core is unavailable."""
+    if _RUST_CORE_AVAILABLE and mcp_mesh_core is not None:
+        result = mcp_mesh_core.get_default_py(key)
+        if result is not None:
+            return result
+    return fallback
+
+
+def _get_rust_default_int(key: str, fallback: int) -> int:
+    """Get integer default value from Rust core."""
+    if _RUST_CORE_AVAILABLE and mcp_mesh_core is not None:
+        result = mcp_mesh_core.get_default_py(key)
+        if result is not None:
+            try:
+                return int(result)
+            except (ValueError, TypeError):
+                pass
+    return fallback
+
 
 class MeshDefaults:
-    """Centralized defaults for all MCP Mesh configuration values."""
+    """Centralized defaults for all MCP Mesh configuration values.
+
+    Config keys that exist in Rust core fetch their defaults from Rust.
+    Python-specific config values have their defaults defined here.
+    """
 
-    # Health and heartbeat configuration
-    HEALTH_INTERVAL = 5  # seconds - fast heartbeat optimization
-    AUTO_RUN_INTERVAL = 10  # seconds
+    # ==========================================================================
+    # Defaults from Rust core (fetched dynamically)
+    # ==========================================================================
+
+    @classmethod
+    @property
+    def HEALTH_INTERVAL(cls) -> int:
+        """Heartbeat interval in seconds. From Rust core."""
+        return _get_rust_default_int("health_interval", 5)
+
+    @classmethod
+    @property
+    def NAMESPACE(cls) -> str:
+        """Default namespace. From Rust core."""
+        return _get_rust_default("namespace", "default")
+
+    @classmethod
+    @property
+    def REGISTRY_URL(cls) -> str:
+        """Default registry URL. From Rust core."""
+        return _get_rust_default("registry_url", "http://localhost:8000")
+
+    @classmethod
+    @property
+    def REDIS_URL(cls) -> str:
+        """Default Redis URL. From Rust core."""
+        return _get_rust_default("redis_url", "redis://localhost:6379")
+
+    # ==========================================================================
+    # Python-specific defaults (not in Rust core)
+    # ==========================================================================
 
     # HTTP server configuration
-    HTTP_HOST = "0.0.0.0"
-    HTTP_PORT = 0  # auto-assign
+    HTTP_HOST = "0.0.0.0"  # Binding address (Rust core has auto-detect for external IP)
+    HTTP_PORT = 0  # Auto-assign port
     HTTP_ENABLED = True
 
-    # Agent configuration
-    NAMESPACE = "default"
-    AUTO_RUN = True
+    # Agent behavior configuration
+    AUTO_RUN = True  # Auto-start agent after decoration
+    AUTO_RUN_INTERVAL = 10  # seconds - debounce for auto-run
+
+    # Version
     VERSION = "1.0.0"
 
-    # Registry configuration defaults (if needed in future)
+    # Registry configuration
     REGISTRY_TIMEOUT = 30  # seconds
 
     @classmethod
@@ -38,12 +109,16 @@ class MeshDefaults:
             Dictionary of all default configuration values
         """
         return {
+            # From Rust core
             "health_interval": cls.HEALTH_INTERVAL,
+            "namespace": cls.NAMESPACE,
+            "registry_url": cls.REGISTRY_URL,
+            "redis_url": cls.REDIS_URL,
+            # Python-specific
             "auto_run_interval": cls.AUTO_RUN_INTERVAL,
             "http_host": cls.HTTP_HOST,
             "http_port": cls.HTTP_PORT,
             "http_enabled": cls.HTTP_ENABLED,
-            "namespace": cls.NAMESPACE,
             "auto_run": cls.AUTO_RUN,
             "version": cls.VERSION,
             "registry_timeout": cls.REGISTRY_TIMEOUT,