mcp-mesh 0.5.7__py3-none-any.whl → 0.6.0__py3-none-any.whl

_mcp_mesh/utils/fastmcp_schema_extractor.py

@@ -0,0 +1,476 @@
+"""
+FastMCP Schema Extractor
+
+Extracts inputSchema from FastMCP tool objects for LLM integration.
+This enables the registry to store tool schemas for tool discovery.
+
+Part of Phase 2: Schema Collection & Propagation
+Part of Phase 2.5: Schema Filtering - removes dependency injection parameters
+Part of Phase 0: Enhanced Schema Extraction - MeshContextModel support
+"""
+
+import inspect
+import logging
+from typing import Any, Dict, Optional, get_args, get_origin, get_type_hints
+
+logger = logging.getLogger(__name__)
+
+
+class FastMCPSchemaExtractor:
+    """
+    Extracts inputSchema from FastMCP tools.
+
+    FastMCP automatically generates JSON schemas from Python type hints.
+    This class extracts those schemas so they can be sent to the registry
+    for LLM tool discovery.
+
+    Phase 2.5: Filters out McpMeshAgent parameters from schemas since
+    they are dependency injection parameters and should not be visible to LLMs.
+
+    Phase 0: Enhances schemas with MeshContextModel Field descriptions for
+    better LLM chain composition.
+    """
+
+    @staticmethod
+    def is_mesh_context_model(type_hint: Any) -> bool:
+        """
+        Check if a type hint is MeshContextModel or a subclass.
+
+        Handles:
+        - Direct MeshContextModel subclass
+        - Optional[MeshContextModel] (Union with None)
+        - Forward references
+
+        Args:
+            type_hint: Type annotation to check
+
+        Returns:
+            True if type is MeshContextModel or subclass
+
+        Example:
+            class ChatContext(MeshContextModel):
+                ...
+
+            is_mesh_context_model(ChatContext) # True
+            is_mesh_context_model(Optional[ChatContext]) # True
+            is_mesh_context_model(str) # False
+        """
+        try:
+            from mesh.types import MeshContextModel
+
+            # Handle None
+            if type_hint is None:
+                return False
+
+            # Handle Union types (like Optional[MeshContextModel])
+            origin = get_origin(type_hint)
+            if origin is not None:
+                # For Union types, check all args
+                args = get_args(type_hint)
+                for arg in args:
+                    if arg is not type(
+                        None
+                    ) and FastMCPSchemaExtractor.is_mesh_context_model(arg):
+                        return True
+                return False
+
+            # Direct type check
+            if inspect.isclass(type_hint):
+                return issubclass(type_hint, MeshContextModel)
+
+        except (ImportError, TypeError):
+            # MeshContextModel not available or type checking failed
+            pass
+
+        return False
+
+    @staticmethod
+    def extract_context_schema(model_class: type) -> dict[str, Any]:
+        """
+        Extract enhanced schema from MeshContextModel with Field descriptions.
+
+        Uses Pydantic's model_json_schema() to get complete schema including:
+        - Field descriptions from Field(description=...)
+        - Default values
+        - Type information
+        - Nested models
+
+        Args:
+            model_class: MeshContextModel subclass
+
+        Returns:
+            Enhanced JSON Schema dict with descriptions
+
+        Example:
+            class AnalysisContext(MeshContextModel):
+                domain: str = Field(description="Analysis domain")
+                user_level: str = Field(default="beginner")
+
+            schema = extract_context_schema(AnalysisContext)
+            # Returns:
+            # {
+            #     "type": "object",
+            #     "properties": {
+            #         "domain": {"type": "string", "description": "Analysis domain"},
+            #         "user_level": {"type": "string", "default": "beginner"}
+            #     },
+            #     "required": ["domain"]
+            # }
+        """
+        try:
+            # Get Pydantic's JSON schema which includes all Field metadata
+            schema = model_class.model_json_schema()
+
+            # Add marker that this is a context for prompt template
+            if "description" not in schema:
+                schema["description"] = "Context for prompt template"
+            else:
+                # Append to existing description
+                schema["description"] = (
+                    f"{schema['description']} (Context for prompt template)"
+                )
+
+            logger.debug(
+                f"Extracted enhanced schema for {model_class.__name__}: "
+                f"{list(schema.get('properties', {}).keys())}"
+            )
+
+            return schema
+
+        except Exception as e:
+            logger.warning(f"Failed to extract schema from {model_class.__name__}: {e}")
+            return {"type": "object"}
+
+    @staticmethod
+    def enhance_schema_with_context_models(
+        schema: dict[str, Any], function: Any
+    ) -> dict[str, Any]:
+        """
+        Enhance schema by detecting MeshContextModel parameters and extracting
+        their Field descriptions.
+
+        Phase 0: For each parameter that is a MeshContextModel subclass, replace
+        the basic schema with an enhanced schema that includes Field descriptions.
+        This helps calling LLM agents construct context objects correctly.
+
+        Args:
+            schema: The inputSchema dict to enhance
+            function: The function whose parameters to analyze
+
+        Returns:
+            Enhanced schema with MeshContextModel Field descriptions
+
+        Example:
+            Before:
+            {
+                "properties": {
+                    "ctx": {"type": "object"}  # Basic
+                }
+            }
+
+            After:
+            {
+                "properties": {
+                    "ctx": {
+                        "type": "object",
+                        "description": "Context for prompt template",
+                        "properties": {
+                            "domain": {
+                                "type": "string",
+                                "description": "Analysis domain: infrastructure, security"
+                            }
+                        }
+                    }
+                }
+            }
+        """
+        if not schema or not isinstance(schema, dict):
+            return schema
+
+        try:
+            # Get type hints from function
+            type_hints = get_type_hints(function)
+        except Exception as e:
+            func_name = getattr(function, "__name__", "<unknown>")
+            logger.debug(f"Could not get type hints for {func_name}: {e}")
+            return schema
+
+        # Create a copy to avoid modifying original
+        enhanced_schema = schema.copy()
+        if "properties" not in enhanced_schema:
+            return enhanced_schema
+
+        enhanced_props = enhanced_schema["properties"].copy()
+
+        # Check each parameter
+        for param_name, param_schema in schema.get("properties", {}).items():
+            type_hint = type_hints.get(param_name)
+
+            if type_hint and FastMCPSchemaExtractor.is_mesh_context_model(type_hint):
+                # Found MeshContextModel parameter!
+                # Extract the actual model class (handle Optional)
+                model_class = type_hint
+                origin = get_origin(type_hint)
+                if origin is not None:
+                    args = get_args(type_hint)
+                    for arg in args:
+                        if arg is not type(None):
+                            model_class = arg
+                            break
+
+                # Extract enhanced schema with Field descriptions
+                context_schema = FastMCPSchemaExtractor.extract_context_schema(
+                    model_class
+                )
+
+                # Replace basic schema with enhanced schema
+                enhanced_props[param_name] = context_schema
+
+                logger.debug(
+                    f"Enhanced {param_name} parameter with MeshContextModel schema: "
+                    f"{list(context_schema.get('properties', {}).keys())}"
+                )
+
+        enhanced_schema["properties"] = enhanced_props
+        return enhanced_schema
+
+    @staticmethod
+    def filter_dependency_parameters(
+        schema: dict[str, Any], function: Any
+    ) -> dict[str, Any]:
+        """
+        Filter out McpMeshAgent dependency injection parameters from schema.
+
+        Phase 2.5: Remove dependency injection parameters from LLM-facing schemas.
+        These parameters are injected at runtime by MCP Mesh and should not be
+        visible to LLMs or included in tool discovery.
+
+        Args:
+            schema: The inputSchema dict to filter
+            function: The function whose parameters to analyze
+
+        Returns:
+            Filtered schema with dependency parameters removed
+
+        Example:
+            Input schema:
+            {
+                "properties": {
+                    "name": {"type": "string"},
+                    "date_service": {"anyOf": [{}, {"type": "null"}], "default": null}
+                },
+                "required": ["name"]
+            }
+
+            Output schema (date_service removed):
+            {
+                "properties": {
+                    "name": {"type": "string"}
+                },
+                "required": ["name"]
+            }
+        """
+        if not schema or not isinstance(schema, dict):
+            return schema
+
+        # Get McpMeshAgent parameter names from signature analysis
+        from _mcp_mesh.engine.signature_analyzer import get_mesh_agent_parameter_names
+
+        mesh_param_names = get_mesh_agent_parameter_names(function)
+
+        if not mesh_param_names:
+            # No dependency parameters to filter
+            return schema
+
+        # Create a copy to avoid modifying original
+        filtered_schema = schema.copy()
+
+        # Filter properties
+        if "properties" in filtered_schema:
+            original_props = filtered_schema["properties"]
+            filtered_props = {
+                param_name: param_schema
+                for param_name, param_schema in original_props.items()
+                if param_name not in mesh_param_names
+            }
+            filtered_schema["properties"] = filtered_props
+
+            logger.debug(
+                f"🔧 Filtered {len(original_props) - len(filtered_props)} dependency parameters "
+                f"from schema: {mesh_param_names}"
+            )
+
+        # Filter required array
+        if "required" in filtered_schema:
+            original_required = filtered_schema["required"]
+            filtered_required = [
+                param_name
+                for param_name in original_required
+                if param_name not in mesh_param_names
+            ]
+            filtered_schema["required"] = filtered_required
+
+        return filtered_schema
+
+    @staticmethod
+    def extract_input_schema(function: Any) -> Optional[dict[str, Any]]:
+        """
+        Extract inputSchema from a function that may have a FastMCP tool attached.
+
+        Args:
+            function: The function object (possibly decorated with @app.tool())
+
+        Returns:
+            inputSchema dict if FastMCP tool found, None otherwise
+
+        The inputSchema format follows JSON Schema specification:
+        {
+            "type": "object",
+            "properties": {
+                "param_name": {"type": "string", "description": "..."},
+                ...
+            },
+            "required": ["param1", "param2"]
+        }
+        """
+        # Check if function has FastMCP tool reference
+        if not hasattr(function, "_fastmcp_tool"):
+            logger.debug(
+                f"Function {getattr(function, '__name__', '<unknown>')} has no FastMCP tool"
+            )
+            return None
+
+        fastmcp_tool = function._fastmcp_tool
+
+        # Extract inputSchema from FastMCP tool
+        # FastMCP uses 'parameters' attribute, not 'inputSchema'
+        if hasattr(fastmcp_tool, "parameters"):
+            schema = fastmcp_tool.parameters
+            logger.debug(
+                f"Extracted schema from {getattr(function, '__name__', '<unknown>')}: "
+                f"{list(schema.get('properties', {}).keys()) if isinstance(schema, dict) else 'invalid'}"
+            )
+            # Phase 2.5: Filter out dependency injection parameters
+            filtered_schema = FastMCPSchemaExtractor.filter_dependency_parameters(
+                schema, function
+            )
+
+            # Phase 0: Enhance schema with MeshContextModel Field descriptions
+            enhanced_schema = FastMCPSchemaExtractor.enhance_schema_with_context_models(
+                filtered_schema, function
+            )
+
+            return enhanced_schema
+
+        logger.debug(
+            f"FastMCP tool for {getattr(function, '__name__', '<unknown>')} "
+            f"has no parameters attribute"
+        )
+        return None
+
+    @staticmethod
+    def extract_from_fastmcp_servers(
+        function: Any, fastmcp_servers: Optional[dict[str, Any]]
+    ) -> Optional[dict[str, Any]]:
+        """
+        Extract inputSchema by looking up function in FastMCP server tool managers.
+
+        This is the primary method for extracting schemas when using FastMCP.
+        It searches all discovered FastMCP servers for a tool whose function
+        matches the given function, then extracts its inputSchema.
+
+        Args:
+            function: The function to find schema for
+            fastmcp_servers: Dict from fastmcp-server-discovery step context
+                            (maps server_name -> server_info dict)
+
+        Returns:
+            inputSchema dict if found, None otherwise
+        """
+        if not fastmcp_servers:
+            return None
+
+        func_id = id(function)
+        func_name = getattr(function, "__name__", "<unknown>")
+
+        # Search all FastMCP servers for this function
+        for server_name, server_info in fastmcp_servers.items():
+            tools_dict = server_info.get("tools", {})
+
+            # Look through all tools in this server
+            for tool_name, tool_obj in tools_dict.items():
+                # Match by function identity
+                tool_fn = getattr(tool_obj, "fn", None)
+                if tool_fn is not None and id(tool_fn) == func_id:
+                    # Found matching tool! Extract schema
+                    # FastMCP stores schema in 'parameters' attribute (not 'inputSchema')
+                    if hasattr(tool_obj, "parameters"):
+                        schema = tool_obj.parameters
+                        logger.debug(
+                            f"✅ Matched function {func_name} to FastMCP tool '{tool_name}' "
+                            f"with schema: {list(schema.get('properties', {}).keys()) if isinstance(schema, dict) else 'invalid'}"
+                        )
+                        # Phase 2.5: Filter out dependency injection parameters
+                        filtered_schema = (
+                            FastMCPSchemaExtractor.filter_dependency_parameters(
+                                schema, function
+                            )
+                        )
+
+                        # Phase 0: Enhance schema with MeshContextModel Field descriptions
+                        enhanced_schema = (
+                            FastMCPSchemaExtractor.enhance_schema_with_context_models(
+                                filtered_schema, function
+                            )
+                        )
+
+                        return enhanced_schema
+                    else:
+                        logger.debug(
+                            f"⚠️ Matched function {func_name} to FastMCP tool '{tool_name}' "
+                            f"but no parameters attribute found"
+                        )
+                        return None
+
+        logger.debug(
+            f"Function {func_name} not found in any FastMCP server tool managers"
+        )
+        return None
+
+    @staticmethod
+    def extract_all_schemas_from_tools(
+        mesh_tools: dict[str, Any], fastmcp_servers: Optional[dict[str, Any]] = None
+    ) -> dict[str, Optional[dict[str, Any]]]:
+        """
+        Extract inputSchemas from all tools in a mesh_tools dict.
+
+        Args:
+            mesh_tools: Dict of function_name -> DecoratedFunction
+            fastmcp_servers: Optional dict of FastMCP server info from discovery step
+
+        Returns:
+            Dict mapping function_name -> inputSchema (or None)
+        """
+        schemas = {}
+
+        for func_name, decorated_func in mesh_tools.items():
+            function = decorated_func.function
+
+            # First try the FastMCP server lookup (primary method)
+            schema = FastMCPSchemaExtractor.extract_from_fastmcp_servers(
+                function, fastmcp_servers
+            )
+
+            # Fallback to _fastmcp_tool attribute (for backward compatibility with tests)
+            if schema is None:
+                schema = FastMCPSchemaExtractor.extract_input_schema(function)
+
+            schemas[func_name] = schema
+
+        logger.info(
+            f"Extracted schemas for {len(mesh_tools)} tools: "
+            f"{sum(1 for s in schemas.values() if s is not None)} with schemas, "
+            f"{sum(1 for s in schemas.values() if s is None)} without"
+        )
+
+        return schemas

