Enterprise agent platform for building, deploying, and operating AI teammates.
from __future__ import annotations
import asyncio
from dataclasses import FrozenInstanceError, fields
from datetime import datetime, timedelta, timezone
from types import SimpleNamespace
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import Session, sessionmaker
from tests.shared.async_waits import DB_PROGRESS_TIMEOUT
from xagent.core.execution_scope import ExecutionScope
from xagent.core.utils.encryption import encrypt_value
from xagent.web import mcp_apps
from xagent.web.api import mcp as mcp_api
from xagent.web.builtin_mcp_registry import get_builtin_public_mcp_app
from xagent.web.models.database import Base
from xagent.web.models.mcp import MCPServer, UserMCPServer
from xagent.web.models.mcp_oauth import MCPOAuthClient, MCPOAuthGrant
from xagent.web.models.oauth_provider import OAuthProvider
from xagent.web.models.public_mcp import PublicMCPApp
from xagent.web.models.user import User
from xagent.web.models.user_oauth import UserOAuth
from xagent.web.services import connector_team_scope
from xagent.web.services.mcp_runtime import (
MCPActorAuthorizationPolicy,
MCPActorExecutionIdentity,
MCPBuiltinOAuthActorPolicy,
)
from xagent.web.services.slack_actor_runtime import (
SLACK_ACTOR_RUNTIME_REFRESH_KEY,
SLACK_CHANNEL_ACCESS_POLICY_ENV,
SlackActorRuntimeGrant,
SlackChannelAccessPolicy,
set_slack_actor_runtime_grant_resolver,
)
from xagent.web.tools import config as web_tools_config
from xagent.web.tools.config import (
ResolvedToken,
WebToolConfig,
set_oauth_token_resolver_hook,
)
OWNER_A = "toby:slack:team:actor-a"
OWNER_B = "toby:slack:team:actor-b"
APP_ID = "actor-drive"
REMOTE_APP_ID = "actor-remote"
APP_EXECUTION = {
"name": "Actor Drive",
"transport": "oauth",
"provider_name": "google",
"oauth_scopes": [],
"launch_config": {
"command": "python",
"args": ["-m", "actor_drive"],
"env_mapping": {"ACTOR_ACCESS_TOKEN": "access_token"},
},
}
@pytest.fixture()
def db_session(tmp_path, monkeypatch):
registry_lookup = mcp_apps.get_builtin_execution_fields_and_optional_scopes
def test_registry(app_id: str):
if app_id == APP_ID:
return APP_EXECUTION, []
return registry_lookup(app_id)
monkeypatch.setattr(
mcp_apps, "get_builtin_execution_fields_and_optional_scopes", test_registry
)
engine = create_engine(
f"sqlite:///{tmp_path / 'actor-mcp.db'}",
connect_args={"check_same_thread": False},
)
Base.metadata.create_all(engine)
session_factory = sessionmaker(bind=engine, autoflush=False, autocommit=False)
db = session_factory()
user = User(username="actor-runtime-user", password_hash="x", is_admin=False)
db.add(user)
db.commit()
db.refresh(user)
try:
yield SimpleNamespace(db=db, user=user, session_factory=session_factory)
finally:
connector_team_scope.set_connector_team_hooks()
set_slack_actor_runtime_grant_resolver(None)
db.close()
engine.dispose()
def _policy(owner: str = OWNER_A) -> MCPBuiltinOAuthActorPolicy:
return MCPBuiltinOAuthActorPolicy(resource_owner_key=owner)
def _add_builtin_server(
db: Session,
user: User,
*,
personal: bool = True,
) -> MCPServer:
app = PublicMCPApp(
app_id=APP_ID,
name="Actor Drive",
description="Canonical actor drive app",
transport="oauth",
provider_name="google",
launch_config={
"command": "python",
"args": ["-m", "actor_drive"],
"env_mapping": {"ACTOR_ACCESS_TOKEN": "access_token"},
},
is_visible_in_connector=True,
)
server = MCPServer(
name="Actor Drive",
description="Canonical actor drive server",
managed="external",
transport="oauth",
auth={"app_id": APP_ID, "provider": "google"},
)
db.add_all([app, server])
db.flush()
if personal:
db.add(
UserMCPServer(
user_id=int(user.id),
mcpserver_id=int(server.id),
is_owner=False,
is_active=True,
)
)
db.commit()
return server
def _add_remote_server(db: Session, user: User) -> MCPServer:
app = PublicMCPApp(
app_id=REMOTE_APP_ID,
name="Actor Remote",
transport="streamable_http",
launch_config={
"url": "https://mcp.example.com/mcp",
"auth": {
"type": "mcp_oauth",
"resource": "https://mcp.example.com/mcp",
"issuer": "https://auth.example.com",
"scope": "records.read",
"client_id": "actor-client",
},
},
is_visible_in_connector=True,
)
server = MCPServer.from_config(
{
"name": REMOTE_APP_ID,
"managed": "external",
"transport": "streamable_http",
"url": "https://mcp.example.com/mcp",
"auth": dict(app.launch_config["auth"]),
}
)
db.add_all([app, server])
db.flush()
db.add(
UserMCPServer(
user_id=int(user.id),
mcpserver_id=int(server.id),
is_owner=False,
is_active=True,
)
)
db.commit()
return server
def _add_remote_grant(
db: Session,
user: User,
server: MCPServer,
*,
owner: str,
token: str,
) -> MCPOAuthGrant:
client = (
db.query(MCPOAuthClient)
.filter(MCPOAuthClient.mcp_server_id == int(server.id))
.one_or_none()
)
if client is None:
client = MCPOAuthClient(
mcp_server_id=int(server.id),
issuer="https://auth.example.com",
authorization_endpoint="https://auth.example.com/authorize",
token_endpoint="https://auth.example.com/token",
client_id="actor-client",
token_endpoint_auth_method="none",
redirect_uri="https://xagent.example.com/api/mcp/oauth/callback",
)
db.add(client)
db.flush()
grant = MCPOAuthGrant(
mcp_server_id=int(server.id),
user_id=int(user.id),
mcp_oauth_client_id=int(client.id),
resource_owner_key=owner,
issuer="https://auth.example.com",
resource="https://mcp.example.com/mcp",
scope="records.read",
access_token=encrypt_value(token),
status="active",
)
db.add(grant)
db.commit()
return grant
def _add_actor_credential(
db: Session,
user: User,
*,
owner: str | None,
token: str,
) -> UserOAuth:
account = UserOAuth(
user_id=int(user.id),
provider=APP_ID,
resource_owner_key=owner,
access_token=token,
provider_user_id="provider-user",
)
db.add(account)
db.commit()
return account
def _config(
seeded,
*,
policy: MCPBuiltinOAuthActorPolicy | None,
connector_team_id: int | None = None,
mcp_auth_context: dict | None = None,
execution_identity: MCPActorExecutionIdentity | None = None,
execution_scope: ExecutionScope | None = None,
) -> WebToolConfig:
return WebToolConfig(
db=seeded.db,
db_factory=seeded.session_factory,
request=None,
user=seeded.user,
user_id=int(seeded.user.id),
workspace_config={"base_dir": "/tmp", "task_id": "1"},
connector_team_id=connector_team_id,
mcp_auth_context=mcp_auth_context,
mcp_runtime_authorization_policy=policy,
mcp_actor_execution_identity=execution_identity,
execution_scope=execution_scope,
)
def _execution_identity() -> MCPActorExecutionIdentity:
return MCPActorExecutionIdentity(
task_id=1,
run_id="run-1",
turn_id="turn-1",
lease_attempt_id="attempt-1",
)
def _add_slack_builtin_server(db: Session, user: User) -> MCPServer:
app = get_builtin_public_mcp_app("slack")
assert app is not None
db.add(PublicMCPApp(**app))
server = MCPServer(
name="Slack",
description="Canonical Slack server",
managed="external",
transport="oauth",
auth={"app_id": "slack", "provider": "slack"},
)
db.add(server)
db.flush()
db.add(
UserMCPServer(
user_id=int(user.id),
mcpserver_id=int(server.id),
is_owner=False,
is_active=True,
)
)
db.commit()
return server
def _token(config: dict) -> str:
return config["config"]["env"]["ACTOR_ACCESS_TOKEN"]
def test_actor_policy_is_frozen_normalized_and_stdio_disabled_by_default() -> None:
policy = MCPBuiltinOAuthActorPolicy(resource_owner_key=f" {OWNER_A} ")
assert policy.resource_owner_key == OWNER_A
assert policy.allow_builtin_stdio is False
assert [field.name for field in fields(policy)] == [
"resource_owner_key",
"allow_builtin_stdio",
]
assert OWNER_A not in repr(policy)
with pytest.raises(FrozenInstanceError):
policy.resource_owner_key = OWNER_B # type: ignore[misc]
def test_general_actor_policy_keeps_legacy_type_identity() -> None:
policy = MCPActorAuthorizationPolicy(
resource_owner_key=OWNER_A,
allow_builtin_stdio=True,
)
assert MCPBuiltinOAuthActorPolicy is MCPActorAuthorizationPolicy
assert isinstance(policy, MCPBuiltinOAuthActorPolicy)
assert policy.allow_builtin_stdio is True
@pytest.mark.parametrize("value", [None, 0, 1, "true"])
def test_actor_policy_rejects_non_boolean_stdio_capability(value: object) -> None:
with pytest.raises(ValueError, match="allow_builtin_stdio must be a boolean"):
MCPActorAuthorizationPolicy(
resource_owner_key=OWNER_A,
allow_builtin_stdio=value, # type: ignore[arg-type]
)
@pytest.mark.parametrize("value", [None, 7, True, "", " "])
def test_actor_policy_rejects_invalid_owner(value: object) -> None:
with pytest.raises((TypeError, ValueError)):
MCPBuiltinOAuthActorPolicy(resource_owner_key=value) # type: ignore[arg-type]
@pytest.mark.parametrize(
"capabilities",
[frozenset(), frozenset({"write"}), frozenset({"read", "write"}), {"read"}],
)
def test_slack_runtime_policy_rejects_non_read_capabilities(capabilities) -> None:
with pytest.raises(ValueError, match="only the read capability"):
SlackChannelAccessPolicy(
channel_ids=frozenset({"C0123456789"}),
expires_at=datetime.now(timezone.utc) + timedelta(minutes=5),
capabilities=capabilities,
)
def test_actor_remote_legacy_classification_queries_each_live_view(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
query = db_session.db.query
queried: list[object] = []
def recording_query(*entities):
queried.extend(entities)
return query(*entities)
db_session.db.query = recording_query # type: ignore[method-assign]
resolved = mcp_apps.classify_actor_remote_oauth_server(db_session.db, server)
assert resolved is not None and resolved["id"] == REMOTE_APP_ID
assert PublicMCPApp in queried
assert MCPServer in queried
assert any(entity is UserMCPServer.id for entity in queried)
def test_actor_remote_hubspot_row_created_by_catalog_connect_is_canonical(
db_session, monkeypatch
) -> None:
monkeypatch.setenv("XAGENT_HUBSPOT_MCP_CLIENT_ID", "hubspot-client")
monkeypatch.setenv("XAGENT_HUBSPOT_MCP_CLIENT_SECRET", "hubspot-secret")
app = get_builtin_public_mcp_app("hubspot")
assert app is not None
db_session.db.add(
PublicMCPApp(
app_id="hubspot",
name=app["name"],
description=app["description"],
transport=app["transport"],
provider_name=app["provider_name"],
category=app["category"],
oauth_scopes=app["oauth_scopes"],
launch_config=app["launch_config"],
is_visible_in_connector=True,
)
)
db_session.db.commit()
server, _ = mcp_api._ensure_catalog_mcp_oauth_server(db_session.db, "hubspot")
monkeypatch.setenv("XAGENT_HUBSPOT_MCP_CLIENT_ID", "rotated-client")
monkeypatch.setenv("XAGENT_HUBSPOT_MCP_CLIENT_SECRET", "rotated-secret")
resolved = mcp_apps.classify_actor_remote_oauth_server(db_session.db, server)
assert resolved is not None and resolved["id"] == "hubspot"
def test_actor_remote_legacy_non_remote_unpersisted_row_remains_native(
db_session,
) -> None:
server = SimpleNamespace(name="uncataloged", transport="stdio", auth=None, id=None)
assert mcp_apps.classify_actor_remote_oauth_server(db_session.db, server) is None
def test_actor_remote_snapshot_freezes_catalog_server_and_owner_view(
db_session, monkeypatch
) -> None:
server = _add_remote_server(db_session.db, db_session.user)
snapshot = mcp_apps.load_mcp_app_snapshot(db_session.db)
with db_session.session_factory() as live_db:
live_db.query(PublicMCPApp).filter(PublicMCPApp.app_id == REMOTE_APP_ID).update(
{"is_visible_in_connector": False}
)
live_db.query(MCPServer).filter(MCPServer.id == int(server.id)).update(
{"name": "changed-live-server"}
)
live_db.query(UserMCPServer).filter(
UserMCPServer.mcpserver_id == int(server.id)
).update({"is_owner": True})
live_db.commit()
monkeypatch.setattr(
db_session.db,
"query",
lambda *_args, **_kwargs: pytest.fail(
"snapshot classification queried the database"
),
)
resolved = mcp_apps.classify_actor_remote_oauth_server(
db_session.db,
server,
snapshot=snapshot,
)
assert resolved is not None and resolved["id"] == REMOTE_APP_ID
def test_actor_remote_snapshot_rejects_ambiguous_server_identity(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
duplicate = MCPServer.from_config(
{
"name": "Actor Remote",
"managed": "external",
"transport": "streamable_http",
"url": "https://mcp.example.com/mcp",
"auth": dict(server.auth),
}
)
db_session.db.add(duplicate)
db_session.db.commit()
snapshot = mcp_apps.load_mcp_app_snapshot(db_session.db)
with pytest.raises(
mcp_apps.RemoteOAuthServerDefinitionError,
match="exactly one server definition",
):
mcp_apps.classify_actor_remote_oauth_server(
db_session.db, server, snapshot=snapshot
)
@pytest.mark.parametrize("drift", ["owner", "invalid_auth"])
def test_actor_remote_snapshot_rejects_noncanonical_definition(
db_session, drift
) -> None:
server = _add_remote_server(db_session.db, db_session.user)
if drift == "owner":
db_session.db.query(UserMCPServer).one().is_owner = True
else:
server.auth = {**server.auth, "scope": "records.write"}
db_session.db.commit()
snapshot = mcp_apps.load_mcp_app_snapshot(db_session.db)
with pytest.raises(mcp_apps.RemoteOAuthServerDefinitionError):
mcp_apps.classify_actor_remote_oauth_server(
db_session.db, server, snapshot=snapshot
)
def test_actor_remote_snapshot_preserves_only_proven_custom_definition(
db_session,
) -> None:
server = MCPServer.from_config(
{
"name": "custom-remote",
"managed": "external",
"transport": "streamable_http",
"url": "https://custom.example.com/mcp",
"auth": {"type": "mcp_oauth"},
}
)
db_session.db.add(server)
db_session.db.flush()
association = UserMCPServer(
user_id=int(db_session.user.id),
mcpserver_id=int(server.id),
is_owner=True,
is_active=True,
)
db_session.db.add(association)
db_session.db.commit()
snapshot = mcp_apps.load_mcp_app_snapshot(db_session.db)
assert (
mcp_apps.classify_actor_remote_oauth_server(
db_session.db, server, snapshot=snapshot
)
is None
)
association.is_owner = False
db_session.db.commit()
unowned_snapshot = mcp_apps.load_mcp_app_snapshot(db_session.db)
with pytest.raises(
mcp_apps.RemoteOAuthServerDefinitionError,
match="catalog identity is unavailable",
):
mcp_apps.classify_actor_remote_oauth_server(
db_session.db, server, snapshot=unowned_snapshot
)
@pytest.mark.asyncio
async def test_actor_remote_prefers_exact_owner_over_workspace_grant(
db_session,
) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=f"xagent:user:{db_session.user.id}",
token="workspace-token",
)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_A,
token="actor-token",
)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["config"]["headers"]["Authorization"] == "Bearer actor-token"
@pytest.mark.asyncio
async def test_actor_remote_falls_back_to_workspace_grant(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=f"xagent:user:{db_session.user.id}",
token="workspace-token",
)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["config"]["headers"]["Authorization"] == "Bearer workspace-token"
@pytest.mark.parametrize("stale_kind", ["expired", "scope"])
@pytest.mark.asyncio
async def test_actor_remote_falls_back_from_unusable_actor_grant(
db_session, stale_kind
) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=f"xagent:user:{db_session.user.id}",
token="workspace-token",
)
actor_grant = _add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_A,
token="stale-actor-token",
)
if stale_kind == "expired":
actor_grant.expires_at = datetime.now(timezone.utc) - timedelta(minutes=1)
else:
actor_grant.scope = "old.read"
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["config"]["headers"]["Authorization"] == "Bearer workspace-token"
assert "stale-actor-token" not in str(configs)
@pytest.mark.parametrize("drift", ["url", "transport", "auth", "managed", "ownership"])
@pytest.mark.asyncio
async def test_actor_remote_rejects_drifted_catalog_server(db_session, drift) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_A,
token="actor-token",
)
if drift == "url":
server.url = "https://attacker.example/mcp"
elif drift == "transport":
server.transport = "sse"
elif drift == "auth":
server.auth = {**server.auth, "scope": "records.write"}
elif drift == "managed":
server.managed = "internal"
elif drift == "ownership":
association = db_session.db.query(UserMCPServer).one()
association.is_owner = True
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert "actor-token" not in str(configs)
@pytest.mark.asyncio
async def test_actor_remote_strips_non_catalog_headers(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_A,
token="actor-token",
)
server.headers = {"Host": "attacker.example", "Cookie": "session=secret"}
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["config"]["headers"] == {"Authorization": "Bearer actor-token"}
@pytest.mark.asyncio
async def test_actor_remote_marks_missing_auth_unavailable(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
server.auth = None
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
@pytest.mark.asyncio
async def test_actor_remote_ignores_foreign_auth_app_id(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_A,
token="actor-token",
)
attacker = User(username="foreign-user", password_hash="x", is_admin=False)
foreign_server = MCPServer.from_config(
{
"name": "foreign-server",
"managed": "external",
"transport": "streamable_http",
"url": "https://attacker.example/mcp",
"auth": {"app_id": REMOTE_APP_ID},
}
)
db_session.db.add_all([attacker, foreign_server])
db_session.db.flush()
db_session.db.add(
UserMCPServer(
user_id=int(attacker.id),
mcpserver_id=int(foreign_server.id),
is_active=True,
is_owner=True,
)
)
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert len(configs) == 1
assert configs[0]["config"]["headers"]["Authorization"] == "Bearer actor-token"
@pytest.mark.asyncio
async def test_actor_policy_preserves_owned_custom_app_id_collision(db_session) -> None:
_add_remote_server(db_session.db, db_session.user)
custom_server = MCPServer.from_config(
{
"name": "custom-remote",
"managed": "external",
"transport": "streamable_http",
"url": "https://custom.example.com/mcp",
"auth": {
"type": "mcp_oauth",
"app_id": REMOTE_APP_ID,
"resource": "https://mcp.example.com/mcp",
"issuer": "https://auth.example.com",
"scope": "records.read",
"client_id": "actor-client",
},
}
)
db_session.db.add(custom_server)
db_session.db.flush()
db_session.db.add(
UserMCPServer(
user_id=int(db_session.user.id),
mcpserver_id=int(custom_server.id),
is_active=True,
is_owner=True,
)
)
db_session.db.commit()
_add_remote_grant(
db_session.db,
db_session.user,
custom_server,
owner=f"xagent:user:{db_session.user.id}",
token="custom-token",
)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
custom_config = next(
config for config in configs if config["name"] == custom_server.name
)
assert custom_config["config"]["headers"]["Authorization"] == (
"Bearer custom-token"
)
@pytest.mark.asyncio
async def test_actor_policy_preserves_custom_resolver_candidates(db_session) -> None:
_add_remote_server(db_session.db, db_session.user)
app = (
db_session.db.query(PublicMCPApp)
.filter(PublicMCPApp.app_id == REMOTE_APP_ID)
.one()
)
app.provider_name = "records-provider"
custom_server = MCPServer.from_config(
{
"name": "custom-resolver-remote",
"managed": "external",
"transport": "streamable_http",
"url": "https://custom.example.com/mcp",
"auth": {"type": "mcp_oauth", "app_id": REMOTE_APP_ID},
}
)
db_session.db.add(custom_server)
db_session.db.flush()
db_session.db.add(
UserMCPServer(
user_id=int(db_session.user.id),
mcpserver_id=int(custom_server.id),
is_active=True,
is_owner=True,
)
)
db_session.db.commit()
providers = []
async def resolver(request) -> ResolvedToken | None:
providers.append(request.provider)
if request.provider == "records-provider":
return ResolvedToken(access_token="resolver-token")
return None
set_oauth_token_resolver_hook(resolver)
try:
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
finally:
set_oauth_token_resolver_hook(None)
custom_config = next(
config for config in configs if config["name"] == custom_server.name
)
assert providers == ["records-provider"]
assert custom_config["config"]["headers"]["Authorization"] == (
"Bearer resolver-token"
)
@pytest.mark.asyncio
async def test_actor_policy_preserves_team_owned_custom_oauth(db_session) -> None:
custom_server = MCPServer.from_config(
{
"name": "retained-team-custom",
"managed": "external",
"transport": "streamable_http",
"url": "https://team.example.com/mcp",
"auth": {"type": "mcp_oauth"},
}
)
db_session.db.add(custom_server)
db_session.db.commit()
connector_team_scope.set_connector_team_hooks(
team_visibility=lambda _db, *, team_id: {
"mcp": {int(custom_server.id)} if team_id == 41 else set(),
"custom_api": set(),
"owned_mcp_definitions": {int(custom_server.id)},
}
)
async def resolver(request) -> ResolvedToken | None:
if request.provider == custom_server.name:
return ResolvedToken(access_token="team-custom-token")
return None
set_oauth_token_resolver_hook(resolver)
try:
configs = await _config(
db_session,
policy=_policy(),
connector_team_id=41,
).get_mcp_server_configs()
finally:
set_oauth_token_resolver_hook(None)
assert configs[0]["name"] == custom_server.name
assert configs[0]["config"]["headers"]["Authorization"] == (
"Bearer team-custom-token"
)
@pytest.mark.asyncio
async def test_actor_policy_rejects_unowned_team_catalog_drift(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
db_session.db.query(UserMCPServer).delete()
server.name = "renamed-team-catalog"
db_session.db.commit()
connector_team_scope.set_connector_team_hooks(
team_visibility=lambda _db, *, team_id: {
"mcp": {int(server.id)} if team_id == 41 else set(),
"custom_api": set(),
"owned_mcp_definitions": set(),
}
)
configs = await _config(
db_session,
policy=_policy(),
connector_team_id=41,
).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
@pytest.mark.asyncio
async def test_actor_remote_rejects_unverifiable_catalog_identity(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
server.name = "renamed-remote"
db_session.db.commit()
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=f"xagent:user:{db_session.user.id}",
token="workspace-token",
)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
assert "workspace-token" not in str(configs)
@pytest.mark.asyncio
async def test_actor_remote_rejects_catalog_auth_reclassification(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
app = (
db_session.db.query(PublicMCPApp)
.filter(PublicMCPApp.app_id == REMOTE_APP_ID)
.one()
)
app.launch_config = {
**app.launch_config,
"auth": {"type": "api_key"},
}
db_session.db.commit()
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=f"xagent:user:{db_session.user.id}",
token="workspace-token",
)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
assert "workspace-token" not in str(configs)
@pytest.mark.asyncio
async def test_actor_remote_never_uses_another_actor_grant(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_B,
token="other-actor-token",
)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert "other-actor-token" not in str(configs)
@pytest.mark.asyncio
async def test_actor_remote_rejects_task_supplied_owner(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_A,
token="actor-token",
)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_B,
token="other-actor-token",
)
configs = await _config(
db_session,
policy=_policy(),
mcp_auth_context={str(server.id): {"resource_owner_key": OWNER_B}},
).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
assert "other-actor-token" not in str(configs)
@pytest.mark.asyncio
async def test_actor_remote_ignores_delegated_authorization(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_A,
token="actor-token",
)
server.runtime_bindings = [
{
"source": {"input_type": "secrets", "key": "authorization"},
"target": {
"target_type": "transport_headers",
"key": "Authorization",
},
}
]
server.allow_delegated_authorization = True
db_session.db.commit()
tool_config = _config(db_session, policy=_policy())
tool_config._connector_runtime_view = {
f"mcp:{server.id}": {
"context": {"account": "task-context"},
"secrets": {"authorization": "Bearer task-token"},
"auth_selector": {},
}
}
configs = await tool_config.get_mcp_server_configs()
assert configs[0]["config"]["headers"]["Authorization"] == "Bearer actor-token"
assert "task-token" not in str(configs)
assert "connector_runtime" not in configs[0]
assert "runtime_bindings" not in configs[0]
@pytest.mark.asyncio
async def test_actor_remote_ignores_resolver_hook(db_session) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_A,
token="actor-token",
)
calls = 0
async def resolver(_request) -> ResolvedToken:
nonlocal calls
calls += 1
return ResolvedToken(access_token="resolver-token")
set_oauth_token_resolver_hook(resolver)
try:
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
finally:
set_oauth_token_resolver_hook(None)
assert calls == 0
assert configs[0]["config"]["headers"]["Authorization"] == "Bearer actor-token"
assert "resolver-token" not in str(configs)
@pytest.mark.asyncio
async def test_actor_builtin_uses_only_exact_owner_namespace(db_session) -> None:
server = _add_builtin_server(db_session.db, db_session.user)
_add_actor_credential(
db_session.db, db_session.user, owner=None, token="ordinary-token"
)
_add_actor_credential(
db_session.db, db_session.user, owner=OWNER_A, token="actor-a-token"
)
_add_actor_credential(
db_session.db, db_session.user, owner=OWNER_B, token="actor-b-token"
)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert [config["id"] for config in configs] == [int(server.id)]
assert _token(configs[0]) == "actor-a-token"
assert "ordinary-token" not in str(configs)
assert "actor-b-token" not in str(configs)
@pytest.mark.asyncio
@pytest.mark.parametrize("owner", [OWNER_A, OWNER_B])
async def test_xero_uses_exact_actor_token(db_session, owner) -> None:
db, user = db_session.db, db_session.user
app = get_builtin_public_mcp_app("xero")
assert app is not None
db.add(PublicMCPApp(**app))
server = MCPServer(
name="Xero",
managed="external",
transport="oauth",
auth={"app_id": "xero", "provider": "xero"},
)
db.add(server)
db.flush()
db.add(
UserMCPServer(
user_id=user.id,
mcpserver_id=server.id,
is_owner=False,
is_active=True,
)
)
for credential_owner, token in (
(None, "workspace-token"),
(OWNER_A, "alice-token"),
(OWNER_B, "bob-token"),
):
db.add(
UserOAuth(
user_id=user.id,
provider="xero",
resource_owner_key=credential_owner,
provider_user_id="xero-user",
access_token=token,
)
)
db.commit()
configs = await _config(db_session, policy=_policy(owner)).get_mcp_server_configs()
expected_token = "alice-token" if owner == OWNER_A else "bob-token"
other_token = "bob-token" if owner == OWNER_A else "alice-token"
assert len(configs) == 1
assert configs[0]["config"]["command"] == "python"
assert configs[0]["config"]["args"] == ["-m", "xagent.web.tools.mcp.xero"]
assert configs[0]["config"]["env"]["XERO_CLIENT_BEARER_TOKEN"] == expected_token
assert "workspace-token" not in str(configs)
assert other_token not in str(configs)
@pytest.mark.asyncio
async def test_actor_composio_facebook_grant_launches_with_composio_env(
db_session, monkeypatch
) -> None:
"""#3531: Toby's per-actor Facebook grant created through Composio carries
token_type="composio"; the actor path must hand the subprocess the
Composio values, never the connected-account id as a Meta token."""
monkeypatch.setenv("COMPOSIO_API_KEY", "composio-key")
db, user = db_session.db, db_session.user
app = get_builtin_public_mcp_app("facebook")
assert app is not None
db.add(PublicMCPApp(**app))
server = MCPServer(
name="Facebook Pages",
managed="external",
transport="oauth",
auth={"app_id": "facebook", "provider": "meta"},
)
db.add(server)
db.flush()
db.add(
UserMCPServer(
user_id=user.id,
mcpserver_id=server.id,
is_owner=False,
is_active=True,
)
)
db.add(
UserOAuth(
user_id=user.id,
provider="facebook",
resource_owner_key=OWNER_A,
provider_user_id="fb-user-1",
access_token="ca_123",
instance_url="actor-hmac",
token_type="composio",
)
)
db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert len(configs) == 1
env = configs[0]["config"]["env"]
assert "META_ACCESS_TOKEN" not in env
assert env["COMPOSIO_API_KEY"] == "composio-key"
assert env["COMPOSIO_CONNECTED_ACCOUNT_ID"] == "ca_123"
assert env["COMPOSIO_USER_ID"] == "actor-hmac"
@pytest.mark.asyncio
async def test_actor_composio_grant_with_a_gone_account_is_unavailable(
db_session, monkeypatch
) -> None:
"""A grant the reconcile pass tombstoned is no longer a credential: the
connector is reported unavailable instead of launching."""
from xagent.web import composio_auth
monkeypatch.setenv("COMPOSIO_API_KEY", "composio-key")
monkeypatch.setenv("COMPOSIO_FACEBOOK_AUTH_CONFIG_ID", "ac_facebook")
monkeypatch.setenv("COMPOSIO_USER_ID_SECRET", "composio-secret")
monkeypatch.setattr(composio_auth, "_missing_account_cursor", 0)
monkeypatch.setattr(
composio_auth,
"_call",
lambda *args, **kwargs: (
404,
{"error": {"slug": "ConnectedAccount_ResourceNotFound"}},
),
)
db, user = db_session.db, db_session.user
app = get_builtin_public_mcp_app("facebook")
assert app is not None
db.add(PublicMCPApp(**app))
server = MCPServer(
name="Facebook Pages",
managed="external",
transport="oauth",
auth={"app_id": "facebook", "provider": "meta"},
)
db.add(server)
db.flush()
db.add(
UserMCPServer(
user_id=user.id,
mcpserver_id=server.id,
is_owner=False,
is_active=True,
)
)
db.add(
UserOAuth(
user_id=user.id,
provider="facebook",
resource_owner_key=OWNER_A,
provider_user_id="fb-user-1",
access_token="ca_123",
instance_url="actor-hmac",
token_type="composio",
)
)
db.commit()
assert composio_auth.tombstone_missing_composio_accounts(db) == 1
assert db.query(UserOAuth).one().access_token == ""
assert mcp_api._oauth_account_can_connect(db.query(UserOAuth).one()) is False
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "oauth_token_required"
assert "ca_123" not in str(configs)
@pytest.mark.asyncio
async def test_actor_composio_instagram_grant_is_not_shadowed_by_a_bare_meta_grant(
db_session, monkeypatch
) -> None:
"""#3533: Instagram accepts a bare ``meta`` grant, but the actor path
looks grants up by exact app id, so a Composio ``instagram`` grant in the
same namespace is the one that launches, with the Composio values."""
monkeypatch.setenv("COMPOSIO_API_KEY", "composio-key")
db = db_session.db
_add_instagram_server(db, db_session.user)
for provider, token, token_type, instance_url in (
("instagram", "ca_ig", "composio", "actor-hmac"),
("meta", "bare-meta-token", "bearer", None),
):
_add_instagram_grant(
db,
db_session.user,
owner=OWNER_A,
provider=provider,
token=token,
token_type=token_type,
instance_url=instance_url,
)
db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert len(configs) == 1
env = configs[0]["config"]["env"]
assert "META_ACCESS_TOKEN" not in env
assert env["COMPOSIO_CONNECTED_ACCOUNT_ID"] == "ca_ig"
assert "bare-meta-token" not in str(configs)
@pytest.mark.asyncio
@pytest.mark.parametrize(
("policy_owner", "native_provider"),
[(OWNER_B, "instagram"), (None, "meta")],
ids=["other-actor", "ordinary-bare-meta"],
)
async def test_a_composio_instagram_grant_leaves_native_resolution_alone(
db_session, monkeypatch, policy_owner, native_provider
) -> None:
"""#3533 item 4, the other direction: an actor's Composio ``instagram``
grant never replaces the native grant another resolution uses: another
actor's own ``instagram`` grant, or the bare ``meta`` grant of the
ordinary namespace."""
monkeypatch.setenv("COMPOSIO_API_KEY", "composio-key")
db = db_session.db
_add_instagram_server(db, db_session.user)
_add_instagram_grant(
db,
db_session.user,
owner=OWNER_A,
provider="instagram",
token="ca_ig",
token_type="composio",
instance_url="actor-hmac",
)
_add_instagram_grant(
db,
db_session.user,
owner=policy_owner,
provider=native_provider,
token="native-meta-token",
token_type="bearer",
instance_url=None,
)
db.commit()
policy = _policy(policy_owner) if policy_owner else None
configs = await _config(db_session, policy=policy).get_mcp_server_configs()
assert len(configs) == 1
env = configs[0]["config"]["env"]
assert env["META_ACCESS_TOKEN"] == "native-meta-token"
assert not any(key.startswith("COMPOSIO_") for key in env)
assert "ca_ig" not in str(configs)
def _add_instagram_server(db: Session, user: User) -> None:
app = get_builtin_public_mcp_app("instagram")
assert app is not None
db.add(PublicMCPApp(**app))
server = MCPServer(
name="Instagram",
managed="external",
transport="oauth",
auth={"app_id": "instagram", "provider": "meta"},
)
db.add(server)
db.flush()
db.add(
UserMCPServer(
user_id=user.id,
mcpserver_id=server.id,
is_owner=False,
is_active=True,
)
)
def _add_instagram_grant(
db: Session,
user: User,
*,
owner: str | None,
provider: str,
token: str,
token_type: str,
instance_url: str | None,
) -> None:
db.add(
UserOAuth(
user_id=user.id,
provider=provider,
resource_owner_key=owner,
provider_user_id=f"{provider}-user",
access_token=token,
token_type=token_type,
instance_url=instance_url,
)
)
@pytest.mark.asyncio
async def test_actor_builtin_refresh_remains_in_exact_owner_namespace(
db_session, monkeypatch
) -> None:
_add_builtin_server(db_session.db, db_session.user)
ordinary = _add_actor_credential(
db_session.db, db_session.user, owner=None, token="ordinary-token"
)
actor_a = _add_actor_credential(
db_session.db, db_session.user, owner=OWNER_A, token="expired-actor-a-token"
)
actor_b = _add_actor_credential(
db_session.db, db_session.user, owner=OWNER_B, token="actor-b-token"
)
async def refresh_exact_actor(_db, account, provider_name):
assert account.id == actor_a.id
assert account.resource_owner_key == OWNER_A
assert provider_name == "google"
account.access_token = "refreshed-actor-a-token"
return True
monkeypatch.setattr(
web_tools_config,
"refresh_oauth_token_if_needed",
refresh_exact_actor,
)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert _token(configs[0]) == "refreshed-actor-a-token"
db_session.db.expire_all()
assert db_session.db.get(UserOAuth, ordinary.id).access_token == "ordinary-token"
assert db_session.db.get(UserOAuth, actor_b.id).access_token == "actor-b-token"
@pytest.mark.asyncio
async def test_concurrent_actor_refresh_keeps_rotated_credential(
db_session,
monkeypatch,
) -> None:
_add_builtin_server(db_session.db, db_session.user)
db_session.db.add(
OAuthProvider(
provider_name="google",
name="Google",
client_id="client-id",
client_secret="client-secret",
auth_url="https://accounts.example/authorize",
token_url="https://accounts.example/token",
)
)
account = _add_actor_credential(
db_session.db,
db_session.user,
owner=OWNER_A,
token="expired-token",
)
account.refresh_token = "rotating-refresh-token"
account.expires_at = datetime.now(timezone.utc) - timedelta(minutes=1)
db_session.db.commit()
class Response:
def __init__(self, status_code: int, payload: dict | None = None) -> None:
self.status_code = status_code
self._payload = payload or {}
def json(self) -> dict:
return self._payload
post_calls = 0
class Client:
async def __aenter__(self):
return self
async def __aexit__(self, *_args):
return None
async def post(self, *_args, **_kwargs):
nonlocal post_calls
post_calls += 1
if post_calls == 1:
await asyncio.sleep(0.05)
return Response(
200,
{
"access_token": "winner-token",
"refresh_token": "winner-refresh-token",
"expires_in": 3600,
},
)
for _ in range(int(DB_PROGRESS_TIMEOUT / 0.01)):
with db_session.session_factory() as check_db:
current = check_db.get(UserOAuth, int(account.id))
if current is not None and current.access_token == "winner-token":
break
await asyncio.sleep(0.01)
return Response(400)
monkeypatch.setattr(web_tools_config, "create_public_async_client", Client)
first, second = await asyncio.gather(
_config(db_session, policy=_policy()).get_mcp_server_configs(),
_config(db_session, policy=_policy()).get_mcp_server_configs(),
)
assert post_calls == 1
assert _token(first[0]) == "winner-token"
assert _token(second[0]) == "winner-token"
db_session.db.expire_all()
persisted = db_session.db.get(UserOAuth, int(account.id))
assert persisted is not None
assert persisted.access_token == "winner-token"
assert persisted.refresh_token == "winner-refresh-token"
@pytest.mark.asyncio
async def test_actor_builtin_missing_exact_credential_does_not_fallback(
db_session,
) -> None:
_add_builtin_server(db_session.db, db_session.user)
_add_actor_credential(
db_session.db, db_session.user, owner=None, token="ordinary-token"
)
_add_actor_credential(
db_session.db, db_session.user, owner=OWNER_B, token="actor-b-token"
)
tool_config = _config(db_session, policy=_policy())
configs = await tool_config.get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "oauth_token_required"
assert "ordinary-token" not in str(configs)
assert "actor-b-token" not in str(configs)
assert OWNER_A not in str(configs)
assert OWNER_A not in str(tool_config.get_mcp_oauth_diagnostics())
@pytest.mark.asyncio
async def test_actor_slack_missing_credential_uses_paired_trusted_grant(
db_session,
) -> None:
_add_slack_builtin_server(db_session.db, db_session.user)
execution_identity = _execution_identity()
seen = []
async def resolver(request):
await asyncio.sleep(0)
seen.append(request)
return SlackActorRuntimeGrant(
access_token="workspace-slack-token",
channel_access=SlackChannelAccessPolicy(
channel_ids=frozenset({"C0123456789"}),
expires_at=datetime.now(timezone.utc) + timedelta(minutes=5),
capabilities=frozenset({"read"}),
),
)
set_slack_actor_runtime_grant_resolver(resolver)
configs = await _config(
db_session,
policy=_policy(),
execution_identity=execution_identity,
).get_mcp_server_configs()
assert len(seen) == 1
request = seen[0]
assert request.user_id == db_session.user.id
assert request.resource_owner_key == OWNER_A
assert request.execution_identity == execution_identity
assert request.builtin_app_id == "slack"
assert configs[0]["config"]["env"]["SLACK_ACCESS_TOKEN"] == (
"workspace-slack-token"
)
serialized = configs[0]["config"]["env"][SLACK_CHANNEL_ACCESS_POLICY_ENV]
assert "C0123456789" in serialized
assert OWNER_A not in repr(request)
assert "run-1" not in repr(request)
assert "workspace-slack-token" not in str(configs)
assert "C0123456789" not in str(configs)
assert '"version":2' in serialized
assert '"capabilities":["read"]' in serialized
assert callable(configs[0]["config"][SLACK_ACTOR_RUNTIME_REFRESH_KEY])
@pytest.mark.asyncio
async def test_actor_slack_invocation_refresh_keeps_actor_and_scope_isolated(
db_session,
) -> None:
_add_slack_builtin_server(db_session.db, db_session.user)
identity_a = _execution_identity()
identity_b = MCPActorExecutionIdentity(
task_id=2,
run_id="run-2",
turn_id="turn-2",
lease_attempt_id="attempt-2",
)
scope_a = ExecutionScope(sandbox_key_suffix="scope-a")
scope_b = ExecutionScope(sandbox_key_suffix="scope-b")
seen = []
def resolver(request):
seen.append(request)
suffix = request.execution_identity.turn_id
return SlackActorRuntimeGrant(
access_token=f"token-{suffix}-{len(seen)}",
channel_access=SlackChannelAccessPolicy(
channel_ids=frozenset({"C0123456789"}),
expires_at=datetime.now(timezone.utc) + timedelta(minutes=5),
capabilities=frozenset({"read"}),
),
)
set_slack_actor_runtime_grant_resolver(resolver)
configs_a = await _config(
db_session,
policy=_policy(OWNER_A),
execution_identity=identity_a,
execution_scope=scope_a,
).get_mcp_server_configs()
configs_b = await _config(
db_session,
policy=_policy(OWNER_B),
execution_identity=identity_b,
execution_scope=scope_b,
).get_mcp_server_configs()
refresh_a = configs_a[0]["config"][SLACK_ACTOR_RUNTIME_REFRESH_KEY]
refresh_b = configs_b[0]["config"][SLACK_ACTOR_RUNTIME_REFRESH_KEY]
assert refresh_a.__closure__ is None
assert refresh_b.__closure__ is None
connection_a = await refresh_a()
connection_b = await refresh_b()
assert [request.resource_owner_key for request in seen] == [
OWNER_A,
OWNER_B,
OWNER_A,
OWNER_B,
]
assert [request.execution_identity for request in seen] == [
identity_a,
identity_b,
identity_a,
identity_b,
]
assert [request.scope for request in seen] == [scope_a, scope_b, scope_a, scope_b]
assert connection_a["env"]["SLACK_ACCESS_TOKEN"] == "token-turn-1-3"
assert connection_b["env"]["SLACK_ACCESS_TOKEN"] == "token-turn-2-4"
assert SLACK_ACTOR_RUNTIME_REFRESH_KEY not in connection_a
assert SLACK_ACTOR_RUNTIME_REFRESH_KEY not in connection_b
@pytest.mark.asyncio
@pytest.mark.parametrize("token", ["actor-token", ""])
async def test_actor_slack_existing_exact_row_never_uses_fallback(
db_session, token
) -> None:
_add_slack_builtin_server(db_session.db, db_session.user)
db_session.db.add(
UserOAuth(
user_id=int(db_session.user.id),
provider="slack",
resource_owner_key=OWNER_A,
access_token=token,
provider_user_id="slack-user",
)
)
db_session.db.commit()
calls = 0
def resolver(_request):
nonlocal calls
calls += 1
return SlackActorRuntimeGrant(
access_token="workspace-slack-token",
channel_access=SlackChannelAccessPolicy(
channel_ids=frozenset({"C0123456789"}),
expires_at=datetime.now(timezone.utc) + timedelta(minutes=5),
capabilities=frozenset({"read"}),
),
)
set_slack_actor_runtime_grant_resolver(resolver)
configs = await _config(
db_session,
policy=_policy(),
execution_identity=_execution_identity(),
).get_mcp_server_configs()
assert calls == 0
if token:
assert configs[0]["config"]["env"]["SLACK_ACCESS_TOKEN"] == token
assert SLACK_CHANNEL_ACCESS_POLICY_ENV not in configs[0]["config"]["env"]
assert SLACK_ACTOR_RUNTIME_REFRESH_KEY not in configs[0]["config"]
else:
assert configs[0]["transport"] == "unavailable"
@pytest.mark.asyncio
async def test_actor_slack_rejects_expired_fallback_grant(db_session) -> None:
_add_slack_builtin_server(db_session.db, db_session.user)
set_slack_actor_runtime_grant_resolver(
lambda _request: SlackActorRuntimeGrant(
access_token="workspace-slack-token",
channel_access=SlackChannelAccessPolicy(
channel_ids=frozenset({"C0123456789"}),
expires_at=datetime.now(timezone.utc) - timedelta(seconds=1),
capabilities=frozenset({"read"}),
),
)
)
configs = await _config(
db_session,
policy=_policy(),
execution_identity=_execution_identity(),
).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "oauth_token_required"
assert "workspace-slack-token" not in str(configs)
@pytest.mark.asyncio
async def test_actor_slack_refresh_failure_never_uses_fallback(
db_session, monkeypatch
) -> None:
_add_slack_builtin_server(db_session.db, db_session.user)
account = UserOAuth(
user_id=int(db_session.user.id),
provider="slack",
resource_owner_key=OWNER_A,
access_token="expired-actor-token",
refresh_token="refresh-token",
expires_at=datetime.now(timezone.utc) - timedelta(minutes=1),
provider_user_id="slack-user",
)
db_session.db.add(account)
db_session.db.commit()
calls = 0
async def transient_refresh_failure(_db, resolved_account, _provider):
assert resolved_account.id == account.id
return False
def resolver(_request):
nonlocal calls
calls += 1
return None
monkeypatch.setattr(
web_tools_config,
"refresh_oauth_token_if_needed",
transient_refresh_failure,
)
set_slack_actor_runtime_grant_resolver(resolver)
configs = await _config(
db_session,
policy=_policy(),
execution_identity=_execution_identity(),
).get_mcp_server_configs()
assert calls == 0
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "oauth_token_refresh_failed"
@pytest.mark.asyncio
async def test_a_rejected_client_is_reported_as_client_rejected_and_keeps_the_grant(
db_session, monkeypatch
) -> None:
"""#3580: the vendor rejected the platform's client, not this grant."""
_add_slack_builtin_server(db_session.db, db_session.user)
account = UserOAuth(
user_id=int(db_session.user.id),
provider="slack",
resource_owner_key=OWNER_A,
access_token="expired-actor-token",
refresh_token="refresh-token",
expires_at=datetime.now(timezone.utc) - timedelta(minutes=1),
provider_user_id="slack-user",
)
db_session.db.add(account)
db_session.db.commit()
async def client_rejected(_db, _account, _provider):
raise web_tools_config._OAuthRefreshClientRejected("client_rejected:slack")
monkeypatch.setattr(
web_tools_config, "refresh_oauth_token_if_needed", client_rejected
)
set_slack_actor_runtime_grant_resolver(lambda _request: None)
configs = await _config(
db_session,
policy=_policy(),
execution_identity=_execution_identity(),
).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "client_rejected:slack"
db_session.db.expire_all()
kept = db_session.db.get(UserOAuth, account.id)
assert (kept.access_token, kept.refresh_token) == (
"expired-actor-token",
"refresh-token",
)
@pytest.mark.asyncio
async def test_team_visible_canonical_builtin_uses_exact_actor_credential(
db_session,
) -> None:
server = _add_builtin_server(db_session.db, db_session.user, personal=False)
_add_actor_credential(
db_session.db, db_session.user, owner=OWNER_A, token="team-actor-token"
)
connector_team_scope.set_connector_team_hooks(
team_visibility=lambda _db, *, team_id: {
"mcp": {int(server.id)} if team_id == 41 else set(),
"custom_api": set(),
}
)
configs = await _config(
db_session,
policy=_policy(),
connector_team_id=41,
).get_mcp_server_configs()
assert [config["id"] for config in configs] == [int(server.id)]
assert _token(configs[0]) == "team-actor-token"
@pytest.mark.asyncio
async def test_drifted_reserved_builtin_cannot_fall_through_to_native_stdio(
db_session,
) -> None:
server = _add_builtin_server(db_session.db, db_session.user)
server.transport = "stdio"
server.command = "/bin/unsafe-native"
server.args = ["--secret", "task-token"]
db_session.db.commit()
tool_config = _config(db_session, policy=_policy())
configs = await tool_config.get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
assert "/bin/unsafe-native" not in str(configs)
assert "task-token" not in str(configs)
@pytest.mark.asyncio
async def test_actor_builtin_rejects_selectors_and_ignores_task_credentials(
db_session,
monkeypatch,
) -> None:
server = _add_builtin_server(db_session.db, db_session.user)
_add_actor_credential(
db_session.db, db_session.user, owner=OWNER_A, token="actor-token"
)
monkeypatch.setattr(
"xagent.web.services.connector_runtime.load_connector_runtime_view",
lambda **_kwargs: {
f"mcp:{server.id}": {
"context": {"secret-context": "context-value"},
"secrets": {"access_token": "task-secret-token"},
"auth_selector": {"resource_owner_key": OWNER_B},
}
},
)
tool_config = _config(
db_session,
policy=_policy(),
mcp_auth_context={
str(server.id): {
"resource_owner_key": OWNER_B,
"access_token": "selector-token",
}
},
)
configs = await tool_config.get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
rendered = str((configs, tool_config.get_mcp_oauth_diagnostics()))
for secret in (
OWNER_A,
OWNER_B,
"task-secret-token",
"selector-token",
"context-value",
"actor-token",
):
assert secret not in rendered
assert "connector_runtime" not in configs[0]
assert "runtime_bindings" not in configs[0]
ignored_runtime_config = _config(db_session, policy=_policy())
ignored_runtime_configs = await ignored_runtime_config.get_mcp_server_configs()
assert _token(ignored_runtime_configs[0]) == "actor-token"
ignored_rendered = str(
(
ignored_runtime_configs,
ignored_runtime_config.get_mcp_oauth_diagnostics(),
)
)
for secret in (OWNER_A, OWNER_B, "task-secret-token", "context-value"):
assert secret not in ignored_rendered
assert "connector_runtime" not in ignored_runtime_configs[0]
assert "runtime_bindings" not in ignored_runtime_configs[0]
@pytest.mark.asyncio
async def test_normalized_reserved_builtin_alias_cannot_run_as_native(
db_session,
) -> None:
server = _add_builtin_server(db_session.db, db_session.user)
server.auth = None
server.name = " ACTOR DRIVE "
server.transport = "stdio"
server.command = "/bin/unsafe-alias"
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
assert "/bin/unsafe-alias" not in str(configs)
@pytest.mark.asyncio
async def test_normalized_reserved_auth_alias_cannot_run_as_native(
db_session,
) -> None:
server = _add_builtin_server(db_session.db, db_session.user)
server.name = "Foreign native server"
server.auth = {"app_id": " ACTOR DRIVE ", "provider": "google"}
server.transport = "stdio"
server.command = "/bin/unsafe-auth-alias"
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
assert "/bin/unsafe-auth-alias" not in str(configs)
@pytest.mark.asyncio
@pytest.mark.parametrize("transport", ["stdio", "sse", "websocket", "streamable_http"])
async def test_actor_policy_preserves_native_mcp_transports(
db_session, transport
) -> None:
kwargs = (
{"command": "echo", "args": ["native"], "env": {"NATIVE": "value"}}
if transport == "stdio"
else {"url": "https://native.example/mcp", "headers": {"X-Native": "value"}}
)
server = MCPServer(
name=f"native-{transport}",
description="native server",
managed="external",
transport=transport,
**kwargs,
)
db_session.db.add(server)
db_session.db.flush()
db_session.db.add(
UserMCPServer(
user_id=int(db_session.user.id),
mcpserver_id=int(server.id),
is_owner=True,
is_active=True,
)
)
db_session.db.commit()
ordinary = await _config(db_session, policy=None).get_mcp_server_configs()
actor = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert actor == ordinary
assert actor[0]["transport"] == transport
@pytest.mark.asyncio
async def test_actor_policy_preserves_native_mcp_oauth(db_session) -> None:
server = MCPServer(
name="native-mcp-oauth",
description="native OAuth server",
managed="external",
transport="streamable_http",
url="https://native.example/mcp",
auth={
"type": "mcp_oauth",
"resource": "https://native.example/mcp",
"issuer": "https://issuer.example",
"client_id": "native-client",
"scope": "read",
},
)
db_session.db.add(server)
db_session.db.flush()
db_session.db.add(
UserMCPServer(
user_id=int(db_session.user.id),
mcpserver_id=int(server.id),
is_owner=True,
is_active=True,
)
)
client = MCPOAuthClient(
mcp_server_id=int(server.id),
issuer="https://issuer.example",
authorization_endpoint="https://issuer.example/authorize",
token_endpoint="https://issuer.example/token",
client_id="native-client",
token_endpoint_auth_method="none",
redirect_uri="https://xagent.example/callback",
)
db_session.db.add(client)
db_session.db.flush()
db_session.db.add(
MCPOAuthGrant(
mcp_server_id=int(server.id),
user_id=int(db_session.user.id),
mcp_oauth_client_id=int(client.id),
resource_owner_key=f"xagent:user:{db_session.user.id}",
issuer="https://issuer.example",
resource="https://native.example/mcp",
scope="read",
access_token=encrypt_value("native-oauth-token"),
expires_at=datetime(2099, 1, 1, tzinfo=timezone.utc),
status="active",
)
)
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "streamable_http"
assert configs[0]["config"]["headers"]["Authorization"] == (
"Bearer native-oauth-token"
)
@pytest.mark.asyncio
async def test_policy_none_preserves_ordinary_builtin_oauth(db_session) -> None:
_add_builtin_server(db_session.db, db_session.user)
_add_actor_credential(
db_session.db, db_session.user, owner=None, token="ordinary-token"
)
_add_actor_credential(
db_session.db, db_session.user, owner=OWNER_A, token="actor-token"
)
configs = await _config(db_session, policy=None).get_mcp_server_configs()
assert _token(configs[0]) == "ordinary-token"
assert "actor-token" not in str(configs)
SIGNED_UPLOADS = [
{
"tool_name": "attach_document",
"file_argument": "document_file_id",
"issuing_tool_name": "request_upload",
"allowed_upload_hosts": ["uploads.example.test"],
"upload_path_prefix": "/staged/",
"content_types": {".pdf": "application/pdf"},
}
]
@pytest.mark.asyncio
async def test_actor_builtin_row_storing_signed_uploads_is_unavailable(
db_session,
) -> None:
server = _add_builtin_server(db_session.db, db_session.user)
_add_actor_credential(
db_session.db, db_session.user, owner=OWNER_A, token="actor-token"
)
server.signed_uploads = SIGNED_UPLOADS
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "config_load_failed"
assert "actor-token" not in str(configs)
@pytest.mark.asyncio
@pytest.mark.parametrize(
"stored",
[SIGNED_UPLOADS, {"tool_name": "attach_document"}],
ids=["valid", "invalid"],
)
async def test_actor_remote_oauth_row_storing_signed_uploads_is_unavailable(
db_session, stored
) -> None:
server = _add_remote_server(db_session.db, db_session.user)
_add_remote_grant(
db_session.db,
db_session.user,
server,
owner=OWNER_A,
token="actor-token",
)
server.signed_uploads = stored
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "invalid_configuration"
assert configs[0]["config"]["message"] == "MCP server upload settings are invalid."
assert "actor-token" not in str(configs)
def _add_gmail_server_and_native_grant(db: Session, user: User) -> None:
"""Toby's Gmail connector with a native (non-Composio) actor grant, the
catalog row seeded as the current environment seeds it."""
app = get_builtin_public_mcp_app("gmail")
assert app is not None
db.add(PublicMCPApp(**app))
server = MCPServer(
name="Gmail",
managed="external",
transport="oauth",
auth={"app_id": "gmail", "provider": "google"},
)
db.add(server)
db.flush()
db.add(
UserMCPServer(
user_id=user.id, mcpserver_id=server.id, is_owner=False, is_active=True
)
)
db.add(
UserOAuth(
user_id=user.id,
provider="gmail",
resource_owner_key=OWNER_A,
provider_user_id="google-subject",
access_token="native-gmail-token",
token_type="Bearer",
)
)
db.commit()
@pytest.mark.asyncio
async def test_a_native_actor_gmail_grant_stays_unavailable_while_the_gate_is_closed(
db_session, monkeypatch
) -> None:
"""#3649: the Gmail Composio switch shows Gmail in the catalog, which is
also Toby's runtime admission check. A native Gmail grant must still not
run while our Google app has no restricted-scope approval; it is reported
as needing a connection, so the member reconnects through Composio."""
monkeypatch.delenv("XAGENT_GOOGLE_RESTRICTED_SCOPES_ENABLED", raising=False)
monkeypatch.setenv("XAGENT_GMAIL_AUTH_BACKEND", "composio")
_add_gmail_server_and_native_grant(db_session.db, db_session.user)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert len(configs) == 1
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "oauth_token_required"
assert "native-gmail-token" not in str(configs)
@pytest.mark.asyncio
async def test_a_native_actor_gmail_grant_runs_while_the_gate_is_open(
db_session, monkeypatch
) -> None:
monkeypatch.setenv("XAGENT_GOOGLE_RESTRICTED_SCOPES_ENABLED", "true")
monkeypatch.setenv("XAGENT_GMAIL_AUTH_BACKEND", "composio")
_add_gmail_server_and_native_grant(db_session.db, db_session.user)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert len(configs) == 1
assert configs[0]["config"]["env"]["GOOGLE_ACCESS_TOKEN"] == "native-gmail-token"
@pytest.mark.asyncio
async def test_a_composio_actor_gmail_grant_is_not_held_back_by_the_gate(
db_session, monkeypatch
) -> None:
"""The gate holds back only native grants: once the Gmail tools run on a
Composio grant (#3647, simulated here), a Composio Gmail grant launches
with the Composio values while the gate stays closed."""
from xagent.web.tools import config as tools_config
monkeypatch.delenv("XAGENT_GOOGLE_RESTRICTED_SCOPES_ENABLED", raising=False)
monkeypatch.setenv("XAGENT_GMAIL_AUTH_BACKEND", "composio")
monkeypatch.setenv("COMPOSIO_API_KEY", "composio-key")
monkeypatch.setattr(
tools_config,
"_COMPOSIO_PROXY_APPS",
tools_config._COMPOSIO_PROXY_APPS | {"gmail"},
)
_add_gmail_server_and_native_grant(db_session.db, db_session.user)
grant = db_session.db.query(UserOAuth).filter_by(provider="gmail").one()
grant.access_token = "ca_gmail"
grant.token_type = "composio"
grant.instance_url = "actor-hmac"
db_session.db.commit()
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert len(configs) == 1
env = configs[0]["config"]["env"]
assert env["COMPOSIO_CONNECTED_ACCOUNT_ID"] == "ca_gmail"
assert "GOOGLE_ACCESS_TOKEN" not in env
@pytest.mark.asyncio
async def test_a_held_back_native_actor_gmail_grant_is_never_refreshed(
db_session, monkeypatch
) -> None:
"""Holding the grant back after refreshing it would still call Google
through our unapproved app and store the new token; it is held back first."""
from xagent.web.tools import config as tools_config
monkeypatch.delenv("XAGENT_GOOGLE_RESTRICTED_SCOPES_ENABLED", raising=False)
monkeypatch.setenv("XAGENT_GMAIL_AUTH_BACKEND", "composio")
_add_gmail_server_and_native_grant(db_session.db, db_session.user)
grant = db_session.db.query(UserOAuth).filter_by(provider="gmail").one()
grant.refresh_token = "native-refresh"
grant.expires_at = datetime.now(timezone.utc) - timedelta(hours=1)
db_session.db.commit()
async def no_refresh(*args, **kwargs):
raise AssertionError("a held-back Gmail grant must not be refreshed")
monkeypatch.setattr(tools_config, "refresh_oauth_token_if_needed", no_refresh)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "oauth_token_required"
db_session.db.expire_all()
grant = db_session.db.query(UserOAuth).filter_by(provider="gmail").one()
assert (grant.access_token, grant.refresh_token) == (
"native-gmail-token",
"native-refresh",
)
@pytest.mark.asyncio
@pytest.mark.parametrize("switch", ["composio", None], ids=["switch-on", "switch-off"])
async def test_a_web_gmail_grant_is_left_as_on_main(db_session, monkeypatch, switch):
"""Only Toby's grants are held back; an ordinary (web) Gmail grant
resolves as it does on main, whatever the switch."""
monkeypatch.delenv("XAGENT_GOOGLE_RESTRICTED_SCOPES_ENABLED", raising=False)
if switch:
monkeypatch.setenv("XAGENT_GMAIL_AUTH_BACKEND", switch)
else:
monkeypatch.delenv("XAGENT_GMAIL_AUTH_BACKEND", raising=False)
_add_gmail_server_and_native_grant(db_session.db, db_session.user)
grant = db_session.db.query(UserOAuth).filter_by(provider="gmail").one()
grant.resource_owner_key = None
db_session.db.commit()
configs = await _config(db_session, policy=None).get_mcp_server_configs()
assert len(configs) == 1
assert configs[0]["config"]["env"]["GOOGLE_ACCESS_TOKEN"] == "native-gmail-token"
@pytest.mark.asyncio
@pytest.mark.parametrize("gate_open", [False, True], ids=["gate-closed", "gate-open"])
async def test_a_shared_native_actor_gmail_grant_is_held_back_too(
db_session, monkeypatch, gate_open
) -> None:
"""Toby's Gmail token can also come from a native shared Google grant;
that path is held back the same way, before any refresh."""
from xagent.web.models.oauth_provider import OAuthProvider
from xagent.web.services.google_oauth_grants import (
write_google_shared_oauth_callback,
)
from xagent.web.tools import config as tools_config
if gate_open:
monkeypatch.setenv("XAGENT_GOOGLE_RESTRICTED_SCOPES_ENABLED", "true")
else:
monkeypatch.delenv("XAGENT_GOOGLE_RESTRICTED_SCOPES_ENABLED", raising=False)
monkeypatch.setenv("XAGENT_GMAIL_AUTH_BACKEND", "composio")
monkeypatch.setenv("XAGENT_GOOGLE_SHARED_OAUTH_GRANTS_ENABLED", "true")
db, user = db_session.db, db_session.user
_add_gmail_server_and_native_grant(db, user)
db.add(
OAuthProvider(
provider_name="google",
name="Google",
client_id="google-client-id",
client_secret="secret",
auth_url="https://accounts.google.com/o/oauth2/auth",
token_url="https://oauth2.googleapis.com/token",
default_scopes=[],
)
)
db.flush()
scopes = get_builtin_public_mcp_app("gmail")["oauth_scopes"]
write_google_shared_oauth_callback(
db,
user_id=int(user.id),
resource_owner_key=OWNER_A,
oauth_client_id="google-client-id",
app_id="gmail",
google_subject="google-subject",
access_token="shared-native-token",
refresh_token="shared-refresh",
granted_scopes=" ".join(scopes),
requested_scopes=list(scopes),
email="[email protected]",
token_type="Bearer",
expires_at=datetime.now(timezone.utc) - timedelta(hours=1),
legacy_oauth_account=db.query(UserOAuth).filter_by(provider="gmail").one(),
)
db.commit()
refreshed: list[str] = []
async def refresh(db, account, provider, **kwargs):
refreshed.append(str(account.provider))
return True
monkeypatch.setattr(tools_config, "refresh_oauth_token_if_needed", refresh)
configs = await _config(db_session, policy=_policy()).get_mcp_server_configs()
if gate_open:
# The shared grant is the one that resolves when the gate allows it.
assert configs[0]["config"]["env"]["GOOGLE_ACCESS_TOKEN"] == (
"shared-native-token"
)
assert refreshed == ["google"]
else:
assert configs[0]["transport"] == "unavailable"
assert configs[0]["config"]["reason"] == "oauth_token_required"
assert refreshed == []