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

_mcp_mesh/engine/provider_handlers/openai_handler.py

@@ -0,0 +1,163 @@
+"""
+OpenAI provider handler.
+
+Optimized for OpenAI models (GPT-4, GPT-4 Turbo, GPT-3.5-turbo)
+using OpenAI's native structured output capabilities.
+"""
+
+import json
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel
+
+from .base_provider_handler import BaseProviderHandler
+
+
+class OpenAIHandler(BaseProviderHandler):
+    """
+    Provider handler for OpenAI models.
+
+    OpenAI Characteristics:
+    - Native structured output via response_format parameter
+    - Strict JSON schema enforcement
+    - Built-in function calling
+    - Works best with concise, focused prompts
+    - response_format ensures valid JSON matching schema
+
+    Key Difference from Claude:
+    - Uses response_format instead of prompt-based JSON instructions
+    - OpenAI API guarantees JSON schema compliance
+    - More strict parsing, less tolerance for malformed JSON
+    - Shorter system prompts work better
+
+    Supported Models:
+    - gpt-4-turbo-preview and later
+    - gpt-4-0125-preview and later
+    - gpt-3.5-turbo-0125 and later
+    - All gpt-4o models
+
+    Reference:
+    https://platform.openai.com/docs/guides/structured-outputs
+    """
+
+    def __init__(self):
+        """Initialize OpenAI handler."""
+        super().__init__(vendor="openai")
+
+    def prepare_request(
+        self,
+        messages: List[Dict[str, Any]],
+        tools: Optional[List[Dict[str, Any]]],
+        output_type: type[BaseModel],
+        **kwargs: Any
+    ) -> Dict[str, Any]:
+        """
+        Prepare request parameters for OpenAI API with structured output.
+
+        OpenAI Strategy:
+        - 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
+
+        Args:
+            messages: List of message dicts
+            tools: Optional list of tool schemas
+            output_type: Pydantic model for response
+            **kwargs: Additional model parameters
+
+        Returns:
+            Dictionary of parameters for litellm.completion() with response_format
+        """
+        # Build base request
+        request_params = {
+            "messages": messages,
+            **kwargs,  # Pass through temperature, max_tokens, etc.
+        }
+
+        # Add tools if provided
+        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()
+
+        # 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": False,  # Allow optional fields with defaults
+            }
+        }
+
+        return request_params
+
+    def format_system_prompt(
+        self,
+        base_prompt: str,
+        tool_schemas: Optional[List[Dict[str, Any]]],
+        output_type: type[BaseModel]
+    ) -> str:
+        """
+        Format system prompt for OpenAI (concise approach).
+
+        OpenAI Strategy:
+        1. Use base prompt as-is
+        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
+
+        Key Difference from Claude:
+        - No JSON schema in prompt (response_format ensures compliance)
+        - Shorter, more focused instructions
+        - Let response_format handle output structure
+
+        Args:
+            base_prompt: Base system prompt
+            tool_schemas: Optional tool schemas
+            output_type: Expected response type
+
+        Returns:
+            Formatted system prompt optimized for OpenAI
+        """
+        system_content = base_prompt
+
+        # Add tool calling instructions if tools available
+        if tool_schemas:
+            system_content += """
+
+IMPORTANT TOOL CALLING RULES:
+- You have access to tools that you can call to gather information
+- Make ONE tool call at a time
+- After receiving tool results, you can make additional calls if needed
+- Once you have all needed information, provide your final response
+"""
+
+        # 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.
+
+        # Optional: Add a brief note that response should be JSON
+        # (though response_format enforces this anyway)
+        system_content += f"\n\nYour final response will be structured as JSON matching the {output_type.__name__} format."
+
+        return system_content
+
+    def get_vendor_capabilities(self) -> Dict[str, bool]:
+        """
+        Return OpenAI-specific capabilities.
+
+        Returns:
+            Capability flags for OpenAI
+        """
+        return {
+            "native_tool_calling": True,  # OpenAI has native function calling
+            "structured_output": True,  # ✅ Native response_format support!
+            "streaming": True,  # Supports streaming
+            "vision": True,  # GPT-4V and later support vision
+            "json_mode": True,  # Has dedicated JSON mode via response_format
+        }

_mcp_mesh/engine/provider_handlers/provider_handler_registry.py

