Polish the tasks surface from final review

- The polling driver floors a server-supplied negative pollIntervalMs
  to zero instead of crashing (trio) or busy-looping (asyncio); tested.
- Client.call_tool documents TaskInputRequiredError alongside the other
  task errors, and the docs and story prose catch up: routing headers
  are no longer listed as deferred, failed tasks are named alongside
  completed ones in the store wording, and the migration guide's old
  removal note now points at the landed extension.
- The tasks story imports EXTENSION_ID from mcp.shared.tasks.

Author: maxisbey

docs/advanced/tasks.md

@@ -27,7 +27,9 @@ then come back.
   `pollIntervalMs` hint, one second between polls in its absence — and surfaces
   only the final `CallToolResult`. A `failed` task raises the typed
   `TaskFailedError` carrying the inlined JSON-RPC error; a `cancelled` one raises
-  `TaskCancelledError`.
+  `TaskCancelledError`; an `input_required` one raises `TaskInputRequiredError` —
+  the automatic in-task input loop is not implemented yet, so drive that task
+  manually (below).
 
 Degradation is built in. A modern client that does not declare the extension is
 never augmented: it keeps getting plain `CallToolResult`s. And a legacy

docs/migration.md

@@ -1568,7 +1568,7 @@ Behavior changes:
 
 Tasks ([SEP-1686](https://github.com/modelcontextprotocol/modelcontextprotocol/issues/1686)) have been removed from the MCP specification and are no longer part of this SDK. The `mcp.client.experimental`, `mcp.server.experimental`, `mcp.shared.experimental`, and `mcp.server.lowlevel.experimental` modules have been removed, along with the `experimental` properties on `ClientSession`, `ServerSession`, `Server`, and `ServerRequestContext`. The corresponding `Task*` types remain in `mcp_types` as types-only definitions, except the `TaskExecutionMode` alias, whose literal is now inlined on `ToolExecution.task_support`.
 
-The 2026-07-28 revision reintroduces Tasks as an official extension: [SEP-2663](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2663), `io.modelcontextprotocol/tasks`, redesigned around polling (`tasks/get`) instead of a blocking `tasks/result`. This SDK does not implement the extension yet.
+Tasks have since returned as the built-in `Tasks` extension ([SEP-2663](https://modelcontextprotocol.io/seps/2663-tasks-extension.md)), with a different wire shape than the experimental SEP-1686 surface — see [Server extensions API](#server-extensions-api-sep-2133) above and [Tasks](advanced/tasks.md).
 
 ## Transports
 

examples/stories/tasks/README.md

@@ -47,11 +47,12 @@ uv run python -m stories.tasks.client --http
 
 This is the core SEP-2663 surface. The tool runs to completion inline, so a task
 is recorded directly as `completed` (the SEP allows any initial status), and
-completed 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`,
-`notifications/tasks`, and SEP-2243 task routing headers.
+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).
 
 ## Spec
 

examples/stories/tasks/client.py

@@ -15,8 +15,7 @@
 import mcp_types as types
 
 from mcp.client import Client, TasksExtension
-from mcp.server.tasks import EXTENSION_ID
-from mcp.shared.tasks import CreateTaskResult, GetTaskRequest, GetTaskRequestParams, GetTaskResult
+from mcp.shared.tasks import EXTENSION_ID, CreateTaskResult, GetTaskRequest, GetTaskRequestParams, GetTaskResult
 from stories._harness import Target, run_client
 
 

src/mcp/client/_tasks.py

@@ -127,7 +127,7 @@ async def run_task_driver(
         if snapshot.status == "input_required":
             raise TaskInputRequiredError(created.task_id)
         interval_ms = snapshot.poll_interval_ms if snapshot.poll_interval_ms is not None else created.poll_interval_ms
-        await sleep(DEFAULT_POLL_INTERVAL_SECONDS if interval_ms is None else interval_ms / 1000)
+        await sleep(DEFAULT_POLL_INTERVAL_SECONDS if interval_ms is None else max(0, interval_ms) / 1000)
 
 
 class TasksExtension(ClientExtension):

src/mcp/client/client.py

@@ -719,6 +719,15 @@ async def call_tool(
             MCPError: A callback returned `ErrorData` for an embedded input request.
             pydantic.ValidationError: The server returned a result that does not
                 conform to the negotiated protocol version.
+            TaskFailedError: The call was augmented into a task that `failed`
+                (a JSON-RPC error during execution).
+            TaskCancelledError: The call was augmented into a task that was
+                cancelled before completing.
+            TaskInputRequiredError: The call was augmented into a task that
+                reached `input_required`; the SDK's automatic in-task input
+                loop is not implemented yet — drive the task manually via
+                `session.call_tool(..., allow_claimed=True)` and the
+                `mcp.shared.tasks` wrappers.
         """
 
         async def retry(r: InputResponses | None, s: str | None) -> CallToolResult | InputRequiredResult | Result:

tests/client/test_tasks.py

@@ -149,6 +149,24 @@ async def test_no_interval_anywhere_falls_back_to_one_second() -> None:
     assert slept == [DEFAULT_POLL_INTERVAL_SECONDS] == [1.0]
 
 
+async def test_negative_poll_interval_is_floored_to_zero() -> None:
+    """SDK-defined: a misbehaving server's negative interval must not crash or
+    busy-loop the driver — it is floored to a zero-length sleep."""
+    get_task, _ = _scripted_get_task(
+        [
+            _snapshot("working", poll_interval_ms=-5000),
+            _snapshot("completed", result=dict(_COMPLETED_RESULT)),
+        ]
+    )
+    sleep, slept = _recording_sleep()
+
+    with anyio.fail_after(5):
+        result = await run_task_driver(_created(), get_task=get_task, sleep=sleep)
+
+    assert result.content == [TextContent(text="done")]
+    assert slept == [0.0]
+
+
 async def test_failed_snapshot_raises_task_failed_error_with_code_and_status_message() -> None:
     """SEP-2663: a `failed` task inlines the JSON-RPC error and SHOULD carry a
     `statusMessage` diagnostic — both surface on the typed error."""