mcp-mesh 0.7.20__py3-none-any.whl → 0.8.0__py3-none-any.whl

mesh/decorators.py

@@ -26,6 +26,25 @@ _runtime_processor: Any | None = None
 _SHARED_AGENT_ID: str | None = None
 
 
+def _find_available_port() -> int:
+    """
+    Find an available port by binding to port 0 and getting the OS-assigned port.
+
+    This is used when http_port=0 is specified to auto-assign a port.
+    Works reliably on all platforms (macOS, Linux, Windows) without external tools.
+
+    Returns:
+        int: An available port number
+    """
+    import socket
+
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        s.listen(1)
+        port = s.getsockname()[1]
+    return port
+
+
 def _start_uvicorn_immediately(http_host: str, http_port: int):
     """
     Start basic uvicorn server immediately to prevent Python interpreter shutdown.
@@ -76,8 +95,75 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
             app = FastAPI(title="MCP Mesh Agent (Starting)")
             logger.debug("📦 IMMEDIATE UVICORN: Created minimal FastAPI app")
 
-        # Add trace context middleware for distributed tracing BEFORE app starts
-        # This must be done before uvicorn.run() since middleware can't be added after start
+        # Add middleware to strip trace arguments from tool calls BEFORE app starts
+        # This must be done unconditionally because meshctl --trace sends trace args
+        # regardless of agent's tracing configuration
+        try:
+            import json as json_module
+
+            class TraceArgumentStripperMiddleware:
+                """Pure ASGI middleware to strip trace arguments from tool calls.
+
+                This middleware ALWAYS runs to strip _trace_id and _parent_span from
+                MCP tool arguments, preventing Pydantic validation errors when
+                meshctl --trace is used with agents that don't have tracing enabled.
+                """
+
+                def __init__(self, app):
+                    self.app = app
+
+                async def __call__(self, scope, receive, send):
+                    if scope["type"] != "http":
+                        await self.app(scope, receive, send)
+                        return
+
+                    async def receive_with_trace_stripping():
+                        message = await receive()
+                        if message["type"] == "http.request":
+                            body = message.get("body", b"")
+                            if body:
+                                try:
+                                    payload = json_module.loads(body.decode("utf-8"))
+                                    if payload.get("method") == "tools/call":
+                                        arguments = payload.get("params", {}).get(
+                                            "arguments", {}
+                                        )
+                                        # Strip trace context fields from arguments
+                                        if (
+                                            "_trace_id" in arguments
+                                            or "_parent_span" in arguments
+                                        ):
+                                            arguments.pop("_trace_id", None)
+                                            arguments.pop("_parent_span", None)
+                                            modified_body = json_module.dumps(
+                                                payload
+                                            ).encode("utf-8")
+                                            logger.debug(
+                                                "[TRACE] Stripped trace fields from arguments"
+                                            )
+                                            return {
+                                                **message,
+                                                "body": modified_body,
+                                            }
+                                except Exception as e:
+                                    logger.debug(
+                                        f"[TRACE] Failed to process body for stripping: {e}"
+                                    )
+                        return message
+
+                    await self.app(scope, receive_with_trace_stripping, send)
+
+            app.add_middleware(TraceArgumentStripperMiddleware)
+            logger.debug(
+                "📦 IMMEDIATE UVICORN: Added trace argument stripper middleware"
+            )
+        except Exception as e:
+            logger.warning(
+                f"⚠️ IMMEDIATE UVICORN: Failed to add trace argument stripper middleware: {e}"
+            )
+
+        # Add trace context middleware for distributed tracing (optional)
+        # This handles trace propagation and header injection when tracing is enabled
         try:
             import os
 
@@ -90,9 +176,10 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
                     """Pure ASGI middleware for trace context and header injection.
 
                     This middleware:
