livekit-agents 0.8.0.dev2__tar.gz → 0.8.0.dev3__tar.gz

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: livekit-agents
-Version: 0.8.0.dev2
+Version: 0.8.0.dev3
 Summary: LiveKit Python Agents
 Home-page: https://github.com/livekit/agents
 License: Apache-2.0
@@ -20,9 +20,9 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 Requires-Dist: click~=8.1
-Requires-Dist: livekit~=0.11
-Requires-Dist: livekit-api~=0.4
-Requires-Dist: livekit-protocol~=0.4
+Requires-Dist: livekit~=0.12.0.dev1
+Requires-Dist: livekit-api~=0.6.0
+Requires-Dist: livekit-protocol~=0.6.0
 Requires-Dist: protobuf>=3
 Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: types-protobuf<5,>=4

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/cli/watcher.py

@@ -75,7 +75,7 @@ class WatchServer:
         self._main_file = main_file
         self._loop = loop
 
-        self._recv_jobs_fut = asyncio.Future()
+        self._recv_jobs_fut = asyncio.Future[None]()
         self._reloading_jobs = False
 
     async def run(self) -> None:

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/ipc/channel.py

@@ -105,7 +105,7 @@ class AsyncProcChannel(ProcChannel):
 
         self._read_q = asyncio.Queue[Optional[Message]]()
         self._write_q = queue.Queue[Optional[Message]]()
-        self._exit_fut = asyncio.Future()
+        self._exit_fut = asyncio.Future[None]()
 
         self._read_t = threading.Thread(
             target=self._read_thread, daemon=True, name="proc_channel_read"

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/ipc/proc_main.py

@@ -157,9 +157,10 @@ async def _async_main(
 
                 if isinstance(msg, proto.ShutdownRequest):
                     if job_task is not None:
-                        job_task.shutdown_fut.set_result(
-                            _ShutdownInfo(reason=msg.reason, user_initiated=False)
-                        )
+                        with contextlib.suppress(asyncio.InvalidStateError):
+                            job_task.shutdown_fut.set_result(
+                                _ShutdownInfo(reason=msg.reason, user_initiated=False)
+                            )
                     else:
                         exit_proc_fut.set()  # there is no running job, we can exit immediately
 
@@ -210,8 +211,9 @@ def main(args: proto.ProcStartArgs) -> None:
             # (this signal can be sent by watchfiles on dev mode)
             loop.run_until_complete(main_task)
     finally:
-        try:
-            loop.run_until_complete(loop.shutdown_default_executor())
-            #loop.run_until_complete(cch.aclose())
-        finally:
-            loop.close()
+        # try:
+        loop.run_until_complete(loop.shutdown_default_executor())
+        loop.run_until_complete(cch.aclose())
+        # finally:
+        # loop.close()
+        # pass

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/ipc/proc_pool.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-import multiprocessing as mp
-import sys
+from multiprocessing.context import ForkServerContext, SpawnContext
 from typing import Any, Callable, Coroutine, Literal
 
 from .. import utils
@@ -26,15 +25,11 @@ class ProcPool(utils.EventEmitter[EventTypes]):
         num_idle_processes: int,
         initialize_timeout: float,
         close_timeout: float,
+        mp_ctx: ForkServerContext | SpawnContext,
         loop: asyncio.AbstractEventLoop,
     ) -> None:
         super().__init__()
-
-        #if sys.platform.startswith("linux"):
-        #    self._mp_ctx = mp.get_context("forkserver")
-        #else:
-        self._mp_ctx = mp.get_context("spawn")
-
+        self._mp_ctx = mp_ctx
         self._initialize_process_fnc = initialize_process_fnc
         self._job_entrypoint_fnc = job_entrypoint_fnc
         self._job_shutdown_fnc = job_shutdown_fnc

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/ipc/supervised_proc.py

@@ -32,6 +32,8 @@ class LogQueueListener:
         t.start()
 
     def stop(self) -> None:
+        if self._thread is None:
+            return
         self._q.put_nowait(self._sentinel)
         self._thread.join()
         self._thread = None
@@ -67,7 +69,7 @@ class SupervisedProc:
         loop: asyncio.AbstractEventLoop,
     ) -> None:
         self._loop = loop
