Merge branch 'main' into show-server-info

Author: barnuri

.github/workflows/publish-docs-manually.yml

@@ -0,0 +1,32 @@
+name: Publish Docs manually
+
+on:
+  workflow_dispatch:
+
+jobs:
+  docs-publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure Git Credentials
+        run: |
+          git config user.name github-actions[bot]
+          git config user.email 41898282+github-actions[bot]@users.noreply.github.com
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+
+      - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
+      - uses: actions/cache@v4
+        with:
+          key: mkdocs-material-${{ env.cache_id }}
+          path: .cache
+          restore-keys: |
+            mkdocs-material-
+
+      - run: uv sync --frozen --group docs
+      - run: uv run --no-sync mkdocs gh-deploy --force

.github/workflows/publish-pypi.yml

@@ -10,24 +10,24 @@ jobs:
     runs-on: ubuntu-latest
     needs: [checks]
     steps:
-    - uses: actions/checkout@v4
+      - uses: actions/checkout@v4
 
-    - name: Install uv
-      uses: astral-sh/setup-uv@v3
-      with:
-        enable-cache: true
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
 
-    - name: Set up Python 3.12
-      run: uv python install 3.12
+      - name: Set up Python 3.12
+        run: uv python install 3.12
 
-    - name: Build
-      run: uv build
+      - name: Build
+        run: uv build
 
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v4
-      with:
-        name: release-dists
-        path: dist/
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
 
   checks:
     uses: ./.github/workflows/shared.yml
@@ -39,17 +39,17 @@ jobs:
     needs:
       - release-build
     permissions:
-      id-token: write  # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
 
     steps:
-    - name: Retrieve release distributions
-      uses: actions/download-artifact@v4
-      with:
-        name: release-dists
-        path: dist/
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
 
-    - name: Publish package distributions to PyPI
-      uses: pypa/gh-action-pypi-publish@release/v1
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
 
   docs-publish:
     runs-on: ubuntu-latest
@@ -62,16 +62,19 @@ jobs:
         run: |
           git config user.name github-actions[bot]
           git config user.email 41898282+github-actions[bot]@users.noreply.github.com
-      - name: "Set up Python"
-        uses: actions/setup-python@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version-file: ".python-version"
+          enable-cache: true
+
       - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
       - uses: actions/cache@v4
         with:
           key: mkdocs-material-${{ env.cache_id }}
           path: .cache
           restore-keys: |
             mkdocs-material-
+
       - run: uv sync --frozen --group docs
       - run: uv run --no-sync mkdocs gh-deploy --force

examples/clients/simple-chatbot/mcp_simple_chatbot/.env.example

@@ -1 +1 @@
-GROQ_API_KEY=gsk_1234567890
+LLM_API_KEY=gsk_1234567890

mkdocs.yml

@@ -5,6 +5,7 @@ strict: true
 repo_name: modelcontextprotocol/python-sdk
 repo_url: https://github.com/modelcontextprotocol/python-sdk
 edit_uri: edit/main/docs/
+site_url: https://modelcontextprotocol.github.io/python-sdk
 
 # TODO(Marcelo): Add Anthropic copyright?
 # copyright: © Model Context Protocol 2025 to present

src/mcp/client/stdio.py renamed to src/mcp/client/stdio/__init__.py

@@ -12,6 +12,12 @@
 
 import mcp.types as types
 
