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

mesh/decorators.py

@@ -26,25 +26,6 @@ _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.
@@ -95,75 +76,8 @@ 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 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
+        # 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
         try:
             import os
 
@@ -238,11 +152,11 @@ 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
+                        # Create body-modifying receive wrapper to strip trace fields from arguments
+                        # This handles the case where trace context is passed in JSON-RPC arguments
                         import json as json_module
 
-                        async def receive_with_trace_extraction():
+                        async def receive_with_trace_stripping():
                             message = await receive()
                             if message["type"] == "http.request":
                                 body = message.get("body", b"")
@@ -293,14 +207,29 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
                                                         parent_span = (
                                                             current_trace.parent_span
                                                         )
-                                                    logger.debug(
-                                                        f"[TRACE] Extracted trace context from arguments: trace_id={arg_trace_id}"
-                                                    )
                                                 except Exception:
                                                     pass
+
+                                            # 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 extraction: {e}"
+                                            f"[TRACE] Failed to process body: {e}"
                                         )
                             return message
 
@@ -320,7 +249,7 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
                             await send(message)
 
                         await self.app(
-                            scope, receive_with_trace_extraction, send_with_trace_headers
+                            scope, receive_with_trace_stripping, send_with_trace_headers
                         )
 
                 app.add_middleware(TraceContextMiddleware)
@@ -370,19 +299,8 @@ def _start_uvicorn_immediately(http_host: str, http_port: int):
 
         logger.debug("📦 IMMEDIATE UVICORN: Added status endpoints")
 
-        # 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")
+        # Determine port (0 means auto-assign)
+        port = http_port if http_port > 0 else 8080
 
         logger.debug(
             f"🚀 IMMEDIATE UVICORN: Starting uvicorn server on {http_host}:{port}"
@@ -618,25 +536,12 @@ 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 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)"
-                            )
+                        if not isinstance(tag, str):
+                            raise ValueError("all dependency tags must be strings")
 
                     dep_version = dep.get("version")
                     if dep_version is not None and not isinstance(dep_version, str):
@@ -754,7 +659,7 @@ def agent(
     http_port: int = 0,
     enable_http: bool = True,
     namespace: str = "default",
-    heartbeat_interval: int = 5,
+    health_interval: int = 5,  # Will be overridden by centralized defaults
     health_check: Callable[[], Awaitable[Any]] | None = None,
     health_check_ttl: int = 15,
     auto_run: bool = True,  # Changed to True by default!
@@ -779,7 +684,7 @@ def agent(
             Environment variable: MCP_MESH_HTTP_ENABLED (takes precedence)
         namespace: Agent namespace (default: "default")
             Environment variable: MCP_MESH_NAMESPACE (takes precedence)
-        heartbeat_interval: Heartbeat interval in seconds (default: 5)
+        health_interval: Health check interval in seconds (default: 30)
             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
@@ -796,7 +701,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 heartbeat_interval parameter (integer, ≥1)
+        MCP_MESH_HEALTH_INTERVAL: Override health_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)
 
@@ -847,10 +752,10 @@ def agent(
         if not isinstance(namespace, str):
             raise ValueError("namespace must be a string")
 
-        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(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(auto_run, bool):
             raise ValueError("auto_run must be a boolean")
@@ -905,9 +810,9 @@ def agent(
         # Import centralized defaults
         from _mcp_mesh.shared.defaults import MeshDefaults
 
-        final_heartbeat_interval = get_config_value(
+        final_health_interval = get_config_value(
             "MCP_MESH_HEALTH_INTERVAL",
-            override=heartbeat_interval,
+            override=health_interval,
             default=MeshDefaults.HEALTH_INTERVAL,
             rule=ValidationRule.NONZERO_RULE,
         )
@@ -938,7 +843,7 @@ def agent(
             "http_port": final_http_port,
             "enable_http": final_enable_http,
             "namespace": final_namespace,
-            "heartbeat_interval": final_heartbeat_interval,
+            "health_interval": final_health_interval,
             "health_check": health_check,
             "health_check_ttl": health_check_ttl,
             "auto_run": final_auto_run,
@@ -1077,10 +982,10 @@ def route(
         async def upload_resume(
             request: Request,
             file: UploadFile = File(...),
-            pdf_tool: mesh.McpMeshTool = None,    # Injected by MCP Mesh
-            user_service: mesh.McpMeshTool = None  # Injected by MCP Mesh
+            pdf_agent: mesh.McpMeshAgent = None,    # Injected by MCP Mesh
+            user_service: mesh.McpMeshAgent = None  # Injected by MCP Mesh
         ):
-            result = await pdf_tool.extract_text_from_pdf(file)
+            result = await pdf_agent.extract_text_from_pdf(file)
             await user_service.update_profile(user_data, result)
             return {"success": True}
     """
@@ -1109,25 +1014,12 @@ 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 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)"
-                            )
+                        if not isinstance(tag, str):
+                            raise ValueError("all dependency tags must be strings")
 
                     dep_version = dep.get("version")
                     if dep_version is not None and not isinstance(dep_version, str):
@@ -1413,34 +1305,6 @@ 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(
@@ -1450,7 +1314,12 @@ def llm(
                 rule=ValidationRule.STRING_RULE,
             ),
             "provider": resolved_provider,
-            "model": resolved_model,
+            "model": get_config_value(
+                "MESH_LLM_MODEL",
+                override=model,
+                default=None,
+                rule=ValidationRule.STRING_RULE,
+            ),
             "api_key": api_key,  # Will be resolved from provider-specific env vars later
             "max_iterations": get_config_value(
                 "MESH_LLM_MAX_ITERATIONS",
@@ -1458,7 +1327,7 @@ def llm(
                 default=10,
                 rule=ValidationRule.NONZERO_RULE,
             ),
-            "system_prompt": effective_system_prompt,
+            "system_prompt": system_prompt,
             "system_prompt_file": system_prompt_file,
             # Phase 1: Template metadata
             "is_template": is_template,

mesh/helpers.py

@@ -214,58 +214,6 @@ 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,7 +2,6 @@
 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
@@ -15,24 +14,24 @@ except ImportError:
     PYDANTIC_AVAILABLE = False
 
 
-class McpMeshTool(Protocol):
+class McpMeshAgent(Protocol):
     """
-    MCP Mesh tool proxy for dependency injection.
+    Unified MCP Mesh agent proxy using FastMCP's built-in client.
 
-    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.
+    This protocol now provides all MCP protocol features using FastMCP's superior client
+    implementation, replacing both the old basic and advanced proxy types.
 
     Features:
-    - Simple callable interface for tool invocation
-    - Full MCP protocol methods (tools, resources, prompts)
+    - All MCP protocol methods (tools, resources, prompts)
     - Streaming support with FastMCP's StreamableHttpTransport
     - Session management with notifications
-    - Automatic redirect handling
+    - Automatic redirect handling (fixes /mcp/ → /mcp issue)
     - CallToolResult objects with structured content parsing
+    - Enhanced proxy configuration via kwargs
 
     Usage Examples:
         @mesh.tool(dependencies=["date-service"])
-        def greet(name: str, date_service: McpMeshTool) -> str:
+        def greet(name: str, date_service: McpMeshAgent) -> str:
             # Simple call - proxy knows which remote function to invoke
             current_date = date_service()
 
@@ -45,7 +44,7 @@ class McpMeshTool(Protocol):
             return f"Hello {name}, today is {current_date}"
 
         @mesh.tool(dependencies=["file-service"])
-        async def process_files(file_service: McpMeshTool) -> str:
+        async def process_files(file_service: McpMeshAgent) -> str:
             # Full MCP Protocol usage
             tools = await file_service.list_tools()
             resources = await file_service.list_resources()
@@ -63,7 +62,7 @@ class McpMeshTool(Protocol):
 
             return "Processing complete"
 
-    The proxy provides all MCP protocol features while maintaining a simple callable interface.
+    The unified proxy provides all MCP protocol features while maintaining simple callable interface.
     """
 
     def __call__(self, arguments: Optional[dict[str, Any]] = None) -> Any:
@@ -157,15 +156,15 @@ class McpMeshTool(Protocol):
             handler: Any,
         ) -> core_schema.CoreSchema:
             """
-            Custom Pydantic core schema for McpMeshTool.
+            Custom Pydantic core schema for McpMeshAgent.
 
-            This makes McpMeshTool parameters appear as optional/nullable in MCP schemas,
+            This makes McpMeshAgent 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 McpMeshTool as an optional Any type for MCP serialization
+            # Treat McpMeshAgent as an optional Any type for MCP serialization
             return core_schema.with_default_schema(
                 core_schema.nullable_schema(core_schema.any_schema()),
                 default=None,
@@ -182,32 +181,6 @@ class McpMeshTool(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.