MRTR: drive input_required manually to keep pending-request UX (#1704) (#1719)

* MRTR: drive input_required manually to keep pending-request UX (#1704)

Follow-up to #1627/#1705. Instead of letting the SDK auto-fulfil the modern
(2026-07-28) MRTR retry loop, InspectorClient now drives it itself so the
Inspector keeps its pending-request UX, owns the loop, and shows era-accurate
semantics.

Core (core/mcp/inspectorClient.ts):
- Construct the SDK Client with `inputRequired: { autoFulfill: false }`
  (unconditional; a no-op on legacy, which never returns input_required).
- New `requestWithInputRequired()` driver: issues the request with
  `allowInputRequired` + `withInputRequired(schema)`, and while the result is
  `input_required`, fulfils each embedded request through the SAME pending
  sampling/elicitation plumbing, then retries the original call with
  `inputResponses` + the echoed `requestState` on a fresh id, bounded by
  MRTR_MAX_ROUNDS.
- Route tools/call, prompts/get, and resources/read through the driver.
- Embedded roots/list is auto-answered from configured roots (no pending UX);
  decline/cancel is echoed to the server (not treated as an abort); a tool-call
  abort mid-round settles the pending request and surfaces
  ToolCallCancelledError.
- Extract shared `enqueuePendingSample`/`enqueuePendingElicitation` helpers used
  by both the legacy inbound handlers and the driver; add a per-request `origin`
  ("server-request" | "input-required") to the pending wrappers.

Web UI:
- New `MrtrOriginNote` element shows an "input_required — your answer returns as
  a retry" note on a modern MRTR round; legacy panels are unchanged.
- Thread `origin` App -> PendingClientRequestModal -> the sampling/elicitation
  panels (and the inline panels).

Test servers: new MRTR presets (multi-round, roots, sampling, loop, edge-case
param shaping). Integration tests cover the manual round-trip (asserting the
pending UI pauses and the retry carries inputResponses + requestState on a new
id), multi-round, roots auto-answer, sampling, decline-echoed, maxRounds bound,
abort mid-round, and requestState-only/inputRequests-only param shaping.

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

* Review: clarify sampling-reject and between-rounds abort comments (#1704)

Address review nits on PR #1719 (comment-only, no behavior change):
- enqueuePendingSample docstring: sampling has no decline/cancel action; the
  panel either sends a result (resolve) or Rejects (reject → fails the call).
  The shared "declined/cancelled resolves" wording was accurate only for the
  elicitation case.
- callToolWithRetries abort comment: note the between-rounds case — when the
  abort lands while an MRTR round awaits an embedded pending request there is no
  in-flight SDK request, so nothing is sent on the wire; the outcome
  (ToolCallCancelledError, no failed-call record) is identical.

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

* test-servers: add mrtr-showcase config exercising every MRTR preset (#1704)

A single modern-era streamable-HTTP server (port 3111) bundling all six MRTR
presets — mrtr_confirm, mrtr_two_step, mrtr_sample, mrtr_roots, mrtr_edge,
mrtr_loop — for manual testing of the manual-driving pending-request UX across
single-round, multi-round, sampling, roots, param-shaping, and maxRounds paths.
Document it in the README alongside modern-mrtr-http.json.

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

@@ -0,0 +1,18 @@
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import { MrtrOriginNote } from "./MrtrOriginNote";
+
+const meta: Meta<typeof MrtrOriginNote> = {
+  title: "Elements/MrtrOriginNote",
+  component: MrtrOriginNote,
+};
+
+export default meta;
+type Story = StoryObj<typeof MrtrOriginNote>;
+
+export const InputRequired: Story = {
+  args: { origin: "input-required" },
+};
+
+export const ServerRequest: Story = {
+  args: { origin: "server-request" },
+};

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

@@ -0,0 +1,23 @@
+import { describe, it, expect } from "vitest";
+import { renderWithMantine, screen } from "../../../test/renderWithMantine";
+import { MrtrOriginNote } from "./MrtrOriginNote";
+
+describe("MrtrOriginNote", () => {
+  it("renders the MRTR note for a modern input-required round", () => {
+    renderWithMantine(<MrtrOriginNote origin="input-required" />);
+    expect(screen.getByText("input_required")).toBeInTheDocument();
+    expect(screen.getByText(/sent back as a retry/i)).toBeInTheDocument();
+  });
+
+  it("renders nothing for a legacy server request", () => {
+    renderWithMantine(<MrtrOriginNote origin="server-request" />);
+    expect(screen.queryByText("input_required")).not.toBeInTheDocument();
+    expect(screen.queryByText(/sent back as a retry/i)).not.toBeInTheDocument();
+  });
+
+  it("defaults to rendering nothing when origin is omitted", () => {
+    renderWithMantine(<MrtrOriginNote />);
+    expect(screen.queryByText("input_required")).not.toBeInTheDocument();
+    expect(screen.queryByText(/sent back as a retry/i)).not.toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,48 @@
+import { Badge, Group, Text } from "@mantine/core";
+import type { PendingRequestOrigin } from "@inspector/core/mcp/types.js";
+
+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.
+   */
+  origin?: PendingRequestOrigin;
+}
+
+const NoteRow = Group.withProps({
+  gap: "xs",
+  align: "center",
+  wrap: "nowrap",
+});
+
+const NoteText = Text.withProps({
+  size: "xs",
+  c: "dimmed",
+});
+
+/**
+ * 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.
+ */
+export function MrtrOriginNote({
+  origin = "server-request",
+}: MrtrOriginNoteProps) {
+  if (origin !== "input-required") 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>
+    </NoteRow>
+  );
+}