diff --git a/litellm/models/mcp_server.py b/litellm/models/mcp_server.py index 23b26bd8e89..e428d20f99d 100644 --- a/litellm/models/mcp_server.py +++ b/litellm/models/mcp_server.py @@ -102,6 +102,7 @@ class LiteLLM_MCPServerTable(LiteLLMPydanticObjectBase): byok_description: List[str] = Field(default_factory=list) byok_api_key_help_url: Optional[str] = None has_user_credential: Optional[bool] = None + connected_app_reachable: bool | None = None source_url: Optional[str] = None timeout: Optional[float] = None max_concurrent_requests: Optional[int] = None diff --git a/litellm/proxy/_experimental/mcp_server/rest_endpoints.py b/litellm/proxy/_experimental/mcp_server/rest_endpoints.py index af3d966c95b..eabb43dd004 100644 --- a/litellm/proxy/_experimental/mcp_server/rest_endpoints.py +++ b/litellm/proxy/_experimental/mcp_server/rest_endpoints.py @@ -21,6 +21,7 @@ list_fault_http_status, ) from litellm.proxy._experimental.mcp_server.ui_session_utils import ( + acting_user_auth, build_effective_auth_contexts, ) from litellm.proxy._experimental.mcp_server.utils import ( @@ -644,13 +645,19 @@ def _as_query_str(value: Any) -> str | None: """Coerce an Optional[str] Query param to str|None, dropping unresolved FastAPI defaults.""" return value if isinstance(value, str) else None - async def _resolve_toolset_scope( + async def _resolve_acting_auth( toolset_name: str | None, user_api_key_dict: UserAPIKeyAuth, ) -> UserAPIKeyAuth: - """Resolve ``toolset_name`` to its scoped ``UserAPIKeyAuth``, or return unchanged.""" + """The one credential this tools request acts as. + + A toolset name narrows the caller's own credential to that toolset; otherwise a dashboard + session is swapped for its admitted subject. The two are mutually exclusive by construction, + which is why they share an owner: the admitted subject resolves per grant source and a team + source deliberately carries none of the caller's ``object_permission``, so a toolset + narrowing layered on top would evaporate on every team-granted server.""" if not toolset_name: - return user_api_key_dict + return await acting_user_auth(user_api_key_dict) from litellm.proxy.utils import get_prisma_client_or_throw @@ -708,6 +715,7 @@ async def list_tool_rest_api( try: mcp_server_name = _as_query_str(mcp_server_name) toolset_name = _as_query_str(toolset_name) + user_api_key_dict = await _resolve_acting_auth(toolset_name, user_api_key_dict) # The full catalog (allowlist filter skipped) is admin-only so the # REST endpoint can't be used to enumerate deliberately-disabled tools. @@ -715,8 +723,6 @@ async def list_tool_rest_api( include_disabled_tools and user_api_key_dict.user_role == LitellmUserRoles.PROXY_ADMIN ) - user_api_key_dict = await _resolve_toolset_scope(toolset_name, user_api_key_dict) - if server_id is None: server_id = mcp_server_name @@ -905,6 +911,7 @@ async def call_tool_rest_api( ) try: + user_api_key_dict = await acting_user_auth(user_api_key_dict) data = await request.json() tool_name = data.get("name") diff --git a/litellm/proxy/_experimental/mcp_server/ui_session_utils.py b/litellm/proxy/_experimental/mcp_server/ui_session_utils.py index 1b37b884987..d1d28574988 100644 --- a/litellm/proxy/_experimental/mcp_server/ui_session_utils.py +++ b/litellm/proxy/_experimental/mcp_server/ui_session_utils.py @@ -1,9 +1,11 @@ -"""Helpers to resolve real team contexts for UI session tokens.""" +"""Helpers to resolve the identity a dashboard UI session token acts as.""" from __future__ import annotations from typing import List +from fastapi import HTTPException + from litellm._logging import verbose_logger from litellm.constants import UI_SESSION_TOKEN_TEAM_ID from litellm.proxy._types import UserAPIKeyAuth @@ -23,12 +25,19 @@ def clone_user_api_key_auth_with_team( return cloned_auth +def is_ui_session_credential(user_api_key_auth: UserAPIKeyAuth) -> bool: + """Whether the caller is the dashboard's SSO-minted session token acting as its user, + the only credential shape allowed to widen a request to the owning user's identity.""" + + return user_api_key_auth.team_id == UI_SESSION_TOKEN_TEAM_ID and bool(user_api_key_auth.user_id) + + async def resolve_ui_session_team_ids( user_api_key_auth: UserAPIKeyAuth, ) -> List[str]: """Resolve the real team ids backing a UI session token.""" - if user_api_key_auth.team_id != UI_SESSION_TOKEN_TEAM_ID or not user_api_key_auth.user_id: + if not is_ui_session_credential(user_api_key_auth): return [] from litellm.proxy.auth.auth_checks import get_user_object @@ -68,12 +77,63 @@ async def resolve_ui_session_team_ids( return resolved_team_ids +async def admitted_user_context(user_api_key_auth: UserAPIKeyAuth) -> UserAPIKeyAuth | None: + """THE owner of "resolve this dashboard session's user identity": the same admitted-subject auth a + gateway OAuth session for this user resolves with, carrying the user row's own object permission, + on this request's tracing span. None for any other credential (a caller-passed key is never + widened) and on reload failure, which every caller reads as "no user-level identity available".""" + + user_id = user_api_key_auth.user_id + if not is_ui_session_credential(user_api_key_auth) or user_id is None: + return None + from litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp import ( + MCPRequestHandler, + ) + + try: + admitted = await MCPRequestHandler._reload_admitted_user(user_id) + except HTTPException as e: + verbose_logger.warning(f"MCP dashboard session: admitted-subject reload failed for {user_id}: {e.detail}") + return None + return admitted.model_copy(update={"parent_otel_span": user_api_key_auth.parent_otel_span}) + + +async def acting_user_auth(user_api_key_auth: UserAPIKeyAuth) -> UserAPIKeyAuth: + """The principal acting-as-user MCP routes resolve permissions with. A non-admin dashboard + session acts as the admitted subject, the same identity a gateway session resolves with, so + server reachability, per-source tool ceilings, rate limits, and billing bind identically on + both surfaces. An admin session keeps its operator view and any caller-passed credential is + returned unchanged, never widened. + + Do not combine this with a narrowing that rewrites a single credential's ``object_permission`` + (toolset scope): the admitted subject resolves per grant source and a team source deliberately + carries none of the caller's own grants, so the narrowing would silently evaporate on every + team-granted server. A request carrying such a scope keeps the caller's own credential.""" + + if not is_ui_session_credential(user_api_key_auth): + return user_api_key_auth + from litellm.proxy.management_endpoints.common_utils import _user_has_admin_view + + if _user_has_admin_view(user_api_key_auth): + return user_api_key_auth + admitted = await admitted_user_context(user_api_key_auth) + return admitted if admitted is not None else user_api_key_auth + + async def build_effective_auth_contexts( user_api_key_auth: UserAPIKeyAuth, ) -> List[UserAPIKeyAuth]: - """Return auth contexts that reflect the actual teams for UI session tokens.""" + """Every auth context a management or listing surface must resolve a UI session token through: + one per real team backing the session, plus the session user's own admitted identity, so a grant + made directly to the user row is as visible to the dashboard as it is to a gateway session.""" resolved_team_ids = await resolve_ui_session_team_ids(user_api_key_auth) - if resolved_team_ids: - return [clone_user_api_key_auth_with_team(user_api_key_auth, team_id) for team_id in resolved_team_ids] - return [user_api_key_auth] + team_contexts = ( + [clone_user_api_key_auth_with_team(user_api_key_auth, team_id) for team_id in resolved_team_ids] + if resolved_team_ids + else [user_api_key_auth] + ) + admitted_context = await admitted_user_context(user_api_key_auth) + if admitted_context is None: + return team_contexts + return [*team_contexts, admitted_context] diff --git a/litellm/proxy/management_endpoints/mcp_management_endpoints.py b/litellm/proxy/management_endpoints/mcp_management_endpoints.py index 282184d6495..d14c1767997 100644 --- a/litellm/proxy/management_endpoints/mcp_management_endpoints.py +++ b/litellm/proxy/management_endpoints/mcp_management_endpoints.py @@ -148,7 +148,9 @@ def validate_tool_name(name: str) -> _ToolNameValidationResult: # type: ignore[ global_mcp_server_manager, ) from litellm.proxy._experimental.mcp_server.ui_session_utils import ( + admitted_user_context, build_effective_auth_contexts, + is_ui_session_credential, ) from litellm.proxy._types import ( LiteLLM_MCPServerTable, @@ -939,6 +941,16 @@ async def _resolve_accessible_mcp_servers( aggregated.setdefault(server.server_id, server) return list(aggregated.values()) + async def _connected_app_reachable_server_ids(user_api_key_dict: UserAPIKeyAuth) -> frozenset[str]: + """Server ids a connected app authorized by this dashboard user is served on the aggregate + MCP endpoint, resolved through the one owner of the admitted subject so the page and the + session cannot drift. Empty when that identity cannot be built, which is the true answer: + the same user cannot open a gateway session either.""" + admitted = await admitted_user_context(user_api_key_dict) + if admitted is None: + return frozenset() + return frozenset(await global_mcp_server_manager.get_allowed_mcp_servers(admitted)) + @router.get( "/server", description="Returns the mcp server list with associated teams", @@ -953,6 +965,12 @@ async def fetch_all_mcp_servers( "servers the team has access to plus globally available (allow_all_keys) servers. " "Used by the Create Key UI to show team-scoped MCP servers.", ), + connected_app_view: bool = Query( + False, + description="Annotate each returned server with connected_app_reachable: whether a " + "connected app authorized by the calling user (a gateway OAuth session) is served " + "this server on the aggregate MCP endpoint.", + ), ): """ Get all of the configured mcp servers for the user in the db with their associated teams @@ -1009,6 +1027,11 @@ async def fetch_all_mcp_servers( servers = await _resolve_accessible_mcp_servers(user_api_key_dict) redacted_mcp_servers = _redact_mcp_credentials_list(servers) + if connected_app_view is True and is_ui_session_credential(user_api_key_dict): + reachable_ids = await _connected_app_reachable_server_ids(user_api_key_dict) + for server in redacted_mcp_servers: + server.connected_app_reachable = server.server_id in reachable_ids + # augment the mcp servers with public status if litellm.public_mcp_servers is not None: for server in redacted_mcp_servers: diff --git a/tests/test_litellm/proxy/_experimental/mcp_server/test_rest_endpoints.py b/tests/test_litellm/proxy/_experimental/mcp_server/test_rest_endpoints.py index 5c9612a055e..061e2f76d1b 100644 --- a/tests/test_litellm/proxy/_experimental/mcp_server/test_rest_endpoints.py +++ b/tests/test_litellm/proxy/_experimental/mcp_server/test_rest_endpoints.py @@ -769,8 +769,179 @@ async def fake_get_tools( assert captured["server"] is stub_server assert result["tools"] == ["tool-1"] assert result["error"] is None + + async def test_non_admin_ui_session_resolves_as_admitted_subject(self, monkeypatch): + """LIT-4861: a non-admin dashboard session must act as the admitted subject on this + route, so server reachability AND tool ceilings bind to the user's grants exactly as + they do for a gateway session, never to the bare session key.""" + from litellm.constants import UI_SESSION_TOKEN_TEAM_ID + + session_auth = UserAPIKeyAuth( + team_id=UI_SESSION_TOKEN_TEAM_ID, user_id="grant-user", user_role="internal_user" + ) + admitted_auth = UserAPIKeyAuth(user_id="grant-user", org_id="admitted-org") + + async def fake_reload(user_id): + assert user_id == "grant-user" + return admitted_auth + + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + fake_reload, + ) + + seen_server_resolution_auths = [] + + async def fake_get_allowed_mcp_servers(user_api_key_auth=None, **kwargs): + seen_server_resolution_auths.append(user_api_key_auth) + return ["server-1"] + + class StubServer: + alias = "server-1" + server_name = "server-1" + name = "stub" + allowed_tools = None + mcp_info = {"server_name": "stub"} + available_on_public_internet = True + + stub_server = StubServer() + captured = {} + + async def fake_get_tools( + server, + server_auth_header, + raw_headers=None, + user_api_key_auth=None, + extra_headers=None, + apply_tool_filters=True, + ): + captured["user_api_key_auth"] = user_api_key_auth + return ["tool-1"] + + monkeypatch.setattr( + rest_endpoints.global_mcp_server_manager, + "get_allowed_mcp_servers", + fake_get_allowed_mcp_servers, + raising=False, + ) + monkeypatch.setattr( + rest_endpoints.global_mcp_server_manager, + "get_mcp_server_by_id", + lambda server_id: stub_server if server_id == "server-1" else None, + raising=False, + ) + monkeypatch.setattr( + rest_endpoints, + "_get_tools_for_single_server", + fake_get_tools, + raising=False, + ) + + request = _build_request(path="/mcp-rest/tools/list", method="GET") + result = await rest_endpoints.list_tool_rest_api( + request, + server_id="server-1", + user_api_key_dict=session_auth, + ) + + resolved = [*seen_server_resolution_auths, captured["user_api_key_auth"]] + assert seen_server_resolution_auths + assert all(a.org_id == "admitted-org" and a.team_id is None for a in resolved) + assert result["tools"] == ["tool-1"] assert result["message"] == "Successfully retrieved tools" + async def test_toolset_scoped_request_keeps_the_caller_credential(self, monkeypatch): + """LIT-4861: the admitted subject resolves per grant source and a team source deliberately + carries none of the caller's own object_permission, so a toolset narrowing layered on top + would evaporate on every team-granted server. A toolset-scoped request therefore stays on + the caller's own credential, exactly as it did before the acting-as-user swap.""" + from litellm.constants import UI_SESSION_TOKEN_TEAM_ID + from litellm.proxy._types import LiteLLM_ObjectPermissionTable + + session_auth = UserAPIKeyAuth( + team_id=UI_SESSION_TOKEN_TEAM_ID, user_id="grant-user", user_role="internal_user" + ) + scoped_auth = UserAPIKeyAuth( + object_permission=LiteLLM_ObjectPermissionTable( + object_permission_id="toolset-scope", + mcp_servers=["toolset-server-1"], + ) + ) + reload_calls: list[str] = [] + scope_inputs: list[UserAPIKeyAuth] = [] + + async def record_reload(user_id): + reload_calls.append(user_id) + return UserAPIKeyAuth(user_id=user_id) + + class StubToolset: + toolset_id = "toolset-1" + + class StubServer: + alias = "toolset-server-1" + server_name = "toolset-server-1" + name = "toolset-server-1" + allowed_tools = None + mcp_info = {"server_name": "toolset-server-1"} + available_on_public_internet = True + + stub_server = StubServer() + + async def fake_get_toolset_by_name_cached(prisma_client, toolset_name): + return StubToolset() + + async def fake_apply_toolset_scope(user_api_key_auth, toolset_id): + scope_inputs.append(user_api_key_auth) + return scoped_auth + + async def fake_get_allowed_mcp_servers(user_api_key_auth=None, **kwargs): + assert user_api_key_auth is scoped_auth + return ["toolset-server-1"] + + async def fake_get_tools(server, server_auth_header, *args, **kwargs): + return ["toolset-tool-1"] + + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + record_reload, + ) + monkeypatch.setattr( + "litellm.proxy.utils.get_prisma_client_or_throw", + lambda *args, **kwargs: MagicMock(), + ) + monkeypatch.setattr( + rest_endpoints.global_mcp_server_manager, + "get_toolset_by_name_cached", + fake_get_toolset_by_name_cached, + raising=False, + ) + monkeypatch.setattr(rest_endpoints, "_apply_toolset_scope", fake_apply_toolset_scope, raising=False) + monkeypatch.setattr( + rest_endpoints.global_mcp_server_manager, + "get_allowed_mcp_servers", + fake_get_allowed_mcp_servers, + raising=False, + ) + monkeypatch.setattr( + rest_endpoints.global_mcp_server_manager, + "get_mcp_server_by_id", + lambda server_id: stub_server if server_id == "toolset-server-1" else None, + raising=False, + ) + monkeypatch.setattr(rest_endpoints, "_get_tools_for_single_server", fake_get_tools, raising=False) + + request = _build_request(path="/mcp-rest/tools/list", method="GET") + result = await rest_endpoints.list_tool_rest_api( + request, + server_id=None, + toolset_name="research_tools", + user_api_key_dict=session_auth, + ) + + assert result["tools"] == ["toolset-tool-1"] + assert scope_inputs == [session_auth] + assert reload_calls == [] + async def test_include_disabled_tools_is_admin_only(self, monkeypatch): """include_disabled_tools skips the allowlist filter only for PROXY_ADMIN; a non-admin passing it stays filtered so the REST endpoint can't be used diff --git a/tests/test_litellm/proxy/_experimental/mcp_server/test_ui_session_utils.py b/tests/test_litellm/proxy/_experimental/mcp_server/test_ui_session_utils.py index 52120207f76..cd4cba51908 100644 --- a/tests/test_litellm/proxy/_experimental/mcp_server/test_ui_session_utils.py +++ b/tests/test_litellm/proxy/_experimental/mcp_server/test_ui_session_utils.py @@ -3,6 +3,7 @@ from unittest.mock import AsyncMock import pytest +from fastapi import HTTPException from litellm.constants import UI_SESSION_TOKEN_TEAM_ID from litellm.proxy._types import UserAPIKeyAuth @@ -120,3 +121,140 @@ def __init__(self) -> None: assert contexts[0].team_id == "team-span" assert contexts[0].parent_otel_span is parent_span + + +@pytest.mark.asyncio +async def test_build_effective_auth_contexts_appends_admitted_user_context(monkeypatch): + """LIT-4861: the dashboard session must resolve with the user's admitted identity so the + page list and every per-server action endpoint see user-level grants the same way the + gateway session does.""" + user_auth = UserAPIKeyAuth(team_id=UI_SESSION_TOKEN_TEAM_ID, user_id="user-42") + admitted_auth = UserAPIKeyAuth(user_id="user-42") + + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.ui_session_utils.resolve_ui_session_team_ids", + AsyncMock(return_value=["team-one"]), + ) + reload_mock = AsyncMock(return_value=admitted_auth) + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + reload_mock, + ) + + contexts = await build_effective_auth_contexts(user_auth) + + assert contexts[-1].user_id == "user-42" and contexts[-1].team_id is None + assert [ctx.team_id for ctx in contexts[:-1]] == ["team-one"] + reload_mock.assert_awaited_once_with("user-42") + + +@pytest.mark.asyncio +async def test_build_effective_auth_contexts_never_widens_caller_passed_keys(monkeypatch): + normal_user = UserAPIKeyAuth(team_id="regular-team", user_id="user-1") + reload_mock = AsyncMock() + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + reload_mock, + ) + + contexts = await build_effective_auth_contexts(normal_user) + + assert contexts == [normal_user] + reload_mock.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_build_effective_auth_contexts_survives_admitted_reload_failure(monkeypatch): + user_auth = UserAPIKeyAuth(team_id=UI_SESSION_TOKEN_TEAM_ID, user_id="user-9") + + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.ui_session_utils.resolve_ui_session_team_ids", + AsyncMock(return_value=["team-a"]), + ) + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + AsyncMock(side_effect=HTTPException(status_code=503, detail="db down")), + ) + + contexts = await build_effective_auth_contexts(user_auth) + + assert [ctx.team_id for ctx in contexts] == ["team-a"] + + +@pytest.mark.asyncio +async def test_acting_user_auth_returns_admitted_subject_for_non_admin_sessions(monkeypatch): + """LIT-4861: acting-as-user MCP routes must resolve a non-admin dashboard session as the + admitted subject so tool ceilings, reachability, and limits bind exactly as on /mcp.""" + from litellm.proxy._experimental.mcp_server.ui_session_utils import acting_user_auth + + user_auth = UserAPIKeyAuth(team_id=UI_SESSION_TOKEN_TEAM_ID, user_id="user-42", user_role="internal_user") + admitted_auth = UserAPIKeyAuth(user_id="user-42") + reload_mock = AsyncMock(return_value=admitted_auth) + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + reload_mock, + ) + + result = await acting_user_auth(user_auth) + + assert result.user_id == "user-42" and result.team_id is None + reload_mock.assert_awaited_once_with("user-42") + + +@pytest.mark.asyncio +async def test_acting_user_auth_keeps_admin_sessions_and_passed_keys_unchanged(monkeypatch): + from litellm.proxy._experimental.mcp_server.ui_session_utils import acting_user_auth + + reload_mock = AsyncMock() + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + reload_mock, + ) + + admin_session = UserAPIKeyAuth(team_id=UI_SESSION_TOKEN_TEAM_ID, user_id="admin-1", user_role="proxy_admin") + assert await acting_user_auth(admin_session) is admin_session + + passed_key = UserAPIKeyAuth(team_id="regular-team", user_id="user-1", user_role="internal_user") + assert await acting_user_auth(passed_key) is passed_key + + reload_mock.assert_not_awaited() + + +@pytest.mark.asyncio +async def test_acting_user_auth_falls_back_to_session_auth_on_reload_failure(monkeypatch): + from litellm.proxy._experimental.mcp_server.ui_session_utils import acting_user_auth + + user_auth = UserAPIKeyAuth(team_id=UI_SESSION_TOKEN_TEAM_ID, user_id="user-9", user_role="internal_user") + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + AsyncMock(side_effect=HTTPException(status_code=503, detail="db down")), + ) + + assert await acting_user_auth(user_auth) is user_auth + + +@pytest.mark.asyncio +async def test_admitted_user_context_carries_the_request_span(monkeypatch): + """Swapping the principal must not drop the request: the admitted subject is rebuilt from the + user row and carries no span of its own, so every consumer would otherwise lose trace linkage + for the resolution and logging it drives.""" + from litellm.proxy._experimental.mcp_server.ui_session_utils import acting_user_auth + + class DummySpan: + def __init__(self) -> None: + self._lock = threading.RLock() + + parent_span = DummySpan() + user_auth = UserAPIKeyAuth( + team_id=UI_SESSION_TOKEN_TEAM_ID, + user_id="user-42", + user_role="internal_user", + parent_otel_span=parent_span, + ) + monkeypatch.setattr( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + AsyncMock(return_value=UserAPIKeyAuth(user_id="user-42")), + ) + + assert (await acting_user_auth(user_auth)).parent_otel_span is parent_span + assert (await build_effective_auth_contexts(user_auth))[-1].parent_otel_span is parent_span diff --git a/tests/test_litellm/proxy/management_endpoints/test_mcp_management_endpoints.py b/tests/test_litellm/proxy/management_endpoints/test_mcp_management_endpoints.py index 53dda8f6648..bf119c4fb2f 100644 --- a/tests/test_litellm/proxy/management_endpoints/test_mcp_management_endpoints.py +++ b/tests/test_litellm/proxy/management_endpoints/test_mcp_management_endpoints.py @@ -6138,3 +6138,255 @@ def test_bundled_openapi_registry_parses_and_entries_are_well_formed(): ) for tool in entry.get("key_tools", []): assert tool.get("name") and tool.get("description"), f"{entry['name']}: malformed key_tool" + + +class TestConnectedAppViewAnnotation: + """LIT-4861: GET /v1/mcp/server?connected_app_view=true must annotate each server with + whether the caller's gateway OAuth sessions (connected apps) are served it on /mcp. + The view is honored only for the dashboard's UI session credential; a caller-passed + virtual key must never be widened to its owning user's identity.""" + + def _ui_session_auth(self, user_role: LitellmUserRoles = LitellmUserRoles.PROXY_ADMIN) -> UserAPIKeyAuth: + from litellm.constants import UI_SESSION_TOKEN_TEAM_ID + + return generate_mock_user_api_key_auth(user_role=user_role, team_id=UI_SESSION_TOKEN_TEAM_ID) + + def _mock_manager(self, servers, reachable_ids): + mock_manager = MagicMock() + mock_manager.get_all_allowed_mcp_servers = AsyncMock(return_value=servers) + mock_manager.get_all_mcp_servers_unfiltered = AsyncMock(return_value=servers) + mock_manager.get_allowed_mcp_servers = AsyncMock(return_value=reachable_ids) + return mock_manager + + def _servers(self): + return [ + generate_mock_mcp_server_db_record(server_id="server-1", alias="Granted"), + generate_mock_mcp_server_db_record(server_id="server-2", alias="Ungranted"), + ] + + @pytest.mark.asyncio + async def test_connected_app_view_annotates_reachability_via_admitted_resolver(self): + caller_auth = self._ui_session_auth() + admitted_auth = UserAPIKeyAuth(user_id="test_user_id") + admitted_auth.mcp_admitted_user_subject = True + mock_manager = self._mock_manager(self._servers(), ["server-1"]) + reload_mock = AsyncMock(return_value=admitted_auth) + + with ( + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.global_mcp_server_manager", + mock_manager, + ), + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.build_effective_auth_contexts", + AsyncMock(return_value=[caller_auth]), + ), + patch( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + reload_mock, + ), + ): + from litellm.proxy.management_endpoints.mcp_management_endpoints import ( + fetch_all_mcp_servers, + ) + + result = await fetch_all_mcp_servers(user_api_key_dict=caller_auth, connected_app_view=True) + + flags = {server.server_id: server.connected_app_reachable for server in result} + assert flags == {"server-1": True, "server-2": False} + reload_mock.assert_awaited_once_with("test_user_id") + mock_manager.get_allowed_mcp_servers.assert_awaited_once_with(admitted_auth) + + @pytest.mark.asyncio + async def test_connected_app_view_stamps_view_all_list_and_survives_non_admin_sanitizer(self): + """view_all preempts the manager's admin shortcut with a second whole-registry + shortcut; the annotation must still land, and must survive the non-admin sanitizer.""" + caller_auth = self._ui_session_auth(user_role=LitellmUserRoles.INTERNAL_USER) + mock_manager = self._mock_manager(self._servers(), ["server-2"]) + + with ( + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints._get_user_mcp_management_mode", + return_value="view_all", + ), + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.global_mcp_server_manager", + mock_manager, + ), + patch( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + AsyncMock(return_value=UserAPIKeyAuth(user_id="test_user_id")), + ), + ): + from litellm.proxy.management_endpoints.mcp_management_endpoints import ( + fetch_all_mcp_servers, + ) + + result = await fetch_all_mcp_servers(user_api_key_dict=caller_auth, connected_app_view=True) + + mock_manager.get_all_mcp_servers_unfiltered.assert_awaited_once() + flags = {server.server_id: server.connected_app_reachable for server in result} + assert flags == {"server-1": False, "server-2": True} + + @pytest.mark.asyncio + async def test_connected_app_view_lists_user_granted_servers_via_admitted_context(self): + """A server granted only through the user's own object permission must be listed and + flagged reachable: the REAL build_effective_auth_contexts appends the admitted-user + context, so the page and every action endpoint resolve it identically.""" + caller_auth = self._ui_session_auth(user_role=LitellmUserRoles.INTERNAL_USER) + admitted_auth = UserAPIKeyAuth(user_id="test_user_id", org_id="admitted-org") + listed_row = generate_mock_mcp_server_db_record(server_id="server-1", alias="TeamGranted") + user_granted_row = generate_mock_mcp_server_db_record(server_id="server-2", alias="UserGranted") + + async def per_context_servers(user_api_key_auth=None): + if user_api_key_auth is not None and user_api_key_auth.org_id == "admitted-org": + return [listed_row, user_granted_row] + return [listed_row] + + mock_manager = MagicMock() + mock_manager.get_all_allowed_mcp_servers = AsyncMock(side_effect=per_context_servers) + mock_manager.get_allowed_mcp_servers = AsyncMock(return_value=["server-1", "server-2"]) + + with ( + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.global_mcp_server_manager", + mock_manager, + ), + patch( + "litellm.proxy._experimental.mcp_server.ui_session_utils.resolve_ui_session_team_ids", + AsyncMock(return_value=[]), + ), + patch( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + AsyncMock(return_value=admitted_auth), + ), + ): + from litellm.proxy.management_endpoints.mcp_management_endpoints import ( + fetch_all_mcp_servers, + ) + + result = await fetch_all_mcp_servers(user_api_key_dict=caller_auth, connected_app_view=True) + + flags = {server.server_id: server.connected_app_reachable for server in result} + assert flags == {"server-1": True, "server-2": True} + + @pytest.mark.asyncio + async def test_connected_app_view_fails_closed_when_admitted_reload_fails(self): + caller_auth = self._ui_session_auth() + mock_manager = self._mock_manager(self._servers(), ["server-1"]) + + with ( + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.global_mcp_server_manager", + mock_manager, + ), + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.build_effective_auth_contexts", + AsyncMock(return_value=[caller_auth]), + ), + patch( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + AsyncMock(side_effect=HTTPException(status_code=401, detail="expired")), + ), + ): + from litellm.proxy.management_endpoints.mcp_management_endpoints import ( + fetch_all_mcp_servers, + ) + + result = await fetch_all_mcp_servers(user_api_key_dict=caller_auth, connected_app_view=True) + + assert all(server.connected_app_reachable is False for server in result) + + @pytest.mark.asyncio + async def test_connected_app_view_off_leaves_field_unset(self): + caller_auth = generate_mock_user_api_key_auth() + mock_manager = self._mock_manager(self._servers(), ["server-1"]) + reload_mock = AsyncMock(return_value=UserAPIKeyAuth(user_id="test_user_id")) + + with ( + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.global_mcp_server_manager", + mock_manager, + ), + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.build_effective_auth_contexts", + AsyncMock(return_value=[caller_auth]), + ), + patch( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + reload_mock, + ), + ): + from litellm.proxy.management_endpoints.mcp_management_endpoints import ( + fetch_all_mcp_servers, + ) + + result = await fetch_all_mcp_servers(user_api_key_dict=caller_auth) + + assert all(server.connected_app_reachable is None for server in result) + reload_mock.assert_not_awaited() + + @pytest.mark.asyncio + async def test_connected_app_view_userless_ui_credential_leaves_field_unset(self): + from litellm.constants import UI_SESSION_TOKEN_TEAM_ID + + caller_auth = UserAPIKeyAuth( + user_role=LitellmUserRoles.PROXY_ADMIN, api_key="test_api_key", team_id=UI_SESSION_TOKEN_TEAM_ID + ) + caller_auth.user_id = None + mock_manager = self._mock_manager(self._servers(), ["server-1"]) + reload_mock = AsyncMock(return_value=UserAPIKeyAuth(user_id="test_user_id")) + + with ( + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.global_mcp_server_manager", + mock_manager, + ), + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.build_effective_auth_contexts", + AsyncMock(return_value=[caller_auth]), + ), + patch( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + reload_mock, + ), + ): + from litellm.proxy.management_endpoints.mcp_management_endpoints import ( + fetch_all_mcp_servers, + ) + + result = await fetch_all_mcp_servers(user_api_key_dict=caller_auth, connected_app_view=True) + + assert all(server.connected_app_reachable is None for server in result) + reload_mock.assert_not_awaited() + + @pytest.mark.asyncio + async def test_connected_app_view_ignored_for_caller_passed_virtual_keys(self): + """A virtual key the user passes themselves is never widened to the owning user's + identity: the view param is a no-op and the admitted resolver is never consulted.""" + caller_auth = generate_mock_user_api_key_auth(team_id="some-real-team") + mock_manager = self._mock_manager(self._servers(), ["server-1"]) + reload_mock = AsyncMock(return_value=UserAPIKeyAuth(user_id="test_user_id")) + + with ( + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.global_mcp_server_manager", + mock_manager, + ), + patch( + "litellm.proxy.management_endpoints.mcp_management_endpoints.build_effective_auth_contexts", + AsyncMock(return_value=[caller_auth]), + ), + patch( + "litellm.proxy._experimental.mcp_server.auth.user_api_key_auth_mcp.MCPRequestHandler._reload_admitted_user", + reload_mock, + ), + ): + from litellm.proxy.management_endpoints.mcp_management_endpoints import ( + fetch_all_mcp_servers, + ) + + result = await fetch_all_mcp_servers(user_api_key_dict=caller_auth, connected_app_view=True) + + assert all(server.connected_app_reachable is None for server in result) + reload_mock.assert_not_awaited() diff --git a/ui/litellm-dashboard/eslint-suppressions.json b/ui/litellm-dashboard/eslint-suppressions.json index 1c07f2d6247..efb1d799a08 100644 --- a/ui/litellm-dashboard/eslint-suppressions.json +++ b/ui/litellm-dashboard/eslint-suppressions.json @@ -2755,7 +2755,7 @@ "count": 1 }, "no-nested-ternary": { - "count": 6 + "count": 4 } }, "src/components/chat/MCPConnectPicker.tsx": { diff --git a/ui/litellm-dashboard/src/components/chat/MCPAppsPanel.test.tsx b/ui/litellm-dashboard/src/components/chat/MCPAppsPanel.test.tsx index 656ef157363..5fc3e75195b 100644 --- a/ui/litellm-dashboard/src/components/chat/MCPAppsPanel.test.tsx +++ b/ui/litellm-dashboard/src/components/chat/MCPAppsPanel.test.tsx @@ -1,6 +1,6 @@ import React from "react"; -import { render, screen, fireEvent } from "@testing-library/react"; -import { describe, it, expect, vi, afterEach } from "vitest"; +import { render, screen, fireEvent, waitFor, act } from "@testing-library/react"; +import { describe, it, expect, vi, afterEach, beforeEach } from "vitest"; import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; import MCPAppsPanel from "./MCPAppsPanel"; import { fetchMCPServers, listMCPTools } from "../networking"; @@ -86,3 +86,208 @@ describe("MCPAppsPanel logos", () => { expect(screen.getByAltText("local_logo logo").getAttribute("src")).toBe("/litellm/ui/assets/logos/github.svg"); }); }); + +const connectServers = [ + { + server_id: "s-reach", + server_name: "reachable_srv", + auth_type: "none", + connected_app_reachable: true, + }, + { + server_id: "s-unreach", + server_name: "unreachable_srv", + auth_type: "none", + connected_app_reachable: false, + }, +] as MCPServer[]; + +const renderConnectPanel = (connectMode: boolean, selectedServers: string[] = []) => + render( + + + , + ); + +describe("MCPAppsPanel connected-app reachability (LIT-4861)", () => { + beforeEach(() => { + vi.clearAllMocks(); + }); + + it("requests the connected-app view and hides unreachable servers in connect mode", async () => { + vi.mocked(fetchMCPServers).mockResolvedValue(connectServers); + vi.mocked(listMCPTools).mockResolvedValue({ tools: [] }); + + renderConnectPanel(true, ["reachable_srv", "unreachable_srv"]); + + expect(await screen.findByText("reachable_srv")).toBeInTheDocument(); + expect(vi.mocked(fetchMCPServers)).toHaveBeenCalledWith("tok", undefined, true); + expect(screen.queryByText("unreachable_srv")).not.toBeInTheDocument(); + expect(screen.getByText("Connected (1)")).toBeInTheDocument(); + const toolCountFetchedIds = vi.mocked(listMCPTools).mock.calls.map((call) => call[1]); + expect(toolCountFetchedIds).toContain("s-reach"); + expect(toolCountFetchedIds).not.toContain("s-unreach"); + }); + + it("blocks connecting an unsupported server from the detail view in connect mode", async () => { + const detailServers = [ + ...connectServers, + { + server_id: "s-unsup", + server_name: "unsupported_srv", + auth_type: "oauth2_token_exchange", + connected_app_reachable: true, + }, + ] as MCPServer[]; + vi.mocked(fetchMCPServers).mockResolvedValue(detailServers); + vi.mocked(listMCPTools).mockResolvedValue({ tools: [] }); + + renderConnectPanel(true); + + fireEvent.click(await screen.findByText("unsupported_srv")); + expect(await screen.findByRole("heading", { name: "unsupported_srv" })).toBeInTheDocument(); + expect(screen.queryByRole("button", { name: "Connect" })).not.toBeInTheDocument(); + expect(screen.getByText("Not supported on this connection")).toBeInTheDocument(); + }); + + it("keeps the detail-view Connect action outside connect mode", async () => { + vi.mocked(fetchMCPServers).mockResolvedValue(connectServers); + vi.mocked(listMCPTools).mockResolvedValue({ tools: [] }); + + renderConnectPanel(false); + + fireEvent.click(await screen.findByText("unreachable_srv")); + expect(await screen.findByRole("heading", { name: "unreachable_srv" })).toBeInTheDocument(); + expect(screen.getByRole("button", { name: "Connect" })).toBeInTheDocument(); + }); + + it("ignores the flag and skips no server outside connect mode", async () => { + vi.mocked(fetchMCPServers).mockResolvedValue(connectServers); + vi.mocked(listMCPTools).mockResolvedValue({ tools: [] }); + + renderConnectPanel(false, ["reachable_srv", "unreachable_srv"]); + + expect(await screen.findByText("unreachable_srv")).toBeInTheDocument(); + expect(vi.mocked(fetchMCPServers)).toHaveBeenCalledWith("tok", undefined, false); + expect(screen.queryByText("Not available to connected apps")).not.toBeInTheDocument(); + expect(screen.getByText("Connected (2)")).toBeInTheDocument(); + const toolCountFetchedIds = vi.mocked(listMCPTools).mock.calls.map((call) => call[1]); + expect(toolCountFetchedIds).toContain("s-unreach"); + }); + + const revocable = (reachable: boolean) => + [ + { server_id: "s-reach", server_name: "reachable_srv", auth_type: "none", connected_app_reachable: true }, + { server_id: "s-drop", server_name: "revoked_srv", auth_type: "none", connected_app_reachable: reachable }, + ] as MCPServer[]; + + const ConnectPanel = ({ + token, + onChange, + client, + }: { + token: string; + onChange: (servers: string[]) => void; + client: QueryClient; + }) => ( + + + + ); + + const newClient = () => new QueryClient({ defaultOptions: { queries: { retry: false } } }); + + it("drops an open detail view when a refetch removes that server from the reachable set", async () => { + vi.mocked(fetchMCPServers).mockResolvedValueOnce(revocable(true)).mockResolvedValueOnce(revocable(false)); + vi.mocked(listMCPTools).mockResolvedValue({ tools: [] }); + + const client = newClient(); + const { rerender } = render(); + + fireEvent.click(await screen.findByText("revoked_srv")); + expect(await screen.findByRole("heading", { name: "revoked_srv" })).toBeInTheDocument(); + + rerender(); + + await waitFor(() => expect(screen.queryByRole("heading", { name: "revoked_srv" })).not.toBeInTheDocument()); + expect(screen.queryByRole("button", { name: "Connect" })).not.toBeInTheDocument(); + expect(screen.queryByText("revoked_srv")).not.toBeInTheDocument(); + expect(screen.getByText("reachable_srv")).toBeInTheDocument(); + }); + + it("does not select a server whose Connect finishes after a refetch removed it", async () => { + vi.mocked(fetchMCPServers).mockResolvedValueOnce(revocable(true)).mockResolvedValueOnce(revocable(false)); + vi.mocked(listMCPTools).mockResolvedValue({ tools: [] }); + + const onChange = vi.fn(); + const client = newClient(); + const { rerender } = render(); + + fireEvent.click(await screen.findByText("revoked_srv")); + expect(await screen.findByRole("heading", { name: "revoked_srv" })).toBeInTheDocument(); + + let finishConnect: (result: { tools: never[] }) => void = () => {}; + vi.mocked(listMCPTools).mockImplementationOnce(() => new Promise((resolve) => (finishConnect = resolve))); + fireEvent.click(screen.getByRole("button", { name: "Connect" })); + + rerender(); + await waitFor(() => expect(screen.queryByRole("heading", { name: "revoked_srv" })).not.toBeInTheDocument()); + + await act(async () => { + finishConnect({ tools: [] }); + }); + + expect(onChange).not.toHaveBeenCalled(); + expect(screen.queryByText("revoked_srv")).not.toBeInTheDocument(); + expect(screen.getByText("Connected", { exact: false }).textContent).toBe("Connected"); + }); + + it("does not select a server when Connect resolves in the same tick the refetch drops it", async () => { + let finishRefetch: (servers: MCPServer[]) => void = () => {}; + vi.mocked(fetchMCPServers) + .mockResolvedValueOnce(revocable(true)) + .mockImplementationOnce(() => new Promise((resolve) => (finishRefetch = resolve))); + vi.mocked(listMCPTools).mockResolvedValue({ tools: [] }); + + const onChange = vi.fn(); + const client = newClient(); + const { rerender } = render(); + + fireEvent.click(await screen.findByText("revoked_srv")); + expect(await screen.findByRole("heading", { name: "revoked_srv" })).toBeInTheDocument(); + + let finishConnect: (result: { tools: never[] }) => void = () => {}; + vi.mocked(listMCPTools).mockImplementationOnce(() => new Promise((resolve) => (finishConnect = resolve))); + fireEvent.click(screen.getByRole("button", { name: "Connect" })); + + rerender(); + + await act(async () => { + finishRefetch(revocable(false)); + finishConnect({ tools: [] }); + }); + + expect(onChange).not.toHaveBeenCalled(); + expect(screen.queryByText("revoked_srv")).not.toBeInTheDocument(); + }); + + it("does not let a superseded list load overwrite the current reachable set", async () => { + let finishStaleLoad: (servers: MCPServer[]) => void = () => {}; + vi.mocked(fetchMCPServers) + .mockImplementationOnce(() => new Promise((resolve) => (finishStaleLoad = resolve))) + .mockResolvedValueOnce(revocable(false)); + vi.mocked(listMCPTools).mockResolvedValue({ tools: [] }); + + const client = newClient(); + const { rerender } = render(); + rerender(); + + expect(await screen.findByText("reachable_srv")).toBeInTheDocument(); + + await act(async () => { + finishStaleLoad(revocable(true)); + }); + + expect(screen.queryByText("revoked_srv")).not.toBeInTheDocument(); + }); +}); diff --git a/ui/litellm-dashboard/src/components/chat/MCPAppsPanel.tsx b/ui/litellm-dashboard/src/components/chat/MCPAppsPanel.tsx index 329e4ec99fa..7dbfc058a77 100644 --- a/ui/litellm-dashboard/src/components/chat/MCPAppsPanel.tsx +++ b/ui/litellm-dashboard/src/components/chat/MCPAppsPanel.tsx @@ -103,16 +103,17 @@ const MCPAppsPanel: React.FC = ({ accessToken, selectedServers, onChange, const [query, setQuery] = useState(""); const [activeTab, setActiveTab] = useState("all"); const [togglingOn, setTogglingOn] = useState>(new Set()); - const [detailServer, setDetailServer] = useState(null); + const [detailServerId, setDetailServerId] = useState(null); const [toolCounts, setToolCounts] = useState>({}); const [loadingCounts, setLoadingCounts] = useState(false); const [oauthConnected, setOauthConnected] = useState>(new Set()); const [oauthChecking, setOauthChecking] = useState>(new Set()); const serversRef = useRef([]); - useEffect(() => { - serversRef.current = servers; - }, [servers]); + const commitServers = useCallback((next: MCPServer[]) => { + serversRef.current = next; + setServers(next); + }, []); const selectedServersRef = useRef(selectedServers); useEffect(() => { selectedServersRef.current = selectedServers; @@ -124,13 +125,30 @@ const MCPAppsPanel: React.FC = ({ accessToken, selectedServers, onChange, const nameOf = (s: MCPServer) => s.server_name ?? s.alias ?? s.server_id; - const fetchLoadCancelledRef = useRef(false); + const detailServer = servers.find((s) => s.server_id === detailServerId); + + const connectUnavailabilityLabel = useCallback( + (s: MCPServer): string | null => { + if (!connectMode) return null; + if (isUnsupportedOnGatewayConnect(s.auth_type)) return "Not supported on this connection"; + return null; + }, + [connectMode], + ); + + const connectableNow = useCallback( + (serverId: string): MCPServer | undefined => { + const current = serversRef.current.find((s) => s.server_id === serverId); + return current !== undefined && connectUnavailabilityLabel(current) === null ? current : undefined; + }, + [connectUnavailabilityLabel], + ); const fetchToolCount = useCallback( - async (server: MCPServer) => { + async (server: MCPServer, isCurrentLoad: () => boolean) => { try { const toolsData = await listMCPTools(accessToken, server.server_id); - if (fetchLoadCancelledRef.current) return; + if (!isCurrentLoad()) return; const tools: MCPTool[] = Array.isArray(toolsData?.tools) ? toolsData.tools : []; setToolCounts((prev) => ({ ...prev, [nameOf(server)]: tools.length })); } catch { @@ -141,17 +159,17 @@ const MCPAppsPanel: React.FC = ({ accessToken, selectedServers, onChange, ); const checkOauthCredential = useCallback( - async (server: MCPServer) => { + async (server: MCPServer, isCurrentLoad: () => boolean) => { try { const status = await getMCPOAuthUserCredentialStatus(accessToken, server.server_id); - if (fetchLoadCancelledRef.current) return; + if (!isCurrentLoad()) return; if (status.has_credential && !status.is_expired) { setOauthConnected((prev) => new Set(prev).add(server.server_id)); } } catch { // ignore } finally { - if (!fetchLoadCancelledRef.current) { + if (isCurrentLoad()) { setOauthChecking((prev) => { const next = new Set(prev); next.delete(server.server_id); @@ -164,70 +182,77 @@ const MCPAppsPanel: React.FC = ({ accessToken, selectedServers, onChange, ); useEffect(() => { - fetchLoadCancelledRef.current = false; + let current = true; + const isCurrentLoad = () => current; - fetchMCPServers(accessToken) + fetchMCPServers(accessToken, undefined, connectMode) .then(async (serverData) => { - if (fetchLoadCancelledRef.current) return; + if (!isCurrentLoad()) return; const list: MCPServer[] = Array.isArray(serverData) ? serverData : serverData?.data ?? []; - const oauthServers = list.filter((s) => s.auth_type === AUTH_TYPE.OAUTH2); - setServers(list); + const reachable = connectMode ? list.filter((s) => s.connected_app_reachable !== false) : list; + const oauthServers = reachable.filter((s) => s.auth_type === AUTH_TYPE.OAUTH2); + commitServers(reachable); setOauthChecking(new Set(oauthServers.map((s) => s.server_id))); setLoading(false); - oauthServers.forEach((s) => checkOauthCredential(s)); + oauthServers.forEach((s) => checkOauthCredential(s, isCurrentLoad)); setLoadingCounts(true); - const chunks = Array.from({ length: Math.ceil(list.length / TOOLS_FETCH_CONCURRENCY) }, (_, i) => - list.slice(i * TOOLS_FETCH_CONCURRENCY, (i + 1) * TOOLS_FETCH_CONCURRENCY), + const chunks = Array.from({ length: Math.ceil(reachable.length / TOOLS_FETCH_CONCURRENCY) }, (_, i) => + reachable.slice(i * TOOLS_FETCH_CONCURRENCY, (i + 1) * TOOLS_FETCH_CONCURRENCY), ); for (const chunk of chunks) { - if (fetchLoadCancelledRef.current) return; - await Promise.allSettled(chunk.map((s) => fetchToolCount(s))); + if (!isCurrentLoad()) return; + await Promise.allSettled(chunk.map((s) => fetchToolCount(s, isCurrentLoad))); } - if (!fetchLoadCancelledRef.current) setLoadingCounts(false); + if (isCurrentLoad()) setLoadingCounts(false); }) .catch(() => { - if (!fetchLoadCancelledRef.current) { - setServers([]); + if (isCurrentLoad()) { + commitServers([]); setLoading(false); } }); return () => { - fetchLoadCancelledRef.current = true; + current = false; }; - }, [accessToken, fetchToolCount, checkOauthCredential]); + }, [accessToken, connectMode, commitServers, fetchToolCount, checkOauthCredential]); useEffect(() => { if (oauthConnected.size === 0) return; const namesToAdd = serversRef.current - .filter((s) => oauthConnected.has(s.server_id) && !selectedServersRef.current.includes(nameOf(s))) + .filter( + (s) => + oauthConnected.has(s.server_id) && + !selectedServersRef.current.includes(nameOf(s)) && + connectUnavailabilityLabel(s) === null, + ) .map(nameOf); if (namesToAdd.length > 0) { onChangeRef.current([...selectedServersRef.current, ...namesToAdd]); } - }, [oauthConnected]); + }, [oauthConnected, connectUnavailabilityLabel]); - const handleToggle = async (serverName: string, checked: boolean, serverId?: string) => { + const handleToggle = async (server: MCPServer, checked: boolean) => { + const serverName = nameOf(server); if (!checked) { onChange(selectedServers.filter((s) => s !== serverName)); - if (serverId) { - setOauthConnected((prev) => { - const next = new Set(prev); - next.delete(serverId); - return next; - }); - } + setOauthConnected((prev) => { + const next = new Set(prev); + next.delete(server.server_id); + return next; + }); return; } + if (connectableNow(server.server_id) === undefined) return; setTogglingOn((prev) => new Set(prev).add(serverName)); try { - const idToFetch = serverId ?? serverName; - const result = await listMCPTools(accessToken, idToFetch); + const result = await listMCPTools(accessToken, server.server_id); if (result?.error) { MessageManager.warning(`Could not load tools for ${serverName}`); return; } + if (connectableNow(server.server_id) === undefined) return; if (!selectedServersRef.current.includes(serverName)) { onChange([...selectedServersRef.current, serverName]); } @@ -243,11 +268,10 @@ const MCPAppsPanel: React.FC = ({ accessToken, selectedServers, onChange, }; const renderConnectionIndicator = (server: MCPServer) => { - if (connectMode && isUnsupportedOnGatewayConnect(server.auth_type)) { + const unavailabilityLabel = connectUnavailabilityLabel(server); + if (unavailabilityLabel !== null) { return ( - - Not supported on this connection - + {unavailabilityLabel} ); } if (server.auth_type === AUTH_TYPE.OAUTH2) { @@ -285,11 +309,23 @@ const MCPAppsPanel: React.FC = ({ accessToken, selectedServers, onChange, !query.trim() || name.toLowerCase().includes(query.toLowerCase()) || (s.description ?? "").toLowerCase().includes(query.toLowerCase()); - const matchesTab = activeTab === "all" || selectedServers.includes(name); + const matchesTab = + activeTab === "all" || (selectedServers.includes(name) && connectUnavailabilityLabel(s) === null); return matchesQuery && matchesTab; }); - const connectedCount = servers.filter((s) => selectedServers.includes(nameOf(s))).length; + const connectedCount = servers.filter( + (s) => selectedServers.includes(nameOf(s)) && connectUnavailabilityLabel(s) === null, + ).length; + + const emptyStateText = () => { + if (servers.length === 0) { + return connectMode + ? "No MCP servers are available to this connection yet. Ask an admin to grant your user or team access." + : "No MCP servers configured. Add servers in Tools -> MCP Servers."; + } + return activeTab === "connected" ? "No servers connected yet." : "No servers match your search."; + }; const totalTools = Object.values(toolCounts).reduce((sum, n) => sum + n, 0); if (detailServer) { @@ -298,12 +334,65 @@ const MCPAppsPanel: React.FC = ({ accessToken, selectedServers, onChange, const isTogglingOn = togglingOn.has(name); const color = getAvatarColor(name); + const renderDetailAction = () => { + const unavailabilityLabel = connectUnavailabilityLabel(detailServer); + if (unavailabilityLabel !== null) { + return {unavailabilityLabel}; + } + if (detailServer.auth_type !== AUTH_TYPE.OAUTH2) { + return ( + + ); + } + if (oauthConnected.has(detailServer.server_id)) { + return ( + + ); + } + return ( + { + setOauthConnected((prev) => new Set(prev).add(id)); + }} + variant="button" + /> + ); + }; + return (
- {detailServer.auth_type === AUTH_TYPE.OAUTH2 ? ( - oauthConnected.has(detailServer.server_id) ? ( - - ) : ( - { - setOauthConnected((prev) => new Set(prev).add(id)); - }} - variant="button" - /> - ) - ) : ( - - )} + {renderDetailAction()}

Information

@@ -494,13 +542,7 @@ const MCPAppsPanel: React.FC = ({ accessToken, selectedServers, onChange, ))} ) : filtered.length === 0 ? ( -
- {servers.length === 0 - ? "No MCP servers configured. Add servers in Tools -> MCP Servers." - : activeTab === "connected" - ? "No servers connected yet." - : "No servers match your search."} -
+
{emptyStateText()}
) : (
{filtered.map((server, idx) => { @@ -508,16 +550,16 @@ const MCPAppsPanel: React.FC = ({ accessToken, selectedServers, onChange, const color = getAvatarColor(name); const isLeftCol = idx % 2 === 0; const count = toolCounts[name]; - const unsupported = !!connectMode && isUnsupportedOnGatewayConnect(server.auth_type); + const unavailable = connectUnavailabilityLabel(server) !== null; return (
setDetailServer(server)} + onClick={() => setDetailServerId(server.server_id)} className={`flex items-center gap-3 p-4 bg-card cursor-pointer transition-colors hover:bg-accent/30 min-w-0 ${ isLeftCol ? "border-r" : "" } ${Math.floor(idx / 2) < Math.floor((filtered.length - 1) / 2) ? "border-b" : ""} ${ - unsupported ? "opacity-50" : "" + unavailable ? "opacity-50" : "" }`} > {server.mcp_info?.logo_url ? ( diff --git a/ui/litellm-dashboard/src/components/mcp_tools/types.tsx b/ui/litellm-dashboard/src/components/mcp_tools/types.tsx index de497d91afe..44ac25ea955 100644 --- a/ui/litellm-dashboard/src/components/mcp_tools/types.tsx +++ b/ui/litellm-dashboard/src/components/mcp_tools/types.tsx @@ -436,6 +436,7 @@ export interface MCPServer { byok_description?: string[] | null; byok_api_key_help_url?: string | null; has_user_credential?: boolean | null; + connected_app_reachable?: boolean | null; /** GitHub / source repository URL */ source_url?: string | null; diff --git a/ui/litellm-dashboard/src/components/networking.tsx b/ui/litellm-dashboard/src/components/networking.tsx index a15767d26cb..84549c8d0f9 100644 --- a/ui/litellm-dashboard/src/components/networking.tsx +++ b/ui/litellm-dashboard/src/components/networking.tsx @@ -4782,9 +4782,12 @@ export const fetchDiscoverableMCPServers = async (accessToken: string) => { } }; -export const fetchMCPServers = async (accessToken: string, teamId?: string | null) => { +export const fetchMCPServers = async (accessToken: string, teamId?: string | null, connectedAppView?: boolean) => { try { - return await apiClient.get(`/v1/mcp/server`, { accessToken, query: { team_id: teamId || undefined } }); + return await apiClient.get(`/v1/mcp/server`, { + accessToken, + query: { team_id: teamId || undefined, connected_app_view: connectedAppView || undefined }, + }); } catch (error) { console.error("Failed to fetch MCP servers:", error); throw error;