-        log_q = mp.Queue()
+        log_q = mp_ctx.Queue()
         log_q.cancel_join_thread()
         mp_pch, mp_cch = mp_ctx.Pipe(duplex=True)
 
@@ -97,7 +99,7 @@ class SupervisedProc:
         self._main_atask: asyncio.Task[None] | None = None
         self._closing = False
         self._kill_sent = False
-        self._initialize_fut = asyncio.Future()
+        self._initialize_fut = asyncio.Future[None]()
 
     @property
     def exitcode(self) -> int | None:
@@ -145,7 +147,7 @@ class SupervisedProc:
 
         self._proc.start()
         self._pid = self._proc.pid
-        self._join_fut = asyncio.Future()
+        self._join_fut = asyncio.Future[None]()
 
         def _sync_run():
             self._proc.join()
@@ -161,7 +163,8 @@ class SupervisedProc:
         if not self.started:
             raise RuntimeError("process not started")
 
-        await asyncio.shield(self._main_atask)
+        if self._main_atask:
+            await asyncio.shield(self._main_atask)
 
     async def initialize(self) -> None:
         """initialize the job process, this is calling the user provided initialize_process_fnc
@@ -198,16 +201,18 @@ class SupervisedProc:
             await self._pch.asend(proto.ShutdownRequest())
 
         try:
-            await asyncio.wait_for(
-                asyncio.shield(self._main_atask), timeout=self._close_timeout
-            )
+            if self._main_atask:
+                await asyncio.wait_for(
+                    asyncio.shield(self._main_atask), timeout=self._close_timeout
+                )
         except asyncio.TimeoutError:
             logger.error(
                 "process did not exit in time, killing job", extra=self.logging_extra()
             )
             self._send_kill_signal()
 
-        await asyncio.shield(self._main_atask)
+        if self._main_atask:
+            await asyncio.shield(self._main_atask)
 
     async def kill(self) -> None:
         """forcefully kill the job process"""
@@ -216,7 +221,8 @@ class SupervisedProc:
 
         self._closing = True
         self._send_kill_signal()
-        await asyncio.shield(self._main_atask)
+        if self._main_atask:
+            await asyncio.shield(self._main_atask)
 
     async def launch_job(self, info: RunningJobInfo) -> None:
         """start/assign a job to the process"""
@@ -230,7 +236,10 @@ class SupervisedProc:
 
     def _send_kill_signal(self) -> None:
         """forcefully kill the job process"""
-        if not self._proc.is_alive():
+        try:
+            if not self._proc.is_alive():
+                return
+        except ValueError:
             return
 
         logger.debug("killing job process", extra=self.logging_extra())

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/job.py

@@ -114,8 +114,8 @@ def _apply_auto_subscribe_opts(room: rtc.Room, auto_subscribe: AutoSubscribe) ->
         ):
             pub.set_subscribed(True)
 
-    for p in room.participants.values():
-        for pub in p.tracks.values():
+    for p in room.remote_participants.values():
+        for pub in p.track_publications.values():
             _subscribe_if_needed(pub)
 
     @room.on("track_published")
@@ -128,11 +128,11 @@ def _apply_auto_subscribe_opts(room: rtc.Room, auto_subscribe: AutoSubscribe) ->
 class JobProcess:
     def __init__(self, *, start_arguments: Any | None = None) -> None:
         self._mp_proc = mp.current_process()
-        self._userdata = {}
+        self._userdata: dict[str, Any] = {}
         self._start_arguments = start_arguments
 
     @property
-    def pid(self) -> int:
+    def pid(self) -> int | None:
         return self._mp_proc.pid
 
     @property

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/transcription/_utils.py

@@ -7,7 +7,7 @@ from livekit import rtc
 
 def find_micro_track_id(room: rtc.Room, identity: str) -> str:
     p: rtc.RemoteParticipant | rtc.LocalParticipant | None = (
-        room.participants_by_identity.get(identity)
+        room.remote_participants.get(identity)
     )
     if identity == room.local_participant.identity:
         p = room.local_participant
@@ -17,7 +17,7 @@ def find_micro_track_id(room: rtc.Room, identity: str) -> str:
 
     # find first micro track
     track_id = None
-    for track in p.tracks.values():
+    for track in p.track_publications.values():
         if track.source == rtc.TrackSource.SOURCE_MICROPHONE:
             track_id = track.sid
             break

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/transcription/stt_forwarder.py

@@ -45,9 +45,8 @@ class STTSegmentsForwarder:
 
                 transcription = rtc.Transcription(
                     participant_identity=self._participant_identity,
-                    track_id=self._track_id,
+                    track_sid=self._track_id,
                     segments=[seg],  # no history for now
-                    language="",  # TODO(theomonnom)
                 )
                 await self._room.local_participant.publish_transcription(transcription)
 
@@ -66,13 +65,19 @@ class STTSegmentsForwarder:
                     start_time=0,
                     end_time=0,
                     final=False,
+                    language="",  # TODO
                 )
             )
         elif ev.type == stt.SpeechEventType.FINAL_TRANSCRIPT:
             text = ev.alternatives[0].text
             self._queue.put_nowait(
                 rtc.TranscriptionSegment(
-                    id=self._current_id, text=text, start_time=0, end_time=0, final=True
+                    id=self._current_id,
+                    text=text,
+                    start_time=0,
+                    end_time=0,
+                    final=True,
+                    language="",  # TODO
                 )
             )
 

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/transcription/tts_forwarder.py

@@ -185,6 +185,10 @@ class TTSSegmentsForwarder:
         self._forming_segments.q.append(new_seg)
         self._seg_queue.put_nowait(new_seg)
 
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
     async def aclose(self) -> None:
         if self._closed:
             return
@@ -213,9 +217,8 @@ class TTSSegmentsForwarder:
 
                 tr = rtc.Transcription(
                     participant_identity=self._opts.participant_identity,
-                    track_id=self._opts.track_id,
+                    track_sid=self._opts.track_id,
                     segments=[seg],  # no history for now, only one segment
-                    language=self._opts.language,
                 )
                 await self._opts.room.local_participant.publish_transcription(tr)
 
@@ -294,7 +297,12 @@ class TTSSegmentsForwarder:
             await self._sleep_if_not_closed(first_delay)
             rtc_seg_q.put_nowait(
                 rtc.TranscriptionSegment(
-                    id=seg_id, text=text, start_time=0, end_time=0, final=False
+                    id=seg_id,
+                    text=text,
+                    start_time=0,
+                    end_time=0,
+                    final=False,
+                    language=self._opts.language,
                 )
             )
             await self._sleep_if_not_closed(delay - first_delay)
@@ -302,7 +310,12 @@ class TTSSegmentsForwarder:
 
         rtc_seg_q.put_nowait(
             rtc.TranscriptionSegment(
-                id=seg_id, text=tokenized_sentence, start_time=0, end_time=0, final=True
+                id=seg_id,
+                text=tokenized_sentence,
+                start_time=0,
+                end_time=0,
+                final=True,
+                language=self._opts.language,
             )
         )
 

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "0.8.0-dev.2"
+__version__ = "0.8.0-dev.3"

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/voice_assistant/agent_output.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-import contextlib
+import time
 from typing import Any, AsyncIterable, Union
 
 from livekit import rtc
@@ -116,53 +116,42 @@ class AgentOutput:
             co = _stream_synthesis_task(handle._speech_source, handle)
 
         synth = asyncio.create_task(co)
+        synth.add_done_callback(lambda _: handle._buf_ch.close())
         try:
             _ = await asyncio.wait(
                 [synth, handle._interrupt_fut], return_when=asyncio.FIRST_COMPLETED
             )
         finally:
-            with contextlib.suppress(asyncio.CancelledError):
-                synth.cancel()
-                await synth
-
-            try:
-                if handle.play_handle is not None:
-                    await handle.play_handle
-            finally:
-                await handle._tr_fwd.aclose()
+            await utils.aio.gracefully_cancel(synth)
 
 
 @utils.log_exceptions(logger=logger)
 async def _str_synthesis_task(text: str, handle: SynthesisHandle) -> None:
     """synthesize speech from a string"""
-    if handle._tr_fwd is not None:
+    if handle._tr_fwd and not handle._tr_fwd.closed:
         handle._tr_fwd.push_text(text)
         handle._tr_fwd.mark_text_segment_end()
 
-    # start_time = time.time()
-    # first_frame = True
-    # audio_duration = 0.0
+    start_time = time.time()
+    first_frame = True
     handle._collected_text = text
 
     try:
         async for audio in handle._tts.synthesize(text):
-            # if first_frame:
-            # first_frame = False
-            # dt = time.time() - start_time
-            # self._log_debug(f"tts first frame in {dt:.2f}s")
+            if first_frame:
+                first_frame = False
+                dt = time.time() - start_time
+                logger.debug(f"AgentOutput._str_synthesis_task: TTFB in {dt:.2f}s")
 
             frame = audio.frame
-            # audio_duration += frame.samples_per_channel / frame.sample_rate
 
             handle._buf_ch.send_nowait(frame)
-            if handle._tr_fwd is not None:
+            if handle._tr_fwd and not handle._tr_fwd.closed:
                 handle._tr_fwd.push_audio(frame)
 
     finally:
-        if handle._tr_fwd is not None:
+        if handle._tr_fwd and not handle._tr_fwd.closed:
             handle._tr_fwd.mark_audio_segment_end()
-        handle._buf_ch.close()
-        # self._log_debug(f"tts finished synthesising {audio_duration:.2f}s of audio")
 
 
 @utils.log_exceptions(logger=logger)
@@ -173,27 +162,19 @@ async def _stream_synthesis_task(
 
     @utils.log_exceptions(logger=logger)
     async def _read_generated_audio_task():
-        # start_time = time.time()
-        # first_frame = True
-        # audio_duration = 0.0
+        start_time = time.time()
+        first_frame = True
         async for audio in tts_stream:
-            # if first_frame:
-            #    first_frame = False
-            #    dt = time.time() - start_time
-            #    self._log_debug(f"tts first frame in {dt:.2f}s (streamed)")
+            if first_frame:
+                first_frame = False
+                dt = time.time() - start_time
+                logger.debug(f"AgentOutput._stream_synthesis_task: TTFB in {dt:.2f}s")
 
-            # audio_duration += frame.samples_per_channel / frame.sample_rate
-            if handle._tr_fwd is not None:
+            if handle._tr_fwd and not handle._tr_fwd.closed:
                 handle._tr_fwd.push_audio(audio.frame)
 
             handle._buf_ch.send_nowait(audio.frame)
 
-            # we're only flushing once, so we know we can break at the end of the first segment
-
-        # self._log_debug(
-        #    f"tts finished synthesising {audio_duration:.2f}s audio (streamed)"
-        # )
-
     # otherwise, stream the text to the TTS
     tts_stream = handle._tts.stream()
     read_atask = asyncio.create_task(_read_generated_audio_task())
@@ -201,20 +182,20 @@ async def _stream_synthesis_task(
     try:
         async for seg in streamed_text:
             handle._collected_text += seg
-            if handle._tr_fwd is not None:
+
+            if handle._tr_fwd and not handle._tr_fwd.closed:
                 handle._tr_fwd.push_text(seg)
 
             tts_stream.push_text(seg)
-
     finally:
-        if handle._tr_fwd is not None:
+        tts_stream.end_input()
+
+        if handle._tr_fwd and not handle._tr_fwd.closed:
             handle._tr_fwd.mark_text_segment_end()
 
-        tts_stream.end_input()
         await read_atask
         await tts_stream.aclose()
 
-        if handle._tr_fwd is not None:
+        if handle._tr_fwd and not handle._tr_fwd.closed:
+            # mark_audio_segment_end must be called *after* mart_text_segment_end
             handle._tr_fwd.mark_audio_segment_end()
-
-        handle._buf_ch.close()

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/voice_assistant/cancellable_source.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import contextlib
 from typing import AsyncIterable, Literal
 
 from livekit import rtc
@@ -41,8 +40,8 @@ class PlayoutHandle:
 
         self._interrupted = True
 
-    def __await__(self):
-        return self._done_fut.__await__()
+    def join(self) -> asyncio.Future:
+        return self._done_fut
 
 
 class CancellableAudioSource(utils.EventEmitter[EventTypes]):
@@ -89,6 +88,7 @@ class CancellableAudioSource(utils.EventEmitter[EventTypes]):
         self._playout_atask = asyncio.create_task(
             self._playout_task(self._playout_atask, handle)
         )
+
         return handle
 
     @utils.log_exceptions(logger=logger)
@@ -104,9 +104,9 @@ class CancellableAudioSource(utils.EventEmitter[EventTypes]):
 
         try:
             if old_task is not None:
-                with contextlib.suppress(asyncio.CancelledError):
-                    old_task.cancel()
-                    await old_task
+                await utils.aio.gracefully_cancel(old_task)
+
+            logger.debug("CancellableAudioSource._playout_task: started")
 
             async for frame in handle._playout_source:
                 if first_frame:
@@ -121,7 +121,7 @@ class CancellableAudioSource(utils.EventEmitter[EventTypes]):
                     break
 
                 # divide the frame by chunks of 20ms
-                ms20 = frame.sample_rate // 100
+                ms20 = frame.sample_rate // 50
                 i = 0
                 while i < len(frame.data):
                     if _should_break():
@@ -148,10 +148,12 @@ class CancellableAudioSource(utils.EventEmitter[EventTypes]):
                     handle._time_played += rem / frame.sample_rate
         finally:
             if not first_frame:
-                if handle._tr_fwd is not None:
-                    if not cancelled:
-                        handle._tr_fwd.segment_playout_finished()
+                if handle._tr_fwd is not None and not cancelled:
+                    handle._tr_fwd.segment_playout_finished()
 
                 self.emit("playout_stopped", cancelled)
 
-            handle._done_fut.set_result(None)
+            handle._done_fut.set_result(None)
+            if handle._tr_fwd is not None:
+                await handle._tr_fwd.aclose()
+            logger.debug("CancellableAudioSource._playout_task: ended")

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/voice_assistant/human_input.py

@@ -75,7 +75,7 @@ class HumanInput(utils.EventEmitter[EventTypes]):
         Subscribe to the participant microphone if found and not already subscribed.
         Do nothing if no track is found.
         """