+from .win32 import (
+    create_windows_process,
+    get_windows_executable_command,
+    terminate_windows_process,
+)
+
 # Environment variables to inherit by default
 DEFAULT_INHERITED_ENV_VARS = (
     [
@@ -101,14 +107,18 @@ async def stdio_client(server: StdioServerParameters, errlog: TextIO = sys.stder
     read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
     write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
 
-    process = await anyio.open_process(
-        [server.command, *server.args],
+    command = _get_executable_command(server.command)
+
+    # Open process with stderr piped for capture
+    process = await _create_platform_compatible_process(
+        command=command,
+        args=server.args,
         env=(
             {**get_default_environment(), **server.env}
             if server.env is not None
             else get_default_environment()
         ),
-        stderr=errlog,
+        errlog=errlog,
         cwd=server.cwd,
     )
 
@@ -159,4 +169,48 @@ async def stdin_writer():
     ):
         tg.start_soon(stdout_reader)
         tg.start_soon(stdin_writer)
-        yield read_stream, write_stream
+        try:
+            yield read_stream, write_stream
+        finally:
+            # Clean up process to prevent any dangling orphaned processes
+            if sys.platform == "win32":
+                await terminate_windows_process(process)
+            else:
+                process.terminate()
+
+
+def _get_executable_command(command: str) -> str:
+    """
+    Get the correct executable command normalized for the current platform.
+
+    Args:
+        command: Base command (e.g., 'uvx', 'npx')
+
+    Returns:
+        str: Platform-appropriate command
+    """
+    if sys.platform == "win32":
+        return get_windows_executable_command(command)
+    else:
+        return command
+
+
+async def _create_platform_compatible_process(
+    command: str,
+    args: list[str],
+    env: dict[str, str] | None = None,
+    errlog: TextIO = sys.stderr,
+    cwd: Path | str | None = None,
+):
+    """
+    Creates a subprocess in a platform-compatible way.
+    Returns a process handle.
+    """
+    if sys.platform == "win32":
+        process = await create_windows_process(command, args, env, errlog, cwd)
+    else:
+        process = await anyio.open_process(
+            [command, *args], env=env, stderr=errlog, cwd=cwd
+        )
+
+    return process

src/mcp/client/stdio/win32.py

@@ -0,0 +1,109 @@
+"""
+Windows-specific functionality for stdio client operations.
+"""
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import TextIO
+
+import anyio
+from anyio.abc import Process
+
+
+def get_windows_executable_command(command: str) -> str:
+    """
+    Get the correct executable command normalized for Windows.
+
+    On Windows, commands might exist with specific extensions (.exe, .cmd, etc.)
+    that need to be located for proper execution.
+
+    Args:
+        command: Base command (e.g., 'uvx', 'npx')
+
+    Returns:
+        str: Windows-appropriate command path
+    """
+    try:
+        # First check if command exists in PATH as-is
+        if command_path := shutil.which(command):
+            return command_path
+
+        # Check for Windows-specific extensions
+        for ext in [".cmd", ".bat", ".exe", ".ps1"]:
+            ext_version = f"{command}{ext}"
+            if ext_path := shutil.which(ext_version):
+                return ext_path
+
+        # For regular commands or if we couldn't find special versions
+        return command
+    except OSError:
+        # Handle file system errors during path resolution
+        # (permissions, broken symlinks, etc.)
+        return command
+
+
+async def create_windows_process(
+    command: str,
+    args: list[str],
+    env: dict[str, str] | None = None,
+    errlog: TextIO = sys.stderr,
+    cwd: Path | str | None = None,
+):
+    """
+    Creates a subprocess in a Windows-compatible way.
+
+    Windows processes need special handling for console windows and
+    process creation flags.
+
+    Args:
+        command: The command to execute
+        args: Command line arguments
+        env: Environment variables
+        errlog: Where to send stderr output
+        cwd: Working directory for the process
+
+    Returns:
+        A process handle
+    """
+    try:
+        # Try with Windows-specific flags to hide console window
+        process = await anyio.open_process(
+            [command, *args],
+            env=env,
+            # Ensure we don't create console windows for each process
+            creationflags=subprocess.CREATE_NO_WINDOW  # type: ignore
+            if hasattr(subprocess, "CREATE_NO_WINDOW")
+            else 0,
+            stderr=errlog,
+            cwd=cwd,
+        )
+        return process
+    except Exception:
+        # Don't raise, let's try to create the process without creation flags
+        process = await anyio.open_process(
+            [command, *args], env=env, stderr=errlog, cwd=cwd
+        )
+        return process
+
+
+async def terminate_windows_process(process: Process):
+    """
+    Terminate a Windows process.
+
+    Note: On Windows, terminating a process with process.terminate() doesn't
+    always guarantee immediate process termination.
+    So we give it 2s to exit, or we call process.kill()
+    which sends a SIGKILL equivalent signal.
+
+    Args:
+        process: The process to terminate
+    """
+    try:
+        process.terminate()
+        with anyio.fail_after(2.0):
+            await process.wait()
+    except TimeoutError:
+        # Force kill if it doesn't terminate
+        process.kill()

src/mcp/server/fastmcp/utilities/func_metadata.py

@@ -88,7 +88,7 @@ def pre_parse_json(self, data: dict[str, Any]) -> dict[str, Any]:
                     pre_parsed = json.loads(data[field_name])
                 except json.JSONDecodeError:
                     continue  # Not JSON - skip
-                if isinstance(pre_parsed, str):
+                if isinstance(pre_parsed, str | int | float):
                     # This is likely that the raw value is e.g. `"hello"` which we
                     # Should really be parsed as '"hello"' in Python - but if we parse
                     # it as JSON it'll turn into just 'hello'. So we skip it.

src/mcp/server/lowlevel/server.py

@@ -301,7 +301,7 @@ def create_content(data: str | bytes, mime_type: str | None):
 
                             return types.BlobResourceContents(
                                 uri=req.params.uri,
-                                blob=base64.urlsafe_b64encode(data).decode(),
+                                blob=base64.b64encode(data).decode(),
                                 mimeType=mime_type or "application/octet-stream",
                             )