Tasks: io.modelcontextprotocol/tasks extension on modern servers (era fork) (#1731)

* Tasks: modern io.modelcontextprotocol/tasks extension (era fork core)

Core + test-server implementation of the SEP-2663 tasks extension for modern
(2026-07-28) connections, forked from the legacy 2025-11-25 tasks path.

SDK v2 removed all tasks support AND era-gates the tasks/* spec methods out of
the modern era on both the client (outbound) and server (inbound) sides, and its
codec rejects a resultType:"task" result outright. So the Inspector drives the
extension itself: task creation rides tools/call (a modern method) with the
resultType:"task" frame rewritten at the transport to a CallToolResult carrying
the handle in _meta; tasks/get/update/cancel go over a raw-wire request channel
that bypasses the era gate (full modern envelope, string ids, consumed by the
transport). input_required tasks reuse the existing pending-request modal via
fulfilInputRequests, answered with tasks/update. No tasks/list, no tasks/result.

Tab + run-as-task gate on the negotiated extension; the managed task store's
refresh re-polls known handles on modern (no server list). Test server serves
the extension via an Express interceptor (SDK can't) + a shared poll-driven
runtime. Full integration coverage of both eras.

Refs #1631

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

* Tasks modern era: tests + coverage (raw-wire, schemas, era integration)

Adds unit coverage for modernTaskSchemas and the raw-wire request channel
(transport-null guard, send failure, timeout, error response, teardown), plus
end-to-end era integration tests (create/poll/input-required/update/cancel,
synchronous passthrough, unknown-id error, modern store re-poll). Fixes the App
and constructor-capabilities tests for the always-on tasks extension.

Refs #1631

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

* Tasks modern era: docs + share test servers per era to de-flake coverage

Document the tasks era-fork test configs in README and the new core/test-server
files in AGENTS.md. Share one modern + one legacy test server across the era
integration block (started lazily, stopped in afterAll) — starting a fresh
Express server per test made connection negotiation flaky under the heavy
concurrent coverage run.

Refs #1631

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

* Restore pr-screenshots deleted inadvertently

The logging/subscriptions PR screenshots + README were staged-deleted in the
working tree before this branch; restore them from v2/main so this PR doesn't
remove other PRs' artifacts.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

* Tasks modern era: offer Run-as-task for any tool + PR screenshots

On modern (SEP-2663) task creation is server-directed — the client declares the
extension once and any tool may return a task — so the Tools screen now offers
'Run as task' for every tool on a modern connection (threaded via a modernTasks
prop through InspectorView → ToolsScreen → ToolDetailPanel), rather than gating
on the legacy per-tool taskSupport. Verified end-to-end in the web UI (remote
proxy): create → poll tasks/get → input_required elicitation → tasks/update →
inline result, plus the unchanged legacy tasks/list/result flow. Adds proof
screenshots.

Refs #1631

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

* Tasks modern era: address two follow-ups (task-input note + ordinary-path auto-poll)

1. The pending-request note now distinguishes a modern task round from an MRTR
   round: a new 'task-input-required' PendingRequestOrigin threads through
   fulfilInputRequests → the pending-request modal → MrtrOriginNote, which shows
   'submitted via a tasks/update request (SEP-2663), not a retry' instead of the
   MRTR retry copy.

2. The ordinary (non-run-as-task) modern callTool path now auto-polls an
   unsolicited task handle: attemptToolCall detects the rewritten handle in the
   result _meta and drives it to termination (get → input_required/update →
   inline result), dispatching task events so the Tasks tab + toasts track it and
   the tool result resolves to the task's final result. The poll loop is shared
   with the streaming path via extracted helpers (submitModernTaskInput /
   modernTaskTerminalOutcome / modernTaskPollInterval).

Refs #1631

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

* Tasks modern era: address review (negotiated envelope version, input-round cap, clarifying comment) + fresh smoke screenshots

Review of #1731:
1. withModernTaskEnvelope now stamps the NEGOTIATED protocol version
   (getProtocolVersion() ?? MODERN_PROTOCOL_VERSION) so the envelope matches the
   MCP-Protocol-Version header instead of a hardcoded constant.
2. A never-completing input_required task is now bounded by MRTR_MAX_ROUNDS in the
   shared submitModernTaskInput (threaded through both poll loops), so a
   non-conformant server can't re-prompt the user forever. New modern_loop_task
   test-server tool + integration test cover the cap.
3. ToolDetailPanel: comment clarifying that per-tool taskSupport:"forbidden" is
   deliberately ignored on modern (task creation is server-directed under SEP-2663).

(The abort-during-poll observation is addressed in the PR reply: the cancel path
uses tasks/cancel and disconnect rejects the in-flight raw request, so the poll
stops; matches legacy.)

Fresh web-UI smoke screenshots (modern connected, task completed, input_required
with the corrected tasks/update note, input completed).

Refs #1631

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

* Tasks modern era: fix uncancelable input-required loop + sticky cancel

Two bug fixes reported during manual testing of the tasks era-fork (#1631):

1. A modern task paused at `input_required` (e.g. `modern_loop_task`, which
   never advances) could not be cancelled: the poll loop blocked on the
   pending-request modal, so `cancelRequestorTask` sent `tasks/cancel` but the
   modal kept re-prompting. Now each modern poll loop registers a per-task
   AbortController (`registerTaskInputAbort`), `cancelRequestorTask` aborts it
   to reject the pending elicitation and unblock the poll, and the embedded
   input requests are tagged with their owning task id
   (`RELATED_TASK_META_KEY`) so the pending-request UI's Cancel action cancels
   the TASK rather than sending a "cancel" answer the server would re-prompt on.

2. On the legacy server, cancelling a task briefly showed CANCELLED then
   flipped to COMPLETED when the in-flight tool call resolved. Cancellation is
   a deliberate terminal decision, so `ManagedRequestorTasksState` now remembers
   cancelled task ids and ignores any later non-cancelled status update.

Also: move the compact task id onto its own line in the embedded monitoring
sidebar so the status badge / Cancel Task control don't wrap; DRY the duplicated
task poll-interval logic into a shared `taskPollInterval` helper.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

* Refresh tasks PR screenshots + capture both bug-fix scenarios

Recapture the five tasks flow screenshots against the current build and add
two demonstrating the post-review fixes: modern_loop_task cancelled from the
pending-request modal (uncancelable-loop fix) and a legacy task staying
CANCELLED after the in-flight call resolves (sticky-cancel fix).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

* Address re-review: sticky cancel on legacy refresh + App cancel-routing test

Re-review of the cancelable-loop / sticky-cancel fix raised two non-blocking
hardening items:

1. The legacy tasks/list refresh() rebuilt the list from the server, honoring
   only dismissedTaskIds — so a cooperative-cancel server that re-lists a
   user-cancelled task as completed could un-stick the cancel on a manual
   Refresh. The refresh path now pins a cancelledTaskIds task to "cancelled"
   (keeping it visible-as-cancelled, matching the live-merge handlers) rather
   than dropping it. Covered by a new state test.

2. Added an App.test.tsx case locking in the user-facing half of the fix: Cancel
   on a task-input-required elicitation calls cancelRequestorTask (not respond).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01XNdjEPKLG637X8YmhDiEk5

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

clients/web/src/components/elements/MrtrOriginNote/MrtrOriginNote.stories.tsx

@@ -13,6 +13,10 @@ export const InputRequired: Story = {
   args: { origin: "input-required" },
 };
 
+export const TaskInputRequired: Story = {
+  args: { origin: "task-input-required" },
+};
+
 export const ServerRequest: Story = {
   args: { origin: "server-request" },
 };

clients/web/src/components/elements/MrtrOriginNote/MrtrOriginNote.test.tsx

@@ -9,6 +9,16 @@ describe("MrtrOriginNote", () => {
     expect(screen.getByText(/sent back as a retry/i)).toBeInTheDocument();
   });
 
+  it("renders the tasks/update note for a modern task input-required round (#1631)", () => {
+    renderWithMantine(<MrtrOriginNote origin="task-input-required" />);
+    expect(screen.getByText("input_required")).toBeInTheDocument();
+    expect(
+      screen.getByText(/submitted via a tasks\/update request/i),
+    ).toBeInTheDocument();
+    // The task note must NOT claim the answer is a retry (that's the MRTR case).
+    expect(screen.queryByText(/sent back as a retry/i)).not.toBeInTheDocument();
+  });
+
   it("renders nothing for a legacy server request", () => {
     renderWithMantine(<MrtrOriginNote origin="server-request" />);
     expect(screen.queryByText("input_required")).not.toBeInTheDocument();

clients/web/src/components/elements/MrtrOriginNote/MrtrOriginNote.tsx

@@ -6,7 +6,8 @@ export interface MrtrOriginNoteProps {
    * How the pending request reached the Inspector. `"server-request"` (the
    * default) is a legacy server→client request and renders nothing, keeping the
    * panel visually identical to its pre-MRTR form. `"input-required"` is a
-   * modern (2026-07-28) MRTR round and renders the era-accurate note.
+   * modern (2026-07-28) MRTR round and `"task-input-required"` is a modern task
+   * (SEP-2663) round — each renders its own era-accurate note.
    */
   origin?: PendingRequestOrigin;
 }
