dv-pipecat-flows 0.0.22.dev1484__tar.gz → 0.0.22.dev1487__tar.gz

{dv_pipecat_flows-0.0.22.dev1484/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.22.dev1487}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.22.dev1484
+Version: 0.0.22.dev1487
 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.22.dev1484 → dv_pipecat_flows-0.0.22.dev1487/src/dv_pipecat_flows.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.22.dev1484
+Version: 0.0.22.dev1487
 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.22.dev1484 → dv_pipecat_flows-0.0.22.dev1487}/src/pipecat_flows/condition_evaluator.py

@@ -380,6 +380,18 @@ def _evaluate_rule(
 
     rhs = _resolve_side(rule, "value", state, tool_outputs)
 
+    # Fail-closed for jq sides: a jq LHS/RHS that errored or yielded null must not
+    # drive a match. Without this a None jq LHS satisfies ``not_equals`` against
+    # any non-null RHS (None != value) and misroutes the router — contradicting
+    # ``evaluate_jq_side``'s "bad jq degrades the rule to False" policy. Plain
+    # variable refs keep their historic None handling (a missing var is still
+    # legitimately != a value), and ``exists`` / ``not_exists`` above are untouched.
+    if isinstance(rule, dict) and (
+        (rule.get("variable_kind") == "jq" and lhs is None)
+        or (rule.get("value_kind") == "jq" and rhs is None)
+    ):
+        return False
+
     if op == "equals":
         if lhs is None:
             return False

{dv_pipecat_flows-0.0.22.dev1484 → dv_pipecat_flows-0.0.22.dev1487}/src/pipecat_flows/manager.py

@@ -2114,6 +2114,32 @@ In all of these cases, you can provide a `name` in your new node's config for de
             "router_default_next"
         )
 
