test: add lifecycle, completion, logging, and MCPServer feature interaction tests

Extends the interaction suite with the initialize handshake (server identity,
instructions, capability derivation, client identity and capabilities as seen
by the server), completion round trips, logging notifications, and the
MCPServer resource/prompt/structured-output behaviours. Records two more
divergences on the requirements manifest: MCPServer reports unknown resources
and prompts with error code 0 rather than the codes the spec documents.

Removes the 'pragma: no cover' from the method-not-found fallback now that it
is covered.

Author: maxisbey

src/mcp/server/lowlevel/server.py

@@ -513,7 +513,7 @@ async def _handle_request(
                     if raise_exceptions:  # pragma: no cover
                         raise err
                     response = types.ErrorData(code=0, message=str(err))
-            else:  # pragma: no cover
+            else:
                 response = types.ErrorData(code=types.METHOD_NOT_FOUND, message="Method not found")
 
             if isinstance(response, types.ErrorData) and span is not None:

tests/interaction/_requirements.py

@@ -60,6 +60,42 @@ class Requirement:
         ),
     ),
     # ═══════════════════════════════════════════════════════════════════════════
+    # Lifecycle
+    # ═══════════════════════════════════════════════════════════════════════════
+    "lifecycle:initialize:server-info": Requirement(
+        source=f"{SPEC_BASE_URL}/basic/lifecycle#initialization",
+        behavior="The initialize result identifies the server: name and version, plus title when declared.",
+    ),
+    "lifecycle:initialize:instructions": Requirement(
+        source=f"{SPEC_BASE_URL}/basic/lifecycle#initialization",
+        behavior=(
+            "Server-declared instructions are returned in the initialize result, and omitted when the "
+            "server declares none."
+        ),
+    ),
+    "lifecycle:initialize:capabilities:from-handlers": Requirement(
+        source=f"{SPEC_BASE_URL}/basic/lifecycle#capability-negotiation",
+        behavior=(
+            "The server advertises a capability for each feature area it has a registered handler for, "
+            "and omits the capability for areas it does not."
+        ),
+    ),
+    "lifecycle:initialize:capabilities:minimal": Requirement(
+        source=f"{SPEC_BASE_URL}/basic/lifecycle#capability-negotiation",
+        behavior="A server with no feature handlers advertises no feature capabilities.",
+    ),
+    "lifecycle:initialize:client-info": Requirement(
+        source=f"{SPEC_BASE_URL}/basic/lifecycle#initialization",
+        behavior="The client's name, version, and title are visible to server handlers after initialization.",
+    ),
+    "lifecycle:initialize:client-capabilities": Requirement(
+        source=f"{SPEC_BASE_URL}/basic/lifecycle#capability-negotiation",
+        behavior=(
+            "The client capabilities visible to the server reflect which client callbacks are configured "
+            "(sampling, elicitation, roots)."
+        ),
+    ),
+    # ═══════════════════════════════════════════════════════════════════════════
     # Ping
     # ═══════════════════════════════════════════════════════════════════════════
     "ping:client-to-server": Requirement(
@@ -123,6 +159,53 @@ class Requirement:
         source=f"{SPEC_BASE_URL}/server/tools#error-handling",
         behavior="tools/call for a name the server does not recognise returns a JSON-RPC error.",
     ),
