Address follow-up review: thread poll timeouts, honor the confirm answer

- Client.call_tool's per-call read_timeout_seconds now bounds each
  tasks/get poll as well as the initial call (per-request bound, not a
  whole-loop deadline); pinned by a recording test.
- The everything-server's confirm_delete keeps the file when an accepted
  elicitation answers confirm: false (conformance legs re-verified).
- The routing-header parentheticals attribute the requirement to
  SEP-2663 and the header family to SEP-2243.

Author: maxisbey

examples/servers/everything-server/mcp_everything_server/server.py

@@ -612,8 +612,9 @@ async def confirm_delete(filename: str, ctx: Context) -> str | InputRequiredResu
     responses = ctx.input_responses
     if responses and "confirm" in responses:
         answer = responses["confirm"]
-        accepted = isinstance(answer, ElicitResult) and answer.action == "accept"
-        return f"Deleted {filename}" if accepted else f"Kept {filename}"
+        if isinstance(answer, ElicitResult) and answer.action == "accept" and (answer.content or {}).get("confirm"):
+            return f"Deleted {filename}"
+        return f"Kept {filename}"
     return InputRequiredResult(
         input_requests={
             "confirm": ElicitRequest(

examples/stories/tasks/README.md

@@ -48,8 +48,9 @@ finished (completed or failed) tasks live in a pluggable `TaskStore`
 (`Tasks(store=...)`, in-memory default) that enforces `default_ttl_ms`. Deferred
 to follow-ups, each needing deeper SDK plumbing: background execution (returning
 `working` tasks), the in-task `input_required`/`inputResponses` loop over
-`tasks/update`, and `notifications/tasks` (the SEP-2243 `Mcp-Name` routing
-header is already handled by the shared header table).
+`tasks/update`, and `notifications/tasks` (SEP-2663's `Mcp-Name` routing
+header — the SEP-2243 header family — is already handled by the shared header
+table).
 
 ## Spec
 

src/mcp/client/client.py

@@ -623,7 +623,8 @@ async def call_tool(
         Args:
             name: The name of the tool to call.
             arguments: Arguments to pass to the tool.
-            read_timeout_seconds: Timeout for each underlying `tools/call` round.
+            read_timeout_seconds: Timeout for each underlying `tools/call` round
+                and each `tasks/get` poll.
             progress_callback: Callback for progress updates.
             input_responses: Responses to seed the first call with (e.g. when
                 resuming from a persisted `InputRequiredResult`).
@@ -664,7 +665,7 @@ async def retry(
 
         result = await self._drive_input_required(await retry(input_responses, request_state), retry)
         if isinstance(result, CreateTaskResult):
-            return await self._drive_task(result, name)
+            return await self._drive_task(result, name, read_timeout_seconds=read_timeout_seconds)
         return result
 
     async def list_prompts(
@@ -745,19 +746,24 @@ async def dispatch(key: str, req: InputRequest) -> InputResponse | ErrorData:
             first, dispatch=dispatch, retry=retry, max_rounds=self.input_required_max_rounds
         )
 
-    async def _drive_task(self, created: CreateTaskResult, tool_name: str) -> CallToolResult:
+    async def _drive_task(
+        self, created: CreateTaskResult, tool_name: str, *, read_timeout_seconds: float | None = None
+    ) -> CallToolResult:
         """Poll an SEP-2663 task to its final `CallToolResult` (the transparent flow).
 
         The driver's `get_task` rounds go through `session.send_request`, so each
-        poll carries the session read timeout and the `Mcp-Name` routing header.
-        The polled result re-enters the same output-schema validation as the
-        direct path, so both paths surface identical guarantees.
+        poll carries the caller's per-request read timeout (falling back to the
+        session read timeout) and the `Mcp-Name` routing header. The polled
+        result re-enters the same output-schema validation as the direct path,
+        so both paths surface identical guarantees.
         """
         session = self.session
 
         async def get_task(task_id: str) -> GetTaskResult:
             request = GetTaskRequest(params=GetTaskRequestParams(task_id=task_id))
-            return await session.send_request(cast("types.ClientRequest", request), GetTaskResult)
+            return await session.send_request(
+                cast("types.ClientRequest", request), GetTaskResult, request_read_timeout_seconds=read_timeout_seconds
+            )
 
         result = await run_task_driver(created, get_task=get_task)
         if not result.is_error:

src/mcp/server/tasks.py

@@ -48,8 +48,9 @@
 excluded the call. Background execution (returning `working` tasks), the in-task
 `input_required`/`inputResponses` loop over `tasks/update`, and
 `notifications/tasks` over `subscriptions/listen` are deferred follow-ups, each
-needing deeper SDK plumbing. (The SEP-2243 `Mcp-Name: <taskId>` routing header
-is already handled by the shared header table in `mcp.shared.inbound`.)
+needing deeper SDK plumbing. (SEP-2663's `Mcp-Name: <taskId>` routing header --
+the SEP-2243 header family -- is already handled by the shared header table in
+`mcp.shared.inbound`.)
 
 Task ids are unguessable bearer capabilities: any caller presenting a valid id
 may poll the task. That is deliberate -- the modern wire has no sessions, and a

tests/server/test_tasks.py

@@ -268,6 +268,29 @@ async def test_declaring_client_call_tool_transparently_polls_to_the_call_tool_r
     assert result.meta is None
 
 
+async def test_call_tool_read_timeout_seconds_bounds_each_task_poll(monkeypatch: pytest.MonkeyPatch) -> None:
+    """SDK-defined: a caller's per-call `read_timeout_seconds` is forwarded to every
+    `tasks/get` poll as that request's own per-request bound (not a whole-loop
+    deadline), matching the bound the initial `tools/call` carries."""
+    async with Client(_tasks_server(), extensions={EXTENSION_ID: {}}) as client:
+        session = client.session
+        inner_send_request = session.send_request
+        timeouts_by_method: dict[str, list[float | None]] = {}
+
+        async def recording_send_request(
+            request: Any, result_type: Any, request_read_timeout_seconds: float | None = None, **kwargs: Any
+        ) -> Any:
+            timeouts_by_method.setdefault(request.method, []).append(request_read_timeout_seconds)
+            return await inner_send_request(request, result_type, request_read_timeout_seconds, **kwargs)
+
+        monkeypatch.setattr(session, "send_request", recording_send_request)
+        result = await client.call_tool("echo", {"text": "hi"}, read_timeout_seconds=7.5)
+
+    assert result == snapshot(types.CallToolResult(content=[types.TextContent(text="hi")]))
+    assert timeouts_by_method["tools/call"] == [7.5]
+    assert timeouts_by_method["tasks/get"] == [7.5]
+
+
 async def test_tool_error_result_under_augmentation_surfaces_as_is_error_call_tool_result() -> None:
     """SEP-2663: a tool result with `isError: true` is a `completed` task, so the
     transparent driver returns it as the ordinary error-shaped `CallToolResult`