Era-aware connection model & capability gating (#1626) (#1697)

* Era-aware connection model & capability gating (#1626)

Make protocol era (SEP §7.8) a first-class, per-server connection dimension,
orthogonal to the transport type, and drive the SDK Client's versionNegotiation
from it.

Config
- Add `ServerProtocolEra` ("legacy" | "auto" | "modern"), `DEFAULT_PROTOCOL_ERA`
  (legacy, per the SDK's don't-auto-probe guidance), `MODERN_PROTOCOL_VERSION`,
  and `eraToVersionNegotiation()` in core/mcp/types.ts.
- Persist `protocolEra` on `StoredMCPServer` / `InspectorServerSettings`,
  round-tripping through serverList.ts (omitting the default on disk) and the
  `/api/servers` read + write validators.

InspectorClient / state
- Thread `versionNegotiation` through `InspectorClientOptions` (default legacy),
  replacing the hardcoded pin. After connect, read `getProtocolEra()` /
  `getDiscoverResult()` / `getNegotiatedProtocolVersion()`, expose them via
  getters, dispatch `protocolEraChange` / `discoverResultChange`, and clear on
  disconnect. `useInspectorClient` surfaces `protocolEra` / `discoverResult`.

Web UI
- ServerSettingsForm: a Protocol Era selector bound to the per-server setting.
- ConnectionInfoContent: era-aware — Era badge, Session ("Sessionless" on
  modern), and a Discovery section (supported versions + extensions) from the
  `server/discover` result.

CLI/TUI also map the mcp.json `protocolEra` into versionNegotiation so the field
applies uniformly. Version negotiation stays fully client-side; modern connect
works over the existing remote tunnel and disconnect is sessionless (the SDK
skips DELETE when there is no session id). Mcp-* header fidelity is left to the
History/Network card.

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

* Address @claude review: era docstrings, era validation, stdio session label, AGENTS.md rule

- Fix stale docstrings/comments in inspectorClient.ts, useInspectorClient.ts,
  inspectorClientEventTarget.ts, and ConnectionInfoContent.tsx: getProtocolEra()
  returns "legacy" (not undefined) on a plain legacy connect; it is undefined
  only when not connected.
- Validate protocolEra at the storedFieldsToInspectorSettings read boundary
  (new shared isProtocolEra guard) so a hand-edited mcp.json read directly by
  the CLI/TUI drops an unknown era instead of passing it to
  eraToVersionNegotiation. Keeps the exhaustive switch intact.
- ConnectionInfoContent: the Session row is HTTP-only — show "N/A (stdio)" for
  stdio instead of the misleading "Session-based".
- AGENTS.md: add a rule against unjustified `as unknown as` double casts, and
  drop the one such cast introduced in the serverList test.

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

* Address re-review: dedupe isProtocolEra guard in remote server

Replace the local isProtocolEra in remote/node/server.ts with the shared guard
now exported from serverList.ts (already imported here), so the era literal set
lives in one place and can't drift.

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>

core/react/useInspectorClient.ts

@@ -7,6 +7,8 @@ import type {
   ClientCapabilities,
   ServerCapabilities,
   Implementation,
+  ProtocolEra,
+  DiscoverResult,
 } from "@modelcontextprotocol/client";
 
 // Module-scope frozen object so the `?? EMPTY_CLIENT_CAPABILITIES`
@@ -22,6 +24,19 @@ export interface UseInspectorClientResult {
   serverInfo?: Implementation;
   instructions?: string;
   protocolVersion?: string;
+  /**
+   * Protocol era negotiated with the server (SEP §7.8): `"legacy"` for the
+   * 2025-11-25 initialize handshake, `"modern"` for the 2026-era sessionless
+   * model. Populated for every era once connected (a plain legacy connect
+   * reports `"legacy"`); undefined only when not connected. (#1626)
+   */
+  protocolEra?: ProtocolEra;
+  /**
+   * The `server/discover` result on a probed/pinned connect — server identity,
+   * capabilities, and supported versions learned without an initialize
+   * handshake. Undefined on a legacy connect. (#1626)
+   */
+  discoverResult?: DiscoverResult;
   /**
    * Message from the most recent mid-session transport failure (the client's
    * `error` event — stdio crash, SSE drop, HTTP 5xx). Stays set until the next
@@ -66,6 +81,12 @@ export function useInspectorClient(
   const [protocolVersion, setProtocolVersion] = useState<string | undefined>(
     inspectorClient?.getProtocolVersion(),
   );
+  const [protocolEra, setProtocolEra] = useState<ProtocolEra | undefined>(
+    inspectorClient?.getProtocolEra(),
+  );
+  const [discoverResult, setDiscoverResult] = useState<
+    DiscoverResult | undefined
+  >(inspectorClient?.getDiscoverResult());
   const [lastError, setLastError] = useState<string | undefined>(undefined);
 
   useEffect(() => {
@@ -75,6 +96,8 @@ export function useInspectorClient(
       setServerInfo(undefined);
       setInstructions(undefined);
       setProtocolVersion(undefined);
+      setProtocolEra(undefined);
+      setDiscoverResult(undefined);
       setLastError(undefined);
       return;
     }
@@ -84,6 +107,8 @@ export function useInspectorClient(
     setServerInfo(inspectorClient.getServerInfo());
     setInstructions(inspectorClient.getInstructions());
     setProtocolVersion(inspectorClient.getProtocolVersion());
+    setProtocolEra(inspectorClient.getProtocolEra());
+    setDiscoverResult(inspectorClient.getDiscoverResult());
     setLastError(undefined);
 
     const onStatusChange = (event: TypedEvent<"statusChange">) => {
@@ -111,6 +136,14 @@ export function useInspectorClient(
     ) => {
       setProtocolVersion(event.detail);
     };
+    const onProtocolEraChange = (event: TypedEvent<"protocolEraChange">) => {
+      setProtocolEra(event.detail);
+    };
+    const onDiscoverResultChange = (
+      event: TypedEvent<"discoverResultChange">,
+    ) => {
+      setDiscoverResult(event.detail);
+    };
 
     inspectorClient.addEventListener("statusChange", onStatusChange);
     inspectorClient.addEventListener("error", onError);
@@ -127,6 +160,11 @@ export function useInspectorClient(
       "protocolVersionChange",
       onProtocolVersionChange,
     );
+    inspectorClient.addEventListener("protocolEraChange", onProtocolEraChange);
+    inspectorClient.addEventListener(
+      "discoverResultChange",
+      onDiscoverResultChange,
+    );
 
     return () => {
       inspectorClient.removeEventListener("statusChange", onStatusChange);
@@ -147,6 +185,14 @@ export function useInspectorClient(
         "protocolVersionChange",
         onProtocolVersionChange,
       );
+      inspectorClient.removeEventListener(
+        "protocolEraChange",
+        onProtocolEraChange,
+      );
+      inspectorClient.removeEventListener(
+        "discoverResultChange",
+        onDiscoverResultChange,
+      );
     };
   }, [inspectorClient]);
 
@@ -173,6 +219,8 @@ export function useInspectorClient(
     serverInfo,
     instructions,
     protocolVersion,
+    protocolEra,
+    discoverResult,
     lastError,
     appRendererClient: inspectorClient?.getAppRendererClient() ?? null,
     connect,