Skip to content

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.py
index 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.py
index 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 User
from ...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 exc
raise 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 = 4
diff --git a/src/xagent/web/schemas/v1.py b/src/xagent/web/schemas/v1.py
index 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 datetime
from 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_RE
from .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.py
index 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 from
the SDK body, so the web code decides every stored value, name rule and
encryption. 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 asyncio
import logging
from typing import Any, Iterable, Optional, cast
@@ -25,6 +29,7 @@ from ...core.tools.adapters.vibe.signed_upload import signed_upload_settings_err
from ...core.tools.core.mcp.model import MASKED_SECRET_VALUE, SENSITIVE_AUTH_FIELDS
from ..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_local
from ..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.py
new file mode 100644
index 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.py
index 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) == 9
assert {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) == 13
before = _store()
_fail_web_create(monkeypatch, exc)
@@ -1684,7 +1727,7 @@ def test_write_error_translation(bob, monkeypatch, row_id, exc, status, code, me
error = _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.text
diff --git a/tests/web/api/v1/test_personal_key_principal_policy.py b/tests/web/api/v1/test_personal_key_principal_policy.py
index 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, routes
headers = _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.py
index 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"),
}