transport

@dataclass(frozen=True)
class DispatcherTransport:
    """Explicitly opt into a dispatcher-backed connection instead of message streams.

    Pass this wrapper to `Client` or `ServerRuntime.connect()`. Entering
    `connection` acquires the channel and yields an unstarted dispatcher; the
    SDK owns its receive loop. Exiting releases the channel after the loop
    stops. Native adapters can use their own framing without implementing MCP
    negotiation, validation, callbacks, or a separate client-session API.

    Custom dispatcher implementations remain experimental until the lifecycle
    contract has been validated against native network bindings.
    """

    connection: AbstractAsyncContextManager[Dispatcher[TransportContext]]

class ReadStream(Protocol[T_co]):
    """Protocol for reading items from a stream.

    Consumers that need the sender's context should use
    ``getattr(stream, 'last_context', None)``.
    """

    async def receive(self) -> T_co: ...
    async def aclose(self) -> None: ...
    def __aiter__(self) -> ReadStream[T_co]: ...
    async def __anext__(self) -> T_co: ...
    async def __aenter__(self) -> Self: ...
    async def __aexit__(
        self,
        exc_type: type[BaseException] | None,
        exc_val: BaseException | None,
        exc_tb: TracebackType | None,
    ) -> bool | None: ...

class Transport(AbstractAsyncContextManager[TransportStreams], Protocol):
    """An async context manager yielding a logical peer's read and write streams.

    Entering opens the channel. Exiting closes owned resources and stops its
    background tasks. Consumers may close the streams before context exit, so
    stream closure must be idempotent. Borrowed network clients remain owned by
    their caller.

    Each inbound item is a decoded `SessionMessage` or a recoverable exception.
    End the read stream when the connection is lost; an exception item alone
    does not fail pending requests. Writes must support cancellation and apply
    backpressure instead of buffering indefinitely.

    A stream pair belongs to one logical peer, not an entire broker. The
    adapter owns framing and routing; the SDK owns MCP protocol processing.
    """

class WriteStream(Protocol[T_contra]):
    """Protocol for writing items to a stream."""

    async def send(self, item: T_contra, /) -> None: ...
    async def aclose(self) -> None: ...
    async def __aenter__(self) -> Self: ...
    async def __aexit__(
        self,
        exc_type: type[BaseException] | None,
        exc_val: BaseException | None,
        exc_tb: TracebackType | None,
    ) -> bool | None: ...