-        for publication in self._participant.tracks.values():
+        for publication in self._participant.track_publications.values():
             if publication.source != rtc.TrackSource.SOURCE_MICROPHONE:
                 continue
 

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/voice_assistant/voice_assistant.py

@@ -216,7 +216,7 @@ class VoiceAssistant(utils.EventEmitter[EventTypes]):
                 self._link_participant(participant)
         else:
             # no participant provided, try to find the first in the room
-            for participant in self._room.participants.values():
+            for participant in self._room.remote_participants.values():
                 self._link_participant(participant.identity)
                 break
 
@@ -290,7 +290,7 @@ class VoiceAssistant(utils.EventEmitter[EventTypes]):
         self._link_participant(participant.identity)
 
     def _link_participant(self, identity: str) -> None:
-        participant = self._room.participants_by_identity.get(identity)
+        participant = self._room.remote_participants.get(identity)
         if participant is None:
             logger.error("_link_participant must be called with a valid identity")
             return
@@ -312,7 +312,7 @@ class VoiceAssistant(utils.EventEmitter[EventTypes]):
 
             tv = 1.0
             if self._opts.allow_interruptions:
-                tv = max(0, 1 - ev.probability)
+                tv = max(0.0, 1.0 - ev.probability)
                 self._agent_output.audio_source.target_volume = tv
 
             smoothed_tv = self._agent_output.audio_source.smoothed_volume
