Merge branch 'main' into main

Author: PratyushNag

examples/clients/simple-auth-client/README.md

@@ -1,11 +1,11 @@
 # Simple Auth Client Example
 
-A demonstration of how to use the MCP Python SDK with OAuth authentication over streamable HTTP transport.
+A demonstration of how to use the MCP Python SDK with OAuth authentication over streamable HTTP or SSE transport.
 
 ## Features
 
 - OAuth 2.0 authentication with PKCE
-- Streamable HTTP transport  
+- Support for both StreamableHTTP and SSE transports
 - Interactive command-line interface
 
 ## Installation
@@ -31,7 +31,10 @@ uv run mcp-simple-auth --transport streamable-http --port 3001
 uv run mcp-simple-auth-client
 
 # Or with custom server URL
-MCP_SERVER_URL=http://localhost:3001 uv run mcp-simple-auth-client
+MCP_SERVER_PORT=3001 uv run mcp-simple-auth-client
+
+# Use SSE transport
+MCP_TRANSPORT_TYPE=sse uv run mcp-simple-auth-client
 ```
 
 ### 3. Complete OAuth flow
@@ -67,4 +70,5 @@ mcp> quit
 
 ## Configuration
 
-- `MCP_SERVER_URL` - Server URL (default: http://localhost:3001)
+- `MCP_SERVER_PORT` - Server URL (default: 8000)
+- `MCP_TRANSPORT_TYPE` - Transport type: `streamable_http` (default) or `sse`

examples/clients/simple-auth-client/mcp_simple_auth_client/main.py

@@ -18,6 +18,7 @@
 
 from mcp.client.auth import OAuthClientProvider, TokenStorage
 from mcp.client.session import ClientSession
+from mcp.client.sse import sse_client
 from mcp.client.streamable_http import streamablehttp_client
 from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAuthToken
 
@@ -149,8 +150,9 @@ def get_state(self):
 class SimpleAuthClient:
     """Simple MCP client with auth support."""
 
-    def __init__(self, server_url: str):
+    def __init__(self, server_url: str, transport_type: str = "streamable_http"):
         self.server_url = server_url
+        self.transport_type = transport_type
         self.session: ClientSession | None = None
 
     async def connect(self):
@@ -195,38 +197,48 @@ async def _default_redirect_handler(authorization_url: str) -> None:
                 callback_handler=callback_handler,
             )
 
-            # Create streamable HTTP transport with auth handler
-            stream_context = streamablehttp_client(
-                url=self.server_url,
-                auth=oauth_auth,
-                timeout=timedelta(seconds=60),
-            )
-
-            print(
-                "📡 Opening transport connection (HTTPX handles auth automatically)..."
-            )
-            async with stream_context as (read_stream, write_stream, get_session_id):
-                print("🤝 Initializing MCP session...")
-                async with ClientSession(read_stream, write_stream) as session:
-                    self.session = session
-                    print("⚡ Starting session initialization...")
-                    await session.initialize()
-                    print("✨ Session initialization complete!")
-
-                    print(f"\n✅ Connected to MCP server at {self.server_url}")
-                    session_id = get_session_id()
-                    if session_id:
-                        print(f"Session ID: {session_id}")
-
-                    # Run interactive loop
-                    await self.interactive_loop()
+            # Create transport with auth handler based on transport type
+            if self.transport_type == "sse":
+                print("📡 Opening SSE transport connection with auth...")
+                async with sse_client(
+                    url=self.server_url,
+                    auth=oauth_auth,
+                    timeout=60,
+                ) as (read_stream, write_stream):
+                    await self._run_session(read_stream, write_stream, None)
+            else:
+                print("📡 Opening StreamableHTTP transport connection with auth...")
+                async with streamablehttp_client(
+                    url=self.server_url,
+                    auth=oauth_auth,
+                    timeout=timedelta(seconds=60),
+                ) as (read_stream, write_stream, get_session_id):
+                    await self._run_session(read_stream, write_stream, get_session_id)
 
         except Exception as e:
             print(f"❌ Failed to connect: {e}")
             import traceback
 
             traceback.print_exc()
 
+    async def _run_session(self, read_stream, write_stream, get_session_id):
+        """Run the MCP session with the given streams."""
+        print("🤝 Initializing MCP session...")
+        async with ClientSession(read_stream, write_stream) as session:
+            self.session = session
+            print("⚡ Starting session initialization...")
+            await session.initialize()
+            print("✨ Session initialization complete!")
+
+            print(f"\n✅ Connected to MCP server at {self.server_url}")
+            if get_session_id:
+                session_id = get_session_id()
+                if session_id:
+                    print(f"Session ID: {session_id}")
+
+            # Run interactive loop
+            await self.interactive_loop()
+
     async def list_tools(self):
         """List available tools from the server."""
         if not self.session:
@@ -326,13 +338,20 @@ async def main():
     """Main entry point."""
     # Default server URL - can be overridden with environment variable
     # Most MCP streamable HTTP servers use /mcp as the endpoint
-    server_url = os.getenv("MCP_SERVER_URL", "http://localhost:8000/mcp")
+    server_url = os.getenv("MCP_SERVER_PORT", 8000)
+    transport_type = os.getenv("MCP_TRANSPORT_TYPE", "streamable_http")
+    server_url = (
+        f"http://localhost:{server_url}/mcp"
+        if transport_type == "streamable_http"
+        else f"http://localhost:{server_url}/sse"
+    )
 
     print("🚀 Simple MCP Auth Client")
     print(f"Connecting to: {server_url}")
+    print(f"Transport type: {transport_type}")
 
     # Start connection flow - OAuth will be handled automatically
-    client = SimpleAuthClient(server_url)
+    client = SimpleAuthClient(server_url, transport_type)
     await client.connect()
 
 

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}")
 

examples/servers/simple-prompt/mcp_simple_prompt/server.py

@@ -114,7 +114,7 @@ async def handle_sse(request):
 
         import uvicorn
 
-        uvicorn.run(starlette_app, host="0.0.0.0", port=port)
+        uvicorn.run(starlette_app, host="127.0.0.1", port=port)
     else:
         from mcp.server.stdio import stdio_server
 

examples/servers/simple-resource/mcp_simple_resource/server.py

@@ -72,7 +72,7 @@ async def handle_sse(request):
 
         import uvicorn
 
-        uvicorn.run(starlette_app, host="0.0.0.0", port=port)
+        uvicorn.run(starlette_app, host="127.0.0.1", port=port)
     else:
         from mcp.server.stdio import stdio_server
 

examples/servers/simple-streamablehttp-stateless/mcp_simple_streamablehttp_stateless/server.py

@@ -136,6 +136,6 @@ async def lifespan(app: Starlette) -> AsyncIterator[None]:
 
     import uvicorn
 
-    uvicorn.run(starlette_app, host="0.0.0.0", port=port)
+    uvicorn.run(starlette_app, host="127.0.0.1", port=port)
 
     return 0

examples/servers/simple-streamablehttp/mcp_simple_streamablehttp/server.py

@@ -164,6 +164,6 @@ async def lifespan(app: Starlette) -> AsyncIterator[None]:
 
     import uvicorn
 
-    uvicorn.run(starlette_app, host="0.0.0.0", port=port)
+    uvicorn.run(starlette_app, host="127.0.0.1", port=port)
 
     return 0

examples/servers/simple-tool/mcp_simple_tool/server.py

@@ -84,7 +84,7 @@ async def handle_sse(request):
 
         import uvicorn
 
-        uvicorn.run(starlette_app, host="0.0.0.0", port=port)
+        uvicorn.run(starlette_app, host="127.0.0.1", port=port)
     else:
         from mcp.server.stdio import stdio_server
 

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/session.py

@@ -209,7 +209,9 @@ async def list_resources(
             types.ClientRequest(
                 types.ListResourcesRequest(
                     method="resources/list",
-                    cursor=cursor,
+                    params=types.PaginatedRequestParams(cursor=cursor)
+                    if cursor is not None
+                    else None,
                 )
             ),
             types.ListResourcesResult,
@@ -223,7 +225,9 @@ async def list_resource_templates(
             types.ClientRequest(
                 types.ListResourceTemplatesRequest(
                     method="resources/templates/list",
-                    cursor=cursor,
+                    params=types.PaginatedRequestParams(cursor=cursor)
+                    if cursor is not None
+                    else None,
                 )
             ),
             types.ListResourceTemplatesResult,
@@ -295,7 +299,9 @@ async def list_prompts(self, cursor: str | None = None) -> types.ListPromptsResu
             types.ClientRequest(
                 types.ListPromptsRequest(
                     method="prompts/list",
-                    cursor=cursor,
+                    params=types.PaginatedRequestParams(cursor=cursor)
+                    if cursor is not None
+                    else None,
                 )
             ),
             types.ListPromptsResult,
@@ -340,7 +346,9 @@ async def list_tools(self, cursor: str | None = None) -> types.ListToolsResult:
             types.ClientRequest(
                 types.ListToolsRequest(
                     method="tools/list",
-                    cursor=cursor,
+                    params=types.PaginatedRequestParams(cursor=cursor)
+                    if cursor is not None
+                    else None,
                 )
             ),
             types.ListToolsResult,

src/mcp/client/session_group.py

@@ -77,10 +77,10 @@ class ClientSessionGroup:
     the client and can be accessed via the session.
 
     Example Usage:
-        name_fn = lambda name, server_info: f"{(server_info.name)}-{name}"
+        name_fn = lambda name, server_info: f"{(server_info.name)}_{name}"
         async with ClientSessionGroup(component_name_hook=name_fn) as group:
             for server_params in server_params:
-                group.connect_to_server(server_param)
+                await group.connect_to_server(server_param)
             ...
 
     """
@@ -145,14 +145,15 @@ async def __aexit__(
     ) -> bool | None:
         """Closes session exit stacks and main exit stack upon completion."""
 
+        # Only close the main exit stack if we created it
+        if self._owns_exit_stack:
+            await self._exit_stack.aclose()
+
         # Concurrently close session stacks.
         async with anyio.create_task_group() as tg:
             for exit_stack in self._session_exit_stacks.values():
                 tg.start_soon(exit_stack.aclose)
 
-        # Only close the main exit stack if we created it
-        if self._owns_exit_stack:
-            await self._exit_stack.aclose()
 
     @property
     def sessions(self) -> list[mcp.ClientSession]:

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,12 +26,21 @@ 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,
 ):
     """
     Client transport for SSE.
 
     `sse_read_timeout` determines how long (in seconds) the client will wait for a new
     event before disconnecting. All other HTTP operations are controlled by `timeout`.
+
+    Args:
+        url: The SSE endpoint URL.
+        headers: Optional headers to include in requests.
+        timeout: HTTP timeout for regular operations.
+        sse_read_timeout: Timeout for SSE read operations.
+        auth: Optional HTTPX authentication handler.
     """
     read_stream: MemoryObjectReceiveStream[SessionMessage | Exception]
     read_stream_writer: MemoryObjectSendStream[SessionMessage | Exception]
@@ -45,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) 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