@@ -127,7 +165,9 @@ vi.mock("@/components/common_components/ModelAliasManager", () => ({
default: vi.fn(({ initialModelAliases, onAliasUpdate }) => (
{JSON.stringify(initialModelAliases)}
-
+
@@ -138,8 +178,8 @@ vi.mock("@/components/common_components/ModelAliasManager", () => ({
vi.mock("@/app/(dashboard)/hooks/accessGroups/useAccessGroups", () => ({
useAccessGroups: vi.fn().mockReturnValue({
data: [
- { access_group_id: "ag-1", access_group_name: "Group 1" },
- { access_group_id: "ag-2", access_group_name: "Group 2" },
+ { access_group_id: "ag-1", access_group_name: "Group 1", access_mcp_server_ids: [] },
+ { access_group_id: "ag-2", access_group_name: "Group 2", access_mcp_server_ids: [] },
],
isLoading: false,
isError: false,
@@ -170,12 +210,18 @@ import { useKeys } from "@/app/(dashboard)/hooks/keys/useKeys";
import { useOrganization } from "@/app/(dashboard)/hooks/organizations/useOrganizations";
import { useTeam } from "@/app/(dashboard)/hooks/teams/useTeams";
import { useCurrentUser } from "@/app/(dashboard)/hooks/users/useCurrentUser";
+import { useMCPServers } from "@/app/(dashboard)/hooks/mcpServers/useMCPServers";
+import { useMCPToolsets } from "@/app/(dashboard)/hooks/mcpServers/useMCPToolsets";
+import { useAccessGroups } from "@/app/(dashboard)/hooks/accessGroups/useAccessGroups";
const mockUseAllProxyModels = vi.mocked(useAllProxyModels);
const mockUseKeys = vi.mocked(useKeys);
const mockUseTeam = vi.mocked(useTeam);
const mockUseOrganization = vi.mocked(useOrganization);
const mockUseCurrentUser = vi.mocked(useCurrentUser);
+const mockUseMCPServers = vi.mocked(useMCPServers);
+const mockUseMCPToolsets = vi.mocked(useMCPToolsets);
+const mockUseAccessGroups = vi.mocked(useAccessGroups);
const createMockTeamData = (overrides = {}) => ({
team_id: "123",
@@ -234,6 +280,16 @@ const seedDefaultMocks = () => {
data: { models: [] },
isLoading: false,
} as any);
+ mockUseMCPServers.mockReturnValue({ data: [], isLoading: false, isError: false } as any);
+ mockUseMCPToolsets.mockReturnValue({ data: [], isLoading: false, isError: false } as any);
+ mockUseAccessGroups.mockReturnValue({
+ data: [
+ { access_group_id: "ag-1", access_group_name: "Group 1", access_mcp_server_ids: [] },
+ { access_group_id: "ag-2", access_group_name: "Group 2", access_mcp_server_ids: [] },
+ ],
+ isLoading: false,
+ isError: false,
+ } as any);
mockUseKeys.mockReturnValue({
data: { keys: [], total_count: 0, current_page: 1, total_pages: 1 },
isPending: false,
@@ -2193,3 +2249,187 @@ describe("TeamInfoView - the exact bytes the update call sends", () => {
expect(networking.teamUpdateCall).not.toHaveBeenCalled();
});
});
+
+describe("TeamInfo MCP permission retention", () => {
+ beforeEach(seedDefaultMocks);
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ const server = (serverId: string, serverName: string, alias?: string): MCPServer =>
+ ({
+ server_id: serverId,
+ server_name: serverName,
+ alias,
+ mcp_access_groups: [],
+ created_at: "",
+ created_by: "",
+ updated_at: "",
+ updated_by: "",
+ }) as MCPServer;
+
+ const effective = (serverId: string, kind: EffectiveMcpServer["source"]["kind"]): EffectiveMcpServer =>
+ ({
+ server: server(serverId, serverId),
+ permissionKey: serverId,
+ supersededKeys: [],
+ ambiguousKeys: [],
+ keyedTools: undefined,
+ toolsetTools: undefined,
+ allowedTools: undefined,
+ source: kind === "accessGroup" ? { kind, name: "ops_readonly" } : { kind },
+ }) as EffectiveMcpServer;
+
+ it("retains permissions for directly and indirectly granted servers", () => {
+ const resolution = grantedMcpServerIds(
+ [effective("direct", "direct"), effective("inherited", "toolPermission")],
+ ["ag-1"],
+ [{ access_group_id: "ag-1", access_mcp_server_ids: ["inherited"] }],
+ );
+ expect(resolution.kind).toBe("resolved");
+ if (resolution.kind !== "resolved") return;
+
+ expect(
+ retainedMcpToolPermissions(
+ { direct: ["create_issue"], inherited: ["list_issues"], removed: ["delete_repo"] },
+ resolution.serverIds,
+ [server("direct", "deploy_tracker"), server("inherited", "issue_tracker"), server("removed", "old_tracker")],
+ ),
+ ).toEqual({
+ direct: ["create_issue"],
+ inherited: ["list_issues"],
+ });
+ });
+
+ it("matches name and alias permission keys to granted server ids", () => {
+ const catalog = [server("server-1", "issue_tracker", "issues")];
+
+ expect(
+ retainedMcpToolPermissions(
+ { issue_tracker: ["list_issues"], issues: ["create_issue"] },
+ new Set(["server-1"]),
+ catalog,
+ ),
+ ).toEqual({
+ issue_tracker: ["list_issues"],
+ issues: ["create_issue"],
+ });
+ });
+
+ it("refuses an unresolved selected access group", () => {
+ expect(grantedMcpServerIds([effective("server-1", "direct")], ["missing"], [])).toEqual({
+ kind: "unresolvable",
+ reason: expect.stringMatching(/access groups could not be loaded/),
+ });
+ });
+
+ it("retains an unknown permission key so an inventory refresh cannot erase it", () => {
+ expect(retainedMcpToolPermissions({ "not-yet-loaded": ["read"] }, new Set(), [])).toEqual({
+ "not-yet-loaded": ["read"],
+ });
+ });
+
+ it("retains an ambiguous name-keyed permission when one matching server remains granted", () => {
+ const catalog = [server("server-1", "shared"), server("server-2", "shared")];
+
+ expect(retainedMcpToolPermissions({ shared: ["read"] }, new Set(["server-1"]), catalog)).toEqual({
+ shared: ["read"],
+ });
+ });
+
+ it("retains an indirectly granted server on an unrelated team save", async () => {
+ const user = userEvent.setup({ delay: null });
+ const catalog = [server("direct-server", "deploy_tracker"), server("group-server", "issue_tracker")];
+ mockUseMCPServers.mockReturnValue({ data: catalog, isLoading: false, isError: false } as any);
+ mockUseMCPToolsets.mockReturnValue({ data: [], isLoading: false, isError: false } as any);
+ mockUseAccessGroups.mockReturnValue({
+ data: [{ access_group_id: "ag-1", access_group_name: "Ops", access_mcp_server_ids: ["group-server"] }],
+ isLoading: false,
+ isError: false,
+ } as any);
+ vi.mocked(networking.teamInfoCall).mockResolvedValue(
+ createMockTeamData({
+ models: ["gpt-4"],
+ access_group_ids: ["ag-1"],
+ object_permission: {
+ mcp_servers: ["direct-server"],
+ mcp_access_groups: [],
+ mcp_toolsets: [],
+ mcp_tool_permissions: {
+ "direct-server": ["create_issue"],
+ "group-server": ["list_issues"],
+ },
+ },
+ }),
+ );
+ vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: {}, team_id: "123" } as any);
+
+ renderWithProviders(
+
,
+ );
+ await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0));
+ await user.click(screen.getByRole("tab", { name: "Settings" }));
+ await user.click(await screen.findByRole("button", { name: /edit settings/i }));
+ await user.clear(screen.getByLabelText("Team Name"));
+ await user.type(screen.getByLabelText("Team Name"), "Renamed Team");
+ await user.click(screen.getByRole("button", { name: /save changes/i }));
+
+ await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled());
+ const [, payload] = vi.mocked(networking.teamUpdateCall).mock.calls[0];
+ expect(payload.object_permission.mcp_tool_permissions).toEqual({
+ "direct-server": ["create_issue"],
+ "group-server": ["list_issues"],
+ });
+ });
+
+ it("refuses a save with MCP permissions while the server inventory is unavailable", async () => {
+ const user = userEvent.setup({ delay: null });
+ mockUseMCPServers.mockReturnValue({ data: [], isLoading: false, isError: true } as any);
+ vi.mocked(networking.teamInfoCall).mockResolvedValue(
+ createMockTeamData({
+ models: ["gpt-4"],
+ object_permission: {
+ mcp_servers: ["direct-server"],
+ mcp_access_groups: [],
+ mcp_toolsets: [],
+ mcp_tool_permissions: { "direct-server": ["create_issue"] },
+ },
+ }),
+ );
+ vi.mocked(networking.teamUpdateCall).mockResolvedValue({ data: {}, team_id: "123" } as any);
+ const errorToast = vi.spyOn(toast, "fromError").mockImplementation(() => {});
+
+ renderWithProviders(
+
,
+ );
+ await waitFor(() => expect(screen.queryAllByText("Test Team").length).toBeGreaterThan(0));
+ await user.click(screen.getByRole("tab", { name: "Settings" }));
+ await user.click(await screen.findByRole("button", { name: /edit settings/i }));
+ await user.click(screen.getByRole("button", { name: /save changes/i }));
+
+ await waitFor(() =>
+ expect(errorToast).toHaveBeenCalledWith(expect.stringMatching(/server list could not be loaded/)),
+ );
+ expect(networking.teamUpdateCall).not.toHaveBeenCalled();
+ errorToast.mockRestore();
+ });
+});
diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx
index 57437384d77..6331072ec34 100644
--- a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx
+++ b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx
@@ -74,6 +74,15 @@ import GuardrailSettingsView from "../GuardrailSettingsView";
import LoggingSettingsView from "../logging_settings_view";
import MCPServerSelector from "../mcp_server_management/MCPServerSelector";
import MCPToolPermissions from "../mcp_server_management/MCPToolPermissions";
+import {
+ mcpServersForIdentifier,
+ resolveEffectiveMcpServers,
+ type EffectiveMcpServer,
+} from "../mcp_server_management/effectiveMcpServers";
+import type { MCPServer } from "../mcp_tools/types";
+import { useMCPServers } from "@/app/(dashboard)/hooks/mcpServers/useMCPServers";
+import { useMCPToolsets } from "@/app/(dashboard)/hooks/mcpServers/useMCPToolsets";
+import { useAccessGroups, type AccessGroupResponse } from "@/app/(dashboard)/hooks/accessGroups/useAccessGroups";
import { ModelSelect } from "../ModelSelect/ModelSelect";
import { estimateChecks, estimateTooltips } from "../templates/estimatedOutputTokens";
import ObjectPermissionsView from "../object_permissions_view";
@@ -118,6 +127,41 @@ const TEAM_MODEL_BADGE_TONES: Record
= {
const teamModelBadgeHref = (badge: TeamModelBadge): string | undefined =>
badge.kind === "direct" || badge.kind === "access-group" ? modelGroupHref(badge.label) : undefined;
+export type McpGrantResolution =
+ | { readonly kind: "resolved"; readonly serverIds: ReadonlySet }
+ | { readonly kind: "unresolvable"; readonly reason: string };
+
+export const grantedMcpServerIds = (
+ effectiveServers: readonly EffectiveMcpServer[],
+ selectedAccessGroupIds: readonly string[],
+ accessGroups: readonly Pick[],
+): McpGrantResolution => {
+ const selectedGroups = accessGroups.filter((group) => selectedAccessGroupIds.includes(group.access_group_id));
+ if (selectedAccessGroupIds.some((id) => !selectedGroups.some((group) => group.access_group_id === id))) {
+ return { kind: "unresolvable", reason: "the team's access groups could not be loaded" };
+ }
+ const direct = effectiveServers
+ .filter(({ source }) => source.kind !== "toolPermission")
+ .map(({ server }) => server.server_id);
+ const viaUnifiedGroups = selectedGroups.flatMap((group) => group.access_mcp_server_ids);
+ return { kind: "resolved", serverIds: new Set([...direct, ...viaUnifiedGroups]) };
+};
+
+export const retainedMcpToolPermissions = (
+ toolPermissions: Record,
+ grantedServerIds: ReadonlySet,
+ knownServers: readonly MCPServer[],
+): Record =>
+ Object.fromEntries(
+ Object.entries(toolPermissions).filter(([key]) => {
+ const named = mcpServersForIdentifier(knownServers, key);
+ return named.length === 0 || named.some((server) => grantedServerIds.has(server.server_id));
+ }),
+ );
+
+export const mcpUnresolvableSaveError = (reason: string): string =>
+ `Cannot save MCP tool permissions because ${reason}. Retry once the page has finished loading`;
+
export interface TeamMembership {
user_id: string;
team_id: string;
@@ -442,6 +486,9 @@ const TeamInfoView: React.FC = ({
const routerSettingsRef = React.useRef(null);
const [organization, setOrganization] = useState(null);
const { userRole, userId } = useAuthorized();
+ const { data: allMcpServers = [], isError: mcpServersFailed, isLoading: mcpServersLoading } = useMCPServers();
+ const { data: allMcpToolsets = [], isError: mcpToolsetsFailed, isLoading: mcpToolsetsLoading } = useMCPToolsets();
+ const { data: allAccessGroups = [], isError: accessGroupsFailed, isLoading: accessGroupsLoading } = useAccessGroups();
const canEditTeamEstimates = isProxyAdminRole(userRole);
const teamEstimateTooltip = estimateTooltips(canEditTeamEstimates, "team");
const { data: userOrganizations = [] } = useOrganizations();
@@ -462,6 +509,15 @@ const TeamInfoView: React.FC = ({
const killSwitchOn = form.watch("disable_global_guardrails");
const watchedMcpSelection = form.watch("mcp_servers_and_groups");
const watchedToolPermissions = form.watch("mcp_tool_permissions");
+ const mcpLookupFailure =
+ (
+ [
+ [mcpServersFailed, "the MCP server list could not be loaded"],
+ [mcpToolsetsFailed, "the MCP toolset list could not be loaded"],
+ [accessGroupsFailed, "the access group list could not be loaded"],
+ [mcpServersLoading || mcpToolsetsLoading || accessGroupsLoading, "the MCP server inventory is still loading"],
+ ] as const
+ ).find(([failed]) => failed)?.[1] ?? null;
const availableRateLimitModels = useMemo(() => {
const selected = watchedModels ?? teamData?.team_info?.models ?? [];
if (selected.includes("all-proxy-models") || selected.includes("all-team-models")) {
@@ -837,10 +893,31 @@ const TeamInfoView: React.FC = ({
accessGroups: [],
toolsets: [],
};
- const serverIds = new Set(servers || []);
- const mcpToolPermissions = Object.fromEntries(
- Object.entries(values.mcp_tool_permissions || {}).filter(([serverId]) => serverIds.has(serverId)),
- );
+ const submittedToolPermissions: Record = values.mcp_tool_permissions || {};
+ const effectiveMcpInput = {
+ allServers: allMcpServers,
+ selectedServers: servers || [],
+ selectedAccessGroups: accessGroups || [],
+ selectedToolsets: toolsets || [],
+ toolsets: allMcpToolsets,
+ toolPermissions: submittedToolPermissions,
+ };
+ const mcpResolution: McpGrantResolution =
+ mcpLookupFailure !== null
+ ? { kind: "unresolvable", reason: mcpLookupFailure }
+ : grantedMcpServerIds(
+ resolveEffectiveMcpServers(effectiveMcpInput),
+ values.access_group_ids || [],
+ allAccessGroups,
+ );
+ if (mcpResolution.kind === "unresolvable" && Object.keys(submittedToolPermissions).length > 0) {
+ toast.fromError(mcpUnresolvableSaveError(mcpResolution.reason));
+ return;
+ }
+ const mcpToolPermissions =
+ mcpResolution.kind === "resolved"
+ ? retainedMcpToolPermissions(submittedToolPermissions, mcpResolution.serverIds, allMcpServers)
+ : submittedToolPermissions;
updateData.object_permission = {};
if (servers) {