modelcontextprotocol/inspector
Watch
1
0
Fork
You've already forked inspector
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2

fix: surface list-fetch failures in paginated mode (#1998)

Browse source 
#1954 wired the list-load error off the aggregate managed stores only.
With `paginatedLists` on, those stores deliberately skip their all-page
walk, so their error is permanently null — while the paged stores that
actually drive the sidebar had no error state at all and `loadPage` had
a try/finally with no catch. A failing list showed an empty panel with
no alert and no Retry, and the connect-time `void loadPage(undefined)`
left an unhandled rejection.

- Give PagedTools/Prompts/ResourcesState observable error state: an
  `errorChange` event plus `getError()`, set in a new catch in
  `loadPage`, cleared on the next success and on disconnect. The
  rejection is still re-thrown, matching ManagedListState — callers'
  auth-recovery wrappers key off it to detect a 401.
- Catch the connect-time load's rejection (`.catch(() => {})`) now that
  the failure is recorded as state rather than lost.
- Select the error by mode in `usePaginatedList`, the same way `items`
  already is, and read it in App.tsx from the pagination model.
- Rename `useManagedListError` to `useListError`: both store families
  expose an identical `errorChange`, so the hook declares that one-event
  contract itself instead of importing ManagedListEventMap.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0177mPHAdECD18nLLCTwR5rh
Signed-off-by: cliffhall <cliff@futurescale.com>
This commit is contained in:
cliffhall 2026-08-17 20:40:23 -04:00
commit de60983ccc
3 changed files with 523 additions and 42 deletions
Download patch file Download diff file Expand all files Collapse all files

39
core/mcp/state/pagedPromptsState.ts
View file

@ -21,6 +21,8 @@ import type { PagePaginationState } from "./pagedToolsState.js";
export interface PagedPromptsStateEventMap {
promptsChange: Prompt[];
paginationChange: PagePaginationState;
/** The last page load's failure, or `null` once a load succeeds. */
errorChange: Error | null;
}
export interface LoadPageResult {
@ -35,6 +37,11 @@ export class PagedPromptsState extends TypedEventTarget<PagedPromptsStateEventMa
// Double-click guard: a load in flight makes the next `loadPage` a no-op so
// the same page can't be appended twice (#1721).
private loading = false;
// The last page load's failure, kept as observable state so a failing page
// renders an alert with a Retry instead of an empty sidebar. The aggregate
// stores carry the same state, but they are not the display source in
// paginated mode, so their error never fires there (#1998).
private error: Error | null = null;
private client: InspectorClientProtocol | null = null;
private unsubscribe: (() => void) | null = null;
@ -43,7 +50,11 @@ export class PagedPromptsState extends TypedEventTarget<PagedPromptsStateEventMa
this.client = client;
const onConnect = (): void => {
if (this.client?.getServerSettings()?.paginatedLists) {
void this.loadPage(undefined);
// No caller to await this one, so its rejection is caught here rather
// than left to become an unhandled rejection. Not a swallow:
// `loadPage` has already recorded the failure via `setError`, and the
// list panel renders it (#1998).
void this.loadPage(undefined).catch(() => {});
}
};
const onStatusChange = (): void => {
@ -70,6 +81,20 @@ export class PagedPromptsState extends TypedEventTarget<PagedPromptsStateEventMa
return { nextCursor: this.nextCursor, pageCount: this.pageCount };
}
/** The last page load's failure, or `null` when the last load succeeded. */
getError(): Error | null {
return this.error;
}
// Compared by identity rather than message: two distinct failures with the
// same text are still two events, and a re-render on a repeat failure is
// cheap next to silently coalescing them.
private setError(value: Error | null): void {
if (this.error === value) return;
this.error = value;
this.dispatchTypedEvent("errorChange", value);
}
clear(): void {
this.reset();
}
@ -80,6 +105,9 @@ export class PagedPromptsState extends TypedEventTarget<PagedPromptsStateEventMa
this.pageCount = 0;
this.dispatchTypedEvent("promptsChange", this.prompts);
this.dispatchTypedEvent("paginationChange", this.getPagination());
// A disconnect ends the session the error belonged to — a stale
// "couldn't load" must not outlive it into the next connect.
this.setError(null);
}
async loadPage(
@ -102,9 +130,17 @@ export class PagedPromptsState extends TypedEventTarget<PagedPromptsStateEventMa
: [...this.prompts, ...result.prompts];
this.pageCount = cursor === undefined ? 1 : this.pageCount + 1;
this.nextCursor = result.nextCursor;
this.setError(null);
this.dispatchTypedEvent("promptsChange", this.prompts);
this.dispatchTypedEvent("paginationChange", this.getPagination());
return { prompts: result.prompts, nextCursor: result.nextCursor };
} catch (err) {
// Recorded as observable state AND re-thrown: the state drives the
// panel's alert, while the rejection is what a caller's auth-recovery
// wrapper keys off to detect a 401 and start a re-authorization. The
// connect-time load, which has no such caller, catches it above.
this.setError(err instanceof Error ? err : new Error(String(err)));
throw err;
} finally {
this.loading = false;
}
@ -116,5 +152,6 @@ export class PagedPromptsState extends TypedEventTarget<PagedPromptsStateEventMa
this.prompts = [];
this.nextCursor = undefined;
this.pageCount = 0;
this.error = null;
}
}