@@ -22,27 +23,37 @@ const NoteText = Text.withProps({
   c: "dimmed",
 });
 
+// The two modern origins differ in HOW the answer is delivered: an MRTR round
+// retries the original call with the answer (SEP-2322); a task round submits it
+// via a separate `tasks/update` request (SEP-2663). The note is accurate to each
+// so a user debugging the wire isn't told to expect the wrong follow-up frame.
+const NOTE_BY_ORIGIN: Partial<Record<PendingRequestOrigin, string>> = {
+  "input-required":
+    "The server returned input_required; your answer is sent back as a retry of the original request (MRTR).",
+  "task-input-required":
+    "This task reached input_required; your answer is submitted via a tasks/update request (SEP-2663), not a retry.",
+};
+
 /**
- * Era-accurate note for a pending sampling/elicitation request. On a modern
- * MRTR round (`origin: "input-required"`, SEP-2322) the request was embedded in
- * a tool-call/prompt/resource `input_required` result rather than sent as a
- * server→client JSON-RPC request, and the user's answer is echoed back to the
- * server as a retry of the original call. Legacy requests
- * (`origin: "server-request"`) render nothing so their panels are unchanged.
+ * Era-accurate note for a pending sampling/elicitation request. A modern MRTR
+ * round (`origin: "input-required"`, SEP-2322) embeds the request in a
+ * tool-call/prompt/resource `input_required` result and retries the original
+ * call with the answer; a modern task round (`origin: "task-input-required"`,
+ * SEP-2663) surfaces it from the task's `inputRequests` and submits the answer
+ * via `tasks/update`. Legacy requests (`origin: "server-request"`) render
+ * nothing so their panels are unchanged.
  */
 export function MrtrOriginNote({
   origin = "server-request",
 }: MrtrOriginNoteProps) {
-  if (origin !== "input-required") return null;
+  const note = NOTE_BY_ORIGIN[origin];
+  if (!note) return null;
   return (
     <NoteRow>
       <Badge variant="outline" color="blue">
         input_required
       </Badge>
-      <NoteText>
-        The server returned input_required; your answer is sent back as a retry
-        of the original request (MRTR).
-      </NoteText>
+      <NoteText>{note}</NoteText>
     </NoteRow>
   );
 }