dv-pipecat-ai 0.0.74.dev770__py3-none-any.whl → 0.0.82.dev776__py3-none-any.whl

pipecat/transports/services/livekit.py

@@ -4,6 +4,13 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
+"""LiveKit transport implementation for Pipecat.
+
+This module provides comprehensive LiveKit real-time communication integration
+including audio streaming, data messaging, participant management, and room
+event handling for conversational AI applications.
+"""
+
 import asyncio
 from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, List, Optional
@@ -11,7 +18,7 @@ from typing import Any, Awaitable, Callable, List, Optional
 from loguru import logger
 from pydantic import BaseModel
 
-from pipecat.audio.utils import create_default_resampler
+from pipecat.audio.utils import create_stream_resampler
 from pipecat.audio.vad.vad_analyzer import VADAnalyzer
 from pipecat.frames.frames import (
     AudioRawFrame,
@@ -28,7 +35,6 @@ from pipecat.transports.base_input import BaseInputTransport
 from pipecat.transports.base_output import BaseOutputTransport
 from pipecat.transports.base_transport import BaseTransport, TransportParams
 from pipecat.utils.asyncio.task_manager import BaseTaskManager
-from pipecat.utils.asyncio.watchdog_async_iterator import WatchdogAsyncIterator
 
 try:
     from livekit import rtc
@@ -41,19 +47,49 @@ except ModuleNotFoundError as e:
 
 @dataclass
 class LiveKitTransportMessageFrame(TransportMessageFrame):
+    """Frame for transport messages in LiveKit rooms.
+
+    Parameters:
+        participant_id: Optional ID of the participant this message is for/from.
+    """
+
     participant_id: Optional[str] = None
 
 
 @dataclass
 class LiveKitTransportMessageUrgentFrame(TransportMessageUrgentFrame):
+    """Frame for urgent transport messages in LiveKit rooms.
+
+    Parameters:
+        participant_id: Optional ID of the participant this message is for/from.
+    """
+
     participant_id: Optional[str] = None
 
 
 class LiveKitParams(TransportParams):
+    """Configuration parameters for LiveKit transport.
+
+    Inherits all parameters from TransportParams without additional configuration.
+    """
+
     pass
 
 
 class LiveKitCallbacks(BaseModel):
+    """Callback handlers for LiveKit events.
+
+    Parameters:
+        on_connected: Called when connected to the LiveKit room.
+        on_disconnected: Called when disconnected from the LiveKit room.
+        on_participant_connected: Called when a participant joins the room.
+        on_participant_disconnected: Called when a participant leaves the room.
+        on_audio_track_subscribed: Called when an audio track is subscribed.
+        on_audio_track_unsubscribed: Called when an audio track is unsubscribed.
+        on_data_received: Called when data is received from a participant.
+        on_first_participant_joined: Called when the first participant joins.
+    """
+
     on_connected: Callable[[], Awaitable[None]]
     on_disconnected: Callable[[], Awaitable[None]]
     on_participant_connected: Callable[[str], Awaitable[None]]
@@ -65,6 +101,12 @@ class LiveKitCallbacks(BaseModel):
 
 
 class LiveKitTransportClient:
+    """Core client for interacting with LiveKit rooms.
+
+    Manages the connection to LiveKit rooms and handles all low-level API interactions
+    including room management, audio streaming, data messaging, and event handling.
+    """
+
     def __init__(
         self,
         url: str,
@@ -74,6 +116,16 @@ class LiveKitTransportClient:
         callbacks: LiveKitCallbacks,
         transport_name: str,
     ):
+        """Initialize the LiveKit transport client.
+
+        Args:
+            url: LiveKit server URL to connect to.
+            token: Authentication token for the room.
+            room_name: Name of the LiveKit room to join.
+            params: Configuration parameters for the transport.
+            callbacks: Event callback handlers.
+            transport_name: Name identifier for the transport.
+        """
         self._url = url
         self._token = token
         self._room_name = room_name
@@ -93,15 +145,33 @@ class LiveKitTransportClient:
 
     @property
     def participant_id(self) -> str:
+        """Get the participant ID for this client.
+
+        Returns:
+            The participant ID assigned by LiveKit.
+        """
         return self._participant_id
 
     @property
     def room(self) -> rtc.Room:
+        """Get the LiveKit room instance.
+
+        Returns:
+            The LiveKit room object.
+
+        Raises:
+            Exception: If room object is not available.
+        """
         if not self._room:
             raise Exception(f"{self}: missing room object (pipeline not started?)")
         return self._room
 
     async def setup(self, setup: FrameProcessorSetup):
+        """Setup the client with task manager and room initialization.
+
+        Args:
+            setup: The frame processor setup configuration.
+        """
         if self._task_manager:
             return
 
@@ -118,13 +188,20 @@ class LiveKitTransportClient:
         self.room.on("disconnected")(self._on_disconnected_wrapper)
 
     async def cleanup(self):
+        """Cleanup client resources."""
         await self.disconnect()
 
     async def start(self, frame: StartFrame):
+        """Start the client and initialize audio components.
+
+        Args:
+            frame: The start frame containing initialization parameters.
+        """
         self._out_sample_rate = self._params.audio_out_sample_rate or frame.audio_out_sample_rate
 
     @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
     async def connect(self):
+        """Connect to the LiveKit room with retry logic."""
         if self._connected:
             # Increment disconnect counter if already connected.
             self._disconnect_counter += 1
@@ -168,6 +245,7 @@ class LiveKitTransportClient:
             raise
 
     async def disconnect(self):
+        """Disconnect from the LiveKit room."""
         # Decrement leave counter when leaving.
         self._disconnect_counter -= 1
 
@@ -181,6 +259,12 @@ class LiveKitTransportClient:
         await self._callbacks.on_disconnected()
 
     async def send_data(self, data: bytes, participant_id: Optional[str] = None):
+        """Send data to participants in the room.
+
+        Args:
+            data: The data bytes to send.
+            participant_id: Optional specific participant to send to.
+        """
         if not self._connected:
             return
 
@@ -195,6 +279,11 @@ class LiveKitTransportClient:
             logger.error(f"Error sending data: {e}")
 
     async def publish_audio(self, audio_frame: rtc.AudioFrame):
+        """Publish an audio frame to the room.
+
+        Args:
+            audio_frame: The LiveKit audio frame to publish.
+        """
         if not self._connected or not self._audio_source:
             return
 
@@ -204,9 +293,22 @@ class LiveKitTransportClient:
             logger.error(f"Error publishing audio: {e}")
 
     def get_participants(self) -> List[str]:
+        """Get list of participant IDs in the room.
+
+        Returns:
+            List of participant IDs.
+        """
         return [p.sid for p in self.room.remote_participants.values()]
 
     async def get_participant_metadata(self, participant_id: str) -> dict:
+        """Get metadata for a specific participant.
+
+        Args:
+            participant_id: ID of the participant to get metadata for.
+
+        Returns:
+            Dictionary containing participant metadata.
+        """
         participant = self.room.remote_participants.get(participant_id)
         if participant:
             return {
@@ -218,9 +320,19 @@ class LiveKitTransportClient:
         return {}
 
     async def set_participant_metadata(self, metadata: str):
+        """Set metadata for the local participant.
+
+        Args:
+            metadata: Metadata string to set.
+        """
         await self.room.local_participant.set_metadata(metadata)
 
     async def mute_participant(self, participant_id: str):
+        """Mute a specific participant's audio tracks.
+
+        Args:
+            participant_id: ID of the participant to mute.
+        """
         participant = self.room.remote_participants.get(participant_id)
         if participant:
             for track in participant.tracks.values():
@@ -228,6 +340,11 @@ class LiveKitTransportClient:
                     await track.set_enabled(False)
 
     async def unmute_participant(self, participant_id: str):
+        """Unmute a specific participant's audio tracks.
+
+        Args:
+            participant_id: ID of the participant to unmute.
+        """
         participant = self.room.remote_participants.get(participant_id)
         if participant:
             for track in participant.tracks.values():
@@ -236,12 +353,14 @@ class LiveKitTransportClient:
 
     # Wrapper methods for event handlers
     def _on_participant_connected_wrapper(self, participant: rtc.RemoteParticipant):
+        """Wrapper for participant connected events."""
         self._task_manager.create_task(
             self._async_on_participant_connected(participant),
             f"{self}::_async_on_participant_connected",
         )
 
     def _on_participant_disconnected_wrapper(self, participant: rtc.RemoteParticipant):
+        """Wrapper for participant disconnected events."""
         self._task_manager.create_task(
             self._async_on_participant_disconnected(participant),
             f"{self}::_async_on_participant_disconnected",
@@ -253,6 +372,7 @@ class LiveKitTransportClient:
         publication: rtc.RemoteTrackPublication,
         participant: rtc.RemoteParticipant,
     ):
+        """Wrapper for track subscribed events."""
         self._task_manager.create_task(
             self._async_on_track_subscribed(track, publication, participant),
             f"{self}::_async_on_track_subscribed",
@@ -264,27 +384,32 @@ class LiveKitTransportClient:
         publication: rtc.RemoteTrackPublication,
         participant: rtc.RemoteParticipant,
     ):
+        """Wrapper for track unsubscribed events."""
         self._task_manager.create_task(
             self._async_on_track_unsubscribed(track, publication, participant),
             f"{self}::_async_on_track_unsubscribed",
         )
 
     def _on_data_received_wrapper(self, data: rtc.DataPacket):
+        """Wrapper for data received events."""
         self._task_manager.create_task(
             self._async_on_data_received(data),
             f"{self}::_async_on_data_received",
         )
 
     def _on_connected_wrapper(self):
+        """Wrapper for connected events."""
         self._task_manager.create_task(self._async_on_connected(), f"{self}::_async_on_connected")
 
     def _on_disconnected_wrapper(self):
+        """Wrapper for disconnected events."""
         self._task_manager.create_task(
             self._async_on_disconnected(), f"{self}::_async_on_disconnected"
         )
 
     # Async methods for event handling
     async def _async_on_participant_connected(self, participant: rtc.RemoteParticipant):
+        """Handle participant connected events."""
         logger.info(f"Participant connected: {participant.identity}")
         await self._callbacks.on_participant_connected(participant.sid)
         if not self._other_participant_has_joined:
@@ -292,6 +417,7 @@ class LiveKitTransportClient:
             await self._callbacks.on_first_participant_joined(participant.sid)
 
     async def _async_on_participant_disconnected(self, participant: rtc.RemoteParticipant):
+        """Handle participant disconnected events."""
         logger.info(f"Participant disconnected: {participant.identity}")
         await self._callbacks.on_participant_disconnected(participant.sid)
         if len(self.get_participants()) == 0:
@@ -303,6 +429,7 @@ class LiveKitTransportClient:
         publication: rtc.RemoteTrackPublication,
         participant: rtc.RemoteParticipant,
     ):
+        """Handle track subscribed events."""
         if track.kind == rtc.TrackKind.KIND_AUDIO:
             logger.info(f"Audio track subscribed: {track.sid} from participant {participant.sid}")
             self._audio_tracks[participant.sid] = track
@@ -311,6 +438,7 @@ class LiveKitTransportClient:
                 self._process_audio_stream(audio_stream, participant.sid),
                 f"{self}::_process_audio_stream",
             )
