import gc
import io
import os
import sys
import threading
from collections.abc import AsyncIterator, Iterator
from contextlib import asynccontextmanager, contextmanager
from io import TextIOWrapper

import anyio
import anyio.to_thread
import pytest
from mcp_types import (
    CLIENT_CAPABILITIES_META_KEY,
    CLIENT_INFO_META_KEY,
    PROTOCOL_VERSION_META_KEY,
    SERVER_INFO_META_KEY,
    JSONRPCMessage,
    JSONRPCRequest,
    JSONRPCResponse,
    jsonrpc_message_adapter,
)
from typing_extensions import Buffer

from mcp.server.mcpserver import MCPServer
from mcp.server.stdio import stdio_server
from mcp.shared.message import SessionMessage


@pytest.mark.anyio
async def test_stdio_server_round_trips_messages_over_injected_streams() -> None:
    """stdio_server frames JSON-RPC messages as one line each in both directions."""
    stdin = io.StringIO()
    stdout = io.StringIO()

    messages = [
        JSONRPCRequest(jsonrpc="2.0", id=1, method="ping"),
        JSONRPCResponse(jsonrpc="2.0", id=2, result={}),
    ]

    for message in messages:
        stdin.write(message.model_dump_json(by_alias=True, exclude_none=True) + "\n")
    stdin.seek(0)

    with anyio.fail_after(5):
        async with stdio_server(stdin=anyio.AsyncFile(stdin), stdout=anyio.AsyncFile(stdout)) as (
            read_stream,
            write_stream,
        ):
            async with read_stream:
                received_messages: list[JSONRPCMessage] = []
                for _ in range(2):
                    received = await read_stream.receive()
                    assert not isinstance(received, Exception)
                    received_messages.append(received.message)

            assert received_messages[0] == JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")
            assert received_messages[1] == JSONRPCResponse(jsonrpc="2.0", id=2, result={})

            responses = [
                JSONRPCRequest(jsonrpc="2.0", id=3, method="ping"),
                JSONRPCResponse(jsonrpc="2.0", id=4, result={}),
            ]

            for response in responses:
                await write_stream.send(SessionMessage(response))
            await write_stream.aclose()

    stdout.seek(0)
    output_lines = stdout.readlines()
    assert len(output_lines) == 2

    received_responses = [jsonrpc_message_adapter.validate_json(line.strip()) for line in output_lines]
    assert received_responses[0] == JSONRPCRequest(jsonrpc="2.0", id=3, method="ping")
    assert received_responses[1] == JSONRPCResponse(jsonrpc="2.0", id=4, result={})


@pytest.mark.anyio
async def test_stdio_server_invalid_utf8(monkeypatch: pytest.MonkeyPatch) -> None:
    """Non-UTF-8 stdin bytes surface as an in-stream exception without killing the stream."""
    valid = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")
    raw_stdin = io.BytesIO(b"\xff\xfe\n" + valid.model_dump_json(by_alias=True, exclude_none=True).encode() + b"\n")

    # stdio_server()'s default path wraps sys.stdin.buffer with errors='replace'.
    monkeypatch.setattr(sys, "stdin", TextIOWrapper(raw_stdin, encoding="utf-8"))
    monkeypatch.setattr(sys, "stdout", TextIOWrapper(io.BytesIO(), encoding="utf-8"))

    with anyio.fail_after(5):
        async with stdio_server() as (read_stream, write_stream):
            await write_stream.aclose()
            async with read_stream:  # pragma: no branch
                first = await read_stream.receive()
                assert isinstance(first, Exception)

                second = await read_stream.receive()
                assert isinstance(second, SessionMessage)
                assert second.message == valid


