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
76 lines
2.7 KiB
TypeScript
76 lines
2.7 KiB
TypeScript
import { useState, useEffect, useCallback } from "react";
|
|
import type { InspectorClientProtocol } from "../mcp/inspectorClientProtocol.js";
|
|
import type {
|
|
ManagedResourceTemplatesState,
|
|
ManagedResourceTemplatesStateEventMap,
|
|
} 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[]>;
|
|
}
|
|
|
|
/**
|
|
* React hook that subscribes to ManagedResourceTemplatesState and returns
|
|
* resource templates + refresh.
|
|
*/
|
|
export function useManagedResourceTemplates(
|
|
client: InspectorClientProtocol | null,
|
|
managedResourceTemplatesState: ManagedResourceTemplatesState | null,
|
|
): UseManagedResourceTemplatesResult {
|
|
const [resourceTemplates, setResourceTemplates] = useState<
|
|
ResourceTemplate[]
|
|
>(managedResourceTemplatesState?.getResourceTemplates() ?? []);
|
|
|
|
useEffect(() => {
|
|
if (!managedResourceTemplatesState) {
|
|
setResourceTemplates([]);
|
|
return;
|
|
}
|
|
setResourceTemplates(managedResourceTemplatesState.getResourceTemplates());
|
|
const onResourceTemplatesChange = (
|
|
event: TypedEventGeneric<
|
|
ManagedResourceTemplatesStateEventMap,
|
|
"resourceTemplatesChange"
|
|
>,
|
|
) => {
|
|
setResourceTemplates(event.detail);
|
|
};
|
|
managedResourceTemplatesState.addEventListener(
|
|
"resourceTemplatesChange",
|
|
onResourceTemplatesChange,
|
|
);
|
|
return () => {
|
|
managedResourceTemplatesState.removeEventListener(
|
|
"resourceTemplatesChange",
|
|
onResourceTemplatesChange,
|
|
);
|
|
};
|
|
}, [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
|
|
// (`cacheMode: "refresh"`) so a modern server's `ttlMs`-cached list can't
|
|
// return stale — and re-stores the fresh aggregate.
|
|
const next = await managedResourceTemplatesState.refresh(
|
|
undefined,
|
|
"refresh",
|
|
);
|
|
setResourceTemplates(next);
|
|
return next;
|
|
}, [client, managedResourceTemplatesState]);
|
|
|
|
return { resourceTemplates, error, refresh };
|
|
}
|