+    "tools:call:invalid-arguments": Requirement(
+        source=f"{SPEC_BASE_URL}/server/tools#error-handling",
+        behavior=(
+            "Arguments that fail the tool's input validation produce a tool execution error (isError true "
+            "with the validation failure described in content), not a protocol error."
+        ),
+    ),
+    # ═══════════════════════════════════════════════════════════════════════════
+    # Completion
+    # ═══════════════════════════════════════════════════════════════════════════
+    "completion:complete:prompt-ref": Requirement(
+        source=f"{SPEC_BASE_URL}/server/utilities/completion#requesting-completions",
+        behavior="completion/complete with a ref/prompt returns suggested values for the named prompt argument.",
+    ),
+    "completion:complete:resource-ref": Requirement(
+        source=f"{SPEC_BASE_URL}/server/utilities/completion#requesting-completions",
+        behavior="completion/complete with a ref/resource returns suggested values for a URI template variable.",
+    ),
+    "completion:complete:context": Requirement(
+        source=f"{SPEC_BASE_URL}/server/utilities/completion#context",
+        behavior="Previously-resolved argument values supplied in context.arguments reach the completion handler.",
+    ),
+    "completion:complete:not-supported": Requirement(
+        source=f"{SPEC_BASE_URL}/server/utilities/completion#capabilities",
+        behavior=(
+            "A server with no completion handler does not advertise the completions capability and rejects "
+            "completion/complete with METHOD_NOT_FOUND."
+        ),
+    ),
+    # ═══════════════════════════════════════════════════════════════════════════
+    # Logging
+    # ═══════════════════════════════════════════════════════════════════════════
+    "logging:set-level": Requirement(
+        source=f"{SPEC_BASE_URL}/server/utilities/logging#log-levels",
+        behavior="logging/setLevel delivers the requested level to the server's handler and returns an empty result.",
+    ),
+    "logging:message:notification": Requirement(
+        source=f"{SPEC_BASE_URL}/server/utilities/logging#log-message-notifications",
+        behavior=(
+            "A log message sent by a server handler is delivered to the client's logging callback with its "
+            "severity level, logger name, and data, in the order the server sent them."
+        ),
+    ),
+    "logging:message:all-levels": Requirement(
+        source=f"{SPEC_BASE_URL}/server/utilities/logging#log-levels",
+        behavior="All eight RFC 5424 severity levels are deliverable as log message notifications.",
+    ),
     # ═══════════════════════════════════════════════════════════════════════════
     # Resources
     # ═══════════════════════════════════════════════════════════════════════════
@@ -167,6 +250,61 @@ class Requirement:
     # ═══════════════════════════════════════════════════════════════════════════
     # MCPServer behavioural guarantees (not spec-mandated)
     # ═══════════════════════════════════════════════════════════════════════════
