test: cover get_prompt context=None fallback; revert no branch pragma

- pragma: no branch only exempts branch coverage, not line coverage.
  The return on line 97 is never executed, so no cover is correct.
- get_prompt fallback at server.py:1089 was never hit since all tests
  use Client (E2E). Added a direct-call test.

Author: maxisbey

GENERICS_AUDIT.md

@@ -0,0 +1,76 @@
+# Generics Audit
+
+## 1. Dangling TypeVars in manager/base methods
+
+**Where:** `tool_manager.py:84`, `tools/base.py:95`, `prompts/manager.py:51`,
+`prompts/base.py:138`, `resource_manager.py:84`, `templates.py:102`
+
+`Context[LifespanContextT, RequestT]` on a method of a non-generic class.
+TypeVars appear once, return types don't use them. Pyright treats them as
+method-scoped and discards per-call. Behaviorally identical to
+`Context[Any, Any]` but reads as if it means something.
+
+**Fix:** `Context[Any, Any]`. The handler boundary is `Callable[..., Any]` --
+T is already dead one layer down, threading it through managers is ceremony.
+
+## 2. `@server.tool()` doesn't check `Context[T]` against `MCPServer[T]`
+
+Only user-visible gap. `MCPServer[AppState]` + `def tool(ctx: Context[int])`
+passes pyright. Decorator sig is `Callable[[_CallableT], _CallableT]` -- no
+relationship to the server's T.
+
+**Fix:** Won't-fix. Introspection-based injection can't be pattern-matched at
+the type level. Document the `ServerContext: TypeAlias = Context[AppState, Any]`
+workaround.
+
+## 3. `Context._mcp_server: MCPServer` (bare)
+
+**Where:** `mcpserver/context.py:59,66,75`
+
+`Context[AppState, Any].mcp_server` returns `MCPServer[Any]`. Context knows
+AppState, property forgot.
+
+**Fix:** `MCPServer[LifespanContextT]`. Sound -- every construction site
+(`server.py:301,334,371`) passes `mcp_server=self` where self's T matches ctx's T.
+
+## 4. Two TypeVars, one concept, two defaults
+
+|         | `LifespanResultT`       | `LifespanContextT`     |
+|---------|-------------------------|------------------------|
+| Defined | `lowlevel/server.py:74` | `server/context.py:13` |
+| Default | `Any`                   | `dict[str, Any]`       |
+| Used by | Server, MCPServer, Settings, ExperimentalHandlers | ServerRequestContext, Context |
+
+Same concept ("what lifespan yields"). Works because TypeVar identity doesn't
+matter for binding, only position. But `Context()` gives
+`Context[dict[str, Any], Any]` while `MCPServer()` gives `MCPServer[Any]`.
+
+**Fix:** Import `LifespanResultT` into `context.py`, delete `LifespanContextT`.
+
+## 5. `ServerSessionT` orphan
+
+**Where:** `server/session.py:60`
+
+Defined, zero references.
+
+**Fix:** Delete.
+
+## 6. `RequestResponder.__init__` has 3 dangling TypeVars
+
+**Where:** `shared/session.py:79`
+
+Class is `Generic[ReceiveRequestT, SendResultT]` but `__init__`'s `session`
+param uses 5. The extra 3 are method-scoped on `__init__`.
+
+**Fix:** `session: BaseSession[Any, Any, SendResultT, ReceiveRequestT, Any]`
+
+## 7. Arity drift on `ServerRequestContext`
+
+Lowlevel writes `ServerRequestContext[T]` (1 arg), mcpserver writes
+`ServerRequestContext[T, R]` (2 args). Both valid because `RequestT` has
+`default=Any`. Not a bug, inconsistent.
+
+## 8. `Context` is invariant
+
+`Context[AppState]` not assignable to `Context[object]`. Forced through `Any`.
+Doesn't matter once #1 is fixed.

src/mcp/server/mcpserver/context.py

@@ -93,7 +93,7 @@ async def report_progress(self, progress: float, total: float | None = None, mes
         """
         progress_token = self.request_context.meta.get("progress_token") if self.request_context.meta else None
 
-        if progress_token is None:  # pragma: no branch
+        if progress_token is None:  # pragma: no cover
             return
 
         await self.request_context.session.send_progress_notification(

tests/server/mcpserver/test_server.py

@@ -1231,6 +1231,19 @@ def prompt_no_context(text: str) -> str:
 class TestServerPrompts:
     """Test prompt functionality in MCPServer server."""
 
+    async def test_get_prompt_direct_call_without_context(self):
+        """Test calling mcp.get_prompt() directly without passing context."""
+        mcp = MCPServer()
+
+        @mcp.prompt()
+        def fn() -> str:
+            return "Hello, world!"
+
+        result = await mcp.get_prompt("fn")
+        content = result.messages[0].content
+        assert isinstance(content, TextContent)
+        assert content.text == "Hello, world!"
+
     async def test_prompt_decorator(self):
         """Test that the prompt decorator registers prompts correctly."""
         mcp = MCPServer()