Merge branch 'main' into fix-307-Temporary-Redirect

Author: chi2liu

examples/clients/simple-chatbot/mcp_simple_chatbot/main.py

@@ -245,7 +245,7 @@ def get_response(self, messages: list[dict[str, str]]) -> str:
         }
         payload = {
             "messages": messages,
-            "model": "llama-3.2-90b-vision-preview",
+            "model": "meta-llama/llama-4-scout-17b-16e-instruct",
             "temperature": 0.7,
             "max_tokens": 4096,
             "top_p": 1,
@@ -284,12 +284,9 @@ def __init__(self, servers: list[Server], llm_client: LLMClient) -> None:
 
     async def cleanup_servers(self) -> None:
         """Clean up all servers properly."""
-        cleanup_tasks = [
-            asyncio.create_task(server.cleanup()) for server in self.servers
-        ]
-        if cleanup_tasks:
+        for server in reversed(self.servers):
             try:
-                await asyncio.gather(*cleanup_tasks, return_exceptions=True)
+                await server.cleanup()
             except Exception as e:
                 logging.warning(f"Warning during final cleanup: {e}")
 

pyproject.toml

@@ -109,7 +109,13 @@ members = ["examples/servers/*"]
 mcp = { workspace = true }
 
 [tool.pytest.ini_options]
+log_cli = true
 xfail_strict = true
+addopts = """
+    --color=yes
+    --capture=fd
+    --numprocesses auto
+"""
 filterwarnings = [
     "error",
     # This should be fixed on Uvicorn's side.

src/mcp/client/sse.py

@@ -10,7 +10,7 @@
 from httpx_sse import aconnect_sse
 
 import mcp.types as types
-from mcp.shared._httpx_utils import create_mcp_http_client
+from mcp.shared._httpx_utils import McpHttpClientFactory, create_mcp_http_client
 from mcp.shared.message import SessionMessage
 
 logger = logging.getLogger(__name__)
@@ -26,6 +26,7 @@ async def sse_client(
     headers: dict[str, Any] | None = None,
     timeout: float = 5,
     sse_read_timeout: float = 60 * 5,
+    httpx_client_factory: McpHttpClientFactory = create_mcp_http_client,
     auth: httpx.Auth | None = None,
 ):
     """
@@ -53,7 +54,7 @@ async def sse_client(
     async with anyio.create_task_group() as tg:
         try:
             logger.info(f"Connecting to SSE endpoint: {remove_request_params(url)}")
-            async with create_mcp_http_client(headers=headers, auth=auth) as client:
+            async with httpx_client_factory(headers=headers, auth=auth) as client:
                 async with aconnect_sse(
                     client,
                     "GET",

src/mcp/client/streamable_http.py

@@ -19,7 +19,7 @@
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from httpx_sse import EventSource, ServerSentEvent, aconnect_sse
 
-from mcp.shared._httpx_utils import create_mcp_http_client
+from mcp.shared._httpx_utils import McpHttpClientFactory, create_mcp_http_client
 from mcp.shared.message import ClientMessageMetadata, SessionMessage
 from mcp.types import (
     ErrorData,
@@ -430,6 +430,7 @@ async def streamablehttp_client(
     timeout: timedelta = timedelta(seconds=30),
     sse_read_timeout: timedelta = timedelta(seconds=60 * 5),
     terminate_on_close: bool = True,
+    httpx_client_factory: McpHttpClientFactory = create_mcp_http_client,
     auth: httpx.Auth | None = None,
 ) -> AsyncGenerator[
     tuple[
@@ -464,7 +465,7 @@ async def streamablehttp_client(
         try:
             logger.info(f"Connecting to StreamableHTTP endpoint: {url}")
 
-            async with create_mcp_http_client(
+            async with httpx_client_factory(
                 headers=transport.request_headers,
                 timeout=httpx.Timeout(
                     transport.timeout.seconds, read=transport.sse_read_timeout.seconds

src/mcp/server/fastmcp/tools/base.py

@@ -1,5 +1,6 @@
 from __future__ import annotations as _annotations
 
+import functools
 import inspect
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, get_origin
@@ -53,7 +54,7 @@ def from_function(
             raise ValueError("You must provide a name for lambda functions")
 
         func_doc = description or fn.__doc__ or ""
-        is_async = inspect.iscoroutinefunction(fn)
+        is_async = _is_async_callable(fn)
 
         if context_kwarg is None:
             sig = inspect.signature(fn)
@@ -98,3 +99,12 @@ async def run(
             )
         except Exception as e:
             raise ToolError(f"Error executing tool {self.name}: {e}") from e
+
+
+def _is_async_callable(obj: Any) -> bool:
+    while isinstance(obj, functools.partial):
+        obj = obj.func
+
+    return inspect.iscoroutinefunction(obj) or (
+        callable(obj) and inspect.iscoroutinefunction(getattr(obj, "__call__", None))
+    )

src/mcp/shared/_httpx_utils.py

@@ -1,12 +1,21 @@
 """Utilities for creating standardized httpx AsyncClient instances."""
 
-from typing import Any
+from typing import Any, Protocol
 
 import httpx
 
 __all__ = ["create_mcp_http_client"]
 
 
+class McpHttpClientFactory(Protocol):
+    def __call__(
+        self,
+        headers: dict[str, str] | None = None,
+        timeout: httpx.Timeout | None = None,
+        auth: httpx.Auth | None = None,
+    ) -> httpx.AsyncClient: ...
+
+
 def create_mcp_http_client(
     headers: dict[str, str] | None = None,
     timeout: httpx.Timeout | None = None,

tests/client/test_config.py

@@ -44,7 +44,9 @@ def test_command_execution(mock_config_path: Path):
 
     test_args = [command] + args + ["--help"]
 
-    result = subprocess.run(test_args, capture_output=True, text=True, timeout=5)
+    result = subprocess.run(
+        test_args, capture_output=True, text=True, timeout=5, check=False
+    )
 
     assert result.returncode == 0
     assert "usage" in result.stdout.lower()

tests/server/fastmcp/test_tool_manager.py

@@ -102,6 +102,39 @@ def create_user(user: UserInput, flag: bool) -> dict:
         assert "age" in tool.parameters["$defs"]["UserInput"]["properties"]
         assert "flag" in tool.parameters["properties"]
 
+    def test_add_callable_object(self):
+        """Test registering a callable object."""
+
+        class MyTool:
+            def __init__(self):
+                self.__name__ = "MyTool"
+
+            def __call__(self, x: int) -> int:
+                return x * 2
+
+        manager = ToolManager()
+        tool = manager.add_tool(MyTool())
+        assert tool.name == "MyTool"
+        assert tool.is_async is False
+        assert tool.parameters["properties"]["x"]["type"] == "integer"
+
+    @pytest.mark.anyio
+    async def test_add_async_callable_object(self):
+        """Test registering an async callable object."""
+
+        class MyAsyncTool:
+            def __init__(self):
+                self.__name__ = "MyAsyncTool"
+
+            async def __call__(self, x: int) -> int:
+                return x * 2
+
+        manager = ToolManager()
+        tool = manager.add_tool(MyAsyncTool())
+        assert tool.name == "MyAsyncTool"
+        assert tool.is_async is True
+        assert tool.parameters["properties"]["x"]["type"] == "integer"
+
     def test_add_invalid_tool(self):
         manager = ToolManager()
         with pytest.raises(AttributeError):
@@ -168,6 +201,34 @@ async def double(n: int) -> int:
         result = await manager.call_tool("double", {"n": 5})
         assert result == 10
 
+    @pytest.mark.anyio
+    async def test_call_object_tool(self):
+        class MyTool:
+            def __init__(self):
+                self.__name__ = "MyTool"
+
+            def __call__(self, x: int) -> int:
+                return x * 2
+
+        manager = ToolManager()
+        tool = manager.add_tool(MyTool())
+        result = await tool.run({"x": 5})
+        assert result == 10
+
+    @pytest.mark.anyio
+    async def test_call_async_object_tool(self):
+        class MyAsyncTool:
+            def __init__(self):
+                self.__name__ = "MyAsyncTool"
+
+            async def __call__(self, x: int) -> int:
+                return x * 2
+
+        manager = ToolManager()
+        tool = manager.add_tool(MyAsyncTool())
+        result = await tool.run({"x": 5})
+        assert result == 10
+
     @pytest.mark.anyio
     async def test_call_tool_with_default_args(self):
         def add(a: int, b: int = 1) -> int: