mcp-mesh 0.8.0b9__tar.gz → 0.8.1__tar.gz

{mcp_mesh-0.8.0b9 → mcp_mesh-0.8.1}/.gitignore

@@ -256,3 +256,12 @@ 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/
+.claude/
+*.org

{mcp_mesh-0.8.0b9 → mcp_mesh-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.8.0b9
+Version: 0.8.1
 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,6 +18,8 @@ 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: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
@@ -30,7 +32,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.0b9
+Requires-Dist: mcp-mesh-core>=0.8.1
 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

{mcp_mesh-0.8.0b9 → mcp_mesh-0.8.1}/_mcp_mesh/__init__.py

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

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

@@ -348,6 +348,15 @@ class DependencyInjector:
         logger.debug(f"🤖 Creating LLM injection wrapper for {function_id}")
         return self._llm_injector.create_injection_wrapper(func, function_id)
 
+    def initialize_direct_llm_agents(self) -> None:
+        """
+        Initialize LLM agents that use direct LiteLLM (no mesh delegation).
+
+        This should be called during agent startup to initialize agents that
+        don't need to wait for registry response.
+        """
+        self._llm_injector.initialize_direct_llm_agents()
+
     def create_injection_wrapper(
         self, func: Callable, dependencies: list[str]
     ) -> Callable:

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

@@ -14,8 +14,12 @@ 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
@@ -23,8 +27,7 @@ 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
@@ -633,12 +636,14 @@ IMPORTANT TOOL CALLING RULES:
             # Multi-turn conversation - use provided messages array
             messages = message.copy()
 
-            # 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}
+            # 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}
 
             # Log conversation history
             logger.info(
@@ -646,10 +651,17 @@ IMPORTANT TOOL CALLING RULES:
             )
         else:
             # Single-turn - build messages array from string
-            messages = [
-                {"role": "system", "content": system_content},
-                {"role": "user", "content": message},
-            ]
+            # 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},
+                ]
 
             logger.info(f"🚀 Starting agentic loop for message: {message[:100]}...")
 
@@ -705,6 +717,16 @@ 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.0b9 → mcp_mesh-0.8.1}/_mcp_mesh/engine/mesh_llm_agent_injector.py

@@ -65,6 +65,75 @@ class MeshLlmAgentInjector(BaseInjector):
         super().__init__()
         self._llm_agents: dict[str, dict[str, Any]] = {}
 