@@ -0,0 +1,167 @@
+"""
+Provider handler registry for vendor-specific LLM behavior.
+
+Manages selection and instantiation of provider handlers based on vendor name.
+"""
+
+import logging
+from typing import Dict, Optional, Type
+
+from .base_provider_handler import BaseProviderHandler
+from .claude_handler import ClaudeHandler
+from .generic_handler import GenericHandler
+from .openai_handler import OpenAIHandler
+
+logger = logging.getLogger(__name__)
+
+
+class ProviderHandlerRegistry:
+    """
+    Registry for provider-specific handlers.
+
+    Manages mapping from vendor names to handler classes and provides
+    handler selection logic. Handlers customize LLM API calls for
+    optimal performance with each vendor.
+
+    Vendor Mapping:
+    - "anthropic" -> ClaudeHandler
+    - "openai" -> OpenAIHandler
+    - "unknown" or others -> GenericHandler
+
+    Usage:
+        handler = ProviderHandlerRegistry.get_handler("anthropic")
+        request = handler.prepare_request(messages, tools, output_type)
+        system_prompt = handler.format_system_prompt(base, tools, output_type)
+
+    Extensibility:
+        New handlers can be registered:
+        ProviderHandlerRegistry.register("cohere", CohereHandler)
+    """
+
+    # Built-in vendor mappings
+    _handlers: Dict[str, Type[BaseProviderHandler]] = {
+        "anthropic": ClaudeHandler,
+        "openai": OpenAIHandler,
+    }
+
+    # Cache of instantiated handlers (singleton per vendor)
+    _instances: Dict[str, BaseProviderHandler] = {}
+
+    @classmethod
+    def register(cls, vendor: str, handler_class: Type[BaseProviderHandler]) -> None:
+        """
+        Register a custom provider handler.
+
+        Allows runtime registration of new handlers without modifying registry code.
+
+        Args:
+            vendor: Vendor name (e.g., "cohere", "gemini", "together")
+            handler_class: Handler class (must subclass BaseProviderHandler)
+
+        Raises:
+            TypeError: If handler_class doesn't subclass BaseProviderHandler
+
+        Example:
+            class CohereHandler(BaseProviderHandler):
+                ...
+
+            ProviderHandlerRegistry.register("cohere", CohereHandler)
+        """
+        if not issubclass(handler_class, BaseProviderHandler):
+            raise TypeError(
+                f"Handler class must subclass BaseProviderHandler, got {handler_class}"
+            )
+
+        cls._handlers[vendor] = handler_class
+        logger.info(f"📝 Registered provider handler: {vendor} -> {handler_class.__name__}")
+
+        # Clear cached instance if it exists (force re-instantiation)
+        if vendor in cls._instances:
+            del cls._instances[vendor]
+
+    @classmethod
+    def get_handler(cls, vendor: Optional[str] = None) -> BaseProviderHandler:
+        """
+        Get provider handler for vendor.
+
+        Selection Logic:
+        1. If vendor matches registered handler -> use that handler
+        2. If vendor is None or "unknown" -> use GenericHandler
+        3. If vendor unknown -> use GenericHandler with warning
+
+        Handlers are cached (singleton per vendor) for performance.
+
+        Args:
+            vendor: Vendor name from LLM provider registration
+                   (e.g., "anthropic", "openai", "google")
+
+        Returns:
+            Provider handler instance for the vendor
+
+        Example:
+            # Get Claude handler
+            handler = ProviderHandlerRegistry.get_handler("anthropic")
+
+            # Get OpenAI handler
+            handler = ProviderHandlerRegistry.get_handler("openai")
+
+            # Get generic fallback
+            handler = ProviderHandlerRegistry.get_handler("unknown")
+        """
+        # Normalize vendor name (handle None, empty string)
+        vendor = (vendor or "unknown").lower().strip()
+
+        # Check cache first
+        if vendor in cls._instances:
+            logger.debug(f"🔍 Using cached handler for vendor: {vendor}")
+            return cls._instances[vendor]
+
+        # Get handler class (or fallback to Generic)
+        if vendor in cls._handlers:
+            handler_class = cls._handlers[vendor]
+            logger.info(
+                f"✅ Selected {handler_class.__name__} for vendor: {vendor}"
+            )
+        else:
+            handler_class = GenericHandler
+            if vendor != "unknown":
+                logger.warning(
+                    f"⚠️  No specific handler for vendor '{vendor}', using GenericHandler"
+                )
+            else:
+                logger.debug("Using GenericHandler for unknown vendor")
+
+        # Instantiate and cache
+        handler = handler_class() if handler_class != GenericHandler else GenericHandler(vendor)
+        cls._instances[vendor] = handler
+
+        logger.debug(f"🆕 Instantiated handler: {handler}")
+        return handler
+
+    @classmethod
+    def list_vendors(cls) -> Dict[str, str]:
+        """
+        List all registered vendors and their handlers.
+
+        Returns:
+            Dictionary mapping vendor name -> handler class name
+
+        Example:
+            vendors = ProviderHandlerRegistry.list_vendors()
+            # {'anthropic': 'ClaudeHandler', 'openai': 'OpenAIHandler'}
+        """
+        return {
+            vendor: handler_class.__name__
+            for vendor, handler_class in cls._handlers.items()
+        }
+
+    @classmethod
+    def clear_cache(cls) -> None:
+        """
+        Clear cached handler instances.
+
+        Useful for testing or when handler behavior needs to be reset.
+        Next get_handler() call will create fresh instances.
+        """
+        cls._instances.clear()
+        logger.debug("🧹 Cleared provider handler cache")