@@ -471,6 +471,7 @@ class VoiceAssistant(utils.EventEmitter[EventTypes]):
         )
 
     async def _play_speech(self, speech_info: _SpeechInfo) -> None:
+        logger.debug("VoiceAssistant._play_speech started")
         MIN_TIME_PLAYED_FOR_COMMIT = 1.5
 
         assert (
@@ -485,7 +486,7 @@ class VoiceAssistant(utils.EventEmitter[EventTypes]):
         user_speech_commited = False
 
         play_handle = synthesis_handle.play()
-        play_handle_fut = asyncio.ensure_future(play_handle)
+        join_fut = play_handle.join()
         self._playing_synthesis = synthesis_handle
 
         def _commit_user_message_if_needed() -> None:
@@ -507,7 +508,7 @@ class VoiceAssistant(utils.EventEmitter[EventTypes]):
             # really quickly (barely audible), we don't want to mark this question as "answered".
             if not is_using_tools and (
                 play_handle.time_played < MIN_TIME_PLAYED_FOR_COMMIT
-                and not play_handle_fut.done()
+                and not join_fut.done()
             ):
                 return
 
@@ -519,9 +520,9 @@ class VoiceAssistant(utils.EventEmitter[EventTypes]):
             user_speech_commited = True
 
         # wait for the play_handle to finish and check every 1s if the user question should be committed
-        while not play_handle_fut.done():
+        while not join_fut.done():
             await asyncio.wait(
-                [play_handle_fut], return_when=asyncio.FIRST_COMPLETED, timeout=1.0
+                [join_fut], return_when=asyncio.FIRST_COMPLETED, timeout=1.0
             )
 
             _commit_user_message_if_needed()
@@ -579,7 +580,8 @@ class VoiceAssistant(utils.EventEmitter[EventTypes]):
                     transcript=_llm_stream_to_str_iterable(answer_stream)
                 )
                 self._playing_synthesis = answer_synthesis
