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

@@ -594,8 +594,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

@@ -51,8 +51,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/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=[TasksExtension()]) 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`