hud-python 0.4.35__py3-none-any.whl → 0.4.37__py3-none-any.whl

hud/server/tests/test_mcp_server_integration.py

@@ -0,0 +1,405 @@
+from __future__ import annotations
+
+import asyncio
+import socket
+from contextlib import suppress
+from typing import Any, cast
+
+import pytest
+
+from hud.clients import MCPClient
+from hud.server import MCPServer
+from hud.server import server as server_mod  # for toggling _sigterm_received
+from hud.server.low_level import LowLevelServerWithInit
+
+
+def _free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+async def _start_http_server(mcp: MCPServer, port: int) -> asyncio.Task:
+    # run the server in the background; cancel to stop
+    task = asyncio.create_task(
+        mcp.run_async(
+            transport="http",
+            host="127.0.0.1",
+            port=port,
+            path="/mcp",
+            log_level="ERROR",
+            show_banner=False,
+        )
+    )
+    # brief yield so uvicorn can boot
+    await asyncio.sleep(0.05)
+    return task
+
+
+def _first_text(result) -> str | None:
+    # Result.content is usually a list of TextContent
+    c = getattr(result, "content", None)
+    if isinstance(c, list) and c and hasattr(c[0], "text"):
+        return c[0].text
+    if isinstance(c, str):
+        return c
+    return None
+
+
+@pytest.mark.asyncio
+async def test_low_level_injection_happens_when_initialize_used() -> None:
+    mcp = MCPServer(name="InitInject")
+    assert not isinstance(mcp._mcp_server, LowLevelServerWithInit)
+
+    @mcp.initialize
+    async def _init(_ctx) -> None:
+        return None
+
+    assert isinstance(mcp._mcp_server, LowLevelServerWithInit)
+
+
+@pytest.mark.asyncio
+async def test_initialize_runs_once_and_tools_work() -> None:
+    port = _free_port()
+
+    mcp = MCPServer(name="ServerInitOnce")
+    state = {"init_calls": 0, "initialized": False}
+
+    @mcp.initialize
+    async def _init(_ctx) -> None:
+        # this would corrupt stdout if not redirected; we rely on stderr redirection
+        print("hello from init")  # noqa: T201
+        state["init_calls"] += 1
+        state["initialized"] = True
+
+    @mcp.tool()
+    async def initialized() -> bool:  # type: ignore[override]
+        return state["initialized"]
+
+    @mcp.tool()
+    async def echo(text: str = "ok") -> str:  # type: ignore[override]
+        return f"echo:{text}"
+
+    server_task = await _start_http_server(mcp, port)
+
+    async def connect_and_check() -> None:
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        client = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await client.initialize()
+        tools = await client.list_tools()
+        names = sorted(t.name for t in tools)
+        assert {"echo", "initialized"} <= set(names)
+        res = await client.call_tool(name="initialized", arguments={})
+        # boolean return is exposed via structuredContent["result"]
+        assert getattr(res, "structuredContent", {}).get("result") is True
+        res2 = await client.call_tool(name="echo", arguments={"text": "ping"})
+        assert _first_text(res2) == "echo:ping"
+        await client.shutdown()
+
+    try:
+        await connect_and_check()
+        await connect_and_check()
+        # initializer should have executed only once across multiple clients
+        assert state["init_calls"] == 1
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task.cancel()
+            await server_task
+
+
+@pytest.mark.asyncio
+async def test_shutdown_handler_only_on_sigterm_flag() -> None:
+    port = _free_port()
+
+    mcp = MCPServer(name="ShutdownTest")
+    called = asyncio.Event()
+
+    @mcp.shutdown
+    async def _on_shutdown() -> None:
+        called.set()
+
+    # no SIGTERM flag: should NOT call shutdown on normal cancel
+    server_task = await _start_http_server(mcp, port)
+    try:
+        # sanity connect so lifespan actually ran
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        c = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c.initialize()
+        await c.shutdown()
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task.cancel()
+            await server_task
+    # give a tick to let lifespan finally run
+    await asyncio.sleep(0.05)
+    assert not called.is_set()
+
+    # now start again and simulate SIGTERM so shutdown handler fires
+    called.clear()
+    port2 = _free_port()
+    server_task2 = await _start_http_server(mcp, port=port2)
+    try:
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port2}/mcp"}}
+        c = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c.initialize()
+        await c.shutdown()
+
+        # flip the module-level flag the lifespan checks
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task2.cancel()
+            await server_task2
+
+    # shutdown coroutine should have run because flag was set when lifespan exited
+    assert called.is_set()
+    # reset the flag for any other tests
+    server_mod._sigterm_received = False  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_initializer_exception_propagates_to_client() -> None:
+    port = _free_port()
+
+    mcp = MCPServer(name="InitError")
+
+    @mcp.initialize
+    async def _init(_ctx) -> None:
+        raise RuntimeError("boom during init")
+
+    server_task = await _start_http_server(mcp, port)
+
+    cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+    client = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+
+    try:
+        with pytest.raises(Exception):
+            await client.initialize()
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task.cancel()
+            await server_task
+        # defensive: client may or may not be fully created
+        with suppress(Exception):
+            await client.shutdown()
+
+
+# --- additional tests for MCPServer coverage ---
+
+
+@pytest.mark.asyncio
+async def test_init_after_tools_preserves_handlers_and_runs_once() -> None:
+    """If tools are added BEFORE @mcp.initialize, the handler copy during
+    low-level server replacement must keep them; init should still run once total.
+    """
+    port = _free_port()
+
+    mcp = MCPServer(name="InitAfterTools")
+    state = {"init_calls": 0}
+
+    # Register tools first
+    @mcp.tool()
+    async def foo() -> str:  # type: ignore[override]
+        return "bar"
+
+    # Now register initializer (this triggers server replacement)
+    @mcp.initialize
+    async def _init(_ctx) -> None:
+        state["init_calls"] += 1
+
+    server_task = await _start_http_server(mcp, port)
+
+    async def connect_and_check() -> None:
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        c = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c.initialize()
+        tools = await c.list_tools()
+        names = sorted(t.name for t in tools)
+        assert "foo" in names, "tool registered before @initialize must survive replacement"
+        res = await c.call_tool(name="foo", arguments={})
+        assert _first_text(res) == "bar"
+        await c.shutdown()
+
+    try:
+        await connect_and_check()
+        await connect_and_check()
+        assert state["init_calls"] == 1, "initializer should execute exactly once"
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task.cancel()
+            await server_task
+
+
+@pytest.mark.asyncio
+async def test_tool_default_argument_used_when_omitted() -> None:
+    """Echo tool should use its default when argument is omitted."""
+    port = _free_port()
+
+    mcp = MCPServer(name="EchoDefault")
+
+    @mcp.tool()
+    async def echo(text: str = "ok") -> str:  # type: ignore[override]
+        return f"echo:{text}"
+
+    server_task = await _start_http_server(mcp, port)
+    try:
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        c = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c.initialize()
+        # Call with no args → default should kick in
+        res = await c.call_tool(name="echo", arguments={})
+        assert _first_text(res) == "echo:ok"
+        await c.shutdown()
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task.cancel()
+            await server_task
+
+
+@pytest.mark.asyncio
+async def test_shutdown_handler_runs_once_when_both_paths_fire() -> None:
+    """With SIGTERM flag set, both the lifespan.finally and run_async.finally would
+    try to invoke @mcp.shutdown. The per-instance guard must ensure exactly once.
+    """
+    port = _free_port()
+    mcp = MCPServer(name="ShutdownOnce")
+    calls = {"n": 0}
+
+    @mcp.shutdown
+    async def _on_shutdown() -> None:
+        calls["n"] += 1
+
+    server_task = await _start_http_server(mcp, port)
+    try:
+        # Ensure lifespan started
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        c = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c.initialize()
+        await c.shutdown()
+
+        # Arm SIGTERM flag so both code paths believe they should run
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task.cancel()
+            await server_task
+
+    # Give the event loop a tick to run both finalizers
+    await asyncio.sleep(0.05)
+
+    try:
+        assert calls["n"] == 1, f"shutdown hook must run exactly once, got {calls['n']}"
+    finally:
+        # Always reset module flag
+        server_mod._sigterm_received = False  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_initialize_ctx_exposes_client_info() -> None:
+    """Initializer gets a ctx; clientInfo may be absent depending on client implementation."""
+    port = _free_port()
+
+    mcp = MCPServer(name="InitCtx")
+    seen = {"has_session": False, "client_name": None}
+
+    @mcp.initialize
+    async def _init(ctx) -> None:  # type: ignore[override]
+        # Ensure we have a session object
+        seen["has_session"] = hasattr(ctx, "session") and ctx.session is not None
+
+        # Client info is optional; capture it if present
+        client_info = getattr(getattr(ctx.session, "client_params", None), "clientInfo", None)
+        if client_info is not None:
+            seen["client_name"] = getattr(client_info, "name", None)
+
+    server_task = await _start_http_server(mcp, port)
+    try:
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        c = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c.initialize()
+        await c.shutdown()
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task.cancel()
+            await server_task
+
+    assert seen["has_session"] is True
+    # If present, name should be a string; otherwise None is acceptable.
+    assert seen["client_name"] is None or isinstance(seen["client_name"], str)
+
+
+@pytest.mark.asyncio
+async def test_initialize_redirects_stdout_to_stderr(capsys) -> None:
+    """Initializer prints should be redirected to stderr (never stdout)."""
+    port = _free_port()
+
+    mcp = MCPServer(name="StdoutRedirect")
+
+    @mcp.initialize
+    async def _init(_ctx) -> None:
+        # This would normally pollute STDOUT; our server redirects to STDERR
+        print("INIT_STDOUT_MARKER")  # noqa: T201
+
+    server_task = await _start_http_server(mcp, port)
+
+    try:
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        c = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c.initialize()
+        await c.shutdown()
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task.cancel()
+            await server_task
+
+    captured = capsys.readouterr()
+    assert "INIT_STDOUT_MARKER" in captured.err
+    assert "INIT_STDOUT_MARKER" not in captured.out
+
+
+@pytest.mark.asyncio
+async def test_initialize_callable_form_runs_once() -> None:
+    """Coverage for mcp.initialize(fn) (callable style), not only decorator usage."""
+    port = _free_port()
+    mcp = MCPServer(name="CallableInit")
+    hits = {"n": 0}
+
+    async def _init(_ctx) -> None:
+        hits["n"] += 1
+
+    # Callable form instead of decorator
+    mcp.initialize(_init)
+
+    server_task = await _start_http_server(mcp, port)
+    try:
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        c1 = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c1.initialize()
+        await c1.shutdown()
+
+        c2 = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c2.initialize()
+        await c2.shutdown()
+    finally:
+        with suppress(asyncio.CancelledError):
+            server_task.cancel()
+            await server_task
+
+    assert hits["n"] == 1
+
+
+@pytest.mark.asyncio
+async def test_notification_handlers_survive_real_replacement() -> None:
+    """End-to-end check that notification handlers survive when initialize is registered."""
+    mcp = MCPServer(name="NotifCopy")
+
+    # Seed a dummy notification handler before replacement
+    cast("dict[Any, Any]", mcp._mcp_server.notification_handlers)["hud/notify"] = object()
+    assert "hud/notify" in mcp._mcp_server.notification_handlers
+
+    @mcp.initialize
+    async def _init(_ctx) -> None:
+        pass
+
+    # After replacement, the handler should still be there
+    assert "hud/notify" in mcp._mcp_server.notification_handlers

