further modifications to fix pyright errors

Author: sreenithi

docs/migration.md

@@ -550,9 +550,14 @@ from mcp.shared._context import SessionT
 from mcp.shared._context import SessionT_co
 ```
 
-#### `AbstractBaseSession` simplified
+#### New `AbstractBaseSession` structural interface
 
-`AbstractBaseSession` is now a pure abstract interface with no `__init__` method and no `WireMessageT` type parameter. If you were subclassing it directly, you now need to manage all state in your subclass.
+The session hierarchy now uses a new **runtime-checkable Protocol** called `AbstractBaseSession` to define the shared contract for all MCP sessions. This protocol enables structural subtyping, allowing different transport implementations to be used interchangeably without requiring rigid inheritance.
+
+Key characteristics of `AbstractBaseSession`:
+1.  **Pure Interface**: It is a structural protocol with no implementation state or `__init__` method.
+2.  **Simplified Type Parameters**: It takes two parameters: `AbstractBaseSession[SendRequestT, SendNotificationT]`. Contravariant variance is used for these parameters to ensure that sessions can be used safely in generic contexts (like `RequestContext`).
+3.  **BaseSession Implementation**: The concrete implementation logic (state management, response routing) is provided by the `BaseSession` class, which satisfies the protocol.
 
 **Before:**
 
@@ -575,6 +580,56 @@ class MySession(AbstractBaseSession[...]):
         self._my_state = {}
 ```
 
+#### `SendRequestT` changed to contravariant
+
+The `SendRequestT` TypeVar is now defined as **contravariant** to support its use in the `AbstractBaseSession` Protocol.
+
+**Before:**
+
+```python
+SendRequestT = TypeVar("SendRequestT", ClientRequest, ServerRequest)
+```
+
+**After:**
+
+```python
+SendRequestT = TypeVar("SendRequestT", ClientRequest, ServerRequest, contravariant=True)
+```
+
+#### `SendNotificationT` changed to contravariant
+
+The `SendNotificationT` TypeVar is now defined as **contravariant** to support its use in the `AbstractBaseSession` Protocol.
+
+**Before:**
+
+```python
+SendNotificationT = TypeVar("SendNotificationT", ClientNotification, ServerNotification)
+```
+
+**After:**
+
+```python
+SendNotificationT = TypeVar(
+    "SendNotificationT", ClientNotification, ServerNotification, contravariant=True
+)
+```
+
+#### `ReceiveResultT` changed to covariant
+
+The `ReceiveResultT` TypeVar is now defined as **covariant** to support its use in the `AbstractBaseSession` Protocol.
+
+**Before:**
+
+```python
+ReceiveResultT = TypeVar("ReceiveResultT", bound=BaseModel)
+```
+
+**After:**
+
+```python
+ReceiveResultT = TypeVar("ReceiveResultT", bound=BaseModel, covariant=True)
+```
+
 #### `BaseClientSession` is now a Protocol
 
 `BaseClientSession` is now a `typing.Protocol` (structural subtyping) instead of an abstract base class. It no longer inherits from `AbstractBaseSession` and requires no inheritance to satisfy.

src/mcp/client/base_client_session.py

@@ -6,7 +6,7 @@
 from mcp.shared.session import ProgressFnT
 from mcp.types._types import RequestParamsMeta
 
-ClientSessionT_contra = TypeVar("ClientSessionT_contra", contravariant=True)
+ClientSessionT_contra = TypeVar("ClientSessionT_contra", bound="BaseClientSession", contravariant=True)
 
 
 @runtime_checkable

src/mcp/shared/_context.py

@@ -1,13 +1,17 @@
 """Request context for MCP handlers."""
 
 from dataclasses import dataclass
-from typing import Generic
-
+from typing import TYPE_CHECKING, Generic, Any
 from typing_extensions import TypeVar
 
+if TYPE_CHECKING:
+    from mcp.shared.session import AbstractBaseSession
+
 from mcp.types import RequestId, RequestParamsMeta
 
-SessionT_co = TypeVar("SessionT_co", covariant=True)
+SessionT_co = TypeVar(
+    "SessionT_co", bound="AbstractBaseSession[Any, Any]", covariant=True
+)
 
 
 @dataclass(kw_only=True)

src/mcp/shared/session.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from abc import ABC, abstractmethod
 from collections.abc import Callable
 from contextlib import AsyncExitStack
 from types import TracebackType
@@ -10,7 +9,7 @@
 import anyio
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from pydantic import BaseModel, TypeAdapter
-from typing_extensions import Self
+from typing_extensions import Protocol, Self, runtime_checkable
 
 from mcp.shared.exceptions import MCPError
 from mcp.shared.message import MessageMetadata, ServerMessageMetadata, SessionMessage
@@ -36,11 +35,13 @@
     ServerResult,
 )
 
-SendRequestT = TypeVar("SendRequestT", ClientRequest, ServerRequest)
+SendRequestT = TypeVar("SendRequestT", ClientRequest, ServerRequest, contravariant=True)
 SendResultT = TypeVar("SendResultT", ClientResult, ServerResult)
-SendNotificationT = TypeVar("SendNotificationT", ClientNotification, ServerNotification)
+SendNotificationT = TypeVar(
+    "SendNotificationT", ClientNotification, ServerNotification, contravariant=True
+)
 ReceiveRequestT = TypeVar("ReceiveRequestT", ClientRequest, ServerRequest)
-ReceiveResultT = TypeVar("ReceiveResultT", bound=BaseModel)
+ReceiveResultT = TypeVar("ReceiveResultT", bound=BaseModel, covariant=True)
 ReceiveNotificationT = TypeVar("ReceiveNotificationT", ClientNotification, ServerNotification)
 
 RequestId = str | int
@@ -155,24 +156,20 @@ def cancelled(self) -> bool:
         return self._cancel_scope.cancel_called
 
 
+@runtime_checkable
 class AbstractBaseSession(
-    ABC,
+    Protocol,
     Generic[
         SendRequestT,
         SendNotificationT,
-        SendResultT,
-        ReceiveRequestT,
-        ReceiveNotificationT,
     ],
 ):
     """Pure abstract interface for MCP sessions.
 
-    This class defines the contract that all session implementations must satisfy,
-    without managing any state. Subclasses are responsible for their own initialization
-    and state management.
+    This protocol defines the contract that all session implementations must satisfy,
+    irrespective of the transport used.
     """
 
-    @abstractmethod
     async def send_request(
         self,
         request: SendRequestT,
@@ -188,18 +185,16 @@ async def send_request(
 
         Do not use this method to emit notifications! Use send_notification() instead.
         """
-        raise NotImplementedError
+        ...
 
-    @abstractmethod
     async def send_notification(
         self,
         notification: SendNotificationT,
         related_request_id: RequestId | None = None,
     ) -> None:
         """Emits a notification, which is a one-way message that does not expect a response."""
-        raise NotImplementedError
+        ...
 
-    @abstractmethod
     async def send_progress_notification(
         self,
         progress_token: ProgressToken,
@@ -208,13 +203,17 @@ async def send_progress_notification(
         message: str | None = None,
     ) -> None:
         """Sends a progress notification for a request that is currently being processed."""
-        raise NotImplementedError
+        ...
 
 
 class BaseSession(
     AbstractBaseSession[
         SendRequestT,
         SendNotificationT,
+    ],
+    Generic[
+        SendRequestT,
+        SendNotificationT,
         SendResultT,
         ReceiveRequestT,
         ReceiveNotificationT,