Enterprise agent platform for building, deploying, and operating AI teammates.
feat(v1): delete and switch MCP connectors with a personal key (#3751)
Alex Liu4cdc0542452a
diff --git a/src/xagent/web/api/v1/errors.py b/src/xagent/web/api/v1/errors.pyindex 978682572..cfef3f5fc 100644--- a/src/xagent/web/api/v1/errors.py+++ b/src/xagent/web/api/v1/errors.py@@ -156,6 +156,20 @@ class V1ErrorCode(str, Enum):# names the holder's own connector when the exact name is theirs.CONNECTOR_NAME_CONFLICT = "connector_name_conflict"+ # The connector cannot be changed or deleted through the API: it is a+ # catalog app connection, or a connector with OAuth connections that+ # another account (such as an automation account) manages through the+ # holder's link. 409.+ # ``details.reason`` says which: ``catalog`` or ``managed_elsewhere``+ # (``unknown`` for a 409 from a create or a switch, which the web code+ # does not raise today).+ CONNECTOR_NOT_EDITABLE = "connector_not_editable"++ # The key holder may see the connector but may not change it: the team+ # shares it, or the web rules deny the holder this change. 403.+ # ``details.reason`` says which: ``team_shared`` or ``not_permitted``.+ CONNECTOR_FORBIDDEN = "connector_forbidden"+# The connector cannot be started from the API. 409.# ``details.reason`` says why: ``team_shared`` or ``disabled`` from the# check made before anything starts; otherwise the connector session's own@@ -271,6 +285,12 @@ _DEFAULT_MESSAGES: dict[V1ErrorCode, str] = {"unique across all users and are compared case-insensitively, treating ""spaces, hyphens and underscores as the same character."),+ V1ErrorCode.CONNECTOR_NOT_EDITABLE: (+ "This connector can only be changed in the web app."+ ),+ V1ErrorCode.CONNECTOR_FORBIDDEN: (+ "You do not have permission to change this connector."+ ),V1ErrorCode.CONNECTOR_UNAVAILABLE: ("This connector cannot be started from the API; details.reason says why."),diff --git a/src/xagent/web/api/v1/mcp_servers.py b/src/xagent/web/api/v1/mcp_servers.pyindex c3121a132..851c5f666 100644--- a/src/xagent/web/api/v1/mcp_servers.py+++ b/src/xagent/web/api/v1/mcp_servers.py@@ -24,6 +24,8 @@ from ...models.user import Userfrom ...schemas.v1 import (V1McpServer,V1McpServerCreateRequest,+ V1McpServerDeleteResponse,+ V1McpServerEnabledRequest,V1McpServerTools,V1McpTool,V1McpToolLoadFailure,@@ -132,6 +134,18 @@ def _is_bad_request(exc: HTTPException) -> bool:return exc.status_code == 400+def _has_status(+ status_code: int,+) -> Callable[[HTTPException, str, Sequence[str]], bool]:+ return lambda exc, _name, _secrets: exc.status_code == status_code+++_MANAGED_ELSEWHERE_MESSAGE = (+ "This connector has connections managed outside your account; remove it in "+ "the web app."+)++# The first matching row wins; the last row matches every remaining failure._MCP_WRITE_ERROR_ROWS: tuple[_WriteErrorRow, ...] = (_WriteErrorRow(@@ -176,6 +190,27 @@ _MCP_WRITE_ERROR_ROWS: tuple[_WriteErrorRow, ...] = (V1ErrorCode.INVALID_INPUT,_no_message,),+ _WriteErrorRow(+ "forbidden",+ _has_status(403),+ 403,+ V1ErrorCode.CONNECTOR_FORBIDDEN,+ _no_message,+ ),+ _WriteErrorRow(+ "not_found",+ _has_status(404),+ 404,+ V1ErrorCode.CONNECTOR_NOT_FOUND,+ _no_message,+ ),+ _WriteErrorRow(+ "managed_elsewhere",+ _has_status(409),+ 409,+ V1ErrorCode.CONNECTOR_NOT_EDITABLE,+ _no_message,+ ),_WriteErrorRow("internal_error",lambda _exc, _n, _s: True,@@ -211,14 +246,22 @@ def _raise_v1_from_mcp_write_error(action,exc.status_code,)- details = (- {"connector_id": owned_connector_id}- if row.id == "exact_name_conflict" and owned_connector_id is not None- else None- )- raise V1ApiError(- row.code, row.status, row.message(exc, requested_name, secrets), details- ) from exc+ message = row.message(exc, requested_name, secrets)+ details: Optional[dict[str, Any]] = None+ if row.id == "exact_name_conflict" and owned_connector_id is not None:+ details = {"connector_id": owned_connector_id}+ elif row.id == "forbidden":+ details = {"reason": "not_permitted"}+ elif row.id == "managed_elsewhere":+ # Of the web writes called here, only the delete answers 409: the+ # connector has OAuth connections another account manages. Any+ # other action has no such 409 today.+ if action == "delete":+ message = _MANAGED_ELSEWHERE_MESSAGE+ details = {"reason": "managed_elsewhere"}+ else:+ details = {"reason": "unknown"}+ raise V1ApiError(row.code, row.status, message, details) from excraise AssertionError("the last row matches every failure") # pragma: no cover@@ -362,6 +405,66 @@ async def create_mcp_server()[email protected]("/{server_id}", response_model=V1McpServerDeleteResponse)+async def delete_mcp_server(+ server_id: int = Path(gt=0, le=2**31 - 1),+ authed: tuple[UserPrincipalSnapshot, PersonalApiKeySnapshot] = Depends(+ get_user_from_personal_key+ ),+) -> V1McpServerDeleteResponse:+ """Delete one of the key holder's connectors.++ This removes the holder's link to the connector; the definition goes with+ the last link, unless the team keeps it. A connector the holder cannot+ see answers 404; one seen only through the team answers 403+ ``connector_forbidden``; a catalog app connection, or a connector with+ OAuth connections that another account (such as an automation account)+ manages through your link, answers 409 ``connector_not_editable``.+ """+ user, key = authed+ try:+ await McpServerManagementRuntime().delete_server(+ user_id=int(user.id), key_prefix=key.key_prefix, server_id=server_id+ )+ except HTTPException as exc:+ _raise_v1_from_mcp_write_error(+ exc, action="delete", requested_name="", secrets=()+ )+ return V1McpServerDeleteResponse(id=server_id)++[email protected]("/{server_id}/enabled", response_model=V1McpServer)+async def set_mcp_server_enabled(+ request: V1McpServerEnabledRequest,+ server_id: int = Path(gt=0, le=2**31 - 1),+ authed: tuple[UserPrincipalSnapshot, PersonalApiKeySnapshot] = Depends(+ get_user_from_personal_key+ ),+) -> V1McpServer:+ """Switch one of the key holder's connectors on or off.++ Setting the value a connector already has is not an error. Only the+ holder's own switch changes; catalog and non-remote connectors can be+ switched too. A connector seen only through the team answers 403+ ``connector_forbidden``.+ """+ user, key = authed+ try:+ return await McpServerManagementRuntime().set_enabled(+ user_id=int(user.id),+ key_prefix=key.key_prefix,+ server_id=server_id,+ enabled=request.enabled,+ )+ except HTTPException as exc:+ _raise_v1_from_mcp_write_error(+ exc,+ action="enable" if request.enabled else "disable",+ requested_name="",+ secrets=(),+ )++# ===== listing a connector's tools =====_V1_TOOL_LISTING_MAX_INFLIGHT = 4diff --git a/src/xagent/web/schemas/v1.py b/src/xagent/web/schemas/v1.pyindex 84d6dc24e..4f1e80ec3 100644--- a/src/xagent/web/schemas/v1.py+++ b/src/xagent/web/schemas/v1.py@@ -27,7 +27,14 @@ Design notes:from datetime import datetimefrom typing import Annotated, Any, Dict, List, Literal, Optional-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StringConstraints+from pydantic import (+ BaseModel,+ ConfigDict,+ Field,+ StrictBool,+ StrictInt,+ StringConstraints,+)from ..api.skill_hub import _MAX_SKILL_MD_CHARS, _NAME_REfrom .agent import PromptContextFieldDeclaration, PromptContextFieldList@@ -679,6 +686,20 @@ class V1McpServerCreateRequest(BaseModel):)+class V1McpServerEnabledRequest(BaseModel):+ """Body for ``PUT /v1/mcp-servers/{server_id}/enabled``."""++ model_config = ConfigDict(extra="forbid")++ enabled: StrictBool = Field(+ ..., description="Whether the connector is switched on for the key holder."+ )+++class V1McpServerDeleteResponse(BaseModel):+ id: int++class CreateTaskResponse(BaseModel):"""``POST /v1/chat/tasks`` -> 202 Accepted response.diff --git a/src/xagent/web/services/mcp_server_management.py b/src/xagent/web/services/mcp_server_management.pyindex dfbe45cfd..eba74ac47 100644--- a/src/xagent/web/services/mcp_server_management.py+++ b/src/xagent/web/services/mcp_server_management.py@@ -12,11 +12,15 @@ module's own ``_masked_auth``.A create calls the web ``create_mcp_server`` with a request model built fromthe SDK body, so the web code decides every stored value, name rule andencryption. This module never assigns ``url`` or ``auth`` on a stored row.-The web function's ``HTTPException`` propagates; the route translates it.+A delete calls the web ``delete_mcp_server`` and a switch calls the web+``update_mcp_server`` with an ``is_active``-only request, after this module has+checked that the holder has a link of their own to change. The web function's+``HTTPException`` propagates; the route translates it."""from __future__ import annotations+import asyncioimport loggingfrom typing import Any, Iterable, Optional, cast@@ -25,6 +29,7 @@ from ...core.tools.adapters.vibe.signed_upload import signed_upload_settings_errfrom ...core.tools.core.mcp.model import MASKED_SECRET_VALUE, SENSITIVE_AUTH_FIELDSfrom ..api.mcp import (MCPServerCreate,+ MCPServerUpdate,_check_mcp_permission,_default_resource_owner_key,_enrich_oauth_server_info,@@ -34,6 +39,8 @@ from ..api.mcp import (_oauth_account_summaries,_require_parsable_mcp_oauth_identifiers,create_mcp_server,+ delete_mcp_server,+ update_mcp_server,)from ..models.database import get_session_localfrom ..models.mcp import MCPServer, UserMCPServer@@ -70,6 +77,15 @@ _REMOTE_TRANSPORTS = frozenset({"streamable_http", "sse"})_CATALOG_AUTH_KEYS = ("app_id", "provider", "builtin_provenance")+_TEAM_READ_ONLY_MESSAGE = (+ "This connector is shared with your team and is read-only through the API."+)+_CATALOG_NOT_EDITABLE_MESSAGE = (+ "This connector is a catalog app connection, or cannot be shown not to be "+ "one, so it can only be changed in the web app."+)++def _log_write(action: str, key_prefix: str, user_id: int, server_id: int) -> None:# Nothing but identifiers: no name, no configuration.logger.info(@@ -176,6 +192,32 @@ def resolve_holder_connector(return None+def _resolve_changeable(+ db: Any, user_id: int, server_id: int+) -> tuple[MCPServer, UserMCPServer]:+ """The connector and the holder's own link, for a change the holder may try.++ A connector the holder cannot see is a 404. One seen only through the+ team has no link of the holder's own to change, so it is refused with 403+ before any web function runs.+ """+ # Imported here for the reason given in ``_load_holder``.+ from ..api.v1.errors import V1ApiError, V1ErrorCode++ row = resolve_holder_connector(db, user_id, server_id)+ if row is None:+ raise V1ApiError(V1ErrorCode.CONNECTOR_NOT_FOUND, 404)+ server, link = row+ if link is None:+ raise V1ApiError(+ V1ErrorCode.CONNECTOR_FORBIDDEN,+ 403,+ _TEAM_READ_ONLY_MESSAGE,+ details={"reason": "team_shared"},+ )+ return server, link++def _catalog_classification_keys(db: Any, servers: Iterable[MCPServer]) -> frozenset[str]:@@ -540,6 +582,71 @@ class McpServerManagementRuntime:return await run_db_io_cancellation_safe(run)+ async def delete_server(+ self, *, user_id: int, key_prefix: str, server_id: int+ ) -> None:+ """Delete the holder's link to a connector through the web delete.++ The web function is a coroutine because it revokes OAuth grants over+ the network after committing. It runs on a new event loop in this+ worker thread, so none of the web function's database work blocks the+ loop that serves requests. Catalog connectors are refused before it+ runs.+ """+ # Imported here for the reason given in ``_load_holder``.+ from ..api.v1.errors import V1ApiError, V1ErrorCode++ def run() -> None:+ with get_session_local()() as db:+ user = _load_holder(db, user_id)+ server, _link = _resolve_changeable(db, user_id, server_id)+ if connector_kind(db, server) == "catalog":+ raise V1ApiError(+ V1ErrorCode.CONNECTOR_NOT_EDITABLE,+ 409,+ _CATALOG_NOT_EDITABLE_MESSAGE,+ details={"reason": "catalog"},+ )+ asyncio.run(delete_mcp_server(server_id, current_user=user, db=db))+ _log_write("delete", key_prefix, user_id, server_id)++ await run_db_io_cancellation_safe(run)++ async def set_enabled(+ self, *, user_id: int, key_prefix: str, server_id: int, enabled: bool+ ) -> V1McpServer:+ """Switch the holder's own link on or off and return the connector.++ Only ``is_active`` is sent to the web function, so the shared+ definition is neither locked nor written.+ """+ # Imported here for the reason given in ``_load_holder``.+ from ..api.v1.errors import V1ApiError, V1ErrorCode++ def run() -> V1McpServer:+ with get_session_local()() as db:+ user = _load_holder(db, user_id)+ _resolve_changeable(db, user_id, server_id)+ update_mcp_server(+ server_id,+ MCPServerUpdate(is_active=enabled),+ current_user=user,+ db=db,+ )+ row = resolve_holder_connector(db, user_id, server_id)+ if row is None or row[1] is None:+ # The web function has committed the update, so the+ # holder's link is gone only if it was deleted in between,+ # even when the team still shares the connector.+ raise V1ApiError(V1ErrorCode.CONNECTOR_NOT_FOUND, 404)+ projected = _project_rows(db, user, [row])[0]+ _log_write(+ "enable" if enabled else "disable", key_prefix, user_id, server_id+ )+ return projected++ return await run_db_io_cancellation_safe(run)+async def require_listable(self, *, user_id: int, server_id: int) -> None:"""Raise unless the holder may have this connector's tools listed.diff --git a/tests/web/api/v1/test_mcp_server_delete_enable.py b/tests/web/api/v1/test_mcp_server_delete_enable.pynew file mode 100644index 000000000..bcd86b3a9--- /dev/null+++ b/tests/web/api/v1/test_mcp_server_delete_enable.py@@ -0,0 +1,824 @@+"""Integration tests for deleting and switching connectors through /v1."""++import asyncio+import logging+import threading+from datetime import datetime, timedelta, timezone+from typing import Any++import httpx+import pytest+import sqlalchemy as sa+from fastapi import Depends, HTTPException+from fastapi.security import HTTPAuthorizationCredentials+from sqlalchemy.exc import OperationalError++from xagent.core.utils.encryption import encrypt_value+from xagent.web.api import mcp as mcp_api+from xagent.web.api.v1.deps import _bearer, get_user_from_personal_key+from xagent.web.api.v1.errors import _DEFAULT_MESSAGES, V1ErrorCode+from xagent.web.models.database import get_engine+from xagent.web.models.mcp import MCPServer, UserMCPServer+from xagent.web.models.mcp_oauth import MCPOAuthClient, MCPOAuthFlowState, MCPOAuthGrant+from xagent.web.services import connector_team_scope, mcp_server_management+from xagent.web.services.connector_team_scope import ConnectorDeleteDecision++from ..conftest import _direct_db_session, app_for_tests, client+from .test_mcp_servers import secret_connector # noqa: F401 (fixture)+from .test_mcp_servers import (+ _CATALOG_CELLS,+ _SECRETS,+ CONNECTOR_URL,+ Holder,+ _assert_nothing_written,+ _error,+ _get_one,+ _holder,+ _key_prefix,+ _link,+ _list,+ _seed,+ _seed_catalog_apps,+ _seed_grant,+ _share_with_team,+ _store,+)++pytestmark = pytest.mark.usefixtures("_test_db")++_TEAM_READ_ONLY = (+ "This connector is shared with your team and is read-only through the API."+)+_NOT_EDITABLE_CATALOG = (+ "This connector is a catalog app connection, or cannot be shown not to be "+ "one, so it can only be changed in the web app."+)+_MANAGED_ELSEWHERE = (+ "This connector has connections managed outside your account; remove it in "+ "the web app."+)+_FORBIDDEN = _DEFAULT_MESSAGES[V1ErrorCode.CONNECTOR_FORBIDDEN]+_NOT_FOUND = _DEFAULT_MESSAGES[V1ErrorCode.CONNECTOR_NOT_FOUND]+_INTERNAL = _DEFAULT_MESSAGES[V1ErrorCode.INTERNAL_ERROR]++# The three write actions this module adds, as the log line names them.+_WRITE_ACTIONS = ["delete", "enable", "disable"]++[email protected](autouse=True)+def _no_team_hooks():+ connector_team_scope.set_connector_team_hooks()+ yield+ connector_team_scope.set_connector_team_hooks()+++def bob() -> Holder:+ return _holder("bob")+++def carol() -> Holder:+ return _holder("carol")+++# ===== helpers =====+++def _delete(holder: Holder, server_id: int):+ return client.delete(f"/v1/mcp-servers/{server_id}", headers=holder.headers)+++def _set_enabled(holder: Holder, server_id: int, enabled: Any):+ return client.put(+ f"/v1/mcp-servers/{server_id}/enabled",+ headers=holder.headers,+ json={"enabled": enabled},+ )+++def _act(action: str, holder: Holder, server_id: int):+ if action == "delete":+ return _delete(holder, server_id)+ return _set_enabled(holder, server_id, action == "enable")+++def _link_of(holder: Holder, server_id: int) -> UserMCPServer | None:+ db = _direct_db_session()+ try:+ return (+ db.query(UserMCPServer)+ .filter_by(user_id=holder.user_id, mcpserver_id=server_id)+ .one_or_none()+ )+ finally:+ db.close()+++def _definition_exists(server_id: int) -> bool:+ db = _direct_db_session()+ try:+ return db.query(MCPServer.id).filter_by(id=server_id).first() is not None+ finally:+ db.close()+++def _grant_count(server_id: int) -> int:+ db = _direct_db_session()+ try:+ return db.query(MCPOAuthGrant).filter_by(mcp_server_id=server_id).count()+ finally:+ db.close()+++def _seed_flow_state(holder: Holder, server_id: int) -> None:+ """One pending OAuth flow of ``holder``; the grant seed makes its client row."""+ db = _direct_db_session()+ try:+ client_row = db.query(MCPOAuthClient).filter_by(mcp_server_id=server_id).one()+ db.add(+ MCPOAuthFlowState(+ state=f"state-{holder.user_id}-{server_id}",+ mcp_server_id=server_id,+ user_id=holder.user_id,+ mcp_oauth_client_id=client_row.id,+ resource_owner_key=f"xagent:user:{holder.user_id}",+ issuer="https://auth.example.test",+ resource="https://mcp.example.test/mcp",+ scope="read write",+ code_verifier="verifier",+ expires_at=datetime.now(timezone.utc) + timedelta(minutes=10),+ )+ )+ db.commit()+ finally:+ db.close()+++def _flow_state_count(server_id: int) -> int:+ db = _direct_db_session()+ try:+ return db.query(MCPOAuthFlowState).filter_by(mcp_server_id=server_id).count()+ finally:+ db.close()+++class _Calls:+ """Counts calls to the web functions, which must not run on a refusal."""++ def __init__(self, monkeypatch) -> None:+ self.calls: list[str] = []++ async def delete(*_a, **_k):+ self.calls.append("delete")+ raise AssertionError("web delete must not run")++ def update(*_a, **_k):+ self.calls.append("update")+ raise AssertionError("web update must not run")++ monkeypatch.setattr(mcp_server_management, "delete_mcp_server", delete)+ monkeypatch.setattr(mcp_server_management, "update_mcp_server", update)+++def _lose_the_link():+ """A ``resolve_holder_connector`` that finds the connector on its first call+ and nothing on its second, as if another request deleted it in between."""+ real = mcp_server_management.resolve_holder_connector+ calls = {"n": 0}++ def resolve(db, user_id, server_id):+ calls["n"] += 1+ return real(db, user_id, server_id) if calls["n"] == 1 else None++ return resolve+++def _fail_statements(match) -> Any:+ """Make every SQL statement accepted by ``match`` fail in the real database."""+ engine = get_engine()++ def fail(conn, cursor, statement, parameters, context, executemany):+ if match(statement):+ raise OperationalError(statement, parameters, Exception("boom"))++ sa.event.listen(engine, "before_cursor_execute", fail)+ return lambda: sa.event.remove(engine, "before_cursor_execute", fail)+++# ===== write isolation =====++_REFUSED_CELLS = {+ "someone_elses": (404, "connector_not_found", _NOT_FOUND, None),+ "shared_with_the_team": (+ 403,+ "connector_forbidden",+ _TEAM_READ_ONLY,+ {"reason": "team_shared"},+ ),+ "missing": (404, "connector_not_found", _NOT_FOUND, None),+}++[email protected]("cell", list(_REFUSED_CELLS))[email protected]("action", _WRITE_ACTIONS)+def test_a_connector_the_holder_may_not_change_is_refused_without_a_write(+ bob, carol, monkeypatch, caplog, action, cell+):+ assert len(_REFUSED_CELLS) == 3+ status, code, message, details = _REFUSED_CELLS[cell]+ server_id = _seed("carols", owner=carol)+ if cell == "shared_with_the_team":+ _share_with_team(server_id)+ if cell == "missing":+ server_id += 1000+ before = _store()+ spy = _Calls(monkeypatch)++ with caplog.at_level(logging.INFO):+ resp = _act(action, bob, server_id)++ error = _error(resp, status, code)+ assert error["message"] == message+ assert error.get("details") == details+ assert spy.calls == []+ _assert_nothing_written(before)+ assert not [r for r in caplog.records if "mcp server write:" in r.getMessage()]++[email protected]("action", _WRITE_ACTIONS)+def test_a_failing_access_hook_is_a_503_and_writes_nothing(+ bob, carol, monkeypatch, action+):+ server_id = _seed("carols", owner=carol)+ connector_team_scope.set_connector_team_hooks(+ access=lambda _db, _uid, _refs: (_ for _ in ()).throw(RuntimeError("exploded")),+ visibility=lambda _db, _uid: {"mcp": {server_id}, "custom_api": set()},+ )+ before = _store()+ spy = _Calls(monkeypatch)++ resp = _act(action, bob, server_id)++ # The hook failure is not folded into "not found" or "forbidden".+ _error(resp, 503, "connector_runtime_unavailable")+ assert "exploded" not in resp.text+ assert spy.calls == []+ _assert_nothing_written(before)+++# ===== deleting =====++[email protected]("transport", ["streamable_http", "stdio", "websocket"])+def test_delete_removes_the_holders_connector(bob, carol, transport):+ server_id = _seed(+ "doomed",+ owner=bob,+ transport=transport,+ url=CONNECTOR_URL if transport == "streamable_http" else None,+ command="launch" if transport == "stdio" else None,+ )+ other = _seed("kept", owner=bob)+ carols = _seed("carols", owner=carol)++ resp = _delete(bob, server_id)++ assert resp.status_code == 200, resp.text+ assert resp.json() == {"id": server_id}+ assert not _definition_exists(server_id)+ assert _link_of(bob, server_id) is None+ assert [row["id"] for row in _list(bob)] == [other]+ assert _definition_exists(carols) and _link_of(carol, carols) is not None+ _error(_get_one(bob, server_id), 404, "connector_not_found")+++def test_delete_leaves_the_definition_while_another_user_still_links_it(bob, carol):+ server_id = _seed("shared-by-link", owner=bob)+ _link(carol, server_id, is_owner=False)++ resp = _delete(bob, server_id)++ assert resp.status_code == 200, resp.text+ assert _link_of(bob, server_id) is None+ assert _definition_exists(server_id)+ assert _link_of(carol, server_id) is not None+++def test_a_non_owner_with_delete_rights_deletes_only_their_own_link(bob, carol):+ server_id = _seed("owned-by-bob", owner=bob)+ _link(carol, server_id, is_owner=False, can_delete=True)++ resp = _delete(carol, server_id)++ assert resp.status_code == 200, resp.text+ assert resp.json() == {"id": server_id}+ assert _link_of(carol, server_id) is None+ assert _definition_exists(server_id)+ assert _link_of(bob, server_id) is not None+++def test_a_second_delete_is_a_404(bob):+ server_id = _seed("once", owner=bob)+ assert _delete(bob, server_id).status_code == 200++ _error(_delete(bob, server_id), 404, "connector_not_found")+++def test_deleting_a_team_owned_definition_leaves_it_to_the_team(bob):+ server_id = _seed("team-owned", owner=bob)+ connector_team_scope.set_connector_team_hooks(+ deleted=lambda _db, _uid, _type, _id: ConnectorDeleteDecision(+ team_owned=True, authorized=True, delete_definition=False+ ),+ visibility=lambda _db, _uid: {"mcp": {server_id}, "custom_api": set()},+ )++ resp = _delete(bob, server_id)++ assert resp.status_code == 200, resp.text+ assert _definition_exists(server_id)+ assert _link_of(bob, server_id) is None+ assert _get_one(bob, server_id).json()["access"] == "team"+ # The team still shares it, so a repeat is refused rather than not found.+ _error(_delete(bob, server_id), 403, "connector_forbidden")+++ "reason",+ ["blocked_by_team_agent", "not_a_team_admin"],+)+def test_a_web_refusal_to_delete_is_a_403_that_changes_nothing(bob, reason):+ server_id = _seed("held", owner=bob)+ if reason == "blocked_by_team_agent":+ connector_team_scope.set_connector_team_hooks(+ deleted=lambda *_a: ConnectorDeleteDecision(+ team_owned=True, blocked_reason="Still used by a team agent: SECRET"+ )+ )+ else:+ connector_team_scope.set_connector_team_hooks(+ deleted=lambda *_a: ConnectorDeleteDecision(+ team_owned=True, authorized=False+ )+ )+ before = _store()++ resp = _delete(bob, server_id)++ error = _error(resp, 403, "connector_forbidden")+ assert error["message"] == _FORBIDDEN+ assert error["details"] == {"reason": "not_permitted"}+ assert "SECRET" not in resp.text+ _assert_nothing_written(before)+++def test_a_link_without_delete_rights_is_a_403_from_the_web_rules(bob):+ server_id = _seed("not-mine", owner=bob, is_owner=False, can_delete=False)+ before = _store()++ error = _error(_delete(bob, server_id), 403, "connector_forbidden")++ assert error["details"] == {"reason": "not_permitted"}+ _assert_nothing_written(before)+++def test_other_accounts_oauth_state_makes_a_delete_a_409(bob):+ server_id = _seed("actor-bound", owner=bob)+ _seed_grant(bob, server_id, owner_key="xagent:actor:machine-account")+ before = _store()++ resp = _delete(bob, server_id)++ error = _error(resp, 409, "connector_not_editable")+ assert error["message"] == _MANAGED_ELSEWHERE+ assert error["details"] == {"reason": "managed_elsewhere"}+ _assert_nothing_written(before)+ assert _grant_count(server_id) == 1++[email protected]("cell", list(_CATALOG_CELLS))+def test_delete_refuses_catalog_connectors_and_deletes_custom_ones(+ bob, monkeypatch, cell+):+ name, columns, kind = _CATALOG_CELLS[cell]+ _seed_catalog_apps()+ server_id = _seed(name, owner=bob, **columns)+ before = _store()++ if kind == "catalog":+ spy = _Calls(monkeypatch)+ resp = _delete(bob, server_id)+ error = _error(resp, 409, "connector_not_editable")+ assert error["message"] == _NOT_EDITABLE_CATALOG+ assert error["details"] == {"reason": "catalog"}+ assert spy.calls == []+ _assert_nothing_written(before)+ else:+ resp = _delete(bob, server_id)+ assert resp.status_code == 200, resp.text+ assert not _definition_exists(server_id)+++def test_a_database_failure_during_delete_is_a_500_that_changes_nothing(bob, caplog):+ server_id = _seed("fragile", owner=bob)+ _seed_grant(bob, server_id)+ _seed_flow_state(bob, server_id)+ before = _store()+ # Fails after the flow states have been deleted, so this checks the rollback.+ stop = _fail_statements(lambda s: s.startswith("DELETE FROM user_mcpservers"))+ try:+ with caplog.at_level(logging.INFO):+ resp = _delete(bob, server_id)+ finally:+ stop()++ error = _error(resp, 500, "internal_error")+ assert error["message"] == _INTERNAL+ assert "boom" not in resp.text+ _assert_nothing_written(before)+ assert _grant_count(server_id) == 1+ assert _flow_state_count(server_id) == 1+ assert any("action=delete status=500" in r.getMessage() for r in caplog.records)+ assert not [r for r in caplog.records if "mcp server write:" in r.getMessage()]+++def test_a_real_delete_removes_the_holders_grants_and_flow_states_and_revokes_them(+ bob, carol, monkeypatch+):+ server_id = _seed("revoked", owner=bob)+ # Another user keeps the definition, so the foreign-key cascade cannot be+ # what removes the holder's grant and flow state below.+ _link(carol, server_id, is_owner=False)+ _seed_grant(bob, server_id)+ db = _direct_db_session()+ try:+ grant = db.query(MCPOAuthGrant).filter_by(mcp_server_id=server_id).one()+ grant.access_token = encrypt_value("AT-plain")+ grant.refresh_token = encrypt_value("RT-plain")+ client_row = db.query(MCPOAuthClient).filter_by(mcp_server_id=server_id).one()+ client_row.metadata_json = {+ "revocation_endpoint": "https://auth.example.test/revoke"+ }+ db.commit()+ finally:+ db.close()+ _seed_flow_state(bob, server_id)+ revoked: list[tuple[str, str]] = []++ def handler(request: httpx.Request) -> httpx.Response:+ revoked.append((str(request.url), request.content.decode()))+ return httpx.Response(200)++ monkeypatch.setattr(+ mcp_api,+ "create_mcp_oauth_http_client",+ lambda **_kw: httpx.AsyncClient(transport=httpx.MockTransport(handler)),+ )++ resp = _delete(bob, server_id)++ assert resp.status_code == 200, resp.text+ assert _definition_exists(server_id)+ assert _grant_count(server_id) == 0+ assert _flow_state_count(server_id) == 0+ assert [url for url, _ in revoked] == ["https://auth.example.test/revoke"] * 2+ assert [+ ("token=AT-plain" in body, "token=RT-plain" in body) for _, body in revoked+ ] == [+ (True, False),+ (False, True),+ ]+ assert "token_type_hint=access_token" in revoked[0][1]+ assert "token_type_hint=refresh_token" in revoked[1][1]+++# ===== the delete runs outside the request's event loop =====+++def test_delete_runs_on_a_different_loop_than_the_request(bob, monkeypatch):+ server_id = _seed("elsewhere", owner=bob)+ seen: dict[str, int] = {}++ async def recording_delete(*_args, **_kwargs):+ seen["delete_loop"] = id(asyncio.get_running_loop())+ seen["delete_thread"] = threading.get_ident()++ monkeypatch.setattr(mcp_server_management, "delete_mcp_server", recording_delete)++ # Same signature as the real dependency, so FastAPI reads the bearer token+ # from the request as before.+ async def recording_personal_key(+ credentials: HTTPAuthorizationCredentials | None = Depends(_bearer),+ ):+ seen["request_loop"] = id(asyncio.get_running_loop())+ seen["request_thread"] = threading.get_ident()+ return await get_user_from_personal_key(credentials)++ app_for_tests.dependency_overrides[get_user_from_personal_key] = (+ recording_personal_key+ )+ try:+ resp = _delete(bob, server_id)+ finally:+ del app_for_tests.dependency_overrides[get_user_from_personal_key]++ assert resp.status_code == 200, resp.text+ assert set(seen) == {+ "request_loop",+ "request_thread",+ "delete_loop",+ "delete_thread",+ }+ assert seen["request_loop"] != seen["delete_loop"]+ assert seen["request_thread"] != seen["delete_thread"]+++# ===== switching on and off =====++[email protected]("enabled", [True, False])+def test_enable_and_disable_switch_only_the_holders_link(bob, carol, enabled):+ server_id = _seed("switch", owner=bob, is_active=not enabled)+ _link(carol, server_id, is_owner=False, is_active=not enabled)+ definition_before = _store()[0]++ resp = _set_enabled(bob, server_id, enabled)++ assert resp.status_code == 200, resp.text+ body = resp.json()+ assert (body["id"], body["enabled"], body["access"]) == (server_id, enabled, "own")+ link, carols = _link_of(bob, server_id), _link_of(carol, server_id)+ assert link is not None and carols is not None+ assert (link.is_active, carols.is_active) == (enabled, not enabled)+ assert _store()[0] == definition_before+ assert _get_one(bob, server_id).json() == body+ assert [row["enabled"] for row in _list(bob)] == [enabled]+++def test_a_non_owner_switches_only_their_own_link(bob, carol):+ server_id = _seed("owned-by-bob", owner=bob)+ _link(carol, server_id, is_owner=False)+ definition_before = _store()[0]++ resp = _set_enabled(carol, server_id, False)++ assert resp.status_code == 200, resp.text+ assert resp.json()["enabled"] is False+ carols, bobs = _link_of(carol, server_id), _link_of(bob, server_id)+ assert carols is not None and bobs is not None+ assert (carols.is_active, bobs.is_active) == (False, True)+ assert _store()[0] == definition_before++[email protected]("enabled", [True, False])+def test_a_switch_sends_only_is_active_to_the_web_function(bob, monkeypatch, enabled):+ server_id = _seed("switch-fields", owner=bob, is_active=not enabled)+ seen: list[set[str]] = []+ real_update = mcp_server_management.update_mcp_server++ def spy(server_id_arg, server_data, **kwargs):+ seen.append(set(server_data.model_fields_set))+ return real_update(server_id_arg, server_data, **kwargs)++ monkeypatch.setattr(mcp_server_management, "update_mcp_server", spy)++ resp = _set_enabled(bob, server_id, enabled)++ assert resp.status_code == 200, resp.text+ assert seen == [{"is_active"}]+++def test_a_connector_deleted_during_a_switch_is_a_404(bob, monkeypatch, caplog):+ server_id = _seed("vanishing", owner=bob)+ monkeypatch.setattr(+ mcp_server_management, "resolve_holder_connector", _lose_the_link()+ )++ with caplog.at_level(logging.INFO):+ resp = _set_enabled(bob, server_id, False)++ error = _error(resp, 404, "connector_not_found")+ assert error["message"] == _NOT_FOUND+ assert not [+ r for r in caplog.records if r.getMessage().startswith("personal key mcp")+ ]+++def test_a_link_deleted_during_a_switch_is_a_404_even_when_the_team_shares_it(+ bob, monkeypatch, caplog+):+ server_id = _seed("vanishing-shared", owner=bob)+ _share_with_team(server_id)+ real_update = mcp_server_management.update_mcp_server++ def update_then_lose_the_link(*args, **kwargs):+ result = real_update(*args, **kwargs)+ other = _direct_db_session()+ try:+ other.query(UserMCPServer).filter_by(+ user_id=bob.user_id, mcpserver_id=server_id+ ).delete()+ other.commit()+ finally:+ other.close()+ return result++ monkeypatch.setattr(+ mcp_server_management, "update_mcp_server", update_then_lose_the_link+ )++ with caplog.at_level(logging.INFO):+ resp = _set_enabled(bob, server_id, False)++ error = _error(resp, 404, "connector_not_found")+ assert error["message"] == _NOT_FOUND+ assert not [+ r for r in caplog.records if r.getMessage().startswith("personal key mcp")+ ]+ assert _definition_exists(server_id)+++def test_setting_the_same_value_twice_gives_the_same_answer(bob):+ server_id = _seed("twice", owner=bob, is_active=False)++ first = _set_enabled(bob, server_id, True)+ second = _set_enabled(bob, server_id, True)++ assert first.status_code == second.status_code == 200+ assert first.json() == second.json()+ assert first.json()["enabled"] is True+ off = _set_enabled(bob, server_id, False)+ again = _set_enabled(bob, server_id, False)+ assert off.json() == again.json()+ assert off.json()["enabled"] is False++[email protected]("transport", ["stdio", "websocket"])+def test_launcher_connectors_can_be_switched_and_deleted(bob, transport):+ server_id = _seed(+ "launcher",+ owner=bob,+ transport=transport,+ url=None if transport == "stdio" else "wss://mcp.example.test/ws",+ command="SECRET-command",+ )++ off = _set_enabled(bob, server_id, False)+ assert off.status_code == 200, off.text+ assert off.json()["enabled"] is False+ assert "SECRET-command" not in off.text+ assert _delete(bob, server_id).status_code == 200+ assert not _definition_exists(server_id)++[email protected]("cell", list(_CATALOG_CELLS))+def test_catalog_connectors_can_be_switched(bob, cell):+ name, columns, kind = _CATALOG_CELLS[cell]+ _seed_catalog_apps()+ server_id = _seed(name, owner=bob, **columns)++ resp = _set_enabled(bob, server_id, False)++ assert resp.status_code == 200, resp.text+ assert (resp.json()["kind"], resp.json()["enabled"]) == (kind, False)+ link = _link_of(bob, server_id)+ assert link is not None and link.is_active is False+++ "body",+ [+ {},+ {"enabled": None},+ {"enabled": "yes"},+ {"enabled": 1},+ {"enabled": True, "x": 1},+ ],+ ids=["missing", "null", "string", "integer", "extra_key"],+)+def test_enabled_body_must_be_exactly_a_boolean(bob, body):+ server_id = _seed("strict", owner=bob)+ before = _store()++ resp = client.put(+ f"/v1/mcp-servers/{server_id}/enabled", headers=bob.headers, json=body+ )++ _error(resp, 422, "invalid_input")+ _assert_nothing_written(before)+++def test_a_database_failure_while_switching_is_a_500_that_changes_nothing(bob, caplog):+ server_id = _seed("fragile", owner=bob)+ before = _store()+ stop = _fail_statements(lambda s: s.startswith("UPDATE user_mcpservers"))+ try:+ with caplog.at_level(logging.INFO):+ resp = _set_enabled(bob, server_id, False)+ finally:+ stop()++ error = _error(resp, 500, "internal_error")+ assert error["message"] == _INTERNAL+ assert "boom" not in resp.text+ _assert_nothing_written(before)+ assert any("action=disable status=500" in r.getMessage() for r in caplog.records)+++# ===== secrets =====+++def test_a_switch_response_carries_no_secret(bob, secret_connector): # noqa: F811+ resp = _set_enabled(bob, secret_connector, False)++ assert resp.status_code == 200, resp.text+ for secret in _SECRETS:+ assert secret not in resp.text+ assert resp.json() == _get_one(bob, secret_connector).json()+++_SECRET_DETAIL = "SECRET-web-detail"+_REFUSAL_ROWS = ["forbidden", "not_found", "not_editable"]+_REFUSALS = {+ "forbidden": (HTTPException(403, _SECRET_DETAIL), 403, "connector_forbidden"),+ "not_found": (HTTPException(404, _SECRET_DETAIL), 404, "connector_not_found"),+ "not_editable": (+ HTTPException(409, _SECRET_DETAIL),+ 409,+ "connector_not_editable",+ ),+}+_REFUSAL_DETAILS = {+ ("forbidden", "delete"): {"reason": "not_permitted"},+ ("forbidden", "enable"): {"reason": "not_permitted"},+ ("forbidden", "disable"): {"reason": "not_permitted"},+ ("not_found", "delete"): None,+ ("not_found", "enable"): None,+ ("not_found", "disable"): None,+ ("not_editable", "delete"): {"reason": "managed_elsewhere"},+ ("not_editable", "enable"): {"reason": "unknown"},+ ("not_editable", "disable"): {"reason": "unknown"},+}+_REFUSAL_MESSAGES = {+ "forbidden": _FORBIDDEN,+ "not_found": _NOT_FOUND,+}+_NOT_EDITABLE_DEFAULT = _DEFAULT_MESSAGES[V1ErrorCode.CONNECTOR_NOT_EDITABLE]++[email protected]("row", _REFUSAL_ROWS)[email protected]("action", _WRITE_ACTIONS)+def test_web_refusals_become_sdk_errors_without_the_web_text(+ bob, monkeypatch, action, row+):+ exc, status, code = _REFUSALS[row]+ server_id = _seed("refused", owner=bob)++ async def delete(*_a, **_k):+ raise exc++ def update(*_a, **_k):+ raise exc++ monkeypatch.setattr(mcp_server_management, "delete_mcp_server", delete)+ monkeypatch.setattr(mcp_server_management, "update_mcp_server", update)+ before = _store()++ resp = _act(action, bob, server_id)++ error = _error(resp, status, code)+ assert _SECRET_DETAIL not in resp.text+ assert error.get("details") == _REFUSAL_DETAILS[(row, action)]+ if row == "not_editable":+ expected = _MANAGED_ELSEWHERE if action == "delete" else _NOT_EDITABLE_DEFAULT+ else:+ expected = _REFUSAL_MESSAGES[row]+ assert error["message"] == expected+ assert "detail" not in resp.json()+ _assert_nothing_written(before)+++# ===== the write log =====++[email protected]("action", _WRITE_ACTIONS)+def test_each_successful_write_logs_one_line(bob, caplog, action):+ assert len(_WRITE_ACTIONS) == 3+ server_id = _seed("log-subject", owner=bob, is_active=action != "enable")++ with caplog.at_level(logging.INFO):+ resp = _act(action, bob, server_id)++ assert resp.status_code == 200, resp.text+ lines = [+ r.getMessage()+ for r in caplog.records+ if r.getMessage().startswith("personal key mcp server write:")+ ]+ assert lines == [+ f"personal key mcp server write: action={action} "+ f"key_prefix={_key_prefix(bob)} user_id={bob.user_id} "+ f"server_id={server_id}"+ ]+ assert "log-subject" not in lines[0]diff --git a/tests/web/api/v1/test_mcp_servers.py b/tests/web/api/v1/test_mcp_servers.pyindex 86f965339..b7dc8cde1 100644--- a/tests/web/api/v1/test_mcp_servers.py+++ b/tests/web/api/v1/test_mcp_servers.py@@ -235,27 +235,41 @@ def _own_routes() -> list[tuple[str, str]]:("GET", "/v1/mcp-servers/{server_id}"),("POST", "/v1/mcp-servers"),("GET", "/v1/mcp-servers/{server_id}/tools"),+ ("DELETE", "/v1/mcp-servers/{server_id}"),+ ("PUT", "/v1/mcp-servers/{server_id}/enabled"),],)def test_mcp_routes_accept_only_personal_keys(method, path, kind):assert _own_routes() == [+ ("DELETE", "/v1/mcp-servers/{server_id}"),("GET", "/v1/mcp-servers"),("GET", "/v1/mcp-servers/{server_id}"),("GET", "/v1/mcp-servers/{server_id}/tools"),("POST", "/v1/mcp-servers"),+ ("PUT", "/v1/mcp-servers/{server_id}/enabled"),]+ bodies = {"POST": _create_body(), "PUT": {"enabled": True}}resp = client.request(method,path.replace("{server_id}", "1"),headers=_headers_for(kind),- json=_create_body() if method == "POST" else None,+ json=bodies.get(method),)_error(resp, 401, "invalid_api_key")@pytest.mark.parametrize("server_id", [0, 2**31])-def test_server_id_outside_the_column_range_is_rejected(bob, server_id):- _error(_get_one(bob, server_id), 422, "invalid_input")+ ("method", "suffix", "body"),+ [("GET", "", None), ("DELETE", "", None), ("PUT", "/enabled", {"enabled": True})],+)+def test_server_id_outside_the_column_range_is_rejected(+ bob, server_id, method, suffix, body+):+ resp = client.request(+ method, f"/v1/mcp-servers/{server_id}{suffix}", headers=bob.headers, json=body+ )+ _error(resp, 422, "invalid_input")# ===== visibility =====@@ -1636,6 +1650,27 @@ _ROW_CASES: list[tuple[str, HTTPException, int, str, str]] = ["invalid_input",_DEFAULT_INVALID_INPUT,),+ (+ "forbidden",+ HTTPException(403, f"Not allowed: {_REQUEST_SECRET_VALUES[0]}"),+ 403,+ "connector_forbidden",+ _DEFAULT_MESSAGES[V1ErrorCode.CONNECTOR_FORBIDDEN],+ ),+ (+ "not_found",+ HTTPException(404, f"MCP server not found {_REQUEST_SECRET_VALUES[1]}"),+ 404,+ "connector_not_found",+ _DEFAULT_MESSAGES[V1ErrorCode.CONNECTOR_NOT_FOUND],+ ),+ (+ "managed_elsewhere",+ HTTPException(409, f"Has connections: {_REQUEST_SECRET_VALUES[0]}"),+ 409,+ "connector_not_editable",+ _DEFAULT_MESSAGES[V1ErrorCode.CONNECTOR_NOT_EDITABLE],+ ),("internal_error",HTTPException(500, f"Failed to create MCP server: {_REQUEST_SECRET_VALUES[0]}"),@@ -1653,9 +1688,17 @@ _ROW_CASES: list[tuple[str, HTTPException, int, str, str]] = []+# The rows whose answer carries ``details.reason``; the other rows here carry+# no details.+_ROW_DETAILS = {+ "forbidden": {"reason": "not_permitted"},+ "managed_elsewhere": {"reason": "unknown"},+}++def test_create_success_carries_no_secret(bob):rows = mcp_servers_routes._MCP_WRITE_ERROR_ROWS- assert len(rows) == 6+ assert len(rows) == 9assert {row.id for row in rows} == {case[0] for case in _ROW_CASES}ok = _create(bob, name="made-connector", **_REQUEST_SECRETS)@@ -1676,7 +1719,7 @@ def test_create_success_carries_no_secret(bob):ids=[f"{case[0]}-{i}" for i, case in enumerate(_ROW_CASES)],)def test_write_error_translation(bob, monkeypatch, row_id, exc, status, code, message):- assert len(_ROW_CASES) == 10+ assert len(_ROW_CASES) == 13before = _store()_fail_web_create(monkeypatch, exc)@@ -1684,7 +1727,7 @@ def test_write_error_translation(bob, monkeypatch, row_id, exc, status, code, meerror = _error(resp, status, code)assert error["message"] == message- assert "details" not in error+ assert error.get("details") == _ROW_DETAILS.get(row_id)assert "detail" not in resp.json()for secret in _REQUEST_SECRET_VALUES:assert secret not in resp.textdiff --git a/tests/web/api/v1/test_personal_key_principal_policy.py b/tests/web/api/v1/test_personal_key_principal_policy.pyindex 7230abef0..114b9c6ba 100644--- a/tests/web/api/v1/test_personal_key_principal_policy.py+++ b/tests/web/api/v1/test_personal_key_principal_policy.py@@ -129,9 +129,9 @@ def test_personal_key_policy_runs_only_after_the_key_verifies() -> None:@pytest.mark.usefixtures("_template_manager")def test_personal_key_policy_applies_to_every_personal_key_route() -> None:routes = _personal_key_routes()- # The 19 management routes (me, agents, templates, skills, MCP connectors), the 11+ # The 21 management routes (me, agents, templates, skills, MCP connectors), the 11# /v1/chat task routes and the features route.- assert len(routes) == 31, routes+ assert len(routes) == 33, routesheaders = _bearer(_create_personal_key()[0])for method, template in routes:diff --git a/tests/web/api/v1/test_status_only_projection.py b/tests/web/api/v1/test_status_only_projection.pyindex 69159ef43..578846b45 100644--- a/tests/web/api/v1/test_status_only_projection.py+++ b/tests/web/api/v1/test_status_only_projection.py@@ -338,6 +338,8 @@ EXCLUDE = {("GET", "/v1/mcp-servers/{server_id}"),("POST", "/v1/mcp-servers"),("GET", "/v1/mcp-servers/{server_id}/tools"),+ ("DELETE", "/v1/mcp-servers/{server_id}"),+ ("PUT", "/v1/mcp-servers/{server_id}/enabled"),}