{mcp_mesh-0.5.7.dist-info → mcp_mesh-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.5.7
+Version: 0.6.0
 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.5.7.dist-info → mcp_mesh-0.6.0.dist-info}/RECORD

@@ -1,20 +1,28 @@
-_mcp_mesh/__init__.py,sha256=CTRyqemXkVmKL85NBmkaOB9AN-FOZxseOKEnV_s7AMk,2719
+_mcp_mesh/__init__.py,sha256=HW8krPO-11yYkgOXvo9W9J2oPcBQ58kOyYgabuEdlZs,2719
 _mcp_mesh/engine/__init__.py,sha256=2ennzbo7yJcpkXO9BqN69TruLjJfmJY4Y5VEsG644K4,3630
 _mcp_mesh/engine/async_mcp_client.py,sha256=UcbQjxtgVfeRw6DHTZhAzN1gkcKlTg-lUPEePRPQWAU,6306
-_mcp_mesh/engine/decorator_registry.py,sha256=0-GI7DILpbB6GRLIYhZu0DcdHEA62d89jDYxkK1ywiM,22422
-_mcp_mesh/engine/dependency_injector.py,sha256=k6PzG9te1J5DbuDV2OrErXM3AcV1X6_ZvCy5KFYo1nk,27496
+_mcp_mesh/engine/base_injector.py,sha256=qzRLZqFP2VvEFagVovkpdldvDmm3VwPHm6tHwV58a2k,5648
+_mcp_mesh/engine/decorator_registry.py,sha256=89uNOod-3VG9mpD_MoqxmFnXfS3u2Zw54QTZNL61rN0,25932
+_mcp_mesh/engine/dependency_injector.py,sha256=aKES6fHSUph1c5--IOVzsbzXC_3V7NkcsIPlN1Y69sI,30634
 _mcp_mesh/engine/full_mcp_proxy.py,sha256=PlRv7GSKqn5riOCqeCVulVdtq3z1Ug76mOkwMsOFHXw,25297
