fix: surface list-fetch failures instead of swallowing them

A list load that failed — a transport error, or a result the SDK's era
codec rejects as invalid — reported nothing. The connect-time refresh is
fired with no caller to await it (`void this.refresh()`), so its rejection
became an unhandled rejection: the header said "Connected", the panel
rendered an empty list indistinguishable from a server that has none, and
the failed exchange showed in the Protocol panel as a clean success.

Two surfaces now tell the truth:

- ManagedListState records the failure as observable state (`getError` +
  an `errorChange` event) and still re-throws, so App's auth-recovery
  wrapper keeps working. The four `useManaged*` hooks expose it via a
  shared `useManagedListError`, and the Tools/Prompts/Resources sidebars
  render a `ListLoadError` alert with the reason and a Retry.
- A response the client refused is attributed back to its Protocol entry
  (`markResponseRejected` → `responseRejected` → `MessageEntry.clientError`),
  which now renders an Error status and a "Rejected by the Inspector"
  alert rather than the green resultType badge alone. The SDK gives no
  request id with a decode failure, so the id is recovered by correlation;
  see the comment on `markResponseRejected` for why that is exact.

Also stops `listAllTools` from dropping a failing excluded-tools walk on
the floor — it stays non-fatal but is logged.

Closes #1953

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

core/react/useManagedListError.ts

@@ -0,0 +1,57 @@
+import { useState, useEffect } from "react";
+import type { ManagedListEventMap } from "../mcp/state/managedListState.js";
+import type { TypedEventGeneric } from "../mcp/typedEventTarget.js";
+
+/**
+ * The slice of a managed list state this hook needs. Declared structurally
+ * rather than as `ManagedListState<T, M>` so the four list hooks can share it
+ * without threading their item type through — the error is the same shape for
+ * all of them.
+ */
+export interface ManagedListErrorSource {
+  getError(): Error | null;
+  addEventListener(
+    type: "errorChange",
+    listener: (
+      event: TypedEventGeneric<ManagedListEventMap, "errorChange">,
+    ) => void,
+  ): void;
+  removeEventListener(
+    type: "errorChange",
+    listener: (
+      event: TypedEventGeneric<ManagedListEventMap, "errorChange">,
+    ) => void,
+  ): void;
+}
+
+/**
+ * Subscribe to a managed list state's last-fetch error (#1953).
+ *
+ * Shared by the four `useManaged*` hooks so a list load that fails — including
+ * the connect-time one, which has no caller to await it — reaches the UI
+ * instead of only the console. `null` means the last fetch succeeded.
+ */
+export function useManagedListError(
+  state: ManagedListErrorSource | null,
+): Error | null {
+  const [error, setError] = useState<Error | null>(state?.getError() ?? null);
+
+  useEffect(() => {
+    if (!state) {
+      setError(null);
+      return;
+    }
+    setError(state.getError());
+    const onErrorChange = (
+      event: TypedEventGeneric<ManagedListEventMap, "errorChange">,
+    ) => {
+      setError(event.detail);
+    };
+    state.addEventListener("errorChange", onErrorChange);
+    return () => {
+      state.removeEventListener("errorChange", onErrorChange);
+    };
+  }, [state]);
+
+  return error;
+}

core/react/useManagedPrompts.ts

@@ -6,8 +6,15 @@ import type {
 } from "../mcp/state/managedPromptsState.js";
 import type { Prompt } from "@modelcontextprotocol/client";
 import type { TypedEventGeneric } from "../mcp/typedEventTarget.js";
+import { useManagedListError } from "./useManagedListError.js";
 
 export interface UseManagedPromptsResult {
+  /**
+   * The last fetch's failure (transport error, or a result the SDK codec
+   * rejected), or `null` when it succeeded. Includes the connect-time load,
+   * whose failure has no caller to surface it (#1953).
+   */
+  error: Error | null;
   prompts: Prompt[];
   /** True when a `prompts/list_changed` arrived since the last user refresh. */
   listChanged: boolean;
@@ -65,6 +72,8 @@ export function useManagedPrompts(
     };
   }, [managedPromptsState]);
 
+  const error = useManagedListError(managedPromptsState);
+
   const refresh = useCallback(async (): Promise<Prompt[]> => {
     if (!managedPromptsState || !client) return [];
     // A user-initiated refresh acknowledges the change — clear the indicator
@@ -85,5 +94,5 @@ export function useManagedPrompts(
     managedPromptsState?.clearListChanged();
   }, [managedPromptsState]);
 
-  return { prompts, listChanged, refresh, clearListChanged };
+  return { prompts, error, listChanged, refresh, clearListChanged };
 }

