Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

73.9 KB
Raw Blame
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 == []