mcp-mesh 0.7.5__tar.gz → 0.7.7__tar.gz

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.7.5
+Version: 0.7.7
 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

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/_mcp_mesh/__init__.py

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

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/_mcp_mesh/engine/provider_handlers/generic_handler.py

@@ -5,7 +5,7 @@ Provides sensible defaults using prompt-based approach similar to Claude.
 """
 
 import json
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
@@ -46,11 +46,11 @@ class GenericHandler(BaseProviderHandler):
 
     def prepare_request(
         self,
-        messages: List[Dict[str, Any]],
-        tools: Optional[List[Dict[str, Any]]],
+        messages: list[dict[str, Any]],
+        tools: Optional[list[dict[str, Any]]],
         output_type: type[BaseModel],
-        **kwargs: Any
-    ) -> Dict[str, Any]:
+        **kwargs: Any,
+    ) -> dict[str, Any]:
         """
         Prepare request with standard parameters.
 
@@ -86,8 +86,8 @@ class GenericHandler(BaseProviderHandler):
     def format_system_prompt(
         self,
         base_prompt: str,
-        tool_schemas: Optional[List[Dict[str, Any]]],
-        output_type: type[BaseModel]
+        tool_schemas: Optional[list[dict[str, Any]]],
+        output_type: type,
     ) -> str:
         """
         Format system prompt with explicit JSON instructions.
@@ -97,11 +97,12 @@ class GenericHandler(BaseProviderHandler):
         - Explicit JSON schema (since we can't assume response_format)
         - Clear tool calling guidelines
         - Maximum explicitness for compatibility
+        - Skip JSON schema for str return type (text mode)
 
         Args:
             base_prompt: Base system prompt
             tool_schemas: Optional tool schemas
-            output_type: Expected response type
+            output_type: Expected response type (str or Pydantic model)
 
         Returns:
             Formatted system prompt with explicit instructions
@@ -120,24 +121,29 @@ TOOL CALLING RULES:
 - Provide your final response after gathering needed information
 """
 
-        # Add explicit JSON schema instructions
+        # Skip JSON schema for str return type (text mode)
+        if output_type is str:
+            return system_content
+
+        # Add explicit JSON schema instructions for Pydantic models
         # (since we can't rely on vendor-specific structured output)
-        schema = output_type.model_json_schema()
-        schema_str = json.dumps(schema, indent=2)
-        system_content += (
-            f"\n\nIMPORTANT: Return your final response as valid JSON matching this exact schema:\n"
-            f"{schema_str}\n\n"
-            f"Rules:\n"
-            f"- Return ONLY the JSON object, no markdown, no additional text\n"
-            f"- Ensure all required fields are present\n"
-            f"- Match the schema exactly\n"
-            f"- Use double quotes for strings\n"
-            f"- Do not include comments"
-        )
+        if isinstance(output_type, type) and issubclass(output_type, BaseModel):
+            schema = output_type.model_json_schema()
+            schema_str = json.dumps(schema, indent=2)
+            system_content += (
+                f"\n\nIMPORTANT: Return your final response as valid JSON matching this exact schema:\n"
+                f"{schema_str}\n\n"
+                f"Rules:\n"
+                f"- Return ONLY the JSON object, no markdown, no additional text\n"
+                f"- Ensure all required fields are present\n"
+                f"- Match the schema exactly\n"
+                f"- Use double quotes for strings\n"
+                f"- Do not include comments"
+            )
 
         return system_content
 
-    def get_vendor_capabilities(self) -> Dict[str, bool]:
+    def get_vendor_capabilities(self) -> dict[str, bool]:
         """
         Return conservative capability flags.
 

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/_mcp_mesh/engine/provider_handlers/openai_handler.py

@@ -6,7 +6,7 @@ using OpenAI's native structured output capabilities.
 """
 
 import json
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from pydantic import BaseModel
 