+    "mcpserver:tools:output-schema:model": Requirement(
+        source="sdk",
+        behavior=(
+            "A tool returning a typed model advertises a matching generated outputSchema and returns the "
+            "model's fields as structuredContent alongside a serialised text block."
+        ),
+    ),
+    "mcpserver:tools:output-schema:wrapped": Requirement(
+        source="sdk",
+        behavior=(
+            "A tool returning a non-object type (primitive or list) wraps the value as {'result': ...} in "
+            "structuredContent, with a matching generated outputSchema."
+        ),
+    ),
+    "mcpserver:resources:static": Requirement(
+        source="sdk",
+        behavior=(
+            "A function registered with @mcp.resource() for a fixed URI is listed by resources/list and "
+            "served by resources/read at that URI."
+        ),
+    ),
+    "mcpserver:resources:template": Requirement(
+        source="sdk",
+        behavior=(
+            "A function registered with a URI template is listed by resources/templates/list and matched "
+            "by resources/read, receiving the parameters extracted from the requested URI."
+        ),
+    ),
+    "mcpserver:resources:unknown-uri": Requirement(
+        source="sdk",
+        behavior="resources/read for a URI matching no registered resource returns a JSON-RPC error.",
+        divergence=Divergence(
+            note=(
+                "The spec reserves -32002 for resource-not-found; MCPServer raises ResourceError, which "
+                "the low-level server converts to error code 0."
+            ),
+        ),
+    ),
+    "mcpserver:prompts:decorated": Requirement(
+        source="sdk",
+        behavior=(
+            "A function registered with @mcp.prompt() is listed with arguments derived from its signature "
+            "and rendered into prompt messages by prompts/get."
+        ),
+    ),
+    "mcpserver:prompts:unknown-name": Requirement(
+        source="sdk",
+        behavior="prompts/get for a name that was never registered returns a JSON-RPC error.",
+        divergence=Divergence(
+            note=(
+                "The spec's example uses -32602 Invalid params for unknown prompts; MCPServer raises "
+                "ValueError, which the low-level server converts to error code 0."
+            ),
+        ),
+    ),
     "mcpserver:tools:handler-exception": Requirement(
         source="sdk",
         behavior=(

tests/interaction/lowlevel/test_completion.py

@@ -0,0 +1,106 @@
+"""Completion interactions against the low-level Server, driven through the public Client API."""
+
+import pytest
+from inline_snapshot import snapshot
+
+from mcp import MCPError, types
+from mcp.client.client import Client
+from mcp.server import Server, ServerRequestContext
+from mcp.types import (
+    METHOD_NOT_FOUND,
+    CompleteResult,
+    Completion,
+    ErrorData,
+    PromptReference,
+    ResourceTemplateReference,
+)
+from tests.interaction._requirements import requirement
+
+pytestmark = pytest.mark.anyio
+
+
+@requirement("completion:complete:prompt-ref")
+async def test_complete_prompt_argument() -> None:
+    """Completing a prompt argument delivers the ref, argument name, and current value to the handler.
+
+    The returned values are filtered by the argument's value, proving the value reached the handler.
+    """
+
+    async def completion(ctx: ServerRequestContext, params: types.CompleteRequestParams) -> CompleteResult:
+        assert isinstance(params.ref, PromptReference)
+        assert params.ref.name == "code_review"
+        assert params.argument.name == "language"
+        candidates = ["python", "pytorch", "ruby"]
+        matches = [candidate for candidate in candidates if candidate.startswith(params.argument.value)]
+        return CompleteResult(completion=Completion(values=matches, total=len(matches), has_more=False))
+
+    server = Server("completer", on_completion=completion)
+
+    async with Client(server) as client:
+        result = await client.complete(
+            PromptReference(name="code_review"), argument={"name": "language", "value": "py"}
+        )
+
+    assert result == snapshot(
+        CompleteResult(completion=Completion(values=["python", "pytorch"], total=2, has_more=False))
+    )
+
+
+@requirement("completion:complete:resource-ref")
+async def test_complete_resource_template_variable() -> None:
+    """Completing a URI template variable delivers the template URI and variable name to the handler."""
+
+    async def completion(ctx: ServerRequestContext, params: types.CompleteRequestParams) -> CompleteResult:
+        assert isinstance(params.ref, ResourceTemplateReference)
+        assert params.ref.uri == "github://repos/{owner}/{repo}"
+        assert params.argument.name == "owner"
+        return CompleteResult(completion=Completion(values=[f"{params.argument.value}contextprotocol"]))
+
+    server = Server("completer", on_completion=completion)
+
+    async with Client(server) as client:
+        result = await client.complete(
+            ResourceTemplateReference(uri="github://repos/{owner}/{repo}"),
+            argument={"name": "owner", "value": "model"},
+        )
+
+    assert result == snapshot(CompleteResult(completion=Completion(values=["modelcontextprotocol"])))
+
+
+@requirement("completion:complete:context")
+async def test_complete_receives_context_arguments() -> None:
+    """Previously-resolved arguments passed as completion context reach the handler.
+
+    The returned value is derived from the context, proving it arrived.
+    """
+
+    async def completion(ctx: ServerRequestContext, params: types.CompleteRequestParams) -> CompleteResult:
+        assert params.argument.name == "repo"
+        assert params.context is not None
+        assert params.context.arguments is not None
+        return CompleteResult(completion=Completion(values=[f"{params.context.arguments['owner']}/python-sdk"]))
+
+    server = Server("completer", on_completion=completion)
+
+    async with Client(server) as client:
+        result = await client.complete(
+            ResourceTemplateReference(uri="github://repos/{owner}/{repo}"),
+            argument={"name": "repo", "value": ""},
+            context_arguments={"owner": "modelcontextprotocol"},
+        )
+
+    assert result == snapshot(CompleteResult(completion=Completion(values=["modelcontextprotocol/python-sdk"])))
+
+
+@requirement("completion:complete:not-supported")
+async def test_complete_without_handler_is_method_not_found() -> None:
+    """A server with no completion handler advertises no completions capability and rejects the request."""
+    server = Server("incomplete")
+
+    async with Client(server) as client:
+        assert client.initialize_result.capabilities.completions is None
+
+        with pytest.raises(MCPError) as exc_info:
+            await client.complete(PromptReference(name="anything"), argument={"name": "topic", "value": ""})
+
+    assert exc_info.value.error == snapshot(ErrorData(code=METHOD_NOT_FOUND, message="Method not found"))