📝(legal) update terms of service

Update terms of service content after legal review

CHANGELOG.md

@@ -13,20 +13,22 @@ and this project adheres to
 - ✨(summary) report exception type in failure analytics
 - ✨(frontend) add configurable documentation menu item
 
+### Changed
+
+- ⬆️(frontend) upgrade @mediapipe/tasks-vision from 0.10.14 to 0.10.35
+- ⬆️(frontend) upgrade i18next from 26.3.1 to 26.3.4
+- ⬆️(frontend) upgrade posthog-js from 1.391.2 to 1.395.0
+- ⬆️(frontend) upgrade @tanstack/react-query from 5.101.0 to 5.101.1
+- ⬆️(frontend) upgrade livekit-client from 2.19.2 to 2.20.0
+- ⚡️(frontend) limit unnecessary re-renders #1510
+- 📝(legal) update terms of service
+
 ## Fixed
 
 - 🐛(transcription) fix silent bug in speaker assignment
 - 🐛(summary) extend tasks auto retry logic
 - 🐛(summary) properly detect when failure webhook should be sent
-
-### Changed
-
-- ⬆️(frontend) upgrade @mediapipe/tasks-vision from 0.10.14 to 0.10.35
-- ⬆️(frontend) upgrade i18next from 26.3.1 to 26.3.2
-- ⬆️(frontend) upgrade posthog-js from 1.391.2 to 1.395.0
-- ⬆️(frontend) upgrade @tanstack/react-query from 5.101.0 to 5.101.1
-- ⬆️(frontend) upgrade livekit-client from 2.19.2 to 2.20.0
-- ⚡️(frontend) limit unnecessary re-renders #1510
+- 🐛(backend) preserve recording metadata when updating room access
 
 ## [1.24.0] - 2026-07-21
 

publiccode.yml

@@ -0,0 +1,52 @@
+publiccodeYmlVersion: 0.5.0
+name: LaSuite Meet
+applicationSuite: LaSuite
+url: https://github.com/suitenumerique/meet
+releaseDate: 2026-07-22
+platforms:
+  - web
+organisation:
+  name: DINUM
+  uri: https://numerique.gouv.fr
+fundedBy:
+  - name: Direction interministérielle du numérique (DINUM)
+    uri: https://www.numerique.gouv.fr
+developmentStatus: stable
+softwareType: standalone/web
+intendedAudience:
+  countries:
+    - FR
+description:
+  en:
+    localisedName: LaSuite Meet
+    shortDescription: "Open Source video conference solution, based on LiveKit"
+    longDescription: "Open Source video conference application, based on LiveKit,
+      Django and React. It is the official web video conference application of
+      French Ministries."
+    features:
+      - Optimized for stability in large meetings (+100 p.)
+      - Support for multiple screen sharing streams
+      - Non-persistent, secure chat
+      - Meeting recording
+      - Meeting transcription & Summary
+      - Telephony integration
+      - Secure participation with robust authentication and access control
+      - Customizable frontend style
+legal:
+  license: MIT
+maintenance:
+  type: internal
+  contacts:
+    - name: "Samuel Paccoud"
+      email: samuel.paccoud@numerique.gouv.fr
+      affiliation: DINUM
+    - name: "Antoine Lebaud"
+      email: antoine.lebaud.ext@numerique.gouv.fr
+      affiliation: DINUM
+localisation:
+  localisationReady: true
+  availableLanguages:
+    - fr
+    - de
+    - en
+    - nl

src/addons/outlook/package-lock.json

@@ -10,7 +10,7 @@
       "license": "MIT",
       "dependencies": {
         "core-js": "3.49.0",
-        "i18next": "^26.3.2",
+        "i18next": "^26.3.4",
         "i18next-browser-languagedetector": "8.2.1",
         "regenerator-runtime": "0.14.1"
       },