-                await answer_synthesis.play()
+                play_handle = answer_synthesis.play()
+                await play_handle.join()
 
                 collected_text = answer_synthesis.collected_text
                 interrupted = answer_synthesis.interrupted
@@ -595,6 +597,8 @@ class VoiceAssistant(utils.EventEmitter[EventTypes]):
             else:
                 self.emit("agent_speech_committed", msg)
 
+        logger.debug("VoiceAssistant._play_speech ended")
+
 
 async def _llm_stream_to_str_iterable(stream: LLMStream) -> AsyncIterable[str]:
     async for chunk in stream:
@@ -677,6 +681,7 @@ class _DeferredAnswerValidation:
         self._last_final_transcript = ""
         self._received_end_of_speech = False
         self._validate_fnc()
+        logger.debug("_DeferredAnswerValidation speech validated")
 
     def _run(self, delay: float) -> None:
         if self._validating_task is not None:

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit/agents/worker.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import datetime
+import multiprocessing as mp
 import os
 from dataclasses import dataclass, field
 from functools import reduce
@@ -35,7 +36,7 @@ from .job import JobAcceptArguments, JobContext, JobProcess, JobRequest, Running
 from .log import DEV_LEVEL, logger
 from .version import __version__
 
-MAX_RECONNECT_ATTEMPTS = 3.0
+MAX_RECONNECT_ATTEMPTS = 3
 ASSIGNMENT_TIMEOUT = 7.5
 UPDATE_LOAD_INTERVAL = 10.0
 