+    async def _timed_router_completion(self, node_id: str, **kwargs: Any) -> Optional[str]:
+        """Run a Collect-path constrained completion, logging its latency.
+
+        Every LLM call the Collect node makes — digit extraction, spoken-value
+        extraction, and the yes/no confirm — funnels through here. The calls are
+        non-streaming (``stream=False``) and return a tiny JSON, so the whole
+        round-trip is effectively the time-to-first-token; it's logged per call,
+        labelled by ``schema_name`` and the resolved model, so the node's LLM
+        tail latency is visible in call logs (grep ``ttft``). The ``finally`` logs
+        even on failure, so a slow call that then errors is still measured.
+        """
+        llm_service = kwargs.get("llm_service")
+        model = (
+            getattr(llm_service, "model_name", None)
+            or getattr(llm_service, "_model_name", None)
+            or getattr(llm_service, "_model", None)
+            or "?"
+        )
+        label = kwargs.get("schema_name", "router_decision")
+        start = time.monotonic()
+        try:
+            return await self._adapter.run_router_completion(**kwargs)
+        finally:
+            elapsed_ms = (time.monotonic() - start) * 1000.0
+            logger.info(f"Collect '{node_id}': {label} on {model} ttft {elapsed_ms:.0f}ms")
+
     async def _extract_spoken_value(
         self,
         node_id: str,
@@ -2134,35 +2160,21 @@ In all of these cases, you can provide a `name` in your new node's config for de
         turn, and ``system_prompt`` overrides the default extraction instruction.
         """
         observer = self._user_turn_observer
+        entry_ts = time.monotonic()
         if observer is not None and timeout_s > 0:
-            entry_ts = time.monotonic()
-            if observer.last_user_stopped_ts < entry_ts:
+            # Wait for the caller's reply to COMMIT, and stay PATIENT while they're
+            # still mid-utterance, so we read their finished answer (e.g. a
+            # barge-in "जी हाँ, सही है") and not an empty/partial first fragment.
+            deadline = entry_ts + timeout_s
+            while observer.last_user_stopped_ts < entry_ts or self._caller_is_speaking():
                 observer.event.clear()
-                if observer.last_user_stopped_ts < entry_ts:
-                    try:
-                        await asyncio.wait_for(observer.event.wait(), timeout=timeout_s)
-                    except asyncio.TimeoutError:
-                        return None
-
-        # Scope the extraction to the caller's latest turn (plus any explicit
-        # grounding prefix). Feeding the whole transcript makes the constrained
-        # extraction ambiguous: the read-back ("I have 8130579687…") and prior
-        # digit turns sit in history, so a yes/no confirm would extract the phone
-        # number instead of "yes". The confirm passes the read-back question as a
-        # `context_prefix` so the model knows WHAT is being confirmed without the
-        # whole noisy history.
-        context_messages: List[Dict[str, Any]] = list(context_prefix or [])
-        if self._context_aggregator:
-            ctx = self._context_aggregator.user()._context
-            all_messages = (
-                ctx.get_messages() if hasattr(ctx, "get_messages")
-                else getattr(ctx, "messages", [])
-            )
-            latest_user = next(
-                (m for m in reversed(all_messages) if m.get("role") == "user"), None
-            )
-            if latest_user is not None:
-                context_messages.append(latest_user)
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    break
+                try:
+                    await asyncio.wait_for(observer.event.wait(), timeout=remaining)
+                except asyncio.TimeoutError:
+                    break
 
         llm_service = self._llm
         if isinstance(llm_service, LLMSwitcher):
@@ -2175,26 +2187,82 @@ In all of these cases, you can provide a `name` in your new node's config for de
         if enum_values:
             value_spec = {"type": "enum", "values": list(enum_values), "description": description}
         schema = build_router_response_schema([], {"value": value_spec})
-        try:
-            raw = await self._adapter.run_router_completion(
-                llm_service=llm_service,
-                system_prompt=system_prompt or (
-                    "Extract the requested value from the caller's latest "
-                    "message. Put ONLY the value in the `value` field, or an "
-                    "empty string if the caller did not clearly provide it."
-                ),
-                response_schema=schema,
-                context_messages=context_messages,
-                schema_name=f"collect_{node_id}",
-            )
-        except Exception as exc:
-            logger.warning(f"Collect '{node_id}': extraction call failed: {exc!r}")
-            return None
-        if not raw:
-            return None
-        _branch, extracted = parse_router_response(raw, [UNCLEAR_BRANCH_ID])
-        value = (extracted or {}).get("value")
-        return value if isinstance(value, str) and value.strip() else None
+
+        deadline = entry_ts + timeout_s if timeout_s > 0 else entry_ts
+        last_value: Optional[str] = None
+        # Extract, then RE-EXTRACT if the caller kept talking while we were calling
+        # the LLM. A paused / fragmented reply ("उह…" <pause> "जी हाँ, यह सही है")
+        # commits its first fragment as its own turn, so a single extraction fires
+        # on the leading filler and misses the real answer — which is exactly how a
+        # clear "yes" got read as a rejection. The LLM round-trip doubles as a
+        # settle window: if the reply GREW (or the caller is still mid-utterance) by
+        # the time it returns, our input was partial, so we let them finish and
+        # extract again. Bounded so a chatty caller can never loop us unbounded, and
+        # zero added latency when the first reply is already complete.
+        for _ in range(3):
+            # Read the caller's reply from the NON-LOSSY observer log — the context
+            # aggregator DROPS turns on barge-in, which made the confirm read an
+            # empty/partial reply. Join any chunks spoken since we started listening
+            # so a fragmented answer reaches the model whole. ``context_prefix``
+            # carries the read-back question so the model knows WHAT is being
+            # confirmed. Fall back to the aggregator when there's no observer (tests).
+            reply = ""
+            if observer is not None and hasattr(observer, "transcripts_since"):
+                reply = " ".join(observer.transcripts_since(entry_ts)).strip()
+            context_messages: List[Dict[str, Any]] = list(context_prefix or [])
+            if reply:
+                context_messages.append({"role": "user", "content": reply})
+            elif self._context_aggregator:
+                ctx = self._context_aggregator.user()._context
+                all_messages = (
+                    ctx.get_messages() if hasattr(ctx, "get_messages")
+                    else getattr(ctx, "messages", [])
+                )
+                latest_user = next(
+                    (m for m in reversed(all_messages) if m.get("role") == "user"), None
+                )
+                if latest_user is not None:
+                    context_messages.append(latest_user)
+            try:
+                raw = await self._timed_router_completion(
+                    node_id,
+                    llm_service=llm_service,
+                    system_prompt=system_prompt or (
+                        "Extract the requested value from the caller's latest "
+                        "message. Put ONLY the value in the `value` field, or an "
+                        "empty string if the caller did not clearly provide it."
+                    ),
+                    response_schema=schema,
+                    context_messages=context_messages,
+                    schema_name=f"collect_{node_id}",
+                )
+            except Exception as exc:
+                logger.warning(f"Collect '{node_id}': extraction call failed: {exc!r}")
+                return last_value
+            if raw:
+                _branch, extracted = parse_router_response(raw, [UNCLEAR_BRANCH_ID])
+                value = (extracted or {}).get("value")
+                if isinstance(value, str) and value.strip():
+                    last_value = value
+            # No observer (unit tests) → single shot. Otherwise re-extract only if
+            # the caller said MORE during the call or is still speaking, and time
+            # remains.
+            if observer is None or not hasattr(observer, "transcripts_since"):
+                break
+            grew = " ".join(observer.transcripts_since(entry_ts)).strip() != reply
+            if (not grew and not self._caller_is_speaking()) or time.monotonic() >= deadline:
+                break
+            # Let the caller finish the rest of their reply before re-extracting, so
+            # we don't fire again on yet another partial.
+            while self._caller_is_speaking() and time.monotonic() < deadline:
+                observer.event.clear()
+                try:
+                    await asyncio.wait_for(
+                        observer.event.wait(), timeout=max(0.05, deadline - time.monotonic())
+                    )
+                except asyncio.TimeoutError:
+                    break
+        return last_value
 
     def _active_language(self) -> str:
         """The conversation's current language for caller-facing prompts.
@@ -2267,6 +2335,21 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 )
         return turns
 