-                    1. Extracts trace context from incoming request headers
-                    2. Sets up trace context for the request lifecycle
-                    3. Injects trace headers into the response (works with SSE)
+                    1. Extracts trace context from incoming request headers AND arguments
+                    2. Strips trace fields (_trace_id, _parent_span) from arguments to avoid validation errors
+                    3. Sets up trace context for the request lifecycle
+                    4. Injects trace headers into the response (works with SSE)
                     """
 
                     def __init__(self, app):
@@ -127,7 +214,7 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
                                 headers_list, "x-parent-span"
                             )
 
-                            # Setup trace context
+                            # Setup trace context from headers
                             trace_context = {
                                 "trace_id": (
                                     incoming_trace_id if incoming_trace_id else None
@@ -151,6 +238,72 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
                         except Exception as e:
                             logger.warning(f"Failed to set trace context: {e}")
 
+                        # Create receive wrapper to extract trace context from arguments
+                        # Note: Argument stripping is handled by TraceArgumentStripperMiddleware
+                        import json as json_module
+
+                        async def receive_with_trace_extraction():
+                            message = await receive()
+                            if message["type"] == "http.request":
+                                body = message.get("body", b"")
+                                if body:
+                                    try:
+                                        payload = json_module.loads(
+                                            body.decode("utf-8")
+                                        )
+                                        if payload.get("method") == "tools/call":
+                                            arguments = payload.get("params", {}).get(
+                                                "arguments", {}
+                                            )
+
+                                            # Extract trace context from arguments if not in headers
+                                            nonlocal trace_id, span_id, parent_span
+                                            if not trace_id and arguments.get(
+                                                "_trace_id"
+                                            ):
+                                                try:
+                                                    from _mcp_mesh.tracing.context import (
+                                                        TraceContext,
+                                                    )
+                                                    from _mcp_mesh.tracing.trace_context_helper import (
+                                                        TraceContextHelper,
+                                                    )
+
+                                                    arg_trace_id = arguments.get(
+                                                        "_trace_id"
+                                                    )
+                                                    arg_parent_span = arguments.get(
+                                                        "_parent_span"
+                                                    )
+                                                    trace_context = {
+                                                        "trace_id": arg_trace_id,
+                                                        "parent_span": arg_parent_span,
+                                                    }
+                                                    TraceContextHelper.setup_request_trace_context(
+                                                        trace_context, logger
+                                                    )
+                                                    current_trace = (
+                                                        TraceContext.get_current()
+                                                    )
+                                                    if current_trace:
+                                                        trace_id = (
+                                                            current_trace.trace_id
+                                                        )
+                                                        span_id = current_trace.span_id
+                                                        parent_span = (
+                                                            current_trace.parent_span
+                                                        )
+                                                    logger.debug(
+                                                        f"[TRACE] Extracted trace context from arguments: trace_id={arg_trace_id}"
+                                                    )
+                                                except Exception:
+                                                    pass
+                                    except Exception as e:
+                                        logger.debug(
+                                            f"[TRACE] Failed to process body for extraction: {e}"
+                                        )
+                            return message
+
                         # Wrap send to inject headers before response starts
                         async def send_with_trace_headers(message):
                             if message["type"] == "http.response.start" and trace_id:
@@ -166,7 +319,9 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
                                 message = {**message, "headers": headers}
                             await send(message)
 
-                        await self.app(scope, receive, send_with_trace_headers)
+                        await self.app(
+                            scope, receive_with_trace_extraction, send_with_trace_headers
+                        )
 
                 app.add_middleware(TraceContextMiddleware)
                 logger.debug(
@@ -215,8 +370,19 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
 
         logger.debug("📦 IMMEDIATE UVICORN: Added status endpoints")
 
-        # Determine port (0 means auto-assign)
-        port = http_port if http_port > 0 else 8080
+        # Port handling:
+        # - http_port=0 explicitly means auto-assign (let uvicorn choose)
+        # - http_port>0 means use that specific port
+        # Note: The default is 8080 only if http_port was never specified,
+        # which is handled upstream in the @mesh.agent decorator
+        port = http_port
+
+        # Handle http_port=0: find an available port BEFORE starting uvicorn
+        # This is more reliable than detecting the port after uvicorn starts
+        # and works on all platforms (Linux containers don't have lsof installed)
+        if port == 0:
+            port = _find_available_port()
+            logger.info(f"🎯 IMMEDIATE UVICORN: Auto-assigned port {port} for agent")
 
         logger.debug(
             f"🚀 IMMEDIATE UVICORN: Starting uvicorn server on {http_host}:{port}"
@@ -452,12 +618,25 @@ def tool(
                         raise ValueError("dependency capability must be a string")
 
                     # Validate optional dependency fields
+                    # Tags can be strings or arrays of strings (OR alternatives)
+                    # e.g., ["required", ["python", "typescript"]] = required AND (python OR typescript)
                     dep_tags = dep.get("tags", [])
                     if not isinstance(dep_tags, list):
                         raise ValueError("dependency tags must be a list")
                     for tag in dep_tags:
-                        if not isinstance(tag, str):
-                            raise ValueError("all dependency tags must be strings")
+                        if isinstance(tag, str):
+                            continue  # Simple tag - OK
+                        elif isinstance(tag, list):
+                            # OR alternative - validate inner tags are all strings
+                            for inner_tag in tag:
+                                if not isinstance(inner_tag, str):
+                                    raise ValueError(
+                                        "OR alternative tags must be strings"
+                                    )
+                        else:
+                            raise ValueError(
+                                "tags must be strings or arrays of strings (OR alternatives)"
+                            )
 
                     dep_version = dep.get("version")
                     if dep_version is not None and not isinstance(dep_version, str):
@@ -575,7 +754,7 @@ def agent(
     http_port: int = 0,
     enable_http: bool = True,
     namespace: str = "default",
-    health_interval: int = 5,  # Will be overridden by centralized defaults
+    heartbeat_interval: int = 5,
     health_check: Callable[[], Awaitable[Any]] | None = None,
     health_check_ttl: int = 15,
     auto_run: bool = True,  # Changed to True by default!
@@ -600,7 +779,7 @@ def agent(
             Environment variable: MCP_MESH_HTTP_ENABLED (takes precedence)
         namespace: Agent namespace (default: "default")
             Environment variable: MCP_MESH_NAMESPACE (takes precedence)
-        health_interval: Health check interval in seconds (default: 30)
+        heartbeat_interval: Heartbeat interval in seconds (default: 5)
             Environment variable: MCP_MESH_HEALTH_INTERVAL (takes precedence)
         health_check: Optional async function that returns HealthStatus
             Called before heartbeat and on /health endpoint with TTL caching
@@ -617,7 +796,7 @@ def agent(
         MCP_MESH_HTTP_PORT: Override http_port parameter (integer, 0-65535)
         MCP_MESH_HTTP_ENABLED: Override enable_http parameter (boolean: true/false)
         MCP_MESH_NAMESPACE: Override namespace parameter (string)
-        MCP_MESH_HEALTH_INTERVAL: Override health_interval parameter (integer, ≥1)
+        MCP_MESH_HEALTH_INTERVAL: Override heartbeat_interval parameter (integer, ≥1)
         MCP_MESH_AUTO_RUN: Override auto_run parameter (boolean: true/false)
         MCP_MESH_AUTO_RUN_INTERVAL: Override auto_run_interval parameter (integer, ≥1)
 
@@ -668,10 +847,10 @@ def agent(
         if not isinstance(namespace, str):
             raise ValueError("namespace must be a string")
 
-        if not isinstance(health_interval, int):
-            raise ValueError("health_interval must be an integer")
-        if health_interval < 1:
-            raise ValueError("health_interval must be at least 1 second")
+        if not isinstance(heartbeat_interval, int):
+            raise ValueError("heartbeat_interval must be an integer")
+        if heartbeat_interval < 1:
+            raise ValueError("heartbeat_interval must be at least 1 second")
 
         if not isinstance(auto_run, bool):
             raise ValueError("auto_run must be a boolean")
@@ -726,9 +905,9 @@ def agent(
         # Import centralized defaults
         from _mcp_mesh.shared.defaults import MeshDefaults
 
-        final_health_interval = get_config_value(
+        final_heartbeat_interval = get_config_value(
             "MCP_MESH_HEALTH_INTERVAL",
-            override=health_interval,
+            override=heartbeat_interval,
             default=MeshDefaults.HEALTH_INTERVAL,
             rule=ValidationRule.NONZERO_RULE,
         )
@@ -759,7 +938,7 @@ def agent(
             "http_port": final_http_port,
             "enable_http": final_enable_http,
             "namespace": final_namespace,
-            "health_interval": final_health_interval,
+            "heartbeat_interval": final_heartbeat_interval,
             "health_check": health_check,
             "health_check_ttl": health_check_ttl,
             "auto_run": final_auto_run,
@@ -898,10 +1077,10 @@ def route(
         async def upload_resume(
             request: Request,
             file: UploadFile = File(...),
-            pdf_agent: mesh.McpMeshAgent = None,    # Injected by MCP Mesh
-            user_service: mesh.McpMeshAgent = None  # Injected by MCP Mesh
+            pdf_tool: mesh.McpMeshTool = None,    # Injected by MCP Mesh
+            user_service: mesh.McpMeshTool = None  # Injected by MCP Mesh
         ):
-            result = await pdf_agent.extract_text_from_pdf(file)
+            result = await pdf_tool.extract_text_from_pdf(file)
             await user_service.update_profile(user_data, result)
             return {"success": True}
     """