-_mcp_mesh/engine/http_wrapper.py,sha256=PeYR7HkJVX7Hb0W-uYSMO-Y14VqCyrPlWzA6vnwf1Tw,21640
+_mcp_mesh/engine/http_wrapper.py,sha256=T9VQ2LZbGgCzyOVXVwdqas7-W3Wid0EwRboFUpdYWtM,20718
+_mcp_mesh/engine/llm_config.py,sha256=eaBXtCmmM-gyD3enKuhhHHdOkSZVMHxb-T9D89Wgc9M,1156
+_mcp_mesh/engine/llm_errors.py,sha256=h7BiI14u-jL8vtvBfFbFDDrN7gIw8PQjXIl5AP1SBuA,3276
 _mcp_mesh/engine/mcp_client_proxy.py,sha256=eJStwy_VQJexYYD8bOh_m4Ld3Bb8Ae_dt8N1CC41qBc,17625
+_mcp_mesh/engine/mesh_llm_agent.py,sha256=0XbrZlddUxbfXw8hnqztwsomzbYbBGnYHMHiEviVN00,15912
+_mcp_mesh/engine/mesh_llm_agent_injector.py,sha256=46lyf12uX54lAJVWWdZpmnOo009RllUkAxmcmi2rY1k,19322
+_mcp_mesh/engine/response_parser.py,sha256=aOO5nhlmZrpucrLiI-19VHBgEwE774EAYfvsgsPrL_c,8490
 _mcp_mesh/engine/self_dependency_proxy.py,sha256=OkKt0-B_ADnJlWtHiHItoZCBZ7Su0iz2unEPFfXvrs4,3302
 _mcp_mesh/engine/session_aware_client.py,sha256=mc9eh-aCvUvfllORiXTf_X8_jPqV-32QdWKlr8tHLkU,10600
 _mcp_mesh/engine/session_manager.py,sha256=MCr0_fXBaUjXM51WU5EhDkiGvBdfzYQFVNb9DCXXL0A,10418
-_mcp_mesh/engine/signature_analyzer.py,sha256=w5mvnRo1cc31the6OZln5keOVJphL26V6jDAHVNA29A,7946
-_mcp_mesh/engine/unified_mcp_proxy.py,sha256=33xm-jABTYUwr_uIB6mx4yNlNJrsvstCHJOMTdcm-pg,36365
+_mcp_mesh/engine/signature_analyzer.py,sha256=ftn9XsX0ZHWIaACdjgBVtCuIdqVU_4ST8cvcpzu4HTk,12339
+_mcp_mesh/engine/tool_executor.py,sha256=Bf_9d02EEY9_yHm1p1-5YZ4rY6MPxn4SVpI6-3sm1uo,5456
+_mcp_mesh/engine/tool_schema_builder.py,sha256=8t-DAPfNzXWAa5ktolwZJulyAJp8sYg6--VYznWqd7E,3580
+_mcp_mesh/engine/unified_mcp_proxy.py,sha256=SmhLWXdjmgvJWOLGQk-cXrvYjGSzx98HzL0Q5jpMNIY,36326
 _mcp_mesh/generated/.openapi-generator-ignore,sha256=-d-Y-RVAZRrHw36jO0b79oDXpfA8rZdBGPCG4Vs_rUs,227
-_mcp_mesh/generated/.openapi-generator/FILES,sha256=BXFXHe4FTV5GFUTNjMhmvOrVcYVlHJc5O-3UXyp8OCY,2169
+_mcp_mesh/generated/.openapi-generator/FILES,sha256=BfEjaFFKaP-O6syjKqu5C9P_6HuBPDTfYBkz4u7IXAo,2404
 _mcp_mesh/generated/.openapi-generator/VERSION,sha256=nMm490YXJUW3_vAdeAsg7E3yRgUqVwk5-50PuaFonM8,7
