Merge branch 'main' into feature/runtime-tools

Author: Nikita Bellini

.github/workflows/shared.yml

@@ -29,6 +29,7 @@ jobs:
   test:
     runs-on: ${{ matrix.os }}
     timeout-minutes: 10
+    continue-on-error: true
     strategy:
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13"]
@@ -48,8 +49,14 @@ jobs:
 
       - name: Run pytest
         run: uv run --frozen --no-sync pytest
-    continue-on-error: true
 
+      # This must run last as it modifies the environment!
+      - name: Run pytest with lowest versions
+        run: |
+          uv sync --all-extras --upgrade
+          uv run --no-sync pytest
+        env:
+          UV_RESOLUTION: lowest-direct
   readme-snippets:
     runs-on: ubuntu-latest
     steps:

README.md

@@ -1366,13 +1366,13 @@ The MCP protocol defines three core primitives that servers can implement:
 
 MCP servers declare capabilities during initialization:
 
-| Capability  | Feature Flag                 | Description                        |
-|-------------|------------------------------|------------------------------------|
-| `prompts`   | `listChanged`                | Prompt template management         |
-| `resources` | `subscribe`<br/>`listChanged`| Resource exposure and updates      |
-| `tools`     | `listChanged`                | Tool discovery and execution       |
-| `logging`   | -                            | Server logging configuration       |
-| `completion`| -                            | Argument completion suggestions    |
+| Capability   | Feature Flag                 | Description                        |
+|--------------|------------------------------|------------------------------------|
+| `prompts`    | `listChanged`                | Prompt template management         |
+| `resources`  | `subscribe`<br/>`listChanged`| Resource exposure and updates      |
+| `tools`      | `listChanged`                | Tool discovery and execution       |
+| `logging`    | -                            | Server logging configuration       |
+| `completions`| -                            | Argument completion suggestions    |
 
 ## Documentation
 

pyproject.toml