@@ -9364,9 +9364,9 @@
       }
     },
     "node_modules/i18next": {
-      "version": "26.3.2",
-      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.3.2.tgz",
-      "integrity": "sha512-QQkXAM1sPDHqhxMQuBeHVMUn6mJchF+wdpOoQerciLAFqO3ZYdxO0EUbeEhruyutnNwpUQIITDVzLjwnNL0T1w==",
+      "version": "26.3.4",
+      "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.3.4.tgz",
+      "integrity": "sha512-pa7m0d7pBDqGHZxljT+WPFeyFgQ7P7SciPPo1tTqYuO0z4sqADYhwnBESmmGp/wEof1inwdls/k8ZgTg8rxFHA==",
       "funding": [
         {
           "type": "individual",

src/addons/outlook/package.json

@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "core-js": "3.49.0",
-    "i18next": "26.3.2",
+    "i18next": "26.3.4",
     "i18next-browser-languagedetector": "8.2.1",
     "regenerator-runtime": "0.14.1"
   },

src/backend/core/api/permissions.py

@@ -6,11 +6,6 @@ from django.http import Http404
 from rest_framework import permissions
 
 from ..models import RoleChoices
-from ..services.participants_management import (
-    ParticipantNotFoundException,
-    ParticipantsManagement,
-    ParticipantsManagementException,
-)
 
 ACTION_FOR_METHOD_TO_PERMISSION = {
     "versions_detail": {"DELETE": "versions_destroy", "GET": "versions_retrieve"}
@@ -171,30 +166,3 @@ class CanMuteParticipant(permissions.BasePermission):
 
         # LiveKit token scoped to this room
         return request.auth.video.room == str(obj.id)
-
-
-class IsPresentInMeeting(permissions.BasePermission):
-    """Check that the requesting user is currently connected to the meeting.
-
-    The requester must be session-authenticated (their DB identity is needed
-    to check privileges); presence is verified against LiveKit using their
-    `sub` as participant identity. Fails closed on LiveKit errors.
-    """
-
-    message = "You must be connected to the meeting to perform this action."
-
-    def has_object_permission(self, request, view, obj):
-        """Verify the requester's identity is a participant of the room."""
-        user = request.user
-
-        if not user or not user.is_authenticated:
-            return False
-
-        try:
-            return ParticipantsManagement().check_if_in_meeting(
-                room_name=str(obj.pk), identity=str(user.sub)
-            )
-        except ParticipantNotFoundException:
-            return False
-        except ParticipantsManagementException:
-            return False

src/backend/core/api/serializers.py

@@ -183,12 +183,13 @@ class RoomSerializer(serializers.ModelSerializer):
                 user=request.user,
                 username=username,
                 configuration=output["configuration"],
-                role=role,
-                is_authenticated=request.user.is_authenticated,
+                is_admin_or_owner=is_admin_or_owner,
             )
         else:
             del output["pin_code"]
 
+        output["is_administrable"] = is_admin_or_owner
+
         return output
 
 
@@ -298,8 +299,8 @@ class RoomInviteSerializer(serializers.Serializer):
 class BaseParticipantsManagementSerializer(BaseValidationOnlySerializer):
     """Base serializer for participant management operations."""
 
-    participant_identity = serializers.CharField(
-        help_text="LiveKit participant identity (matching the user's sub format)"
+    participant_identity = serializers.UUIDField(
+        help_text="LiveKit participant identity (UUID format)"
     )
 
 
@@ -311,15 +312,6 @@ class MuteParticipantSerializer(BaseParticipantsManagementSerializer):
     )
 
 
-class ParticipantRoleSerializer(BaseParticipantsManagementSerializer):
-    """Validate an in-meeting role change (promotion/demotion) request."""
-
-    role = serializers.ChoiceField(
-        choices=[models.RoleChoices.MEMBER, models.RoleChoices.ADMIN],
-        help_text="Target role. Ownership cannot be granted this way.",
-    )
-
-
 TrackSource = Literal["camera", "microphone", "screen_share", "screen_share_audio"]
 
 

src/backend/core/api/viewsets.py

@@ -88,10 +88,6 @@ from core.services.room_management import (
     RoomManagementException,
     RoomNotFoundException,
 )
-from core.services.room_roles import (
-    RoomRoleError,
-    RoomRoleService,
-)
 from core.services.subtitle import SubtitleException, SubtitleService
 from core.tasks.file import process_file_deletion
 
@@ -643,53 +639,6 @@ class RoomViewSet(
             status=drf_status.HTTP_200_OK,
         )
 
-    @decorators.action(
-        detail=True,
-        methods=["post"],
-        url_path="update-participant-role",
-        permission_classes=[
-            permissions.HasPrivilegesOnRoom,
-            permissions.IsPresentInMeeting,
-        ],
-    )
-    def update_participant_role(self, request, pk=None):  # pylint: disable=unused-argument
-        """Promote or demote a participant currently connected to the meeting.
-
-        Requires the requester to be session-authenticated, have privileges
-        (admin/owner) on the room, and be connected to the meeting.
-
-        If the target participant has a user account, the role is persisted
-        (`ResourceAccess`) then mirrored to their LiveKit attributes.
-
-        If the participant is anonymous, the promotion will fail.
-        """
-
-        room = self.get_object()
-
-        serializer = serializers.ParticipantRoleSerializer(data=request.data)
-        serializer.is_valid(raise_exception=True)
-
-        participant_identity = serializer.validated_data["participant_identity"]
-        role = serializer.validated_data["role"]
-
-        if str(request.user.sub) == str(participant_identity):
-            return drf_response.Response(
-                {"error": "You cannot change your own role."},
-                status=drf_status.HTTP_403_FORBIDDEN,
-            )
-
-        try:
-            result = RoomRoleService().set_participant_role(
-                room=room,
-                participant_identity=participant_identity,
-                role=role,
-                actor=request.user,
-            )
-        except RoomRoleError as e:
-            return drf_response.Response({"error": str(e)}, status=e.status_code)
-
-        return drf_response.Response(result, status=drf_status.HTTP_200_OK)
-
     @decorators.action(
         detail=True,
         methods=["post"],

src/backend/core/recording/services/recording_events.py

@@ -9,6 +9,11 @@ from livekit import api
 from core import models, utils
 from core.models import Recording
 from core.recording.event.notification import notification_service
+from core.services.room_management import (
+    RoomManagement,
+    RoomManagementException,
+    RoomNotFoundException,
+)
 
 logger = getLogger(__name__)
 
@@ -39,10 +44,15 @@ class RecordingEventsService:
         recording_status = status_mapping.get(egress_status)
         if recording_status:
             try:
-                utils.update_room_metadata(
+                RoomManagement().update_metadata(
                     room_name, {"recording_status": recording_status}
                 )
-            except utils.MetadataUpdateException as e:
+            except RoomNotFoundException:
+                logger.info(
+                    "LiveKit room %s no longer exists, skipping metadata update",
+                    room_name,
+                )
+            except RoomManagementException as e:
                 logger.exception("Failed to update room's metadata: %s", e)
 
     @staticmethod

src/backend/core/recording/worker/mediator.py

@@ -2,8 +2,12 @@
 
 import logging
 
-from core import utils
 from core.models import Recording, RecordingStatusChoices
+from core.services.room_management import (
+    RoomManagement,
+    RoomManagementException,
+    RoomNotFoundException,
+)
 
 from .exceptions import (
     RecordingStartError,
@@ -64,10 +68,15 @@ class WorkerServiceMediator:
         mode = recording.options.get("original_mode", None) or recording.mode
 
         try:
-            utils.update_room_metadata(
+            RoomManagement().update_metadata(
                 room_name, {"recording_mode": mode, "recording_status": "starting"}
             )
-        except utils.MetadataUpdateException as e:
+        except RoomNotFoundException:
+            logger.info(
+                "LiveKit room %s no longer exists, skipping metadata update",
+                room_name,
+            )
+        except RoomManagementException as e:
             logger.exception("Failed to update room's metadata: %s", e)
 
         logger.info(

src/backend/core/services/livekit_events.py

@@ -11,7 +11,7 @@ from django.conf import settings
 
 from livekit import api
 
-from core import models, utils
+from core import models
 from core.recording.services.metadata_collector import (
     MetadataCollectorException,
     MetadataCollectorService,
@@ -23,6 +23,11 @@ from core.recording.services.recording_events import (
 )
 
 from .lobby import LobbyService
+from .room_management import (
+    RoomManagement,
+    RoomManagementException,
+    RoomNotFoundException,
+)
 from .telephony import TelephonyException, TelephonyService
 
 logger = getLogger(__name__)
@@ -177,10 +182,15 @@ class LiveKitEventsService:
 
         try:
             room_name = str(recording.room.id)
-            utils.update_room_metadata(
-                room_name, {}, ["recording_mode", "recording_status"]
+            RoomManagement().update_metadata(
+                room_name, remove_keys=["recording_mode", "recording_status"]
             )
-        except utils.MetadataUpdateException as e:
+        except RoomNotFoundException:
+            logger.info(
+                "LiveKit room %s no longer exists, skipping metadata update",
+                room_name,
+            )
+        except RoomManagementException as e:
             logger.exception("Failed to update room's metadata: %s", e)
 
         if recording.options.get("metadata_collector_dispatch_id", None) is not None:

src/backend/core/services/lobby.py

@@ -162,6 +162,7 @@ class LobbyService:
                 username=username,
                 color=participant.color,
                 configuration=room.configuration,
+                is_admin_or_owner=False,
                 participant_id=participant_id,
             )
             return participant, livekit_config
@@ -182,6 +183,7 @@ class LobbyService:
                 username=username,
                 color=participant.color,
                 configuration=room.configuration,
+                is_admin_or_owner=False,
                 participant_id=participant_id,
             )
 

src/backend/core/services/room_management.py

@@ -8,6 +8,7 @@ from typing import Dict, Optional
 
 from asgiref.sync import async_to_sync
 from livekit.api import (
+    ListRoomsRequest,
     TwirpError,
     UpdateRoomMetadataRequest,
 )
@@ -29,20 +30,45 @@ class RoomManagement:
     """Service for managing LiveKit rooms."""
 
     @async_to_sync
-    async def update_metadata(self, room_name: str, metadata: Optional[Dict] = None):
-        """Update a LiveKit room's metadata.
+    async def update_metadata(
+        self,
+        room_name: str,
+        metadata: Optional[Dict] = None,
+        remove_keys: Optional[list[str]] = None,
+    ):
+        """Merge values into a LiveKit room's metadata.
 
         The `room_name` corresponds to the LiveKit room identifier
         (i.e. the Room model's UUID as a string).
+
+        Raises:
+            RoomNotFoundException: the room does not exist in LiveKit.
+            RoomManagementException: the metadata update otherwise fails.
         """
 
         lkapi = utils.create_livekit_client()
 
         try:
+            response = await lkapi.room.list_rooms(ListRoomsRequest(names=[room_name]))
+
+            if not response.rooms:
+                logger.warning(
+                    "Room %s not found in LiveKit, skipping metadata update",
+                    room_name,
+                )
+                raise RoomNotFoundException("Room does not exist")
+
+            existing_metadata = json.loads(response.rooms[0].metadata or "{}")
+
+            for key in remove_keys or []:
+                existing_metadata.pop(key, None)
+
+            updated_metadata = {**existing_metadata, **(metadata or {})}
+
             await lkapi.room.update_room_metadata(
                 UpdateRoomMetadataRequest(
                     room=room_name,
-                    metadata=json.dumps(metadata) if metadata is not None else "",
+                    metadata=json.dumps(updated_metadata),
                 )
             )
 

src/backend/core/services/room_roles.py

@@ -1,178 +0,0 @@
-"""Room role management service.
-
-Single entry point for changing a user's role on a room, used by:
-- the in-meeting endpoint (promote/demote a connected participant)
-- (more to come soon)
-
-`ResourceAccess` is the source of truth. The LiveKit `room_role`
-participant attribute is only a projection of it, synced best-effort.
-"""
-
-from logging import getLogger
-from uuid import UUID
-
-from core import models
-from core.services.participants_management import (
-    ParticipantNotFoundException,
-    ParticipantsManagement,
-    ParticipantsManagementException,
-)
-
-logger = getLogger(__name__)
-
-
-class RoomRoleError(Exception):
-    """Base exception for room role management errors."""
-
-    status_code = 400
-
-
-class SelfActionError(RoomRoleError):
-    """Raised when a user tries to change their own role."""
-
-    status_code = 403
-
-
-class OwnerRoleError(RoomRoleError):
-    """Raised when trying to demote an owner or grant ownership."""
-
-    status_code = 403
-
-
-class ParticipantNotInMeetingError(RoomRoleError):
-    """Raised when the target participant is not connected to the meeting."""
-
-    status_code = 404
-
-
-class UserNotFoundError(RoomRoleError):
-    """Raised when the target participant has no user account in database."""
-
-    status_code = 404
-
-
-ASSIGNABLE_ROLES = (models.RoleChoices.MEMBER, models.RoleChoices.ADMIN)
-
-
-class RoomRoleService:
-    """Manage promotion and demotion of room co-hosts."""
-
-    def set_role(
-        self, room: models.Room, user: models.User, role: str, actor: models.User
-    ):
-        """Persist `role` for `user` on `room`, idempotently and atomically.
-
-        Returns the up-to-date `ResourceAccess`. Never grants or removes
-        ownership: granting OWNER is refused, and an existing OWNER access
-        is never modified.
-        """
-
-        if role not in ASSIGNABLE_ROLES:
-            raise OwnerRoleError("Ownership cannot be granted through this action.")
-
-        if actor is not None and user == actor:
-            raise SelfActionError("You cannot change your own role.")
-
-        access, created = models.ResourceAccess.objects.get_or_create(
-            resource=room,
-            user=user,
-            defaults={"role": role},
-        )
-
-        if created:
-            return access
-
-        if access.role == models.RoleChoices.OWNER:
-            raise OwnerRoleError("Room owners cannot be demoted.")
-
-        if access.role != role:
-            access.role = role
-            access.save(update_fields=["role", "updated_at"])
-
-        return access
-
-    def set_participant_role(
-        self,
-        room: models.Room,
-        participant_identity: UUID,
-        role: str,
-        actor: models.User,
-    ):
-        """Change the role of a participant currently connected to the meeting.
-
-        - The participant must be connected (checked against LiveKit).
-        - The participant must map to a user account.
-        - The role is persisted in DB then mirrored to LiveKit.
-
-        Returns a dict: {"role", "livekit_synced"}.
-        """
-
-        room_name = str(room.pk)
-        participants_management = ParticipantsManagement()
-
-        try:
-            is_in_meeting = participants_management.check_if_in_meeting(
-                room_name=room_name, identity=str(participant_identity)
-            )
-        except ParticipantNotFoundException as e:
-            raise ParticipantNotInMeetingError(
-                "Participant is not connected to this meeting."
-            ) from e
-
-        if not is_in_meeting:
-            raise ParticipantNotInMeetingError(
-                "Participant is not connected to this meeting."
-            )
-
-        user = models.User.objects.filter(sub=participant_identity).first()
-
-        if user is None:
-            raise UserNotFoundError(
-                "This participant has no user account and cannot be assigned a role."
-            )
-
-        # Source of truth first: even if the LiveKit sync below fails,
-        # the role is real and any fresh token will carry it.
-        self.set_role(room=room, user=user, role=role, actor=actor)
-
-        livekit_synced = self._sync_livekit_role(
-            room_name=room_name,
-            participant_identity=str(participant_identity),
-            role=str(role),
-        )
-
-        return {
-            "role": role,
-            "livekit_synced": livekit_synced,
-        }
-
-    @staticmethod
-    def _sync_livekit_role(room_name: str, participant_identity: str, role: str):
-        """Mirror the role to the participant's LiveKit attributes.
-
-        Best-effort: returns False on failure instead of raising, so callers
-        can report a partial success. Re-running the action re-syncs.
-        """
-        try:
-            ParticipantsManagement().update(
-                room_name=room_name,
-                identity=participant_identity,
-                attributes={"room_role": role},
-            )
-        except ParticipantNotFoundException:
-            # The participant left between the presence check and the update:
-            # harmless, the DB state (if any) remains authoritative.
-            logger.info(
-                "Participant %s left room %s before role sync",
-                participant_identity,
-                room_name,
-            )
-            return False
-        except ParticipantsManagementException:
-            logger.exception(
-                "Could not sync role to LiveKit for participant %s in room %s",
-                participant_identity,
-                room_name,
-            )
-            return False
-        return True

src/backend/core/tests/recording/worker/test_mediator.py

@@ -34,10 +34,8 @@ def mediator(mock_worker_service):
     return WorkerServiceMediator(mock_worker_service)
 
 
-@mock.patch("core.utils.update_room_metadata")
-def test_start_recording_success(
-    mock_update_room_metadata, mediator, mock_worker_service
-):
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
+def test_start_recording_success(mock_update_metadata, mediator, mock_worker_service):
     """Test successful recording start"""
     # Setup
     worker_id = "test-worker-123"
@@ -60,7 +58,7 @@ def test_start_recording_success(
     assert mock_recording.worker_id == worker_id
     assert mock_recording.status == RecordingStatusChoices.ACTIVE
 
-    mock_update_room_metadata.assert_called_once_with(
+    mock_update_metadata.assert_called_once_with(
         str(mock_recording.room.id),
         {"recording_mode": mock_recording.mode, "recording_status": "starting"},
     )
@@ -69,9 +67,9 @@ def test_start_recording_success(
 @pytest.mark.parametrize(
     "error_class", [WorkerRequestError, WorkerConnectionError, WorkerResponseError]
 )
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_mediator_start_recording_worker_errors(
-    mock_update_room_metadata, mediator, mock_worker_service, error_class
+    mock_update_metadata, mediator, mock_worker_service, error_class
 ):
     """Test handling of various worker errors during start"""
     # Setup
@@ -89,7 +87,7 @@ def test_mediator_start_recording_worker_errors(
     assert mock_recording.status == RecordingStatusChoices.FAILED_TO_START
     assert mock_recording.worker_id is None
 
-    mock_update_room_metadata.assert_not_called()
+    mock_update_metadata.assert_not_called()
 
 
 @pytest.mark.parametrize(
@@ -103,9 +101,9 @@ def test_mediator_start_recording_worker_errors(
         RecordingStatusChoices.ABORTED,
     ],
 )
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_mediator_start_recording_from_forbidden_status(
-    mock_update_room_metadata, mediator, mock_worker_service, status
+    mock_update_metadata, mediator, mock_worker_service, status
 ):
     """Test handling of various worker errors during start"""
     # Setup
@@ -119,7 +117,7 @@ def test_mediator_start_recording_from_forbidden_status(
     mock_recording.refresh_from_db()
     assert mock_recording.status == status
 
-    mock_update_room_metadata.assert_not_called()
+    mock_update_metadata.assert_not_called()
 
 
 def test_mediator_stop_recording_success(mediator, mock_worker_service):

src/backend/core/tests/rooms/test_api_rooms_participants_management.py

@@ -80,7 +80,7 @@ def test_mute_participant_with_livekit_token_for_this_room(mock_livekit_client):
     room = RoomFactory()
 
     user = AnonymousUser()
-    token = utils.generate_token(str(room.id), user)
+    token = utils.generate_token(str(room.id), user, is_admin_or_owner=False)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": room.id})
     response = client.post(
@@ -106,7 +106,7 @@ def test_mute_participant_with_livekit_token_for_another_room_forbidden(
     other_room = RoomFactory()
 
     user = AnonymousUser()
-    token = utils.generate_token(str(other_room.id), user)
+    token = utils.generate_token(str(other_room.id), user, is_admin_or_owner=False)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": target_room.id})
     response = client.post(
@@ -146,7 +146,7 @@ def test_mute_participant_everyone_can_mute_disabled_blocks_non_admin(
     room = RoomFactory(configuration={"everyone_can_mute": False})
 
     user = AnonymousUser()
-    token = utils.generate_token(str(room.id), user)
+    token = utils.generate_token(str(room.id), user, is_admin_or_owner=False)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": room.id})
     response = client.post(
@@ -293,7 +293,7 @@ def test_mute_participant_admin_with_token_for_this_room(mock_livekit_client):
     )
     # Token identity matches the admin user so LiveKitTokenAuthentication
     # resolves request.user back to the admin.
-    token = utils.generate_token(str(room.id), user)
+    token = utils.generate_token(str(room.id), user, is_admin_or_owner=True)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": room.id})
     response = client.post(
@@ -323,7 +323,7 @@ def test_mute_participant_admin_with_token_for_another_room(mock_livekit_client)
     # Token is scoped to a DIFFERENT room, and admin status must only be
     # honored when established via session, never via a LiveKit
     # token, which can be replayed off-host.
-    token = utils.generate_token(str(other_room.id), user)
+    token = utils.generate_token(str(other_room.id), user, is_admin_or_owner=True)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": target_room.id})
     response = client.post(
@@ -354,7 +354,7 @@ def test_mute_participant_admin_token_replayed_does_not_grant_admin(
         role=random.choice(["administrator", "owner"]),
     )
     # The token is the only credential.
-    token = utils.generate_token(str(room.id), admin_user)
+    token = utils.generate_token(str(room.id), admin_user, is_admin_or_owner=True)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": room.id})
     response = client.post(
@@ -374,7 +374,7 @@ def test_mute_participant_livekit_token_triggers_presence_check(mock_livekit_cli
     room = RoomFactory()
 
     user = AnonymousUser()
-    token = utils.generate_token(str(room.id), user)
+    token = utils.generate_token(str(room.id), user, is_admin_or_owner=False)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": room.id})
     response = client.post(
@@ -405,7 +405,7 @@ def test_mute_participant_livekit_token_presence_check_returns_participant(
     )
 
     user = AnonymousUser()
-    token = utils.generate_token(str(room.id), user)
+    token = utils.generate_token(str(room.id), user, is_admin_or_owner=False)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": room.id})
     response = client.post(
@@ -433,7 +433,7 @@ def test_mute_participant_livekit_token_presence_check_participant_not_found(
     )
 
     user = AnonymousUser()
-    token = utils.generate_token(str(room.id), user)
+    token = utils.generate_token(str(room.id), user, is_admin_or_owner=False)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": room.id})
     response = client.post(
@@ -462,7 +462,7 @@ def test_mute_participant_livekit_token_presence_check_twirp_error_forbidden(
     )
 
     user = AnonymousUser()
-    token = utils.generate_token(str(room.id), user)
+    token = utils.generate_token(str(room.id), user, is_admin_or_owner=False)
 
     url = reverse("rooms-mute-participant", kwargs={"pk": room.id})
     response = client.post(
@@ -719,13 +719,13 @@ def test_update_participant_invalid_payload():
     )
     client.force_authenticate(user=user)
 
-    payload = {"participant_identity": ["test"]}
+    payload = {"participant_identity": "invalid-uuid"}
 
     url = reverse("rooms-update-participant", kwargs={"pk": room.id})
     response = client.post(url, payload, format="json")
 
     assert response.status_code == status.HTTP_400_BAD_REQUEST
-    assert "Not a valid string." in str(response.data)
+    assert "Must be a valid UUID." in str(response.data)
 
 
 def test_update_participant_no_update_fields():
@@ -918,7 +918,7 @@ def test_remove_participant_invalid_payload():
     )
     client.force_authenticate(user=user)
 
-    payload = {"participant_identity": ["invalid-uuid"]}
+    payload = {"participant_identity": "invalid-uuid"}
 
     url = reverse("rooms-remove-participant", kwargs={"pk": room.id})
     response = client.post(url, payload, format="json")

src/backend/core/tests/rooms/test_api_rooms_retrieve.py

@@ -12,7 +12,7 @@ import pytest
 from rest_framework.test import APIClient
 
 from ...factories import RoomFactory, UserFactory, UserResourceAccessFactory
-from ...models import RoleChoices, RoomAccessLevel
+from ...models import RoomAccessLevel
 
 pytestmark = pytest.mark.django_db
 
@@ -31,6 +31,7 @@ def test_api_rooms_retrieve_anonymous_private_pk():
         "configuration": {},
         "access_level": "restricted",
         "id": str(room.id),
+        "is_administrable": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -50,6 +51,7 @@ def test_api_rooms_retrieve_anonymous_trusted_pk():
         "configuration": {},
         "access_level": "trusted",
         "id": str(room.id),
+        "is_administrable": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -68,6 +70,7 @@ def test_api_rooms_retrieve_anonymous_private_pk_no_dashes():
         "configuration": {},
         "access_level": "restricted",
         "id": str(room.id),
+        "is_administrable": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -84,6 +87,7 @@ def test_api_rooms_retrieve_anonymous_private_slug():
         "configuration": {},
         "access_level": "restricted",
         "id": str(room.id),
+        "is_administrable": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -100,6 +104,7 @@ def test_api_rooms_retrieve_anonymous_private_slug_not_normalized():
         "configuration": {},
         "access_level": "restricted",
         "id": str(room.id),
+        "is_administrable": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -209,6 +214,7 @@ def test_api_rooms_retrieve_anonymous_public(mock_token):
         "configuration": {},
         "access_level": str(room.access_level),
         "id": str(room.id),
+        "is_administrable": False,
         "livekit": {
             "url": "test_url_value",
             "room": expected_name,
@@ -255,6 +261,7 @@ def test_api_rooms_retrieve_authenticated_public(mock_token):
         "configuration": {"can_publish_sources": ["camera"]},
         "access_level": str(room.access_level),
         "id": str(room.id),
+        "is_administrable": False,
         "livekit": {
             "url": "test_url_value",
             "room": expected_name,
@@ -271,9 +278,8 @@ def test_api_rooms_retrieve_authenticated_public(mock_token):
         username=None,
         color=None,
         sources=["camera"],
-        role=None,
+        is_admin_or_owner=False,
         participant_id=None,
-        is_authenticated=True,
     )
 
 
@@ -307,6 +313,7 @@ def test_api_rooms_retrieve_authenticated_trusted(mock_token):
         "configuration": {},
         "access_level": str(room.access_level),
         "id": str(room.id),
+        "is_administrable": False,
         "livekit": {
             "url": "test_url_value",
             "room": expected_name,
@@ -323,9 +330,8 @@ def test_api_rooms_retrieve_authenticated_trusted(mock_token):
         username=None,
         color=None,
         sources=None,
-        role=None,
+        is_admin_or_owner=False,
         participant_id=None,
-        is_authenticated=True,
     )
 
 
@@ -349,6 +355,7 @@ def test_api_rooms_retrieve_authenticated():
         "configuration": {},
         "access_level": "restricted",
         "id": str(room.id),
+        "is_administrable": False,
         "name": room.name,
         "slug": room.slug,
     }
@@ -394,6 +401,7 @@ def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries, setti
         "configuration": {"can_publish_sources": ["camera"]},
         "access_level": str(room.access_level),
         "id": str(room.id),
+        "is_administrable": False,
         "livekit": {
             "url": "test_url_value",
             "room": expected_name,
@@ -410,9 +418,8 @@ def test_api_rooms_retrieve_members(mock_token, django_assert_num_queries, setti
         username=None,
         color=None,
         sources=["camera"],
-        role=str(RoleChoices.MEMBER),
+        is_admin_or_owner=False,
         participant_id=None,
-        is_authenticated=True,
     )
 
 
@@ -486,6 +493,7 @@ def test_api_rooms_retrieve_administrators(
     assert content_dict == {
         "access_level": str(room.access_level),
         "id": str(room.id),
+        "is_administrable": True,
         "configuration": {},
         "livekit": {
             "url": "test_url_value",
@@ -503,7 +511,6 @@ def test_api_rooms_retrieve_administrators(
         username=None,
         color=None,
         sources=None,
-        role=str(user_access.role),
+        is_admin_or_owner=True,
         participant_id=None,
-        is_authenticated=True,
     )

src/backend/core/tests/rooms/test_api_rooms_update_participant_role.py

@@ -1,319 +0,0 @@
-"""
-Test rooms API endpoints in the Meet core app: update-participant-role.
-"""
-
-# pylint: disable=redefined-outer-name,unused-argument
-
-import uuid
-from unittest import mock
-
-import pytest
-from rest_framework.test import APIClient
-
-from ...factories import RoomFactory, UserFactory
-from ...models import ResourceAccess, RoleChoices
-from ...services.participants_management import ParticipantNotFoundException
-
-pytestmark = pytest.mark.django_db
-
-
-def test_update_participant_role_anonymous():
-    """Anonymous requesters are rejected."""
-    client = APIClient()
-    room = RoomFactory()
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": "some-identity", "role": "administrator"},
-        format="json",
-    )
-
-    assert response.status_code == 401
-
-
-def test_update_participant_role_requires_privileges():
-    """A simple member cannot promote other participants."""
-    client = APIClient()
-    user = UserFactory()
-    room = RoomFactory(users=[(user, RoleChoices.MEMBER)])
-    client.force_login(user)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": "some-identity", "role": "administrator"},
-        format="json",
-    )
-
-    assert response.status_code == 403
-
-
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_requester_not_in_meeting(mock_perm_pm):
-    """An admin who is not connected to the meeting is rejected."""
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = False
-    client = APIClient()
-    user = UserFactory()
-    room = RoomFactory(users=[(user, RoleChoices.ADMIN)])
-    client.force_login(user)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": "some-identity", "role": "administrator"},
-        format="json",
-    )
-
-    assert response.status_code == 403
-    mock_perm_pm.return_value.check_if_in_meeting.assert_called_once_with(
-        room_name=str(room.pk), identity=str(user.sub)
-    )
-
-
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_cannot_target_self(mock_perm_pm):
-    """Requesters cannot change their own role."""
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = True
-    client = APIClient()
-    user = UserFactory(sub=uuid.uuid4())
-    room = RoomFactory(users=[(user, RoleChoices.ADMIN)])
-    client.force_login(user)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": user.sub, "role": "member"},
-        format="json",
-    )
-
-    assert response.status_code == 403
-    assert response.json() == {"error": "You cannot change your own role."}
-
-
-@mock.patch("core.services.room_roles.RoomRoleService._sync_livekit_role")
-@mock.patch("core.services.room_roles.ParticipantsManagement")
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_promotes_authenticated_target(
-    mock_perm_pm, mock_svc_pm, mock_sync
-):
-    """Promoting a connected, authenticated participant persists the role."""
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = True
-    mock_svc_pm.return_value.check_if_in_meeting.return_value = True
-    mock_sync.return_value = True
-
-    client = APIClient()
-    admin = UserFactory()
-    target = UserFactory(sub=uuid.uuid4())
-    room = RoomFactory(users=[(admin, RoleChoices.OWNER)])
-    client.force_login(admin)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": str(target.sub), "role": "administrator"},
-        format="json",
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {
-        "role": "administrator",
-        "livekit_synced": True,
-    }
-    access = ResourceAccess.objects.get(resource=room, user=target)
-    assert access.role == RoleChoices.ADMIN
-    mock_sync.assert_called_once_with(
-        room_name=str(room.pk),
-        participant_identity=str(target.sub),
-        role="administrator",
-    )
-
-
-@mock.patch("core.services.room_roles.RoomRoleService._sync_livekit_role")
-@mock.patch("core.services.room_roles.ParticipantsManagement")
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_demotes_authenticated_target(
-    mock_perm_pm, mock_svc_pm, mock_sync
-):
-    """Demoting a connected admin back to member updates the access row."""
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = True
-    mock_svc_pm.return_value.check_if_in_meeting.return_value = True
-    mock_sync.return_value = True
-
-    client = APIClient()
-    admin = UserFactory()
-    target = UserFactory(sub=uuid.uuid4())
-    room = RoomFactory(users=[(admin, RoleChoices.OWNER), (target, RoleChoices.ADMIN)])
-    client.force_login(admin)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": str(target.sub), "role": "member"},
-        format="json",
-    )
-
-    assert response.status_code == 200
-    access = ResourceAccess.objects.get(resource=room, user=target)
-    assert access.role == RoleChoices.MEMBER
-
-
-@mock.patch("core.services.room_roles.RoomRoleService._sync_livekit_role")
-@mock.patch("core.services.room_roles.ParticipantsManagement")
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_cannot_demote_owner(
-    mock_perm_pm, mock_svc_pm, mock_sync
-):
-    """Room owners can never be demoted."""
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = True
-    mock_svc_pm.return_value.check_if_in_meeting.return_value = True
-
-    client = APIClient()
-    admin = UserFactory()
-    owner = UserFactory(sub=uuid.uuid4())
-    room = RoomFactory(users=[(admin, RoleChoices.ADMIN), (owner, RoleChoices.OWNER)])
-    client.force_login(admin)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": str(owner.sub), "role": "member"},
-        format="json",
-    )
-
-    assert response.status_code == 403
-    assert response.json() == {"error": "Room owners cannot be demoted."}
-    assert (
-        ResourceAccess.objects.get(resource=room, user=owner).role == RoleChoices.OWNER
-    )
-    mock_sync.assert_not_called()
-
-
-@mock.patch("core.services.room_roles.RoomRoleService._sync_livekit_role")
-@mock.patch("core.services.room_roles.ParticipantsManagement")
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_anonymous_target_is_ephemeral(
-    mock_perm_pm, mock_svc_pm, mock_sync
-):
-    """Promoting an anonymous participant should not be possible."""
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = True
-    mock_svc_pm.return_value.check_if_in_meeting.return_value = True
-    mock_sync.return_value = True
-
-    client = APIClient()
-    admin = UserFactory()
-    room = RoomFactory(users=[(admin, RoleChoices.ADMIN)])
-    client.force_login(admin)
-
-    anonymous_identity = uuid.uuid4()
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": anonymous_identity, "role": "administrator"},
-        format="json",
-    )
-
-    assert response.status_code == 404
-    assert response.json() == {
-        "error": "This participant has no user account and cannot be assigned a role."
-    }
-    assert not ResourceAccess.objects.filter(resource=room).exclude(user=admin).exists()
-
-
-@mock.patch("core.services.room_roles.RoomRoleService._sync_livekit_role")
-@mock.patch("core.services.room_roles.ParticipantsManagement")
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_target_not_in_meeting(
-    mock_perm_pm, mock_svc_pm, mock_sync
-):
-    """Only connected participants can be promoted or demoted."""
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = True
-    mock_svc_pm.return_value.check_if_in_meeting.side_effect = (
-        ParticipantNotFoundException("Participant does not exist")
-    )
-
-    client = APIClient()
-    admin = UserFactory()
-    target = UserFactory(sub=uuid.uuid4())
-    room = RoomFactory(users=[(admin, RoleChoices.ADMIN)])
-    client.force_login(admin)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": str(target.sub), "role": "administrator"},
-        format="json",
-    )
-
-    assert response.status_code == 404
-    assert not ResourceAccess.objects.filter(resource=room, user=target).exists()
-    mock_sync.assert_not_called()
-
-
-@mock.patch("core.services.room_roles.RoomRoleService._sync_livekit_role")
-@mock.patch("core.services.room_roles.ParticipantsManagement")
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_is_idempotent_and_resyncs(
-    mock_perm_pm, mock_svc_pm, mock_sync
-):
-    """Promoting an existing admin succeeds and still re-syncs LiveKit."""
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = True
-    mock_svc_pm.return_value.check_if_in_meeting.return_value = True
-    mock_sync.return_value = True
-
-    client = APIClient()
-    admin = UserFactory()
-    target = UserFactory(sub=uuid.uuid4())
-    room = RoomFactory(users=[(admin, RoleChoices.OWNER), (target, RoleChoices.ADMIN)])
-    client.force_login(admin)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": str(target.sub), "role": "administrator"},
-        format="json",
-    )
-
-    assert response.status_code == 200
-    mock_sync.assert_called_once()
-
-
-@mock.patch("core.services.room_roles.RoomRoleService._sync_livekit_role")
-@mock.patch("core.services.room_roles.ParticipantsManagement")
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_livekit_failure_reports_partial_success(
-    mock_perm_pm, mock_svc_pm, mock_sync
-):
-    """A LiveKit sync failure does not lose the persisted role."""
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = True
-    mock_svc_pm.return_value.check_if_in_meeting.return_value = True
-    mock_sync.return_value = False
-
-    client = APIClient()
-    admin = UserFactory()
-    target = UserFactory(sub=uuid.uuid4())
-    room = RoomFactory(users=[(admin, RoleChoices.OWNER)])
-    client.force_login(admin)
-
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": str(target.sub), "role": "administrator"},
-        format="json",
-    )
-
-    assert response.status_code == 200
-    assert response.json() == {
-        "role": "administrator",
-        "livekit_synced": False,
-    }
-    assert (
-        ResourceAccess.objects.get(resource=room, user=target).role == RoleChoices.ADMIN
-    )
-
-
-@mock.patch("core.api.permissions.ParticipantsManagement")
-def test_update_participant_role_rejects_owner_role(mock_perm_pm):
-    """The owner role can never be granted through this endpoint."""
-    client = APIClient()
-    admin = UserFactory()
-    room = RoomFactory(users=[(admin, RoleChoices.ADMIN)])
-    client.force_login(admin)
-
-    mock_perm_pm.return_value.check_if_in_meeting.return_value = True
-    response = client.post(
-        f"/api/v1.0/rooms/{room.id}/update-participant-role/",
-        {"participant_identity": "some-identity", "role": "owner"},
-        format="json",
-    )
-
-    assert response.status_code == 400

src/backend/core/tests/services/test_livekit_events.py

@@ -20,8 +20,9 @@ from core.services.livekit_events import (
     api,
 )
 from core.services.lobby import LobbyService
+from core.services.room_management import RoomManagementException
 from core.services.telephony import TelephonyException, TelephonyService
-from core.utils import MetadataUpdateException, NotificationError
+from core.utils import NotificationError
 
 pytestmark = pytest.mark.django_db
 
@@ -70,9 +71,9 @@ def test_initialization(
     ),
 )
 @mock.patch("core.utils.notify_participants")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_success(
-    mock_update_room_metadata, mock_notify, mode, notification_type, service
+    mock_update_metadata, mock_notify, mode, notification_type, service
 ):
     """Should successfully stop recording and notifies all participant."""
 
@@ -86,8 +87,8 @@ def test_handle_egress_ended_success(
     mock_notify.assert_called_once_with(
         room_name=str(recording.room.id), notification_data={"type": notification_type}
     )
-    mock_update_room_metadata.assert_called_once_with(
-        str(recording.room.id), {}, ["recording_mode", "recording_status"]
+    mock_update_metadata.assert_called_once_with(
+        str(recording.room.id), remove_keys=["recording_mode", "recording_status"]
     )
 
     recording.refresh_from_db()
@@ -104,9 +105,9 @@ def test_handle_egress_ended_success(
         (EgressStatus.EGRESS_ABORTED, "aborted"),
     ),
 )
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_updated_success(
-    mock_update_room_metadata, egress_status, status, service
+    mock_update_metadata, egress_status, status, service
 ):
     """Should successfully update room's metadata."""
 
@@ -117,7 +118,7 @@ def test_handle_egress_updated_success(
 
     service._handle_egress_updated(mock_data)
 
-    mock_update_room_metadata.assert_called_once_with(
+    mock_update_metadata.assert_called_once_with(
         str(recording.room.id), {"recording_status": status}
     )
 
@@ -129,9 +130,9 @@ def test_handle_egress_updated_success(
         EgressStatus.EGRESS_LIMIT_REACHED,
     ),
 )
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_updated_non_handled(
-    mock_update_room_metadata, egress_status, service
+    mock_update_metadata, egress_status, service
 ):
     """Should ignore certain egress status and don't trigger metadata updates."""
 
@@ -142,7 +143,7 @@ def test_handle_egress_updated_non_handled(
 
     service._handle_egress_updated(mock_data)
 
-    mock_update_room_metadata.assert_not_called()
+    mock_update_metadata.assert_not_called()
 
 
 @pytest.mark.parametrize(
@@ -153,9 +154,9 @@ def test_handle_egress_updated_non_handled(
     ),
 )
 @mock.patch("core.utils.notify_participants")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_metadata_update_fails(
-    mock_update_room_metadata, mock_notify, mode, notification_type, service
+    mock_update_metadata, mock_notify, mode, notification_type, service
 ):
     """Should successfully stop and save recording when metadata's update fails."""
 
@@ -164,7 +165,7 @@ def test_handle_egress_ended_metadata_update_fails(
     mock_data.egress_info.egress_id = recording.worker_id
     mock_data.egress_info.status = EgressStatus.EGRESS_LIMIT_REACHED
 
-    mock_update_room_metadata.side_effect = MetadataUpdateException("Error notifying")
+    mock_update_metadata.side_effect = RoomManagementException("Error notifying")
 
     service._handle_egress_ended(mock_data)
 
@@ -178,9 +179,9 @@ def test_handle_egress_ended_metadata_update_fails(
 
 
 @mock.patch("core.utils.notify_participants")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_notification_fails(
-    mock_update_room_metadata, mock_notify, service
+    mock_update_metadata, mock_notify, service
 ):
     """Should raise ActionFailedError when notification fails but still stop recording."""
 
@@ -200,15 +201,15 @@ def test_handle_egress_ended_notification_fails(
     recording.refresh_from_db()
     assert recording.status == "stopped"
 
-    mock_update_room_metadata.assert_called_once_with(
-        str(recording.room.id), {}, ["recording_mode", "recording_status"]
+    mock_update_metadata.assert_called_once_with(
+        str(recording.room.id), remove_keys=["recording_mode", "recording_status"]
     )
 
 
 @mock.patch("core.utils.notify_participants")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_recording_not_found(
-    mock_update_room_metadata, mock_notify, service
+    mock_update_metadata, mock_notify, service
 ):
     """Should raise ActionFailedError when recording doesn't exist."""
 
@@ -223,16 +224,16 @@ def test_handle_egress_ended_recording_not_found(
         service._handle_egress_ended(mock_data)
 
     mock_notify.assert_not_called()
-    mock_update_room_metadata.assert_not_called()
+    mock_update_metadata.assert_not_called()
 
     recording.refresh_from_db()
     assert recording.status == "active"
 
 
 @mock.patch("core.utils.notify_participants")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_recording_not_active(
-    mock_update_room_metadata, mock_notify, service
+    mock_update_metadata, mock_notify, service
 ):
     """Should ignore non-active recordings."""
 
@@ -244,8 +245,8 @@ def test_handle_egress_ended_recording_not_active(
     service._handle_egress_ended(mock_data)
 
     mock_notify.assert_not_called()
-    mock_update_room_metadata.assert_called_once_with(
-        str(recording.room.id), {}, ["recording_mode", "recording_status"]
+    mock_update_metadata.assert_called_once_with(
+        str(recording.room.id), remove_keys=["recording_mode", "recording_status"]
     )
 
     recording.refresh_from_db()
@@ -253,9 +254,9 @@ def test_handle_egress_ended_recording_not_active(
 
 
 @mock.patch("core.utils.notify_participants")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_recording_not_limit_reached(
-    mock_update_room_metadata, mock_notify, service
+    mock_update_metadata, mock_notify, service
 ):
     """Should ignore egress non-limit-reached statuses."""
 
@@ -267,16 +268,16 @@ def test_handle_egress_ended_recording_not_limit_reached(
     service._handle_egress_ended(mock_data)
 
     mock_notify.assert_not_called()
-    mock_update_room_metadata.assert_called_once_with(
-        str(recording.room.id), {}, ["recording_mode", "recording_status"]
+    mock_update_metadata.assert_called_once_with(
+        str(recording.room.id), remove_keys=["recording_mode", "recording_status"]
     )
     assert recording.status == "stopped"
 
 
 @mock.patch("core.services.livekit_events.MetadataCollectorService")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_calls_metadata_collector_stop_when_conditions_are_met(
-    mock_update_room_metadata, mock_collector_class, service, settings
+    mock_update_metadata, mock_collector_class, service, settings
 ):
     """Should call MetadataCollectorService.stop when it exists."""
     settings.METADATA_COLLECTOR_ENABLED = True
@@ -306,7 +307,7 @@ def test_handle_egress_ended_calls_metadata_collector_stop_when_conditions_are_m
     ],
 )
 @mock.patch("core.services.livekit_events.MetadataCollectorService")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_does_not_call_metadata_collector_stop_when_conditions_not_met(
     _, mock_collector_class, metadata_enabled, options, service, settings
 ):  # pylint: disable=too-many-arguments,too-many-positional-arguments
@@ -335,7 +336,7 @@ def test_handle_egress_ended_does_not_call_metadata_collector_stop_when_conditio
     "notify_external_services"
 )
 @mock.patch("core.utils.notify_participants")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 @pytest.mark.parametrize(
     "egress_status",
     [EgressStatus.EGRESS_COMPLETE, EgressStatus.EGRESS_LIMIT_REACHED],
@@ -345,7 +346,7 @@ def test_handle_egress_ended_does_not_call_metadata_collector_stop_when_conditio
     [(True, "notification_succeeded"), (False, "saved")],
 )
 def test_handle_egress_ended_finalizes_recording(  # noqa: PLR0913
-    mock_update_room_metadata,
+    mock_update_metadata,
     mock_notify,
     mock_notify_external_services,
     notify_return_value,
@@ -378,7 +379,7 @@ def test_handle_egress_ended_finalizes_recording(  # noqa: PLR0913
     "notify_external_services"
 )
 @mock.patch("core.utils.notify_participants")
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 @pytest.mark.parametrize(
     "egress_status, expected_status",
     [
@@ -387,7 +388,7 @@ def test_handle_egress_ended_finalizes_recording(  # noqa: PLR0913
     ],
 )
 def test_handle_egress_ended_does_not_finalize_when_webhooks_enabled(  # noqa: PLR0913
-    mock_update_room_metadata,
+    mock_update_metadata,
     mock_notify,
     mock_notify_external_services,
     egress_status,
@@ -424,9 +425,9 @@ def test_handle_egress_ended_does_not_finalize_when_webhooks_enabled(  # noqa: P
         EgressStatus.EGRESS_ABORTED,
     ],
 )
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_does_not_save_on_wrong_status(
-    mock_update_room_metadata, egress_status, service, settings
+    mock_update_metadata, egress_status, service, settings
 ):
     """Shouldn't save on invalid status."""
     settings.RECORDING_STORAGE_EVENT_ENABLE = False
@@ -445,9 +446,9 @@ def test_handle_egress_ended_does_not_save_on_wrong_status(
 @pytest.mark.parametrize(
     "status", ["failed_to_start", "aborted", "failed_to_stop", "saved", "initiated"]
 )
-@mock.patch("core.utils.update_room_metadata")
+@mock.patch("core.services.room_management.RoomManagement.update_metadata")
 def test_handle_egress_ended_ignores_non_savable_recording(
-    mock_update_room_metadata, status, service, settings
+    mock_update_metadata, status, service, settings
 ):
     """Should handle non-savable recordings idempotently without raising.
 

src/backend/core/tests/services/test_lobby.py

@@ -266,6 +266,7 @@ def test_request_entry_public_room(
         username=username,
         color=participant.color,
         configuration=room.configuration,
+        is_admin_or_owner=False,
         participant_id="test-participant-id",
     )
 
@@ -304,6 +305,7 @@ def test_request_entry_trusted_room(
         username=username,
         color=participant.color,
         configuration=room.configuration,
+        is_admin_or_owner=False,
         participant_id="test-participant-id",
     )
 
@@ -398,6 +400,7 @@ def test_request_entry_accepted_participant(
         username=username,
         color="#123456",
         configuration=room.configuration,
+        is_admin_or_owner=False,
         participant_id="test-participant-id",
     )
     lobby_service._get_participant.assert_called_once_with(room.id, participant_id)

src/backend/core/utils.py

@@ -31,7 +31,6 @@ from livekit.api import (  # pylint: disable=E0611
     LiveKitAPI,
     SendDataRequest,
     TwirpError,
-    UpdateRoomMetadataRequest,
     VideoGrants,
 )
 
@@ -66,9 +65,8 @@ def generate_token(
     username: Optional[str] = None,
     color: Optional[str] = None,
     sources: Optional[List[str]] = None,
-    role: Optional[str] = None,
+    is_admin_or_owner: bool = False,
     participant_id: Optional[str] = None,
-    is_authenticated: Optional[bool] = False,
 ) -> str:
     """Generate a LiveKit access token for a user in a specific room.
 
@@ -81,16 +79,14 @@ def generate_token(
                          If none, a value will be generated
         sources: (Optional[List[str]]): List of media sources the user can publish
                          If none, defaults to LIVEKIT_DEFAULT_SOURCES.
-        role (Optional[str]): Room's access role if any
+        is_admin_or_owner (bool): Whether user has admin privileges
         participant_id (Optional[str]): Stable identifier for anonymous users;
                          used as identity when user.is_anonymous.
-        is_authenticated (Optional[bool]): Is user authentified.
 
     Returns:
         str: The LiveKit JWT access token.
     """
 
-    is_admin_or_owner = role in ("owner", "administrator")
     if is_admin_or_owner:
         sources = settings.LIVEKIT_DEFAULT_SOURCES
 
@@ -131,11 +127,7 @@ def generate_token(
         .with_identity(identity)
         .with_name(display_name)
         .with_attributes(
-            {
-                "color": color,
-                "room_role": role,
-                "is_authenticated": "true" if is_authenticated else "false",
-            }
+            {"color": color, "room_admin": "true" if is_admin_or_owner else "false"}
         )
     )
 
@@ -146,11 +138,10 @@ def generate_livekit_config(
     room_id: str,
     user,
     username: str,
-    role: Optional[str] = None,
+    is_admin_or_owner: bool,
     color: Optional[str] = None,
     configuration: Optional[dict] = None,
     participant_id: Optional[str] = None,
-    is_authenticated: Optional[bool] = False,
 ) -> dict:
     """Generate LiveKit configuration for room access.
 
@@ -158,12 +149,11 @@ def generate_livekit_config(
         room_id: Room identifier
         user: User instance requesting access
         username: Display name in room
-        role (str): Room's access role if any
+        is_admin_or_owner (bool): Whether the user has admin/owner privileges for this room.
         color (Optional[str]): Optional color to associate with the participant.
         configuration (Optional[dict]): Room configuration dict that can override default settings.
         participant_id (Optional[str]): Stable identifier for anonymous users;
                          used as identity when user.is_anonymous.
-        is_authenticated: Optional[bool]: Is user authentified.
 
     Returns:
         dict: LiveKit configuration with URL, room and access token
@@ -182,9 +172,8 @@ def generate_livekit_config(
             username=username,
             color=color,
             sources=sources,
-            role=role,
+            is_admin_or_owner=is_admin_or_owner,
             participant_id=participant_id,
-            is_authenticated=is_authenticated,
         ),
     }
 
@@ -268,57 +257,6 @@ async def notify_participants(room_name: str, notification_data: dict):
         await lkapi.aclose()
 
 
-class MetadataUpdateException(Exception):
-    """Room's metadata update fails."""
-
-
-@async_to_sync
-async def update_room_metadata(
-    room_name: str, metadata: dict, remove_keys: Optional[list[str]] = None
-):
-    """Update LiveKit room metadata by merging new values with existing metadata.
-
-    Args:
-        room_name: Name of the room to update
-        metadata: Dictionary of metadata key-values to add/update
-        remove_keys: Optional list of keys to remove from existing metadata.
-    """
-
-    lkapi = create_livekit_client()
-
-    try:
-        response = await lkapi.room.list_rooms(
-            ListRoomsRequest(
-                names=[room_name],
-            )
-        )
-
-        if not response.rooms:
-            return
-
-        room = response.rooms[0]
-
-        existing_metadata = json.loads(room.metadata) if room.metadata else {}
-
-        if remove_keys:
-            for key in remove_keys:
-                existing_metadata.pop(key, None)
-
-        updated_metadata = {**existing_metadata, **metadata}
-
-        await lkapi.room.update_room_metadata(
-            UpdateRoomMetadataRequest(
-                room=room_name, metadata=json.dumps(updated_metadata).encode("utf-8")
-            )
-        )
-    except TwirpError as e:
-        raise MetadataUpdateException(
-            f"Failed to update metadata for room {room_name}: {e}"
-        ) from e
-    finally:
-        await lkapi.aclose()
-
-
 ALPHANUMERIC_CHARSET = string.ascii_letters + string.digits
 
 

src/frontend/src/components/Avatar.tsx

@@ -56,7 +56,7 @@ export const Avatar = React.memo(
             fontWeight="500"
             fill="currentColor"
           >
-            {initial.toUpperCase()}
+            {initial}
           </text>
         </svg>
       </div>

src/frontend/src/features/participants/api/updateParticipantRole.ts

@@ -1,31 +0,0 @@
-import { fetchApi } from '@/api/fetchApi'
-import { useRoomData } from '@/features/rooms/livekit/hooks/useRoomData'
-import { AssignableParticipantRole } from '@/features/rooms/api/ApiRoom'
-
-export const useParticipantRole = () => {
-  const data = useRoomData()
-
-  const updateParticipantRole = async (
-    identity: string,
-    role: AssignableParticipantRole
-  ) => {
-    if (!data?.id) {
-      throw new Error('Room id is not available')
-    }
-
-    try {
-      return fetchApi(`rooms/${data.id}/update-participant-role/`, {
-        method: 'POST',
-        body: JSON.stringify({
-          participant_identity: identity,
-          role: role,
-        }),
-      })
-    } catch (error) {
-      console.error(
-        `Failed to update participant's role ${identity}: ${error instanceof Error ? error.message : 'Unknown error'}`
-      )
-    }
-  }
-  return { updateParticipantRole }
-}

src/frontend/src/features/participants/components/ParticipantRow.tsx

@@ -5,10 +5,7 @@ import { Text } from '@/primitives/Text'
 import { useTranslation } from 'react-i18next'
 import { Avatar } from '@/components/Avatar'
 import { getParticipantColor } from '@/features/rooms/utils/getParticipantColor'
-import {
-  getParticipantIsRoomAdmin,
-  getParticipantIsRoomOwner,
-} from '@/features/rooms/utils/getParticipantIsRoomAdminOrOwner'
+import { getParticipantIsRoomAdmin } from '@/features/rooms/utils/getParticipantIsRoomAdmin'
 import { type LocalParticipant, type Participant, Track } from 'livekit-client'
 import { isLocal } from '@/utils/livekit'
 import {
@@ -149,11 +146,8 @@ export const ParticipantRow = ({ participant }: ParticipantListItemProps) => {
               </span>
             )}
           </Text>
-          {getParticipantIsRoomOwner(participant) && (
-            <Text variant="xsNote">{t('participants.host')}</Text>
-          )}
           {getParticipantIsRoomAdmin(participant) && (
-            <Text variant="xsNote">{t('participants.cohost')}</Text>
+            <Text variant="xsNote">{t('participants.host')}</Text>
           )}
         </VStack>
       </HStack>

src/frontend/src/features/participants/components/menu/ParticipantMenu.tsx

@@ -1,46 +1,24 @@
 import { Menu as RACMenu } from 'react-aria-components'
 import type { Participant } from 'livekit-client'
+import { useIsAdminOrOwner } from '@/features/rooms/livekit/hooks/useIsAdminOrOwner'
 import { PinMenuItem } from './items/PinMenuItem'
 import { RemoveMenuItem } from './items/RemoveMenuItem'
-import { PromoteMenuItem } from './items/PromoteMenuItem'
-import { useIsAdminOrOwner } from '@/features/rooms/livekit/hooks/useIsAdminOrOwner'
-import { useParticipantAttributes } from '@livekit/components-react'
 
 export const ParticipantMenu = ({
   participant,
 }: {
   participant: Participant
 }) => {
-  const isLocalUserAdminOrOwner = useIsAdminOrOwner()
-
-  const { attributes } = useParticipantAttributes({ participant })
-
-  const isAdmin = attributes?.room_role === 'administrator'
-  const isOwner = attributes?.room_role === 'owner'
-  const isAuthenticated = attributes?.is_authenticated == 'true'
-
-  const canManage = !participant.isLocal && isLocalUserAdminOrOwner && !isOwner
-
+  const isAdminOrOwner = useIsAdminOrOwner()
+  const canModerateParticipant = !participant.isLocal && isAdminOrOwner
   return (
     <RACMenu
       style={{
-        minWidth: '100px',
+        minWidth: '75px',
       }}
     >
       <PinMenuItem participant={participant} />
-      {canManage && (
-        <RemoveMenuItem
-          identity={participant.identity}
-          displayedName={participant.name}
-        />
-      )}
-      {canManage && isAuthenticated && (
-        <PromoteMenuItem
-          identity={participant.identity}
-          isAdmin={isAdmin}
-          displayedName={participant.name}
-        />
-      )}
+      {canModerateParticipant && <RemoveMenuItem participant={participant} />}
     </RACMenu>
   )
 }

src/frontend/src/features/participants/components/menu/ParticipantMenuButton.tsx

@@ -1,6 +1,7 @@
 import { Button, Menu } from '@/primitives'
 import { RiMore2Fill } from '@remixicon/react'
 import { ParticipantMenu } from './ParticipantMenu'
+import { useIsAdminOrOwner } from '@/features/rooms/livekit/hooks/useIsAdminOrOwner'
 import type { Participant } from 'livekit-client'
 import { useTranslation } from 'react-i18next'
 
@@ -10,6 +11,8 @@ export const ParticipantMenuButton = ({
   participant: Participant
 }) => {
   const { t } = useTranslation('rooms', { keyPrefix: 'participants' })
+  const isAdminOrOwner = useIsAdminOrOwner()
+  if (!isAdminOrOwner) return null
   return (
     <Menu>
       <Button

src/frontend/src/features/participants/components/menu/items/PromoteMenuItem.tsx

@@ -1,47 +0,0 @@
-import React, { useCallback } from 'react'
-import { MenuItem } from 'react-aria-components'
-import { useTranslation } from 'react-i18next'
-import { RiAdminLine, RiUserMinusLine } from '@remixicon/react'
-import { useParticipantRole } from '@/features/participants/api/updateParticipantRole'
-import { menuRecipe } from '@/primitives/menuRecipe'
-import { HStack } from '@/styled-system/jsx'
-
-type PromoteMenuItemProps = {
-  identity: string
-  displayedName?: string
-  isAdmin: boolean
-}
-
-export const PromoteMenuItem = React.memo(
-  ({ identity, displayedName, isAdmin }: PromoteMenuItemProps) => {
-    const { t } = useTranslation('rooms', { keyPrefix: 'participantMenu' })
-
-    const { updateParticipantRole } = useParticipantRole()
-
-    const label = isAdmin ? 'demote' : 'promote'
-    const Icon = isAdmin ? RiUserMinusLine : RiAdminLine
-
-    const toggleRole = useCallback(
-      () =>
-        updateParticipantRole(identity, isAdmin ? 'member' : 'administrator'),
-      [isAdmin, updateParticipantRole, identity]
-    )
-
-    return (
-      <MenuItem
-        aria-label={t(`${label}.ariaLabel`, {
-          name: displayedName || identity,
-        })}
-        className={menuRecipe({ icon: true }).item}
-        onAction={toggleRole}
-      >
-        <HStack gap={0.25}>
-          <Icon size={20} aria-hidden />
-          {t(`${label}.label`)}
-        </HStack>
-      </MenuItem>
-    )
-  }
-)
-
-PromoteMenuItem.displayName = 'PromoteMenuItem'

src/frontend/src/features/participants/components/menu/items/RemoveMenuItem.tsx

@@ -1,4 +1,4 @@
-import React from 'react'
+import type { Participant } from 'livekit-client'
 import { menuRecipe } from '@/primitives/menuRecipe'
 import { HStack } from '@/styled-system/jsx'
 import { RiCloseLine } from '@remixicon/react'
@@ -6,30 +6,23 @@ import { MenuItem } from 'react-aria-components'
 import { useRemoveParticipant } from '@/features/rooms/api/removeParticipant'
 import { useTranslation } from 'react-i18next'
 
-type RemoveMenuItemProps = {
-  identity: string
-  displayedName?: string
+export const RemoveMenuItem = ({
+  participant,
+}: {
+  participant: Participant
+}) => {
+  const { t } = useTranslation('rooms', { keyPrefix: 'participantMenu.remove' })
+  const { removeParticipant } = useRemoveParticipant()
+  return (
+    <MenuItem
+      aria-label={t('ariaLabel', { name: participant.name })}
+      className={menuRecipe({ icon: true }).item}
+      onAction={() => removeParticipant(participant)}
+    >
+      <HStack gap={0.25}>
+        <RiCloseLine size={20} aria-hidden />
+        {t('label')}
+      </HStack>
+    </MenuItem>
+  )
 }
-
-export const RemoveMenuItem = React.memo(
-  ({ identity, displayedName }: RemoveMenuItemProps) => {
-    const { t } = useTranslation('rooms', {
-      keyPrefix: 'participantMenu.remove',
-    })
-    const { removeParticipant } = useRemoveParticipant()
-    return (
-      <MenuItem
-        aria-label={t('ariaLabel', { name: displayedName || identity })}
-        className={menuRecipe({ icon: true }).item}
-        onAction={() => removeParticipant(identity)}
-      >
-        <HStack gap={0.25}>
-          <RiCloseLine size={20} aria-hidden />
-          {t('label')}
-        </HStack>
-      </MenuItem>
-    )
-  }
-)
-
-RemoveMenuItem.displayName = 'RemoveMenuItem'

src/frontend/src/features/rooms/api/ApiRoom.ts

@@ -28,6 +28,3 @@ export type ApiRoom = {
   livekit?: ApiLiveKit
   configuration?: RoomConfiguration
 }
-
-export type ParticipantRole = 'member' | 'administrator' | 'owner'
-export type AssignableParticipantRole = Exclude<ParticipantRole, 'owner'>

src/frontend/src/features/rooms/api/removeParticipant.ts

@@ -1,10 +1,11 @@
+import type { Participant } from 'livekit-client'
 import { useRoomData } from '../livekit/hooks/useRoomData'
 import { fetchApi } from '@/api/fetchApi'
 
 export const useRemoveParticipant = () => {
   const data = useRoomData()
 
-  const removeParticipant = async (identity: string) => {
+  const removeParticipant = async (participant: Participant) => {
     if (!data?.id) {
       throw new Error('Room id is not available')
     }
@@ -12,7 +13,7 @@ export const useRemoveParticipant = () => {
     return fetchApi(`rooms/${data.id}/remove-participant/`, {
       method: 'POST',
       body: JSON.stringify({
-        participant_identity: identity,
+        participant_identity: participant.identity,
       }),
     })
   }

src/frontend/src/features/rooms/livekit/components/Admin.tsx

@@ -11,9 +11,6 @@ import { useQuery } from '@tanstack/react-query'
 import { useParams } from 'wouter'
 import { usePublishSourcesManager } from '../hooks/usePublishSourcesManager'
 import { usePermissionsManager } from '../hooks/usePermissionsManager'
-import { useEffect } from 'react'
-import { closeSidePanel } from '@/stores/layout'
-import { useIsAdminOrOwner } from '../hooks/useIsAdminOrOwner'
 
 export const Admin = () => {
   const { t } = useTranslation('rooms', { keyPrefix: 'admin' })
@@ -26,14 +23,6 @@ export const Admin = () => {
 
   const { mutateAsync: patchRoom } = usePatchRoom()
 
-  const isAdminOrOwner = useIsAdminOrOwner()
-
-  useEffect(() => {
-    if (!isAdminOrOwner) {
-      closeSidePanel()
-    }
-  }, [isAdminOrOwner])
-
   const { data: readOnlyData } = useQuery({
     queryKey: [keys.room, roomId],
     queryFn: () => fetchRoom({ roomId }),

src/frontend/src/features/rooms/livekit/components/SidePanel.tsx

@@ -1,4 +1,4 @@
-import { closeSidePanel, layoutStore } from '@/stores/layout'
+import { layoutStore } from '@/stores/layout'
 import { css } from '@/styled-system/css'
 import { Heading } from 'react-aria-components'
 import { text } from '@/primitives/Text'
@@ -199,7 +199,10 @@ export const SidePanel = () => {
       ref={asideRef}
       title={title}
       ariaLabel={t('ariaLabel', { title })}
-      onClose={closeSidePanel}
+      onClose={() => {
+        layoutStore.activePanelId = null
+        layoutStore.activeSubPanelId = null
+      }}
       closeButtonTooltip={t('closeButton', {
         content: t(`content.${activeSubPanelId || activePanelId}`),
       })}

src/frontend/src/features/rooms/livekit/hooks/useIsAdminOrOwner.ts

@@ -1,17 +1,6 @@
-import {
-  useParticipantAttribute,
-  useRoomContext,
-} from '@livekit/components-react'
-import { ParticipantRole } from '@/features/rooms/api/ApiRoom'
+import { useRoomData } from './useRoomData'
 
 export const useIsAdminOrOwner = () => {
-  const room = useRoomContext()
-  const localParticipant = room.localParticipant
-  const role = useParticipantAttribute('room_role', {
-    participant: localParticipant,
-  })
-  return (
-    role !== undefined &&
-    ['administrator', 'owner'].includes(role as ParticipantRole)
-  )
+  const apiRoomData = useRoomData()
+  return apiRoomData?.is_administrable
 }

src/frontend/src/features/rooms/livekit/hooks/usePublishSourcesManager.ts

@@ -8,7 +8,7 @@ import { useRemoteParticipants } from '@livekit/components-react'
 import { useUpdateParticipantsPermissions } from '@/features/rooms/api/updateParticipantsPermissions'
 import { useRoomData } from '@/features/rooms/livekit/hooks/useRoomData'
 import { isSubsetOf } from '@/features/rooms/utils/isSubsetOf'
-import { getParticipantIsRoomAdminOrOwner } from '@/features/rooms/utils/getParticipantIsRoomAdminOrOwner'
+import { getParticipantIsRoomAdmin } from '@/features/rooms/utils/getParticipantIsRoomAdmin'
 import Source = Track.Source
 import {
   NotificationType,
@@ -48,7 +48,7 @@ export const usePublishSourcesManager = () => {
   })
 
   const unprivilegedRemoteParticipants = remoteParticipants.filter(
-    (participant) => !getParticipantIsRoomAdminOrOwner(participant)
+    (participant) => !getParticipantIsRoomAdmin(participant)
   )
 
   const currentSources = useMemo(() => {

src/frontend/src/features/rooms/livekit/hooks/useSyncLiveKitMetadata.ts

@@ -13,8 +13,7 @@ import { useRoomContext } from '@livekit/components-react'
 import { useRoomData } from './useRoomData'
 
 /**
- * Shape of the LiveKit room metadata blob pushed by the backend.
- * Matches RoomManagement.update_metadata → {"configuration": room.configuration}
+ * The subset of LiveKit's room metadata this hook actually uses.
  */
 type RoomLiveKitMetadata = {
   configuration?: RoomConfiguration

src/frontend/src/features/rooms/utils/getParticipantIsAuthenticated.ts

@@ -1,8 +0,0 @@
-import type { Participant } from 'livekit-client'
-
-export const getParticipantIsAuthenticated = (
-  participant: Participant
-): boolean => {
-  const isAuthenticated = participant.attributes?.is_authenticated
-  return isAuthenticated == 'true'
-}

src/frontend/src/features/rooms/utils/getParticipantIsRoomAdmin.ts

@@ -0,0 +1,12 @@
+import type { Participant } from 'livekit-client'
+
+export const getParticipantIsRoomAdmin = (
+  participant: Participant
+): boolean => {
+  const attributes = participant.attributes
+
+  if (!attributes) {
+    return false
+  }
+  return attributes?.room_admin === 'true'
+}

src/frontend/src/features/rooms/utils/getParticipantIsRoomAdminOrOwner.ts

@@ -1,20 +0,0 @@
-import type { Participant } from 'livekit-client'
-import { ParticipantRole } from '@/features/rooms/api/ApiRoom'
-
-const participantHasRoomRole = (
-  participant: Participant,
-  roles: ParticipantRole[]
-): boolean => {
-  const role = participant.attributes?.room_role
-  return role !== undefined && roles.includes(role as ParticipantRole)
-}
-
-export const getParticipantIsRoomAdmin = (participant: Participant): boolean =>
-  participantHasRoomRole(participant, ['administrator'])
-
-export const getParticipantIsRoomOwner = (participant: Participant): boolean =>
-  participantHasRoomRole(participant, ['owner'])
-
-export const getParticipantIsRoomAdminOrOwner = (
-  participant: Participant
-): boolean => participantHasRoomRole(participant, ['administrator', 'owner'])

src/frontend/src/locales/de/rooms.json

@@ -583,7 +583,6 @@
     "you": "Du",
     "unknown": "Unbekannte Person",
     "host": "Host",
-    "cohost": "Co-host",
     "contributors": "Teilnehmende",
     "collapsable": {
       "open": "{{name}}-Liste öffnen",
@@ -628,14 +627,6 @@
     "pin": {
       "label": "Anheften",
       "ariaLabel": "Hefte {{name}} an"
-    },
-    "promote": {
-      "label": "Zum Co-Host machen",
-      "ariaLabel": "{{name}} zum Co-Host machen"
-    },
-    "demote": {
-      "label": "Co-Host-Rolle entfernen",
-      "ariaLabel": "Die Co-Host-Rolle von {{name}} entfernen"
     }
   },
   "pinAnnouncements": {

src/frontend/src/locales/de/termsOfService.json

@@ -19,11 +19,12 @@
       "paragraphs": [
         "Visio ist das Produkt, dessen Nutzung in diesen Bedingungen beschrieben wird und das auf der folgenden Seite vorgestellt ist: https://visio.numerique.gouv.fr.",
         "Nutzerinnen und Nutzer von Visio sind alle Personen, die Visio zu Zwecken der Videokommunikation verwenden, unabhängig davon, ob sie Mitarbeitende, Partner oder Dienstleister der zuständigen Verwaltungen sind. Die zuständige Verwaltung ist die staatliche Verwaltung oder ihr unterstellte Einrichtung, die Visio ihren Mitarbeitenden, Partnern oder Dienstleistern zur Verfügung stellt.",
-        "Raumorganisatorinnen und -organisatoren sind Nutzerinnen und Nutzer, die nach Anmeldung über ProConnect für einen Videokonferenzraum verantwortlich sind."
+        "Raumorganisatorinnen und -organisatoren sind Nutzerinnen und Nutzer, die nach Anmeldung über ProConnect für einen Videokonferenzraum verantwortlich sind.",
+        "Die zuständige Verwaltung ist die Verwaltung, die dem staatlichen Informations- und Kommunikationssystem unterliegt und Visio ihren Mitarbeitenden, Partnern oder Dienstleistern zur Verfügung stellt."
       ]
     },
     "article4": {
-      "title": "4. Zugang zur Anwendung",
+      "title": "4. Zugang zum Dienst",
       "definition": "Visio wird den Nutzerinnen und Nutzern von ihrer zuständigen Verwaltung zur Verfügung gestellt. Organisatorinnen und Organisatoren können anschließend unter eigener Verantwortung einen Zugangslink zum Raum an beliebige Personen weitergeben."
     },
     "article5": {
@@ -32,7 +33,7 @@
         "section1": {
           "title": "5.1. Funktionen für Organisatorinnen und Organisatoren",
           "content": "Visio ermöglicht Mitarbeitenden staatlicher Verwaltungen und ihnen unterstellter Einrichtungen, von einem Standardarbeitsplatz aus einen Videokonferenzraum zu erstellen, der mit ihrem ProConnect-Konto verknüpft ist.",
-          "paragraph1": "Jede Mitarbeiterin und jeder Mitarbeiter des Staates oder einer ihm unterstellten Einrichtung, deren Tätigkeiten mit der Nutzung von Visio vereinbar sind oder die keinen besonderen Vertraulichkeits- oder Berufsgeheimnispflichten unterliegen, kann eine Videokonferenz erstellen und organisieren. Der Einladungslink kann anschließend mit anderen Personen, Nutzerinnen und Nutzern, innerhalb oder außerhalb der Verwaltung geteilt werden.",
+          "paragraph1": "Sie oder er kann anschließend den Besprechungslink mit anderen Personen, Nutzerinnen und Nutzern, teilen, unabhängig davon, ob diese zur Verwaltung gehören oder nicht.",
           "paragraph2": "Zu diesem Zweck kann jede Raumorganisatorin bzw. jeder Raumorganisator:",
           "capabilities": [
             "den Zugang zum Raum durch einen Warteraum schützen;",
@@ -41,7 +42,7 @@
             "eine Nutzerin oder einen Nutzer aus dem Raum entfernen;",
             "das Transkriptionstool der Sitzung nach Einholung der Zustimmung der Nutzerinnen und Nutzer unter eigener Verantwortung verwenden."
           ],
-          "paragraph3": "Nur Mitarbeitende, deren ProConnect-Konto zu einer zur Raumorganisation in Visio berechtigten Domäne gehört oder die keiner besonderen Vertraulichkeits- oder Berufsgeheimnispflicht unterliegen, dürfen die Anwendung und ihre Funktionen nutzen oder kontrollieren.",
+          "paragraph3": "Mitarbeitende sollten sich an ihre zuständige Verwaltung wenden, um den Rahmen der Nutzung von Visio sicherzustellen, insbesondere bei Besprechungen mit erhöhten Vertraulichkeitsanforderungen.",
           "paragraph4": "Das automatische Transkriptionstool kann von Organisatorinnen und Organisatoren über das Einstellungsmenü des Raums genutzt werden. Es liegt in ihrer Verantwortung, die Zustimmung der an der transkribierten Sitzung teilnehmenden Nutzerinnen und Nutzer sicherzustellen. Die Transkriptionssprache kann im selben Menü geändert werden. Am Ende der Sitzung erhält die Organisatorin bzw. der Organisator einen Link zum Zugriff auf die im von der DINUM betriebenen Tool „Docs“ gespeicherte Transkription."
         },
         "section2": {

src/frontend/src/locales/en/rooms.json

@@ -582,7 +582,6 @@
     "you": "You",
     "unknown": "Unknown participant",
     "host": "Host",
-    "cohost": "Co-host",
     "contributors": "Contributors",
     "collapsable": {
       "open": "Open {{name}} list",
@@ -627,14 +626,6 @@
     "pin": {
       "label": "Pin",
       "ariaLabel": "Pin {{name}}"
-    },
-    "promote": {
-      "label": "Make co-host",
-      "ariaLabel": "Make {{name}} a co-host"
-    },
-    "demote": {
-      "label": "Remove co-host role",
-      "ariaLabel": "Remove {{name}}'s co-host role"
     }
   },
   "pinAnnouncements": {

src/frontend/src/locales/en/termsOfService.json

@@ -19,11 +19,12 @@
       "paragraphs": [
         "Visio is the product whose use is described in these terms and presented on the following page: https://visio.numerique.gouv.fr.",
         "Users of Visio are any persons using Visio for videoconferencing communication purposes, whether they are staff members, partners, or service providers of the relevant administrations. The supervising administration is the State administration or body under its supervision that makes Visio available to its staff members, partners, or service providers.",
-        "Room organizers are users who are responsible for a videoconference room after logging in via ProConnect."
+        "Room organizers are users who are responsible for a videoconference room after logging in via ProConnect.",
+        "The supervising administration is the administration that falls under the State information and communication system and makes Visio available to its staff members, partners, or service providers."
       ]
     },
     "article4": {
-      "title": "4. Access to the application",
+      "title": "4. Access to the service",
       "definition": "Visio is made available to users by their supervising administration. Organizers may then share a link granting access to the room with any person, under their responsibility."
     },
     "article5": {
@@ -32,7 +33,7 @@
         "section1": {
           "title": "5.1. Features available to organizers",
           "content": "Visio allows staff of State administrations and bodies under their supervision to create a videoconference room from a standard workstation, linked to their ProConnect account.",
-          "paragraph1": "Any State staff member or staff member of a body under State supervision, whose activities are compatible with the use of Visio or who is not subject to specific confidentiality or professional secrecy obligations, may create and organize a videoconference. They may then share the meeting link with other persons, users, whether or not they belong to the administration.",
+          "paragraph1": "They may then share the meeting link with other persons, users, whether or not they belong to the administration.",
           "paragraph2": "For this purpose, each room organizer may:",
           "capabilities": [
             "Protect access to the room with a waiting room;",
@@ -41,7 +42,7 @@
             "Remove a user from the room;",
             "Use the meeting transcription tool after obtaining the consent of users, under their responsibility."
           ],
-          "paragraph3": "Only staff members whose ProConnect account belongs to a domain authorized to organize rooms on Visio or who are not subject to specific confidentiality or professional secrecy obligations may use or have control over the application and its features.",
+          "paragraph3": "Staff members must contact their supervising administration to ensure the proper framework for using Visio, particularly for meetings subject to heightened confidentiality requirements.",
           "paragraph4": "The automatic transcription tool can be used by organizers from the room settings menu. Organizers are responsible for ensuring the consent of users participating in the transcribed meeting. The transcription language can be changed from the same menu. At the end of the meeting, a link is sent to the organizer to access the transcription stored in the tool called Docs operated by DINUM."
         },
         "section2": {

src/frontend/src/locales/fr/rooms.json

@@ -583,7 +583,6 @@
     "unknown": "Participant inconnu",
     "contributors": "Contributeurs",
     "host": "Organisateur de la réunion",
-    "cohost": "Co-organisateur",
     "collapsable": {
       "open": "Ouvrir la liste {{name}}",
       "close": "Fermer la liste {{name}}"
@@ -627,14 +626,6 @@
     "pin": {
       "label": "Épingler",
       "ariaLabel": "Épingler {{name}}"
-    },
-    "promote": {
-      "label": "Nommer co-organisateur",
-      "ariaLabel": "Nommer {{name}} co-organisateur"
-    },
-    "demote": {
-      "label": "Retirer le rôle de co-organisateur",
-      "ariaLabel": "Retirer le rôle de co-organisateur à {{name}}"
     }
   },
   "pinAnnouncements": {

src/frontend/src/locales/fr/termsOfService.json

@@ -19,11 +19,12 @@
       "paragraphs": [
         "Visio est le produit dont l’utilisation est décrite dans les présentes modalités et présenté sur la page suivante : https://visio.numerique.gouv.fr.",
         "Les utilisateurs et utilisatrices de Visio sont toute personne utilisant Visio à des fins de communication en visioconférence, qu’elles soient des agents, des partenaires ou des prestataires des administrations de rattachement. L’administration de rattachement est l’administration de l’Etat et des organismes sous sa tutelle qui met à disposition Visio à ses agents, partenaires ou prestataires.",
-        "Les organisateurs et organisatrices de salon sont des utilisateurs et utilisatrices qui sont responsables d’un salon de visioconférence après s’être connecté par ProConnect."
+        "Les organisateurs et organisatrices de salon sont des utilisateurs et utilisatrices qui sont responsables d’un salon de visioconférence après s’être connecté par ProConnect.",
+        "L’administration de rattachement est l’administration relevant du système d’information et de communication de l’Etat qui met à disposition Visio à ses agents, partenaires ou prestataires."
       ]
     },
     "article4": {
-      "title": "4. Accès à l’application",
+      "title": "4. Accès au service",
       "definition": "Visio est mis à disposition des utilisateurs et utilisatrices par leur administration de rattachement. Les organisateurs et organisatrices peuvent ensuite transmettre un lien permettant d’accéder au salon à toute personne, sous leur responsabilité."
     },
     "article5": {
@@ -32,7 +33,7 @@
         "section1": {
           "title": "5.1. Fonctionnalités ouvertes aux organisateurs et organisatrices",
           "content": "Visio offre aux agents des administrations de l’Etat et des organismes sous sa tutelle la possibilité de créer un salon de visioconférence depuis un poste de travail standard, lié à leur compte ProConnect.",
-          "paragraph1": "Tout agent de l’État ou d’un organisme sous sa tutelle, dont les activités sont compatibles avec l’utilisation de Visio ou qui n’est pas soumis à des obligations particulières de confidentialité ou de secret professionnel, peut créer et organiser une visioconférence. Il ou elle peut ensuite partager le lien de la réunion avec d’autres personnes, utilisateurs et utilisatrices, qu’elles fassent partie de l’administration ou non.",
+          "paragraph1": "Il ou elle peut ensuite partager le lien de la réunion avec d’autres personnes, utilisateurs et utilisatrices, qu’elles fassent partie de l’administration ou non.",
           "paragraph2": "A cet effet, chaque organisateur ou organisatrice de salon peut :",
           "capabilities": [
             "Protéger l’accès au salon par une salle d’attente ;",
@@ -41,7 +42,7 @@
             "Exclure un utilisateur ou utilisatrice du salon ;",
             "Utiliser l’outil de transcription de la réunion après avoir obtenu l’aval des utilisateurs et des utilisatrices, sous sa responsabilité."
           ],
-          "paragraph3": "Seuls les agents, dont le compte ProConnect relève d’un domaine autorisé à organiser des salons sur Visio ou qui <u>ne sont pas soumis à une obligation de confidentialité particulière ou de secret professionnel</u>, peuvent utiliser ou avoir la maîtrise de l’application et de ses fonctionnalités.",
+          "paragraph3": "Les agents doivent se rapprocher de leur administration de rattachement pour s'assurer du cadre d'utilisation en sein de Visio, notamment en ce qui concerne des réunions soumises à des obligations renforcées de confidentialité.",
           "paragraph4": "L’outil de transcription automatique peut être utilisé par les organisateurs et organisatrices depuis le menu des paramètres du salon. Il appartient aux organisateurs et organisatrices de s’assurer de l’aval des utilisateurs et utilisatrices participants à la réunion transcrite. La langue de transcription peut être modifiée depuis le même menu. À la fin de la réunion, un lien est transmis à l’organisateur ou l’organisatrice pour accéder à la transcription conservée sur l’outil intitulé Docs opéré par la DINUM."
         },
         "section2": {

src/frontend/src/locales/nl/rooms.json

@@ -582,7 +582,6 @@
     "you": "U",
     "unknown": "Onbekende deelnemer",
     "host": "Host",
-    "cohost": "Co-host",
     "contributors": "Deelnemers",
     "collapsable": {
       "open": "Open {{name}} lijst",
@@ -627,14 +626,6 @@
     "pin": {
       "label": "Pinnen",
       "ariaLabel": "Maak {{name}} vast"
-    },
-    "promote": {
-      "label": "Co-host maken",
-      "ariaLabel": "{{name}} co-host maken"
-    },
-    "demote": {
-      "label": "Co-hostrol verwijderen",
-      "ariaLabel": "De co-hostrol van {{name}} verwijderen"
     }
   },
   "pinAnnouncements": {

src/frontend/src/locales/nl/termsOfService.json

@@ -19,11 +19,12 @@
       "paragraphs": [
         "Visio is het product waarvan het gebruik in deze voorwaarden wordt beschreven en dat wordt gepresenteerd op de volgende pagina: https://visio.numerique.gouv.fr.",
         "Gebruikers van Visio zijn alle personen die Visio gebruiken voor videocommunicatiedoeleinden, ongeacht of zij medewerkers, partners of dienstverleners zijn van de betrokken administraties. De bevoegde administratie is de overheidsadministratie of de onder haar toezicht staande instantie die Visio ter beschikking stelt aan haar medewerkers, partners of dienstverleners.",
-        "Ruimteorganisatoren zijn gebruikers die verantwoordelijk zijn voor een videoconferentieruimte na inloggen via ProConnect."
+        "Ruimteorganisatoren zijn gebruikers die verantwoordelijk zijn voor een videoconferentieruimte na inloggen via ProConnect.",
+        "De bevoegde administratie is de administratie die onder het informatie- en communicatiesysteem van de Staat valt en Visio ter beschikking stelt aan haar medewerkers, partners of dienstverleners."
       ]
     },
     "article4": {
-      "title": "4. Toegang tot de applicatie",
+      "title": "4. Toegang tot de dienst",
       "definition": "Visio wordt aan gebruikers ter beschikking gesteld door hun bevoegde administratie. Organisatoren kunnen vervolgens, onder hun verantwoordelijkheid, een toegangslink tot de ruimte delen met elke persoon."
     },
     "article5": {
@@ -32,7 +33,7 @@
         "section1": {
           "title": "5.1. Functionaliteiten voor organisatoren",
           "content": "Visio biedt medewerkers van overheidsadministraties en onder hun toezicht staande instanties de mogelijkheid om vanaf een standaardwerkstation een videoconferentieruimte aan te maken, gekoppeld aan hun ProConnect-account.",
-          "paragraph1": "Elke medewerker van de Staat of van een onder zijn toezicht staande instantie, van wie de activiteiten verenigbaar zijn met het gebruik van Visio of die niet onder specifieke vertrouwelijkheids- of beroepsgeheimverplichtingen valt, kan een videoconferentie aanmaken en organiseren. De vergaderlink kan vervolgens worden gedeeld met andere personen, gebruikers, binnen of buiten de administratie.",
+          "paragraph1": "Hij of zij kan vervolgens de vergaderlink delen met andere personen, gebruikers, of zij nu wel of niet deel uitmaken van de administratie.",
           "paragraph2": "Daartoe kan elke ruimteorganisator:",
           "capabilities": [
             "de toegang tot de ruimte beveiligen met een wachtruimte;",
@@ -41,7 +42,7 @@
             "een gebruiker uit de ruimte verwijderen;",
             "de transcriptietool van de vergadering gebruiken na toestemming van de gebruikers, onder eigen verantwoordelijkheid."
           ],
-          "paragraph3": "Alleen medewerkers van wie het ProConnect-account behoort tot een domein dat gemachtigd is om ruimtes op Visio te organiseren, of die niet onder specifieke vertrouwelijkheids- of beroepsgeheimverplichtingen vallen, mogen de applicatie en haar functionaliteiten gebruiken of beheren.",
+          "paragraph3": "Medewerkers moeten contact opnemen met hun bevoegde administratie om zeker te zijn van het gebruikskader binnen Visio, met name voor vergaderingen waarvoor strengere vertrouwelijkheidsverplichtingen gelden.",
           "paragraph4": "De automatische transcriptietool kan door organisatoren worden gebruikt via het instellingenmenu van de ruimte. Het is de verantwoordelijkheid van de organisatoren om de toestemming te verkrijgen van de gebruikers die deelnemen aan de getranscribeerde vergadering. De transcriptietaal kan in hetzelfde menu worden gewijzigd. Aan het einde van de vergadering ontvangt de organisator een link om de transcriptie te raadplegen die wordt bewaard in de door DINUM beheerde tool “Docs”."
         },
         "section2": {

src/frontend/src/stores/chat.ts

@@ -64,6 +64,7 @@ export const clearTextAreaValue = () => {
 }
 
 export function resetChatStore() {
+  console.count('resetChatStore')
   Object.assign(chatStore, {
     ...initialState,
     rows: [],

src/frontend/src/stores/layout.ts

@@ -34,8 +34,3 @@ export const setPinnedTrack = (trackRef: TrackReferenceOrPlaceholder): void => {
 export const clearPinnedTrack = (): void => {
   layoutStore.pinnedTrackRef = undefined
 }
-
-export const closeSidePanel = (): void => {
-  layoutStore.activePanelId = null
-  layoutStore.activeSubPanelId = null
-}