-_mcp_mesh/generated/mcp_mesh_registry_client/__init__.py,sha256=C_J51kNjdAQ2ikcXQzaIC0x9HQgbibT02x1rmWpeKGw,5604
+_mcp_mesh/generated/mcp_mesh_registry_client/__init__.py,sha256=E8sKkIh1IUQ6VKVKvFgD3XiC0kE3odmXj0iWzUpZmxs,5937
 _mcp_mesh/generated/mcp_mesh_registry_client/api_client.py,sha256=SLzm-p1vhbhufVDn7sNKjq9aSBkZUXTdwRIf7Ne57l8,28104
 _mcp_mesh/generated/mcp_mesh_registry_client/api_response.py,sha256=eMxw1mpmJcoGZ3gs9z6jM4oYoZ10Gjk333s9sKxGv7s,652
 _mcp_mesh/generated/mcp_mesh_registry_client/configuration.py,sha256=PCZ03PQGCEG0lfIn4s1tk8WrB9HpQ-LCXIUK110F1gY,18544
@@ -25,7 +33,7 @@ _mcp_mesh/generated/mcp_mesh_registry_client/api/__init__.py,sha256=CP4BRsWFhioE
 _mcp_mesh/generated/mcp_mesh_registry_client/api/agents_api.py,sha256=rHY0h_wcv9eLRzOitkRZ7PDKtgWr5xism3azkZpuI6I,46445
 _mcp_mesh/generated/mcp_mesh_registry_client/api/health_api.py,sha256=BJsqdNHz-dZXJsvQmYdZLLM_vf1Lf6DKRH9xzpyfkuU,30552
 _mcp_mesh/generated/mcp_mesh_registry_client/api/tracing_api.py,sha256=2FmSDoWiAfx404kB5mkWvYviE37QVY-Cb-kA90o1rn8,13179
-_mcp_mesh/generated/mcp_mesh_registry_client/models/__init__.py,sha256=s54kd3wYhgltJgOFD0RLQX7prcuI4uDibwVXXo5SrTs,3968
+_mcp_mesh/generated/mcp_mesh_registry_client/models/__init__.py,sha256=uJ0eFAM2V740prPrGV4xQo3YsPJGHiElezId3-5ZR28,4573
 _mcp_mesh/generated/mcp_mesh_registry_client/models/agent_info.py,sha256=ZD3qwc7GlKYV3Jlxbc79gEJWf-2_H0m07GVyHL4cCVw,5293
 _mcp_mesh/generated/mcp_mesh_registry_client/models/agent_metadata.py,sha256=_ixbM8wlhL5C7jx-NXoA0zdJSK88-TX8URuCIOv7_E8,6520
 _mcp_mesh/generated/mcp_mesh_registry_client/models/agent_metadata_dependencies_inner.py,sha256=LiO2JfFwasidNJ859LKmDHa6kV1boGIlTdhFwmpgoxw,6303
@@ -43,13 +51,17 @@ _mcp_mesh/generated/mcp_mesh_registry_client/models/health_response.py,sha256=vE
 _mcp_mesh/generated/mcp_mesh_registry_client/models/heartbeat_request.py,sha256=YRsl7YhZLBfudS_i5s7zRDkG6fO9S9c7TrveeKUV0aM,3901
 _mcp_mesh/generated/mcp_mesh_registry_client/models/heartbeat_request_metadata.py,sha256=A-L6mFz19Pa-QExvCihCHrJDHIlIV18w290usgD6_Yo,4317
 _mcp_mesh/generated/mcp_mesh_registry_client/models/heartbeat_response.py,sha256=dPJxz5XQukw4QejkeP7F3FAm8m0wW-5gm9xpajlkGqQ,4907
