mcp-mesh 0.8.1__py3-none-any.whl → 0.9.0b2__py3-none-any.whl

_mcp_mesh/__init__.py

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

_mcp_mesh/engine/mesh_llm_agent.py

@@ -9,7 +9,7 @@ import json
 import logging
 import time
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Literal, Optional, Union
 
 from pydantic import BaseModel
 
@@ -539,8 +539,8 @@ IMPORTANT TOOL CALLING RULES:
 
             logger.debug(
                 f"📥 Received response from mesh provider: "
-                f"content={message_dict.get('content', '')[:200]}..., "
-                f"tool_calls={len(message_dict.get('tool_calls', []))}"
+                f"content={(message_dict.get('content') or '')[:200]}..., "
+                f"tool_calls={len(message_dict.get('tool_calls') or [])}"
             )
 
             return MockResponse(message_dict)
@@ -618,13 +618,20 @@ IMPORTANT TOOL CALLING RULES:
         # Render base system prompt (from template or literal) with effective context
         base_system_prompt = self._render_system_prompt(effective_context)
 
-        # Phase 2: Use provider handler to format system prompt
-        # This allows vendor-specific optimizations (e.g., OpenAI skips JSON instructions)
-        system_content = self._provider_handler.format_system_prompt(
-            base_prompt=base_system_prompt,
-            tool_schemas=self._tool_schemas,
-            output_type=self.output_type,
-        )
+        # Phase 2: Format system prompt
+        if self._is_mesh_delegated:
+            # Delegate path: Just use base prompt + basic tool instructions
+            # Provider will add vendor-specific formatting
+            system_content = base_system_prompt
+            if self._tool_schemas:
+                system_content += "\n\nYou have access to tools. Use them when needed to gather information."
+        else:
+            # Direct path: Use vendor handler for vendor-specific optimizations
+            system_content = self._provider_handler.format_system_prompt(
+                base_prompt=base_system_prompt,
+                tool_schemas=self._tool_schemas,
+                output_type=self.output_type,
+            )
 
         # Debug: Log system prompt (truncated for privacy)
         logger.debug(

_mcp_mesh/engine/mesh_llm_agent_injector.py

@@ -123,11 +123,14 @@ class MeshLlmAgentInjector(BaseInjector):
 
                     # 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)
+                            return self._create_llm_agent(
+                                _func_id, context_value=context_value
+                            )
 
                         wrapper._mesh_create_context_agent = create_context_agent
                         logger.info(
@@ -262,17 +265,25 @@ class MeshLlmAgentInjector(BaseInjector):
             filter_config = llm_metadata.config.get("filter")
             has_filter = filter_config is not None and len(filter_config) > 0
 
+        # CRITICAL FIX: Always set config if not already set (prevents KeyError during race condition)
+        # When provider arrives before tools, config must be available for inject_llm_agent
+        # to create the LLM agent with context. Without this, _create_llm_agent fails with KeyError.
+        if "config" not in self._llm_agents[function_id] and llm_metadata:
+            self._llm_agents[function_id]["config"] = llm_metadata.config
+            self._llm_agents[function_id]["output_type"] = llm_metadata.output_type
+            self._llm_agents[function_id]["param_name"] = llm_metadata.param_name
+            self._llm_agents[function_id]["function"] = llm_metadata.function
+            logger.debug(
+                f"📋 Set config from DecoratorRegistry for '{function_id}' (awaiting tools)"
+            )
+
         # 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(
@@ -568,7 +579,9 @@ class MeshLlmAgentInjector(BaseInjector):
                         )
 
                 # Check if templates are enabled
-                is_template = config_dict.get("is_template", False) if config_dict else False
+                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
@@ -739,13 +752,17 @@ class MeshLlmAgentInjector(BaseInjector):
                 )
 
         # Create MeshLlmAgent with both metadata and proxies
