mcp-mesh 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

_mcp_mesh/__init__.py

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

_mcp_mesh/engine/llm_config.py

@@ -17,7 +17,7 @@ class LLMConfig:
     Supports both direct LiteLLM providers (string) and mesh delegation (dict).
     """
 
-    provider: Union[str, Dict[str, Any]] = "claude"
+    provider: Union[str, dict[str, Any]] = "claude"
     """LLM provider - string for direct LiteLLM (e.g., 'claude', 'openai') or dict for mesh delegation
        Mesh delegation format: {"capability": "llm", "tags": ["claude"], "version": ">=1.0.0"}"""
 
@@ -33,6 +33,9 @@ class LLMConfig:
     system_prompt: Optional[str] = None
     """Optional system prompt to prepend to all interactions"""
 
+    output_mode: Optional[str] = None
+    """Output mode override: 'strict', 'hint', or 'text'. If None, auto-detected by handler."""
+
     def __post_init__(self):
         """Validate configuration after initialization."""
         if self.max_iterations < 1:
@@ -43,3 +46,9 @@ class LLMConfig:
         # Only validate model for string providers (not needed for mesh delegation)
         if isinstance(self.provider, str) and not self.model:
             raise ValueError("model cannot be empty when using string provider")
+
+        # Validate output_mode if provided
+        if self.output_mode and self.output_mode not in ("strict", "hint", "text"):
+            raise ValueError(
+                f"output_mode must be 'strict', 'hint', or 'text', got '{self.output_mode}'"
+            )

_mcp_mesh/engine/mesh_llm_agent.py

@@ -58,7 +58,7 @@ class MeshLlmAgent:
         self,
         config: LLMConfig,
         filtered_tools: list[dict[str, Any]],
-        output_type: type[BaseModel],
+        output_type: type[BaseModel] | type[str],
         tool_proxies: Optional[dict[str, Any]] = None,
         template_path: Optional[str] = None,
         context_value: Optional[Any] = None,
@@ -71,7 +71,7 @@ class MeshLlmAgent:
         Args:
             config: LLM configuration (provider, model, api_key, etc.)
             filtered_tools: List of tool metadata from registry (for schema building)
-            output_type: Pydantic BaseModel for response validation
+            output_type: Pydantic BaseModel for response validation, or str for plain text
             tool_proxies: Optional map of function_name -> proxy for tool execution
             template_path: Optional path to Jinja2 template file for system prompt
             context_value: Optional context for template rendering (MeshContextModel, dict, or None)
@@ -87,6 +87,7 @@ class MeshLlmAgent:
         self.max_iterations = config.max_iterations
         self.output_type = output_type
         self.system_prompt = config.system_prompt  # Public attribute for tests
+        self.output_mode = config.output_mode  # Output mode override (strict/hint/text)
         self._iteration_count = 0
 
         # Detect if using mesh delegation (provider is dict)
@@ -126,12 +127,19 @@ IMPORTANT TOOL CALLING RULES:
 - Once you have gathered all necessary information, provide your final response
 """
 