+    def _collect_turns_since(self, since_ts: float) -> List[str]:
+        """Caller turns (voice + keypad) committed since ``since_ts``, read from
+        the NON-LOSSY observer transcript log rather than the context aggregator.
+
+        The context aggregator (and the transcript handler) DROP a turn when the
+        caller re-speaks before it's pushed — so a chunked dictation like
+        "70823" … "41303" loses the first chunk, and Collect reads a partial.
+        The observer captured the raw ``TranscriptionFrame`` upstream of that
+        drop, so reading from it recovers every chunk. Falls back to ``[]`` when
+        there's no observer (unit tests stub the extractor directly)."""
+        observer = self._user_turn_observer
+        if observer is not None and hasattr(observer, "transcripts_since"):
+            return observer.transcripts_since(since_ts)
+        return []
+
     async def _drain_user_turns(self, settle_s: float) -> None:
         """Absorb any rapid follow-up turns within a short settle window, so a
         multi-chunk dictation triggers ONE digit extraction instead of one per
@@ -2274,6 +2357,46 @@ In all of these cases, you can provide a `name` in your new node's config for de
         while await self._await_user_turn(timeout_s=settle_s):
             pass
 
+    # Absolute backstop: most a Capture accumulate-loop will wait before giving
+    # up, so a hot mic / endless background noise that VAD reads as "speaking"
+    # can never trap the call in the node (the activity-aware wait below would
+    # otherwise reset forever).
+    _MAX_CAPTURE_SECONDS = 90.0
+
+    def _caller_is_speaking(self) -> bool:
+        """True while the caller has an IN-PROGRESS utterance — they started more
+        recently than they last stopped. Lets the Capture node avoid nudging over
+        them or acting on a half-spoken value. False when there's no observer
+        yet (e.g. tests / pre-pipeline)."""
+        observer = self._user_turn_observer
+        return bool(observer and observer.last_user_started_ts > observer.last_user_stopped_ts)
+
+    async def _wait_for_caller_input(
+        self,
+        timeout_s: float,
+        deadline_ts: float,
+        allow_keypad: bool,
+        keypad_dtmf: Dict[str, Any],
+    ) -> bool:
+        """Wait for a committed caller turn (voice, or a keypad fallback). PATIENT
+        while the caller is mid-utterance: a voice timeout that lands while they
+        are still speaking is NOT counted as silence — keep waiting for them to
+        finish, bounded by ``deadline_ts``. Returns True if input arrived, False
+        on genuine silence (or once the absolute deadline passes)."""
+        while True:
+            if await self._await_user_turn(timeout_s):
+                return True
+            # Voice window elapsed with nothing committed. If they're still
+            # talking and we have time, keep waiting rather than nudging over them.
+            if self._caller_is_speaking() and time.monotonic() < deadline_ts:
+                continue
+            # Genuine silence → optional keypad fallback, else report silence.
+            if allow_keypad:
+                capture_timeout = float((keypad_dtmf or {}).get("timeout", 8.0)) + 10.0
+                if await self._await_dtmf_capture(keypad_dtmf, capture_timeout):
+                    return True
+            return False
+
     async def _extract_accumulated_digits(
         self, node_id: str, turns: List[str], what: str = "phone number"
     ) -> str:
@@ -2305,17 +2428,33 @@ In all of these cases, you can provide a `name` in your new node's config for de
             }},
         )
         try:
-            raw = await self._adapter.run_router_completion(
+            raw = await self._timed_router_completion(
+                node_id,
                 llm_service=llm_service,
                 system_prompt=(
                     f"The caller is dictating a {what} to you, possibly across "
                     "several messages and in ANY language (English, Hindi, etc.), or "
-                    f"as keypad input (a message like 'User inputted: 5'). Read "
+                    "as keypad input (a message like 'User inputted: 5'). Read "
                     f"EVERYTHING they have said and put the full {what} — every digit, "
                     "in the order spoken — into `value` as digits 0-9 only, with no "
-                    "spaces or punctuation. If they correct or restate it, "
-                    "use their final intended value. Output an empty string if they "
-                    "have given no digits yet."
+                    "spaces or punctuation. Expand spoken repeat-words into digits: "
+                    "'double X' / 'डबल X' / 'do baar X' means XX, and 'triple X' / "
+                    "'ट्रिपल X' means XXX (e.g. 'double seven' -> 77, 'triple 9' -> 999, "
+                    "'double oh' -> 00). If they correct or restate any part — e.g. "
+                    "'no, the first/last part is X', 'the start/beginning is X', "
+                    "'the end is X', 'where I said Y it's actually Z', or they repeat "
+                    "the whole thing — APPLY the correction to the earlier value and "
+                    "output the single final intended number, keeping the un-corrected "
+                    "digits unchanged. When the position is vague, anchor on the VALUE: "
+                    "find the run of digits they are replacing and swap only that run. "
+                    "A correction may be terse and the position named in ANY language "
+                    "(start/beginning/शुरू/स्टार्टिंग, end/last/एंड/लास्ट), and is often "
+                    "prefixed with 'no'/'नहीं' — still apply it. Examples: '70823 41303' "
+                    "then 'no, the first part is 807' -> '8072341303'; '70823 41303' "
+                    "then 'नहीं, स्टार्टिंग में 80 है' (the start is 80) -> '8082341303'; "
+                    "'70823 41303' then 'एंड में 5 है' (the end is 5) -> '7082341305'; "
+                    "'70823 41303' then 'where I said 41 it's 14' -> '7082314303'. "
+                    "Output an empty string if they have given no digits yet."
                 ),
                 response_schema=schema,
                 context_messages=context_messages,
@@ -2330,6 +2469,32 @@ In all of these cases, you can provide a `name` in your new node's config for de
         value = (extracted or {}).get("value")
         return re.sub(r"\D", "", value) if isinstance(value, str) else ""
 
+    async def _reextract_if_corrected(
+        self,
+        node_id: str,
+        collect_type: str,
+        start_ts: float,
+        current_normalized: Any,
+        *,
+        what: str = "phone number",
+        **norm_opts: Any,
+    ) -> Optional[Tuple[str, Any]]:
+        """After a REJECTED confirm, re-extract over the turns we already have —
+        the caller's correction ("no, the end is 5") is already among them — and
+        return ``(new_buffer, new_normalized)`` when it resolves to a DIFFERENT
+        valid value. That means the caller actually corrected the number, so we
+        re-read the corrected value at once instead of asking them to repeat it.
+        Returns ``None`` for a plain rejection that carries no new/changed digits
+        (the caller just said "no") → fall through to the "what should it be?" ask.
+        """
+        new_buffer = await self._extract_accumulated_digits(
+            node_id, self._collect_turns_since(start_ts), what=what
+        )
+        new_normalized = normalize_collect_value(collect_type, new_buffer, **norm_opts)
+        if new_normalized and new_normalized != current_normalized:
+            return new_buffer, new_normalized
+        return None
+
     async def _run_collect_node(
         self, node_id: str, node_config: Dict[str, Any]
     ) -> Optional[str]:
@@ -2410,11 +2575,14 @@ In all of these cases, you can provide a `name` in your new node's config for de
         the caller. Returns the E.164 value or ``None``.
         """
         target = 10  # min national digits; validity decided by normalize_phone