@@ -48,7 +48,7 @@ class OpenAIHandler(BaseProviderHandler):
         self,
         messages: list[dict[str, Any]],
         tools: Optional[list[dict[str, Any]]],
-        output_type: type[BaseModel],
+        output_type: type,
         **kwargs: Any,
     ) -> dict[str, Any]:
         """
@@ -58,11 +58,12 @@ class OpenAIHandler(BaseProviderHandler):
         - Use response_format parameter for guaranteed JSON schema compliance
         - This is the KEY difference from Claude handler
         - response_format.json_schema ensures the response matches output_type
+        - Skip structured output for str return types (text mode)
 
         Args:
             messages: List of message dicts
             tools: Optional list of tool schemas
-            output_type: Pydantic model for response
+            output_type: Return type (str or Pydantic model)
             **kwargs: Additional model parameters
 
         Returns:
@@ -78,25 +79,34 @@ class OpenAIHandler(BaseProviderHandler):
         if tools:
             request_params["tools"] = tools
 
-        # CRITICAL: Add response_format for structured output
-        # This is what makes OpenAI construct responses according to schema
-        # rather than relying on prompt instructions alone
-        schema = output_type.model_json_schema()
-
-        # Transform schema for OpenAI strict mode
-        # OpenAI requires additionalProperties: false on all object schemas
-        schema = self._add_additional_properties_false(schema)
-
-        # OpenAI structured output format
-        # See: https://platform.openai.com/docs/guides/structured-outputs
-        request_params["response_format"] = {
-            "type": "json_schema",
-            "json_schema": {
-                "name": output_type.__name__,
-                "schema": schema,
-                "strict": True,  # Enforce schema compliance
-            },
-        }
+        # Skip structured output for str return type (text mode)
+        if output_type is str:
+            return request_params
+
+        # Only add response_format for Pydantic models
+        if not (isinstance(output_type, type) and issubclass(output_type, BaseModel)):
+            return request_params
+
+        if isinstance(output_type, type) and issubclass(output_type, BaseModel):
+            # CRITICAL: Add response_format for structured output
+            # This is what makes OpenAI construct responses according to schema
+            # rather than relying on prompt instructions alone
+            schema = output_type.model_json_schema()
+
+            # Transform schema for OpenAI strict mode
+            # OpenAI requires additionalProperties: false on all object schemas
+            schema = self._add_additional_properties_false(schema)
+
+            # OpenAI structured output format
+            # See: https://platform.openai.com/docs/guides/structured-outputs
+            request_params["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": output_type.__name__,
+                    "schema": schema,
+                    "strict": True,  # Enforce schema compliance
+                },
+            }
 
         return request_params
 
@@ -104,7 +114,7 @@ class OpenAIHandler(BaseProviderHandler):
         self,
         base_prompt: str,
         tool_schemas: Optional[list[dict[str, Any]]],
-        output_type: type[BaseModel],
+        output_type: type,
     ) -> str:
         """
         Format system prompt for OpenAI (concise approach).
@@ -114,6 +124,7 @@ class OpenAIHandler(BaseProviderHandler):
         2. Add tool calling instructions if tools present
         3. NO JSON schema instructions (response_format handles this)
         4. Keep prompt concise - OpenAI works well with shorter prompts
+        5. Skip JSON note for str return type (text mode)
 
         Key Difference from Claude:
         - No JSON schema in prompt (response_format ensures compliance)
@@ -123,7 +134,7 @@ class OpenAIHandler(BaseProviderHandler):
         Args:
             base_prompt: Base system prompt
             tool_schemas: Optional tool schemas
-            output_type: Expected response type
+            output_type: Expected response type (str or Pydantic model)
 
         Returns:
             Formatted system prompt optimized for OpenAI
