Register the Tasks extension on the conformance fixture server

The everything-server now opts into Tasks with an allowlist augment
predicate, so every pre-existing tool stays synchronous while the new
task fixture tools (slow_compute, failing_job, protocol_error_job,
confirm_delete, multi_input, test_tool_with_task) exercise augmentation,
failed-task recording, the required-capability error, and the
MRTR-then-task composition. Eight of the nine baselined tasks-* expected
failures now pass and are removed; tasks-mrtr-input stays baselined with
an accurate rationale (tasks are born terminal -- the in-task
input_required/tasks/update resume loop is a documented follow-up).
Verified locally against the pinned harness: all four server legs green
with zero unexpected failures and zero stale baselines.

Author: maxisbey

.github/actions/conformance/expected-failures.yml

@@ -13,22 +13,26 @@
 client: []
 
 server:
-  # SEP-2663 (io.modelcontextprotocol/tasks): the SDK does not implement the
-  # tasks extension yet. These extension-tagged scenarios are selected only by
-  # the bare `--suite all` leg — extension scenarios never match a
-  # --spec-version filter and the active/draft suites exclude them — so these
-  # entries are inert for the other legs that read this file.
+  # SEP-2663 (io.modelcontextprotocol/tasks): the SDK implements the extension
+  # with tasks born terminal — the tool runs to completion inside the
+  # interceptor, so there is no background execution and no in-task
+  # `input_required` parking (see the deferred follow-ups in
+  # src/mcp/server/tasks.py). tasks-mrtr-input needs exactly that surface: a
+  # task that parks with `status:"input_required"` + a non-empty
+  # `inputRequests` map on tasks/get, resumes via the tasks/update
+  # inputResponses loop, and supports partial fulfillment across two pending
+  # keys. The everything-server's `confirm_delete`/`multi_input` fixtures
+  # therefore resolve their elicitation on the original `tools/call` (SEP-2322
+  # MRTR) and never mint a task, so all three checks fail with "did not create
+  # a task". Remove this entry when background task execution and the in-task
+  # input_required/tasks/update resume loop land. Extension-tagged scenarios
+  # are selected only by the bare `--suite all` leg — they never match a
+  # --spec-version filter and the active/draft suites exclude them — so this
+  # entry is inert for the other legs that read this file.
   #
   # `tasks-status-notifications` is intentionally NOT listed: the harness
   # skips it unconditionally (pending its rewrite against subscriptions/
   # listen), and a baseline entry for a scenario with no failing checks is
-  # flagged stale.
-  - tasks-lifecycle
-  - tasks-capability-negotiation
-  - tasks-wire-fields
-  - tasks-request-state-removal
+  # flagged stale. The other eight tasks-* scenarios pass against the
+  # everything-server's Tasks registration and are not listed either.
   - tasks-mrtr-input
-  - tasks-request-headers
-  - tasks-dispatch-and-envelope
-  - tasks-required-task-error
-  - tasks-mrtr-composition

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

@@ -12,9 +12,12 @@
 
 import click
 from mcp.server import ServerRequestContext
+from mcp.server.extension import require_client_extension
 from mcp.server.mcpserver import Context, MCPServer, RequestStateSecurity
 from mcp.server.mcpserver.prompts.base import Prompt, UserMessage
 from mcp.server.streamable_http import EventCallback, EventMessage, EventStore
+from mcp.server.tasks import EXTENSION_ID as TASKS_EXTENSION_ID
+from mcp.server.tasks import Tasks
 from mcp.shared.exceptions import MCPError
 from mcp_types import (
     AudioContent,
@@ -44,7 +47,7 @@
     TextResourceContents,
     UnsubscribeRequestParams,
 )
-from mcp_types.jsonrpc import MISSING_REQUIRED_CLIENT_CAPABILITY
+from mcp_types.jsonrpc import INTERNAL_ERROR, MISSING_REQUIRED_CLIENT_CAPABILITY
 from pydantic import BaseModel, Field
 
 logger = logging.getLogger(__name__)