+            await self._callbacks.on_audio_track_subscribed(participant.sid)
 
     async def _async_on_track_unsubscribed(
         self,
@@ -318,22 +446,27 @@ class LiveKitTransportClient:
         publication: rtc.RemoteTrackPublication,
         participant: rtc.RemoteParticipant,
     ):
+        """Handle track unsubscribed events."""
         logger.info(f"Track unsubscribed: {publication.sid} from {participant.identity}")
         if track.kind == rtc.TrackKind.KIND_AUDIO:
             await self._callbacks.on_audio_track_unsubscribed(participant.sid)
 
     async def _async_on_data_received(self, data: rtc.DataPacket):
+        """Handle data received events."""
         await self._callbacks.on_data_received(data.data, data.participant.sid)
 
     async def _async_on_connected(self):
+        """Handle connected events."""
         await self._callbacks.on_connected()
 
     async def _async_on_disconnected(self, reason=None):
+        """Handle disconnected events."""
         self._connected = False
         logger.info(f"Disconnected from {self._room_name}. Reason: {reason}")
         await self._callbacks.on_disconnected()
 
     async def _process_audio_stream(self, audio_stream: rtc.AudioStream, participant_id: str):
+        """Process incoming audio stream from a participant."""
         logger.info(f"Started processing audio stream for participant {participant_id}")
         async for event in audio_stream:
             if isinstance(event, rtc.AudioFrameEvent):