@@ -25,7 +25,7 @@ dependencies = [
     "anyio>=4.5",
     "httpx>=0.27",
     "httpx-sse>=0.4",
-    "pydantic>=2.7.2,<3.0.0",
+    "pydantic>=2.8.0,<3.0.0",
     "starlette>=0.27",
     "python-multipart>=0.0.9",
     "sse-starlette>=1.6.1",
@@ -36,14 +36,13 @@ dependencies = [
 
 [project.optional-dependencies]
 rich = ["rich>=13.9.4"]
-cli = ["typer>=0.12.4", "python-dotenv>=1.0.0"]
+cli = ["typer>=0.16.0", "python-dotenv>=1.0.0"]
 ws = ["websockets>=15.0.1"]
 
 [project.scripts]
 mcp = "mcp.cli:app [cli]"
 
 [tool.uv]
-resolution = "lowest-direct"
 default-groups = ["dev", "docs"]
 required-version = ">=0.7.2"
 
@@ -58,6 +57,7 @@ dev = [
     "pytest-examples>=0.0.14",
     "pytest-pretty>=1.2.0",
     "inline-snapshot>=0.23.0",
+    "dirty-equals>=0.9.0",
 ]
 docs = [
     "mkdocs>=1.6.1",
@@ -124,5 +124,5 @@ filterwarnings = [
     # This should be fixed on Uvicorn's side.
     "ignore::DeprecationWarning:websockets",
     "ignore:websockets.server.WebSocketServerProtocol is deprecated:DeprecationWarning",
-    "ignore:Returning str or bytes.*:DeprecationWarning:mcp.server.lowlevel"
+    "ignore:Returning str or bytes.*:DeprecationWarning:mcp.server.lowlevel",
 ]

src/mcp/server/fastmcp/resources/types.py

@@ -54,7 +54,12 @@ class FunctionResource(Resource):
     async def read(self) -> str | bytes:
         """Read the resource by calling the wrapped function."""
         try:
-            result = await self.fn() if inspect.iscoroutinefunction(self.fn) else self.fn()
+            # Call the function first to see if it returns a coroutine
+            result = self.fn()
+            # If it's a coroutine, await it
+            if inspect.iscoroutine(result):
+                result = await result
+
             if isinstance(result, Resource):
                 return await result.read()
             elif isinstance(result, bytes):

src/mcp/server/lowlevel/server.py

@@ -190,6 +190,7 @@ def get_capabilities(
         resources_capability = None
         tools_capability = None
         logging_capability = None
+        completions_capability = None
 
         # Set prompt capabilities if handler exists
         if types.ListPromptsRequest in self.request_handlers:
@@ -209,12 +210,17 @@ def get_capabilities(
         if types.SetLevelRequest in self.request_handlers:
             logging_capability = types.LoggingCapability()
 
+        # Set completions capabilities if handler exists
+        if types.CompleteRequest in self.request_handlers:
+            completions_capability = types.CompletionsCapability()
+
         return types.ServerCapabilities(
             prompts=prompts_capability,
             resources=resources_capability,
             tools=tools_capability,
             logging=logging_capability,
             experimental=experimental_capabilities,
+            completions=completions_capability,
         )
 
     @property

src/mcp/types.py

@@ -286,6 +286,12 @@ class LoggingCapability(BaseModel):
     model_config = ConfigDict(extra="allow")
 
 
+class CompletionsCapability(BaseModel):
+    """Capability for completions operations."""
+
+    model_config = ConfigDict(extra="allow")
+
+
 class ServerCapabilities(BaseModel):
     """Capabilities that a server may support."""
 
@@ -299,6 +305,8 @@ class ServerCapabilities(BaseModel):
     """Present if the server offers any resources to read."""
     tools: ToolsCapability | None = None
     """Present if the server offers any tools to call."""
+    completions: CompletionsCapability | None = None
+    """Present if the server offers autocompletion suggestions for prompts and resources."""
     model_config = ConfigDict(extra="allow")
 
 

tests/issues/test_188_concurrency.py

@@ -3,58 +3,84 @@
 from pydantic import AnyUrl
 
 from mcp.server.fastmcp import FastMCP
-from mcp.shared.memory import (
-    create_connected_server_and_client_session as create_session,
-)
-
-_sleep_time_seconds = 0.01
-_resource_name = "slow://slow_resource"
+from mcp.shared.memory import create_connected_server_and_client_session as create_session
 
 
 @pytest.mark.anyio
-async def test_messages_are_executed_concurrently():
+async def test_messages_are_executed_concurrently_tools():
     server = FastMCP("test")
-    call_timestamps = []
+    event = anyio.Event()
+    tool_started = anyio.Event()
+    call_order = []
 
     @server.tool("sleep")
     async def sleep_tool():
-        call_timestamps.append(("tool_start_time", anyio.current_time()))
-        await anyio.sleep(_sleep_time_seconds)
-        call_timestamps.append(("tool_end_time", anyio.current_time()))
+        call_order.append("waiting_for_event")
+        tool_started.set()
+        await event.wait()
+        call_order.append("tool_end")
         return "done"
 
-    @server.resource(_resource_name)
-    async def slow_resource():
-        call_timestamps.append(("resource_start_time", anyio.current_time()))
-        await anyio.sleep(_sleep_time_seconds)
-        call_timestamps.append(("resource_end_time", anyio.current_time()))
+    @server.tool("trigger")
+    async def trigger():
+        # Wait for tool to start before setting the event
+        await tool_started.wait()
+        call_order.append("trigger_started")
+        event.set()
+        call_order.append("trigger_end")
         return "slow"
 
     async with create_session(server._mcp_server) as client_session:
+        # First tool will wait on event, second will set it
         async with anyio.create_task_group() as tg:
-            for _ in range(10):
-                tg.start_soon(client_session.call_tool, "sleep")
-                tg.start_soon(client_session.read_resource, AnyUrl(_resource_name))
+            # Start the tool first (it will wait on event)
+            tg.start_soon(client_session.call_tool, "sleep")
+            # Then the trigger tool will set the event to allow the first tool to continue
+            await client_session.call_tool("trigger")
 
-        active_calls = 0
-        max_concurrent_calls = 0
-        for call_type, _ in sorted(call_timestamps, key=lambda x: x[1]):
-            if "start" in call_type:
-                active_calls += 1
-                max_concurrent_calls = max(max_concurrent_calls, active_calls)
-            else:
-                active_calls -= 1
-        print(f"Max concurrent calls: {max_concurrent_calls}")
-        assert max_concurrent_calls > 1, "No concurrent calls were executed"
+        # Verify that both ran concurrently
+        assert call_order == [
+            "waiting_for_event",
+            "trigger_started",
+            "trigger_end",
+            "tool_end",
+        ], f"Expected concurrent execution, but got: {call_order}"
 
 
-def main():
-    anyio.run(test_messages_are_executed_concurrently)
+@pytest.mark.anyio
+async def test_messages_are_executed_concurrently_tools_and_resources():
+    server = FastMCP("test")
+    event = anyio.Event()
+    tool_started = anyio.Event()
+    call_order = []
 
+    @server.tool("sleep")
+    async def sleep_tool():
+        call_order.append("waiting_for_event")
+        tool_started.set()
+        await event.wait()
+        call_order.append("tool_end")
+        return "done"
 
-if __name__ == "__main__":
-    import logging
+    @server.resource("slow://slow_resource")
+    async def slow_resource():
+        # Wait for tool to start before setting the event
+        await tool_started.wait()
+        event.set()
+        call_order.append("resource_end")
+        return "slow"
 
-    logging.basicConfig(level=logging.DEBUG)
+    async with create_session(server._mcp_server) as client_session:
+        # First tool will wait on event, second will set it
+        async with anyio.create_task_group() as tg:
+            # Start the tool first (it will wait on event)
+            tg.start_soon(client_session.call_tool, "sleep")
+            # Then the resource (it will set the event)
+            tg.start_soon(client_session.read_resource, AnyUrl("slow://slow_resource"))
 
-    main()
+        # Verify that both ran concurrently
+        assert call_order == [
+            "waiting_for_event",
+            "resource_end",
+            "tool_end",
+        ], f"Expected concurrent execution, but got: {call_order}"

tests/server/fastmcp/test_func_metadata.py

@@ -3,6 +3,7 @@
 
 import annotated_types
 import pytest
+from dirty_equals import IsPartialDict
 from pydantic import BaseModel, Field
 
 from mcp.server.fastmcp.utilities.func_metadata import func_metadata
@@ -202,11 +203,8 @@ def func_dict_any() -> dict[str, Any]:
         return {"a": 1, "b": "hello", "c": [1, 2, 3]}
 
     meta = func_metadata(func_dict_any)
-    assert meta.output_schema == {
-        "additionalProperties": True,
-        "type": "object",
-        "title": "func_dict_anyDictOutput",
-    }
+
+    assert meta.output_schema == IsPartialDict(type="object", title="func_dict_anyDictOutput")
 
     # Test dict[str, str]
     def func_dict_str() -> dict[str, str]:

tests/server/test_session.py

@@ -11,8 +11,13 @@
 from mcp.shared.session import RequestResponder
 from mcp.types import (
     ClientNotification,
+    Completion,
+    CompletionArgument,
+    CompletionsCapability,
     InitializedNotification,
+    PromptReference,
     PromptsCapability,
+    ResourceReference,
     ResourcesCapability,
     ServerCapabilities,
 )
@@ -80,6 +85,7 @@ async def test_server_capabilities():
     caps = server.get_capabilities(notification_options, experimental_capabilities)
     assert caps.prompts is None
     assert caps.resources is None
+    assert caps.completions is None
 
     # Add a prompts handler
     @server.list_prompts()
@@ -89,6 +95,7 @@ async def list_prompts():
     caps = server.get_capabilities(notification_options, experimental_capabilities)
     assert caps.prompts == PromptsCapability(listChanged=False)
     assert caps.resources is None
+    assert caps.completions is None
 
     # Add a resources handler
     @server.list_resources()
@@ -98,6 +105,19 @@ async def list_resources():
     caps = server.get_capabilities(notification_options, experimental_capabilities)
     assert caps.prompts == PromptsCapability(listChanged=False)
     assert caps.resources == ResourcesCapability(subscribe=False, listChanged=False)
+    assert caps.completions is None
+
+    # Add a complete handler
+    @server.completion()
+    async def complete(ref: PromptReference | ResourceReference, argument: CompletionArgument):
+        return Completion(
+            values=["completion1", "completion2"],
+        )
+
+    caps = server.get_capabilities(notification_options, experimental_capabilities)
+    assert caps.prompts == PromptsCapability(listChanged=False)
+    assert caps.resources == ResourcesCapability(subscribe=False, listChanged=False)
+    assert caps.completions == CompletionsCapability()
 
 
 @pytest.mark.anyio