dv-pipecat-ai 0.0.93.dev75__tar.gz → 0.0.93.dev77__tar.gz

{dv_pipecat_ai-0.0.93.dev75/src/dv_pipecat_ai.egg-info → dv_pipecat_ai-0.0.93.dev77}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev75
+Version: 0.0.93.dev77
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.93.dev75 → dv_pipecat_ai-0.0.93.dev77/src/dv_pipecat_ai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev75
+Version: 0.0.93.dev77
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.93.dev75 → dv_pipecat_ai-0.0.93.dev77}/src/pipecat/transports/base_output.py

@@ -142,6 +142,27 @@ class BaseOutputTransport(FrameProcessor):
         for _, sender in self._media_senders.items():
             await sender.cancel(frame)
 
+    def is_transport_alive(self) -> bool:
+        """Return True if the underlying transport is still able to receive frames.
+
+        Used by the audio task handler's silence-fill loop to self-exit when
+        the call has ended but the pipeline cancellation didn't reach the
+        audio task (a real production scenario — see pod gjxkm 2026-06-10).
+        Without this check, the loop synthesizes silence + mixes + filters
+        forever on a dead transport, burning a full CPU core.
+
+        Subclasses should override this with a cheap, synchronous check on
+        their client/connection state (e.g. for WebSocket transports, return
+        False once the WS is closing or closed). The default `True` keeps
+        existing transports unchanged — they fall back to the legacy
+        spin-forever behaviour unless they opt in.
+
+        Returns:
+            True if the transport can still deliver audio, False if the
+            audio task should exit because the transport is dead.
+        """
+        return True
+
     async def set_transport_ready(self, frame: StartFrame):
         """Called when the transport is ready to stream.
 
@@ -761,6 +782,7 @@ class BaseOutputTransport(FrameProcessor):
                 last_frame_time = 0
                 silence = b"\x00" * self._audio_chunk_size
                 while True:
+                    iter_start = time.monotonic()
                     try:
                         frame = self._audio_queue.get_nowait()
                         if isinstance(frame, OutputAudioRawFrame):
@@ -769,6 +791,28 @@ class BaseOutputTransport(FrameProcessor):
                         yield frame
                         self._audio_queue.task_done()
                     except asyncio.QueueEmpty:
+                        # Cheap dead-transport probe BEFORE doing the heavy
+                        # mix/filter/clip work. If the underlying transport
+                        # has closed (e.g. the call ended but pipeline
+                        # cancellation didn't reach this task), exit the
+                        # generator. `_audio_task_handler`'s `async for` then
+                        # ends naturally and the asyncio task releases its
+                        # references — CPU drops to zero per leak instead of
+                        # spinning on synthesized silence forever.
+                        #
+                        # `is_transport_alive()` is a cheap synchronous flag
+                        # read on subclasses that opt in (e.g.
+                        # FastAPIWebsocketOutputTransport returns False once
+                        # `_client.is_closing` or `not _client.is_connected`).
+                        # For transports that haven't opted in, the default
+                        # `True` keeps existing behaviour.
+                        if not self._transport.is_transport_alive():
+                            logger.info(
+                                f"{self._transport} audio task exiting: "
+                                f"transport reports not alive — pipeline "
+                                f"cancellation did not reach this task"
+                            )
+                            return
                         # Notify the bot stopped speaking upstream if necessary.
                         diff_time = time.time() - last_frame_time
                         # Use a shorter threshold for the first stop only.
@@ -786,30 +830,35 @@ class BaseOutputTransport(FrameProcessor):
                             num_channels=self._params.audio_out_channels,
                         )
                         yield frame
-                        # Pace the empty-queue silence-fill loop to actual audio
-                        # playback rate. The previous `asyncio.sleep(0)` only
-                        # yields to the scheduler for a single tick; the loop
-                        # then resumes immediately and iterates as fast as the
-                        # event loop will dispatch it. If the audio task
-                        # outlives the call that created it (e.g. abnormal
-                        # pipeline shutdown), this synthesizes silence frames
-                        # thousands of times per second and pegs a full CPU
-                        # core on the soundfile mixer + Krisp filter + numpy
-                        # clipping path (observed in prod: pod gjxkm at 1.0
-                        # cores with no incoming traffic, profile dominated by
-                        # mixer.mix + _clip + filter on silence). Sleeping for
-                        # one audio chunk's worth of time matches the natural
-                        # rate at which the downstream transport would actually
-                        # consume these frames, so a healthy call sees no
-                        # behavior change while a leaked task uses ~0.01 cores
-                        # instead of 1.0.
+                        # Budget-based pacing for the empty-queue silence-fill
+                        # branch. Follow-up correction to #376, which used a
+                        # flat `await asyncio.sleep(chunk_secs)`. That naive
+                        # form added chunk_secs ON TOP of processing time +
+                        # write time per iteration, so a healthy call that was
+                        # previously paced by transport write_audio_frame()'s
+                        # TCP backpressure at ~chunk_secs/iter ends up at
+                        # 2*chunk_secs/iter — half the audio production rate,
+                        # creating real underrun risk on the receiver side.
+                        #
+                        # Budget-based form: target one chunk_secs total per
+                        # iteration. On a healthy call, processing + yield +
+                        # write already takes ≥ chunk_secs (backpressure-bound),
+                        # so `elapsed >= chunk_secs` and the sleep is 0 —
+                        # behavior is bit-for-bit identical to the original
+                        # `sleep(0)` version. On a leaked task with no real
+                        # consumer (write fails fast, no backpressure), the
+                        # iteration is ~5 ms and the sleep fills in ~5 ms to
+                        # reach chunk_secs, capping iter rate at audio rate
+                        # (~100 Hz). CPU drops from ~1.0 cores to ~0.5 cores
+                        # per leaked task.
                         chunk_secs = (
                             self._audio_chunk_size
                             / (self._sample_rate * self._params.audio_out_channels * 2)
                             if self._sample_rate
                             else 0.01
                         )
-                        await asyncio.sleep(chunk_secs)
+                        elapsed = time.monotonic() - iter_start
+                        await asyncio.sleep(max(0, chunk_secs - elapsed))
 
             if self._mixer:
                 return with_mixer(BOT_VAD_STOP_SECS)

{dv_pipecat_ai-0.0.93.dev75 → dv_pipecat_ai-0.0.93.dev77}/src/pipecat/transports/websocket/fastapi.py

@@ -465,6 +465,17 @@ class FastAPIWebsocketOutputTransport(BaseOutputTransport):
         """
         await self._write_frame(frame)
 
+    def is_transport_alive(self) -> bool:
+        """Whether the WebSocket is still able to receive audio.
+
+        Used by the base output transport's `with_mixer` empty-queue branch
+        to bail out before doing heavy mix/filter/clip work on a dead
+        connection. See BaseOutputTransport.is_transport_alive().
+        """
+        return bool(
+            self._client and self._client.is_connected and not self._client.is_closing
+        )
+
     async def write_audio_frame(self, frame: OutputAudioRawFrame) -> bool:
         """Write an audio frame to the WebSocket with timing simulation.