diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx
index f5afb636245..041ba4b548d 100644
--- a/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx
+++ b/ui/litellm-dashboard/src/components/team/TeamInfo.test.tsx
@@ -9,6 +9,7 @@ import type { EffectiveMcpServer } from "../mcp_server_management/effectiveMcpSe
import type { MCPServer } from "../mcp_tools/types";
import TeamInfoView, {
grantedMcpServerIds,
+ type McpGrantInput,
retainedMcpToolPermissions,
standingToolPermissionServerIds,
type TeamData,
@@ -191,6 +192,14 @@ vi.mock("@/app/(dashboard)/hooks/accessGroups/useAccessGroups", () => ({
}),
}));
+vi.mock("@/components/common_components/AccessGroupSelector", () => ({
+ default: ({ value, onChange }: { value?: string[]; onChange?: (next: string[]) => void }) => (
+
+ ),
+}));
+
vi.mock("@/app/(dashboard)/hooks/keys/useKeys", () => ({
useKeys: vi.fn().mockReturnValue({
data: { keys: [], total_count: 0, current_page: 1, total_pages: 1 },
@@ -2286,13 +2295,96 @@ describe("TeamInfo MCP permission retention", () => {
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"] }],
- new Set(),
+ const UNIFIED_SERVER = server("unified-server", "wiki");
+ const UNIFIED_GROUPS = [
+ { access_group_id: "ag-1", access_group_name: "Group 1", access_mcp_server_ids: ["unified-server"] },
+ { access_group_id: "ag-2", access_group_name: "Group 2", access_mcp_server_ids: [] },
+ ];
+
+ const unifiedTeam = (toolPermissions: Record, serverIds: string[] = []) => {
+ const teamData = {
+ models: ["gpt-4"],
+ access_group_ids: ["ag-1", "ag-2"],
+ access_group_mcp_server_ids: serverIds,
+ object_permission: {
+ mcp_servers: [],
+ mcp_access_groups: [],
+ mcp_toolsets: [],
+ mcp_tool_permissions: toolPermissions,
+ },
+ };
+ return createMockTeamData(teamData);
+ };
+
+ const renderMcpEditor = async (
+ user: ReturnType,
+ {
+ initialTeam = unifiedTeam({ wiki: ["read_page"] }, ["unified-server"]),
+ freshTeam = initialTeam,
+ accessGroups = [],
+ }: {
+ initialTeam?: ReturnType;
+ freshTeam?: ReturnType;
+ accessGroups?: typeof UNIFIED_GROUPS;
+ } = {},
+ ) => {
+ mockUseMCPServers.mockReturnValue({ data: [UNIFIED_SERVER], isLoading: false, isError: false } as any);
+ mockUseMCPToolsets.mockReturnValue({ data: [], isLoading: false, isError: false } as any);
+ mockUseAccessGroups.mockReturnValue({ data: accessGroups, isLoading: false, isError: false } as any);
+ vi.mocked(networking.teamInfoCall).mockResolvedValueOnce(initialTeam).mockResolvedValue(freshTeam);
+ 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 screen.findByLabelText("Team Name");
+ };
+
+ const saveMcpEditor = async (user: ReturnType) => {
+ await user.click(screen.getByRole("button", { name: /save changes/i }));
+ await waitFor(() => expect(networking.teamUpdateCall).toHaveBeenCalled());
+ const calls = vi.mocked(networking.teamUpdateCall).mock.calls;
+ const [, payload] = calls[calls.length - 1];
+ return payload.object_permission.mcp_tool_permissions;
+ };
+
+ const refuseMcpSave = async (user: ReturnType, reason: RegExp) => {
+ const errorToast = vi.spyOn(toast, "fromError").mockImplementation(() => {});
+ await user.click(screen.getByRole("button", { name: /save changes/i }));
+ await waitFor(() => expect(errorToast).toHaveBeenCalledWith(expect.stringMatching(reason)));
+ expect(networking.teamUpdateCall).not.toHaveBeenCalled();
+ errorToast.mockRestore();
+ };
+
+ const resolveGrants = (overrides: Partial) => {
+ const input: McpGrantInput = {
+ effectiveServers: [effective("server-1", "direct")],
+ selectedAccessGroupIds: ["ag-1"],
+ accessGroups: [],
+ standingServerIds: new Set(),
+ loadTeamGroups: vi.fn(),
+ ...overrides,
+ };
+ return grantedMcpServerIds(input);
+ };
+
+ it("retains permissions for directly and indirectly granted servers", async () => {
+ const resolution = await resolveGrants({
+ effectiveServers: [effective("direct", "direct"), effective("inherited", "toolPermission")],
+ accessGroups: [{ access_group_id: "ag-1", access_mcp_server_ids: ["inherited"] }],
+ });
expect(resolution.kind).toBe("resolved");
if (resolution.kind !== "resolved") return;
@@ -2323,8 +2415,69 @@ describe("TeamInfo MCP permission retention", () => {
});
});
- it("refuses an unresolved selected access group", () => {
- expect(grantedMcpServerIds([effective("server-1", "direct")], ["missing"], [], new Set())).toEqual({
+ it("does not reload the team when the access group list covers the selection", async () => {
+ const loadTeamGroups = vi.fn();
+ await expect(
+ resolveGrants({
+ accessGroups: [{ access_group_id: "ag-1", access_mcp_server_ids: ["group-server"] }],
+ loadTeamGroups,
+ }),
+ ).resolves.toEqual({
+ kind: "resolved",
+ serverIds: new Set(["server-1", "group-server"]),
+ });
+ expect(loadTeamGroups).not.toHaveBeenCalled();
+ });
+
+ it("falls back to the team's loaded access group servers when the list is unavailable and the selection is unchanged", async () => {
+ expect(
+ await resolveGrants({
+ loadTeamGroups: vi.fn().mockResolvedValue({ ids: ["ag-1"], serverIds: ["group-server"] }),
+ }),
+ ).toEqual({
+ kind: "resolved",
+ serverIds: new Set(["server-1", "group-server"]),
+ });
+ });
+
+ it("adds standing tool-permission grants to the reloaded team grants", async () => {
+ expect(
+ await resolveGrants({
+ effectiveServers: [effective("server-1", "direct"), effective("standing", "toolPermission")],
+ standingServerIds: new Set(["standing"]),
+ loadTeamGroups: vi.fn().mockResolvedValue({ ids: ["ag-1"], serverIds: ["group-server"] }),
+ }),
+ ).toEqual({
+ kind: "resolved",
+ serverIds: new Set(["server-1", "group-server", "standing"]),
+ });
+ });
+
+ it("is unresolvable when the list is unavailable and the selection changed", async () => {
+ expect(
+ await resolveGrants({
+ loadTeamGroups: vi.fn().mockResolvedValue({ ids: ["ag-1", "ag-2"], serverIds: ["group-server"] }),
+ }),
+ ).toEqual({
+ kind: "unresolvable",
+ reason: expect.stringMatching(/access groups could not be loaded/),
+ });
+ });
+
+ it("is unresolvable when the team reload fails", async () => {
+ expect(await resolveGrants({ loadTeamGroups: vi.fn().mockRejectedValue(new Error("boom")) })).toEqual({
+ kind: "unresolvable",
+ reason: expect.stringMatching(/access groups could not be reloaded/),
+ });
+ });
+
+ it("refuses an unresolved selected access group", async () => {
+ expect(
+ await resolveGrants({
+ selectedAccessGroupIds: ["missing"],
+ loadTeamGroups: vi.fn().mockResolvedValue({ ids: [], serverIds: [] }),
+ }),
+ ).toEqual({
kind: "unresolvable",
reason: expect.stringMatching(/access groups could not be loaded/),
});
@@ -2354,22 +2507,101 @@ describe("TeamInfo MCP permission retention", () => {
});
});
+ it("keeps the group server allowlist when the access group list is unavailable and the selection is unchanged", async () => {
+ const user = userEvent.setup({ delay: null });
+ await renderMcpEditor(user);
+
+ await user.clear(screen.getByLabelText("Team Name"));
+ await user.type(screen.getByLabelText("Team Name"), "Renamed Team");
+
+ expect(await saveMcpEditor(user)).toEqual({ wiki: ["read_page"] });
+ });
+
+ it("refuses a save when the access group list is unavailable and the selection changed", async () => {
+ const user = userEvent.setup({ delay: null });
+ await renderMcpEditor(user);
+
+ await user.click(screen.getByRole("button", { name: "remove first unified access group" }));
+ await refuseMcpSave(user, /access groups could not be loaded/);
+ });
+
+ it("keeps the group server allowlist when a selected access group is missing from the list", async () => {
+ const user = userEvent.setup({ delay: null });
+ await renderMcpEditor(user, {
+ accessGroups: [UNIFIED_GROUPS[1]],
+ initialTeam: unifiedTeam({ wiki: ["read_page"] }, ["unified-server"]),
+ });
+
+ expect(await saveMcpEditor(user)).toEqual({ wiki: ["read_page"] });
+ });
+
+ it("uses current group grants when a server was revoked after the page loaded", async () => {
+ const user = userEvent.setup({ delay: null });
+ await renderMcpEditor(user, {
+ initialTeam: unifiedTeam({ wiki: ["read_page"] }, ["unified-server"]),
+ freshTeam: unifiedTeam({ wiki: ["read_page"] }),
+ });
+
+ expect(await saveMcpEditor(user)).toEqual({});
+ });
+
+ it("uses current group grants when a server was granted after the page loaded", async () => {
+ const user = userEvent.setup({ delay: null });
+ await renderMcpEditor(user, {
+ initialTeam: unifiedTeam({ wiki: ["read_page"] }),
+ freshTeam: unifiedTeam({ wiki: ["read_page"] }, ["unified-server"]),
+ });
+
+ expect(await saveMcpEditor(user)).toEqual({ wiki: ["read_page"] });
+ });
+
+ it("keeps a standing allowlist that no group grant covers at load or at save", async () => {
+ const user = userEvent.setup({ delay: null });
+ await renderMcpEditor(user, {
+ initialTeam: unifiedTeam({ wiki: ["read_page"] }),
+ freshTeam: unifiedTeam({ wiki: ["read_page"] }),
+ });
+
+ expect(await saveMcpEditor(user)).toEqual({ wiki: ["read_page"] });
+ });
+
+ it("refuses a save when the access group list is unavailable and the team reload fails", async () => {
+ const user = userEvent.setup({ delay: null });
+ await renderMcpEditor(user);
+ vi.mocked(networking.teamInfoCall).mockRejectedValueOnce(new Error("boom"));
+
+ await refuseMcpSave(user, /access groups could not be reloaded/);
+ });
+
it("identifies standing tool-permission grants not covered by loaded access groups", () => {
expect(
standingToolPermissionServerIds(
[effective("a", "toolPermission"), effective("b", "toolPermission"), effective("c", "direct")],
["ag-1"],
[{ access_group_id: "ag-1", access_mcp_server_ids: ["b"] }],
+ [],
),
).toEqual(new Set(["a"]));
});
- it("includes standing tool-permission grants in the resolved server ids", () => {
- expect(grantedMcpServerIds([effective("x", "toolPermission")], [], [], new Set(["x"]))).toEqual({
+ it("does not treat a server granted by the team's loaded access groups as standing", () => {
+ expect(
+ standingToolPermissionServerIds(
+ [effective("a", "toolPermission"), effective("b", "toolPermission")],
+ ["ag-1"],
+ [],
+ ["b"],
+ ),
+ ).toEqual(new Set(["a"]));
+ });
+
+ it("includes standing tool-permission grants in the resolved server ids", async () => {
+ const standingOnly = { effectiveServers: [effective("x", "toolPermission")], selectedAccessGroupIds: [] };
+ expect(await resolveGrants({ ...standingOnly, standingServerIds: new Set(["x"]) })).toEqual({
kind: "resolved",
serverIds: new Set(["x"]),
});
- expect(grantedMcpServerIds([effective("x", "toolPermission")], [], [], new Set())).toEqual({
+ expect(await resolveGrants(standingOnly)).toEqual({
kind: "resolved",
serverIds: new Set(),
});
diff --git a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx
index 3ca58b4006b..efd69a79fc0 100644
--- a/ui/litellm-dashboard/src/components/team/TeamInfo.tsx
+++ b/ui/litellm-dashboard/src/components/team/TeamInfo.tsx
@@ -131,16 +131,29 @@ export type McpGrantResolution =
| { readonly kind: "resolved"; readonly serverIds: ReadonlySet }
| { readonly kind: "unresolvable"; readonly reason: string };
+export type TeamAccessGroupGrants = {
+ readonly ids: readonly string[];
+ readonly serverIds: readonly string[];
+};
+
+const sameIdSelection = (a: readonly string[], b: readonly string[]): boolean => {
+ const aSet = new Set(a);
+ const bSet = new Set(b);
+ return aSet.size === bSet.size && [...aSet].every((id) => bSet.has(id));
+};
+
export const standingToolPermissionServerIds = (
loadedEffectiveServers: readonly EffectiveMcpServer[],
loadedAccessGroupIds: readonly string[],
accessGroups: readonly Pick[],
+ loadedTeamGroupServerIds: readonly string[],
): ReadonlySet => {
- const loadedUnifiedServerIds = new Set(
- accessGroups
+ const loadedUnifiedServerIds = new Set([
+ ...accessGroups
.filter((group) => loadedAccessGroupIds.includes(group.access_group_id))
.flatMap((group) => group.access_mcp_server_ids),
- );
+ ...loadedTeamGroupServerIds,
+ ]);
return new Set(
loadedEffectiveServers
.filter(({ source, server }) => source.kind === "toolPermission" && !loadedUnifiedServerIds.has(server.server_id))
@@ -148,21 +161,46 @@ export const standingToolPermissionServerIds = (
);
};
-export const grantedMcpServerIds = (
- effectiveServers: readonly EffectiveMcpServer[],
- selectedAccessGroupIds: readonly string[],
- accessGroups: readonly Pick[],
- standingServerIds: ReadonlySet,
-): McpGrantResolution => {
+export type McpGrantInput = {
+ readonly effectiveServers: readonly EffectiveMcpServer[];
+ readonly selectedAccessGroupIds: readonly string[];
+ readonly accessGroups: readonly Pick[];
+ readonly standingServerIds: ReadonlySet;
+ readonly loadTeamGroups: () => Promise;
+};
+
+export const grantedMcpServerIds = async ({
+ effectiveServers,
+ selectedAccessGroupIds,
+ accessGroups,
+ standingServerIds,
+ loadTeamGroups,
+}: McpGrantInput): Promise => {
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, ...standingServerIds]) };
+ if (selectedAccessGroupIds.every((id) => selectedGroups.some((group) => group.access_group_id === id))) {
+ return {
+ kind: "resolved",
+ serverIds: new Set([
+ ...direct,
+ ...selectedGroups.flatMap((group) => group.access_mcp_server_ids),
+ ...standingServerIds,
+ ]),
+ };
+ }
+ const loadedTeamGroups = await loadTeamGroups().catch(() => null);
+ if (loadedTeamGroups === null) {
+ return { kind: "unresolvable", reason: "the team's access groups could not be reloaded" };
+ }
+ if (sameIdSelection(selectedAccessGroupIds, loadedTeamGroups.ids)) {
+ return {
+ kind: "resolved",
+ serverIds: new Set([...direct, ...loadedTeamGroups.serverIds, ...standingServerIds]),
+ };
+ }
+ return { kind: "unresolvable", reason: "the team's access groups could not be loaded" };
};
export const retainedMcpToolPermissions = (
@@ -947,16 +985,25 @@ const TeamInfoView: React.FC = ({
loadedEffectiveMcpServers,
info.access_group_ids ?? [],
allAccessGroups,
+ info.access_group_mcp_server_ids ?? [],
);
+ const mcpGrantInput: McpGrantInput = {
+ effectiveServers: resolveEffectiveMcpServers(effectiveMcpInput),
+ selectedAccessGroupIds: values.access_group_ids || [],
+ accessGroups: allAccessGroups,
+ standingServerIds,
+ loadTeamGroups: async () => {
+ const teamInfo = await teamInfoCall(accessToken, teamId);
+ return {
+ ids: teamInfo.team_info.access_group_ids ?? [],
+ serverIds: teamInfo.team_info.access_group_mcp_server_ids ?? [],
+ };
+ },
+ };
const mcpResolution: McpGrantResolution =
mcpLookupFailure !== null
? { kind: "unresolvable", reason: mcpLookupFailure }
- : grantedMcpServerIds(
- resolveEffectiveMcpServers(effectiveMcpInput),
- values.access_group_ids || [],
- allAccessGroups,
- standingServerIds,
- );
+ : await grantedMcpServerIds(mcpGrantInput);
if (mcpResolution.kind === "unresolvable" && Object.keys(submittedToolPermissions).length > 0) {
toast.fromError(mcpUnresolvableSaveError(mcpResolution.reason));
return;