39
core/mcp/state/pagedResourcesState.ts
View file

@ -22,6 +22,8 @@ import type { PagePaginationState } from "./pagedToolsState.js";
export interface PagedResourcesStateEventMap {
resourcesChange: Resource[];
paginationChange: PagePaginationState;
/** The last page load's failure, or `null` once a load succeeds. */
errorChange: Error | null;
}
export interface LoadPageResult {
@ -36,6 +38,11 @@ export class PagedResourcesState extends TypedEventTarget<PagedResourcesStateEve
// Double-click guard: a load in flight makes the next `loadPage` a no-op so
// the same page can't be appended twice (#1721).
private loading = false;
// The last page load's failure, kept as observable state so a failing page
// renders an alert with a Retry instead of an empty sidebar. The aggregate
// stores carry the same state, but they are not the display source in
// paginated mode, so their error never fires there (#1998).
private error: Error | null = null;
private client: InspectorClientProtocol | null = null;
private unsubscribe: (() => void) | null = null;
@ -44,7 +51,11 @@ export class PagedResourcesState extends TypedEventTarget<PagedResourcesStateEve
this.client = client;
const onConnect = (): void => {
if (this.client?.getServerSettings()?.paginatedLists) {
void this.loadPage(undefined);
// No caller to await this one, so its rejection is caught here rather
// than left to become an unhandled rejection. Not a swallow:
// `loadPage` has already recorded the failure via `setError`, and the
// list panel renders it (#1998).
void this.loadPage(undefined).catch(() => {});
}
};
const onStatusChange = (): void => {
@ -71,6 +82,20 @@ export class PagedResourcesState extends TypedEventTarget<PagedResourcesStateEve
return { nextCursor: this.nextCursor, pageCount: this.pageCount };
}
/** The last page load's failure, or `null` when the last load succeeded. */
getError(): Error | null {
return this.error;
}
// Compared by identity rather than message: two distinct failures with the
// same text are still two events, and a re-render on a repeat failure is
// cheap next to silently coalescing them.
private setError(value: Error | null): void {
if (this.error === value) return;
this.error = value;
this.dispatchTypedEvent("errorChange", value);
}
clear(): void {
this.reset();
}
@ -81,6 +106,9 @@ export class PagedResourcesState extends TypedEventTarget<PagedResourcesStateEve
this.pageCount = 0;
this.dispatchTypedEvent("resourcesChange", this.resources);
this.dispatchTypedEvent("paginationChange", this.getPagination());
// A disconnect ends the session the error belonged to — a stale
// "couldn't load" must not outlive it into the next connect.
this.setError(null);
}
async loadPage(
@ -103,9 +131,17 @@ export class PagedResourcesState extends TypedEventTarget<PagedResourcesStateEve
: [...this.resources, ...result.resources];
this.pageCount = cursor === undefined ? 1 : this.pageCount + 1;
this.nextCursor = result.nextCursor;
this.setError(null);
this.dispatchTypedEvent("resourcesChange", this.resources);
this.dispatchTypedEvent("paginationChange", this.getPagination());
return { resources: result.resources, nextCursor: result.nextCursor };
} catch (err) {
// Recorded as observable state AND re-thrown: the state drives the
// panel's alert, while the rejection is what a caller's auth-recovery
// wrapper keys off to detect a 401 and start a re-authorization. The
// connect-time load, which has no such caller, catches it above.
this.setError(err instanceof Error ? err : new Error(String(err)));
throw err;
} finally {
this.loading = false;
}
@ -117,5 +153,6 @@ export class PagedResourcesState extends TypedEventTarget<PagedResourcesStateEve
this.resources = [];
this.nextCursor = undefined;
this.pageCount = 0;
this.error = null;
}
}

