dv-pipecat-flows 0.0.0.dev2786__tar.gz → 0.0.0.dev2828__tar.gz

{dv_pipecat_flows-0.0.0.dev2786/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.0.dev2828}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.0.dev2786
+Version: 0.0.0.dev2828
 Summary: Conversation Flow management for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Source, https://github.com/pipecat-ai/pipecat-flows

{dv_pipecat_flows-0.0.0.dev2786 → dv_pipecat_flows-0.0.0.dev2828/src/dv_pipecat_flows.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.0.dev2786
+Version: 0.0.0.dev2828
 Summary: Conversation Flow management for Pipecat AI applications
 License: BSD 2-Clause License
 Project-URL: Source, https://github.com/pipecat-ai/pipecat-flows

{dv_pipecat_flows-0.0.0.dev2786 → dv_pipecat_flows-0.0.0.dev2828}/src/dv_pipecat_flows.egg-info/scm_file_list.json

@@ -333,6 +333,7 @@
     "ringg-bot/ringg_processors/realtime_audio_suppressor.py",
     "ringg-bot/ringg_processors/realtime_tts_bridge.py",
     "ringg-bot/ringg_processors/screen_auto_injector.py",
+    "ringg-bot/ringg_processors/tts_cache.py",
     "ringg-bot/ringg_processors/two_stage_user_idle_processor.py",
     "ringg-bot/ringg_processors/user_activity_reset_processor.py",
     "ringg-bot/scripts/delete_agent_cache.py",
@@ -359,6 +360,7 @@
     "ringg-bot/test_bot.py",
     "ringg-bot/tests/__init__.py",
     "ringg-bot/tests/conftest.py",
+    "ringg-bot/tests/test_abandoned_call_report.py",
     "ringg-bot/tests/test_action_call_variables.py",
     "ringg-bot/tests/test_app_metrics.py",
     "ringg-bot/tests/test_artifact_store.py",
@@ -381,8 +383,10 @@
     "ringg-bot/tests/test_dom_context_injector.py",
     "ringg-bot/tests/test_dropped_turn_regeneration.py",
     "ringg-bot/tests/test_end_call_schema.py",
+    "ringg-bot/tests/test_end_call_teardown.py",
     "ringg-bot/tests/test_env_config_asterisk_ami.py",
     "ringg-bot/tests/test_execute_plan.py",
+    "ringg-bot/tests/test_find_button_api_config.py",
     "ringg-bot/tests/test_flow_query_kb.py",
     "ringg-bot/tests/test_gcs_fetch.py",
     "ringg-bot/tests/test_http_client_diagnostics.py",
@@ -409,6 +413,7 @@
     "ringg-bot/tests/test_merge_parallel_tool_responses.py",
     "ringg-bot/tests/test_metrics_bridge.py",
     "ringg-bot/tests/test_metrics_collector_llm.py",
+    "ringg-bot/tests/test_no_bot_calls_are_failed.py",
     "ringg-bot/tests/test_on_call_api_pre_call_message.py",
     "ringg-bot/tests/test_on_call_jq_metadata.py",
     "ringg-bot/tests/test_on_call_sdk_context.py",
@@ -443,6 +448,7 @@
     "ringg-bot/tests/test_transcript_timestamp_format.py",
     "ringg-bot/tests/test_transfer_custom_vars.py",
     "ringg-bot/tests/test_transfer_summary_api_tool.py",
+    "ringg-bot/tests/test_tts_cache.py",
     "ringg-bot/tests/test_tts_currency.py",
     "ringg-bot/tests/test_variable_replacement.py",
     "ringg-bot/tests/test_wandb_llm.py",
@@ -554,6 +560,7 @@
     "ringg-bot/utils/tts.py",
     "ringg-bot/utils/twilio_async_client.py",
     "ringg-bot/utils/warning_messages.py",
+    "ringg-bot/utils/widget_transcript.py",
     "ringg-bot/utils/word_timestamp_logger.py",
     "ringg-bot/voice_services/asterisk/asterisk_service.py",
     "ringg-bot/voice_services/asterisk/router.py",
@@ -647,8 +654,11 @@
     "tests/test_openai_realtime_transcript_filter.py",
     "tests/test_response_formatters.py",
     "tests/test_router_extract_schema.py",
+    "tests/test_router_mode_guard.py",
     "tests/test_router_no_unclear.py",
+    "tests/test_router_wait_idle.py",
     "tests/test_tts_split_cache.py",
+    "tests/test_user_turn_observer.py",
     "tests/test_voicemail_detector.py",
     "uv.lock"
   ]

