@@ -225,6 +225,10 @@ Because `populate_by_name=True` is set, the old camelCase names still work as co
 
 Results returned from server handlers are now validated against the negotiated protocol version's schema before being sent. A result that does not conform raises on the server side and the client receives an `INTERNAL_ERROR` response. The case most existing code will hit is `Tool.inputSchema`: the spec requires it to contain `"type": "object"`, so an empty `{}` is now rejected.
 
+### Client validates inbound traffic against the protocol schema
+
+`ClientSession` now validates server requests, notifications, and results against the negotiated protocol version's schema before parsing them into `mcp.types` models. Spec-invalid server output that the previous monolith parse tolerated may now raise `pydantic.ValidationError` from `list_tools()`, `call_tool()`, and similar calls. `_meta` remains the sanctioned place for result extras (and `experimental` for capability extras).
+
 ### `args` parameter removed from `ClientSessionGroup.call_tool()`
 
 The deprecated `args` parameter has been removed from `ClientSessionGroup.call_tool()`. Use `arguments` instead.
@@ -535,9 +539,9 @@ await ctx.log(level="info", data="hello")
 
 Positional calls (`await ctx.info("hello")`) are unaffected.
 
-### `Context.elicit()` schema gate tightened
+### `Context.elicit()` schema gate validates the rendered schema
 
-`Context.elicit()` (and `elicit_with_validation()`) now accept only schemas whose fields are a single primitive type (`str`, `int`, `float`, `bool`) or `Optional[primitive]`. `list[...]` fields and unions of multiple primitives (e.g. `int | str`) raise `TypeError` at the call site; previously `list[str]` and arbitrary primitive unions were allowed but produced a `requestedSchema` outside the spec's restricted subset. `Optional[T]` fields now render as `{"type": ...}` with the field omitted from `required` instead of the non-spec `anyOf` shape.
+`Context.elicit()` (and `elicit_with_validation()`) now render the schema first and validate each property against the spec's `PrimitiveSchemaDefinition`, raising `TypeError` at the call site for anything outside it. `Optional[T]` fields render as `{"type": ...}` with the field omitted from `required` (previously the non-spec `anyOf` shape). A bare `list[str]` field is rejected because it renders without the required enum items; use `list[Literal[...]]` or `list[str]` with `json_schema_extra` supplying the items. Unions of multiple primitives (e.g. `int | str`) and nested models are rejected.
 
 ### Replace `RootModel` by union types with `TypeAdapter` validation
 
@@ -947,7 +951,7 @@ from mcp.types import (
 )
 
 async def handle_list_tools(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult:
-    return ListToolsResult(tools=[Tool(name="my_tool", description="A tool", input_schema={})])
+    return ListToolsResult(tools=[Tool(name="my_tool", description="A tool", input_schema={"type": "object"})])
 
 
 async def handle_call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
 
@@ -14,7 +14,6 @@
 import hashlib
 import json
 import re
-import shutil
 import subprocess
 import sys
 import tempfile
@@ -35,22 +34,40 @@
         ("$defs/NumberSchema/properties/default/type", "integer", ["integer", "number"]),
         ("$defs/NumberSchema/properties/maximum/type", "integer", ["integer", "number"]),
         ("$defs/NumberSchema/properties/minimum/type", "integer", ["integer", "number"]),
+        # ``null`` arm is monolith superset leniency: hosts may answer optional form fields with null.
         (
             "$defs/ElicitResult/properties/content/additionalProperties/anyOf/1/type",
             ["string", "integer", "boolean"],
-            ["string", "integer", "number", "boolean"],
+            ["string", "integer", "number", "boolean", "null"],
+        ),
+        # Older python-sdk releases emit ``anyOf`` for Optional fields; the callback's
+        # own schema validation is the real gate, so accept any property shape inbound.
+        # PrimitiveSchemaDefinition becomes an orphan $def after this patch but
+        # datamodel-codegen still emits it; elicitation.py imports it as the gate type.
+        (
+            "$defs/ElicitRequestFormParams/properties/requestedSchema/properties/properties/additionalProperties",
+            {"$ref": "#/$defs/PrimitiveSchemaDefinition"},
+            {},
         ),
     ],
     "2026-07-28": [
         ("$defs/NumberSchema/properties/default/type", "number", ["integer", "number"]),
         ("$defs/NumberSchema/properties/maximum/type", "number", ["integer", "number"]),
         ("$defs/NumberSchema/properties/minimum/type", "number", ["integer", "number"]),
+        # ``null`` arm is monolith superset leniency: hosts may answer optional form fields with null.
         (
             "$defs/ElicitResult/properties/content/additionalProperties/anyOf/1/type",
             ["string", "integer", "boolean"],
-            ["string", "integer", "number", "boolean"],
+            ["string", "integer", "number", "boolean", "null"],
         ),
         ("$defs/JSONValue/anyOf/2/type", ["string", "integer", "boolean"], ["string", "integer", "number", "boolean"]),
+        # Older python-sdk releases emit ``anyOf`` for Optional fields; the callback's
+        # own schema validation is the real gate, so accept any property shape inbound.
+        (
+            "$defs/ElicitRequestFormParams/properties/requestedSchema/properties/properties/additionalProperties",
+            {"$ref": "#/$defs/PrimitiveSchemaDefinition"},
+            {},
+        ),
     ],
 }
 