@contextmanager
def _pipe_planted_on_fd0(monkeypatch: pytest.MonkeyPatch) -> Iterator[tuple[int, int]]:
    """Plants a fresh pipe on fd 0 and rebinds sys.stdin over it; yields (read_fd, write_fd).

    Close ownership: the caller closes the write end exactly once; the helper closes only what
    it created - a double close lands on a recycled fd and destroys whatever unrelated file now
    lives there (pytest's capture files). os.dup2 is captured up front to survive monkeypatching.
    """
    real_dup2 = os.dup2
    in_r, in_w = os.pipe()
    saved0 = os.dup(0)
    os.dup2(in_r, 0)
    # Created after the plant so its cached stream state describes the pipe.
    stdin_double = TextIOWrapper(open(0, "rb", closefd=False), encoding="utf-8")
    try:
        monkeypatch.setattr(sys, "stdin", stdin_double)
        yield in_r, in_w
    finally:
        stdin_double.close()
        real_dup2(saved0, 0)
        os.close(saved0)
        os.close(in_r)


@contextmanager
def _pipe_planted_on_fd1(monkeypatch: pytest.MonkeyPatch) -> Iterator[tuple[int, int]]:
    """Like _pipe_planted_on_fd0 but plants fd 1 and rebinds sys.stdout; yields (read_fd, write_fd)."""
    real_dup2 = os.dup2
    out_r, out_w = os.pipe()
    saved1 = os.dup(1)
    os.dup2(out_w, 1)
    stdout_double = TextIOWrapper(open(1, "wb", closefd=False), encoding="utf-8")
    try:
        monkeypatch.setattr(sys, "stdout", stdout_double)
        yield out_r, out_w
    finally:
        stdout_double.close()
        real_dup2(saved1, 1)
        os.close(saved1)
        os.close(out_r)
        os.close(out_w)


@contextmanager
def _pipe_planted_on_fd2() -> Iterator[int]:
    """Like _pipe_planted_on_fd0 but plants fd 2 to observe the stdout diversion; yields the read end."""
    real_dup2 = os.dup2
    err_r, err_w = os.pipe()
    saved2 = os.dup(2)
    try:
        os.dup2(err_w, 2)
        yield err_r
    finally:
        real_dup2(saved2, 2)
        os.close(saved2)
        os.close(err_r)
        os.close(err_w)


def _frame(message: JSONRPCRequest | JSONRPCResponse) -> bytes:
    """One JSON-RPC message as the newline-terminated wire line the transport reads."""
    return (message.model_dump_json(by_alias=True, exclude_none=True) + "\n").encode()


async def _read_from(fd: int) -> bytes:
    """One os.read from fd, in a worker thread.

    A regression can leave the pipe empty; abandoning turns a read that would outlive
    fail_after on the loop thread into a red TimeoutError instead.
    """
    return await anyio.to_thread.run_sync(os.read, fd, 65536, abandon_on_cancel=True)


