Build and run agents you can see, understand and trust.
Python agentchatbotlarge-language-modelsllmllm-agentmcpmulti-agentmulti-modalreact-agentrealtime-agentvoice-agentvoice-assistant
fix(app): support cross-owner agent invites (#2326)
logicwu0ff8697ec4d59
diff --git a/src/agentscope/app/_router/_session.py b/src/agentscope/app/_router/_session.pyindex 4f4add0f1..34b620c9e 100644--- a/src/agentscope/app/_router/_session.py+++ b/src/agentscope/app/_router/_session.py@@ -59,6 +59,7 @@ from ..workspace_manager import WorkspaceManagerBaseasync def _build_team_detail(storage: StorageBase,+ access: ResourceAccessService,user_id: str,team: TeamRecord,) -> TeamDetailResponse:@@ -69,6 +70,8 @@ async def _build_team_detail(storage (`StorageBase`):Application storage. Used to look up the leader session,each member agent, and each member's session.+ access (`ResourceAccessService`):+ Resolves roster agents against the viewer's current grants.user_id (`str`):The owner user id.team (`TeamRecord`):@@ -91,8 +94,8 @@ async def _build_team_detail(members: list[TeamMemberView] = []for member in await _ensure_team_members(storage, user_id, team):- agent = await storage.get_agent(member.owner_id, member.agent_id)- if agent is None:+ agent = await access.try_resolve_agent(user_id, member.agent_id)+ if agent is None or agent.user_id != member.owner_id:continue# Use the member's team-scoped session id directly; an invited# agent has multiple sessions and only ``member.session_id``@@ -243,6 +246,7 @@ async def list_sessions(if team_record is not None:team_detail = await _build_team_detail(storage,+ access,user_id,team_record,)diff --git a/src/agentscope/app/_service/_access.py b/src/agentscope/app/_service/_access.pyindex 8e4101d33..4f4fce042 100644--- a/src/agentscope/app/_service/_access.py+++ b/src/agentscope/app/_service/_access.py@@ -412,6 +412,22 @@ class ResourceAccessService:``source == "user"`` agents since team workers are notshareable."""+ record = await self.try_resolve_agent(viewer_id, agent_id)+ if record is None:+ raise self._not_found(ResourceKind.AGENT, agent_id)+ return record++ async def try_resolve_agent(+ self,+ viewer_id: str,+ agent_id: str,+ ) -> AgentRecord | None:+ """Resolve an agent for runtime use, returning ``None`` when hidden.++ This is the non-raising counterpart of :meth:`resolve_agent` for+ stale references such as team rosters or toolkit snapshots. Owner+ reads include team workers; cross-owner refs only resolve user agents.+ """record = await self._storage.get_agent(viewer_id, agent_id)if record is not None:return record@@ -425,7 +441,7 @@ class ResourceAccessService:)if record is not None and record.source != "team":return record- raise self._not_found(ResourceKind.AGENT, agent_id)+ return Noneasync def resolve_knowledge_base(self,diff --git a/src/agentscope/app/_service/_session.py b/src/agentscope/app/_service/_session.pyindex 99f926299..2037489f0 100644--- a/src/agentscope/app/_service/_session.py+++ b/src/agentscope/app/_service/_session.py@@ -436,7 +436,8 @@ class SessionService:are fully removed.- ``role == "invited"``: the member is a pre-existing user-ownedagent borrowed via ``AgentInvite``. Only the borrowed- team-scoped session is removed; the underlying+ team-scoped session in the team owner's namespace is removed;+ the underlying:class:`AgentRecord` and its other sessions survive.The leader's own session is **not** deleted — teams dissolve,@@ -463,7 +464,7 @@ class SessionService:await self.delete_agent(member.owner_id, member.agent_id)else: # invitedawait self.delete_session(- member.owner_id,+ user_id,member.agent_id,member.session_id,)diff --git a/src/agentscope/app/_service/_toolkit.py b/src/agentscope/app/_service/_toolkit.pyindex 5281e1bae..13b434693 100644--- a/src/agentscope/app/_service/_toolkit.py+++ b/src/agentscope/app/_service/_toolkit.py@@ -216,6 +216,7 @@ time or interval"AgentInvite(**team_tool_kwargs,invitable_pool=invitable_pool,+ resource_access_service=resource_access_service,),)diff --git a/src/agentscope/app/_tool/_agent_invite.py b/src/agentscope/app/_tool/_agent_invite.pyindex 251d9f636..ba461de32 100644--- a/src/agentscope/app/_tool/_agent_invite.py+++ b/src/agentscope/app/_tool/_agent_invite.py@@ -5,10 +5,10 @@ Unlike :class:`AgentCreate`, which spawns a brand-new worker(``source='team'``) from a :class:`SubAgentTemplate`, this tool**borrows** a pre-existing user-owned agent by minting a freshteam-scoped :class:`SessionRecord` on top of the *existing*-:class:`AgentRecord`. The borrowed agent keeps its system prompt,-context/react configs, workspace, MCP, skills, and model choice; only-a new session is created so it can hold a parallel conversation for-the team.+:class:`AgentRecord`. The borrowed agent keeps its definition, including+its system prompt and context/react configs. Workspace and model are taken+from the *caller's* own session of that agent, so a cross-owner borrow+never picks up the owner's MCPs, skills, cache, or session permissions.When the team is dissolved or the leader is deleted, only the borrowedsession is cleaned up — the underlying :class:`AgentRecord` survives@@ -34,6 +34,7 @@ from ..._utils._common import _generate_idif TYPE_CHECKING:from ..message_bus import MessageBus+ from .._service._access import ResourceAccessServicefrom ..storage import AgentRecord, StorageBasefrom ..workspace_manager import WorkspaceManagerBase@@ -168,6 +169,7 @@ class AgentInvite(_TeamToolBase):session_id: str,agent_id: str,invitable_pool: list["AgentRecord"],+ resource_access_service: "ResourceAccessService | None" = None,) -> None:"""Bind the base dependencies plus the invitable pool snapshot.@@ -187,7 +189,13 @@ class AgentInvite(_TeamToolBase):The calling agent id.invitable_pool (`list[AgentRecord]`):Snapshot of currently-invitable agents. Must be- non-empty — the caller skips construction otherwise.+ non-empty — the caller skips construction otherwise. When+ no access service is supplied, the constructor is responsible+ for ensuring every snapshot entry is safe for the caller.+ resource_access_service (`ResourceAccessService | None`):+ Resolves the selected agent against the caller's current+ access grants. ``None`` preserves direct construction for+ owner-only integrations."""super().__init__(storage,@@ -201,6 +209,7 @@ class AgentInvite(_TeamToolBase):self._pool_by_id: dict[str, "AgentRecord"] = {a.id: a for a in invitable_pool}+ self._resource_access_service = resource_access_service# Build enum + a human-readable per-target rundown for the LLM.enum_values = [@@ -266,12 +275,24 @@ class AgentInvite(_TeamToolBase):team = await self._require_leader_team("invite members")- # Re-fetch fresh — the snapshot could be stale if the user- # just toggled the invite off.- fresh = await self._storage.get_agent(- self._user_id,- invited.id,- )+ # Re-fetch fresh — both the invite settings and a cross-owner+ # access grant may have changed since the toolkit snapshot+ # was assembled. Without an access service the pool is+ # trusted to hold only entries the caller may use.+ access = self._resource_access_service+ if access is None:+ fresh = await self._storage.get_agent(+ invited.user_id,+ invited.id,+ )+ else:+ fresh = await access.try_resolve_agent(+ self._user_id,+ invited.id,+ )+ # Same id under a different owner is a different agent.+ if fresh is not None and fresh.user_id != invited.user_id:+ fresh = Noneif (fresh is Noneor not fresh.data.invite_config.invitable@@ -321,13 +342,11 @@ class AgentInvite(_TeamToolBase):# not block the invite.leader_name = leader.name if leader else leader_session.agent_id- # Prefer the invited agent's own primary session for- # workspace + chat-model reuse: it already has any MCP /- # skills / cache set up. Fall back to a freshly-generated- # workspace id + the leader's chat model when the agent has- # never been opened — the underlying workspace is created- # lazily by the workspace manager on first chat, so a bare- # id is enough.+ # Reuse the caller's own primary session of this agent for+ # workspace + model, else a fresh workspace and the leader's+ # model. The lookup is caller-scoped, so a cross-owner borrow+ # never reuses the owner's session, MCPs, skills, or cache.+ # The workspace is created lazily on first chat.invited_sessions = await self._storage.list_sessions(self._user_id,invited.id,@@ -402,7 +421,7 @@ class AgentInvite(_TeamToolBase):team.data.members = [*existing_members,TeamMember(- owner_id=self._user_id,+ owner_id=invited.user_id,agent_id=invited.id,session_id=borrowed.id,role="invited",diff --git a/src/agentscope/app/storage/_base.py b/src/agentscope/app/storage/_base.pyindex 760a6b158..6c4027ba4 100644--- a/src/agentscope/app/storage/_base.py+++ b/src/agentscope/app/storage/_base.py@@ -864,7 +864,8 @@ class StorageBase(ABC):is fully removed because it was spawned solely for thisteam.- ``role == "invited"`` — call :meth:`delete_session` for- the borrowed team-scoped session only. The invited+ the borrowed team-scoped session under the team owner's+ namespace only. The invitedagent's :class:`AgentRecord` and any other sessions itowns survive the team's dissolution.2. Clear ``team_id`` on the leader session referenced bydiff --git a/src/agentscope/app/storage/_model/_team.py b/src/agentscope/app/storage/_model/_team.pyindex 235c176b6..67f31afb7 100644--- a/src/agentscope/app/storage/_model/_team.py+++ b/src/agentscope/app/storage/_model/_team.py@@ -22,13 +22,9 @@ class TeamMember(BaseModel):owner_id: str = Field(description=(- "Owner of the member's agent. Always equals the team owner "- "in today's user-only invite pool, but is stored explicitly "- "so a future admin-share layer (agents borrowed across users) "- "can slot in without a schema migration. Distinct name from "- ":attr:`TeamRecord.user_id` on purpose — the surrounding "- "team already carries the team owner in context, so calling "- "this field ``user_id`` too would be ambiguous."+ "Owner of the member's agent definition. For a cross-owner "+ "invited member this differs from the team owner; its borrowed "+ "session still belongs to :attr:`TeamRecord.user_id`."),)@@ -41,8 +37,8 @@ class TeamMember(BaseModel):"The team-scoped session id for this member. For ``created`` ""members this is the sole session (1:1 with the agent). For ""``invited`` members this is the freshly-minted session that "- "``AgentInvite`` created — the agent's other sessions are "- "unrelated to this team."+ "``AgentInvite`` created in the team owner's namespace — the "+ "agent owner's other sessions are unrelated to this team."),)diff --git a/src/agentscope/app/storage/_redis_storage.py b/src/agentscope/app/storage/_redis_storage.pyindex 4115fadb1..352957780 100644--- a/src/agentscope/app/storage/_redis_storage.py+++ b/src/agentscope/app/storage/_redis_storage.py@@ -1707,7 +1707,8 @@ class RedisStorage(StorageBase):worker's session.- ``role == "invited"`` — the member is a pre-existinguser-owned agent that was borrowed via ``AgentInvite``.- Only remove the team-scoped session via+ Only remove the team-scoped session from the team owner's+ namespace via:meth:`delete_session`; the underlying:class:`AgentRecord` and its other sessions must survive.@@ -1754,7 +1755,7 @@ class RedisStorage(StorageBase):await self.delete_agent(member.owner_id, member.agent_id)else: # invitedawait self.delete_session(- member.owner_id,+ user_id,member.agent_id,member.session_id,)diff --git a/src/agentscope/app/storage/_sql/_storage.py b/src/agentscope/app/storage/_sql/_storage.pyindex a9697e096..d760a4476 100644--- a/src/agentscope/app/storage/_sql/_storage.py+++ b/src/agentscope/app/storage/_sql/_storage.py@@ -645,7 +645,7 @@ class AsyncSQLAlchemyStorage(StorageBase):else: # invited — only the borrowed session goesawait self._delete_session_impl(sess,- member.owner_id,+ user_id,member.agent_id,member.session_id,)diff --git a/tests/resource_access_policy_test.py b/tests/resource_access_policy_test.pyindex a6b833bff..9fe8907b0 100644--- a/tests/resource_access_policy_test.py+++ b/tests/resource_access_policy_test.py@@ -369,6 +369,14 @@ class ResourceAccessServiceTest(IsolatedAsyncioTestCase):},)+ async def test_try_resolve_agent_returns_none_when_not_visible(+ self,+ ) -> None:+ """Non-raising resolution should represent hidden agents as None."""+ agent = await self.service.try_resolve_agent("other", "agent-1")++ self.assertIsNone(agent)+async def test_list_agents_skips_shared_team_agents(self) -> None:"""Cross-owner team agents should not appear in shared lists."""views = await self.service.list_resource(diff --git a/tests/service_team_tools_test.py b/tests/service_team_tools_test.pyindex f71eb9337..3666bbfdf 100644--- a/tests/service_team_tools_test.py+++ b/tests/service_team_tools_test.py@@ -31,6 +31,13 @@ from agentscope.app._tool import (TeamSay,)from agentscope.app._types import SubAgentTemplate+from agentscope.app._router._session import _build_team_detail+from agentscope.app._service import ResourceAccessService+from agentscope.app.access import (+ ResourceAccessPolicyBase,+ ResourceKind,+ ResourceRef,+)from agentscope.app.message_bus import RedisMessageBusfrom agentscope.app.storage import (TeamOrigin,@@ -39,7 +46,9 @@ from agentscope.app.storage import (AgentRecord,RedisStorage,SessionConfig,+ StorageBase,)+from agentscope.message import ToolResultStatefrom agentscope.permission import (AdditionalWorkingDirectory,PermissionBehavior,@@ -102,6 +111,31 @@ def _make_agent_record()+class _SharedAgentPolicy(ResourceAccessPolicyBase):+ """Mutable sharing policy used to exercise grant revocation."""++ def __init__(self, owner_id: str, agent_id: str) -> None:+ self.owner_id = owner_id+ self.agent_id = agent_id+ self.allowed = True++ async def list_accessible(+ self,+ viewer_id: str,+ kind: ResourceKind,+ storage: StorageBase,+ ) -> list[ResourceRef]:+ if not self.allowed or kind != ResourceKind.AGENT:+ return []+ return [+ ResourceRef(+ kind=ResourceKind.AGENT,+ owner_id=self.owner_id,+ resource_id=self.agent_id,+ ),+ ]++class _TeamToolsTestBase(IsolatedAsyncioTestCase):"""Shared fixture: a fakeredis-backed storage + bus, a leaderagent record, and a leader session.@@ -1476,6 +1510,178 @@ class TestAgentInviteSuccess(_AgentInviteTestBase):self.assertEqual(primary_inbox, [])+class TestAgentInviteCrossOwner(_AgentInviteTestBase):+ """A viewer can invite an agent exposed by the access policy."""++ async def _make_shared_agent(+ self,+ ) -> tuple[AgentRecord, _SharedAgentPolicy, ResourceAccessService]:+ """Store a shared agent and expose it through a mutable policy."""+ from agentscope.app.storage._model._agent import InviteConfig++ shared_owner = "platform-owner"+ shared_agent = AgentRecord(+ user_id=shared_owner,+ source="user",+ data=AgentData(+ name="Shared Specialist",+ system_prompt="I am a shared specialist.",+ context_config=ContextConfig(),+ react_config=ReActConfig(),+ invite_config=InviteConfig(+ invitable=True,+ invite_description="Shared expert.",+ ),+ ),+ )+ await self.storage.upsert_agent(shared_owner, shared_agent)+ await self.storage.upsert_session(+ user_id=shared_owner,+ agent_id=shared_agent.id,+ config=SessionConfig(workspace_id="owner-private-workspace"),+ )+ policy = _SharedAgentPolicy(shared_owner, shared_agent.id)+ access = ResourceAccessService(self.storage, policy)+ return shared_agent, policy, access++ async def test_invites_shared_agent(self) -> None:+ """The borrowed session belongs to the viewer, while the team+ roster preserves the shared agent definition's real owner."""+ shared_agent, _policy, access = await self._make_shared_agent()+ pool = await access.list_resource(self.user_id, ResourceKind.AGENT)++ tool = AgentInvite(+ storage=self.storage,+ message_bus=self.bus,+ workspace_manager=self.workspace_manager,+ user_id=self.user_id,+ session_id=self.leader_session.id,+ agent_id=self.leader_agent.id,+ invitable_pool=pool,+ resource_access_service=access,+ )++ chunk = await tool(+ target=f"Shared Specialist@{shared_agent.id[:8]}",+ prompt="Please handle this.",+ )++ self.assertNotEqual(+ chunk.state,+ ToolResultState.ERROR,+ chunk.content[0].text,+ )++ leader = await self.storage.get_session(+ self.user_id,+ self.leader_agent.id,+ self.leader_session.id,+ )+ team = await self.storage.get_team(self.user_id, leader.team_id)+ member = team.data.members[0]+ self.assertEqual(member.owner_id, shared_agent.user_id)++ borrowed = await self.storage.get_session(+ self.user_id,+ shared_agent.id,+ member.session_id,+ )+ self.assertIsNotNone(borrowed)+ self.assertNotEqual(+ borrowed.config.workspace_id,+ "owner-private-workspace",+ )+ self.assertIsNone(+ await self.storage.get_session(+ shared_agent.user_id,+ shared_agent.id,+ member.session_id,+ ),+ )++ await TeamDelete(+ storage=self.storage,+ message_bus=self.bus,+ workspace_manager=self.workspace_manager,+ user_id=self.user_id,+ session_id=self.leader_session.id,+ agent_id=self.leader_agent.id,+ )()+ self.assertIsNone(+ await self.storage.get_session(+ self.user_id,+ shared_agent.id,+ member.session_id,+ ),+ )+ self.assertIsNotNone(+ await self.storage.get_agent(+ shared_agent.user_id,+ shared_agent.id,+ ),+ )++ async def test_rejects_shared_agent_after_access_revoked(self) -> None:+ """Invocation rechecks a share captured in the toolkit snapshot."""+ shared_agent, policy, access = await self._make_shared_agent()+ pool = await access.list_resource(self.user_id, ResourceKind.AGENT)+ tool = AgentInvite(+ storage=self.storage,+ message_bus=self.bus,+ workspace_manager=self.workspace_manager,+ user_id=self.user_id,+ session_id=self.leader_session.id,+ agent_id=self.leader_agent.id,+ invitable_pool=pool,+ resource_access_service=access,+ )+ policy.allowed = False++ chunk = await tool(+ target=f"Shared Specialist@{shared_agent.id[:8]}",+ prompt="Please handle this.",+ )++ self.assertEqual(chunk.state, ToolResultState.ERROR)+ self.assertIn("no longer invitable", chunk.content[0].text)++ async def test_revoked_agent_is_hidden_from_team_detail(self) -> None:+ """A stale roster must not bypass a revoked cross-owner grant."""+ shared_agent, policy, access = await self._make_shared_agent()+ pool = await access.list_resource(self.user_id, ResourceKind.AGENT)+ invite = AgentInvite(+ storage=self.storage,+ message_bus=self.bus,+ workspace_manager=self.workspace_manager,+ user_id=self.user_id,+ session_id=self.leader_session.id,+ agent_id=self.leader_agent.id,+ invitable_pool=pool,+ resource_access_service=access,+ )+ result = await invite(+ target=f"Shared Specialist@{shared_agent.id[:8]}",+ prompt="Please handle this.",+ )+ self.assertNotEqual(result.state, ToolResultState.ERROR)++ leader = await self.storage.get_session(+ self.user_id,+ self.leader_agent.id,+ self.leader_session.id,+ )+ team = await self.storage.get_team(self.user_id, leader.team_id)+ policy.allowed = False++ detail = await _build_team_detail(+ self.storage,+ access,+ self.user_id,+ team,+ )+ self.assertEqual(detail.members, [])++class TestAgentInviteRejections(_AgentInviteTestBase):"""``AgentInvite`` rejects the obvious bad inputs / states."""diff --git a/tests/storage_redis_test.py b/tests/storage_redis_test.pyindex faeb85d8f..5e0bba412 100644--- a/tests/storage_redis_test.py+++ b/tests/storage_redis_test.py@@ -17,6 +17,7 @@ from agentscope.app.storage import (ChannelOrigin,ScheduleOrigin,TeamData,+ TeamMember,TeamRecord,)from agentscope.app.storage import MCPRecord, SkillRecord@@ -1133,6 +1134,55 @@ class TestTeamCascade(IsolatedAsyncioTestCase):self.assertIsNotNone(leader)self.assertIsNone(leader.team_id)+ async def test_delete_team_removes_cross_owner_borrowed_session(+ self,+ ) -> None:+ """An invited definition owner differs from its session owner."""+ definition_owner = "user-2"+ invited = make_agent_record(definition_owner)+ await self.storage.upsert_agent(definition_owner, invited)+ owner_session = await self.storage.upsert_session(+ definition_owner,+ invited.id,+ make_session_config("owner-private-workspace"),+ )+ borrowed = await self.storage.upsert_session(+ self.user_id,+ invited.id,+ make_session_config("viewer-borrowed-workspace"),+ )+ self.team.data.members = [+ TeamMember(+ owner_id=definition_owner,+ agent_id=invited.id,+ session_id=borrowed.id,+ role="invited",+ ),+ ]+ self.team.data.member_ids = [invited.id]+ await self.storage.upsert_team(self.user_id, self.team)++ self.assertTrue(+ await self.storage.delete_team(self.user_id, self.team.id),+ )+ self.assertIsNone(+ await self.storage.get_session(+ self.user_id,+ invited.id,+ borrowed.id,+ ),+ )+ self.assertIsNotNone(+ await self.storage.get_session(+ definition_owner,+ invited.id,+ owner_session.id,+ ),+ )+ self.assertIsNotNone(+ await self.storage.get_agent(definition_owner, invited.id),+ )+async def test_delete_leader_session_dissolves_team(self) -> None:"""Deleting a leader session auto-dissolves its team."""await self.storage.delete_session(diff --git a/tests/storage_sql_test.py b/tests/storage_sql_test.pyindex 0d2224fce..fdf74367f 100644--- a/tests/storage_sql_test.py+++ b/tests/storage_sql_test.py@@ -499,10 +499,11 @@ class AsyncSQLAlchemyStorageTest(IsolatedAsyncioTestCase):# another that will be "invited".created_agent = _agent_record("user-1", "created")created_agent.source = "team"- invited_agent = _agent_record("user-1", "invited")+ invited_owner = "user-2"+ invited_agent = _agent_record(invited_owner, "invited")await self.storage.upsert_agent("user-1", created_agent)- await self.storage.upsert_agent("user-1", invited_agent)+ await self.storage.upsert_agent(invited_owner, invited_agent)# Sessions for both, plus the leader session.leader = await self.storage.upsert_session(@@ -521,7 +522,7 @@ class AsyncSQLAlchemyStorageTest(IsolatedAsyncioTestCase):config=_session_config(),)surviving_session = await self.storage.upsert_session(- user_id="user-1",+ user_id=invited_owner,agent_id=invited_agent.id,config=_session_config(),)@@ -539,7 +540,7 @@ class AsyncSQLAlchemyStorageTest(IsolatedAsyncioTestCase):role="created",),TeamMember(- owner_id="user-1",+ owner_id=invited_owner,agent_id=invited_agent.id,session_id=invited_session.id,role="invited",@@ -564,7 +565,7 @@ class AsyncSQLAlchemyStorageTest(IsolatedAsyncioTestCase):)# Invited member: agent survives, only the invited session is gone.self.assertIsNotNone(- await self.storage.get_agent("user-1", invited_agent.id),+ await self.storage.get_agent(invited_owner, invited_agent.id),)self.assertIsNone(await self.storage.get_session(@@ -575,7 +576,7 @@ class AsyncSQLAlchemyStorageTest(IsolatedAsyncioTestCase):)self.assertIsNotNone(await self.storage.get_session(- "user-1",+ invited_owner,invited_agent.id,surviving_session.id,),