_mcp_mesh/engine/response_parser.py

@@ -17,7 +17,7 @@ logger = logging.getLogger(__name__)
 # Module-level compiled regex for code fence stripping (compile once, use many times)
 _CODE_FENCE_PATTERN = re.compile(r"^```(?:json)?\s*|\s*```$", re.MULTILINE)
 
-# REMOVE_LATER: Regex to extract JSON from code fences in mixed content
+# Regex to extract JSON from code fences in mixed content
 _JSON_BLOCK_PATTERN = re.compile(r"```json\s*\n(.+?)\n```", re.DOTALL)
 
 T = TypeVar("T", bound=BaseModel)
@@ -56,30 +56,13 @@ class ResponseParser:
         """
         logger.debug(f"📝 Parsing response into {output_type.__name__}...")
 
-        # REMOVE_LATER: Debug raw content
-        logger.warning(f"🔍 REMOVE_LATER: Raw content length: {len(content)}")
-        logger.warning(
-            f"🔍 REMOVE_LATER: Raw content (first 500 chars): {content[:500]!r}"
-        )
-        logger.warning(
-            f"🔍 REMOVE_LATER: Raw content (last 200 chars): {content[-200:]!r}"
-        )
-
         try:
-            # REMOVE_LATER: Extract JSON from mixed content (narrative + XML + JSON)
+            # Extract JSON from mixed content (narrative + XML + JSON)
             extracted_content = ResponseParser._extract_json_from_mixed_content(content)
 
             # Strip markdown code fences if present
             cleaned_content = ResponseParser._strip_markdown_fences(extracted_content)
 
-            # REMOVE_LATER: Debug cleaned content
-            logger.warning(
-                f"🔍 REMOVE_LATER: Cleaned content length: {len(cleaned_content)}"
-            )
-            logger.warning(
-                f"🔍 REMOVE_LATER: Cleaned content: {cleaned_content[:500]!r}"
-            )
-
             # Try to parse as JSON
             response_data = ResponseParser._parse_json_with_fallback(
                 cleaned_content, output_type
@@ -97,7 +80,7 @@ class ResponseParser:
     @staticmethod
     def _extract_json_from_mixed_content(content: str) -> str:
         """
-        REMOVE_LATER: Extract JSON from mixed content (narrative + XML + JSON).
+        Extract JSON from mixed content (narrative + XML + JSON).
 
         Tries multiple strategies to find JSON in mixed responses:
         1. Find ```json ... ``` code fence blocks