@@ -342,15 +475,23 @@ class LiveKitTransportClient:
                 logger.warning(f"Received unexpected event type: {type(event)}")
 
     async def get_next_audio_frame(self):
+        """Get the next audio frame from the queue."""
         while True:
             frame, participant_id = await self._audio_queue.get()
             yield frame, participant_id
 
     def __str__(self):
+        """String representation of the LiveKit transport client."""
         return f"{self._transport_name}::LiveKitTransportClient"
 
 
 class LiveKitInputTransport(BaseInputTransport):
+    """Handles incoming media streams and events from LiveKit rooms.
+
+    Processes incoming audio streams from room participants and forwards them
+    as Pipecat frames, including audio resampling and VAD integration.
+    """
+
     def __init__(
         self,
         transport: BaseTransport,
@@ -358,22 +499,40 @@ class LiveKitInputTransport(BaseInputTransport):
         params: LiveKitParams,
         **kwargs,
     ):
+        """Initialize the LiveKit input transport.
+
+        Args:
+            transport: The parent transport instance.
+            client: LiveKitTransportClient instance.
+            params: Configuration parameters.
+            **kwargs: Additional arguments passed to parent class.
+        """
         super().__init__(params, **kwargs)
         self._transport = transport
         self._client = client
 
         self._audio_in_task = None
         self._vad_analyzer: Optional[VADAnalyzer] = params.vad_analyzer