+_mcp_mesh/generated/mcp_mesh_registry_client/models/llm_tool_filter.py,sha256=_cC9pBNQIrC9i9U-SCdi9APCyzgK3XbJRotou9nVZ7k,5228
+_mcp_mesh/generated/mcp_mesh_registry_client/models/llm_tool_filter_filter_inner.py,sha256=dmjxwlS9NbNCvr2ntAaHou5BFm-v9wQySM5NnR0k-c8,6404
+_mcp_mesh/generated/mcp_mesh_registry_client/models/llm_tool_filter_filter_inner_one_of.py,sha256=ozbjc1H9ZppodlMw-L-YDFsg-gA19RliXGESob6vjho,3405
+_mcp_mesh/generated/mcp_mesh_registry_client/models/llm_tool_info.py,sha256=ocwVpJUHwCf_wee2DyV1QVDpEtGZDKasHPTHQ_mnKho,4624
 _mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_agent_register_metadata.py,sha256=HGABUatJp_mu2uFWzC7HBEZACHXIKFmIeegFYfHEcN4,4820
-_mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_agent_registration.py,sha256=qZiljiQH877iBN35poelxDPPnHwpjbu9J2yCwKmZgg8,6182
-_mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_registration_response.py,sha256=tKG2maoADs_cXc2IdU-Pycsf0jyfOLnqeGZJtLXwf3E,5075
+_mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_agent_registration.py,sha256=6bzahvFFC3EFT_JzZmtbgG6hikNDppJBMx94E1e_q3Y,6812
+_mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_registration_response.py,sha256=BObxAkSORrykYo3GRqHifbdxC4NtgdaDoD3yB3CSNMM,6924
 _mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_registration_response_dependencies_resolved_value_inner.py,sha256=tmcFBO8rbB_F-TfpU2lsG29CKTpQPfiuJqE62r81p0k,4071
 _mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_tool_dependency_registration.py,sha256=PkY1rWdS3y5TTxRRFpATWmm3dhw_Qw2_4QBzCv_7ZuU,3658
 _mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_tool_register_metadata.py,sha256=cvbVtiRMd-VfhrMNQX0bRcmW0_FyotYLwLPX8gAsl1o,4935
-_mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_tool_registration.py,sha256=pCBgCwDYpAzqzqE2ksj91uk8PxMuZ9RhDGprbohsYKI,4957
+_mcp_mesh/generated/mcp_mesh_registry_client/models/mesh_tool_registration.py,sha256=JZ6m1pBU0GGWpef0CAU0FklaHWa4tPDhAaCAdj1GYdc,5985
 _mcp_mesh/generated/mcp_mesh_registry_client/models/registration_response.py,sha256=XzIwhTaBrztXgIHQwvW9KRfWOY5GNjVV4RpZKEwxrV8,5030
 _mcp_mesh/generated/mcp_mesh_registry_client/models/rich_dependency.py,sha256=Y6TB1Zvfkq2U8YMSmWUmIcOZMU6ZZxRFmifUGwdRwa0,3591
 _mcp_mesh/generated/mcp_mesh_registry_client/models/root_response.py,sha256=Das3mRHvgqDJVuWsoWLtwUTv_I5nFejhV10U0JZ_CZM,3221
@@ -57,7 +69,7 @@ _mcp_mesh/generated/mcp_mesh_registry_client/models/standardized_dependency.py,s
 _mcp_mesh/generated/mcp_mesh_registry_client/models/trace_event.py,sha256=9Q_8WaVl0MxswRnHpkqq9GKnvOW54HW4tkrTM9oda14,4461
 _mcp_mesh/pipeline/__init__.py,sha256=9Aplh4m1z-rYTQys0JQLYlq9wTPdI72eSOhUPqcnvpA,1557
 _mcp_mesh/pipeline/api_heartbeat/__init__.py,sha256=IXTLoQLAPqQEWZ8VMWc5W_cQJkDv95rlVGXyXoQDjHk,473
-_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py,sha256=uVv7KjEfVO_5Ny3fgC_DD9B8dg_IIUdJmtGVrTaSStU,25312
+_mcp_mesh/pipeline/api_heartbeat/api_dependency_resolution.py,sha256=jo5SmI52T7Vz9yEz5O78SHYh-HyJtpzdOxoa5EylHsI,22011
 _mcp_mesh/pipeline/api_heartbeat/api_fast_heartbeat_check.py,sha256=PY4bbuZgxy3r0ccuBl-OuJvcPSMhyGz4FomxwYFhuvM,4821
 _mcp_mesh/pipeline/api_heartbeat/api_health_check.py,sha256=kDmFeOG_4tyqyJSBZjPcc7xTzGpP4vq6ObW_WBqXvzM,5130
 _mcp_mesh/pipeline/api_heartbeat/api_heartbeat_orchestrator.py,sha256=uBswzWOBzU8p_C0AE2DF8UwIWG4rP2zecHfPqKzNuC0,10367
@@ -76,20 +88,21 @@ _mcp_mesh/pipeline/mcp_heartbeat/__init__.py,sha256=nRNjZ3VD_9bPLQuJ6Nc02gE7KSLc
 _mcp_mesh/pipeline/mcp_heartbeat/dependency_resolution.py,sha256=qQ1KhrRYroYL2nnjLufXsXaaAO593GnuvJrRy_Ws97k,17764
 _mcp_mesh/pipeline/mcp_heartbeat/fast_heartbeat_check.py,sha256=QTzYdL81WERkOaBVOgNbFQh1ddTn70urNtyIgtFTudA,4465
 _mcp_mesh/pipeline/mcp_heartbeat/heartbeat_orchestrator.py,sha256=uB9o298X7GbOaKUw4ij_fUAOCpK0n2brx_oWqWGTXFY,11296