@@ -43,9 +44,11 @@ UPDATE_LOAD_INTERVAL = 10.0
 def _default_initialize_process_fnc(proc: JobProcess) -> Any:
     return
 
+
 async def _default_shutdown_fnc(proc: JobContext) -> None:
     return
 
+
 async def _default_request_fnc(ctx: JobRequest) -> None:
     await ctx.accept()
 
@@ -122,12 +125,17 @@ class Worker(utils.EventEmitter[EventTypes]):
         self._pending_assignments: dict[str, asyncio.Future[agent.JobAssignment]] = {}
         self._close_future: asyncio.Future[None] | None = None
         self._msg_chan = utils.aio.Chan[agent.WorkerMessage](128, loop=self._loop)
+
+        # using spawn context for all platforms. We may have further optimizations for
+        # Linux with forkserver, but for now, this is the safest option
+        mp_ctx = mp.get_context("spawn")
         self._proc_pool = ipc.proc_pool.ProcPool(
             initialize_process_fnc=opts.prewarm_fnc,
             job_entrypoint_fnc=opts.entrypoint_fnc,
             job_shutdown_fnc=_default_shutdown_fnc,
             num_idle_processes=opts.num_idle_processes,
             loop=self._loop,
+            mp_ctx=mp_ctx,
             initialize_timeout=opts.initialize_process_timeout,
             close_timeout=opts.shutdown_process_timeout,
         )