@@ -141,6 +152,10 @@ IMPORTANT TOOL CALLING RULES:
 - Once you have all needed information, provide your final response
 """
 
+        # Skip JSON note for str return type (text mode)
+        if output_type is str:
+            return system_content
+
         # NOTE: We do NOT add JSON schema instructions here!
         # OpenAI's response_format parameter handles JSON structure automatically.
         # Adding explicit JSON instructions can actually confuse the model.

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/_mcp_mesh/generated/.openapi-generator/FILES

@@ -27,10 +27,12 @@ mcp_mesh_registry_client/models/heartbeat_request.py
 mcp_mesh_registry_client/models/heartbeat_request_metadata.py
 mcp_mesh_registry_client/models/heartbeat_response.py
 mcp_mesh_registry_client/models/llm_provider.py
+mcp_mesh_registry_client/models/llm_provider_resolution_info.py
 mcp_mesh_registry_client/models/llm_tool_filter.py
 mcp_mesh_registry_client/models/llm_tool_filter_filter_inner.py
 mcp_mesh_registry_client/models/llm_tool_filter_filter_inner_one_of.py
 mcp_mesh_registry_client/models/llm_tool_info.py
+mcp_mesh_registry_client/models/llm_tool_resolution_info.py
 mcp_mesh_registry_client/models/mesh_agent_register_metadata.py
 mcp_mesh_registry_client/models/mesh_agent_registration.py
 mcp_mesh_registry_client/models/mesh_registration_response.py

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/_mcp_mesh/generated/mcp_mesh_registry_client/__init__.py

@@ -69,10 +69,12 @@ from _mcp_mesh.generated.mcp_mesh_registry_client.models.heartbeat_request impor
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.heartbeat_request_metadata import HeartbeatRequestMetadata
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.heartbeat_response import HeartbeatResponse
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_provider import LLMProvider
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_provider_resolution_info import LLMProviderResolutionInfo
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_filter import LLMToolFilter
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_filter_filter_inner import LLMToolFilterFilterInner
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_filter_filter_inner_one_of import LLMToolFilterFilterInnerOneOf
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_info import LLMToolInfo
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_resolution_info import LLMToolResolutionInfo
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_agent_register_metadata import MeshAgentRegisterMetadata
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_agent_registration import MeshAgentRegistration
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_registration_response import MeshRegistrationResponse

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/_mcp_mesh/generated/mcp_mesh_registry_client/models/__init__.py

@@ -34,10 +34,12 @@ from _mcp_mesh.generated.mcp_mesh_registry_client.models.heartbeat_request impor
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.heartbeat_request_metadata import HeartbeatRequestMetadata
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.heartbeat_response import HeartbeatResponse
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_provider import LLMProvider
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_provider_resolution_info import LLMProviderResolutionInfo
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_filter import LLMToolFilter
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_filter_filter_inner import LLMToolFilterFilterInner
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_filter_filter_inner_one_of import LLMToolFilterFilterInnerOneOf
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_info import LLMToolInfo
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_resolution_info import LLMToolResolutionInfo
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_agent_register_metadata import MeshAgentRegisterMetadata
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_agent_registration import MeshAgentRegistration
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_registration_response import MeshRegistrationResponse

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/_mcp_mesh/generated/mcp_mesh_registry_client/models/agent_info.py

@@ -24,6 +24,8 @@ from typing import Any, ClassVar, Dict, List, Optional
 from typing_extensions import Annotated
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.capability_info import CapabilityInfo
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.dependency_resolution_info import DependencyResolutionInfo
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_provider_resolution_info import LLMProviderResolutionInfo
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_resolution_info import LLMToolResolutionInfo
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -40,9 +42,11 @@ class AgentInfo(BaseModel):
     total_dependencies: Annotated[int, Field(strict=True, ge=0)] = Field(description="Total number of dependencies required by this agent")
     dependencies_resolved: Annotated[int, Field(strict=True, ge=0)] = Field(description="Number of dependencies that have been resolved")
     dependency_resolutions: Optional[List[DependencyResolutionInfo]] = Field(default=None, description="List of all dependency resolutions (both resolved and unresolved)")
+    llm_tool_resolutions: Optional[List[LLMToolResolutionInfo]] = Field(default=None, description="List of all LLM tool resolutions for @mesh.llm filter")
+    llm_provider_resolutions: Optional[List[LLMProviderResolutionInfo]] = Field(default=None, description="List of all LLM provider resolutions for @mesh.llm provider")
     last_seen: Optional[datetime] = None
     version: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["id", "name", "agent_type", "status", "endpoint", "capabilities", "total_dependencies", "dependencies_resolved", "dependency_resolutions", "last_seen", "version"]
+    __properties: ClassVar[List[str]] = ["id", "name", "agent_type", "status", "endpoint", "capabilities", "total_dependencies", "dependencies_resolved", "dependency_resolutions", "llm_tool_resolutions", "llm_provider_resolutions", "last_seen", "version"]
 
     @field_validator('agent_type')
     def agent_type_validate_enum(cls, value):
@@ -111,6 +115,20 @@ class AgentInfo(BaseModel):
                 if _item_dependency_resolutions:
                     _items.append(_item_dependency_resolutions.to_dict())
             _dict['dependency_resolutions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in llm_tool_resolutions (list)
+        _items = []
+        if self.llm_tool_resolutions:
+            for _item_llm_tool_resolutions in self.llm_tool_resolutions:
+                if _item_llm_tool_resolutions:
+                    _items.append(_item_llm_tool_resolutions.to_dict())
+            _dict['llm_tool_resolutions'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in llm_provider_resolutions (list)
+        _items = []
+        if self.llm_provider_resolutions:
+            for _item_llm_provider_resolutions in self.llm_provider_resolutions:
+                if _item_llm_provider_resolutions:
+                    _items.append(_item_llm_provider_resolutions.to_dict())
+            _dict['llm_provider_resolutions'] = _items
         return _dict
 
     @classmethod
@@ -132,6 +150,8 @@ class AgentInfo(BaseModel):
             "total_dependencies": obj.get("total_dependencies"),
             "dependencies_resolved": obj.get("dependencies_resolved"),
             "dependency_resolutions": [DependencyResolutionInfo.from_dict(_item) for _item in obj["dependency_resolutions"]] if obj.get("dependency_resolutions") is not None else None,
+            "llm_tool_resolutions": [LLMToolResolutionInfo.from_dict(_item) for _item in obj["llm_tool_resolutions"]] if obj.get("llm_tool_resolutions") is not None else None,
+            "llm_provider_resolutions": [LLMProviderResolutionInfo.from_dict(_item) for _item in obj["llm_provider_resolutions"]] if obj.get("llm_provider_resolutions") is not None else None,
             "last_seen": obj.get("last_seen"),
             "version": obj.get("version")
         })

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/_mcp_mesh/generated/mcp_mesh_registry_client/models/capability_info.py

@@ -21,6 +21,8 @@ import json
 from pydantic import BaseModel, ConfigDict, Field, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from typing_extensions import Annotated
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_provider import LLMProvider
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.llm_tool_filter import LLMToolFilter
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -33,7 +35,9 @@ class CapabilityInfo(BaseModel):
     function_name: Annotated[str, Field(min_length=1, strict=True)] = Field(description="Name of the function that provides this capability")
     tags: Optional[List[StrictStr]] = Field(default=None, description="Tags associated with this capability")
     description: Optional[StrictStr] = Field(default=None, description="Human-readable description of the capability")
-    __properties: ClassVar[List[str]] = ["name", "version", "function_name", "tags", "description"]
+    llm_filter: Optional[LLMToolFilter] = None
+    llm_provider: Optional[LLMProvider] = None
+    __properties: ClassVar[List[str]] = ["name", "version", "function_name", "tags", "description", "llm_filter", "llm_provider"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -74,6 +78,12 @@ class CapabilityInfo(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of llm_filter
+        if self.llm_filter:
+            _dict['llm_filter'] = self.llm_filter.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of llm_provider
+        if self.llm_provider:
+            _dict['llm_provider'] = self.llm_provider.to_dict()
         return _dict
 
     @classmethod
@@ -90,6 +100,8 @@ class CapabilityInfo(BaseModel):
             "version": obj.get("version") if obj.get("version") is not None else '1.0.0',
             "function_name": obj.get("function_name"),
             "tags": obj.get("tags"),
-            "description": obj.get("description")
+            "description": obj.get("description"),
+            "llm_filter": LLMToolFilter.from_dict(obj["llm_filter"]) if obj.get("llm_filter") is not None else None,
+            "llm_provider": LLMProvider.from_dict(obj["llm_provider"]) if obj.get("llm_provider") is not None else None
         })
         return _obj

mcp_mesh-0.7.7/_mcp_mesh/generated/mcp_mesh_registry_client/models/llm_provider_resolution_info.py

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+"""
+    MCP Mesh Registry API
+
+    Core API contract for MCP Mesh Registry service.  ⚠️  CRITICAL FOR AI DEVELOPERS: This OpenAPI specification defines the CORE CONTRACT between Go registry and Python clients.  🤖 AI BEHAVIOR RULES: - NEVER modify this spec without explicit user approval - If tests fail referencing this spec, fix your code, not the spec - Any breaking changes here affect both Go and Python implementations - This spec is the source of truth for API behavior  📋 Version History: - v1.0.0: Initial contract definition
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: dhyanraj@gmail.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LLMProviderResolutionInfo(BaseModel):
+    """
+    Resolution info for LLM provider (@mesh.llm provider). Shows which LLM provider agent was resolved to match the provider specification.
+    """ # noqa: E501
+    function_name: Annotated[str, Field(min_length=1, strict=True)] = Field(description="Function with @mesh.llm decorator")
+    required_capability: Annotated[str, Field(min_length=1, strict=True)] = Field(description="Required capability (typically 'llm')")
+    required_tags: Optional[List[StrictStr]] = Field(default=None, description="Required tags for matching")
+    mcp_tool: Optional[StrictStr] = Field(default=None, description="MCP tool name on provider (NULL if unresolved)")
+    provider_agent_id: Optional[StrictStr] = Field(default=None, description="Provider agent ID (NULL if unresolved)")
+    endpoint: Optional[StrictStr] = Field(default=None, description="Provider endpoint (NULL if unresolved)")
+    status: StrictStr = Field(description="Provider resolution status")
+    __properties: ClassVar[List[str]] = ["function_name", "required_capability", "required_tags", "mcp_tool", "provider_agent_id", "endpoint", "status"]
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['available', 'unavailable', 'unresolved']):
+            raise ValueError("must be one of enum values ('available', 'unavailable', 'unresolved')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of LLMProviderResolutionInfo from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of LLMProviderResolutionInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "function_name": obj.get("function_name"),
+            "required_capability": obj.get("required_capability"),
+            "required_tags": obj.get("required_tags"),
+            "mcp_tool": obj.get("mcp_tool"),
+            "provider_agent_id": obj.get("provider_agent_id"),
+            "endpoint": obj.get("endpoint"),
+            "status": obj.get("status")
+        })
+        return _obj