-        # Snapshot the caller-turn count so we read only turns spoken to THIS
-        # node; a confirm "no" / invalid advances it to ignore the rejected attempt.
-        start_index = len(self._user_messages())
+        # Snapshot a monotonic time so we read (from the non-lossy observer log)
+        # only turns spoken to THIS node; a confirm "no" / invalid advances it to
+        # ignore the rejected attempt's turns.
+        start_ts = time.monotonic()
         buffer = ""
         misses = 0
+        corrections = 0  # confirm "no" rounds, bounded so a correction can't loop
+        deadline = time.monotonic() + self._MAX_CAPTURE_SECONDS
 
         async def _nudge(language: str) -> None:
             """Re-ask: echo a partial and ask for the rest, else the author reask."""
@@ -2430,51 +2598,68 @@ In all of these cases, you can provide a `name` in your new node's config for de
 
         while misses < max_attempts:
             language = self._active_language()
-            # Give the caller longer to START dictating; once we hold a partial,
-            # nudge sooner if they pause rather than leaving dead air.
-            got_turn = await self._await_user_turn(timeout_s=7.0 if buffer else 15.0)
-            if not got_turn and allow_keypad:
-                # Keypad fallback: a keypress commits a "User inputted: N." turn
-                # that the extractor reads alongside spoken turns.
-                capture_timeout = float(keypad_dtmf.get("timeout", 8.0)) + 10.0
-                if await self._await_dtmf_capture(keypad_dtmf, capture_timeout):
-                    got_turn = True
+            # Longer window to START dictating; 7s once we hold a partial. Patient
+            # while the caller is mid-utterance, so a timeout can't clip them.
+            got_turn = await self._wait_for_caller_input(
+                5.0 if buffer else 15.0, deadline, allow_keypad, keypad_dtmf
+            )
             if not got_turn:
-                # Silence: nothing new heard → re-ask, count a miss.
+                if time.monotonic() >= deadline:
+                    break  # absolute cap reached → give up rather than loop forever
+                # Genuine silence (caller not mid-utterance): re-ask, count a miss.
                 misses += 1
                 if misses < max_attempts:
                     await _nudge(language)
                 continue
 
-            # Collapse a rapid multi-chunk dictation into a single extraction.
-            await self._drain_user_turns(settle_s=1.2)
-
             previous = buffer
+            turns_before = len(self._collect_turns_since(start_ts))
             buffer = await self._extract_accumulated_digits(
-                node_id, self._caller_turns_since(start_index)
+                node_id, self._collect_turns_since(start_ts)
             )
+            # Freshness: a turn committed during extraction, or the caller is
+            # speaking now → the value may be stale (mid-correction). Re-extract
+            # next pass instead of reading back a number they're still changing.
+            if len(self._collect_turns_since(start_ts)) > turns_before or self._caller_is_speaking():
+                continue
             normalized = normalize_collect_value(
                 "phone", buffer, country_default=country_default
             )
             if normalized:
-                confirmed = await self._confirm_collected(node_id, " ".join(buffer))
-                if confirmed is True:
-                    return normalized
-                # Wrong / unclear → start over: ignore everything said so far so the
-                # next dictation isn't re-extracted together with the rejected one.
-                start_index = len(self._user_messages())
-                buffer = ""
-                if confirmed is False:
+                # Confirm; on a "no, it's X" correction RE-EXTRACT over the turns we
+                # already have (the caller's fix is already among them) and re-read
+                # 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``.
+                while True:
+                    confirmed = await self._confirm_collected(node_id, " ".join(buffer))
+                    if confirmed is True:
+                        return normalized
+                    corrections += 1
+                    if corrections >= max_attempts:
+                        break
+                    corrected = await self._reextract_if_corrected(
+                        node_id, "phone", start_ts, normalized,
+                        country_default=country_default,
+                    )
+                    if corrected is not None:
+                        buffer, normalized = corrected
+                        continue  # re-read the corrected number, no "what should it be?"
+                    buffer = ""
                     await self._task.queue_frame(
                         TTSSpeakFrame(text=collect_prompt(language, "restart_denied"))
                     )