@@ -110,19 +93,10 @@ class ResponseParser:
         Returns:
             Extracted JSON string or original content
         """
-        # REMOVE_LATER: Debug extraction attempt
-        logger.warning(
-            f"🔍 REMOVE_LATER: Attempting JSON extraction from content length: {len(content)}"
-        )
-
         # Strategy 1: Try to find ```json ... ``` blocks
         json_match = _JSON_BLOCK_PATTERN.search(content)
         if json_match:
             extracted = json_match.group(1).strip()
-            logger.warning(
-                f"🔍 REMOVE_LATER: Extracted JSON from code fence, length: {len(extracted)}"
-            )
-            logger.warning(f"🔍 REMOVE_LATER: Extracted content: {extracted[:200]}...")
             return extracted
 
         # Strategy 2: Try to find any JSON object {...} in content
@@ -139,18 +113,9 @@ class ResponseParser:
                     if brace_count == 0:
                         # Found matching brace
                         extracted = content[brace_start : i + 1]
-                        logger.warning(
-                            f"🔍 REMOVE_LATER: Extracted JSON from braces, length: {len(extracted)}"
-                        )
-                        logger.warning(
-                            f"🔍 REMOVE_LATER: Extracted content: {extracted[:200]}..."
-                        )
                         return extracted
 
         # No JSON found, return original
-        logger.warning(
-            "🔍 REMOVE_LATER: No JSON extraction needed, returning original"
-        )
         return content
 
     @staticmethod

_mcp_mesh/engine/tool_schema_builder.py

@@ -91,8 +91,9 @@ class ToolSchemaBuilder:
             },
         }
 
-        # OpenAPI spec uses "inputSchema" (camelCase) - enforce strict contract
-        input_schema = tool.get("inputSchema")
+        # Registry returns "input_schema" (snake_case) in JSON
+        # Note: Pydantic model has alias="inputSchema" but we receive raw dicts
+        input_schema = tool.get("input_schema")
         if input_schema:
             tool_schema["function"]["parameters"] = input_schema
 

_mcp_mesh/generated/.openapi-generator/FILES

@@ -20,11 +20,13 @@ mcp_mesh_registry_client/models/decorator_agent_metadata.py
 mcp_mesh_registry_client/models/decorator_agent_request.py
 mcp_mesh_registry_client/models/decorator_info.py
 mcp_mesh_registry_client/models/dependency_info.py
+mcp_mesh_registry_client/models/dependency_resolution_info.py
 mcp_mesh_registry_client/models/error_response.py
 mcp_mesh_registry_client/models/health_response.py
 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_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
@@ -37,6 +39,7 @@ mcp_mesh_registry_client/models/mesh_tool_dependency_registration.py
 mcp_mesh_registry_client/models/mesh_tool_register_metadata.py
 mcp_mesh_registry_client/models/mesh_tool_registration.py
 mcp_mesh_registry_client/models/registration_response.py
+mcp_mesh_registry_client/models/resolved_llm_provider.py
 mcp_mesh_registry_client/models/rich_dependency.py
 mcp_mesh_registry_client/models/root_response.py
 mcp_mesh_registry_client/models/standardized_dependency.py

_mcp_mesh/generated/.openapi-generator-ignore

@@ -1,4 +1,3 @@
-# Skip packaging files - we use this as part of our main package
 pyproject.toml
 setup.py
 setup.cfg

_mcp_mesh/generated/mcp_mesh_registry_client/__init__.py

@@ -1,19 +1,3 @@
-"""
-🤖 AI BEHAVIOR GUIDANCE:
-This package contains generated Python client for MCP Mesh REGISTRY API.
-DO NOT modify files in this package directly - they will be overwritten.
-
-SCOPE: Registry API - for agents to communicate with registry service
-
-TO USE THIS CLIENT:
-1. Import: from _mcp_mesh.generated.mcp_mesh_registry_client import AgentsApi
-2. Configure: api_client = ApiClient(Configuration(host="http://registry:8000"))
-3. Use: agents_api = AgentsApi(api_client)
-
-GENERATED FROM: api/mcp-mesh-registry.openapi.yaml
-CONTRACT: Registry service communication only
-"""
-
 # coding: utf-8
 
 # flake8: noqa
@@ -21,7 +5,7 @@ CONTRACT: Registry service communication only
 """
     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
+    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
@@ -34,85 +18,55 @@ CONTRACT: Registry service communication only
 __version__ = "1.0.0"
 
 # import apis into sdk package
-from _mcp_mesh.generated.mcp_mesh_registry_client.api.agents_api import \
-    AgentsApi
-from _mcp_mesh.generated.mcp_mesh_registry_client.api.health_api import \
-    HealthApi
-from _mcp_mesh.generated.mcp_mesh_registry_client.api.tracing_api import \
-    TracingApi
-from _mcp_mesh.generated.mcp_mesh_registry_client.api_client import ApiClient
+from _mcp_mesh.generated.mcp_mesh_registry_client.api.agents_api import AgentsApi
+from _mcp_mesh.generated.mcp_mesh_registry_client.api.health_api import HealthApi
+from _mcp_mesh.generated.mcp_mesh_registry_client.api.tracing_api import TracingApi
+
 # import ApiClient
