Address PR review: align URL elicitation with spec

Remove non-spec types and methods per reviewer feedback:
- Remove ElicitTrackRequest, ElicitTrackRequestParams, ElicitTrackResult
- Remove track_elicitation() method from ClientSession
- Revert CONNECTION_CLOSED to -32000 (no conflict with -32042)

Align type structure with spec's discriminated union:
- Create separate ElicitRequestFormParams and ElicitRequestURLParams
- Make ElicitRequestParams a TypeAlias for the union
- Form mode now requires requestedSchema (per spec)
- URL mode requires url and elicitationId (per spec)

Fix ElicitResult.content type to match spec:
- Add list[str] support for array values
- Remove float and None (not in spec)

Consolidate error types:
- Remove redundant UrlElicitationInfo
- Use ElicitRequestURLParams in ElicitationRequiredErrorData

Update server session to use new typed params classes.

Author: cbcoutinho

src/mcp/client/session.py

@@ -509,29 +509,6 @@ async def list_tools(
 
         return result
 
-    async def track_elicitation(
-        self,
-        elicitation_id: str,
-        progress_token: types.ProgressToken | None = None,
-    ) -> types.ElicitTrackResult:
-        """Send an elicitation/track request to monitor URL mode elicitation progress.
-
-        Args:
-            elicitation_id: The unique identifier of the elicitation to track
-            progress_token: Optional token for receiving progress notifications
-
-        Returns:
-            ElicitTrackResult indicating the status of the elicitation
-        """
-        params = types.ElicitTrackRequestParams(elicitationId=elicitation_id)  # pragma: no cover
-        if progress_token is not None:  # pragma: no cover
-            params.meta = types.RequestParams.Meta(progressToken=progress_token)
-
-        return await self.send_request(  # pragma: no cover
-            types.ClientRequest(types.ElicitTrackRequest(params=params)),
-            types.ElicitTrackResult,
-        )
-
     async def send_roots_list_changed(self) -> None:  # pragma: no cover
         """Send a roots/list_changed notification."""
         await self.send_notification(types.ClientNotification(types.RootsListChangedNotification()))

src/mcp/server/elicitation.py

@@ -139,8 +139,8 @@ async def elicit_url(
     - Any interaction where data should not pass through the LLM context
 
     The response indicates whether the user consented to navigate to the URL.
-    The actual interaction happens out-of-band, and you can track progress using
-    session.track_elicitation().
+    The actual interaction happens out-of-band. When the elicitation completes,
+    the server should send an ElicitCompleteNotification to notify the client.
 
     Args:
         session: The server session

src/mcp/server/session.py

@@ -370,8 +370,7 @@ async def elicit_form(
         return await self.send_request(
             types.ServerRequest(
                 types.ElicitRequest(
-                    params=types.ElicitRequestParams(
-                        mode="form",
+                    params=types.ElicitRequestFormParams(
                         message=message,
                         requestedSchema=requestedSchema,
                     ),
@@ -405,8 +404,7 @@ async def elicit_url(
         return await self.send_request(
             types.ServerRequest(
                 types.ElicitRequest(
-                    params=types.ElicitRequestParams(
-                        mode="url",
+                    params=types.ElicitRequestURLParams(
                         message=message,
                         url=url,
                         elicitationId=elicitation_id,

src/mcp/types.py

@@ -151,8 +151,8 @@ class JSONRPCResponse(BaseModel):
 """Error code indicating that a URL mode elicitation is required before the request can be processed."""
 
 # SDK error codes
-CONNECTION_CLOSED = -32001
-# REQUEST_TIMEOUT = -32002  # the typescript sdk uses this
+CONNECTION_CLOSED = -32000
+# REQUEST_TIMEOUT = -32001  # the typescript sdk uses this
 
 # Standard JSON-RPC error codes
 PARSE_ERROR = -32700
@@ -1462,22 +1462,6 @@ class ElicitCompleteNotification(
     params: ElicitCompleteNotificationParams
 
 
-class ElicitTrackRequestParams(RequestParams):
-    """Parameters for elicitation tracking requests."""
-
-    elicitationId: str
-    """The unique identifier of the elicitation to track."""
-
-    model_config = ConfigDict(extra="allow")
-
-
-class ElicitTrackRequest(Request[ElicitTrackRequestParams, Literal["elicitation/track"]]):
-    """A request from the client to track progress of a URL mode elicitation."""
-
-    method: Literal["elicitation/track"] = "elicitation/track"
-    params: ElicitTrackRequestParams
-
-
 class ClientRequest(
     RootModel[
         PingRequest
@@ -1493,7 +1477,6 @@ class ClientRequest(
         | UnsubscribeRequest
         | CallToolRequest
         | ListToolsRequest
-        | ElicitTrackRequest
     ]
 ):
     pass
@@ -1510,34 +1493,58 @@ class ClientNotification(
 """Schema for elicitation requests."""
 
 
-class ElicitRequestParams(RequestParams):
-    """Parameters for elicitation requests.
+class ElicitRequestFormParams(RequestParams):
+    """Parameters for form mode elicitation requests.
 
-    The mode field determines the type of elicitation:
-    - "form": In-band structured data collection with optional schema validation
-    - "url": Out-of-band interaction via URL navigation
+    Form mode collects non-sensitive information from the user via an in-band form
+    rendered by the client.
     """
 
-    mode: Literal["form", "url"]
-    """The mode of elicitation (form or url)."""
+    mode: Literal["form"] = "form"
+    """The elicitation mode (always "form" for this type)."""
 
     message: str
-    """A human-readable message explaining why the interaction is needed."""
+    """The message to present to the user describing what information is being requested."""
+
+    requestedSchema: ElicitRequestedSchema
+    """
+    A restricted subset of JSON Schema defining the structure of expected response.
+    Only top-level properties are allowed, without nesting.
+    """
 
-    # Form mode fields
-    requestedSchema: ElicitRequestedSchema | None = None
-    """JSON Schema defining the structure of expected response (form mode only)."""
+    model_config = ConfigDict(extra="allow")
+
+
+class ElicitRequestURLParams(RequestParams):
+    """Parameters for URL mode elicitation requests.
+
+    URL mode directs users to external URLs for sensitive out-of-band interactions
+    like OAuth flows, credential collection, or payment processing.
+    """
+
+    mode: Literal["url"] = "url"
+    """The elicitation mode (always "url" for this type)."""
+
+    message: str
+    """The message to present to the user explaining why the interaction is needed."""
 
-    # URL mode fields
-    url: str | None = None
-    """The URL that the user should navigate to (url mode only)."""
+    url: str
+    """The URL that the user should navigate to."""
 
-    elicitationId: str | None = None
-    """A unique identifier for the elicitation (url mode only)."""
+    elicitationId: str
+    """
+    The ID of the elicitation, which must be unique within the context of the server.
+    The client MUST treat this ID as an opaque value.
+    """
 
     model_config = ConfigDict(extra="allow")
 
 
+# Union type for elicitation request parameters
+ElicitRequestParams: TypeAlias = ElicitRequestURLParams | ElicitRequestFormParams
+"""Parameters for elicitation requests - either form or URL mode."""
+
+
 class ElicitRequest(Request[ElicitRequestParams, Literal["elicitation/create"]]):
     """A request from the server to elicit information from the client."""
 
@@ -1556,59 +1563,29 @@ class ElicitResult(Result):
     - "cancel": User dismissed without making an explicit choice
     """
 
-    content: dict[str, str | int | float | bool | None] | None = None
+    content: dict[str, str | int | bool | list[str]] | None = None
     """
     The submitted form data, only present when action is "accept" in form mode.
-    Contains values matching the requested schema.
+    Contains values matching the requested schema. Values can be strings, integers,
+    booleans, or arrays of strings.
     For URL mode, this field is omitted.
     """
 
 
-class ElicitTrackResult(Result):
-    """The server's response to an elicitation tracking request."""
-
-    status: Literal["pending", "complete"]
-    """
-    The status of the elicitation.
-    - "pending": The elicitation is still in progress
-    - "complete": The elicitation has been completed
-    """
-
-    model_config = ConfigDict(extra="allow")
-
-
-class UrlElicitationInfo(BaseModel):
-    """Information about a URL mode elicitation embedded in an ElicitationRequired error."""
-
-    mode: Literal["url"] = "url"
-    """The mode of elicitation (must be "url")."""
-
-    elicitationId: str
-    """A unique identifier for the elicitation."""
-
-    url: str
-    """The URL that the user should navigate to."""
-
-    message: str
-    """A human-readable message explaining why the interaction is needed."""
-
-    model_config = ConfigDict(extra="allow")
-
-
 class ElicitationRequiredErrorData(BaseModel):
-    """Error data for ElicitationRequired errors.
+    """Error data for URLElicitationRequiredError.
 
     Servers return this when a request cannot be processed until one or more
     URL mode elicitations are completed.
     """
 
-    elicitations: list[UrlElicitationInfo]
+    elicitations: list[ElicitRequestURLParams]
     """List of URL mode elicitations that must be completed."""
 
     model_config = ConfigDict(extra="allow")
 
 
-class ClientResult(RootModel[EmptyResult | CreateMessageResult | ListRootsResult | ElicitResult | ElicitTrackResult]):
+class ClientResult(RootModel[EmptyResult | CreateMessageResult | ListRootsResult | ElicitResult]):
     pass
 
 

tests/server/fastmcp/test_elicitation.py

@@ -7,6 +7,7 @@
 import pytest
 from pydantic import BaseModel, Field
 
+from mcp import types
 from mcp.client.session import ClientSession, ElicitationFnT
 from mcp.server.fastmcp import Context, FastMCP
 from mcp.server.session import ServerSession
@@ -247,8 +248,8 @@ async def defaults_tool(ctx: Context[ServerSession, None]) -> str:
     # First verify that defaults are present in the JSON schema sent to clients
     async def callback_schema_verify(context: RequestContext[ClientSession, None], params: ElicitRequestParams):
         # Verify the schema includes defaults
+        assert isinstance(params, types.ElicitRequestFormParams), "Expected form mode elicitation"
         schema = params.requestedSchema
-        assert schema is not None, "Schema should not be None for form mode elicitation"
         props = schema["properties"]
 
         assert props["name"]["default"] == "Guest"

tests/server/fastmcp/test_url_elicitation.py

@@ -157,9 +157,12 @@ async def check_url_response(ctx: Context[ServerSession, None]) -> str:
         return f"Action: {result.action}, Content: {result.content}"
 
     async def elicitation_callback(context: RequestContext[ClientSession, None], params: ElicitRequestParams):
-        # Verify that no content field is expected for URL mode
+        # Verify that this is URL mode
         assert params.mode == "url"
-        assert params.requestedSchema is None
+        assert isinstance(params, types.ElicitRequestURLParams)
+        # URL params have url and elicitationId, not requestedSchema
+        assert params.url == "https://example.com/test"
+        assert params.elicitationId == "test-001"
         # Return without content - this is correct for URL mode
         return ElicitResult(action="accept")
 
@@ -195,9 +198,9 @@ async def ask_name(ctx: Context[ServerSession, None]) -> str:
     async def elicitation_callback(context: RequestContext[ClientSession, None], params: ElicitRequestParams):
         # Verify form mode parameters
         assert params.mode == "form"
+        assert isinstance(params, types.ElicitRequestFormParams)
+        # Form params have requestedSchema, not url/elicitationId
         assert params.requestedSchema is not None
-        assert params.url is None
-        assert params.elicitationId is None
         return ElicitResult(action="accept", content={"name": "Alice"})
 
     async with create_connected_server_and_client_session(
@@ -261,25 +264,6 @@ async def test_url_elicitation_required_error_code():
     )
 
 
-@pytest.mark.anyio
-async def test_track_elicitation_method_exists():
-    """Test that track_elicitation method exists on ClientSession."""
-    # This test just verifies the method signature and parameter handling exist
-    # without actually calling the server (which may not implement it yet)
-    import inspect
-
-    from mcp.client.session import ClientSession
-
-    # Verify the method exists
-    assert hasattr(ClientSession, "track_elicitation")
-
-    # Verify the method signature
-    sig = inspect.signature(ClientSession.track_elicitation)
-    params = list(sig.parameters.keys())
-    assert "elicitation_id" in params
-    assert "progress_token" in params
-
-
 @pytest.mark.anyio
 async def test_elicit_url_typed_results():
     """Test that elicit_url returns properly typed result objects."""