@@ -100,9 +103,24 @@ async def replay_events_after(self, last_event_id: EventId, send_callback: Event
 # Fixed fixture key (RequestStateSecurity requires at least 32 bytes); a real deployment would load a shared secret.
 _REQUEST_STATE_KEY = b"everything-server-fixture-request-state-key"
 
+# SEP-2663 Tasks extension: only these fixture tools are task-augmented, so every
+# other tool keeps its synchronous behaviour even for clients that declare the
+# extension (the tasks conformance scenarios assert e.g. `greet` stays sync).
+TASK_AUGMENTED_TOOLS = frozenset(
+    {
+        "slow_compute",
+        "failing_job",
+        "protocol_error_job",
+        "confirm_delete",
+        "multi_input",
+        "test_tool_with_task",
+    }
+)
+
 mcp = MCPServer(
     name="mcp-conformance-test-server",
     request_state_security=RequestStateSecurity(keys=[_REQUEST_STATE_KEY]),
+    extensions=[Tasks(augment=lambda params: params.name in TASK_AUGMENTED_TOOLS)],
 )
 
 
@@ -532,6 +550,86 @@ async def test_input_required_result_capabilities(ctx: Context) -> InputRequired
     return InputRequiredResult(input_requests=requests, request_state="capability-gated")
 
 
+# SEP-2663 Tasks extension fixtures (io.modelcontextprotocol/tasks). The server
+# decides augmentation per call via the TASK_AUGMENTED_TOOLS allowlist above;
+# `greet` stays deliberately outside it as the synchronous contrast the tasks
+# scenarios assert on.
+
+CONFIRM_SCHEMA = {"type": "object", "properties": {"confirm": {"type": "boolean"}}, "required": ["confirm"]}
+
+
+@mcp.tool()
+def greet(name: str) -> str:
+    """Sync-only greeting tool; never task-augmented"""
+    return f"Hello, {name}!"
+
+
+@mcp.tool()
+def slow_compute(seconds: float, label: str = "") -> str:
+    """Task-supporting compute fixture (SEP-2663).
+
+    Conformance passes durations up to 60s and immediately polls or cancels, so
+    the fixture records the requested duration instead of sleeping — the
+    born-terminal task is then observable well inside the scenario timeouts.
+    """
+    return f"slow_compute({label or 'unlabelled'}) finished after {seconds}s"
+
+
+@mcp.tool()
+async def failing_job(ctx: Context) -> str:
+    """Task-required fixture: rejects non-declaring clients, then reports a tool error (SEP-2663)"""
+    require_client_extension(ctx.request_context, TASKS_EXTENSION_ID)
+    raise RuntimeError("failing_job always reports a tool execution error")
+
+
+@mcp.tool()
+def protocol_error_job() -> str:
+    """Task fixture that fails at the protocol level, recording a `failed` task (SEP-2663)"""
+    raise MCPError(code=INTERNAL_ERROR, message="protocol_error_job failed at the protocol level")
+
+
+@mcp.tool()
+async def confirm_delete(filename: str, ctx: Context) -> str | InputRequiredResult:
+    """Task fixture gathering a deletion confirmation via elicitation (SEP-2322 + SEP-2663)"""
+    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}"
+    return InputRequiredResult(
+        input_requests={
+            "confirm": ElicitRequest(
+                params=ElicitRequestFormParams(message=f"Really delete {filename}?", requested_schema=CONFIRM_SCHEMA)
+            )
+        }
+    )
+
+
+@mcp.tool()
+async def multi_input(ctx: Context) -> str | InputRequiredResult:
+    """Task fixture fanning out two simultaneous elicitations (SEP-2663 partial fulfillment probe)"""
+    responses = ctx.input_responses
+    if responses and {"first", "second"} <= responses.keys():
+        return "multi_input received both responses"
+    return InputRequiredResult(
+        input_requests={
+            "first": _name_elicitation("First input?"),
+            "second": _name_elicitation("Second input?"),
+        }
+    )
+
+
+@mcp.tool()
+async def test_tool_with_task(ctx: Context) -> str | InputRequiredResult:
+    """SEP-2663 MRTR-to-task composition fixture: gathers a name, then the final round becomes a task"""
+    responses = ctx.input_responses
+    if responses and "user_name" in responses:
+        answer = responses["user_name"]
+        name = answer.content.get("name", "stranger") if isinstance(answer, ElicitResult) and answer.content else "?"
+        return f"Hello, {name}! The gathered-name task is complete."
+    return InputRequiredResult(input_requests={"user_name": _name_elicitation()})
+
+
 # SEP-1613 / SEP-2106 JSON Schema 2020-12 fixture: a tool whose inputSchema carries
 # the full set of 2020-12 keywords the conformance scenario asserts on.