-        schema = self.output_type.model_json_schema()
-        schema_str = json.dumps(schema, indent=2)
-        self._cached_json_instructions = (
-            f"\n\nIMPORTANT: You must return your final response as valid JSON matching this schema:\n"
-            f"{schema_str}\n\nReturn ONLY the JSON object, no additional text."
-        )
+        # Only generate JSON schema for Pydantic models, not for str return type
+        if self.output_type is not str and hasattr(
+            self.output_type, "model_json_schema"
+        ):
+            schema = self.output_type.model_json_schema()
+            schema_str = json.dumps(schema, indent=2)
+            self._cached_json_instructions = (
+                f"\n\nIMPORTANT: You must return your final response as valid JSON matching this schema:\n"
+                f"{schema_str}\n\nReturn ONLY the JSON object, no additional text."
+            )
+        else:
+            # str return type - no JSON schema needed
+            self._cached_json_instructions = ""
 
         logger.debug(
             f"🤖 MeshLlmAgent initialized: provider={config.provider}, model={config.model}, "
@@ -483,22 +491,36 @@ IMPORTANT TOOL CALLING RULES:
             try:
                 # Call LLM (either direct LiteLLM or mesh-delegated)
                 try:
-                    if self._is_mesh_delegated:
-                        # Mesh delegation: use provider handler to prepare vendor-specific request
-                        # Phase 2: Handler prepares params including response_format for OpenAI, etc.
-                        request_params = self._provider_handler.prepare_request(
-                            messages=messages,
-                            tools=self._tool_schemas if self._tool_schemas else None,
-                            output_type=self.output_type,
-                            **kwargs,
-                        )
+                    # Build kwargs with output_mode override if set
+                    call_kwargs = (
+                        {**kwargs, "output_mode": self.output_mode}
+                        if self.output_mode
+                        else kwargs
+                    )
+
+                    # Use provider handler to prepare vendor-specific request
+                    request_params = self._provider_handler.prepare_request(
+                        messages=messages,
+                        tools=self._tool_schemas if self._tool_schemas else None,
+                        output_type=self.output_type,
+                        **call_kwargs,
+                    )
 
-                        # Extract model_params to send to provider
-                        # Don't send messages/tools (already separate params) or model/api_key (provider has them)
+                    if self._is_mesh_delegated:
+                        # Mesh delegation: extract model_params to send to provider
+                        # Exclude messages/tools (separate params), model/api_key (provider has them),
+                        # and output_mode (only used locally by prepare_request)
                         model_params = {
                             k: v
                             for k, v in request_params.items()
-                            if k not in ["messages", "tools", "model", "api_key"]
+                            if k
+                            not in [
+                                "messages",
+                                "tools",
+                                "model",
+                                "api_key",
+                                "output_mode",
+                            ]
                         }
 
                         logger.debug(
@@ -509,19 +531,10 @@ IMPORTANT TOOL CALLING RULES:
                         response = await self._call_mesh_provider(
                             messages=messages,
                             tools=self._tool_schemas if self._tool_schemas else None,
-                            **model_params,  # Now includes response_format!
+                            **model_params,
                         )
                     else:
-                        # Direct LiteLLM call
-                        # Phase 2: Use provider handler to prepare vendor-specific request
-                        request_params = self._provider_handler.prepare_request(
-                            messages=messages,
-                            tools=self._tool_schemas if self._tool_schemas else None,
-                            output_type=self.output_type,
-                            **kwargs,
-                        )
-
-                        # Add model and API key (common to all vendors)
+                        # Direct LiteLLM call: add model and API key
                         request_params["model"] = self.model
                         request_params["api_key"] = self.api_key
 
@@ -612,15 +625,20 @@ IMPORTANT TOOL CALLING RULES:
         """
         Parse LLM response into output type.
 
-        Delegates to ResponseParser for actual parsing logic.
+        For str return type, returns content directly without parsing.
+        For Pydantic models, delegates to ResponseParser.
 
         Args:
             content: Response content from LLM
 
         Returns:
-            Parsed Pydantic model instance
+            Raw string (if output_type is str) or parsed Pydantic model instance
 
         Raises:
             ResponseParseError: If response doesn't match output_type schema or invalid JSON
         """
+        # For str return type, return content directly without parsing
+        if self.output_type is str:
+            return content
+
         return ResponseParser.parse(content, self.output_type)

_mcp_mesh/engine/mesh_llm_agent_injector.py

@@ -19,6 +19,35 @@ from .unified_mcp_proxy import UnifiedMCPProxy
 logger = logging.getLogger(__name__)
 
 
+def extract_vendor_from_model(model: str) -> str | None:
+    """
+    Extract vendor name from LiteLLM model string.
+
+    LiteLLM uses vendor/model format (e.g., "anthropic/claude-sonnet-4-5").
+    This extracts the vendor for provider handler selection.
+
+    Args:
+        model: LiteLLM model string
+
+    Returns:
+        Vendor name (e.g., "anthropic", "openai") or None if not extractable
+
+    Examples:
+        "anthropic/claude-sonnet-4-5" -> "anthropic"
+        "openai/gpt-4o" -> "openai"
+        "gpt-4" -> None (no vendor prefix)
+    """
+    if not model:
+        return None
+
+    if "/" in model:
+        vendor = model.split("/")[0].lower().strip()
+        logger.debug(f"🔍 Extracted vendor '{vendor}' from model '{model}'")
+        return vendor
+
+    return None
+
+
 class MeshLlmAgentInjector(BaseInjector):
     """
     Manages dynamic injection of MeshLlmAgent proxies.
@@ -86,9 +115,7 @@ class MeshLlmAgentInjector(BaseInjector):
                     exc_info=True,
                 )
 
-    def process_llm_providers(
-        self, llm_providers: dict[str, dict[str, Any]]
-    ) -> None:
+    def process_llm_providers(self, llm_providers: dict[str, dict[str, Any]]) -> None:
         """
         Process llm_providers from registry response (v0.6.1 mesh delegation).
 
@@ -181,9 +208,7 @@ class MeshLlmAgentInjector(BaseInjector):
         """
         function_name = provider_data.get("name")
         if not function_name:
-            raise ValueError(
-                f"Provider missing required 'name' field: {provider_data}"
-            )
+            raise ValueError(f"Provider missing required 'name' field: {provider_data}")
 
         endpoint = provider_data.get("endpoint")
         if not endpoint:
@@ -282,6 +307,22 @@ class MeshLlmAgentInjector(BaseInjector):
             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}'")
+
+            # Set factory for per-call context agent creation (template support)
+            # This allows the decorator's wrapper to create new agents with context per-call
+            config_dict = llm_metadata.config
+            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}'"
+                )
         elif wrapper:
             logger.warning(
                 f"⚠️ Wrapper for '{function_id}' found but has no _mesh_update_llm_agent method"
@@ -487,12 +528,28 @@ class MeshLlmAgentInjector(BaseInjector):
             api_key=config_dict.get("api_key", ""),  # Will use ENV if empty
             max_iterations=config_dict.get("max_iterations", 10),
             system_prompt=config_dict.get("system_prompt"),
+            output_mode=config_dict.get(
+                "output_mode"
+            ),  # Pass through output_mode from decorator
         )
 
         # Phase 4: Template support - extract template metadata
         is_template = config_dict.get("is_template", False)
         template_path = config_dict.get("template_path")
 
+        # Determine vendor for provider handler selection
+        # Priority: 1) From registry (mesh delegation), 2) From model name, 3) None
+        vendor = llm_agent_data.get("vendor")
+        if not vendor:
+            # For direct LiteLLM calls, extract vendor from model name
+            # e.g., "anthropic/claude-sonnet-4-5" -> "anthropic"
+            model = config_dict.get("model", "")
+            vendor = extract_vendor_from_model(model)
+            if vendor:
+                logger.info(
+                    f"🔍 Extracted vendor '{vendor}' from model '{model}' for handler selection"
+                )
+
         # Create MeshLlmAgent with both metadata and proxies
         llm_agent = MeshLlmAgent(
             config=llm_config,
@@ -503,14 +560,20 @@ class MeshLlmAgentInjector(BaseInjector):
             tool_proxies=llm_agent_data["tools_proxies"],  # Proxies for execution
             template_path=template_path if is_template else None,
             context_value=context_value if is_template else None,
-            provider_proxy=llm_agent_data.get("provider_proxy"),  # Provider proxy for mesh delegation
-            vendor=llm_agent_data.get("vendor"),  # Phase 2: Vendor for provider handler selection
+            provider_proxy=llm_agent_data.get(
+                "provider_proxy"
+            ),  # Provider proxy for mesh delegation
+            vendor=vendor,  # Vendor for provider handler selection (from registry or model name)
         )
 
         logger.debug(
             f"🤖 Created MeshLlmAgent for {function_id} with {len(llm_agent_data['tools_metadata'])} tools"
             + (f", template={template_path}" if is_template else "")
-            + (f", provider_proxy={llm_agent_data.get('provider_proxy').function_name if llm_agent_data.get('provider_proxy') else 'None'}" if isinstance(config_dict.get("provider"), dict) else "")
+            + (
+                f", provider_proxy={llm_agent_data.get('provider_proxy').function_name if llm_agent_data.get('provider_proxy') else 'None'}"
+                if isinstance(config_dict.get("provider"), dict)
+                else ""
+            )
         )
 
         return llm_agent