feat(sessions): list_sessions 支持 user_id 为 None 时获取全部 session

list_sessions 的 user_id 参数改为可选，传 None 时返回指定 app 下
所有用户的会话列表（不含 events）。InMemory/SQL/Redis/EvalSessionService
实现统一调整，并补充中英文文档用法说明及单元测试。

Author: weimch

docs/mkdocs/en/session.md

@@ -109,11 +109,18 @@ session = await session_service.get_session(
 
 **List Sessions**:
 ```python
+# Specify user_id: returns all sessions for that user (without events)
 session_list = await session_service.list_sessions(
     app_name="my_app",
     user_id="user_001"
 )
-# Returns ListSessionsResponse, containing all sessions for the user (without events)
+
+# user_id=None: returns sessions across all users for the app
+all_session_list = await session_service.list_sessions(
+    app_name="my_app",
+    user_id=None
+)
+# Returns ListSessionsResponse, containing matching sessions (without events)
 ```
 
 **Delete Session**:
@@ -128,7 +135,7 @@ await session_service.delete_session(
 **Implementation Logic** (`_base_session_service.py`):
 - `create_session`: Creates a session, separates and stores app/user/session state
 - `get_session`: Retrieves a session, merges app/user/session state, applies event filtering
-- `list_sessions`: Lists sessions (excludes events to reduce data transfer)
+- `list_sessions`: Lists sessions (excludes events to reduce data transfer); passing `user_id=None` returns sessions across all users for the app
 - `delete_session`: Deletes a session and its associated data
 
 ---
@@ -611,6 +618,7 @@ session = await session_service.get_session(
 )
 
 # List existing Sessions
+# Specify user_id to return that user's sessions; user_id=None returns sessions across all users for the app
 session_list = await session_service.list_sessions(
     app_name=app_name,
     user_id=user_id

docs/mkdocs/zh/session.md

@@ -109,11 +109,18 @@ session = await session_service.get_session(
 
 **列出会话**：
 ```python
+# 指定 user_id：返回该用户的所有会话（不含 events）
 session_list = await session_service.list_sessions(
     app_name="my_app",
     user_id="user_001"
 )
-# 返回 ListSessionsResponse，包含该用户的所有会话（不含 events）
+
+# user_id 为 None：返回该 app 下所有用户的会话
+all_session_list = await session_service.list_sessions(
+    app_name="my_app",
+    user_id=None
+)
+# 返回 ListSessionsResponse，包含符合条件的所有会话（不含 events）
 ```
 
 **删除会话**：
@@ -128,7 +135,7 @@ await session_service.delete_session(
 **实现逻辑**（`_base_session_service.py`）：
 - `create_session`：创建会话，分离并存储 app/user/session 状态
 - `get_session`：获取会话，合并 app/user/session 状态，应用事件过滤
-- `list_sessions`：列出会话列表（不包含 events，减少数据传输）
+- `list_sessions`：列出会话列表（不包含 events，减少数据传输）；`user_id` 传 `None` 时返回该 app 下所有用户的会话
 - `delete_session`：删除会话及其关联数据
 
 ---
@@ -611,6 +618,7 @@ session = await session_service.get_session(
 )
 
 # 列出存在的 Session
+# 指定 user_id 返回该用户的会话；user_id=None 返回该 app 下所有用户的会话
 session_list = await session_service.list_sessions(
     app_name=app_name,
     user_id=user_id

tests/sessions/test_in_memory_session_service.py

@@ -251,6 +251,23 @@ async def test_list_nonexistent_user(self):
         assert result.sessions == []
         await svc.close()
 
+    async def test_list_all_users_when_user_id_none(self):
+        svc = InMemorySessionService(session_config=_make_session_config())
+        await svc.create_session(app_name="app", user_id="user1", session_id="s1")
+        await svc.create_session(app_name="app", user_id="user2", session_id="s2")
+        result = await svc.list_sessions(app_name="app", user_id=None)
+        ids = sorted(s.id for s in result.sessions)
+        assert ids == ["s1", "s2"]
+        await svc.close()
+
+    async def test_list_all_users_filtered_by_app(self):
+        svc = InMemorySessionService(session_config=_make_session_config())
+        await svc.create_session(app_name="app1", user_id="user1", session_id="s1")
+        await svc.create_session(app_name="app2", user_id="user1", session_id="s2")
+        result = await svc.list_sessions(app_name="app1", user_id=None)
+        assert [s.id for s in result.sessions] == ["s1"]
+        await svc.close()
+
 
 # ---------------------------------------------------------------------------
 # InMemorySessionService — delete_session

tests/sessions/test_redis_session_service.py

@@ -210,6 +210,15 @@ async def test_list_sessions_have_no_events(self):
             assert s.historical_events == []
         await svc.close()
 
+    async def test_list_all_users_when_user_id_none(self):
+        svc = _create_service()
+        await svc.create_session(app_name="app", user_id="user1", session_id="s1")
+        await svc.create_session(app_name="app", user_id="user2", session_id="s2")
+        result = await svc.list_sessions(app_name="app", user_id=None)
+        ids = sorted(s.id for s in result.sessions)
+        assert ids == ["s1", "s2"]
+        await svc.close()
+
 
 class TestRedisDeleteSession:
     async def test_delete_existing(self):

tests/sessions/test_sql_session_service.py

@@ -286,6 +286,15 @@ async def test_list_sessions_have_no_events(self):
             assert s.historical_events == []
         await svc.close()
 
+    async def test_list_all_users_when_user_id_none(self):
+        svc = await _create_service()
+        await svc.create_session(app_name="app", user_id="user1", session_id="s1")
+        await svc.create_session(app_name="app", user_id="user2", session_id="s2")
+        result = await svc.list_sessions(app_name="app", user_id=None)
+        ids = sorted(s.id for s in result.sessions)
+        assert ids == ["s1", "s2"]
+        await svc.close()
+
 
 # ---------------------------------------------------------------------------
 # SqlSessionService — delete_session

trpc_agent_sdk/abc/_session_service.py

@@ -92,8 +92,19 @@ async def get_session(
         """Gets a session."""
 
     @abstractmethod
-    async def list_sessions(self, *, app_name: str, user_id: str) -> ListSessionsResponse:
-        """Lists all the sessions."""
+    async def list_sessions(
+        self,
+        *,
+        app_name: str,
+        user_id: Optional[str] = None,
+    ) -> ListSessionsResponse:
+        """Lists all the sessions.
+
+        Args:
+            app_name: the name of the app.
+            user_id: the id of the user. When None, lists sessions across all
+                users for the given app.
+        """
 
     @abstractmethod
     async def delete_session(self, *, app_name: str, user_id: str, session_id: str) -> None:

trpc_agent_sdk/evaluation/_eval_session_service.py

@@ -71,7 +71,7 @@ async def get_session(
         )
 
     @override
-    async def list_sessions(self, *, app_name: str, user_id: str):
+    async def list_sessions(self, *, app_name: str, user_id: Optional[str] = None):
         return await self._inner.list_sessions(app_name=app_name, user_id=user_id)
 
     @override

trpc_agent_sdk/sessions/_in_memory_session_service.py

@@ -183,26 +183,32 @@ async def get_session(
         return self._merge_state(app_state, user_state, copied_session)
 
     @override
-    async def list_sessions(self, *, app_name: str, user_id: str) -> ListSessionsResponse:
+    async def list_sessions(self, *, app_name: str, user_id: Optional[str] = None) -> ListSessionsResponse:
         empty_response = ListSessionsResponse()
-        if app_name not in self._sessions:
+        app_sessions = self._sessions.get(app_name)
+        if not app_sessions:
             return empty_response
-        if user_id not in self._sessions[app_name]:
+
+        if user_id is None:
+            user_sessions = app_sessions
+        elif user_id in app_sessions:
+            user_sessions = {user_id: app_sessions[user_id]}
+        else:
             return empty_response
 
+        app_state = self._get_app_state(app_name)
         sessions_without_events = []
-        for session_id in self._sessions[app_name][user_id].keys():
-            session = self._get_session(app_name, user_id, session_id)
-            if session is None:
-                continue
-
-            copied_session = copy.deepcopy(session)
-            copied_session.events = []
-            copied_session.historical_events = []
-            app_state = self._get_app_state(app_name)
-            user_state = self._get_user_state(app_name, user_id)
-            copied_session = self._merge_state(app_state, user_state, copied_session)
-            sessions_without_events.append(copied_session)
+        for uid, session_dict in user_sessions.items():
+            user_state = self._get_user_state(app_name, uid)
+            for session_id in session_dict.keys():
+                session = self._get_session(app_name, uid, session_id)
+                if session is None:
+                    continue
+
+                copied_session = copy.deepcopy(session)
+                copied_session.events = []
+                copied_session.historical_events = []
+                sessions_without_events.append(self._merge_state(app_state, user_state, copied_session))
         return ListSessionsResponse(sessions=sessions_without_events)
 
     @override

trpc_agent_sdk/sessions/_redis_session_service.py

@@ -36,6 +36,24 @@
 from ._utils import user_state_key
 
 
+def _session_key_prefix(app_name: str, user_id: Optional[str] = None) -> str:
+    """Generate a Redis key prefix for listing sessions.
+
+    When user_id is None, the prefix matches sessions across all users for the
+    given app; otherwise it is scoped to the specific user.
+
+    Args:
+        app_name: Application name
+        user_id: Optional user identifier
+
+    Returns:
+        Formatted session key prefix with a trailing wildcard.
+    """
+    if user_id is None:
+        return f"session:{app_name}:*"
+    return f"session:{app_name}:{user_id}:*"
+
+
 class RedisSessionService(BaseSessionService):
     """A Redis implementation of the session service.
 
@@ -129,18 +147,17 @@ async def get_session(
             return self._merge_state(app_state, user_state, session)
 
     @override
-    async def list_sessions(self, *, app_name: str, user_id: str) -> ListSessionsResponse:
+    async def list_sessions(self, *, app_name: str, user_id: Optional[str] = None) -> ListSessionsResponse:
         async with self._redis_storage.create_db_session() as redis_session:
-            pattern = session_key(app_name, user_id, "*")
+            pattern = _session_key_prefix(app_name, user_id)
             command = RedisCommand(method='keys', args=(pattern, ))
             keys = await self._redis_storage.execute_command(redis_session, command)
 
             if not keys:
                 return ListSessionsResponse()
 
-            # Get app and user state once for all sessions
+            # Get app state once for all sessions
             app_state = await self._get_app_state(redis_session, app_name)
-            user_state = await self._get_user_state(redis_session, app_name, user_id)
 
             sessions_without_events = []
             for key in keys:
@@ -150,6 +167,7 @@ async def list_sessions(self, *, app_name: str, user_id: str) -> ListSessionsRes
                     storage_session.events = []
                     storage_session.historical_events = []
                     # Merge state
+                    user_state = await self._get_user_state(redis_session, app_name, storage_session.user_id)
                     storage_session = self._merge_state(app_state, user_state, storage_session)
                     sessions_without_events.append(storage_session)
 

trpc_agent_sdk/sessions/_sql_session_service.py

@@ -489,15 +489,17 @@ async def get_session(
             return self.filter_events(session)
 
     @override
-    async def list_sessions(self, *, app_name: str, user_id: str) -> ListSessionsResponse:
+    async def list_sessions(self, *, app_name: str, user_id: Optional[str] = None) -> ListSessionsResponse:
         async with self._sql_storage.create_db_session() as sql_session:
-            filters = [StorageSession.app_name == app_name, StorageSession.user_id == user_id]
+            filters = [StorageSession.app_name == app_name]
+            if user_id is not None:
+                filters.append(StorageSession.user_id == user_id)
             conditions = SqlCondition(filters=filters)
-            session_key = SqlKey(key=(app_name, user_id), storage_cls=StorageSession)
+            session_key = SqlKey(key=(app_name, user_id) if user_id is not None else (app_name,),
+                                 storage_cls=StorageSession)
             results: List[StorageSession] = await self._sql_storage.query(sql_session, session_key, conditions)
 
             app_state = await self._get_app_state(sql_session, app_name)
-            user_state = await self._get_user_state(sql_session, app_name, user_id)
 
             sessions = []
             for storage_session in results:
@@ -508,6 +510,7 @@ async def list_sessions(self, *, app_name: str, user_id: str) -> ListSessionsRes
 
                 storage_session.events = []
 
+                user_state = await self._get_user_state(sql_session, app_name, storage_session.user_id)
                 merged_state = merge_state(
                     StateStorageEntry(app_state_delta=app_state,
                                       user_state_delta=user_state,