-        self._resampler = create_default_resampler()
+        self._resampler = create_stream_resampler()
 
         # Whether we have seen a StartFrame already.
         self._initialized = False
 
     @property
     def vad_analyzer(self) -> Optional[VADAnalyzer]:
+        """Get the Voice Activity Detection analyzer.
+
+        Returns:
+            The VAD analyzer instance if configured.
+        """
         return self._vad_analyzer
 
     async def start(self, frame: StartFrame):
+        """Start the input transport and connect to LiveKit room.
+
+        Args:
+            frame: The start frame containing initialization parameters.
+        """
         await super().start(frame)
 
         if self._initialized:
@@ -389,6 +548,11 @@ class LiveKitInputTransport(BaseInputTransport):
         logger.info("LiveKitInputTransport started")
 
     async def stop(self, frame: EndFrame):
+        """Stop the input transport and disconnect from LiveKit room.
+
+        Args:
+            frame: The end frame signaling transport shutdown.
+        """
         await super().stop(frame)
         await self._client.disconnect()
         if self._audio_in_task:
@@ -396,32 +560,55 @@ class LiveKitInputTransport(BaseInputTransport):
         logger.info("LiveKitInputTransport stopped")
 
     async def cancel(self, frame: CancelFrame):
+        """Cancel the input transport and disconnect from LiveKit room.
+
+        Args:
+            frame: The cancel frame signaling immediate cancellation.
+        """
         await super().cancel(frame)
         await self._client.disconnect()
         if self._audio_in_task and self._params.audio_in_enabled:
             await self.cancel_task(self._audio_in_task)
 
     async def setup(self, setup: FrameProcessorSetup):