@@ -107,13 +124,11 @@ def patch_schema(schema: dict[str, Any], patches: list[tuple[str, Any, Any]]) ->
 
 
 def run_codegen(schema_path: Path, output_path: Path) -> None:
-    """Run datamodel-code-generator (from the ``codegen`` dependency group)."""
-    exe = shutil.which("datamodel-codegen")
-    cmd = [exe] if exe else ["uv", "run", "--frozen", "--group", "codegen", "datamodel-codegen"]
+    """Run datamodel-code-generator at the version pinned in the ``codegen`` dependency group."""
     # fmt: off
     result = subprocess.run(
         [
-            *cmd,
+            "uv", "run", "--frozen", "--group", "codegen", "datamodel-codegen",
             "--input", str(schema_path),
             "--input-file-type", "jsonschema",
             "--output", str(output_path),
 
@@ -554,7 +554,10 @@ async def _on_notify(
         version = self.protocol_version or "2025-11-25"
         try:
             notification = cast(types.ServerNotification, _methods.parse_server_notification(method, version, params))
-        except (KeyError, ValidationError):
+        except KeyError:
+            logger.debug("dropped %r: not defined at %s", method, version)
+            return
+        except ValidationError:
             logger.warning("Failed to validate notification: %s", method, exc_info=True)
             return
         if isinstance(notification, types.CancelledNotification):
 
@@ -2,16 +2,18 @@
 
 from __future__ import annotations
 
-import types
-from typing import Any, Generic, Literal, TypeVar, Union, get_args, get_origin
+from typing import Any, Generic, Literal, TypeVar
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
 from pydantic_core import core_schema
 
 from mcp.server.session import ServerSession
 from mcp.types import RequestId
 
+# Internal surface package; imported as the gate's source of truth for spec-valid property schemas.
+from mcp.types.v2025_11_25 import PrimitiveSchemaDefinition
+
 ElicitSchemaModelT = TypeVar("ElicitSchemaModelT", bound=BaseModel)
 
 
@@ -46,10 +48,6 @@ class AcceptedUrlElicitation(BaseModel):
 UrlElicitationResult = AcceptedUrlElicitation | DeclinedElicitation | CancelledElicitation
 
 
-# Primitive types allowed in elicitation schemas
-_ELICITATION_PRIMITIVE_TYPES = (str, int, float, bool)
-
-
 class _ElicitationJsonSchema(GenerateJsonSchema):
     """JSON-Schema generator that flattens `T | None` to `T` and drops `None` defaults.
 
@@ -68,26 +66,20 @@ def default_schema(self, schema: core_schema.WithDefaultSchema) -> JsonSchemaVal
         return result
 
 
-def _validate_elicitation_schema(schema: type[BaseModel]) -> None:
-    """Validate that a Pydantic model only contains primitive field types."""
-    for field_name, field_info in schema.model_fields.items():
-        if not _is_primitive_field(field_info.annotation):
-            raise TypeError(
-                f"Elicitation schema field '{field_name}' must be a primitive type "
-                f"{_ELICITATION_PRIMITIVE_TYPES} or Optional of one. Unions of multiple "
-                f"primitives, lists, and nested models are not allowed."
-            )
-
+def _validate_rendered_properties(json_schema: dict[str, Any]) -> None:
+    """Reject any `properties` entry the spec's `PrimitiveSchemaDefinition` won't accept.
 
-def _is_primitive_field(annotation: Any) -> bool:
-    """True if `annotation` is a single primitive type, optionally wrapped in `Optional`."""
-    if annotation in _ELICITATION_PRIMITIVE_TYPES:
-        return True
-    origin = get_origin(annotation)
-    if origin is Union or origin is types.UnionType:
-        non_none = [a for a in get_args(annotation) if a is not types.NoneType]
-        return len(non_none) == 1 and non_none[0] in _ELICITATION_PRIMITIVE_TYPES
-    return False
+    Catches whatever the renderer let through that isn't spec-valid: bare
+    `list[str]` (no enum), multi-primitive unions, nested models.
+    """
+    for field_name, prop in json_schema.get("properties", {}).items():
+        try:
+            PrimitiveSchemaDefinition.model_validate(prop)
+        except ValidationError:
+            raise TypeError(
+                f"Elicitation schema field {field_name!r} rendered as {prop!r}, "
+                f"which is not a valid PrimitiveSchemaDefinition"
+            ) from None
 
 
 async def elicit_with_validation(
@@ -106,10 +98,8 @@ async def elicit_with_validation(
 
     For sensitive data like credentials or OAuth flows, use elicit_url() instead.
     """
-    # Validate that schema only contains primitive types and fail loudly if not
-    _validate_elicitation_schema(schema)
-
     json_schema = schema.model_json_schema(schema_generator=_ElicitationJsonSchema)
+    _validate_rendered_properties(json_schema)
 
     result = await session.elicit_form(
         message=message,
 
@@ -223,7 +223,7 @@ async def _on_request(
         # handshake (which only exists at <=2025) and stateless until the header
         # is plumbed; its meaning is fixed regardless of LATEST bumps.
         version = self.connection.protocol_version or "2025-11-25"
-        is_spec_method = method in _methods.MONOLITH_REQUESTS
+        is_spec_method = method in _methods.SPEC_CLIENT_METHODS
 
         async def _inner() -> HandlerResult:
             # Pinned compat: spec methods are surface-validated before lookup,
@@ -294,7 +294,7 @@ async def _on_notify(
         version = self.connection.protocol_version or "2025-11-25"
 
         async def _inner() -> None:
-            if method in _methods.MONOLITH_NOTIFICATIONS:
+            if method in _methods.SPEC_CLIENT_NOTIFICATION_METHODS:
                 try:
                     _methods.validate_client_notification(method, version, params)
                 except KeyError:
 
@@ -32,6 +32,8 @@
     "SERVER_NOTIFICATIONS",
     "SERVER_REQUESTS",
     "SERVER_RESULTS",
+    "SPEC_CLIENT_METHODS",
+    "SPEC_CLIENT_NOTIFICATION_METHODS",
     "parse_client_notification",
     "parse_client_request",
     "parse_client_result",
@@ -325,6 +327,15 @@
 """Results clients send, keyed by the originating server request's (method, version)."""
 
 
+# --- Direction-specific method sets ---
+
+SPEC_CLIENT_METHODS: Final[frozenset[str]] = frozenset(m for m, _ in CLIENT_REQUESTS)
+"""Spec request methods a client may send (any version); the server-side spec-method discriminator."""
+
+SPEC_CLIENT_NOTIFICATION_METHODS: Final[frozenset[str]] = frozenset(m for m, _ in CLIENT_NOTIFICATIONS)
+"""Spec notification methods a client may send (any version); the server-side spec-method discriminator."""
+
+
 # --- Monolith maps ---
 
 MONOLITH_REQUESTS: Final[Mapping[str, type[types.Request[Any, Any]]]] = MappingProxyType(
 
@@ -292,6 +292,21 @@ class Cursor(RootModel[str]):
     """
 
 
+class RequestedSchema(WireModel):
+    """
+    A restricted subset of JSON Schema.
+    Only top-level properties are allowed, without nesting.
+    """
+
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    schema_: Annotated[str | None, Field(alias="$schema")] = None
+    properties: dict[str, Any]
+    required: list[str] | None = None
+    type: Literal["object"]
+
+
 class ElicitResult(WireModel):
     """
     The client's response to an elicitation request.
@@ -311,7 +326,7 @@ class ElicitResult(WireModel):
     - "decline": User explicitly decline the action
     - "cancel": User dismissed without making an explicit choice
     """
-    content: dict[str, list[str] | str | int | float | bool] | None = None
+    content: dict[str, list[str] | str | int | float | bool | None] | None = None
     """
     The submitted form data, only present when action is "accept" and mode was "form".
     Contains values matching the requested schema.
@@ -1753,6 +1768,42 @@ class CompleteRequestParams(WireModel):
     ref: PromptReference | ResourceTemplateReference
 
 
+class ElicitRequestFormParams(WireModel):
+    """
+    The parameters for a request to elicit non-sensitive information from the user via a form in the client.
+    """
+
+    model_config = ConfigDict(
+        extra="ignore",
+    )
+    meta: Annotated[Meta | None, Field(alias="_meta")] = None
+    """
+    See [General fields: `_meta`](/specification/2025-11-25/basic/index#meta) for notes on `_meta` usage.
+    """
+    message: str
+    """
+    The message to present to the user describing what information is being requested.
+    """
+    mode: Literal["form"] = "form"
+    """
+    The elicitation mode.
+    """
+    requested_schema: Annotated[RequestedSchema, Field(alias="requestedSchema")]
+    """
+    A restricted subset of JSON Schema.
+    Only top-level properties are allowed, without nesting.
+    """
+    task: TaskMetadata | None = None
+    """
+    If specified, the caller is requesting task-augmented execution for this request.
+    The request will return a CreateTaskResult immediately, and the actual result can be
+    retrieved later via tasks/result.
+
+    Task augmentation is subject to capability negotiation - receivers MUST declare support
+    for task augmentation of specific request types in their capabilities.
+    """
+
+
 class ElicitRequestURLParams(WireModel):
     """
     The parameters for a request to elicit information from the user via a URL in the client.
@@ -2761,57 +2812,6 @@ class CreateTaskResult(WireModel):
     task: Task
 
 
-class RequestedSchema(WireModel):
-    """
-    A restricted subset of JSON Schema.
-    Only top-level properties are allowed, without nesting.
-    """
-
-    model_config = ConfigDict(
-        extra="ignore",
-    )
-    schema_: Annotated[str | None, Field(alias="$schema")] = None
-    properties: dict[str, PrimitiveSchemaDefinition]
-    required: list[str] | None = None
-    type: Literal["object"]
-
-
-class ElicitRequestFormParams(WireModel):
-    """
-    The parameters for a request to elicit non-sensitive information from the user via a form in the client.
-    """
-
-    model_config = ConfigDict(
-        extra="ignore",
-    )
-    meta: Annotated[Meta | None, Field(alias="_meta")] = None
-    """
-    See [General fields: `_meta`](/specification/2025-11-25/basic/index#meta) for notes on `_meta` usage.
-    """
-    message: str
-    """
-    The message to present to the user describing what information is being requested.
-    """
-    mode: Literal["form"] = "form"
-    """
-    The elicitation mode.
-    """
-    requested_schema: Annotated[RequestedSchema, Field(alias="requestedSchema")]
-    """
-    A restricted subset of JSON Schema.
-    Only top-level properties are allowed, without nesting.
-    """
-    task: TaskMetadata | None = None
-    """
-    If specified, the caller is requesting task-augmented execution for this request.
-    The request will return a CreateTaskResult immediately, and the actual result can be
-    retrieved later via tasks/result.
-
-    Task augmentation is subject to capability negotiation - receivers MUST declare support
-    for task augmentation of specific request types in their capabilities.
-    """
-
-
 class ElicitRequestParams(RootModel[ElicitRequestURLParams | ElicitRequestFormParams]):
     root: ElicitRequestURLParams | ElicitRequestFormParams
     """