-                else:
-                    misses += 1
+                    break
+                if corrections >= max_attempts:
+                    break
                 continue
 
             if len(buffer) >= target:
                 # Enough digits but not a valid number → reset and re-ask.
-                start_index = len(self._user_messages())
+                start_ts = time.monotonic()
                 buffer = ""
                 misses += 1
                 if misses < max_attempts:
@@ -2491,8 +2676,10 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     await _nudge(language)
                 continue
 
-            # Buffer grew but is still incomplete → stay silent and let the caller
-            # keep dictating; don't interrupt mid-number or burn an attempt.
+            # Buffer GREW (progress) → reset the give-up counter so a caller who
+            # keeps adding digits (even slowly, pausing to think) is never cut
+            # off; only a genuine stall trips the bound. Keep listening silently.
+            misses = 0
 
         logger.info(f"Collect '{node_id}': gave up after {misses} misses (buffer='{buffer}')")
         return None
@@ -2518,9 +2705,11 @@ In all of these cases, you can provide a `name` in your new node's config for de
         digits). Returns the digit string or ``None`` on give-up.
         """
         target = int(num_digits) if num_digits else 6
-        start_index = len(self._user_messages())
+        start_ts = time.monotonic()
         buffer = ""
         misses = 0
+        corrections = 0  # confirm "no" rounds, bounded so a correction can't loop
+        deadline = time.monotonic() + self._MAX_CAPTURE_SECONDS
         # Keypad auto-flushes once the caller has keyed `target` digits.
         code_dtmf = {**(keypad_dtmf or {}), "digits": target}
 
@@ -2537,45 +2726,59 @@ In all of these cases, you can provide a `name` in your new node's config for de
 
         while misses < max_attempts:
             language = self._active_language()
-            got_turn = await self._await_user_turn(timeout_s=7.0 if buffer else 15.0)
-            if not got_turn and allow_keypad:
-                capture_timeout = float(code_dtmf.get("timeout", 8.0)) + 10.0
-                if await self._await_dtmf_capture(code_dtmf, capture_timeout):
-                    got_turn = True
+            got_turn = await self._wait_for_caller_input(
+                5.0 if buffer else 15.0, deadline, allow_keypad, code_dtmf
+            )
             if not got_turn:
+                if time.monotonic() >= deadline:
+                    break  # absolute cap reached → give up
                 misses += 1
                 if misses < max_attempts:
                     await _nudge(language)
                 continue
 
-            # Collapse a rapid multi-chunk dictation into a single extraction.
-            await self._drain_user_turns(settle_s=1.2)
-
             previous = buffer
+            turns_before = len(self._collect_turns_since(start_ts))
             buffer = await self._extract_accumulated_digits(
-                node_id, self._caller_turns_since(start_index), what="numeric code"
+                node_id, self._collect_turns_since(start_ts), what="numeric code"
             )
+            # Freshness: stale if a turn committed mid-extraction or they're still
+            # speaking → re-extract next pass rather than read back a half-code.
+            if len(self._collect_turns_since(start_ts)) > turns_before or self._caller_is_speaking():
+                continue
             normalized = normalize_collect_value(
                 collect_type, buffer, num_digits=target
             )
             if normalized:
-                confirmed = await self._confirm_collected(node_id, " ".join(normalized))
-                if confirmed is True:
-                    return normalized
-                # Wrong / unclear → start over: ignore everything said so far.
-                start_index = len(self._user_messages())
-                buffer = ""
-                if confirmed is False:
+                # 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?".
+                while True:
+                    confirmed = await self._confirm_collected(node_id, " ".join(normalized))
+                    if confirmed is True:
+                        return normalized
+                    corrections += 1
+                    if corrections >= max_attempts:
+                        break
+                    corrected = await self._reextract_if_corrected(
+                        node_id, collect_type, start_ts, normalized,
+                        what="numeric code", num_digits=target,
+                    )
+                    if corrected is not None:
+                        buffer, normalized = corrected
+                        continue  # re-read the corrected code, no "what should it be?"
+                    buffer = ""
                     await self._task.queue_frame(
                         TTSSpeakFrame(text=collect_prompt(language, "restart_denied"))
                     )
-                else:
-                    misses += 1
+                    break
+                if corrections >= max_attempts:
+                    break
                 continue
 
             if len(buffer) > target:
                 # Too many digits for this code → reset and re-ask.
-                start_index = len(self._user_messages())
+                start_ts = time.monotonic()
                 buffer = ""
                 misses += 1
                 if misses < max_attempts:
@@ -2591,41 +2794,68 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     await _nudge(language)
                 continue
 
-            # Buffer grew but is still short → stay silent and keep listening.
+            # Buffer GREW (progress) → reset the give-up counter; keep listening.
+            misses = 0
 
         logger.info(f"Collect '{node_id}': code give-up after {misses} misses (buffer='{buffer}')")
         return None
 
-    async def _confirm_collected(self, node_id: str, readback: str) -> Optional[bool]:
+    async def _confirm_collected(
+        self, node_id: str, readback: str, attempts: int = 2
+    ) -> Optional[bool]:
         """Read the value back and capture a yes/no. Returns ``True`` (confirmed),