+    def initialize_direct_llm_agents(self) -> None:
+        """
+        Initialize LLM agents that use direct LiteLLM (no mesh delegation).
+
+        This handles the case where:
+        - provider is a string (e.g., "claude") - direct LiteLLM call
+        - filter is None or empty - no mesh tools needed
+
+        These agents don't need to wait for registry response since all
+        information is available at decorator time.
+        """
+        llm_agents = DecoratorRegistry.get_mesh_llm_agents()
+
+        for function_id, llm_metadata in llm_agents.items():
+            config = llm_metadata.config
+            provider = config.get("provider")
+            filter_config = config.get("filter")
+
+            # Check if this is a direct LiteLLM agent (provider is string, not dict)
+            is_direct_llm = isinstance(provider, str)
+
+            # Check if no tools needed (filter is None or empty)
+            has_no_filter = filter_config is None or (
+                isinstance(filter_config, list) and len(filter_config) == 0
+            )
+
+            if is_direct_llm and has_no_filter:
+                # Skip if already initialized
+                if function_id in self._llm_agents:
+                    continue
+
+                logger.info(
+                    f"🔧 Initializing direct LiteLLM agent for '{function_id}' "
+                    f"(provider={provider}, no filter)"
+                )
+
+                # Initialize empty tools data for direct LiteLLM
+                self._llm_agents[function_id] = {
+                    "config": config,
+                    "output_type": llm_metadata.output_type,
+                    "param_name": llm_metadata.param_name,
+                    "tools_metadata": [],  # No tools for direct LiteLLM
+                    "tools_proxies": {},  # No tool proxies needed
+                    "function": llm_metadata.function,
+                    "provider_proxy": None,  # No mesh delegation
+                }
+
+                # Get the wrapper and update it with LLM agent
+                wrapper = llm_metadata.function
+                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 MeshLlmAgent for '{function_id}' (direct LiteLLM mode)"
+                    )
+
+                    # Set factory for per-call context agent creation (template support)
+                    if config.get("is_template", False):
+                        def create_context_agent(
+                            context_value: Any, _func_id: str = function_id
+                        ) -> MeshLlmAgent:
+                            """Factory to create MeshLlmAgent with context for template rendering."""
+                            return self._create_llm_agent(_func_id, context_value=context_value)
+
+                        wrapper._mesh_create_context_agent = create_context_agent
+                        logger.info(
+                            f"🎯 Set context agent factory for template-based function '{function_id}' (direct LiteLLM mode)"
+                        )
+
     def _build_function_name_to_id_mapping(self) -> dict[str, str]:
         """
         Build mapping from function_name to function_id.
@@ -176,16 +245,41 @@ class MeshLlmAgentInjector(BaseInjector):
             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 (only if tools are also available)
-        # Get the function wrapper from DecoratorRegistry
+        # 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
 
-        # Only update wrapper if we have both tools and provider (tools_metadata indicates tools were processed)
+        # 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)"
+            )
+
+        # Update wrapper if we have tools data (either from filter matching or initialized empty)
         if (
             wrapper
             and hasattr(wrapper, "_mesh_update_llm_agent")
@@ -194,9 +288,26 @@ class MeshLlmAgentInjector(BaseInjector):
             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}'"
+                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"):
+
+            # Set factory for per-call context agent creation (template support)
+            # This is critical for filter=None cases where _process_function_tools isn't called
+            config_dict = llm_metadata.config if llm_metadata else {}
+            if config_dict.get("is_template", False):
+                # Capture function_id by value using default argument to avoid closure issues
+                def create_context_agent(
+                    context_value: Any, _func_id: str = function_id
+                ) -> MeshLlmAgent:
+                    """Factory to create MeshLlmAgent with context for template rendering."""
+                    return self._create_llm_agent(_func_id, context_value=context_value)
+
+                wrapper._mesh_create_context_agent = create_context_agent
+                logger.info(
+                    f"🎯 Set context agent factory for template-based function '{function_id}' (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"
             )
@@ -432,36 +543,60 @@ class MeshLlmAgentInjector(BaseInjector):
         def inject_llm_agent(func: Callable, args: tuple, kwargs: dict) -> tuple:
             """Inject LLM agent into kwargs if not provided."""
             if param_name not in kwargs or kwargs.get(param_name) is None:
-                # Phase 4: Check if templates are enabled
+                # Get config from runtime data or fallback to decorator registry.
+                # Runtime data (self._llm_agents) is populated during heartbeat and has
+                # tools/provider info. Decorator registry is populated at decorator time
+                # and always has config/context_param. For self-dependency calls that
+                # happen before heartbeat, we need the decorator registry fallback.
+                agent_data = None
+                config_dict = None
+
+                # Try runtime data first (has tools, provider from heartbeat)
                 if function_id in self._llm_agents:
                     agent_data = self._llm_agents[function_id]
-                    config_dict = agent_data["config"]
-                    is_template = config_dict.get("is_template", False)
-
-                    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
-
-                        # Detect context parameter
-                        context_param_name = config_dict.get("context_param")
-                        context_info = get_context_parameter_name(
-                            func, explicit_name=context_param_name
+                    config_dict = agent_data.get("config")
+
+                # Fallback to decorator registry (always available, has context_param)
+                # This is critical for self-dependency calls that happen before heartbeat
+                if config_dict is None:
+                    llm_agents_registry = DecoratorRegistry.get_mesh_llm_agents()
+                    if function_id in llm_agents_registry:
+                        llm_metadata = llm_agents_registry[function_id]
+                        config_dict = llm_metadata.config
+                        logger.debug(
+                            f"🔄 Using DecoratorRegistry fallback for '{function_id}' config (self-dependency before heartbeat)"
                         )
 
-                        # Extract context value from call
-                        context_value = None
-                        if context_info is not None:
-                            ctx_name, ctx_index = context_info
+                # Check if templates are enabled
+                is_template = config_dict.get("is_template", False) if config_dict else False
+
+                if is_template and config_dict:
+                    # Templates enabled - create per-call agent with context
+                    # Import signature analyzer for context detection
+                    from .signature_analyzer import get_context_parameter_name
 
-                            # Try kwargs first
-                            if ctx_name in kwargs:
-                                context_value = kwargs[ctx_name]
-                            # Then try positional args
-                            elif ctx_index < len(args):
-                                context_value = args[ctx_index]
+                    # Detect context parameter
+                    context_param_name = config_dict.get("context_param")
+                    context_info = get_context_parameter_name(
+                        func, explicit_name=context_param_name
+                    )
 
-                        # Create agent with context for this call
+                    # Extract context value from call
+                    context_value = None
+                    if context_info is not None:
+                        ctx_name, ctx_index = context_info
+
+                        # Try kwargs first
+                        if ctx_name in kwargs:
+                            context_value = kwargs[ctx_name]
+                        # Then try positional args
+                        elif ctx_index < len(args):
+                            context_value = args[ctx_index]
+
+                    # Create agent with context for this call
+                    # Note: _create_llm_agent requires function_id in self._llm_agents
+                    # If not available yet, use cached agent with context_value set directly
+                    if function_id in self._llm_agents:
                         current_agent = self._create_llm_agent(
                             function_id, context_value=context_value
                         )
@@ -469,22 +604,41 @@ class MeshLlmAgentInjector(BaseInjector):
                             f"🤖 Created MeshLlmAgent with context for {func.__name__}.{param_name}"
                         )
                     else:
-                        # No template - use cached agent (existing behavior)
+                        # Runtime data not yet available - use cached agent but log warning
+                        # The cached agent may have been created without context
                         current_agent = wrapper._mesh_llm_agent
                         if current_agent is not None:
-                            logger.debug(
-                                f"🤖 Injected MeshLlmAgent into {func.__name__}.{param_name}"
-                            )
+                            # Update context on the cached agent if possible
+                            if hasattr(current_agent, "_context_value"):
+                                current_agent._context_value = context_value
+                                logger.debug(
+                                    f"🤖 Updated context on cached MeshLlmAgent for {func.__name__}.{param_name}"
+                                )
+                            else:
+                                logger.debug(
+                                    f"🤖 Injected cached MeshLlmAgent into {func.__name__}.{param_name} (context may not be applied)"
+                                )
                         else:
                             logger.warning(
                                 f"⚠️ MeshLlmAgent for {func.__name__}.{param_name} is None (tools not yet received from registry)"
                             )
+                elif config_dict:
+                    # No template - use cached agent (existing behavior)
+                    current_agent = wrapper._mesh_llm_agent
+                    if current_agent is not None:
+                        logger.debug(
+                            f"🤖 Injected MeshLlmAgent into {func.__name__}.{param_name}"
+                        )
+                    else:
+                        logger.warning(
+                            f"⚠️ MeshLlmAgent for {func.__name__}.{param_name} is None (tools not yet received from registry)"
+                        )
                 else:
-                    # No agent data - use cached (backward compatibility)
+                    # No config found anywhere - use cached (backward compatibility)
                     current_agent = wrapper._mesh_llm_agent
                     if current_agent is None:
                         logger.warning(
-                            f"⚠️ MeshLlmAgent for {func.__name__}.{param_name} is None (tools not yet received from registry)"
+                            f"⚠️ MeshLlmAgent for {func.__name__}.{param_name} is None (no config found)"
                         )
 
                 kwargs[param_name] = current_agent

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

@@ -104,9 +104,10 @@ 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=[],
+                tags=json.dumps([]),
                 version=None,
             )
             deps.append(dep_spec)
@@ -136,6 +137,7 @@ 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,
@@ -272,6 +274,8 @@ 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 = (

{mcp_mesh-0.8.0b9 → mcp_mesh-0.8.1}/_mcp_mesh/pipeline/mcp_heartbeat/rust_heartbeat.py

@@ -117,9 +117,12 @@ def _build_agent_spec(context: dict[str, Any]) -> Any:
         # Build dependency specs
         deps = []
         for dep_info in tool_metadata.get("dependencies", []):
+            # Serialize tags to JSON to support nested arrays for OR alternatives
+            # e.g., ["addition", ["python", "typescript"]] -> addition AND (python OR typescript)
+            tags_json = json.dumps(dep_info.get("tags", []))
             dep_spec = core.DependencySpec(
                 capability=dep_info.get("capability", ""),
-                tags=dep_info.get("tags", []),
+                tags=tags_json,
                 version=dep_info.get("version"),
             )
             deps.append(dep_spec)
@@ -269,6 +272,14 @@ async def _handle_mesh_event(event: Any, context: dict[str, Any]) -> None:
     if event_type == "agent_registered":
         logger.info(f"Agent registered with ID: {event.agent_id}")
 
+        # Initialize direct LiteLLM agents that don't need mesh delegation
+        # These agents have provider="string" and filter=None, so all info is
+        # available at decorator time - no need to wait for registry response
+        from ...engine.dependency_injector import get_global_injector
+
+        injector = get_global_injector()
+        injector.initialize_direct_llm_agents()
+
     elif event_type == "registration_failed":
         logger.error(f"Agent registration failed: {event.error}")