fix(rtc): satisfy mypy strict and preserve track cleanup on unpublish race

Address two issues from review of the local_track_unpublished fix:

1. mypy strict (CI gate) flagged room.py: `pop(sid, None)` was assigned to
   `lpublication`, which is also bound to `track_publications[sid]`
   (non-optional LocalTrackPublication) in sibling branches of the same
   method. mypy fixes the variable's type from that first binding and pushes
   it as the expected return type into `pop`, selecting the
   `pop(key, default: _VT) -> _VT` overload and rejecting None. Use a fresh
   variable with `.get()` + conditional `del`, mirroring the existing
   local_track_republished handler, which already passes the gate.

2. With the handler now removing the publication first in the common
   ordering, unpublish_track's `pop(track_sid, None)` returned None and
   skipped the `_track = None` cleanup, leaving a LocalTrackPublication
   reference held by application code reporting a stale non-None track after
   `await unpublish_track(...)` completed. Capture the publication reference
   before the FFI round-trip so the track is cleared once unpublish
   completes regardless of which path removes it from the dict.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: tmkarthi

livekit-rtc/livekit/rtc/participant.py

@@ -784,6 +784,13 @@ async def unpublish_track(self, track_sid: str) -> None:
         Raises:
             UnpublishTrackError: If there is an error in unpublishing the track.
         """
+        # Capture the publication before the FFI round-trip. The
+        # local_track_unpublished room event races this async response and may
+        # remove it from _track_publications first; holding our own reference
+        # guarantees the track is cleared once unpublish completes, regardless
+        # of which path removes the publication from the dict.
+        publication = self._track_publications.get(track_sid)
+
         req = proto_ffi.FfiRequest()
         req.unpublish_track.local_participant_handle = self._ffi_handle.handle
         req.unpublish_track.track_sid = track_sid
@@ -799,10 +806,9 @@ async def unpublish_track(self, track_sid: str) -> None:
             if cb.unpublish_track.error:
                 raise UnpublishTrackError(cb.unpublish_track.error)
 
-            # The local_track_unpublished room event may have already removed
-            # this publication from the dict (the FFI event and this async
-            # response race during teardown), so pop defensively.
-            publication = self._track_publications.pop(track_sid, None)
+            # Remove defensively: the room-event handler may already have done
+            # so when it processed local_track_unpublished first.
+            self._track_publications.pop(track_sid, None)
             if publication is not None:
                 publication._track = None
             queue.task_done()

livekit-rtc/livekit/rtc/room.py

@@ -737,19 +737,18 @@ def _on_room_event(self, event: proto_room.RoomEvent) -> None:
         elif which == "local_track_unpublished":
             # During teardown the publication may already have been removed
             # from the participant's dict by LocalParticipant.unpublish_track
-            # (or by a previously processed event), so the SID can be gone by
-            # the time this event is dispatched. Pop defensively and skip the
-            # emit when it is no longer tracked, mirroring the remote
-            # track_unpublished and local_track_republished handlers, instead
-            # of raising a KeyError that _listen_task logs as an error.
+            # (the FFI event races that async response), so the SID can be gone
+            # by the time this event is dispatched. Look it up defensively and
+            # skip the emit when it is no longer tracked, mirroring the
+            # local_track_republished and remote track_unpublished handlers,
+            # instead of raising a KeyError that _listen_task logs as an error.
             sid = event.local_track_unpublished.publication_sid
-            lpublication = self.local_participant._track_publications.pop(sid, None)
-            if lpublication is not None:
-                self.emit("local_track_unpublished", lpublication)
+            unpublished = self.local_participant._track_publications.get(sid)
+            if unpublished is not None:
+                del self.local_participant._track_publications[sid]
+                self.emit("local_track_unpublished", unpublished)
             else:
-                logging.debug(
-                    "local_track_unpublished for untracked publication sid %s", sid
-                )
+                logging.debug("local_track_unpublished for untracked publication sid %s", sid)
         elif which == "local_track_republished":
             # The SDK auto-republished a local track during a full
             # reconnect: the underlying Track (and its bound source) is