@pytest.mark.anyio
async def test_stdio_server_takes_stdin_off_the_descriptor_table_while_serving(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """On the real process stdin, the transport claims the protocol pipe and releases it on exit.

    SDK-defined behavior: while serving, fd 0 is the null device, so an inheriting child
    cannot consume protocol bytes or, on Windows, hang at startup (CPython gh-78961).
    """
    with _pipe_planted_on_fd0(monkeypatch) as (in_r, in_w):
        out_r, out_w = os.pipe()
        stdout_double = TextIOWrapper(open(out_w, "wb", closefd=False), encoding="utf-8")
        try:
            monkeypatch.setattr(sys, "stdout", stdout_double)

            request = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")
            response = JSONRPCResponse(jsonrpc="2.0", id=1, result={})
            with anyio.fail_after(5):
                async with stdio_server() as (read_stream, write_stream):
                    async with read_stream:
                        # fd 0 is the null device: instant EOF instead of protocol bytes.
                        assert await anyio.to_thread.run_sync(os.read, 0, 1, abandon_on_cancel=True) == b""

                        os.write(in_w, _frame(request))
                        received = await read_stream.receive()
                        assert isinstance(received, SessionMessage)
                        assert received.message == request

                        await write_stream.send(SessionMessage(response))
                        line = await _read_from(out_r)
                        assert jsonrpc_message_adapter.validate_json(line.decode().strip()) == response

                        os.close(in_w)  # EOF lets the reader finish so the context can exit
                        await write_stream.aclose()

                # samestat is trivially-true for pipes on Windows; POSIX legs carry these assertions.
                assert os.path.sameopenfile(0, in_r)
        finally:
            stdout_double.close()
            os.close(out_r)
            os.close(out_w)


@pytest.mark.anyio
@pytest.mark.parametrize("failing_call", ["dup", "dup2", "dup2_destroys_target"])
async def test_stdio_server_reads_stdin_in_place_when_descriptor_isolation_fails(
    failing_call: str, monkeypatch: pytest.MonkeyPatch
) -> None:
    """A descriptor failure while claiming stdin degrades to reading sys.stdin in place.

    SDK-defined behavior: isolation is best-effort; when duplicating fd 0 or diverting
    it fails, the transport serves over the original stdin exactly as v1 did. A dup2
    that closes its target before failing (Windows UCRT) still leaves fd 0 on the wire.
    """
    request = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")
    with _pipe_planted_on_fd0(monkeypatch) as (in_r, in_w):
        os.write(in_w, _frame(request))
        os.close(in_w)
        monkeypatch.setattr(sys, "stdout", TextIOWrapper(io.BytesIO(), encoding="utf-8"))

        if failing_call == "dup":

            def failing_dup_above_std(fd: int) -> int:
                raise OSError("injected descriptor failure")

            monkeypatch.setattr("mcp.server.stdio._dup_above_std", failing_dup_above_std)
        else:
            # Fires once at the divert, then passes through: pytest's capture
            # machinery also calls os.dup2 at phase transitions. The destroying
            # variant closes the target first, as Windows UCRT dup2 does.
            real_dup2 = os.dup2
            armed = [True]

            def failing_dup2(fd: int, fd2: int, inheritable: bool = True) -> int:
                if armed[0]:
                    armed[0] = False
                    if failing_call == "dup2_destroys_target":
                        os.close(fd2)
                    raise OSError("injected descriptor failure")
                return real_dup2(fd, fd2, inheritable)

            monkeypatch.setattr(os, "dup2", failing_dup2)

        with anyio.fail_after(5):
            async with stdio_server() as (read_stream, write_stream):  # pragma: no branch
                async with read_stream:  # pragma: no branch
                    # Isolation was skipped: fd 0 is still the protocol pipe.
                    assert os.path.sameopenfile(0, in_r)
                    received = await read_stream.receive()
                    assert isinstance(received, SessionMessage)
                    assert received.message == request
                    await write_stream.aclose()


@pytest.mark.anyio
async def test_stdio_server_exits_cleanly_when_the_stdin_restore_fails(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """A failed fd 0 restore on exit is swallowed, not raised, and the fd stays claimed.

    SDK-defined behavior: the restore must never mask what ended the transport, and a
    still-diverted fd must refuse later transports rather than serve them the diversion.
    """
    request = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")
    monkeypatch.setattr("mcp.server.stdio._claims", {})  # this test leaves fd 0 claimed
    with _pipe_planted_on_fd0(monkeypatch) as (_, in_w):
        os.write(in_w, _frame(request))
        os.close(in_w)
        monkeypatch.setattr(sys, "stdout", TextIOWrapper(io.BytesIO(), encoding="utf-8"))

        # The claim's dup2 (first call) succeeds; only the restore's (second) fails.
        real_dup2 = os.dup2
        dup2_calls: list[tuple[int, int]] = []

        def flaky_dup2(fd: int, fd2: int, inheritable: bool = True) -> int:
            dup2_calls.append((fd, fd2))
            if len(dup2_calls) == 2:
                raise OSError("injected restore failure")
            return real_dup2(fd, fd2, inheritable)

        monkeypatch.setattr(os, "dup2", flaky_dup2)

        with anyio.fail_after(5):
            async with stdio_server() as (read_stream, write_stream):  # pragma: no branch
                async with read_stream:  # pragma: no branch
                    received = await read_stream.receive()
                    assert isinstance(received, SessionMessage)
                    assert received.message == request
                    await write_stream.aclose()

        # Restore attempted (second dup2), failure swallowed, fd 0 left on the null device.
        assert dup2_calls[1] == (dup2_calls[1][0], 0)
        devnull_probe = os.open(os.devnull, os.O_RDONLY)
        try:
            assert os.path.sameopenfile(0, devnull_probe)
        finally:
            os.close(devnull_probe)

        # The still-diverted fd stays claimed: a later transport is refused,
        # not handed the null device as its wire.
        with pytest.raises(RuntimeError, match="already claimed fd 0"):
            async with stdio_server():
                pytest.fail("unreachable")  # pragma: no cover


@pytest.mark.anyio
async def test_stdio_server_takes_stdout_off_the_descriptor_table_while_serving(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """On the real process stdout, the transport claims the wire and diverts fd 1 to stderr.

    SDK-defined behavior: stray writes to fd 1 land in the client's log, not the JSON-RPC stream.
    """
    response = JSONRPCResponse(jsonrpc="2.0", id=1, result={})
    with _pipe_planted_on_fd1(monkeypatch) as (out_r, out_w), _pipe_planted_on_fd2() as err_r:
        with anyio.fail_after(5):
            async with stdio_server(stdin=anyio.AsyncFile(io.StringIO())) as (read_stream, write_stream):
                read_stream.close()
                os.write(1, b"stray child output\n")
                assert await _read_from(err_r) == b"stray child output\n"

                # The text layer writes os.linesep, hence CRLF on Windows.
                print("stray print", flush=True)
                assert await _read_from(err_r) == b"stray print" + os.linesep.encode()

                await write_stream.send(SessionMessage(response))
                line = await _read_from(out_r)
                assert jsonrpc_message_adapter.validate_json(line.decode().strip()) == response

                await write_stream.aclose()

        assert os.path.sameopenfile(1, out_w)


@pytest.mark.anyio
async def test_stdio_server_diverts_stdout_to_the_null_device_when_stderr_is_unusable(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """When stderr cannot be duplicated, fd 1 is diverted to the null device instead.

    SDK-defined behavior: a process with unusable fd 2 still gets stdout claimed; the wire stays pure.
    """
    response = JSONRPCResponse(jsonrpc="2.0", id=1, result={})
    with _pipe_planted_on_fd1(monkeypatch) as (out_r, out_w):
        # One-shot injector, as in the isolation-failure test.
        real_dup = os.dup
        armed = [True]

        def failing_dup(fd: int) -> int:
            if fd == 2 and armed[0]:
                armed[0] = False
                raise OSError("injected stderr failure")
            return real_dup(fd)

        monkeypatch.setattr(os, "dup", failing_dup)

        with anyio.fail_after(5):
            async with stdio_server(stdin=anyio.AsyncFile(io.StringIO())) as (read_stream, write_stream):
                read_stream.close()
                # The spent injector passes later duplications through untouched.
                os.close(os.dup(0))
                devnull_probe = os.open(os.devnull, os.O_WRONLY)
                try:
                    assert os.path.sameopenfile(1, devnull_probe)
                finally:
                    os.close(devnull_probe)

                os.write(1, b"discarded\n")
                await write_stream.send(SessionMessage(response))
                line = await _read_from(out_r)
                assert jsonrpc_message_adapter.validate_json(line.decode().strip()) == response
                await write_stream.aclose()

        assert os.path.sameopenfile(1, out_w)


@pytest.mark.anyio
async def test_a_second_stdio_server_on_the_same_process_streams_is_refused(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """A concurrent stdio_server() on already-claimed streams raises instead of contending."""
    request = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")
    response = JSONRPCResponse(jsonrpc="2.0", id=1, result={})
    with _pipe_planted_on_fd0(monkeypatch) as (in_r, in_w), _pipe_planted_on_fd1(monkeypatch) as (out_r, out_w):
        with anyio.fail_after(5):
            async with stdio_server() as (read_stream, write_stream):
                async with read_stream:  # pragma: no branch
                    with pytest.raises(RuntimeError, match="already claimed fd 0"):
                        async with stdio_server():
                            pytest.fail("unreachable")  # pragma: no cover

                    os.write(in_w, _frame(request))
                    received = await read_stream.receive()
                    assert isinstance(received, SessionMessage)
                    assert received.message == request
                    await write_stream.send(SessionMessage(response))
                    line = await _read_from(out_r)
                    assert jsonrpc_message_adapter.validate_json(line.decode().strip()) == response
                    os.close(in_w)
                    await write_stream.aclose()

        assert os.path.sameopenfile(0, in_r)
        assert os.path.sameopenfile(1, out_w)


@pytest.mark.anyio
async def test_a_refused_claim_releases_the_stream_it_already_took(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """A transport refused halfway through claiming restores what it claimed first.

    The first transport claims only stdout; the second claims stdin, is refused on stdout, and must release stdin.
    """
    with _pipe_planted_on_fd0(monkeypatch) as (in_r, in_w), _pipe_planted_on_fd1(monkeypatch) as (_, out_w):
        with anyio.fail_after(5):
            async with stdio_server(stdin=anyio.AsyncFile(io.StringIO())) as (read_stream, write_stream):
                read_stream.close()
                with pytest.raises(RuntimeError, match="already claimed fd 1"):
                    async with stdio_server():
                        pytest.fail("unreachable")  # pragma: no cover

                # fd 0 is back on the protocol pipe, not the null device.
                assert os.path.sameopenfile(0, in_r)
                await write_stream.aclose()

        assert os.path.sameopenfile(1, out_w)
        os.close(in_w)


@pytest.mark.anyio
@pytest.mark.skipif(sys.platform == "win32", reason="atomic above-range dup is POSIX-only (F_DUPFD)")
async def test_the_claim_engages_even_when_stderr_is_closed(  # pragma: lax no cover
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """A process missing fd 2 still gets full isolation on POSIX.

    F_DUPFD allocates the wire duplicate above the standard range atomically, so
    the hole in slot 2 cannot capture it; the stdout diversion falls back to the
    null device. Windows has no atomic minfd dup: the duplicate can land in the
    hole and the transport degrades to serving in place (a documented residue),
    which is safe but not this test's isolation contract, and this test's blocking
    read of the still-piped fd 0 would then never return.
    """
    request = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")
    response = JSONRPCResponse(jsonrpc="2.0", id=1, result={})
    with _pipe_planted_on_fd0(monkeypatch) as (in_r, in_w), _pipe_planted_on_fd1(monkeypatch) as (out_r, out_w):
        saved2 = os.dup(2)
        os.close(2)
        try:
            with anyio.fail_after(5):
                async with stdio_server() as (read_stream, write_stream):
                    async with read_stream:  # pragma: no branch
                        # Claimed: fd 0 reads the null device, not the pipe.
                        devnull_probe = os.open(os.devnull, os.O_RDONLY)
                        try:
                            assert os.path.sameopenfile(0, devnull_probe)
                        finally:
                            os.close(devnull_probe)

                        os.write(in_w, _frame(request))
                        received = await read_stream.receive()
                        assert isinstance(received, SessionMessage)
                        assert received.message == request
                        await write_stream.send(SessionMessage(response))
                        line = await _read_from(out_r)
                        assert jsonrpc_message_adapter.validate_json(line.decode().strip()) == response
                        os.close(in_w)
                        await write_stream.aclose()

            assert os.path.sameopenfile(0, in_r)
            assert os.path.sameopenfile(1, out_w)
        finally:
            os.dup2(saved2, 2)
            os.close(saved2)


@pytest.mark.anyio
async def test_stdio_server_serves_in_place_when_the_diversion_cannot_be_opened(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """A diversion that cannot be opened leaves fd 0 untouched and serves in place."""
    request = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")
    with _pipe_planted_on_fd0(monkeypatch) as (in_r, in_w):
        os.write(in_w, _frame(request))
        os.close(in_w)
        monkeypatch.setattr(sys, "stdout", TextIOWrapper(io.BytesIO(), encoding="utf-8"))

        def failing_diversion() -> int:
            raise OSError("injected diversion failure")

        monkeypatch.setattr("mcp.server.stdio._open_stdin_diversion", failing_diversion)

        with anyio.fail_after(5):
            async with stdio_server() as (read_stream, write_stream):  # pragma: no branch
                async with read_stream:  # pragma: no branch
                    assert os.path.sameopenfile(0, in_r)
                    received = await read_stream.receive()
                    assert isinstance(received, SessionMessage)
                    assert received.message == request
                    await write_stream.aclose()


@pytest.mark.anyio
async def test_a_degraded_session_does_not_close_the_sys_stream_it_served(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """The transport's text layer never closes a buffer it does not own.

    Regression for the issue #1933 class: in the in-place paths the transport wraps
    the sys stream's own buffer, and wrapper garbage collection must not close it.
    """
    with _pipe_planted_on_fd0(monkeypatch) as (_, in_w):
        os.close(in_w)
        monkeypatch.setattr(sys, "stdout", TextIOWrapper(io.BytesIO(), encoding="utf-8"))

        def failing_dup_above_std(fd: int) -> int:
            raise OSError("forced degrade")

        monkeypatch.setattr("mcp.server.stdio._dup_above_std", failing_dup_above_std)

        with anyio.fail_after(5):
            async with stdio_server() as (read_stream, write_stream):
                read_stream.close()
                await write_stream.aclose()

        gc.collect()
        assert not sys.stdin.buffer.closed
        assert not sys.stdout.buffer.closed


class _GatedStdin(io.RawIOBase):
    """Raw stdin double: serves its frames, then blocks until released before EOF.

    A real client holds stdin open until it reads its responses; instant EOF races the
    dispatcher's EOF-time cancellation of in-flight handlers.
    """

    name = "<gated-stdin>"

    def __init__(self, payload: bytes) -> None:
        self._pending = payload
        self._released = threading.Event()

    def readable(self) -> bool:
        return True

    def readinto(self, b: Buffer) -> int:
        view = memoryview(b)
        if self._pending:
            n = min(len(view), len(self._pending))
            view[:n] = self._pending[:n]
            self._pending = self._pending[n:]
            return n
        # A missed release falls through to EOF after the bound.
        self._released.wait(5)
        return 0

    def release(self) -> None:
        self._released.set()


class _NotifyingStdout(io.RawIOBase):
    """Raw stdout double that counts newline-terminated lines and can be awaited on.

    close() is a no-op so the test can read what was written after run() tears down.
    """

    name = "<notifying-stdout>"

    def __init__(self) -> None:
        self._chunks: list[bytes] = []
        self._lines = 0
        self._cond = threading.Condition()

    def writable(self) -> bool:
        return True

    def write(self, b: Buffer) -> int:
        data = bytes(b)
        with self._cond:
            self._chunks.append(data)
            self._lines += data.count(b"\n")
            self._cond.notify_all()
        return len(data)

    def wait_for_lines(self, n: int, timeout: float = 5) -> bool:
        with self._cond:
            return self._cond.wait_for(lambda: self._lines >= n, timeout)

    def getvalue(self) -> bytes:
        with self._cond:
            return b"".join(self._chunks)

    def close(self) -> None:
        pass


def _serve_stdio_and_collect(
    monkeypatch: pytest.MonkeyPatch, server: MCPServer, frames: list[JSONRPCRequest], responses: int
) -> list[JSONRPCMessage]:
    """Serve `frames` over process stdio and return the parsed response lines.

    Runs the blocking server.run("stdio") in a daemon thread and signals stdin EOF only after
    `responses` lines arrive - as a real client would - so handlers never race EOF cancellation.
    """
    payload = "".join(f.model_dump_json(by_alias=True, exclude_none=True) + "\n" for f in frames).encode()
    stdin = _GatedStdin(payload)
    stdout = _NotifyingStdout()
    monkeypatch.setattr(sys, "stdin", TextIOWrapper(stdin, encoding="utf-8"))
    monkeypatch.setattr(sys, "stdout", TextIOWrapper(stdout, encoding="utf-8"))

    def target() -> None:
        server.run("stdio")

    thread = threading.Thread(target=target, daemon=True)
    thread.start()
    arrived = stdout.wait_for_lines(responses)
    stdin.release()
    thread.join(5)
    assert not thread.is_alive(), 'run("stdio") did not return after stdin EOF'
    assert arrived, f"expected {responses} response line(s); stdout carried: {stdout.getvalue()!r}"
    return [jsonrpc_message_adapter.validate_json(line) for line in stdout.getvalue().decode().splitlines()]


def test_mcpserver_run_stdio_serves_until_stdin_closes(monkeypatch: pytest.MonkeyPatch) -> None:
    """`MCPServer.run("stdio")` serves over process stdio and returns at stdin EOF."""
    ping = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")

    responses = _serve_stdio_and_collect(monkeypatch, MCPServer(name="RunStdioServer"), [ping], 1)

    assert responses == [JSONRPCResponse(jsonrpc="2.0", id=1, result={})]


def test_mcpserver_run_stdio_runs_lifespan_cleanup_after_stdin_closes(monkeypatch: pytest.MonkeyPatch) -> None:
    """Code after `yield` in a lifespan runs when stdin EOF ends `run("stdio")`.

    Regression lock for the issue #1027 shutdown chain.
    """
    events: list[str] = []

    @asynccontextmanager
    async def lifespan(server: MCPServer) -> AsyncIterator[None]:
        events.append("setup")
        try:
            yield
        finally:
            events.append("cleanup")

    ping = JSONRPCRequest(jsonrpc="2.0", id=1, method="ping")

    server = MCPServer(name="LifespanStdioServer", lifespan=lifespan)
    responses = _serve_stdio_and_collect(monkeypatch, server, [ping], 1)

    assert events == ["setup", "cleanup"]
    assert responses == [JSONRPCResponse(jsonrpc="2.0", id=1, result={})]


def test_mcpserver_run_stdio_serves_a_modern_connection(monkeypatch: pytest.MonkeyPatch) -> None:
    """`MCPServer.run("stdio")` serves the modern era over process stdio.

    A `server/discover` probe (no initialize handshake), then a request served at the discovered version.
    """
    envelope = {
        PROTOCOL_VERSION_META_KEY: "2026-07-28",
        CLIENT_INFO_META_KEY: {"name": "probe", "version": "1.0"},
        CLIENT_CAPABILITIES_META_KEY: {},
    }
    discover = JSONRPCRequest(jsonrpc="2.0", id=1, method="server/discover", params={"_meta": envelope})
    tools = JSONRPCRequest(jsonrpc="2.0", id=2, method="tools/list", params={"_meta": envelope})

    server = MCPServer(name="ModernStdioServer", version="1.2.3")
    responses = _serve_stdio_and_collect(monkeypatch, server, [discover, tools], 2)

    assert isinstance(responses[0], JSONRPCResponse) and responses[0].id == 1
    assert "2026-07-28" in responses[0].result["supportedVersions"]
    # Server identity travels as the result `_meta` stamp, not a DiscoverResult
    # body field (spec 2026-07-28, #3002).
    assert responses[0].result["_meta"][SERVER_INFO_META_KEY] == {"name": "ModernStdioServer", "version": "1.2.3"}
    assert isinstance(responses[1], JSONRPCResponse) and responses[1].id == 2
    # resultType is modern-only: proves the request was served at the discovered version.
    assert responses[1].result["tools"] == []
    assert responses[1].result["resultType"] == "complete"