https://livekit.io logo
Join Slack
Powered by
hi, in sdk code : ```def _agent_state_changed(self...
# ask-ai
r
hi, in sdk code :
Copy code
def _agent_state_changed(self, ev: AgentStateChangedEvent) -> None:
    if not self._thinking_sound:
        return

    if ev.new_state == "thinking":
        if self._thinking_handle and not self._thinking_handle.done():
            return

        assert self._thinking_sound is not None
        self._thinking_handle = self.play(self._thinking_sound)

    elif self._thinking_handle:
        self._thinking_handle.stop()
but what if the task taks more time than the : self._thinking_handle = self.play(self._thinking_sound)
then it will be silent for the rest of the tool call time taken , is there a wayaround this ??
✅ 1
t
Thanks for reaching out, Areeb. I'm an AI assistant and I'm here to help. Give me a moment while I research this topic.
Thanks — I’m looking at your snippet where a single 
play()
call can end mid-task and leave silence. You're asking how to keep the thinking sound playing for the entire long-running tool call. Short answer: use a looping/managed thinking audio instead of a single one-shot 
play()
call. Two practical options: • Use LiveKit’s BackgroundAudioPlayer to manage thinking audio (recommended). Configure 
thinking_sound
as a looping ambient clip or as a list of clips (with probabilities) so playback continues automatically while the agent is in the "thinking" state. Example pattern: a. Create a BackgroundAudioPlayer with 
thinking_sound
set to a looping ambient clip or multiple 
AudioConfig
entries. b. Start the player for the room/session when the agent session begins. This ensures continuous playback without manually restarting 
play()
. • If you must control playback yourself, run a background coroutine that repeatedly restarts the clip while the agent remains in "thinking": a. On entering "thinking", start a task that: • calls 
self.play()
then awaits its completion, • loops and restarts until the agent leaves "thinking". a. On leaving "thinking", cancel that coroutine and stop any current handle. Be careful to avoid starting duplicate coroutines (check `self._thinking_handle`/task state). Which approach would you prefer: using BackgroundAudioPlayer (automatic looping) or a manual coroutine loop? I can provide example code for the one you choose. Sources: Background audio | LiveKit Documentation, with interactive elements
r
tell me how would be configure the first one approach ??
t
Thanks — I’ll show how to configure LiveKit’s BackgroundAudioPlayer so the thinking sound plays automatically (and continuously) while the agent is in the "thinking" state. 1) Create the player with a looping ambient clip or multiple clips (probability-weighted) • Use a looping ambient clip if you want steady continuous audio. • Use multiple 
AudioConfig
clips to vary sounds and avoid repetition. 2) Start the player when the agent session/room is active. Python example (recommended):
Copy code
from livekit.agents import BackgroundAudioPlayer, AudioConfig, BuiltinAudioClip

background_audio = BackgroundAudioPlayer(
    # Option A: single ambient looping clip (continuous)
    thinking_sound=AudioConfig(BuiltinAudioClip.AMBIENT_LOOP, volume=0.6),

    # Option B: multiple clips with probabilities (varied, auto-managed)
    # thinking_sound=[
    #     AudioConfig(BuiltinAudioClip.KEYBOARD_TYPING, volume=0.8, probability=0.6),
    #     AudioConfig(BuiltinAudioClip.KEYBOARD_TYPING2, volume=0.7, probability=0.4),
    # ],
)

# After connecting to the room and starting the agent session:
await background_audio.start(room=ctx.room, agent_session=session)
Node.js example:
Copy code
import { voice } from '@livekit/agents';

const backgroundAudio = new voice.BackgroundAudioPlayer({
  // Option A: ambient looping clip
  thinkingSound: { source: voice.BuiltinAudioClip.AMBIENT_LOOP, volume: 0.6 },

  // Option B: multiple clips
  // thinkingSound: [
  //   { source: voice.BuiltinAudioClip.KEYBOARD_TYPING, volume: 0.8, probability: 0.6 },
  //   { source: voice.BuiltinAudioClip.KEYBOARD_TYPING2, volume: 0.7, probability: 0.4 },
  // ],
});

await backgroundAudio.start({ room: ctx.room, agentSession: session });
Notes: • Use the ambient/looping clip for uninterrupted audio during long tool calls. • The player automatically starts/stops thinking playback based on the agent state—no manual repeated 
play()
calls needed. Do you want a concrete Python snippet that uses your existing agent lifecycle (where to call 
start
and 
stop
) or help choosing clips/volumes? Sources: Background audio | LiveKit Documentation, with interactive elements
3 Views
Open in Slack
PreviousNext
Powered by