-_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_pipeline.py,sha256=Jb7EVJO13trUVO3aCSgzGqAtoc4vie5kDrYLZtOkiXg,11601
+_mcp_mesh/pipeline/mcp_heartbeat/heartbeat_pipeline.py,sha256=g1Vl9Xt5ibZwZzrNZoWt4fxAf8ssRZaN6p7cXGeYhTQ,11766
 _mcp_mesh/pipeline/mcp_heartbeat/heartbeat_send.py,sha256=ydVx-Vb_RgW1WPCboHVdZfEwNbgDngFV6Y9elZIBrAw,3602
 _mcp_mesh/pipeline/mcp_heartbeat/lifespan_integration.py,sha256=4XPPlaJ6rz-FkDO3bxzVxHmVF-aq1CCaTW4vIBXrB0c,3016
+_mcp_mesh/pipeline/mcp_heartbeat/llm_tools_resolution.py,sha256=uusZTIEL2VVjGezJKotjNV1-c5on56nDWL9FyPRpzw0,8803
 _mcp_mesh/pipeline/mcp_heartbeat/registry_connection.py,sha256=4abbOKN3echwX82PV0RvxF6cJZUu0pMgisOpILZ_ZzY,2875
 _mcp_mesh/pipeline/mcp_startup/__init__.py,sha256=gS0xNmVx66bkLUMw64olMsN40ZLPH3ymwlLixZ4NuTs,1239
 _mcp_mesh/pipeline/mcp_startup/configuration.py,sha256=6LRLIxrqFMU76qrBb6GjGknUlKPZZ9iqOlxE7F9ZhLs,2808
 _mcp_mesh/pipeline/mcp_startup/decorator_collection.py,sha256=RHC6MHtfP9aP0hZ-IJjISZu72e0Pml3LU0qr7dc284w,2294
 _mcp_mesh/pipeline/mcp_startup/fastapiserver_setup.py,sha256=ktCn1IB8J3Iz7T0iUJF_ytwwO_RRbJN3dNQ6qZLY6iI,40229
-_mcp_mesh/pipeline/mcp_startup/fastmcpserver_discovery.py,sha256=ktsE9EZYdyZbCtCKB6HVdzGFMQ0E9n0-7I55LRO99sE,10270
+_mcp_mesh/pipeline/mcp_startup/fastmcpserver_discovery.py,sha256=9n8hlCn4TPHCYcQlAQwA6VnuXPf_MUjuVrszqFD9RYQ,10660
 _mcp_mesh/pipeline/mcp_startup/heartbeat_loop.py,sha256=v85B0ynomvYu87eIvLe-aSZ7-Iwov2VtM4Fg3PkmrZs,3865
-_mcp_mesh/pipeline/mcp_startup/heartbeat_preparation.py,sha256=v3Fl0PvW5s7Ib_Cy7WtXA7gDvsFGiz54a-IlQRTcLPg,10410
+_mcp_mesh/pipeline/mcp_startup/heartbeat_preparation.py,sha256=cjekOrPTzlcuFZci4IoIWQBQeCWomyI0iiSRGJgiVgA,13530
 _mcp_mesh/pipeline/mcp_startup/server_discovery.py,sha256=i3t12Dd2nEg3nbifyMGvm2SYr3WYiYJbicBakS3ZeuM,8007
 _mcp_mesh/pipeline/mcp_startup/startup_orchestrator.py,sha256=KldSG3xfGNm0iexnCMPkDsi3nuIVXBwneDBuoT5gJO4,26756
-_mcp_mesh/pipeline/mcp_startup/startup_pipeline.py,sha256=Y_VeZcvyT3y9phWtGD7cX92NzKZIzF2J6kRJUO8q-9U,2291
+_mcp_mesh/pipeline/mcp_startup/startup_pipeline.py,sha256=cAAbqioYRswf-P25OpZFX2yL_qN2sl_bVk-kcynFxPw,2347
 _mcp_mesh/pipeline/shared/__init__.py,sha256=s9xmdf6LkoetrVRGd7Zp3NUxcJCW6YZ_yNKzUBcnYys,352
 _mcp_mesh/pipeline/shared/base_step.py,sha256=kyPbNUX79NyGrE_0Q-e-Aek7m1J0TW036njWfv0iZ0I,1080
 _mcp_mesh/pipeline/shared/mesh_pipeline.py,sha256=UlQBrPWqbruFiUdVYgFKgPOpp_sMVsO97nZsWX90k9U,6498
