Enterprise agent platform for building, deploying, and operating AI teammates.
"""Task-source gate for OAuth grants a team member made for themselves.
``team_member_mcp_grants_allowed_for_task`` decides, from the task row alone,
whether the runtime may select such a grant. These tests feed it the task as
the runtime really receives it: the detached ``_TaskFields`` that
``load_task_setup_snapshot_sync`` reads from a persisted ``tasks`` row, and the
ORM ``Task`` row itself.
"""
from __future__ import annotations
import ast
import copy
import inspect
import json
import pickle
import textwrap
from collections.abc import Iterator
from dataclasses import fields
from pathlib import Path
from typing import Any
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from tests.shared.auth_database import auth_db_override
from xagent.core.tools.adapters.vibe.factory import ToolFactory
from xagent.core.utils.encryption import encrypt_value
from xagent.web.api.auth import auth_router
from xagent.web.api.chat import chat_router
from xagent.web.models.agent import Agent, AgentStatus
from xagent.web.models.auth_database import get_auth_db
from xagent.web.models.database import Base, get_db, get_engine, init_db
from xagent.web.models.mcp import MCPServer
from xagent.web.models.mcp_oauth import MCPOAuthClient, MCPOAuthGrant
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.user import User
from xagent.web.models.user_channel import UserChannel
from xagent.web.services import agent_service_manager as asm_module
from xagent.web.services import connector_team_scope
from xagent.web.services.agent_service_manager import AgentServiceManager
from xagent.web.services.agent_team_scope import (
AgentTeamScope,
set_agent_team_scope_hook,
)
from xagent.web.services.mcp_oauth import (
resolve_mcp_oauth_runtime_auth,
select_mcp_oauth_grants,
)
from xagent.web.services.mcp_runtime import (
build_mcp_runtime_connection,
team_member_mcp_grants_allowed_for_task,
)
from xagent.web.services.task_setup_snapshot import (
TASK_FIELD_NOT_LOADED,
RuntimeUserFields,
TaskSetupSnapshot,
_TaskFields,
load_task_setup_snapshot_sync,
)
from xagent.web.tools.config import WebToolConfig
SRC_ROOT = Path(__file__).resolve().parents[3] / "src" / "xagent"
@pytest.fixture()
def gate_db(tmp_path) -> Iterator[Any]:
init_db(db_url=f"sqlite:///{tmp_path / 'team_member_gate.db'}")
db = next(get_db())
try:
yield db
finally:
db.close()
Base.metadata.drop_all(bind=get_engine())
def _user(db, name: str) -> User:
user = User(username=name, password_hash="hash", is_admin=False)
db.add(user)
db.commit()
db.refresh(user)
return user
def _channel(db, user_id: int) -> UserChannel:
channel = UserChannel(
user_id=user_id,
channel_type="feishu",
channel_name="feishu-app",
_config={},
is_active=True,
)
db.add(channel)
db.commit()
db.refresh(channel)
return channel
def _task(db, user_id: int, **columns: Any) -> Task:
values: dict[str, Any] = dict(
user_id=user_id,
title="gate task",
description="gate task",
status=TaskStatus.PENDING,
execution_mode="flash",
)
values.update(columns)
explicit_null_source = "source" in values and values["source"] is None
if explicit_null_source:
del values["source"]
task = Task(**values)
db.add(task)
db.commit()
if explicit_null_source:
db.query(Task).filter(Task.id == task.id).update({Task.source: None})
db.commit()
db.refresh(task)
return task
def _snapshot_fields(task: Task) -> _TaskFields:
snapshot = load_task_setup_snapshot_sync(
task_id=int(task.id), task_owner_user_id=int(task.user_id)
)
assert snapshot is not None
assert isinstance(snapshot.task, _TaskFields)
return snapshot.task
# (case id, task columns, allowed). ``channel`` stands for "link the task to a
# real user_channels row".
_ROW_CASES: list[tuple[str, dict[str, Any], bool]] = [
("internal_no_channel", {"source": "internal"}, True),
("none_source_no_channel", {"source": None}, True),
("internal_with_channel", {"source": "internal", "channel": True}, False),
("trigger", {"source": "trigger"}, True),
("trigger_with_channel", {"source": "trigger", "channel": True}, False),
("sdk_personal", {"source": "sdk", "sdk_credential_kind": "personal"}, True),
("sdk_runtime_null_kind", {"source": "sdk", "sdk_credential_kind": None}, False),
("a2a", {"source": "a2a"}, False),
("widget", {"source": "widget"}, False),
("shared_link", {"source": "shared_link"}, False),
("external", {"source": "external"}, False),
("unknown_source", {"source": "brand_new_source"}, False),
(
"unbound_then_rebound_feishu_task",
{"source": "internal", "channel_name": "feishu-app"},
False,
),
(
"telegram_task_channel_unbound",
{"source": "internal", "telegram_user_id": "777001"},
False,
),
]
def _make_row_task(db, user_id: int, columns: dict[str, Any]) -> Task:
columns = dict(columns)
if columns.pop("channel", False):
channel = _channel(db, user_id)
columns["channel_id"] = int(channel.id)
columns["channel_name"] = str(channel.channel_name)
return _task(db, user_id, **columns)
def _hand_built_task_fields() -> _TaskFields:
task_fields = _TaskFields(
id=1,
user_id=1,
status=TaskStatus.PENDING,
agent_id=None,
agent_config=None,
model_name=None,
compact_model_name=None,
execution_mode="flash",
agent_type="standard",
source="internal",
)
for name in (
"channel_id",
"channel_name",
"telegram_user_id",
"sdk_credential_kind",
):
assert getattr(task_fields, name) is TASK_FIELD_NOT_LOADED
return task_fields
def _create_task_through_chat_api(db) -> Task:
"""Write a web chat task with the real create-task route."""
def _override() -> Iterator[Any]:
session = None
try:
session = next(get_db())
yield session
finally:
if session is not None:
session.close()
app = FastAPI()
app.include_router(auth_router)
app.include_router(chat_router)
app.dependency_overrides[get_db] = _override
app.dependency_overrides[get_auth_db] = auth_db_override(_override)
client = TestClient(app, raise_server_exceptions=False)
setup = client.post(
"/api/auth/setup-admin",
json={
"username": "admin",
"email": "[email protected]",
"password": "admin123",
},
)
assert setup.status_code == 200, setup.text
login = client.post(
"/api/auth/login", json={"username": "admin", "password": "admin123"}
)
assert login.status_code == 200, login.text
created = client.post(
"/api/chat/task/create",
headers={"Authorization": f"Bearer {login.json()['access_token']}"},
json={"title": "web chat", "description": "web chat"},
)
assert created.status_code == 200, created.text
db.expire_all()
task = db.query(Task).filter(Task.id == int(created.json()["task_id"])).one()
assert task.channel_id is None
assert task.channel_name is None
assert task.telegram_user_id is None
return task
_ALL_CASE_IDS = [case_id for case_id, _, _ in _ROW_CASES] + [
"task_none",
"web_task_channel_name_null",
"hand_built_fields_without_new_attrs",
]
_ROW_CASES_BY_ID = {case_id: (cols, ok) for case_id, cols, ok in _ROW_CASES}
@pytest.mark.parametrize("case_id", _ALL_CASE_IDS)
def test_team_member_grants_allowed_for_snapshot_task(gate_db, case_id: str) -> None:
if case_id == "task_none":
assert team_member_mcp_grants_allowed_for_task(None) is False
return
if case_id == "hand_built_fields_without_new_attrs":
assert (
team_member_mcp_grants_allowed_for_task(_hand_built_task_fields()) is False
)
return
if case_id == "web_task_channel_name_null":
task = _create_task_through_chat_api(gate_db)
allowed = True
else:
columns, allowed = _ROW_CASES_BY_ID[case_id]
user = _user(gate_db, "gate-member")
task = _make_row_task(gate_db, int(user.id), columns)
assert team_member_mcp_grants_allowed_for_task(_snapshot_fields(task)) is allowed
assert team_member_mcp_grants_allowed_for_task(task) is allowed
# --- grant-forwarding registry ------------------------------------------------
_FORWARDING_KEYWORDS = frozenset(
{"allow_team_member_grants", "mcp_team_member_grants_allowed"}
)
# (path under src/xagent, enclosing function) of every call that passes one of
# the keywords above, whatever the value. A new call site must be added here on
# purpose.
_REGISTERED_CALLS = frozenset(
{
(
"web/services/agent_service_manager.py",
"AgentServiceManager._build_tools_for_task",
),
(
"web/services/agent_service_manager.py",
"AgentServiceManager._get_agent_for_task_unlocked",
),
("web/services/agent_service_manager.py", "create_default_tools"),
("web/tools/config.py", "WebToolConfig._build_mcp_server_config"),
("web/services/mcp_runtime.py", "build_mcp_runtime_connection"),
("web/services/mcp_oauth.py", "resolve_mcp_oauth_runtime_auth"),
("web/api/mcp.py", "list_mcp_apps"),
("web/services/mcp_server_management.py", "_authorization"),
("web/services/mcp_server_management.py", "_project_mcp_server"),
}
)
class _CallScanner(ast.NodeVisitor):
def __init__(self, relpath: str) -> None:
self.relpath = relpath
self.scope: list[str] = []
self.found: set[tuple[str, str]] = set()
def _enter(self, node: ast.AST) -> None:
self.scope.append(node.name) # type: ignore[attr-defined]
self.generic_visit(node)
self.scope.pop()
visit_FunctionDef = _enter
visit_AsyncFunctionDef = _enter
visit_ClassDef = _enter
def visit_Call(self, node: ast.Call) -> None:
if any(kw.arg in _FORWARDING_KEYWORDS for kw in node.keywords):
self.found.add((self.relpath, ".".join(self.scope) or "<module>"))
self.generic_visit(node)
def _scan_forwarding_calls(root: Path) -> set[tuple[str, str]]:
found: set[tuple[str, str]] = set()
for path in sorted(root.rglob("*.py")):
tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
scanner = _CallScanner(path.relative_to(root).as_posix())
scanner.visit(tree)
found |= scanner.found
return found
def test_team_member_grant_kwargs_are_registered() -> None:
assert _scan_forwarding_calls(SRC_ROOT) == set(_REGISTERED_CALLS)
def test_forwarding_scan_catches_unregistered_call_sites(tmp_path: Path) -> None:
route = tmp_path / "web" / "api" / "new_route.py"
route.parent.mkdir(parents=True)
route.write_text(
textwrap.dedent(
"""
def list_things(db):
return select_mcp_oauth_grants(db, allow_team_member_grants=True)
"""
),
encoding="utf-8",
)
builder = tmp_path / "web" / "tools" / "third_builder.py"
builder.parent.mkdir(parents=True)
builder.write_text(
textwrap.dedent(
"""
class Builder:
def build(self, flag):
return WebToolConfig(mcp_team_member_grants_allowed=flag)
"""
),
encoding="utf-8",
)
found = _scan_forwarding_calls(tmp_path)
assert found == {
("web/api/new_route.py", "list_things"),
("web/tools/third_builder.py", "Builder.build"),
}
assert not (found & set(_REGISTERED_CALLS))
def test_gate_reads_fields_without_getattr_defaults() -> None:
source = textwrap.dedent(inspect.getsource(team_member_mcp_grants_allowed_for_task))
function = ast.parse(source).body[0]
getattr_calls = [
node
for node in ast.walk(function)
if isinstance(node, ast.Call)
and isinstance(node.func, ast.Name)
and node.func.id == "getattr"
]
assert getattr_calls == []
defaults = {f.name: f.default for f in fields(_TaskFields)}
for name in (
"channel_id",
"channel_name",
"telegram_user_id",
"sdk_credential_kind",
):
assert defaults[name] is TASK_FIELD_NOT_LOADED
assert pickle.loads(pickle.dumps(TASK_FIELD_NOT_LOADED)) is TASK_FIELD_NOT_LOADED
copied = copy.deepcopy(_hand_built_task_fields())
assert copied.channel_id is TASK_FIELD_NOT_LOADED
def test_gate_refuses_when_only_sdk_credential_kind_is_not_loaded() -> None:
task_fields = _TaskFields(
id=1,
user_id=1,
status=TaskStatus.PENDING,
agent_id=None,
agent_config=None,
model_name=None,
compact_model_name=None,
execution_mode="flash",
agent_type="standard",
source="internal",
channel_id=None,
channel_name=None,
telegram_user_id=None,
)
assert task_fields.sdk_credential_kind is TASK_FIELD_NOT_LOADED
assert team_member_mcp_grants_allowed_for_task(task_fields) is False
@pytest.mark.parametrize(
("function", "parameter"),
[
pytest.param(
asm_module.create_default_tools,
"mcp_team_member_grants_allowed",
id="create_default_tools",
),
pytest.param(
WebToolConfig.__init__,
"mcp_team_member_grants_allowed",
id="WebToolConfig.__init__",
),
pytest.param(
build_mcp_runtime_connection,
"allow_team_member_grants",
id="build_mcp_runtime_connection",
),
pytest.param(
resolve_mcp_oauth_runtime_auth,
"allow_team_member_grants",
id="resolve_mcp_oauth_runtime_auth",
),
pytest.param(
select_mcp_oauth_grants,
"allow_team_member_grants",
id="select_mcp_oauth_grants",
),
],
)
def test_team_member_grant_parameters_default_to_false(
function: Any, parameter: str
) -> None:
assert inspect.signature(function).parameters[parameter].default is False
@pytest.mark.asyncio
async def test_build_tools_for_task_forwards_gate_result() -> None:
def _fields(**channel: Any) -> _TaskFields:
return _TaskFields(
id=42,
user_id=1,
status=TaskStatus.PENDING,
agent_id=None,
agent_config=None,
model_name=None,
compact_model_name=None,
execution_mode="flash",
agent_type="standard",
source="internal",
channel_id=channel.get("channel_id"),
channel_name=None,
telegram_user_id=None,
sdk_credential_kind=None,
)
for task, expected in ((_fields(channel_id=5), False), (_fields(), True)):
manager = AgentServiceManager()
snapshot = TaskSetupSnapshot(
task=task,
runtime_user=RuntimeUserFields(id=1, is_admin=False),
has_reconstructable_history=False,
task_pattern="single_call",
task_llm=None,
task_fast_llm=None,
task_vision_llm=None,
task_compact_llm=None,
agent=None,
agent_config=None,
excluded_agent_id=None,
)
with (
patch(
"xagent.web.services.agent_service_manager.create_default_tools",
new=AsyncMock(return_value=([], MagicMock())),
) as create_tools_mock,
patch.object(
manager, "_get_or_create_task_sandbox", AsyncMock(return_value=None)
),
):
await manager._build_tools_for_task(
task_id=42,
task=task,
db=None,
user=snapshot.runtime_user,
agent_config=None,
task_llm=None,
task_vision_llm=None,
task_setup_snapshot=snapshot,
)
kwargs = create_tools_mock.call_args.kwargs
assert kwargs["mcp_team_member_grants_allowed"] is expected
# --- end to end through the snapshot path -------------------------------------
_MEMBER_TOKEN = "member-path-access-token"
_MCP_URL = "https://mcp.gate.test/mcp"
_ISSUER = "https://auth.gate.test"
_TEAM_ID = 101
def _team_connector_fixture(db) -> dict[str, int]:
owner = _user(db, "gate-owner")
member = _user(db, "gate-member-e2e")
server = MCPServer.from_config(
{
"name": "gate-team-connector",
"managed": "external",
"transport": "streamable_http",
"url": _MCP_URL,
"auth": {"type": "mcp_oauth"},
}
)
db.add(server)
db.commit()
db.refresh(server)
agent = Agent(
user_id=owner.id,
name="gate-team-agent",
instructions="be terse",
execution_mode="balanced",
status=AgentStatus.PUBLISHED,
tool_categories=["mcp"],
team_id=_TEAM_ID,
visibility="team",
models={},
knowledge_bases=[],
skills=[],
)
db.add(agent)
db.commit()
db.refresh(agent)
oauth_client = MCPOAuthClient(
mcp_server_id=server.id,
issuer=_ISSUER,
authorization_endpoint=f"{_ISSUER}/authorize",
token_endpoint=f"{_ISSUER}/token",
client_id="gate-client",
token_endpoint_auth_method="none",
redirect_uri="https://api.gate.test/api/mcp/oauth/callback",
)
db.add(oauth_client)
db.flush()
db.add(
MCPOAuthGrant(
mcp_server_id=server.id,
user_id=member.id,
mcp_oauth_client_id=oauth_client.id,
resource_owner_key=f"xagent:user:{member.id}",
issuer=_ISSUER,
resource=_MCP_URL,
scope="",
access_token=encrypt_value(_MEMBER_TOKEN),
status="active",
)
)
db.commit()
return {
"server_id": int(server.id),
"agent_id": int(agent.id),
"member_id": int(member.id),
}
async def _build_tools_and_load_mcp(
db, *, task: Task, member_id: int
) -> tuple[list[dict[str, Any]], list[dict[str, Any]], dict[str, Any]]:
"""Run the real snapshot path of ``get_agent_for_task`` and load the MCP
server configs from the tool config it built."""
manager = AgentServiceManager()
manager._default_llm = MagicMock()
snapshot = load_task_setup_snapshot_sync(
task_id=int(task.id), task_owner_user_id=member_id
)
assert snapshot is not None
assert snapshot.agent is not None and snapshot.agent.team_id == _TEAM_ID
captured: dict[str, Any] = {}
real_create_default_tools = asm_module.create_default_tools
async def _spy(*args: Any, **kwargs: Any) -> Any:
result = await real_create_default_tools(*args, **kwargs)
captured["kwargs"] = kwargs
captured["tool_config"] = result[1]
return result
async def _no_tools(config: Any) -> list:
return []
member = db.query(User).filter(User.id == member_id).one()
with (
patch.object(asm_module, "create_default_tools", new=_spy),
patch.object(ToolFactory, "create_all_tools", _no_tools),
patch.object(
manager, "_get_or_create_task_sandbox", AsyncMock(return_value=None)
),
patch.object(manager, "_load_persisted_conversation_history"),
patch.object(manager, "_load_persisted_execution_context", new=AsyncMock()),
patch(
"xagent.web.services.agent_service_manager.create_task_tracer",
return_value=MagicMock(),
),
patch("xagent.web.sandbox_manager.get_sandbox_manager", return_value=None),
patch("xagent.web.services.agent_service_manager.AgentService"),
):
try:
await manager.get_agent_for_task(
task_id=int(task.id),
db=db,
user=member,
task_setup_snapshot=snapshot,
)
except Exception:
# Construction after tool building runs against a mocked
# AgentService; what is asserted was recorded before that.
pass
assert "tool_config" in captured, "tool building was never reached"
tool_config = captured["tool_config"]
configs = await tool_config.get_mcp_server_configs()
return configs, tool_config.get_mcp_oauth_diagnostics(), captured["kwargs"]
@pytest.mark.asyncio
async def test_channel_task_through_snapshot_path_excludes_member_grant(
gate_db,
) -> None:
ids = _team_connector_fixture(gate_db)
server_id = ids["server_id"]
member_id = ids["member_id"]
channel = _channel(gate_db, member_id)
def _team_visibility(db: Any, *, team_id: int) -> dict[str, set[int]]:
if team_id == _TEAM_ID:
return {"mcp": {server_id}, "custom_api": set()}
return {"mcp": set(), "custom_api": set()}
set_agent_team_scope_hook(
lambda db, user_id: (
AgentTeamScope(team_id=_TEAM_ID, is_team_admin=False)
if user_id == member_id
else None
)
)
connector_team_scope.set_connector_team_hooks(team_visibility=_team_visibility)
try:
channel_task = _task(
gate_db,
member_id,
source="internal",
agent_id=ids["agent_id"],
channel_id=int(channel.id),
channel_name=str(channel.channel_name),
)
rebound_task = _task(
gate_db,
member_id,
source="internal",
agent_id=ids["agent_id"],
channel_id=None,
channel_name=str(channel.channel_name),
)
web_task = _task(
gate_db,
member_id,
source="internal",
agent_id=ids["agent_id"],
)
for task in (channel_task, rebound_task):
configs, diagnostics, kwargs = await _build_tools_and_load_mcp(
gate_db, task=task, member_id=member_id
)
assert kwargs["mcp_team_member_grants_allowed"] is False
assert [d.get("code") for d in diagnostics] == [
"grant_not_allowed_for_task_source"
]
assert _MEMBER_TOKEN not in json.dumps(configs, default=str)
configs, diagnostics, kwargs = await _build_tools_and_load_mcp(
gate_db, task=web_task, member_id=member_id
)
assert kwargs["mcp_team_member_grants_allowed"] is True
assert diagnostics == []
assert _MEMBER_TOKEN in json.dumps(configs, default=str)
finally:
set_agent_team_scope_hook(None)
connector_team_scope.set_connector_team_hooks()