-from _mcp_mesh.generated.mcp_mesh_registry_client.api_response import \
-    ApiResponse
-from _mcp_mesh.generated.mcp_mesh_registry_client.configuration import \
-    Configuration
-from _mcp_mesh.generated.mcp_mesh_registry_client.exceptions import (
-    ApiAttributeError, ApiException, ApiKeyError, ApiTypeError, ApiValueError,
-    OpenApiException)
+from _mcp_mesh.generated.mcp_mesh_registry_client.api_response import ApiResponse
+from _mcp_mesh.generated.mcp_mesh_registry_client.api_client import ApiClient
+from _mcp_mesh.generated.mcp_mesh_registry_client.configuration import Configuration
+from _mcp_mesh.generated.mcp_mesh_registry_client.exceptions import OpenApiException
+from _mcp_mesh.generated.mcp_mesh_registry_client.exceptions import ApiTypeError
+from _mcp_mesh.generated.mcp_mesh_registry_client.exceptions import ApiValueError
+from _mcp_mesh.generated.mcp_mesh_registry_client.exceptions import ApiKeyError
+from _mcp_mesh.generated.mcp_mesh_registry_client.exceptions import ApiAttributeError
+from _mcp_mesh.generated.mcp_mesh_registry_client.exceptions import ApiException
+
 # import models into sdk package
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_info import \
-    AgentInfo
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_metadata import \
-    AgentMetadata
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_metadata_dependencies_inner import \
-    AgentMetadataDependenciesInner
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_metadata_dependencies_inner_one_of import \
-    AgentMetadataDependenciesInnerOneOf
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_registration import \
-    AgentRegistration
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_registration_metadata import \
-    AgentRegistrationMetadata
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.agents_list_response import \
-    AgentsListResponse
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.capability_info import \
-    CapabilityInfo
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.decorator_agent_metadata import \
-    DecoratorAgentMetadata
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.decorator_agent_request import \
-    DecoratorAgentRequest
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.decorator_info import \
-    DecoratorInfo
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.dependency_info import \
-    DependencyInfo
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.error_response import \
-    ErrorResponse
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.health_response import \
-    HealthResponse
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.heartbeat_request import \
-    HeartbeatRequest
-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_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.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
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_registration_response_dependencies_resolved_value_inner import \
-    MeshRegistrationResponseDependenciesResolvedValueInner
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_tool_dependency_registration import \
-    MeshToolDependencyRegistration
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_tool_register_metadata import \
-    MeshToolRegisterMetadata
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_tool_registration import \
-    MeshToolRegistration
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.registration_response import \
-    RegistrationResponse
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.rich_dependency import \
-    RichDependency
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.root_response import \
-    RootResponse
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.standardized_dependency import \
-    StandardizedDependency
-from _mcp_mesh.generated.mcp_mesh_registry_client.models.trace_event import \
-    TraceEvent
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_info import AgentInfo
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_metadata import AgentMetadata
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_metadata_dependencies_inner import AgentMetadataDependenciesInner
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_metadata_dependencies_inner_one_of import AgentMetadataDependenciesInnerOneOf
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_registration import AgentRegistration
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.agent_registration_metadata import AgentRegistrationMetadata
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.agents_list_response import AgentsListResponse
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.capability_info import CapabilityInfo
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.decorator_agent_metadata import DecoratorAgentMetadata
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.decorator_agent_request import DecoratorAgentRequest
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.decorator_info import DecoratorInfo
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.dependency_info import DependencyInfo
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.dependency_resolution_info import DependencyResolutionInfo
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.error_response import ErrorResponse
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.health_response import HealthResponse
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.heartbeat_request import HeartbeatRequest
+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_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.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
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_registration_response_dependencies_resolved_value_inner import MeshRegistrationResponseDependenciesResolvedValueInner
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_tool_dependency_registration import MeshToolDependencyRegistration
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_tool_register_metadata import MeshToolRegisterMetadata
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.mesh_tool_registration import MeshToolRegistration
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.registration_response import RegistrationResponse
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.resolved_llm_provider import ResolvedLLMProvider
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.rich_dependency import RichDependency
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.root_response import RootResponse
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.standardized_dependency import StandardizedDependency
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.trace_event import TraceEvent