fix(rtc): avoid KeyError in local_track_unpublished handler during teardown

Room._on_room_event did an unchecked
`self.local_participant.track_publications[sid]` lookup on the
`local_track_unpublished` branch. LocalParticipant.unpublish_track
removes the publication from `_track_publications` when its FFI async
response is processed, and that response races the `local_track_unpublished`
room event. When the response is handled first, the SID is already gone and
the handler raises KeyError, which _listen_task logs as a spurious ERROR
with a full traceback on every affected disconnect cleanup.

Pop the publication defensively in the handler and only emit when it is
still tracked, mirroring the remote `track_unpublished` and
`local_track_republished` handlers. This also folds removal into the
handler, fixing a latent leak where a server-forced unpublish (no
unpublish_track call) left the publication in the dict.

Because the handler now owns removal, the common (non-racing) ordering is
that the room event is processed before unpublish_track's pop. Make
unpublish_track's pop tolerant (`pop(track_sid, None)` + guarded
`_track = None`) so it does not raise a new KeyError once the handler has
already removed the publication.

Fixes #681

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

Author: tmkarthi

livekit-rtc/livekit/rtc/participant.py

@@ -799,8 +799,12 @@ async def unpublish_track(self, track_sid: str) -> None:
             if cb.unpublish_track.error:
                 raise UnpublishTrackError(cb.unpublish_track.error)
 
-            publication = self._track_publications.pop(track_sid)
-            publication._track = None
+            # 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)
+            if publication is not None:
+                publication._track = None
             queue.task_done()
         finally:
             self._room_queue.unsubscribe(queue)

livekit-rtc/livekit/rtc/room.py

@@ -735,9 +735,21 @@ def _on_room_event(self, event: proto_room.RoomEvent) -> None:
             ltrack = lpublication.track
             self.emit("local_track_published", lpublication, ltrack)
         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.
             sid = event.local_track_unpublished.publication_sid
-            lpublication = self.local_participant.track_publications[sid]
-            self.emit("local_track_unpublished", lpublication)
+            lpublication = self.local_participant._track_publications.pop(sid, None)
+            if lpublication is not None:
+                self.emit("local_track_unpublished", lpublication)
+            else:
+                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