core/react/useManagedResourceTemplates.ts

@@ -6,8 +6,15 @@ import type {
 } from "../mcp/state/managedResourceTemplatesState.js";
 import type { ResourceTemplateType as ResourceTemplate } from "@modelcontextprotocol/client";
 import type { TypedEventGeneric } from "../mcp/typedEventTarget.js";
+import { useManagedListError } from "./useManagedListError.js";
 
 export interface UseManagedResourceTemplatesResult {
+  /**
+   * The last fetch's failure (transport error, or a result the SDK codec
+   * rejected), or `null` when it succeeded. Includes the connect-time load,
+   * whose failure has no caller to surface it (#1953).
+   */
+  error: Error | null;
   resourceTemplates: ResourceTemplate[];
   refresh: () => Promise<ResourceTemplate[]>;
 }
@@ -50,6 +57,8 @@ export function useManagedResourceTemplates(
     };
   }, [managedResourceTemplatesState]);
 
+  const error = useManagedListError(managedResourceTemplatesState);
+
   const refresh = useCallback(async (): Promise<ResourceTemplate[]> => {
     if (!managedResourceTemplatesState || !client) return [];
     // A user-initiated refresh forces a cache-bypassing round trip
@@ -63,5 +72,5 @@ export function useManagedResourceTemplates(
     return next;
   }, [client, managedResourceTemplatesState]);
 
-  return { resourceTemplates, refresh };
+  return { resourceTemplates, error, refresh };
 }

core/react/useManagedResources.ts

@@ -6,8 +6,15 @@ import type {
 } from "../mcp/state/managedResourcesState.js";
 import type { Resource } from "@modelcontextprotocol/client";
 import type { TypedEventGeneric } from "../mcp/typedEventTarget.js";
+import { useManagedListError } from "./useManagedListError.js";
 
 export interface UseManagedResourcesResult {
+  /**
+   * The last fetch's failure (transport error, or a result the SDK codec
+   * rejected), or `null` when it succeeded. Includes the connect-time load,
+   * whose failure has no caller to surface it (#1953).
+   */
+  error: Error | null;
   resources: Resource[];
   /**
    * True when a `resources/list_changed` arrived since the last user refresh.
@@ -76,6 +83,8 @@ export function useManagedResources(
     };
   }, [managedResourcesState]);
 
+  const error = useManagedListError(managedResourcesState);
+
   const refresh = useCallback(async (): Promise<Resource[]> => {
     if (!managedResourcesState || !client) return [];
     // A user-initiated refresh acknowledges the change — clear the indicator
@@ -96,5 +105,5 @@ export function useManagedResources(
     managedResourcesState?.clearListChanged();
   }, [managedResourcesState]);
 
-  return { resources, listChanged, refresh, clearListChanged };
+  return { resources, error, listChanged, refresh, clearListChanged };
 }

core/react/useManagedTools.ts

@@ -4,8 +4,15 @@ import type { ManagedToolsState } from "../mcp/state/managedToolsState.js";
 import type { ManagedToolsStateEventMap } from "../mcp/state/managedToolsState.js";
 import type { Tool } from "@modelcontextprotocol/client";
 import type { TypedEventGeneric } from "../mcp/typedEventTarget.js";
+import { useManagedListError } from "./useManagedListError.js";
 
 export interface UseManagedToolsResult {
+  /**
+   * The last fetch's failure (transport error, or a result the SDK codec
+   * rejected), or `null` when it succeeded. Includes the connect-time load,
+   * whose failure has no caller to surface it (#1953).
+   */
+  error: Error | null;
   tools: Tool[];
   /** True when a `tools/list_changed` arrived since the last user refresh. */
   listChanged: boolean;
@@ -65,6 +72,8 @@ export function useManagedTools(
     };
   }, [managedToolsState]);
 
+  const error = useManagedListError(managedToolsState);
+
   const refresh = useCallback(async (): Promise<Tool[]> => {
     if (!managedToolsState || !client) return [];
     // A user-initiated refresh acknowledges the change — clear the indicator
@@ -85,5 +94,5 @@ export function useManagedTools(
     managedToolsState?.clearListChanged();
   }, [managedToolsState]);
 
-  return { tools, listChanged, refresh, clearListChanged };
+  return { tools, error, listChanged, refresh, clearListChanged };
 }