-        ``False`` (denied), or ``None`` (no / unclear answer)."""
-        await self._task.queue_frame(
-            TTSSpeakFrame(text=collect_prompt(self._active_language(), "confirm", readback=readback))
-        )
-        # Structured yes/no enum: the model must return "yes" or "no" (or null
-        # when genuinely unclear), grounded with the read-back question so it
-        # 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",
-            timeout_s=10.0,
-            system_prompt=(
-                "The assistant just read a value back to the caller and asked them "
-                "to confirm it (see the assistant message). Based ONLY on the "
-                "caller's latest reply — in any language — answer whether they "
-                "confirmed it is correct."
-            ),
-            context_prefix=[
-                {"role": "assistant", "content": f"I have {readback}. Is that correct?"}
-            ],
-            enum_values=["yes", "no"],
-        )
-        text = (answer or "").strip().lower()
-        if text.startswith("yes"):
-            return True
-        if text.startswith("no"):
-            return False
-        return None  # null / unclear → re-ask
+        ``False`` (denied), or ``None`` (still unclear after re-asking).
+
+        Re-asks the yes/no up to ``attempts`` times: a barge-in / fragmented first
+        reply ("जी" … "हाँ, सही है") can read as unclear, and we'd rather re-ask
+        "is that correct?" than treat a confirming caller as a rejection."""
+        observer = self._user_turn_observer
+        for _ in range(max(1, attempts)):
+            listen_ts = time.monotonic()
+            await self._task.queue_frame(
+                TTSSpeakFrame(text=collect_prompt(self._active_language(), "confirm", readback=readback))
+            )
+            # Structured yes/no enum: the model must return "yes" or "no" (or null
+            # when genuinely unclear), grounded with the read-back question so it
+            # 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",
+                timeout_s=10.0,
+                system_prompt=(
+                    "The assistant just read a value back to the caller and asked them "
+                    "to confirm it (see the assistant message). Based ONLY on the "
+                    "caller's latest reply — in any language — answer whether they "
+                    "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."
+                ),
+                context_prefix=[
+                    {"role": "assistant", "content": f"I have {readback}. Is that correct?"}
+                ],
+                enum_values=["yes", "no"],
+            )
+            # 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,
+            # treat it as a correction (no) regardless of the model — otherwise a
+            # mis-read "yes" stores the UN-corrected number. Read from the non-lossy
+            # observer so a dropped/fragmented reply is still seen.
+            reply = (
+                " ".join(observer.transcripts_since(listen_ts))
+                if observer is not None and hasattr(observer, "transcripts_since")
+                else ""
+            )
+            if any(ch.isdigit() for ch in reply):
+                return False
+            text = (answer or "").strip().lower()
+            if text.startswith("yes"):
+                return True
+            if text.startswith("no"):
+                return False
+            # null / unclear → re-ask "is that correct?" (next loop iteration)
+        return None
 
     async def _collect_single_value(
         self,
@@ -2651,6 +2881,13 @@ In all of these cases, you can provide a `name` in your new node's config for de
             if not raw_value and allow_keypad:
                 capture_timeout = float(keypad_dtmf.get("timeout", 8.0)) + 10.0
                 raw_value = await self._await_dtmf_capture(keypad_dtmf, capture_timeout)
+            # Freshness: if they're still finishing the address, let them complete
+            # and re-read once before validating — don't act on a half-heard value.
+            if raw_value and self._caller_is_speaking():
+                if await self._await_user_turn(timeout_s=5.0):
+                    raw_value = await self._extract_spoken_value(
+                        node_id, description, timeout_s=15.0
+                    )
             normalized = normalize_collect_value(
                 collect_type, raw_value, country_default=country_default
             )

{dv_pipecat_flows-0.0.22.dev1484 → dv_pipecat_flows-0.0.22.dev1487}/src/pipecat_flows/processors/user_turn_observer.py

@@ -33,11 +33,21 @@ from __future__ import annotations
 
 import asyncio
 import time
+from collections import deque
+from typing import List, Tuple
 
-from pipecat.frames.frames import UserStartedSpeakingFrame
+from pipecat.frames.frames import (
+    InterimTranscriptionFrame,
+    TranscriptionFrame,
+    UserStartedSpeakingFrame,
+)
 from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContextFrame
 from pipecat.observers.base_observer import BaseObserver, FramePushed
 
+# 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``.
@@ -69,6 +79,17 @@ class UserTurnObserver(BaseObserver):
         # resolver has to decide stash-vs-shortcircuit.
         self.last_user_started_ts: float = 0.0
         self._event: asyncio.Event = asyncio.Event()
+        # Non-lossy log of FINAL transcripts seen on the wire, as
+        # ``(monotonic_ts, text)``. The downstream context aggregator AND the
+        # transcript handler both DROP a turn when the caller re-speaks
+        # (interruption), which silently loses chunks of a multi-part dictation.
+        # The observer sees the raw ``TranscriptionFrame`` BEFORE any drop, so
+        # the Collect node reads its turns from here to never lose a chunk.
+        self._final_transcripts: List[Tuple[float, str]] = []
+        # ``on_push_frame`` fires once per pipeline HOP, so the same frame is seen
+        # many times as it flows downstream. Dedupe by frame id over a bounded
+        # recent window so a transcript is logged exactly once (not once per hop).
+        self._seen_frame_ids: deque = deque(maxlen=128)
 
     @property
     def event(self) -> asyncio.Event:
@@ -91,3 +112,27 @@ class UserTurnObserver(BaseObserver):
             # this purely as a barge-in detection signal for the interrupt
             # classifier dispatch (`manager._resolve_pure_code_target`).
             self.last_user_started_ts = time.monotonic()
+        elif isinstance(data.frame, TranscriptionFrame) and not isinstance(
+            data.frame, InterimTranscriptionFrame
+        ):
+            # FINAL transcript on the wire — record it BEFORE any downstream
+            # interruption-drop so a multi-chunk dictation never loses a chunk.
+            # Dedupe by frame id: on_push_frame fires once per hop, so the same
+            # frame arrives many times — log it only the first time.
+            frame_id = getattr(data.frame, "id", None)
+            if frame_id is not None and frame_id in self._seen_frame_ids:
+                return
+            if frame_id is not None:
+                self._seen_frame_ids.append(frame_id)
+            text = (getattr(data.frame, "text", "") or "").strip()
+            if text:
+                self._final_transcripts.append((time.monotonic(), text))
+                if len(self._final_transcripts) > _MAX_TRANSCRIPT_LOG:
+                    del self._final_transcripts[:-_MAX_TRANSCRIPT_LOG]
+
+    def transcripts_since(self, since_ts: float) -> List[str]:
+        """Texts of the FINAL transcripts seen strictly after ``since_ts``
+        (monotonic), in arrival order. Non-lossy: includes chunks the downstream
+        aggregator / transcript handler dropped on a re-speech interruption, so
+        the Collect node can re-extract the full number across all chunks."""
+        return [text for ts, text in self._final_transcripts if ts > since_ts]