+        """Setup the input transport with shared client setup.
+
+        Args:
+            setup: The frame processor setup configuration.
+        """
         await super().setup(setup)
         await self._client.setup(setup)
 
     async def cleanup(self):
+        """Cleanup input transport and shared resources."""
         await super().cleanup()
         await self._transport.cleanup()
 
     async def push_app_message(self, message: Any, sender: str):
+        """Push an application message as an urgent transport frame.
+
+        Args:
+            message: The message data to send.
+            sender: ID of the message sender.
+        """
         frame = LiveKitTransportMessageUrgentFrame(message=message, participant_id=sender)
         await self.push_frame(frame)
 
     async def _audio_in_task_handler(self):
+        """Handle incoming audio frames from participants."""
         logger.info("Audio input task started")
         audio_iterator = self._client.get_next_audio_frame()
-        async for audio_data in WatchdogAsyncIterator(audio_iterator, manager=self.task_manager):
+        async for audio_data in audio_iterator:
             if audio_data:
                 audio_frame_event, participant_id = audio_data
                 pipecat_audio_frame = await self._convert_livekit_audio_to_pipecat(
                     audio_frame_event
                 )
+
+                # Skip frames with no audio data
+                if len(pipecat_audio_frame.audio) == 0:
+                    continue
+
                 input_audio_frame = UserAudioRawFrame(
                     user_id=participant_id,
                     audio=pipecat_audio_frame.audio,
@@ -433,6 +620,7 @@ class LiveKitInputTransport(BaseInputTransport):
     async def _convert_livekit_audio_to_pipecat(
         self, audio_frame_event: rtc.AudioFrameEvent
     ) -> AudioRawFrame:
+        """Convert LiveKit audio frame to Pipecat audio frame."""
         audio_frame = audio_frame_event.frame
 
         audio_data = await self._resampler.resample(
@@ -447,6 +635,12 @@ class LiveKitInputTransport(BaseInputTransport):
 
 
 class LiveKitOutputTransport(BaseOutputTransport):
+    """Handles outgoing media streams and events to LiveKit rooms.
+
+    Manages sending audio frames and data messages to LiveKit room participants,
+    including audio format conversion for LiveKit compatibility.
+    """
+
     def __init__(
         self,
         transport: BaseTransport,
@@ -454,6 +648,14 @@ class LiveKitOutputTransport(BaseOutputTransport):
         params: LiveKitParams,
         **kwargs,
     ):
+        """Initialize the LiveKit output transport.
+
+        Args:
+            transport: The parent transport instance.
+            client: LiveKitTransportClient instance.
+            params: Configuration parameters.
+            **kwargs: Additional arguments passed to parent class.
+        """
         super().__init__(params, **kwargs)
         self._transport = transport
         self._client = client
@@ -462,6 +664,11 @@ class LiveKitOutputTransport(BaseOutputTransport):
         self._initialized = False
 
     async def start(self, frame: StartFrame):
+        """Start the output transport and connect to LiveKit room.
+
+        Args:
+            frame: The start frame containing initialization parameters.
+        """
         await super().start(frame)
 
         if self._initialized:
@@ -475,33 +682,60 @@ class LiveKitOutputTransport(BaseOutputTransport):
         logger.info("LiveKitOutputTransport started")
 
     async def stop(self, frame: EndFrame):
+        """Stop the output transport and disconnect from LiveKit room.
+
+        Args:
+            frame: The end frame signaling transport shutdown.
+        """
         await super().stop(frame)
         await self._client.disconnect()
         logger.info("LiveKitOutputTransport stopped")
 
     async def cancel(self, frame: CancelFrame):
+        """Cancel the output transport and disconnect from LiveKit room.
+
+        Args:
+            frame: The cancel frame signaling immediate cancellation.
+        """
         await super().cancel(frame)
         await self._client.disconnect()
 
     async def setup(self, setup: FrameProcessorSetup):
+        """Setup the output transport with shared client setup.
+
+        Args:
+            setup: The frame processor setup configuration.
+        """
         await super().setup(setup)
         await self._client.setup(setup)
 
     async def cleanup(self):
+        """Cleanup output transport and shared resources."""
         await super().cleanup()
         await self._transport.cleanup()
 
     async def send_message(self, frame: TransportMessageFrame | TransportMessageUrgentFrame):
+        """Send a transport message to participants.
+
+        Args:
+            frame: The transport message frame to send.
+        """
         if isinstance(frame, (LiveKitTransportMessageFrame, LiveKitTransportMessageUrgentFrame)):
             await self._client.send_data(frame.message.encode(), frame.participant_id)
         else:
             await self._client.send_data(frame.message.encode())
 
     async def write_audio_frame(self, frame: OutputAudioRawFrame):
+        """Write an audio frame to the LiveKit room.
+
+        Args:
+            frame: The audio frame to write.
+        """
         livekit_audio = self._convert_pipecat_audio_to_livekit(frame.audio)
         await self._client.publish_audio(livekit_audio)
 
     def _convert_pipecat_audio_to_livekit(self, pipecat_audio: bytes) -> rtc.AudioFrame:
+        """Convert Pipecat audio data to LiveKit audio frame."""
         bytes_per_sample = 2  # Assuming 16-bit audio
         total_samples = len(pipecat_audio) // bytes_per_sample
         samples_per_channel = total_samples // self._params.audio_out_channels
@@ -515,6 +749,13 @@ class LiveKitOutputTransport(BaseOutputTransport):
 
 
 class LiveKitTransport(BaseTransport):
+    """Transport implementation for LiveKit real-time communication.
+
+    Provides comprehensive LiveKit integration including audio streaming, data
+    messaging, participant management, and room event handling for conversational
+    AI applications.
+    """
+
     def __init__(
         self,
         url: str,
@@ -524,6 +765,16 @@ class LiveKitTransport(BaseTransport):
         input_name: Optional[str] = None,
         output_name: Optional[str] = None,
     ):
+        """Initialize the LiveKit transport.
+
+        Args:
+            url: LiveKit server URL to connect to.
+            token: Authentication token for the room.
+            room_name: Name of the LiveKit room to join.
+            params: Configuration parameters for the transport.
+            input_name: Optional name for the input transport.
+            output_name: Optional name for the output transport.
+        """
         super().__init__(input_name=input_name, output_name=output_name)
 
         callbacks = LiveKitCallbacks(
@@ -556,6 +807,11 @@ class LiveKitTransport(BaseTransport):
         self._register_event_handler("on_call_state_updated")
 
     def input(self) -> LiveKitInputTransport:
+        """Get the input transport for receiving media and events.
+
+        Returns:
+            The LiveKit input transport instance.
+        """
         if not self._input:
             self._input = LiveKitInputTransport(
                 self, self._client, self._params, name=self._input_name
@@ -563,6 +819,11 @@ class LiveKitTransport(BaseTransport):
         return self._input
 
     def output(self) -> LiveKitOutputTransport:
+        """Get the output transport for sending media and events.
+
+        Returns:
+            The LiveKit output transport instance.
+        """
         if not self._output:
             self._output = LiveKitOutputTransport(
                 self, self._client, self._params, name=self._output_name
@@ -571,41 +832,84 @@ class LiveKitTransport(BaseTransport):
 
     @property
     def participant_id(self) -> str:
+        """Get the participant ID for this transport.
+
+        Returns:
+            The participant ID assigned by LiveKit.
+        """
         return self._client.participant_id
 
     async def send_audio(self, frame: OutputAudioRawFrame):
+        """Send an audio frame to the LiveKit room.
+
+        Args:
+            frame: The audio frame to send.
+        """
         if self._output:
             await self._output.queue_frame(frame, FrameDirection.DOWNSTREAM)
 
     def get_participants(self) -> List[str]:
+        """Get list of participant IDs in the room.
+
+        Returns:
+            List of participant IDs.
+        """
         return self._client.get_participants()
 
     async def get_participant_metadata(self, participant_id: str) -> dict:
+        """Get metadata for a specific participant.
+
+        Args:
+            participant_id: ID of the participant to get metadata for.
+
+        Returns:
+            Dictionary containing participant metadata.
+        """
         return await self._client.get_participant_metadata(participant_id)
 
     async def set_metadata(self, metadata: str):
+        """Set metadata for the local participant.
+
+        Args:
+            metadata: Metadata string to set.
+        """
         await self._client.set_participant_metadata(metadata)
 
     async def mute_participant(self, participant_id: str):
+        """Mute a specific participant's audio tracks.
+
+        Args:
+            participant_id: ID of the participant to mute.
+        """
         await self._client.mute_participant(participant_id)
 
     async def unmute_participant(self, participant_id: str):
+        """Unmute a specific participant's audio tracks.
+
+        Args:
+            participant_id: ID of the participant to unmute.
+        """
         await self._client.unmute_participant(participant_id)
 
     async def _on_connected(self):
+        """Handle room connected events."""
         await self._call_event_handler("on_connected")
 
     async def _on_disconnected(self):
+        """Handle room disconnected events."""
         await self._call_event_handler("on_disconnected")
 
     async def _on_participant_connected(self, participant_id: str):
+        """Handle participant connected events."""
         await self._call_event_handler("on_participant_connected", participant_id)
 
     async def _on_participant_disconnected(self, participant_id: str):
+        """Handle participant disconnected events."""
         await self._call_event_handler("on_participant_disconnected", participant_id)
         await self._call_event_handler("on_participant_left", participant_id, "disconnected")
 
     async def _on_audio_track_subscribed(self, participant_id: str):
+        """Handle audio track subscribed events."""
         await self._call_event_handler("on_audio_track_subscribed", participant_id)
         participant = self._client.room.remote_participants.get(participant_id)
         if participant:
@@ -615,19 +919,33 @@ class LiveKitTransport(BaseTransport):
                 )
 
     async def _on_audio_track_unsubscribed(self, participant_id: str):
+        """Handle audio track unsubscribed events."""
         await self._call_event_handler("on_audio_track_unsubscribed", participant_id)
 
     async def _on_data_received(self, data: bytes, participant_id: str):
+        """Handle data received events."""
         if self._input:
             await self._input.push_app_message(data.decode(), participant_id)
         await self._call_event_handler("on_data_received", data, participant_id)
 
     async def send_message(self, message: str, participant_id: Optional[str] = None):
+        """Send a message to participants in the room.
+
+        Args:
+            message: The message string to send.
+            participant_id: Optional specific participant to send to.
+        """
         if self._output:
             frame = LiveKitTransportMessageFrame(message=message, participant_id=participant_id)
             await self._output.send_message(frame)
 
     async def send_message_urgent(self, message: str, participant_id: Optional[str] = None):
+        """Send an urgent message to participants in the room.
+
+        Args:
+            message: The urgent message string to send.
+            participant_id: Optional specific participant to send to.
+        """
         if self._output:
             frame = LiveKitTransportMessageUrgentFrame(
                 message=message, participant_id=participant_id
@@ -635,19 +953,36 @@ class LiveKitTransport(BaseTransport):
             await self._output.send_message(frame)
 
     async def on_room_event(self, event):
+        """Handle room events.
+
+        Args:
+            event: The room event to handle.
+        """
         # Handle room events
         pass
 
     async def on_participant_event(self, event):
+        """Handle participant events.
+
+        Args:
+            event: The participant event to handle.
+        """
         # Handle participant events
         pass
 
     async def on_track_event(self, event):
+        """Handle track events.
+
+        Args:
+            event: The track event to handle.
+        """
         # Handle track events
         pass
 
     async def _on_call_state_updated(self, state: str):
+        """Handle call state update events."""
         await self._call_event_handler("on_call_state_updated", self, state)
 
     async def _on_first_participant_joined(self, participant_id: str):
+        """Handle first participant joined events."""
         await self._call_event_handler("on_first_participant_joined", participant_id)