@@ -930,12 +1109,25 @@ def route(
                         raise ValueError("dependency capability must be a string")
 
                     # Validate optional dependency fields
+                    # Tags can be strings or arrays of strings (OR alternatives)
+                    # e.g., ["required", ["python", "typescript"]] = required AND (python OR typescript)
                     dep_tags = dep.get("tags", [])
                     if not isinstance(dep_tags, list):
                         raise ValueError("dependency tags must be a list")
                     for tag in dep_tags:
-                        if not isinstance(tag, str):
-                            raise ValueError("all dependency tags must be strings")
+                        if isinstance(tag, str):
+                            continue  # Simple tag - OK
+                        elif isinstance(tag, list):
+                            # OR alternative - validate inner tags are all strings
+                            for inner_tag in tag:
+                                if not isinstance(inner_tag, str):
+                                    raise ValueError(
+                                        "OR alternative tags must be strings"
+                                    )
+                        else:
+                            raise ValueError(
+                                "tags must be strings or arrays of strings (OR alternatives)"
+                            )
 
                     dep_version = dep.get("version")
                     if dep_version is not None and not isinstance(dep_version, str):
@@ -1221,6 +1413,34 @@ def llm(
                 rule=ValidationRule.STRING_RULE,
             )
 
+        # Resolve model with env var override
+        resolved_model = get_config_value(
+            "MESH_LLM_MODEL",
+            override=model,
+            default=None,
+            rule=ValidationRule.STRING_RULE,
+        )
+
+        # Warn about missing configuration parameters
+        if not system_prompt and not system_prompt_file:
+            logger.warning(
+                f"⚠️ @mesh.llm: No 'system_prompt' specified for function '{func.__name__}'. "
+                f"Using default: 'You are a helpful assistant.' "
+                f"Consider adding a custom system_prompt for better results."
+            )
+
+        if isinstance(provider, str) and provider == "claude" and not resolved_model:
+            logger.warning(
+                f"⚠️ @mesh.llm: No 'model' specified for function '{func.__name__}'. "
+                f"The LLM provider will use its default model. "
+                f"Consider specifying a model explicitly (e.g., model='anthropic/claude-sonnet-4-5')."
+            )
+
+        # Use default system prompt if not provided
+        effective_system_prompt = (
+            system_prompt if system_prompt else "You are a helpful assistant."
+        )
+
         resolved_config = {
             "filter": filter,
             "filter_mode": get_config_value(
@@ -1230,12 +1450,7 @@ def llm(
                 rule=ValidationRule.STRING_RULE,
             ),
             "provider": resolved_provider,
-            "model": get_config_value(
-                "MESH_LLM_MODEL",
-                override=model,
-                default=None,
-                rule=ValidationRule.STRING_RULE,
-            ),
+            "model": resolved_model,
             "api_key": api_key,  # Will be resolved from provider-specific env vars later
             "max_iterations": get_config_value(
                 "MESH_LLM_MAX_ITERATIONS",
@@ -1243,7 +1458,7 @@ def llm(
                 default=10,
                 rule=ValidationRule.NONZERO_RULE,
             ),
-            "system_prompt": system_prompt,
+            "system_prompt": effective_system_prompt,
             "system_prompt_file": system_prompt_file,
             # Phase 1: Template metadata
             "is_template": is_template,

mesh/helpers.py

@@ -214,6 +214,58 @@ def llm_provider(
                             f"(requested by consumer)"
                         )
 
+            # Issue #459: Handle output_schema for vendor-specific structured output
+            # Convert to response_format for vendors that support it
+            output_schema = model_params_copy.pop("output_schema", None)
+            output_type_name = model_params_copy.pop("output_type_name", None)
+
+            # Vendors that support structured output via response_format
+            supported_structured_output_vendors = (
+                "openai",
+                "azure",  # Azure OpenAI uses same format as OpenAI
+                "gemini",
+                "vertex_ai",  # Vertex AI Gemini uses same format as Gemini
+                "anthropic",
+            )
+
+            if output_schema:
+                if vendor in supported_structured_output_vendors:
+                    # Apply vendor-specific response_format for structured output
+                    from _mcp_mesh.engine.provider_handlers import make_schema_strict
+
+                    if vendor == "anthropic":
+                        # Claude: doesn't require all properties in 'required', uses strict=False
+                        schema = make_schema_strict(
+                            output_schema, add_all_required=False
+                        )
+                        strict_mode = False
+                    else:
+                        # OpenAI/Azure/Gemini/Vertex: require all properties in 'required', uses strict=True
+                        schema = make_schema_strict(
+                            output_schema, add_all_required=True
+                        )
+                        strict_mode = True
+
+                    model_params_copy["response_format"] = {
+                        "type": "json_schema",
+                        "json_schema": {
+                            "name": output_type_name or "Response",
+                            "schema": schema,
+                            "strict": strict_mode,
+                        },
+                    }
+                    logger.debug(
+                        f"🎯 Applied {vendor} response_format for structured output: "
+                        f"{output_type_name} (strict={strict_mode})"
+                    )
+                else:
+                    # Vendor doesn't support structured output - warn user
+                    logger.warning(
+                        f"⚠️ Structured output schema '{output_type_name or 'Response'}' "
+                        f"was provided but vendor '{vendor}' does not support response_format. "
+                        f"The schema will be ignored and the LLM may return unstructured output."
+                    )
+
             # Build litellm.completion arguments
             completion_args: dict[str, Any] = {
                 "model": effective_model,

mesh/types.py

@@ -2,6 +2,7 @@
 MCP Mesh type definitions for dependency injection.
 """
 
+import warnings
 from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Protocol
@@ -14,24 +15,24 @@ except ImportError:
     PYDANTIC_AVAILABLE = False
 
 
-class McpMeshAgent(Protocol):
+class McpMeshTool(Protocol):
     """
-    Unified MCP Mesh agent proxy using FastMCP's built-in client.
+    MCP Mesh tool proxy for dependency injection.
 
-    This protocol now provides all MCP protocol features using FastMCP's superior client
-    implementation, replacing both the old basic and advanced proxy types.
+    This protocol defines the interface for injected tool dependencies. When you declare
+    a dependency on a remote tool, MCP Mesh injects a proxy that implements this interface.
 
     Features:
-    - All MCP protocol methods (tools, resources, prompts)
+    - Simple callable interface for tool invocation
+    - Full MCP protocol methods (tools, resources, prompts)
     - Streaming support with FastMCP's StreamableHttpTransport
     - Session management with notifications
-    - Automatic redirect handling (fixes /mcp/ → /mcp issue)
+    - Automatic redirect handling
     - CallToolResult objects with structured content parsing
-    - Enhanced proxy configuration via kwargs
 
     Usage Examples:
         @mesh.tool(dependencies=["date-service"])
-        def greet(name: str, date_service: McpMeshAgent) -> str:
+        def greet(name: str, date_service: McpMeshTool) -> str:
             # Simple call - proxy knows which remote function to invoke
             current_date = date_service()
 
@@ -44,7 +45,7 @@ class McpMeshAgent(Protocol):
             return f"Hello {name}, today is {current_date}"
 
         @mesh.tool(dependencies=["file-service"])
-        async def process_files(file_service: McpMeshAgent) -> str:
+        async def process_files(file_service: McpMeshTool) -> str:
             # Full MCP Protocol usage
             tools = await file_service.list_tools()
             resources = await file_service.list_resources()
@@ -62,7 +63,7 @@ class McpMeshAgent(Protocol):
 
             return "Processing complete"
 
-    The unified proxy provides all MCP protocol features while maintaining simple callable interface.
+    The proxy provides all MCP protocol features while maintaining a simple callable interface.
     """
 
     def __call__(self, arguments: Optional[dict[str, Any]] = None) -> Any:
@@ -156,15 +157,15 @@ class McpMeshAgent(Protocol):
             handler: Any,
         ) -> core_schema.CoreSchema:
             """
-            Custom Pydantic core schema for McpMeshAgent.
+            Custom Pydantic core schema for McpMeshTool.
 
-            This makes McpMeshAgent parameters appear as optional/nullable in MCP schemas,
+            This makes McpMeshTool parameters appear as optional/nullable in MCP schemas,
             preventing serialization errors while maintaining type safety for dependency injection.
 
             The dependency injection system will replace None values with actual proxy objects
             at runtime, so MCP callers never need to provide these parameters.
             """
-            # Treat McpMeshAgent as an optional Any type for MCP serialization
+            # Treat McpMeshTool as an optional Any type for MCP serialization
             return core_schema.with_default_schema(
                 core_schema.nullable_schema(core_schema.any_schema()),
                 default=None,
@@ -181,6 +182,32 @@ class McpMeshAgent(Protocol):
             }
 
 
+def _create_deprecated_mcpmeshagent():
+    """Create McpMeshAgent as a deprecated alias for McpMeshTool."""
+
+    class McpMeshAgent(McpMeshTool, Protocol):
+        """
+        Deprecated: Use McpMeshTool instead.
+
+        This is a backwards-compatible alias that will be removed in a future version.
+        """
+
+        def __init_subclass__(cls, **kwargs):
+            warnings.warn(
+                "McpMeshAgent is deprecated, use McpMeshTool instead. "
+                "McpMeshAgent will be removed in a future version.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            super().__init_subclass__(**kwargs)
+
+    return McpMeshAgent
+
+
+# Deprecated alias for backwards compatibility
+McpMeshAgent = _create_deprecated_mcpmeshagent()
+
+
 class MeshLlmAgent(Protocol):
     """
     LLM agent proxy with automatic agentic loop.

_mcp_mesh/generated/.openapi-generator/FILES

@@ -1,50 +0,0 @@
-mcp_mesh_registry_client/__init__.py
-mcp_mesh_registry_client/api/__init__.py
-mcp_mesh_registry_client/api/agents_api.py
-mcp_mesh_registry_client/api/health_api.py
-mcp_mesh_registry_client/api/tracing_api.py
-mcp_mesh_registry_client/api_client.py
-mcp_mesh_registry_client/api_response.py
-mcp_mesh_registry_client/configuration.py
-mcp_mesh_registry_client/exceptions.py
-mcp_mesh_registry_client/models/__init__.py
-mcp_mesh_registry_client/models/agent_info.py
-mcp_mesh_registry_client/models/agent_metadata.py
-mcp_mesh_registry_client/models/agent_metadata_dependencies_inner.py
-mcp_mesh_registry_client/models/agent_metadata_dependencies_inner_one_of.py
-mcp_mesh_registry_client/models/agent_registration.py
-mcp_mesh_registry_client/models/agent_registration_metadata.py
-mcp_mesh_registry_client/models/agents_list_response.py
-mcp_mesh_registry_client/models/capability_info.py
-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_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_registry_client/models/mesh_registration_response_dependencies_resolved_value_inner.py
-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_registry_client/models/trace_event.py
-mcp_mesh_registry_client/py.typed
-mcp_mesh_registry_client/rest.py

_mcp_mesh/generated/.openapi-generator/VERSION

@@ -1 +0,0 @@
-7.13.0

_mcp_mesh/generated/.openapi-generator-ignore

@@ -1,15 +0,0 @@
-# Skip packaging files - we use this as part of our main package
-pyproject.toml
-setup.py
-setup.cfg
-requirements.txt
-test-requirements.txt
-README.md
-tox.ini
-.travis.yml
-.gitlab-ci.yml
-.github/
-git_push.sh
-.gitignore
-test/
-docs/