f201032137
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
98 lines
3.5 KiB
TypeScript
98 lines
3.5 KiB
TypeScript
import { useState, useEffect, useCallback } from "react";
|
|
import type { InspectorClientProtocol } from "../mcp/inspectorClientProtocol.js";
|
|
import type {
|
|
ManagedPromptsState,
|
|
ManagedPromptsStateEventMap,
|
|
} 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;
|
|
refresh: () => Promise<Prompt[]>;
|
|
/** Acknowledge the list-changed indicator without fetching (#1721). */
|
|
clearListChanged: () => void;
|
|
}
|
|
|
|
/**
|
|
* React hook that subscribes to ManagedPromptsState and returns prompts + refresh.
|
|
*/
|
|
export function useManagedPrompts(
|
|
client: InspectorClientProtocol | null,
|
|
managedPromptsState: ManagedPromptsState | null,
|
|
): UseManagedPromptsResult {
|
|
const [prompts, setPrompts] = useState<Prompt[]>(
|
|
managedPromptsState?.getPrompts() ?? [],
|
|
);
|
|
const [listChanged, setListChanged] = useState<boolean>(
|
|
managedPromptsState?.getListChanged() ?? false,
|
|
);
|
|
|
|
useEffect(() => {
|
|
if (!managedPromptsState) {
|
|
setPrompts([]);
|
|
setListChanged(false);
|
|
return;
|
|
}
|
|
setPrompts(managedPromptsState.getPrompts());
|
|
setListChanged(managedPromptsState.getListChanged());
|
|
const onPromptsChange = (
|
|
event: TypedEventGeneric<ManagedPromptsStateEventMap, "promptsChange">,
|
|
) => {
|
|
setPrompts(event.detail);
|
|
};
|
|
const onListChangedChange = (
|
|
event: TypedEventGeneric<
|
|
ManagedPromptsStateEventMap,
|
|
"listChangedChange"
|
|
>,
|
|
) => {
|
|
setListChanged(event.detail);
|
|
};
|
|
managedPromptsState.addEventListener("promptsChange", onPromptsChange);
|
|
managedPromptsState.addEventListener(
|
|
"listChangedChange",
|
|
onListChangedChange,
|
|
);
|
|
return () => {
|
|
managedPromptsState.removeEventListener("promptsChange", onPromptsChange);
|
|
managedPromptsState.removeEventListener(
|
|
"listChangedChange",
|
|
onListChangedChange,
|
|
);
|
|
};
|
|
}, [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
|
|
// BEFORE awaiting the fetch, not after. If a `prompts/list_changed` arrives
|
|
// mid-fetch, the state re-sets the flag (and auto-refreshes); clearing
|
|
// afterward would wipe that genuinely-new signal and the user would miss
|
|
// it. Clearing up front acknowledges only the change in hand.
|
|
managedPromptsState.clearListChanged();
|
|
// A user-initiated refresh forces a cache-bypassing round trip
|
|
// (`cacheMode: "refresh"`) so a modern server's `ttlMs`-cached list can't
|
|
// return stale — and re-stores the fresh aggregate.
|
|
const next = await managedPromptsState.refresh(undefined, "refresh");
|
|
setPrompts(next);
|
|
return next;
|
|
}, [client, managedPromptsState]);
|
|
|
|
const clearListChanged = useCallback(() => {
|
|
managedPromptsState?.clearListChanged();
|
|
}, [managedPromptsState]);
|
|
|
|
return { prompts, error, listChanged, refresh, clearListChanged };
|
|
}
|