@@ -103,7 +116,7 @@ _mcp_mesh/shared/fast_heartbeat_status.py,sha256=OquEsX9ZTbxY1lIsll0Mbb2KDzSJD76
 _mcp_mesh/shared/fastapi_middleware_manager.py,sha256=_h10dSL9mgQstpJW_ZM2cpkU6yTKaYKlZaKXMk2i6IA,14638
 _mcp_mesh/shared/host_resolver.py,sha256=ycs6gXnI1zJX5KiqiLJPX5GkHX8r4j8NMHQOlG2J2X8,2964
 _mcp_mesh/shared/logging_config.py,sha256=n9AqShZ5BZgyrkoTlvux6ECRVpM9dUYvmGB0NPMl-Ak,2477
-_mcp_mesh/shared/registry_client_wrapper.py,sha256=d8yL-MiCrQr_WYdRFStOd531qaLv9kZjh0zJAmCJ-Cc,16976
+_mcp_mesh/shared/registry_client_wrapper.py,sha256=R7KBjIW_vlE_4iLY4xmUcbk5Zeln9iKVIrxfA0vrXbs,19779
 _mcp_mesh/shared/server_discovery.py,sha256=W5nsN-GvEVFD-7XkbMTxh-9FUIEiyWOxP3GYr8GNi3E,13142
 _mcp_mesh/shared/simple_shutdown.py,sha256=jnF1rTR2yR619LZnEjNlu-ZdKlB3PovxKqG0VZ3HDgE,8319
 _mcp_mesh/shared/sse_parser.py,sha256=OEPnfL9xL3rsjQrbyvfUO82WljPSDeO6Z61uUwN1NAo,8035
@@ -115,10 +128,11 @@ _mcp_mesh/tracing/fastapi_tracing_middleware.py,sha256=o-xyAb1hB_GIFXv0hqUeTwhDD
 _mcp_mesh/tracing/redis_metadata_publisher.py,sha256=F78E34qnI3D0tOmbHUTBsLbDst2G7Su2-0F37Rq0rcM,4652
 _mcp_mesh/tracing/trace_context_helper.py,sha256=6tEkwjWFqMBe45zBlhacktmIpzJWTF950ph3bwL3cNc,5994
 _mcp_mesh/tracing/utils.py,sha256=t9lJuTH7CeuzAiiAaD0WxsJMFJPdzZFR0w6-vyR9f2E,3849
-mesh/__init__.py,sha256=l5RSMV8Kx0h7cvku8YkZPbTHjEPWciGT0bcEB2O_eNU,3242
-mesh/decorators.py,sha256=oBWoRE-FA3qUGygAUtk3-eAYBckwTGfTzvXOgCag4ys,36678
-mesh/types.py,sha256=g37DXAzya-xGPa1_WKlW3T3_VqyTn8ZVepIDSrhBTkc,10815
-mcp_mesh-0.5.7.dist-info/METADATA,sha256=mouhZmaO4Ce2rGSiCRXJXVNA-aRxBc-seygYUCKmJhI,4879
-mcp_mesh-0.5.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_mesh-0.5.7.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
-mcp_mesh-0.5.7.dist-info/RECORD,,
+_mcp_mesh/utils/fastmcp_schema_extractor.py,sha256=M54ffesC-56zl_fNJHj9dZxElDQaWFf1MXdSLCuFStg,17253
+mesh/__init__.py,sha256=fiCNEhOPPDnElXdMQ_CJ1c1hhYopL6_rNw98PztPxYA,3405
+mesh/decorators.py,sha256=gvtIBojywunvnM5xuye2nCMkleTxFBPQny4EDkqsVk4,50711
+mesh/types.py,sha256=g5bU_FKuMoxESvLcgoiYTabQVv2tbjE5D8xpPlNoX1E,13309
+mcp_mesh-0.6.0.dist-info/METADATA,sha256=4uMWsKPwpg5x0aK9a_Lb1p1iqscyVfIFImqqLC4mofI,4879
+mcp_mesh-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_mesh-0.6.0.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
+mcp_mesh-0.6.0.dist-info/RECORD,,

mesh/__init__.py

@@ -19,7 +19,7 @@ Use 'import mesh' and then '@mesh.tool()' for consistency with MCP patterns.
 """
 
 from . import decorators
-from .types import McpAgent, McpMeshAgent
+from .types import McpMeshAgent, MeshContextModel, MeshLlmAgent
 
 __version__ = "1.0.0"
 
@@ -87,7 +87,7 @@ def create_server(name: str | None = None) -> "FastMCP":
     return FastMCP(name=name)
 
 
-# Make decorators available as mesh.tool, mesh.agent, and mesh.route
+# Make decorators available as mesh.tool, mesh.agent, mesh.route, and mesh.llm
 def __getattr__(name):
     if name == "tool":
         return decorators.tool
@@ -95,10 +95,14 @@ def __getattr__(name):
         return decorators.agent
     elif name == "route":
         return decorators.route
+    elif name == "llm":
+        return decorators.llm
     elif name == "McpMeshAgent":
         return McpMeshAgent
-    elif name == "McpAgent":
-        return McpAgent
+    elif name == "MeshContextModel":
+        return MeshContextModel
+    elif name == "MeshLlmAgent":
+        return MeshLlmAgent
     elif name == "create_server":
         return create_server
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")