From fb0c886bf27c9ee0eea363159a7bfdf0ba2114d2 Mon Sep 17 00:00:00 2001 From: Alpinist <199138677+Epsilon006@users.noreply.github.com> Date: Sat, 24 Oct 2026 23:29:02 +0800 Subject: [PATCH] fix(mcp): align key toolset server and tool access --- .../mcp_server/auth/user_api_key_auth_mcp.py | 38 +++++++------ .../auth/test_user_api_key_auth_mcp.py | 56 +++++++++++++------ 2 files changed, 62 insertions(+), 32 deletions(-) diff --git a/litellm/proxy/_experimental/mcp_server/auth/user_api_key_auth_mcp.py b/litellm/proxy/_experimental/mcp_server/auth/user_api_key_auth_mcp.py index a8825291801..43af7858cce 100644 --- a/litellm/proxy/_experimental/mcp_server/auth/user_api_key_auth_mcp.py +++ b/litellm/proxy/_experimental/mcp_server/auth/user_api_key_auth_mcp.py @@ -2779,6 +2779,19 @@ class MCPRequestHandler: ) return resolved + @staticmethod + async def _key_toolset_tool_permissions( + object_permission: LiteLLM_ObjectPermissionTable | None, + *, + requires_fresh_policy: bool = False, + ) -> Mapping[str, Sequence[str]]: + try: + return await MCPRequestHandler._toolset_tool_permissions( + object_permission, requires_fresh_policy=requires_fresh_policy + ) + except Exception as e: + raise UnloadableEntitlementError("key MCP toolset entitlement could not be resolved") from e + @staticmethod async def _toolset_tools_for_server( object_permission: LiteLLM_ObjectPermissionTable | None, @@ -3114,12 +3127,11 @@ class MCPRequestHandler: # Tools granted through the key's toolsets restrict this server exactly # as direct tool permissions do; union with any direct grants so the # tool-level check sees the key's full effective tool scope - try: - key_toolset_tools: Final = await MCPRequestHandler._toolset_tools_for_server( - key_obj_perm, server_id, requires_fresh_policy=user_api_key_auth.requires_fresh_policy + key_toolset_tools: Final = ( + await MCPRequestHandler._key_toolset_tool_permissions( + key_obj_perm, requires_fresh_policy=user_api_key_auth.requires_fresh_policy ) - except Exception as e: - raise UnloadableEntitlementError("key MCP toolset entitlement could not be resolved") from e + ).get(server_id) key_group_tools: Final = await MCPRequestHandler._key_access_group_tools_for_server( user_api_key_auth, server_id @@ -3409,23 +3421,17 @@ class MCPRequestHandler: # servers referenced by the key's toolset grants are part of the key's # scope on every path (list, call, REST), subject to the same team/org # ceilings as any other key-level grant - toolset_ids: Final = key_object_permission.mcp_toolsets or [] - toolset_servers: Final = ( - list( - ( - await global_mcp_server_manager.resolve_toolset_tool_permissions( - toolset_ids=toolset_ids, - requires_fresh_policy=user_api_key_auth.requires_fresh_policy, - ) - ).keys() + toolset_servers: Final = list( + await MCPRequestHandler._key_toolset_tool_permissions( + key_object_permission, requires_fresh_policy=user_api_key_auth.requires_fresh_policy ) - if toolset_ids - else [] ) # Combine all lists all_servers: Final = direct_mcp_servers + access_group_servers + tool_perm_servers + toolset_servers return list(MCPRequestHandler._server_grants_with_group_scope(set(all_servers), key_object_permission)) + except UnloadableEntitlementError: + raise except Exception as e: verbose_logger.warning("Failed to get allowed MCP servers for key: %s", e) return [] diff --git a/tests/unit/proxy/_experimental/mcp_server/auth/test_user_api_key_auth_mcp.py b/tests/unit/proxy/_experimental/mcp_server/auth/test_user_api_key_auth_mcp.py index 004263425b1..fcee09c9db3 100644 --- a/tests/unit/proxy/_experimental/mcp_server/auth/test_user_api_key_auth_mcp.py +++ b/tests/unit/proxy/_experimental/mcp_server/auth/test_user_api_key_auth_mcp.py @@ -59,15 +59,29 @@ def test_incoming_guardrail_bearer_requires_exact_authorization_header( @pytest.mark.asyncio @pytest.mark.parametrize( - "resolution", ["valid", "deleted", "empty", "database_error", "fresh_database_error", "cache_error", "no_database"] + "resolution", + [ + "not_declared", + "not_declared_empty", + "valid", + "deleted", + "empty", + "database_error", + "fresh_database_error", + "cache_error", + "no_database", + ], ) @pytest.mark.parametrize("direct_tools", [None, ["read_status"], [MCP_ALL_TOOLS_WILDCARD]]) -async def test_key_declared_toolset_never_becomes_unrestricted_when_unloadable( +@pytest.mark.parametrize("server_grant", ["key", "team"]) +async def test_key_toolset_policy_is_consistent_for_servers_and_tools( monkeypatch: pytest.MonkeyPatch, resolution: str, direct_tools: Sequence[str] | None, + server_grant: str, ) -> None: from litellm.proxy import proxy_server + from litellm.proxy.auth import auth_checks from litellm.types.mcp_server.mcp_toolset import MCPToolset row: Final = MCPToolset( @@ -91,26 +105,36 @@ async def test_key_declared_toolset_never_becomes_unrestricted_when_unloadable( ) monkeypatch.setattr(proxy_server, "prisma_client", None if resolution == "no_database" else client) monkeypatch.setattr(proxy_server, "user_api_key_cache", cache) + monkeypatch.setitem(proxy_server.general_settings, "require_key_mcp_access_defined", False) + team: Final = LiteLLM_TeamTable( + team_id="toolset-team", + object_permission=LiteLLM_ObjectPermissionTable(object_permission_id="team-scope", mcp_servers=["probe"]), + ) + monkeypatch.setattr(auth_checks, "get_team_object", AsyncMock(return_value=team)) auth: Final = UserAPIKeyAuth( + team_id="toolset-team" if server_grant == "team" else None, object_permission=LiteLLM_ObjectPermissionTable( object_permission_id="key-toolset-scope", - mcp_servers=["probe"], - mcp_toolsets=["status-only"], + mcp_servers=["probe"] if server_grant == "key" else [], + mcp_toolsets=None + if resolution == "not_declared" + else [] + if resolution == "not_declared_empty" + else ["status-only"], mcp_tool_permissions={} if direct_tools is None else {"probe": list(direct_tools)}, ), ).model_copy(update={"requires_fresh_policy": resolution == "fresh_database_error"}) - expected: Final = ( - None - if resolution == "valid" and direct_tools == [MCP_ALL_TOOLS_WILDCARD] - else ["read_status"] - if resolution == "valid" - else [] + allowed: Final = resolution in ("valid", "not_declared", "not_declared_empty") + unrestricted: Final = direct_tools == [MCP_ALL_TOOLS_WILDCARD] or ( + resolution in ("not_declared", "not_declared_empty") and direct_tools is None ) + expected: Final = None if allowed and unrestricted else ["read_status"] if allowed else [] + assert await MCPRequestHandler.get_allowed_mcp_servers(auth) == (["probe"] if allowed else []) assert await MCPRequestHandler.get_allowed_tools_for_server("probe", auth) == expected - assert await MCPRequestHandler.is_tool_allowed_for_server("read_status", "probe", auth) is (resolution == "valid") + assert await MCPRequestHandler.is_tool_allowed_for_server("read_status", "probe", auth) is allowed assert await MCPRequestHandler.is_tool_allowed_for_server("write_record", "probe", auth) is ( - resolution == "valid" and direct_tools == [MCP_ALL_TOOLS_WILDCARD] + allowed and unrestricted ) @@ -5021,10 +5045,10 @@ async def test_tool_permission_servers_included_in_allowed_servers(): transport=MCPTransport.http, ) try: - perm = MagicMock() - perm.mcp_servers = [] - perm.mcp_access_groups = [] - perm.mcp_tool_permissions = {"server_id_123": ["tool_a", "tool_b"]} + perm: Final = LiteLLM_ObjectPermissionTable( + object_permission_id="key-tool-scope", + mcp_tool_permissions={"server_id_123": ["tool_a", "tool_b"]}, + ) user_api_key_auth = UserAPIKeyAuth( api_key="test-key",