39
core/mcp/state/pagedToolsState.ts
View file

@ -30,6 +30,8 @@ export interface PagePaginationState {
export interface PagedToolsStateEventMap {
toolsChange: Tool[];
paginationChange: PagePaginationState;
/** The last page load's failure, or `null` once a load succeeds. */
errorChange: Error | null;
}
export interface LoadPageResult {
@ -45,6 +47,11 @@ export class PagedToolsState extends TypedEventTarget<PagedToolsStateEventMap> {
// page"): both calls would otherwise read the same cursor and append the
// same page twice. A load in flight makes the next `loadPage` a no-op (#1721).
private loading = false;
// The last page load's failure, kept as observable state so a failing page
// renders an alert with a Retry instead of an empty sidebar. The aggregate
// stores carry the same state, but they are not the display source in
// paginated mode, so their error never fires there (#1998).
private error: Error | null = null;
private client: InspectorClientProtocol | null = null;
private unsubscribe: (() => void) | null = null;
@ -55,7 +62,11 @@ export class PagedToolsState extends TypedEventTarget<PagedToolsStateEventMap> {
// Auto-load page 1 only in paginated mode — otherwise the managed
// (aggregate) state is the display source and this stays idle (#1721).
if (this.client?.getServerSettings()?.paginatedLists) {
void this.loadPage(undefined);
// No caller to await this one, so its rejection is caught here rather
// than left to become an unhandled rejection. Not a swallow:
// `loadPage` has already recorded the failure via `setError`, and the
// list panel renders it (#1998).
void this.loadPage(undefined).catch(() => {});
}
};
const onStatusChange = (): void => {
@ -82,6 +93,20 @@ export class PagedToolsState extends TypedEventTarget<PagedToolsStateEventMap> {
return { nextCursor: this.nextCursor, pageCount: this.pageCount };
}
/** The last page load's failure, or `null` when the last load succeeded. */
getError(): Error | null {
return this.error;
}
// Compared by identity rather than message: two distinct failures with the
// same text are still two events, and a re-render on a repeat failure is
// cheap next to silently coalescing them.
private setError(value: Error | null): void {
if (this.error === value) return;
this.error = value;
this.dispatchTypedEvent("errorChange", value);
}
/** Clear the accumulated list and pagination progress. */
clear(): void {
this.reset();
@ -93,6 +118,9 @@ export class PagedToolsState extends TypedEventTarget<PagedToolsStateEventMap> {
this.pageCount = 0;
this.dispatchTypedEvent("toolsChange", this.tools);
this.dispatchTypedEvent("paginationChange", this.getPagination());
// A disconnect ends the session the error belonged to — a stale
// "couldn't load" must not outlive it into the next connect.
this.setError(null);
}
async loadPage(cursor?: string): Promise<LoadPageResult> {
@ -116,9 +144,17 @@ export class PagedToolsState extends TypedEventTarget<PagedToolsStateEventMap> {
: [...this.tools, ...result.tools];
this.pageCount = cursor === undefined ? 1 : this.pageCount + 1;
this.nextCursor = result.nextCursor;
this.setError(null);
this.dispatchTypedEvent("toolsChange", this.tools);
this.dispatchTypedEvent("paginationChange", this.getPagination());
return { tools: result.tools, nextCursor: result.nextCursor };
} catch (err) {
// Recorded as observable state AND re-thrown: the state drives the
// panel's alert, while the rejection is what a caller's auth-recovery
// wrapper keys off to detect a 401 and start a re-authorization. The
// connect-time load, which has no such caller, catches it above.
this.setError(err instanceof Error ? err : new Error(String(err)));
throw err;
} finally {
this.loading = false;
}
@ -130,5 +166,6 @@ export class PagedToolsState extends TypedEventTarget<PagedToolsStateEventMap> {
this.tools = [];
this.nextCursor = undefined;
this.pageCount = 0;
this.error = null;
}
}