dv_pipecat_flows-0.0.0.dev2828/src/dv_pipecat_flows.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.0.0.dev0",
+  "distance": 2828,
+  "node": "gf48d50520527927107c4f155d372cd8fdc6d77c2",
+  "dirty": false,
+  "branch": "dv-stage",
+  "node_date": "2026-08-12"
+}

{dv_pipecat_flows-0.0.0.dev2786 → dv_pipecat_flows-0.0.0.dev2828}/src/pipecat_flows/manager.py

@@ -48,7 +48,7 @@ from typing import (
 
 from loguru import logger
 from utils.tracking_helpers import start_tracking, complete_tracking
-from utils.collect_normalizers import is_repeat_request, normalize_collect_value
+from utils.collect_normalizers import normalize_collect_value
 from utils.collect_prompts import collect_prompt
 from pipecat.frames.frames import (
     DTMFUpdateSettingsFrame,
@@ -1872,6 +1872,24 @@ In all of these cases, you can provide a `name` in your new node's config for de
             label="jump",
         )
 
+    def _last_context_role(self) -> Optional[str]:
+        """Role of the last message in the live LLM context, or None when no
+        context aggregator / empty context. Used by the router wait gate to
+        tell a real committed user turn apart from system-generated context
+        pushes (e.g. the idle warning's LLM-path append)."""
+        if not self._context_aggregator:
+            return None
+        ctx = self._context_aggregator.user()._context
+        messages = (
+            ctx.get_messages() if hasattr(ctx, "get_messages") else getattr(ctx, "messages", [])
+        )
+        if not messages:
+            return None
+        last = messages[-1]
+        if isinstance(last, dict):
+            return last.get("role")
+        return getattr(last, "role", None)
+
     async def _run_router_node(
         self, node_id: str, node_config: Dict[str, Any]
     ) -> Optional[str]:
@@ -1905,10 +1923,19 @@ In all of these cases, you can provide a `name` in your new node's config for de
         # `_run_router_node` captures a fresh entry_ts — the next iteration
         # correctly waits for a NEW user reply instead of reclassifying the
         # stale one that triggered the previous UNCLEAR.
+        #
+        # Silence handling is delegated to the user-idle processor: we re-arm
+        # it for the duration of the wait (it was stopped at `_set_node`
+        # entry) and block until the user actually replies. If they never do,
+        # the idle processor's warning → end stages fire and end the call —
+        # the router never classifies stale silence. The idle warning's
+        # fixed-phrase TTSSpeakFrame passes RouterModeGuard; its LLM-path
+        # fallback (realtime/chat-only/unsupported languages) is dropped by
+        # the guard, so that warning is silent but the end stage still ends
+        # the call.
         observer = self._user_turn_observer
 
-        timeout_s = float(node_config.get("router_wait_for_user_timeout", 15.0))
-        if observer is not None and timeout_s > 0:
+        if observer is not None:
             entry_ts = time.monotonic()
             if observer.last_user_stopped_ts >= entry_ts:
                 logger.debug(
@@ -1929,28 +1956,41 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     )
                 else:
                     logger.debug(
-                        f"Router '{node_id}': waiting up to {timeout_s}s for "
-                        f"UserStoppedSpeakingFrame"
+                        f"Router '{node_id}': waiting for "
+                        f"UserStoppedSpeakingFrame (idle processor armed)"
                     )
+                    await self._task.queue_frame(StartUserIdleProcessorFrame())
                     try:
-                        await asyncio.wait_for(
-                            observer.event.wait(), timeout=timeout_s
-                        )
-                        logger.debug(
-                            f"Router '{node_id}': user reply received after "
-                            f"{time.monotonic() - entry_ts:.2f}s"
-                        )
-                    except asyncio.TimeoutError:
-                        # User stayed silent. Don't raise — let the router
-                        # LLM classify whatever context is available; it
-                        # will most likely return UNCLEAR, which the
-                        # existing pick_branch_target machinery routes to
-                        # reprompt or exhausted_node.
-                        logger.info(
-                            f"Router '{node_id}': no user reply within "
-                            f"{timeout_s}s; proceeding (will likely route "
-                            f"to unclear/exhausted)"
+                        while True:
+                            await observer.event.wait()
+                            # The observer fires on EVERY OpenAILLMContextFrame,
+                            # and with idle armed there IS a competing source:
+                            # the idle warning's LLM path (chat-only sessions,
+                            # realtime LLMs) appends its prompt with
+                            # run_llm=True, which makes the user aggregator push
+                            # a context frame with NO new user turn. Accept the
+                            # wake only when the last context message is the
+                            # user's; otherwise keep waiting for the real reply
+                            # (or for idle end-stage to end the call).
+                            role = self._last_context_role()
+                            if role is None or role == "user":
+                                break
+                            logger.debug(
+                                f"Router '{node_id}': ignoring context push "
+                                f"with last role '{role}' (idle warning, not a "
+                                f"user reply); still waiting"
+                            )
+                            observer.event.clear()
+                    finally:
+                        # Restore the "idle stopped while the node is
+                        # processing" invariant for the classifier call.
+                        await self._task.queue_frame(
+                            StopUserIdleProcessorFrame()
                         )
+                    logger.debug(
+                        f"Router '{node_id}': user reply received after "
+                        f"{time.monotonic() - entry_ts:.2f}s"
+                    )
 
         branches = node_config.get("router_branches") or []
         extract = node_config.get("router_extract") or {}
@@ -2649,6 +2689,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
         """
         self._collect_readback = ""  # grouped, language-matched read-back for the confirm
         self._collect_reply = ""  # LLM free reply for a conversational (non-digit) turn
+        self._collect_repeat = False  # LLM-decided: caller asked to hear the digits back
         context_messages = [
             {"role": "user", "content": turn}
             for turn in turns
@@ -2692,6 +2733,14 @@ In all of these cases, you can provide a `name` in your new node's config for de
                         "the number; make no promises or commitments."
                     ),
                 },
+                "repeat_request": {
+                    "type": "boolean",
+                    "description": (
+                        "true ONLY if the caller's latest message asks to hear back the "
+                        "digits captured so far; false when they are offering to dictate "
+                        "again themselves."
+                    ),
+                },
             },
         )
         try:
@@ -2709,6 +2758,11 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     "empty and put a SHORT on-topic reply in `reply`: answer in one "
                     "sentence, then ask again for the number — stay on topic, make no "
                     "promises.\n"
+                    "Set `repeat_request` to true ONLY when the caller's latest message "
+                    "asks to hear back what has been captured so far ('repeat that', "
+                    "'what do you have?', 'दोबारा बोलिए'). An offer to dictate again "
+                    "('मैं फिर से बताती हूँ', 'I'll tell you again') is NOT a repeat "
+                    "request.\n"
                     "Digits: read each spoken number-word in the order spoken and join its "
                     "digits left to right — a digit-word adds one digit, 'double X' adds "
                     "XX, 'triple X' adds XXX (in any language, incl. डबल/ट्रिपल), and a lone "
@@ -2738,6 +2792,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
         reply = (extracted or {}).get("reply")
         self._collect_readback = readback.strip() if isinstance(readback, str) else ""
         self._collect_reply = reply.strip() if isinstance(reply, str) else ""
+        self._collect_repeat = bool((extracted or {}).get("repeat_request"))
         return re.sub(r"\D", "", value) if isinstance(value, str) else ""
 
     async def _reextract_if_corrected(
@@ -2899,9 +2954,10 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 # the CORRECTED number at once — instead of asking "what should it
                 # be?" and making them repeat what they just said. The idempotent
                 # extractor merges "no, the first part is 807" into 70823… →
-                # 8072341303. KEEP start_ts throughout so corrections resolve against
-                # the ORIGINAL number. Only a plain rejection with no new digits
-                # falls through to the re-ask. Bounded by ``corrections``.
+                # 8072341303. Only a plain rejection with no new digits falls
+                # through to the re-ask — and starts FRESH (start_ts advanced), so
+                # the rejected number's turns can't concatenate into the caller's
+                # re-dictation (live call 2a3f6513). Bounded by ``corrections``.
                 while True:
                     confirmed = await self._confirm_collected(
                         node_id, getattr(self, "_collect_readback", "") or " ".join(buffer)
@@ -2918,7 +2974,9 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     if corrected is not None:
                         buffer, normalized = corrected
                         continue  # re-read the corrected number, no "what should it be?"
+                    start_ts = time.monotonic()
                     buffer = ""
+                    echoed = ""
                     await self._task.queue_frame(
                         TTSSpeakFrame(text=collect_prompt(language, "restart_denied"))
                     )
@@ -2947,8 +3005,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 # correction during the echo phase ("no, the 3rd is 5": 7765 → 7755)
                 # changes the value but not the length, so a length check would mis-read
                 # the fix as "no progress" and burn a miss instead of echoing it below.
-                turns = self._collect_turns_since(start_ts)
-                if buffer and turns and is_repeat_request(turns[-1]):
+                if buffer and getattr(self, "_collect_repeat", False):
                     # Re-reads bypass the miss counter, so the absolute deadline is the
                     # only bound — without it a caller repeating "say it again" loops
                     # forever (a turn lands every cycle, never silence, never a miss).
@@ -3052,7 +3109,9 @@ In all of these cases, you can provide a `name` in your new node's config for de
             if normalized:
                 # Same as phone: a "no, it's X" correction re-extracts over the turns
                 # we already have and re-reads the CORRECTED code at once; only a
-                # plain rejection with no new digits asks "what should it be?".
+                # plain rejection with no new digits asks "what should it be?" —
+                # and starts FRESH (start_ts advanced) so the rejected code's turns
+                # can't concatenate into the re-dictation (live call 2a3f6513).
                 while True:
                     confirmed = await self._confirm_collected(
                         node_id, getattr(self, "_collect_readback", "") or " ".join(normalized)
@@ -3069,7 +3128,9 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     if corrected is not None:
                         buffer, normalized = corrected
                         continue  # re-read the corrected code, no "what should it be?"
+                    start_ts = time.monotonic()
                     buffer = ""
+                    echoed = ""
                     await self._task.queue_frame(
                         TTSSpeakFrame(text=collect_prompt(language, "restart_denied"))
                     )
@@ -3095,8 +3156,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 # asked to hear it back, RE-READ the digits-so-far (no miss); else re-ask
                 # and count a miss. Compare by VALUE not length so a same-length
                 # correction during the echo phase counts as progress (echoed below).
-                turns = self._collect_turns_since(start_ts)
-                if buffer and turns and is_repeat_request(turns[-1]):
+                if buffer and getattr(self, "_collect_repeat", False):
                     # Re-reads bypass the miss counter, so the absolute deadline is the
                     # only bound — without it a caller repeating "say it again" loops
                     # forever (a turn lands every cycle, never silence, never a miss).
@@ -3156,7 +3216,8 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # knows WHAT is being confirmed. Works in any language.
             answer = await self._extract_spoken_value(
                 node_id,
-                "yes if the caller agrees the value is correct, no if they say it is wrong",
+                "yes if the caller agrees the value is correct, no if they say it is "
+                "wrong, repeat if they ask to hear the value read back again",
                 timeout_s=10.0,
                 system_prompt=(
                     "The assistant just read a value back to the caller and asked them "
@@ -3165,13 +3226,16 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     "confirmed it is correct. If they point out ANY mistake or give a "
                     "different value — even while sounding agreeable (e.g. 'no, the "
                     "last one is 5 not 3', 'haan but change the first digit') — that "
-                    "is NOT confirmed; answer 'no'. Answer 'yes' only if they accept "
-                    "it exactly as read."
+                    "is NOT confirmed; answer 'no'. Answer 'repeat' ONLY if they ask "
+                    "to HEAR the value again ('repeat that', 'दोबारा बोलिए') — a "
+                    "caller saying it is wrong and offering to dictate it again "
+                    "('नहीं, मैं फिर से बताती हूँ') means 'no', not 'repeat'. Answer "
+                    "'yes' only if they accept it exactly as read."
                 ),
                 context_prefix=[
                     {"role": "assistant", "content": f"I have {readback}. Is that correct?"}
                 ],
-                enum_values=["yes", "no"],
+                enum_values=["yes", "no", "repeat"],
             )
             # Hard guard: a genuine confirmation never contains digits, a correction
             # ("no, the last is 5 not 3") always does. If the reply has any digit,
@@ -3184,17 +3248,18 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 else ""
             )
             has_digit = any(ch.isdigit() for ch in reply)
-            # A request to hear it again ("can you repeat?") is NOT a yes or a no —
-            # re-read the value and DON'T burn a confirm attempt (bounded so a caller
-            # stuck on "repeat" can't loop forever). A digit-carrying reply is a
-            # correction, handled just below, so only a digit-free reply is a repeat.
-            if not has_digit and is_repeat_request(reply):
-                repeats += 1
-                if repeats <= 3:
-                    continue
             if has_digit:
                 return False
             text = (answer or "").strip().lower()
+            # A request to hear it again (LLM-decided — "मैं फिर से बताती हूँ" /
+            # "I'll tell you again" classifies as 'no', not 'repeat'; the old
+            # substring match looped on that false positive, live call 2a3f6513)
+            # is NOT a yes or a no — re-read the value and DON'T burn a confirm
+            # attempt (bounded so a caller stuck on "repeat" can't loop forever).
+            if text.startswith("repeat"):
+                repeats += 1
+                if repeats <= 3:
+                    continue
             if text.startswith("yes"):
                 return True
             if text.startswith("no"):

{dv_pipecat_flows-0.0.0.dev2786 → dv_pipecat_flows-0.0.0.dev2828}/src/pipecat_flows/processors/router_mode_guard.py

@@ -48,6 +48,7 @@ from typing import Callable, Tuple, Type
 
 from pipecat.frames.frames import (
     Frame,
+    LLMContextFrame,
     LLMMessagesFrame,
     LLMRunFrame,
     LLMTextFrame,
@@ -63,6 +64,16 @@ logger = logging.getLogger(__name__)
 # race-free fix for the spurious-bot-text problem.
 _TRIGGER_FRAME_TYPES: Tuple[Type[Frame], ...] = (
     OpenAILLMContextFrame,
+    # Universal context frame. `LLMContextFrame` and `OpenAILLMContextFrame` are
+    # SIBLINGS (both extend Frame directly), so matching one does NOT match the
+    # other — both must be listed. The pipeline picks between them from a single
+    # switch in the bot: `context = LLMContext() if (_use_responses or
+    # _use_universal_for_google) else OpenAILLMContext()`. Omitting this one let
+    # the LLM fire during router-mode nodes on every Responses-API agent
+    # (gpt-5.4-mini/nano are forced onto Responses regardless of the
+    # `use_responses_api` toggle) and every google/gemma agent — the bot spoke
+    # spurious freeform text instead of routing silently.
+    LLMContextFrame,
     LLMMessagesFrame,
     LLMRunFrame,
 )

{dv_pipecat_flows-0.0.0.dev2786 → dv_pipecat_flows-0.0.0.dev2828}/src/pipecat_flows/processors/user_turn_observer.py

@@ -1,4 +1,5 @@
-"""Observer that timestamps :class:`OpenAILLMContextFrame` so router-mode
+"""Observer that timestamps the user-turn-committed context frame
+(:class:`OpenAILLMContextFrame` **or** :class:`LLMContextFrame`) so router-mode
 nodes can detect "user turn is now committed to context" without reaching
 into the user context aggregator's private state.
 
@@ -7,22 +8,27 @@ Why an observer, not a FrameProcessor:
     public ``PipelineTask.add_observer`` API.
   * We only need a passive timestamp + an ``asyncio.Event`` — no frame routing.
 
-Why ``OpenAILLMContextFrame`` and not ``UserStoppedSpeakingFrame``:
+Why a context frame and not ``UserStoppedSpeakingFrame``:
   * ``UserStoppedSpeakingFrame`` is raw VAD — it fires the instant the mic
     detects silence, BEFORE the STT final lands and BEFORE the user-context
     aggregator appends the turn. Router gates that release on this signal
     classify against an empty/stale context.
-  * ``OpenAILLMContextFrame`` is pushed by ``LLMUserContextAggregator``
+  * The context frame is pushed by ``LLMUserContextAggregator``
     (``llm_response._process_aggregation``) only AFTER the final transcript
     is appended to the LLM context. It is the canonical "user turn is now
     in the context the router will read" event.
   * Router-mode never queues ``LLMRunFrame`` for the router node itself, so
-    the only ``OpenAILLMContextFrame`` produced during a router invocation
-    comes from the aggregator's turn-complete path — no competing source.
+    the only context frame produced during a router invocation comes from
+    the aggregator's turn-complete path — no competing source.
+
+BOTH context-frame flavours must be matched (see
+``_USER_TURN_COMMITTED_FRAME_TYPES``): the aggregator emits
+``LLMContextFrame`` on the Responses-API / google / gemma paths and
+``OpenAILLMContextFrame`` on the Chat Completions path.
 
 State exposed:
   * ``last_user_context_pushed_ts``: monotonic time of the latest
-    ``OpenAILLMContextFrame`` (user turn committed to context).
+    user-turn context frame (user turn committed to context).
   * ``last_user_stopped_ts``: backwards-compatible alias kept in sync with
     ``last_user_context_pushed_ts`` so existing callers keep working.
   * ``event``: ``asyncio.Event`` set on every such frame; the consumer is
@@ -38,26 +44,41 @@ from typing import List, Tuple
 
 from pipecat.frames.frames import (
     InterimTranscriptionFrame,
+    LLMContextFrame,
     TranscriptionFrame,
     UserStartedSpeakingFrame,
 )
 from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContextFrame
 from pipecat.observers.base_observer import BaseObserver, FramePushed
 
+# Both context-frame flavours mean the same thing here: "the user's turn is now
+# committed to the context the router will read". Which one the aggregator emits
+# is decided by one switch in the bot:
+#
+#     context = LLMContext() if (_use_responses or _use_universal_for_google)
+#               else OpenAILLMContext()
+#
+# They are SIBLINGS (both extend Frame directly, neither subclasses the other),
+# so matching one does NOT match the other. Keying on only OpenAILLMContextFrame
+# left every Responses-API / google / gemma agent's router waiting the full
+# ``router_wait_for_user_timeout`` (15s) after the caller had already replied.
+_USER_TURN_COMMITTED_FRAME_TYPES = (OpenAILLMContextFrame, LLMContextFrame)
+
 # Bound the per-call transcript log so a very long call can't grow it without
 # limit; far more than any single Collect dictation needs.
 _MAX_TRANSCRIPT_LOG = 256
 
 
 class UserTurnObserver(BaseObserver):
-    """Tracks the timestamp of the most recent ``OpenAILLMContextFrame``.
+    """Tracks the timestamp of the most recent user-turn context frame.
 
     Router-mode uses this to (a) detect a user reply already committed to
     context BEFORE the router was entered (barge-in during the preceding
     Speak's TTS) and (b) await the NEXT user reply when none is available.
 
-    The observer is keyed on ``OpenAILLMContextFrame`` rather than the raw
-    VAD ``UserStoppedSpeakingFrame`` because only the former guarantees the
+    The observer is keyed on the context frame (either flavour, see
+    ``_USER_TURN_COMMITTED_FRAME_TYPES``) rather than the raw VAD
+    ``UserStoppedSpeakingFrame`` because only the former guarantees the
     user's transcript has been appended to the LLM context the router reads.
     """
 
@@ -93,7 +114,7 @@ class UserTurnObserver(BaseObserver):
 
     @property
     def event(self) -> asyncio.Event:
-        """The asyncio.Event set on each ``OpenAILLMContextFrame``.
+        """The asyncio.Event set on each user-turn context frame.
 
         Callers MUST ``.clear()`` before awaiting if they want to wait for the
         NEXT frame (vs. immediately returning on a stale set state).
@@ -101,7 +122,7 @@ class UserTurnObserver(BaseObserver):
         return self._event
 
     async def on_push_frame(self, data: FramePushed) -> None:
-        if isinstance(data.frame, OpenAILLMContextFrame):
+        if isinstance(data.frame, _USER_TURN_COMMITTED_FRAME_TYPES):
             now = time.monotonic()
             self.last_user_context_pushed_ts = now
             self.last_user_stopped_ts = now

dv_pipecat_flows-0.0.0.dev2786/src/dv_pipecat_flows.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.0.0.dev0",
-  "distance": 2786,
-  "node": "g4f35e028c126047efd7781c8674fba2a380c5e99",
-  "dirty": false,
-  "branch": "dv-stage",
-  "node_date": "2026-08-10"
-}