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/test/core/mcp/inspectorClientUrlElicitation.test.ts

@@ -42,6 +42,10 @@ type FakeClient = {
  * we can drive `callTool` through the URL-elicitation error path without a live
  * server. The client is never connected; `callTool` only needs the injected
  * `callTool`/`request` methods plus the (connection-independent) helpers.
+ *
+ * The tool-call path issues `client.request({ method: "tools/call", … })`
+ * (through the MRTR driver, #1704), so these fakes drive the error path from
+ * `request`; `callTool` is left as an unused stub.
  */
 function makeClient(fake: FakeClient): InspectorClient {
   const client = new InspectorClient(
@@ -72,14 +76,14 @@ describe("InspectorClient URL-elicitation error path", () => {
   it("surfaces the URL elicitation, then retries the call on accept", async () => {
     let attempt = 0;
     const fake: FakeClient = {
-      callTool: vi.fn(async () => {
+      callTool: vi.fn(),
+      request: vi.fn(async () => {
         attempt += 1;
         if (attempt === 1) {
           throw new UrlElicitationRequiredError([elicitation]);
         }
         return okResult;
       }),
-      request: vi.fn(),
     };
     const client = makeClient(fake);
 
@@ -99,7 +103,7 @@ describe("InspectorClient URL-elicitation error path", () => {
 
     const invocation = await pending;
     expect(invocation.success).toBe(true);
-    expect(fake.callTool).toHaveBeenCalledTimes(2);
+    expect(fake.request).toHaveBeenCalledTimes(2);
     expect(client.getPendingElicitations()).toHaveLength(0);
   });
 
@@ -111,14 +115,14 @@ describe("InspectorClient URL-elicitation error path", () => {
     };
     let attempt = 0;
     const fake: FakeClient = {
-      callTool: vi.fn(async () => {
+      callTool: vi.fn(),
+      request: vi.fn(async () => {
         attempt += 1;
         if (attempt === 1) {
           throw new UrlElicitationRequiredError([elicitation, second]);
         }
         return okResult;
       }),
-      request: vi.fn(),
     };
     const client = makeClient(fake);
 
@@ -143,15 +147,15 @@ describe("InspectorClient URL-elicitation error path", () => {
 
     const invocation = await pending;
     expect(invocation.success).toBe(true);
-    expect(fake.callTool).toHaveBeenCalledTimes(2);
+    expect(fake.request).toHaveBeenCalledTimes(2);
   });
 
   it("aborts the call (no retry) when the user cancels a required elicitation", async () => {
     const fake: FakeClient = {
-      callTool: vi.fn(async () => {
+      callTool: vi.fn(),
+      request: vi.fn(async () => {
         throw new UrlElicitationRequiredError([elicitation]);
       }),
-      request: vi.fn(),
     };
     const client = makeClient(fake);
     const failedDispatches = trackFailedDispatches(client);
@@ -163,7 +167,7 @@ describe("InspectorClient URL-elicitation error path", () => {
     await client.getPendingElicitations()[0].respond({ action: "cancel" });
 
     await expect(pending).rejects.toThrow(/cancelled/i);
-    expect(fake.callTool).toHaveBeenCalledTimes(1);
+    expect(fake.request).toHaveBeenCalledTimes(1);
     // The abort records exactly one failed history entry — not zero, not a
     // duplicate from the generic catch.
     expect(failedDispatches()).toBe(1);
@@ -172,10 +176,10 @@ describe("InspectorClient URL-elicitation error path", () => {
   it("aborts with a loop error when the server re-requests a completed URL", async () => {
     // The server keeps returning the same URL after the user completes it.
     const fake: FakeClient = {
-      callTool: vi.fn(async () => {
+      callTool: vi.fn(),
+      request: vi.fn(async () => {
         throw new UrlElicitationRequiredError([elicitation]);
       }),
-      request: vi.fn(),
     };
     const client = makeClient(fake);
     const failedDispatches = trackFailedDispatches(client);
@@ -192,7 +196,7 @@ describe("InspectorClient URL-elicitation error path", () => {
     await expect(pending).rejects.toBeInstanceOf(UrlElicitationLoopError);
     await expect(pending).rejects.toMatchObject({ url: elicitation.url });
     // Only the initial call + one retry ran; the URL was presented just once.
-    expect(fake.callTool).toHaveBeenCalledTimes(2);
+    expect(fake.request).toHaveBeenCalledTimes(2);
     expect(client.getPendingElicitations()).toHaveLength(0);
     // The loop abort records exactly one failed history entry (the accepted
     // first round records nothing).
@@ -201,10 +205,10 @@ describe("InspectorClient URL-elicitation error path", () => {
 
   it("settles a pending error-path elicitation as cancelled on disconnect (no hang)", async () => {
     const fake: FakeClient = {
-      callTool: vi.fn(async () => {
+      callTool: vi.fn(),
+      request: vi.fn(async () => {
         throw new UrlElicitationRequiredError([elicitation]);
       }),
-      request: vi.fn(),
     };
     const client = makeClient(fake);
 
@@ -223,13 +227,13 @@ describe("InspectorClient URL-elicitation error path", () => {
 
   it("rethrows a -32042 error with no elicitations without queuing anything", async () => {
     const fake: FakeClient = {
-      callTool: vi.fn(async () => {
+      callTool: vi.fn(),
+      request: vi.fn(async () => {
         throw new ProtocolError(
           ProtocolErrorCode.UrlElicitationRequired,
           "This request requires browser-based authorization.",
         );
       }),
-      request: vi.fn(),
     };
     const client = makeClient(fake);
 
@@ -237,15 +241,15 @@ describe("InspectorClient URL-elicitation error path", () => {
       code: ProtocolErrorCode.UrlElicitationRequired,
     });
     expect(client.getPendingElicitations()).toHaveLength(0);
-    expect(fake.callTool).toHaveBeenCalledTimes(1);
+    expect(fake.request).toHaveBeenCalledTimes(1);
   });
 
   it("rethrows an ordinary error unchanged", async () => {
     const fake: FakeClient = {
-      callTool: vi.fn(async () => {
+      callTool: vi.fn(),
+      request: vi.fn(async () => {
         throw new Error("boom");
       }),
-      request: vi.fn(),
     };
     const client = makeClient(fake);
     const failed = vi.fn();