diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/mcpServers/useMCPServerTools.test.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/mcpServers/useMCPServerTools.test.ts index b6fc5c4b106..81de7b9d403 100644 --- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/mcpServers/useMCPServerTools.test.ts +++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/mcpServers/useMCPServerTools.test.ts @@ -1,9 +1,9 @@ /* @vitest-environment jsdom */ import React from "react"; -import { renderHook, waitFor } from "@testing-library/react"; +import { act, renderHook, waitFor } from "@testing-library/react"; import { describe, it, expect, vi, beforeEach } from "vitest"; import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; -import { useMCPServerTools } from "./useMCPServerTools"; +import { mcpServerToolKeys, useMCPServerTools } from "./useMCPServerTools"; import * as networking from "@/components/networking"; vi.mock("@/components/networking", () => ({ @@ -62,8 +62,12 @@ describe("useMCPServerTools", () => { expect(result.current.get("a")).toEqual({ tools: [], status: "loading" }); }); - it("normalizes a bare array response and tools without descriptions", async () => { - vi.mocked(networking.listMCPTools).mockResolvedValue([{ tool_name: "legacy" }, "plain"]); + it("normalizes a bare array response, tools without descriptions, and drops tools without a name", async () => { + vi.mocked(networking.listMCPTools).mockResolvedValue([ + { tool_name: "legacy" }, + "plain", + { description: "nameless" }, + ]); const { result } = renderHook(() => useMCPServerTools(["a"], new Set(["a"])), { wrapper }); @@ -74,4 +78,25 @@ describe("useMCPServerTools", () => { ]), ); }); + + it("keeps showing the loaded tools when a later refetch fails", async () => { + const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } }); + const sharedWrapper = ({ children }: { children: React.ReactNode }) => + React.createElement(QueryClientProvider, { client: queryClient }, children); + vi.mocked(networking.listMCPTools) + .mockResolvedValueOnce(toolsFor("a")) + .mockResolvedValueOnce({ tools: [], error: "http_502", message: "upstream down" }); + + const { result } = renderHook(() => useMCPServerTools(["a"], new Set(["a"])), { wrapper: sharedWrapper }); + await waitFor(() => expect(result.current.get("a")?.status).toBe("success")); + + await act(() => queryClient.refetchQueries({ queryKey: mcpServerToolKeys.detail("a") })); + + await waitFor(() => expect(queryClient.getQueryState(mcpServerToolKeys.detail("a"))?.status).toBe("error")); + expect(networking.listMCPTools).toHaveBeenCalledTimes(2); + expect(result.current.get("a")).toEqual({ + tools: [{ name: "a_tool", description: "from a" }], + status: "success", + }); + }); }); diff --git a/ui/litellm-dashboard/src/app/(dashboard)/hooks/mcpServers/useMCPServerTools.ts b/ui/litellm-dashboard/src/app/(dashboard)/hooks/mcpServers/useMCPServerTools.ts index 7e29ac785c5..3b62824cd8a 100644 --- a/ui/litellm-dashboard/src/app/(dashboard)/hooks/mcpServers/useMCPServerTools.ts +++ b/ui/litellm-dashboard/src/app/(dashboard)/hooks/mcpServers/useMCPServerTools.ts @@ -10,8 +10,6 @@ export interface MCPServerToolEntry { description: string; } -// "idle" means the server has not been fetched yet, so callers can tell it apart from -// a server that loaded and has no tools. export type MCPServerToolsStatus = "idle" | "loading" | "error" | "success"; export interface MCPServerToolsState { @@ -34,22 +32,20 @@ export const fetchServerTools = async (accessToken: string, serverId: string): P throw new Error(result.message || result.error); } const toolList: RawTool[] = Array.isArray(result) ? result : result?.tools ?? []; - return toolList.map(toEntry); + return toolList.map(toEntry).filter((tool) => tool.name !== ""); }; const toStatus = ({ status, fetchStatus, -}: Pick): MCPServerToolsStatus => { + data, +}: Pick, "status" | "fetchStatus" | "data">): MCPServerToolsStatus => { + // A failed refetch keeps the tools that already loaded on screen. + if (status === "error" && data !== undefined) return "success"; if (status !== "pending") return status; return fetchStatus === "idle" ? "idle" : "loading"; }; -/** - * Tool catalogs for a set of MCP servers, one query per server so a slow or failing - * server never blocks the others. Only servers in `enabledServerIds` are fetched; - * the rest stay "idle" until they are enabled. - */ export const useMCPServerTools = ( serverIds: readonly string[], enabledServerIds: ReadonlySet, @@ -62,6 +58,7 @@ export const useMCPServerTools = ( enabled: !!accessToken && enabledServerIds.has(serverId), staleTime: 5 * 60 * 1000, retry: false, + refetchOnWindowFocus: false, })), combine: (results) => new Map( diff --git a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/MCPToolsetsTab.integration.test.tsx b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/MCPToolsetsTab.integration.test.tsx index 85bf120f5b9..93bdeebda56 100644 --- a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/MCPToolsetsTab.integration.test.tsx +++ b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/MCPToolsetsTab.integration.test.tsx @@ -1,5 +1,5 @@ import React from "react"; -import { fireEvent, render, screen, waitFor, within } from "@testing-library/react"; +import { act, fireEvent, render, screen, waitFor, within } from "@testing-library/react"; import userEvent, { PointerEventsCheckLevel } from "@testing-library/user-event"; import { describe, it, expect, vi, beforeEach } from "vitest"; import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; @@ -7,6 +7,7 @@ import { MCPToolsetsTab } from "./MCPToolsetsTab"; import * as networking from "@/components/networking"; import { useMCPToolsets } from "@/app/(dashboard)/hooks/mcpServers/useMCPToolsets"; import { useMCPServers } from "@/app/(dashboard)/hooks/mcpServers/useMCPServers"; +import { mcpServerToolKeys } from "@/app/(dashboard)/hooks/mcpServers/useMCPServerTools"; import { MCPToolset } from "@/components/mcp_tools/types"; vi.mock("@/components/networking", () => ({ @@ -223,11 +224,13 @@ describe("MCPToolsetsTab tool search and bulk selection", () => { vi.mocked(useMCPServers).mockReturnValue({ data: servers, isSuccess: true } as unknown as ReturnType< typeof useMCPServers >); + const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 0 } } }); render( - + , ); + return queryClient; }; const editToolset = (tools: MCPToolset["tools"]) => @@ -357,6 +360,23 @@ describe("MCPToolsetsTab tool search and bulk selection", () => { }); }); + it("stops fetching server tools once the editor is closed after a search", async () => { + const user = setup(); + const queryClient = renderWithServers(); + + const dialog = await openCreate(user); + await user.type(dialog.getByRole("textbox", { name: "Search tools or servers" }), "issue"); + expect(await dialog.findByRole("checkbox", { name: /^create_ticket/ })).toBeInTheDocument(); + await user.click(dialog.getByRole("button", { name: "Cancel" })); + await waitFor(() => expect(screen.queryByRole("dialog")).not.toBeInTheDocument()); + const callsWhileOpen = vi.mocked(networking.listMCPTools).mock.calls.length; + + await act(() => queryClient.invalidateQueries({ queryKey: mcpServerToolKeys.all })); + await new Promise((resolve) => setTimeout(resolve, 50)); + + expect(networking.listMCPTools).toHaveBeenCalledTimes(callsWhileOpen); + }); + it("clears the whole toolset with Clear all", async () => { const user = setup(); renderWithServers([editToolset([{ server_id: "gh", tool_name: "create_issue" }])]); diff --git a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/MCPToolsetsTab.tsx b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/MCPToolsetsTab.tsx index b0fa236a4f7..600ae98aee3 100644 --- a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/MCPToolsetsTab.tsx +++ b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/MCPToolsetsTab.tsx @@ -48,11 +48,24 @@ const toolsetSchema = z.object({ type ToolsetFormValues = z.infer; -// Typing starts a fetch of every server's tools; wait for a pause so each keystroke does not. const SEARCH_DEBOUNCE_WAIT_MS = 300; const IDLE_SERVER_TOOLS: MCPServerToolsState = { tools: [], status: "idle" }; +const NO_SERVERS: ReadonlySet = new Set(); + +// The modal stays mounted while closed, so fetch only while it is open; otherwise a finished +// search keeps every server's query live and refetches all of them in the background. +const serversToFetch = ( + open: boolean, + searching: boolean, + serverIds: readonly string[], + expandedServerIds: ReadonlySet, +): ReadonlySet => { + if (!open) return NO_SERVERS; + return searching ? new Set(serverIds) : expandedServerIds; +}; + const checkboxStateProps = (state: SelectionState) => ({ checked: state === "all", indeterminate: state === "some", @@ -245,10 +258,10 @@ function CreateToolsetModal({ open, onClose, onSave, initialToolset }: CreateToo const [expandedServerIds, setExpandedServerIds] = useState>(() => new Set()); const { data: mcpServers = [], isSuccess: serversLoaded } = useMCPServers(); const serverIds = React.useMemo(() => mcpServers.map((s) => s.server_id), [mcpServers]); - // Searching needs every server's catalog; otherwise only expanded servers are fetched. + const searching = search.trim() !== "" && debouncedSearch.trim() !== ""; const fetchServerIds = React.useMemo( - () => (debouncedSearch.trim() ? new Set(serverIds) : expandedServerIds), - [debouncedSearch, serverIds, expandedServerIds], + () => serversToFetch(open, searching, serverIds, expandedServerIds), + [open, searching, serverIds, expandedServerIds], ); const toolsByServer = useMCPServerTools(serverIds, fetchServerIds); const serverPrefixById = React.useMemo( diff --git a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/toolsetSelection.ts b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/toolsetSelection.ts index 9688a80d21a..217e8626b43 100644 --- a/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/toolsetSelection.ts +++ b/ui/litellm-dashboard/src/app/(dashboard)/mcp-servers/_components/toolsetSelection.ts @@ -11,16 +11,12 @@ const toolKey = (tool: MCPToolsetTool): string => `${tool.server_id}\u0000${tool const normalize = (query: string): string => query.trim().toLowerCase(); -/** Whether a non-empty search query matches any of a server's names (alias, server name). */ export const matchesServerName = (query: string, serverNames: readonly string[]): boolean => { const q = normalize(query); return q !== "" && serverNames.some((name) => name.toLowerCase().includes(q)); }; -/** - * The tools of one server that a search query shows. A query matching the server's - * name shows every tool on it; otherwise a tool shows when its name or description matches. - */ +// A query that matches the server's name shows every tool on that server. export const filterServerTools = ( query: string, serverNames: readonly string[], @@ -33,7 +29,6 @@ export const filterServerTools = ( return tools.filter((tool) => tool.name.toLowerCase().includes(q) || tool.description.toLowerCase().includes(q)); }; -/** Adds `tools` to the selection, keeping existing order and skipping tools already selected. */ export const selectTools = ( selected: readonly MCPToolsetTool[], tools: readonly MCPToolsetTool[], @@ -48,7 +43,6 @@ export const selectTools = ( return [...selected, ...added]; }; -/** Removes exactly `tools` from the selection; every other selected tool is kept. */ export const deselectTools = ( selected: readonly MCPToolsetTool[], tools: readonly MCPToolsetTool[], @@ -63,7 +57,6 @@ export const toggleTool = (selected: readonly MCPToolsetTool[], tool: MCPToolset export const isToolSelected = (selected: readonly MCPToolsetTool[], tool: MCPToolsetTool): boolean => selected.some((t) => toolKey(t) === toolKey(tool)); -/** How much of `tools` is selected, for a tri-state "select all" checkbox. */ export const selectionState = ( selected: readonly MCPToolsetTool[], tools: readonly MCPToolsetTool[],