+        # Use .get() with defaults for tools_metadata/proxies to handle race condition
+        # where provider arrives before tools (filter-based agents)
         llm_agent = MeshLlmAgent(
             config=llm_config,
-            filtered_tools=llm_agent_data[
-                "tools_metadata"
-            ],  # Metadata for schema building
+            filtered_tools=llm_agent_data.get(
+                "tools_metadata", []
+            ),  # Metadata for schema building (empty if tools not yet received)
             output_type=llm_agent_data["output_type"],
-            tool_proxies=llm_agent_data["tools_proxies"],  # Proxies for execution
+            tool_proxies=llm_agent_data.get(
+                "tools_proxies", {}
+            ),  # Proxies for execution (empty if tools not yet received)
             template_path=template_path if is_template else None,
             context_value=context_value if is_template else None,
             provider_proxy=llm_agent_data.get(

_mcp_mesh/engine/provider_handlers/__init__.py

@@ -9,6 +9,7 @@ from .base_provider_handler import (
     BASE_TOOL_INSTRUCTIONS,
     CLAUDE_ANTI_XML_INSTRUCTION,
     BaseProviderHandler,
+    is_simple_schema,
     make_schema_strict,
 )
 from .claude_handler import ClaudeHandler
@@ -22,6 +23,7 @@ __all__ = [
     "BASE_TOOL_INSTRUCTIONS",
     "CLAUDE_ANTI_XML_INSTRUCTION",
     # Utilities
+    "is_simple_schema",
     "make_schema_strict",
     # Handlers
     "BaseProviderHandler",

_mcp_mesh/engine/provider_handlers/base_provider_handler.py

@@ -6,9 +6,12 @@ that customize how different LLM vendors (Claude, OpenAI, Gemini, etc.) are call
 """
 
 import copy
+import logging
 from abc import ABC, abstractmethod
 from typing import Any, Optional
 
+logger = logging.getLogger(__name__)
+
 from pydantic import BaseModel
 
 # ============================================================================
@@ -61,6 +64,144 @@ def make_schema_strict(
     return result
 
 
+def is_simple_schema(schema: dict[str, Any]) -> bool:
+    """
+    Check if a JSON schema is simple enough for hint mode.
+
+    Simple schema criteria:
+    - Less than 5 fields
+    - All fields are basic types (str, int, float, bool, list)
+    - No nested Pydantic models ($ref or nested objects with properties)
+
+    This is used by provider handlers to decide between hint mode
+    (prompt-based JSON instructions) and strict mode (response_format).
+
+    Args:
+        schema: JSON schema dict
+
+    Returns:
+        True if schema is simple, False otherwise
+    """
+    try:
+        properties = schema.get("properties", {})
+
+        # Check field count
+        if len(properties) >= 5:
+            return False
+
+        # Check for nested objects or complex types
+        for field_name, field_schema in properties.items():
+            field_type = field_schema.get("type")
+
+            # Check for nested objects (indicates nested Pydantic model)
+            if field_type == "object" and "properties" in field_schema:
+                return False
+
+            # Check for $ref (nested model reference)
+            if "$ref" in field_schema:
+                return False
+
+            # Check array items for complex types
+            if field_type == "array":
+                items = field_schema.get("items", {})
+                if items.get("type") == "object" or "$ref" in items:
+                    return False
+
+        return True
+    except Exception:
+        return False
+
+
+def sanitize_schema_for_structured_output(schema: dict[str, Any]) -> dict[str, Any]:
+    """
+    Sanitize a JSON schema by removing validation keywords unsupported by LLM APIs.
+
+    LLM structured output APIs (Claude, OpenAI, Gemini) typically only support
+    the structural parts of JSON Schema, not validation constraints. This function
+    removes unsupported keywords to ensure uniform behavior across all providers.
+
+    Removed keywords:
+    - minimum, maximum (number range)
+    - exclusiveMinimum, exclusiveMaximum (exclusive bounds)
+    - minLength, maxLength (string length)
+    - minItems, maxItems (array size)
+    - pattern (regex validation)
+    - multipleOf (divisibility)
+
+    Args:
+        schema: JSON schema dict (will not be mutated)
+
+    Returns:
+        New schema with unsupported validation keywords removed
+    """
+    result = copy.deepcopy(schema)
+    _strip_unsupported_keywords_recursive(result)
+    logger.debug(
+        "Sanitized schema for structured output (removed validation-only keywords)"
+    )
+    return result
+
+
+# Keywords that are validation-only and not supported by LLM structured output APIs
+_UNSUPPORTED_SCHEMA_KEYWORDS = {
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "minLength",
+    "maxLength",
+    "minItems",
+    "maxItems",
+    "pattern",
+    "multipleOf",
+}
+
+
+def _strip_unsupported_keywords_recursive(obj: Any) -> None:
+    """
+    Recursively strip unsupported validation keywords from a schema object.
+
+    Args:
+        obj: Schema object to process (mutated in place)
+    """
+    if not isinstance(obj, dict):
+        return
+
+    # Remove unsupported keywords at this level
+    for keyword in _UNSUPPORTED_SCHEMA_KEYWORDS:
+        obj.pop(keyword, None)
+
+    # Process $defs (Pydantic uses this for nested models)
+    if "$defs" in obj:
+        for def_schema in obj["$defs"].values():
+            _strip_unsupported_keywords_recursive(def_schema)
+
+    # Process properties
+    if "properties" in obj:
+        for prop_schema in obj["properties"].values():
+            _strip_unsupported_keywords_recursive(prop_schema)
+
+    # Process items (for arrays)
+    if "items" in obj:
+        items = obj["items"]
+        if isinstance(items, dict):
+            _strip_unsupported_keywords_recursive(items)
+        elif isinstance(items, list):
+            for item in items:
+                _strip_unsupported_keywords_recursive(item)
+
+    # Process prefixItems (tuple validation)
+    if "prefixItems" in obj:
+        for item in obj["prefixItems"]:
+            _strip_unsupported_keywords_recursive(item)
+
+    # Process anyOf, oneOf, allOf
+    for key in ("anyOf", "oneOf", "allOf"):
+        if key in obj:
+            for item in obj[key]:
+                _strip_unsupported_keywords_recursive(item)
+
+
 def _add_strict_constraints_recursive(obj: Any, add_all_required: bool) -> None:
     """
     Recursively add strict constraints to a schema object.
@@ -223,6 +364,42 @@ class BaseProviderHandler(ABC):
             "json_mode": False,
         }
 
+    def apply_structured_output(
+        self,
+        output_schema: dict[str, Any],
+        output_type_name: Optional[str],
+        model_params: dict[str, Any],
+    ) -> dict[str, Any]:
+        """
+        Apply vendor-specific structured output handling to model params.
+
+        This is used by LLM providers (via mesh) when they receive an output_schema
+        from a consumer. Each vendor can customize how structured output is enforced.
+
+        Default behavior: Apply response_format with strict schema.
+        Override in subclasses for vendor-specific behavior (e.g., Claude hint mode).
+
+        Args:
+            output_schema: JSON schema dict from consumer
+            output_type_name: Name of the output type (e.g., "AnalysisResult")
+            model_params: Current model parameters dict (will be modified)
+
+        Returns:
+            Modified model_params with structured output settings applied
+        """
+        # Sanitize schema first to remove unsupported validation keywords
+        sanitized_schema = sanitize_schema_for_structured_output(output_schema)
+        strict_schema = make_schema_strict(sanitized_schema, add_all_required=True)
+        model_params["response_format"] = {
+            "type": "json_schema",
+            "json_schema": {
+                "name": output_type_name or "Response",
+                "schema": strict_schema,
+                "strict": True,
+            },
+        }
+        return model_params
+
     def __repr__(self) -> str:
         """String representation of handler."""
         return f"{self.__class__.__name__}(vendor='{self.vendor}')"