hud/server/tests/test_mcp_server_more.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import asyncio
+import socket
+from contextlib import asynccontextmanager, suppress
+
+import anyio
+import pytest
+
+from hud.clients import MCPClient
+from hud.server import MCPServer
+from hud.server import server as server_mod  # to toggle _sigterm_received
+
+
+def _free_port() -> int:
+    """Get a free port for testing."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+@asynccontextmanager
+async def _fake_stdio_server():
+    """
+    Stand-in for mcp.server.stdio.stdio_server that avoids reading real stdin.
+
+    It yields a pair of in-memory streams (receive, send) so the low-level server
+    can start and idle without touching sys.stdin/sys.stdout.
+    """
+    # Server reads from recv_in and writes to send_out
+    send_in, recv_in = anyio.create_memory_object_stream(100)  # stdin → server
+    send_out, recv_out = anyio.create_memory_object_stream(100)  # server → stdout
+    try:
+        yield recv_in, send_out
+    finally:
+        # Best effort close; methods exist across anyio versions
+        for s in (send_in, recv_in, send_out, recv_out):
+            close = getattr(s, "close", None) or getattr(s, "aclose", None)
+            try:
+                if close is not None:
+                    res = close()
+                    if asyncio.iscoroutine(res):
+                        await res
+            except Exception:
+                pass
+
+
+@pytest.fixture(autouse=True)
+def _patch_stdio(monkeypatch: pytest.MonkeyPatch):
+    """Patch stdio server for all tests to avoid stdin reading issues."""
+    monkeypatch.setenv("FASTMCP_DISABLE_BANNER", "1")
+    # Patch both the source and the bound symbol FastMCP uses
+    monkeypatch.setattr("mcp.server.stdio.stdio_server", _fake_stdio_server)
+    monkeypatch.setattr("fastmcp.server.server.stdio_server", _fake_stdio_server)
+
+
+@pytest.mark.asyncio
+async def test_stdio_shutdown_handler_on_sigterm_flag() -> None:
+    """@mcp.shutdown runs on stdio transport when the SIGTERM flag is set."""
+    mcp = MCPServer(name="StdIOShutdown")
+    calls = {"n": 0}
+
+    @mcp.shutdown
+    async def _on_shutdown() -> None:
+        calls["n"] += 1
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        # Simulate SIGTERM path
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    assert calls["n"] == 1
+    assert not getattr(server_mod, "_sigterm_received")
+
+
+@pytest.mark.asyncio
+async def test_stdio_shutdown_handler_not_called_without_sigterm() -> None:
+    """@mcp.shutdown must NOT run on stdio cancel when no SIGTERM flag."""
+    mcp = MCPServer(name="StdIONoSigterm")
+    called = {"n": 0}
+
+    @mcp.shutdown
+    async def _on_shutdown() -> None:
+        called["n"] += 1
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        # no SIGTERM flag
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    assert called["n"] == 0
+
+
+@pytest.mark.asyncio
+async def test_last_initialize_handler_wins_and_ctx_shape_exists() -> None:
+    """If multiple @initialize decorators are applied, only the last one should execute.
+    Also sanity-check that ctx has the expected core attributes in a version-tolerant way.
+    """
+    port = _free_port()
+
+    mcp = MCPServer(name="InitOverride")
+    seen = {"a": False, "b": False, "has_session": False, "has_request": False}
+
+    @mcp.initialize
+    async def _init_a(ctx) -> None:  # type: ignore[override]
+        # This one should get overridden and never run
+        seen["a"] = True
+
+    @mcp.initialize
+    async def _init_b(ctx) -> None:  # type: ignore[override]
+        # This is the one that should actually run
+        seen["b"] = True
+        seen["has_session"] = hasattr(ctx, "session") and ctx.session is not None
+        seen["has_request"] = hasattr(ctx, "request") and ctx.request is not None
+
+    # A simple echo tool so we can verify the server works post-init
+    @mcp.tool()
+    async def echo(text: str = "ok") -> str:  # type: ignore[override]
+        return f"echo:{text}"
+
+    # Start HTTP transport (quickest way to use a real client)
+    task = asyncio.create_task(
+        mcp.run_async(
+            transport="http",
+            host="127.0.0.1",
+            port=port,
+            path="/mcp",
+            log_level="ERROR",
+            show_banner=False,
+        )
+    )
+    await asyncio.sleep(0.05)
+
+    try:
+        cfg = {"srv": {"url": f"http://127.0.0.1:{port}/mcp"}}
+        c = MCPClient(mcp_config=cfg, auto_trace=False, verbose=False)
+        await c.initialize()
+
+        # Call a tool to ensure init didn't break anything
+        res = await c.call_tool(name="echo", arguments={"text": "ping"})
+        text = getattr(res, "content", None)
+        if isinstance(text, list) and text and hasattr(text[0], "text"):
+            text = text[0].text
+        assert text == "echo:ping"
+
+        await c.shutdown()
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    # Only the last initializer should have run
+    assert seen["a"] is False
+    assert seen["b"] is True
+    # And the ctx had the key attributes (shape may vary by lib version; just presence)
+    assert seen["has_session"] is True
+    assert seen["has_request"] is True
+
+
+@pytest.mark.asyncio
+async def test_stdio_shutdown_handler_runs_once_when_both_paths_fire() -> None:
+    """Even on stdio, when SIGTERM is set, ensure shutdown runs exactly once."""
+    mcp = MCPServer(name="StdIOOnce")
+    calls = {"n": 0}
+
+    @mcp.shutdown
+    async def _on_shutdown() -> None:
+        calls["n"] += 1
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        # Make both the lifespan.finally and run_async.finally want to execute
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    assert calls["n"] == 1
+    # Reset global flag always
+    server_mod._sigterm_received = False  # type: ignore[attr-defined]
+
+
+@pytest.mark.asyncio
+async def test_run_async_defaults_to_stdio_and_uses_patched_stdio(monkeypatch: pytest.MonkeyPatch):
+    """transport=None should default to stdio and use our patched stdio server."""
+    entered = {"v": False}
+
+    @asynccontextmanager
+    async def tracking_stdio():
+        entered["v"] = True
+        async with _fake_stdio_server() as streams:
+            yield streams
+
+    # Override the autouse fixture for this test to track entry
+    monkeypatch.setattr("fastmcp.server.server.stdio_server", tracking_stdio)
+
+    mcp = MCPServer(name="DefaultStdio")
+    task = asyncio.create_task(mcp.run_async(transport=None, show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        assert entered["v"] is True, "Expected stdio transport to be used by default"
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+
+@pytest.mark.asyncio
+async def test_custom_lifespan_relies_on_run_async_fallback_for_sigterm() -> None:
+    """When a custom lifespan is supplied, run_async's finally path must still call
+    @shutdown on SIGTERM."""
+
+    @asynccontextmanager
+    async def custom_lifespan(_):
+        # No shutdown call here on purpose
+        yield {}
+
+    mcp = MCPServer(name="CustomLS", lifespan=custom_lifespan)
+    calls = {"n": 0}
+
+    @mcp.shutdown
+    async def _s() -> None:
+        calls["n"] += 1
+
+    task = asyncio.create_task(mcp.run_async(transport="stdio", show_banner=False))
+    try:
+        await asyncio.sleep(0.05)
+        # Ensure finalizer believes SIGTERM happened
+        server_mod._sigterm_received = True  # type: ignore[attr-defined]
+    finally:
+        with suppress(asyncio.CancelledError):
+            task.cancel()
+            await task
+
+    assert calls["n"] == 1
+    assert not getattr(server_mod, "_sigterm_received")

hud/server/tests/test_run_wrapper.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from hud.server import MCPServer
+
+if TYPE_CHECKING:
+    import pytest
+
+
+def test_run_uses_sigterm_wrapper(monkeypatch: pytest.MonkeyPatch) -> None:
+    """MCPServer.run should delegate through _run_with_sigterm (don't actually start a server)."""
+    called = {"hit": False, "args": None, "kwargs": None}
+
+    def fake_wrapper(coro_fn, *args, **kwargs):
+        called["hit"] = True
+        called["args"] = args
+        called["kwargs"] = kwargs
+        # Do not execute the bootstrap coroutine; this is unit wiring only.
+
+    monkeypatch.setattr("hud.server.server._run_with_sigterm", fake_wrapper)
+
+    mcp = MCPServer(name="RunWrapper")
+    # Should immediately return after calling our fake wrapper
+    mcp.run(transport="http", host="127.0.0.1", port=9999, path="/mcp", show_banner=False)
+
+    assert called["hit"] is True
+
+
+def test_run_defaults_to_stdio(monkeypatch: pytest.MonkeyPatch) -> None:
+    """transport=None in .run should resolve to 'stdio' and forward to run_async."""
+    seen = {}
+
+    async def fake_run_async(self, *, transport, show_banner, **kwargs):
+        seen["transport"] = transport
+        seen["show_banner"] = show_banner
+        seen["kwargs"] = kwargs
+
+    # Replace bound method on the instance class
+    monkeypatch.setattr(MCPServer, "run_async", fake_run_async, raising=False)
+
+    # Execute the bootstrap coroutine immediately (no real server)
+    def fake_wrapper(coro_fn, *args, **kwargs):
+        asyncio.run(coro_fn())
+
+    monkeypatch.setattr("hud.server.server._run_with_sigterm", fake_wrapper)
+
+    mcp = MCPServer(name="RunDefaultTransport")
+    mcp.run(transport=None, show_banner=False)
+
+    assert seen["transport"] == "stdio"
+    assert seen["show_banner"] is False