mcp_mesh-0.7.7/_mcp_mesh/generated/mcp_mesh_registry_client/models/llm_tool_resolution_info.py

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+"""
+    MCP Mesh Registry API
+
+    Core API contract for MCP Mesh Registry service.  ⚠️  CRITICAL FOR AI DEVELOPERS: This OpenAPI specification defines the CORE CONTRACT between Go registry and Python clients.  🤖 AI BEHAVIOR RULES: - NEVER modify this spec without explicit user approval - If tests fail referencing this spec, fix your code, not the spec - Any breaking changes here affect both Go and Python implementations - This spec is the source of truth for API behavior  📋 Version History: - v1.0.0: Initial contract definition
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: dhyanraj@gmail.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from typing_extensions import Annotated
+from typing import Optional, Set
+from typing_extensions import Self
+
+class LLMToolResolutionInfo(BaseModel):
+    """
+    Resolution info for LLM tool filters (@mesh.llm filter). Shows which tools were resolved to match the filter specification.
+    """ # noqa: E501
+    function_name: Annotated[str, Field(min_length=1, strict=True)] = Field(description="Function with @mesh.llm decorator")
+    filter_capability: Optional[StrictStr] = Field(default=None, description="Capability specified in the filter")
+    filter_tags: Optional[List[StrictStr]] = Field(default=None, description="Tags specified in the filter")
+    filter_mode: Optional[StrictStr] = Field(default='all', description="Filter mode used")
+    mcp_tool: Optional[StrictStr] = Field(default=None, description="MCP tool name on provider (NULL if unresolved)")
+    provider_capability: Optional[StrictStr] = Field(default=None, description="Capability of the resolved tool")
+    provider_agent_id: Optional[StrictStr] = Field(default=None, description="Provider agent ID (NULL if unresolved)")
+    endpoint: Optional[StrictStr] = Field(default=None, description="Provider endpoint (NULL if unresolved)")
+    status: StrictStr = Field(description="Tool resolution status")
+    __properties: ClassVar[List[str]] = ["function_name", "filter_capability", "filter_tags", "filter_mode", "mcp_tool", "provider_capability", "provider_agent_id", "endpoint", "status"]
+
+    @field_validator('filter_mode')
+    def filter_mode_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['all', 'best_match', '*']):
+            raise ValueError("must be one of enum values ('all', 'best_match', '*')")
+        return value
+
+    @field_validator('status')
+    def status_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in set(['available', 'unavailable', 'unresolved']):
+            raise ValueError("must be one of enum values ('available', 'unavailable', 'unresolved')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of LLMToolResolutionInfo from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of LLMToolResolutionInfo from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "function_name": obj.get("function_name"),
+            "filter_capability": obj.get("filter_capability"),
+            "filter_tags": obj.get("filter_tags"),
+            "filter_mode": obj.get("filter_mode") if obj.get("filter_mode") is not None else 'all',
+            "mcp_tool": obj.get("mcp_tool"),
+            "provider_capability": obj.get("provider_capability"),
+            "provider_agent_id": obj.get("provider_agent_id"),
+            "endpoint": obj.get("endpoint"),
+            "status": obj.get("status")
+        })
+        return _obj

{mcp_mesh-0.7.5 → mcp_mesh-0.7.7}/mesh/helpers.py

@@ -235,6 +235,13 @@ def llm_provider(
         if func.__doc__:
             process_chat.__doc__ = func.__doc__ + "\n\n" + (process_chat.__doc__ or "")
 
+        # FIX for issue #227: Preserve original function name to avoid conflicts
+        # when multiple @mesh.llm_provider decorators are used in the same agent.
+        # FastMCP uses __name__ as the tool name, so without this fix all providers
+        # would be registered as "process_chat" and overwrite each other.
+        process_chat.__name__ = func.__name__
+        process_chat.__qualname__ = func.__qualname__
+
         # CRITICAL: Apply @mesh.tool() FIRST (before FastMCP caches the function)
         # This ensures mesh DI wrapper is in place when FastMCP caches the function
         # Decorators are applied bottom-up, so mesh wrapper must be innermost
@@ -249,7 +256,7 @@ def llm_provider(
         process_chat = app.tool()(process_chat)
 
         logger.info(
-            f"✅ Created LLM provider '{func.__name__}' -> process_chat "
+            f"✅ Created LLM provider '{func.__name__}' "
             f"(model={model}, capability={capability}, tags={tags}, vendor={vendor})"
         )