Merge branch 'main' into main

Author: beaterblank

examples/clients/simple-auth-client/pyproject.toml

@@ -14,10 +14,7 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
 ]
-dependencies = [
-    "click>=8.2.0",
-    "mcp>=1.0.0",
-]
+dependencies = ["click>=8.2.0", "mcp"]
 
 [project.scripts]
 mcp-simple-auth-client = "mcp_simple_auth_client.main:cli"
@@ -44,9 +41,3 @@ target-version = "py310"
 
 [tool.uv]
 dev-dependencies = ["pyright>=1.1.379", "pytest>=8.3.3", "ruff>=0.6.9"]
-
-[tool.uv.sources]
-mcp = { path = "../../../" }
-
-[[tool.uv.index]]
-url = "https://pypi.org/simple"

examples/clients/simple-auth-client/uv.lock

@@ -401,7 +401,7 @@ async def start(self) -> None:
             await self.cleanup_servers()
 
 
-async def main() -> None:
+async def run() -> None:
     """Initialize and run the chat session."""
     config = Configuration()
     server_config = config.load_config("servers_config.json")
@@ -411,5 +411,9 @@ async def main() -> None:
     await chat_session.start()
 
 
+def main() -> None:
+    asyncio.run(run())
+
+
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()

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

@@ -17,12 +17,12 @@ classifiers = [
 dependencies = [
     "python-dotenv>=1.0.0",
     "requests>=2.31.0",
-    "mcp>=1.0.0",
-    "uvicorn>=0.32.1"
+    "mcp",
+    "uvicorn>=0.32.1",
 ]
 
 [project.scripts]
-mcp-simple-chatbot = "mcp_simple_chatbot.client:main"
+mcp-simple-chatbot = "mcp_simple_chatbot.main:main"
 
 [build-system]
 requires = ["hatchling"]

examples/clients/simple-chatbot/pyproject.toml

@@ -98,8 +98,8 @@ venv = ".venv"
 # those private functions instead of testing the private functions directly. It makes it easier to maintain the code source
 # and refactor code that is not public.
 executionEnvironments = [
-  { root = "tests", reportUnusedFunction = false, reportPrivateUsage = false },
-  { root = "examples/servers", reportUnusedFunction = false },
+    { root = "tests", reportUnusedFunction = false, reportPrivateUsage = false },
+    { root = "examples/servers", reportUnusedFunction = false },
 ]
 
 [tool.ruff]
@@ -109,17 +109,17 @@ extend-exclude = ["README.md"]
 
 [tool.ruff.lint]
 select = [
-    "C4",    # flake8-comprehensions
-    "C90",   # mccabe
-    "E",     # pycodestyle
-    "F",     # pyflakes
-    "I",     # isort
-    "PERF",  # Perflint
-    "PL",    # Pylint
-    "UP",    # pyupgrade
+    "C4",   # flake8-comprehensions
+    "C90",  # mccabe
+    "E",    # pycodestyle
+    "F",    # pyflakes
+    "I",    # isort
+    "PERF", # Perflint
+    "PL",   # Pylint
+    "UP",   # pyupgrade
 ]
 ignore = ["PERF203", "PLC0415", "PLR0402"]
-mccabe.max-complexity = 24  # Default is 10
+mccabe.max-complexity = 24 # Default is 10
 
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401"]
@@ -128,13 +128,13 @@ mccabe.max-complexity = 24  # Default is 10
 
 [tool.ruff.lint.pylint]
 allow-magic-value-types = ["bytes", "float", "int", "str"]
-max-args = 23         # Default is 5
-max-branches = 23     # Default is 12
-max-returns = 13      # Default is 6
-max-statements = 102  # Default is 50
+max-args = 23                                              # Default is 5
+max-branches = 23                                          # Default is 12
+max-returns = 13                                           # Default is 6
+max-statements = 102                                       # Default is 50
 
 [tool.uv.workspace]
-members = ["examples/servers/*", "examples/snippets"]
+members = ["examples/clients/*", "examples/servers/*", "examples/snippets"]
 
 [tool.uv.sources]
 mcp = { workspace = true }
@@ -154,16 +154,16 @@ filterwarnings = [
     "ignore:websockets.server.WebSocketServerProtocol is deprecated:DeprecationWarning",
     "ignore:Returning str or bytes.*:DeprecationWarning:mcp.server.lowlevel",
     # pywin32 internal deprecation warning
-    "ignore:getargs.*The 'u' format is deprecated:DeprecationWarning"
+    "ignore:getargs.*The 'u' format is deprecated:DeprecationWarning",
 ]
 
 [tool.markdown.lint]
-default=true
-MD004=false  # ul-style - Unordered list style
-MD007.indent=2  # ul-indent - Unordered list indentation
-MD013=false  # line-length - Line length
-MD029=false  # ol-prefix - Ordered list item prefix
-MD033=false  # no-inline-html Inline HTML
-MD041=false  # first-line-heading/first-line-h1
-MD046=false  # indented-code-blocks
-MD059=false  # descriptive-link-text
+default = true
+MD004 = false    # ul-style - Unordered list style
+MD007.indent = 2 # ul-indent - Unordered list indentation
+MD013 = false    # line-length - Line length
+MD029 = false    # ol-prefix - Ordered list item prefix
+MD033 = false    # no-inline-html Inline HTML
+MD041 = false    # first-line-heading/first-line-h1
+MD046 = false    # indented-code-blocks
+MD059 = false    # descriptive-link-text

examples/clients/simple-chatbot/uv.lock

@@ -328,16 +328,19 @@ async def call_tool(
         arguments: dict[str, Any] | None = None,
         read_timeout_seconds: timedelta | None = None,
         progress_callback: ProgressFnT | None = None,
+        *,
+        meta: dict[str, Any] | None = None,
     ) -> types.CallToolResult:
         """Send a tools/call request with optional progress callback support."""
 
+        _meta: types.RequestParams.Meta | None = None
+        if meta is not None:
+            _meta = types.RequestParams.Meta(**meta)
+
         result = await self.send_request(
             types.ClientRequest(
                 types.CallToolRequest(
-                    params=types.CallToolRequestParams(
-                        name=name,
-                        arguments=arguments,
-                    ),
+                    params=types.CallToolRequestParams(name=name, arguments=arguments, _meta=_meta),
                 )
             ),
             types.CallToolResult,

pyproject.toml

@@ -11,6 +11,7 @@
 from mcp.shared.version import SUPPORTED_PROTOCOL_VERSIONS
 from mcp.types import (
     LATEST_PROTOCOL_VERSION,
+    CallToolResult,
     ClientNotification,
     ClientRequest,
     Implementation,
@@ -23,6 +24,7 @@
     JSONRPCResponse,
     ServerCapabilities,
     ServerResult,
+    TextContent,
 )
 
 
@@ -492,8 +494,125 @@ async def mock_server():
 
     # Assert that capabilities are properly set with custom callbacks
     assert received_capabilities is not None
-    assert received_capabilities.sampling is not None  # Custom sampling callback provided
+    # Custom sampling callback provided
+    assert received_capabilities.sampling is not None
     assert isinstance(received_capabilities.sampling, types.SamplingCapability)
-    assert received_capabilities.roots is not None  # Custom list_roots callback provided
+    # Custom list_roots callback provided
+    assert received_capabilities.roots is not None
     assert isinstance(received_capabilities.roots, types.RootsCapability)
-    assert received_capabilities.roots.listChanged is True  # Should be True for custom callback
+    # Should be True for custom callback
+    assert received_capabilities.roots.listChanged is True
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize(argnames="meta", argvalues=[None, {"toolMeta": "value"}])
+async def test_client_tool_call_with_meta(meta: dict[str, Any] | None):
+    """Test that client tool call requests can include metadata"""
+    client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[SessionMessage](1)
+    server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[SessionMessage](1)
+
+    mocked_tool = types.Tool(name="sample_tool", inputSchema={})
+
+    async def mock_server():
+        # Receive initialization request from client
+        session_message = await client_to_server_receive.receive()
+        jsonrpc_request = session_message.message
+        assert isinstance(jsonrpc_request.root, JSONRPCRequest)
+        request = ClientRequest.model_validate(
+            jsonrpc_request.model_dump(by_alias=True, mode="json", exclude_none=True)
+        )
+        assert isinstance(request.root, InitializeRequest)
+
+        result = ServerResult(
+            InitializeResult(
+                protocolVersion=LATEST_PROTOCOL_VERSION,
+                capabilities=ServerCapabilities(),
+                serverInfo=Implementation(name="mock-server", version="0.1.0"),
+            )
+        )
+
+        # Answer initialization request
+        await server_to_client_send.send(
+            SessionMessage(
+                JSONRPCMessage(
+                    JSONRPCResponse(
+                        jsonrpc="2.0",
+                        id=jsonrpc_request.root.id,
+                        result=result.model_dump(by_alias=True, mode="json", exclude_none=True),
+                    )
+                )
+            )
+        )
+
+        # Receive initialized notification
+        await client_to_server_receive.receive()
+
+        # Wait for the client to send a 'tools/call' request
+        session_message = await client_to_server_receive.receive()
+        jsonrpc_request = session_message.message
+        assert isinstance(jsonrpc_request.root, JSONRPCRequest)
+
+        assert jsonrpc_request.root.method == "tools/call"
+
+        if meta is not None:
+            assert jsonrpc_request.root.params
+            assert "_meta" in jsonrpc_request.root.params
+            assert jsonrpc_request.root.params["_meta"] == meta
+
+        result = ServerResult(
+            CallToolResult(content=[TextContent(type="text", text="Called successfully")], isError=False)
+        )
+
+        # Send the tools/call result
+        await server_to_client_send.send(
+            SessionMessage(
+                JSONRPCMessage(
+                    JSONRPCResponse(
+                        jsonrpc="2.0",
+                        id=jsonrpc_request.root.id,
+                        result=result.model_dump(by_alias=True, mode="json", exclude_none=True),
+                    )
+                )
+            )
+        )
+
+        # Wait for the tools/list request from the client
+        # The client requires this step to validate the tool output schema
+        session_message = await client_to_server_receive.receive()
+        jsonrpc_request = session_message.message
+        assert isinstance(jsonrpc_request.root, JSONRPCRequest)
+
+        assert jsonrpc_request.root.method == "tools/list"
+
+        result = types.ListToolsResult(tools=[mocked_tool])
+
+        await server_to_client_send.send(
+            SessionMessage(
+                JSONRPCMessage(
+                    JSONRPCResponse(
+                        jsonrpc="2.0",
+                        id=jsonrpc_request.root.id,
+                        result=result.model_dump(by_alias=True, mode="json", exclude_none=True),
+                    )
+                )
+            )
+        )
+
+        server_to_client_send.close()
+
+    async with (
+        ClientSession(
+            server_to_client_receive,
+            client_to_server_send,
+        ) as session,
+        anyio.create_task_group() as tg,
+        client_to_server_send,
+        client_to_server_receive,
+        server_to_client_send,
+        server_to_client_receive,
+    ):
+        tg.start_soon(mock_server)
+
+        await session.initialize()
+
+        await session.call_tool(name=mocked_tool.name, arguments={"foo": "bar"}, meta=meta)