Merge remote-tracking branch 'origin/main' into praboud/auth

Author: praboud-ant

README.md

@@ -2,14 +2,12 @@
 
 ## Bumping Dependencies
 
-1. Change dependency
-2. Upgrade lock with `uv lock --resolution lowest-direct
+1. Change dependency version in `pyproject.toml`
+2. Upgrade lock with `uv lock --resolution lowest-direct`
 
 ## Major or Minor Release
 
-1. Create a release branch named `vX.Y.Z` where `X.Y.Z` is the version.
-2. Bump version number on release branch.
-3. Create an annotated, signed tag: `git tag -s -a vX.Y.Z`
-4. Create a github release using `gh release create` and publish it.
-5. Have the release flow being reviewed.
-7. Bump version number on `main` to the next version followed by `.dev`, e.g. `v0.4.0.dev`.
+Create a GitHub release via UI with the tag being `vX.Y.Z` where `X.Y.Z` is the version,
+and the release title being the same. Then ask someone to review the release.
+
+The package version will be set automatically from the tag.

RELEASE.md

@@ -1,6 +1,6 @@
 [project]
 name = "mcp"
-version = "1.4.0.dev0"
+dynamic = ["version"]
 description = "Model Context Protocol SDK"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -48,12 +48,21 @@ dev-dependencies = [
     "ruff>=0.8.5",
     "trio>=0.26.2",
     "pytest-xdist>=3.6.1",
+    "pytest-examples>=0.0.14",
 ]
 
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "uv-dynamic-versioning"]
 build-backend = "hatchling.build"
 
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+vcs = "git"
+style = "pep440"
+bump = true
+
 [project.urls]
 Homepage = "https://modelcontextprotocol.io"
 Repository = "https://github.com/modelcontextprotocol/python-sdk"
@@ -66,12 +75,11 @@ packages = ["src/mcp"]
 include = ["src/mcp", "tests"]
 venvPath = "."
 venv = ".venv"
-strict = [
-    "src/mcp/server/fastmcp/tools/base.py",
-]
+strict = ["src/mcp/**/*.py"]
+exclude = ["src/mcp/types.py"]
 
 [tool.ruff.lint]
-select = ["E", "F", "I"]
+select = ["E", "F", "I", "UP"]
 ignore = []
 
 [tool.ruff]

pyproject.toml

@@ -1,8 +1,10 @@
 """Claude app integration utilities."""
 
 import json
+import os
 import sys
 from pathlib import Path
+from typing import Any
 
 from mcp.server.fastmcp.utilities.logging import get_logger
 
@@ -17,6 +19,10 @@ def get_claude_config_path() -> Path | None:
         path = Path(Path.home(), "AppData", "Roaming", "Claude")
     elif sys.platform == "darwin":
         path = Path(Path.home(), "Library", "Application Support", "Claude")
+    elif sys.platform.startswith("linux"):
+        path = Path(
+            os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"), "Claude"
+        )
     else:
         return None
 
@@ -111,10 +117,7 @@ def update_claude_config(
         # Add fastmcp run command
         args.extend(["mcp", "run", file_spec])
 
-        server_config = {
-            "command": "uv",
-            "args": args,
-        }
+        server_config: dict[str, Any] = {"command": "uv", "args": args}
 
         # Add environment variables if specified
         if env_vars:

src/mcp/cli/claude.py

@@ -294,15 +294,14 @@ def run(
 ) -> None:
     """Run a MCP server.
 
-    The server can be specified in two ways:
-    1. Module approach: server.py - runs the module directly, expecting a server.run()
-       call
-    2. Import approach: server.py:app - imports and runs the specified server object
+    The server can be specified in two ways:\n
+    1. Module approach: server.py - runs the module directly, expecting a server.run() call.\n
+    2. Import approach: server.py:app - imports and runs the specified server object.\n\n
 
     Note: This command runs the server directly. You are responsible for ensuring
-    all dependencies are available. For dependency management, use mcp install
-    or mcp dev instead.
-    """
+    all dependencies are available.\n
+    For dependency management, use `mcp install` or `mcp dev` instead.
+    """  # noqa: E501
     file, server_object = _parse_file_path(file_spec)
 
     logger.debug(

src/mcp/cli/cli.py

@@ -5,10 +5,12 @@
 from urllib.parse import urlparse
 
 import anyio
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 
 from mcp.client.session import ClientSession
 from mcp.client.sse import sse_client
 from mcp.client.stdio import StdioServerParameters, stdio_client
+from mcp.types import JSONRPCMessage
 
 if not sys.warnoptions:
     import warnings
@@ -29,7 +31,10 @@ async def receive_loop(session: ClientSession):
         logger.info("Received message from server: %s", message)
 
 
-async def run_session(read_stream, write_stream):
+async def run_session(
+    read_stream: MemoryObjectReceiveStream[JSONRPCMessage | Exception],
+    write_stream: MemoryObjectSendStream[JSONRPCMessage],
+):
     async with (
         ClientSession(read_stream, write_stream) as session,
         anyio.create_task_group() as tg,

src/mcp/client/__main__.py

@@ -24,6 +24,13 @@ async def __call__(
     ) -> types.ListRootsResult | types.ErrorData: ...
 
 
+class LoggingFnT(Protocol):
+    async def __call__(
+        self,
+        params: types.LoggingMessageNotificationParams,
+    ) -> None: ...
+
+
 async def _default_sampling_callback(
     context: RequestContext["ClientSession", Any],
     params: types.CreateMessageRequestParams,
@@ -43,6 +50,12 @@ async def _default_list_roots_callback(
     )
 
 
+async def _default_logging_callback(
+    params: types.LoggingMessageNotificationParams,
+) -> None:
+    pass
+
+
 ClientResponse: TypeAdapter[types.ClientResult | types.ErrorData] = TypeAdapter(
     types.ClientResult | types.ErrorData
 )
@@ -64,6 +77,7 @@ def __init__(
         read_timeout_seconds: timedelta | None = None,
         sampling_callback: SamplingFnT | None = None,
         list_roots_callback: ListRootsFnT | None = None,
+        logging_callback: LoggingFnT | None = None,
     ) -> None:
         super().__init__(
             read_stream,
@@ -74,20 +88,15 @@ def __init__(
         )
         self._sampling_callback = sampling_callback or _default_sampling_callback
         self._list_roots_callback = list_roots_callback or _default_list_roots_callback
+        self._logging_callback = logging_callback or _default_logging_callback
 
     async def initialize(self) -> types.InitializeResult:
-        sampling = (
-            types.SamplingCapability() if self._sampling_callback is not None else None
-        )
-        roots = (
-            types.RootsCapability(
-                # TODO: Should this be based on whether we
-                # _will_ send notifications, or only whether
-                # they're supported?
-                listChanged=True,
-            )
-            if self._list_roots_callback is not None
-            else None
+        sampling = types.SamplingCapability()
+        roots = types.RootsCapability(
+            # TODO: Should this be based on whether we
+            # _will_ send notifications, or only whether
+            # they're supported?
+            listChanged=True,
         )
 
         result = await self.send_request(
@@ -327,3 +336,13 @@ async def _received_request(
                     return await responder.respond(
                         types.ClientResult(root=types.EmptyResult())
                     )
+
+    async def _received_notification(
+        self, notification: types.ServerNotification
+    ) -> None:
+        """Handle notifications from the server."""
+        match notification.root:
+            case types.LoggingMessageNotification(params=params):
+                await self._logging_callback(params)
+            case _:
+                pass

src/mcp/client/session.py

@@ -127,6 +127,10 @@ async def sse_reader(
                                             continue
 
                                         await read_stream_writer.send(message)
+                                    case _:
+                                        logger.warning(
+                                            f"Unknown SSE event: {sse.event}"
+                                        )
                         except Exception as exc:
                             logger.error(f"Error in sse_reader: {exc}")
                             await read_stream_writer.send(exc)

src/mcp/client/sse.py

@@ -1,7 +1,8 @@
 import os
 import sys
 from contextlib import asynccontextmanager
-from typing import Literal
+from pathlib import Path
+from typing import Literal, TextIO
 
 import anyio
 import anyio.lowlevel
@@ -66,6 +67,9 @@ class StdioServerParameters(BaseModel):
     If not specified, the result of get_default_environment() will be used.
     """
 
+    cwd: str | Path | None = None
+    """The working directory to use when spawning the process."""
+
     encoding: str = "utf-8"
     """
     The text encoding used when sending/receiving messages to the server
@@ -83,7 +87,7 @@ class StdioServerParameters(BaseModel):
 
 
 @asynccontextmanager
-async def stdio_client(server: StdioServerParameters):
+async def stdio_client(server: StdioServerParameters, errlog: TextIO = sys.stderr):
     """
     Client transport for stdio: this will connect to a server by spawning a
     process and communicating with it over stdin/stdout.
@@ -99,8 +103,13 @@ async def stdio_client(server: StdioServerParameters):
 
     process = await anyio.open_process(
         [server.command, *server.args],
-        env=server.env if server.env is not None else get_default_environment(),
-        stderr=sys.stderr,
+        env=(
+            {**get_default_environment(), **server.env}
+            if server.env is not None
+            else get_default_environment()
+        ),
+        stderr=errlog,
+        cwd=server.cwd,
     )
 
     async def stdout_reader():

src/mcp/client/stdio.py

@@ -1,7 +1,7 @@
 import json
 import logging
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from typing import AsyncGenerator
 
 import anyio
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
@@ -39,6 +39,11 @@ async def websocket_client(
     # Create two in-memory streams:
     # - One for incoming messages (read_stream, written by ws_reader)
     # - One for outgoing messages (write_stream, read by ws_writer)
+    read_stream: MemoryObjectReceiveStream[types.JSONRPCMessage | Exception]
+    read_stream_writer: MemoryObjectSendStream[types.JSONRPCMessage | Exception]
+    write_stream: MemoryObjectSendStream[types.JSONRPCMessage]
+    write_stream_reader: MemoryObjectReceiveStream[types.JSONRPCMessage]
+
     read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
     write_stream, write_stream_reader = anyio.create_memory_object_stream(0)