@@ -240,7 +248,7 @@ class Worker(utils.EventEmitter[EventTypes]):
         """_queue_msg raises aio.ChanClosed when the worker is closing/closed"""
         if self._connecting:
             which = msg.WhichOneof("message")
-            if which == "update_worker" and not msg.update_worker.metadata:
+            if which == "update_worker":
                 return
             elif which == "ping":
                 return

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit_agents.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: livekit-agents
-Version: 0.8.0.dev2
+Version: 0.8.0.dev3
 Summary: LiveKit Python Agents
 Home-page: https://github.com/livekit/agents
 License: Apache-2.0
@@ -20,9 +20,9 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 Requires-Dist: click~=8.1
-Requires-Dist: livekit~=0.11
-Requires-Dist: livekit-api~=0.4
-Requires-Dist: livekit-protocol~=0.4
+Requires-Dist: livekit~=0.12.0.dev1
+Requires-Dist: livekit-api~=0.6.0
+Requires-Dist: livekit-protocol~=0.6.0
 Requires-Dist: protobuf>=3
 Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: types-protobuf<5,>=4

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/livekit_agents.egg-info/requires.txt

@@ -1,7 +1,7 @@
 click~=8.1
-livekit~=0.11
-livekit-api~=0.4
-livekit-protocol~=0.4
+livekit~=0.12.0.dev1
+livekit-api~=0.6.0
+livekit-protocol~=0.6.0
 protobuf>=3
 pyjwt>=2.0.0
 types-protobuf<5,>=4

{livekit_agents-0.8.0.dev2 → livekit_agents-0.8.0.dev3}/setup.py

@@ -48,9 +48,9 @@ setuptools.setup(
     python_requires=">=3.9.0",
     install_requires=[
         "click~=8.1",
-        "livekit~=0.11",
-        "livekit-api~=0.4",
-        "livekit-protocol~=0.4",
+        "livekit~=0.12.0.dev1",
+        "livekit-api~=0.6.0",
+        "livekit-protocol~=0.6.0",
         "protobuf>=3",
         "pyjwt>=2.0.0",
         "types-protobuf>=4,<5",