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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.22.dev1487
+Version: 0.0.22.dev1491
 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.dev1487 → dv_pipecat_flows-0.0.22.dev1491}/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 normalize_collect_value
+from utils.collect_normalizers import is_repeat_request, normalize_collect_value
 from utils.collect_prompts import collect_prompt
 from pipecat.frames.frames import (
     DTMFUpdateSettingsFrame,
@@ -2149,6 +2149,8 @@ In all of these cases, you can provide a `name` in your new node's config for de
         system_prompt: Optional[str] = None,
         context_prefix: Optional[List[Dict[str, Any]]] = None,
         enum_values: Optional[List[str]] = None,
+        since_ts: Optional[float] = None,
+        with_reply: bool = False,
     ) -> Optional[str]:
         """Wait for the caller's spoken reply and extract a single value from it
         via a constrained LLM call — the same primitive the LLM router uses
@@ -2158,9 +2160,12 @@ In all of these cases, you can provide a `name` in your new node's config for de
         ``context_prefix`` lets a caller prepend grounding messages (e.g. the
         read-back question the confirm is about) ahead of the caller's latest
         turn, and ``system_prompt`` overrides the default extraction instruction.
+        ``since_ts`` reads a reply that ALREADY committed (e.g. the caller's
+        rejection of a read-back) instead of waiting for a new turn — pass it
+        with ``timeout_s=0`` to re-extract a correction from the denial.
         """
         observer = self._user_turn_observer
-        entry_ts = time.monotonic()
+        entry_ts = since_ts if since_ts is not None else time.monotonic()
         if observer is not None and timeout_s > 0:
             # 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
@@ -2186,7 +2191,24 @@ In all of these cases, you can provide a `name` in your new node's config for de
         value_spec: Dict[str, Any] = {"type": "string", "description": description}
         if enum_values:
             value_spec = {"type": "enum", "values": list(enum_values), "description": description}
-        schema = build_router_response_schema([], {"value": value_spec})
+        extract_spec: Dict[str, Any] = {"value": value_spec}
+        if with_reply:
+            # Same hybrid contract as the digit extractor: when the caller says
+            # something conversational instead of the value, the model answers it
+            # on-topic in `reply` (we speak that) and leaves `value` empty. The field
+            # description below is the instruction — the system prompt stays untouched.
+            self._collect_reply = ""
+            extract_spec["reply"] = {
+                "type": "string",
+                "description": (
+                    "Empty whenever the caller gave the value. ONLY when they gave no "
+                    "value and instead said something conversational (a question, a "
+                    "hesitation, an objection), a SHORT reply in their language that "
+                    "answers in ONE sentence and then asks again for it. Stay on topic; "
+                    "for anything unrelated give a one-line redirect; make no promises."
+                ),
+            }
+        schema = build_router_response_schema([], extract_spec)
 
         deadline = entry_ts + timeout_s if timeout_s > 0 else entry_ts
         last_value: Optional[str] = None
@@ -2244,6 +2266,9 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 value = (extracted or {}).get("value")
                 if isinstance(value, str) and value.strip():
                     last_value = value
+                if with_reply:
+                    reply_val = (extracted or {}).get("reply")
+                    self._collect_reply = reply_val.strip() if isinstance(reply_val, str) else ""
             # 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.
@@ -2362,6 +2387,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
     # can never trap the call in the node (the activity-aware wait below would
     # otherwise reset forever).
     _MAX_CAPTURE_SECONDS = 90.0
+    _MAX_COLLECT_REPLIES = 5  # conversational (non-digit) LLM replies before falling back
 
     def _caller_is_speaking(self) -> bool:
         """True while the caller has an IN-PROGRESS utterance — they started more
@@ -2410,6 +2436,8 @@ In all of these cases, you can provide a `name` in your new node's config for de
         Returns digits 0-9 only, or "" if no digits / on error (degrades to a
         re-ask).
         """
+        self._collect_readback = ""  # grouped, language-matched read-back for the confirm
+        self._collect_reply = ""  # LLM free reply for a conversational (non-digit) turn
         context_messages = [
             {"role": "user", "content": turn}
             for turn in turns
@@ -2422,39 +2450,67 @@ In all of these cases, you can provide a `name` in your new node's config for de
             llm_service = llm_service.active_llm
         schema = build_router_response_schema(
             [],
-            {"value": {
-                "type": "string",
-                "description": f"Every digit of the {what} the caller has said, concatenated in the order spoken, digits 0-9 only (e.g. 12345). No spaces or punctuation.",
-            }},
+            {
+                "value": {
+                    "type": "string",
+                    "description": (
+                        f"The {what} as digits 0-9 only, in the order spoken (no spaces or "
+                        "punctuation). Join each spoken number-word left to right — e.g. "
+                        "'double seven' → '77', 'nine two triple two' → 9,2,222 → '92222', "
+                        "'eight one three zero' → '8130'. Return an empty string if the "
+                        "caller has not given any digits yet (e.g. only said 'hello') — "
+                        "never invent or guess digits."
+                    ),
+                },
+                "readback": {
+                    "type": "string",
+                    "description": (
+                        "A read-back of `value` for confirmation, in the caller's language, "
+                        "with repeated digits grouped — e.g. 8555 → 'eight triple five', "
+                        "77 → 'double seven'. Empty when `value` is empty."
+                    ),
+                },
+                "reply": {
+                    "type": "string",
+                    "description": (
+                        "Empty whenever the caller gave digits. ONLY when they gave no "
+                        "digits and instead said something conversational (a question, a "
+                        "hesitation, an objection), a SHORT reply in their language that "
+                        "answers in ONE sentence and then asks again for the number. Stay "
+                        "on topic; for anything unrelated give a one-line redirect back to "
+                        "the number; make no promises or commitments."
+                    ),
+                },
+            },
         )
         try:
             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 "
-                    "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. 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."
+                    f"The caller is giving you a {what} — by voice in ANY language, or by "
+                    "keypad (a message like 'User inputted: 5') — possibly across several "
+                    "messages. Read everything they have said and return the final number "
+                    "in `value` and `readback`, or leave both empty if no digits have been "
+                    "given yet.\n"
+                    "If the caller instead said something conversational (a question, a "
+                    "hesitation, an objection) and gave NO digits, leave value/readback "
+                    "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"
+                    "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 "
+                    "digit next to a double/triple word stays separate.\n"
+                    "Corrections: if the caller fixes or restates any part — 'no, the "
+                    "first/last part is X', 'the start/beginning is X' (शुरू/स्टार्टिंग), "
+                    "'the end is X' (एंड/लास्ट), 'where I said Y it's Z', or they repeat the "
+                    "whole number — apply it and output the single final number, keeping "
+                    "the un-corrected digits unchanged. When the position is vague, find "
+                    "the run of digits being replaced and swap only that run. Examples: "
+                    "'70823 41303' then 'no, the first part is 807' → '8072341303'; then "
+                    "'एंड में 5 है' → '7082341305'; then 'where I said 41 it's 14' → "
+                    "'7082314303'."
                 ),
                 response_schema=schema,
                 context_messages=context_messages,
@@ -2467,6 +2523,10 @@ In all of these cases, you can provide a `name` in your new node's config for de
             return ""
         _branch, extracted = parse_router_response(raw, [UNCLEAR_BRANCH_ID])
         value = (extracted or {}).get("value")
+        readback = (extracted or {}).get("readback")
+        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 ""
         return re.sub(r"\D", "", value) if isinstance(value, str) else ""
 
     async def _reextract_if_corrected(
@@ -2580,20 +2640,17 @@ In all of these cases, you can provide a `name` in your new node's config for de
         # ignore the rejected attempt's turns.
         start_ts = time.monotonic()
         buffer = ""
+        echoed = ""  # bare digits already spoken back, so we echo only the NEW ones
         misses = 0
+        replies = 0  # conversational (non-digit) replies, bounded so chatter can't loop
         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."""
-            if buffer:
-                remaining = max(0, target - len(buffer))
-                unit = collect_prompt(language, "unit_one" if remaining == 1 else "unit_many")
-                await self._task.queue_frame(TTSSpeakFrame(text=collect_prompt(
-                    language, "continue_partial", readback=" ".join(buffer),
-                    remaining=remaining, unit=unit,
-                )))
-            elif reask:
+            """Re-prompt ONLY when we have nothing yet (the author's reask). Holding a
+            partial → stay silent: the progress echo already spoke the digits, so
+            re-speaking them just sounds like a repeat (and talks over the caller)."""
+            if not buffer and reask:
                 await self._task.queue_frame(TTSSpeakFrame(text=reask))
 
         while misses < max_attempts:
@@ -2601,7 +2658,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # 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
+                7.0 if buffer else 15.0, deadline, allow_keypad, keypad_dtmf
             )
             if not got_turn:
                 if time.monotonic() >= deadline:
@@ -2635,7 +2692,9 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 # 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))
+                    confirmed = await self._confirm_collected(
+                        node_id, getattr(self, "_collect_readback", "") or " ".join(buffer)
+                    )
                     if confirmed is True:
                         return normalized
                     corrections += 1
@@ -2661,6 +2720,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 # Enough digits but not a valid number → reset and re-ask.
                 start_ts = time.monotonic()
                 buffer = ""
+                echoed = ""
                 misses += 1
                 if misses < max_attempts:
                     await self._task.queue_frame(
@@ -2668,17 +2728,49 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     )
                 continue
 
-            if len(buffer) == len(previous):
-                # A turn arrived but added no new digits (filler / mis-hear) →
-                # re-ask and count a miss so garbage can't loop forever.
+            if buffer == previous:
+                # A turn arrived but the number is UNCHANGED (filler / mis-hear / a
+                # request to repeat). If the caller asked to hear it back, RE-READ the
+                # digits-so-far (no miss); otherwise re-ask and count a miss so garbage
+                # can't loop forever. Compare by VALUE, not length: a same-length
+                # 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]):
+                    # 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).
+                    if time.monotonic() >= deadline:
+                        break
+                    await self._task.queue_frame(TTSSpeakFrame(
+                        text=collect_prompt(language, "echo", digits=" ".join(buffer))
+                    ))
+                    continue
+                reply = getattr(self, "_collect_reply", "")
+                if reply and replies < self._MAX_COLLECT_REPLIES and time.monotonic() < deadline:
+                    # The caller said something other than digits (a question / objection).
+                    # Speak the LLM's on-topic reply (it answers AND steers back to the
+                    # number) instead of the robotic nudge. Bounded + deadline-capped so it
+                    # can't crowd out give-up; a repeat request was already handled above.
+                    replies += 1
+                    await self._task.queue_frame(TTSSpeakFrame(text=reply))
+                    continue
                 misses += 1
                 if misses < max_attempts:
                     await _nudge(language)
                 continue
 
-            # 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.
+            # Buffer CHANGED (progress — new digits OR a correction) → echo it back
+            # (bare, in the caller's language) so they hear we caught the change, and
+            # reset the give-up counter. A clean append echoes only the NEW digits; a
+            # correction (not a prefix of what we echoed) re-echoes the full number.
+            delta = buffer[len(echoed):] if buffer.startswith(echoed) else buffer
+            if delta:
+                await self._task.queue_frame(TTSSpeakFrame(
+                    text=collect_prompt(language, "echo", digits=" ".join(delta))
+                ))
+            echoed = buffer
             misses = 0
 
         logger.info(f"Collect '{node_id}': gave up after {misses} misses (buffer='{buffer}')")
@@ -2707,27 +2799,24 @@ In all of these cases, you can provide a `name` in your new node's config for de
         target = int(num_digits) if num_digits else 6
         start_ts = time.monotonic()
         buffer = ""
+        echoed = ""  # bare digits already spoken back, so we echo only the NEW ones
         misses = 0
+        replies = 0  # conversational (non-digit) replies, bounded so chatter can't loop
         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}
 
         async def _nudge(language: str) -> None:
-            if buffer:
-                remaining = max(0, target - len(buffer))
-                unit = collect_prompt(language, "unit_one" if remaining == 1 else "unit_many")
-                await self._task.queue_frame(TTSSpeakFrame(text=collect_prompt(
-                    language, "continue_partial", readback=" ".join(buffer),
-                    remaining=remaining, unit=unit,
-                )))
-            elif reask:
+            """Re-prompt ONLY when we have nothing yet (the author's reask); holding a
+            partial → stay silent (the progress echo already spoke the digits)."""
+            if not buffer and reask:
                 await self._task.queue_frame(TTSSpeakFrame(text=reask))
 
         while misses < max_attempts:
             language = self._active_language()
             got_turn = await self._wait_for_caller_input(
-                5.0 if buffer else 15.0, deadline, allow_keypad, code_dtmf
+                7.0 if buffer else 15.0, deadline, allow_keypad, code_dtmf
             )
             if not got_turn:
                 if time.monotonic() >= deadline:
@@ -2754,7 +2843,9 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 # 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))
+                    confirmed = await self._confirm_collected(
+                        node_id, getattr(self, "_collect_readback", "") or " ".join(normalized)
+                    )
                     if confirmed is True:
                         return normalized
                     corrections += 1
@@ -2780,6 +2871,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 # Too many digits for this code → reset and re-ask.
                 start_ts = time.monotonic()
                 buffer = ""
+                echoed = ""
                 misses += 1
                 if misses < max_attempts:
                     await self._task.queue_frame(
@@ -2787,14 +2879,45 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     )
                 continue
 
-            if len(buffer) == len(previous):
-                # A turn arrived but added no new digits → re-ask, count a miss.
+            if buffer == previous:
+                # Unchanged (filler / mis-hear / a request to repeat). If the caller
+                # 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]):
+                    # 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).
+                    if time.monotonic() >= deadline:
+                        break
+                    await self._task.queue_frame(TTSSpeakFrame(
+                        text=collect_prompt(language, "echo", digits=" ".join(buffer))
+                    ))
+                    continue
+                reply = getattr(self, "_collect_reply", "")
+                if reply and replies < self._MAX_COLLECT_REPLIES and time.monotonic() < deadline:
+                    # The caller said something other than digits (a question / objection).
+                    # Speak the LLM's on-topic reply (it answers AND steers back to the
+                    # number) instead of the robotic nudge. Bounded + deadline-capped so it
+                    # can't crowd out give-up; a repeat request was already handled above.
+                    replies += 1
+                    await self._task.queue_frame(TTSSpeakFrame(text=reply))
+                    continue
                 misses += 1
                 if misses < max_attempts:
                     await _nudge(language)
                 continue
 
-            # Buffer GREW (progress) → reset the give-up counter; keep listening.
+            # Buffer CHANGED (new digits OR a correction) → echo it back, bare, and
+            # reset the give-up counter. Append → only the new digits; a correction →
+            # the full code re-echoed.
+            delta = buffer[len(echoed):] if buffer.startswith(echoed) else buffer
+            if delta:
+                await self._task.queue_frame(TTSSpeakFrame(
+                    text=collect_prompt(language, "echo", digits=" ".join(delta))
+                ))
+            echoed = buffer
             misses = 0
 
         logger.info(f"Collect '{node_id}': code give-up after {misses} misses (buffer='{buffer}')")
@@ -2810,7 +2933,9 @@ In all of these cases, you can provide a `name` in your new node's config for de
         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)):
+        repeats = 0
+        asked = 0
+        while asked < max(1, attempts):
             listen_ts = time.monotonic()
             await self._task.queue_frame(
                 TTSSpeakFrame(text=collect_prompt(self._active_language(), "confirm", readback=readback))
@@ -2847,7 +2972,16 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 if observer is not None and hasattr(observer, "transcripts_since")
                 else ""
             )
-            if any(ch.isdigit() for ch in reply):
+            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()
             if text.startswith("yes"):
@@ -2855,6 +2989,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
             if text.startswith("no"):
                 return False
             # null / unclear → re-ask "is that correct?" (next loop iteration)
+            asked += 1
         return None
 
     async def _collect_single_value(
@@ -2874,9 +3009,11 @@ In all of these cases, you can provide a `name` in your new node's config for de
         description = {
             "email": "the email address the caller said, as a standard address (e.g. john.smith@gmail.com)",
         }.get(collect_type, "the value the caller said")
-        for attempt in range(max_attempts):
+        attempt = 0
+        replies = 0
+        while attempt < max_attempts:
             raw_value = await self._extract_spoken_value(
-                node_id, description, timeout_s=15.0
+                node_id, description, timeout_s=15.0, with_reply=True
             )
             if not raw_value and allow_keypad:
                 capture_timeout = float(keypad_dtmf.get("timeout", 8.0)) + 10.0
@@ -2886,27 +3023,53 @@ In all of these cases, you can provide a `name` in your new node's config for de
             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
+                        node_id, description, timeout_s=15.0, with_reply=True
                     )
             normalized = normalize_collect_value(
                 collect_type, raw_value, country_default=country_default
             )
             if normalized:
-                # Read the value back and confirm before storing (phone-parity).
-                confirmed = await self._confirm_collected(node_id, normalized)
-                if confirmed is True:
-                    return normalized
-                # Denied / unclear → re-ask on the next attempt.
-                if confirmed is False and attempt < max_attempts - 1:
-                    await self._task.queue_frame(
-                        TTSSpeakFrame(text=collect_prompt(self._active_language(), "restart_denied"))
+                # Read the value back and confirm before storing (phone-parity). On a
+                # denial, re-extract from the rejection reply itself ("no, it's
+                # jane@gmail.com") and re-confirm the fix directly, instead of making
+                # the caller repeat the whole address. A plain "no" with no new value
+                # falls through to "what should it be?" and the next attempt.
+                while True:
+                    confirm_ts = time.monotonic()
+                    confirmed = await self._confirm_collected(node_id, normalized)
+                    if confirmed is True:
+                        return normalized
+                    corrected = normalize_collect_value(
+                        collect_type,
+                        await self._extract_spoken_value(
+                            node_id, description, timeout_s=0.0, since_ts=confirm_ts
+                        ),
+                        country_default=country_default,
                     )
+                    if corrected and corrected != normalized:
+                        normalized = corrected
+                        continue  # re-read the corrected value for confirmation
+                    if attempt < max_attempts - 1:
+                        await self._task.queue_frame(
+                            TTSSpeakFrame(text=collect_prompt(self._active_language(), "restart_denied"))
+                        )
+                    break
+                attempt += 1
+                continue
+            # No valid value. If the caller said something conversational instead, speak
+            # the LLM's on-topic reply (it answers AND steers back) WITHOUT burning an
+            # attempt (bounded). Otherwise count the attempt and re-ask.
+            reply = getattr(self, "_collect_reply", "")
+            if reply and replies < self._MAX_COLLECT_REPLIES:
+                replies += 1
+                await self._task.queue_frame(TTSSpeakFrame(text=reply))
                 continue
+            attempt += 1
             logger.info(
                 f"Collect '{node_id}': no valid {collect_type} "
-                f"(attempt {attempt + 1}/{max_attempts})"
+                f"(attempt {attempt}/{max_attempts})"
             )
-            if reask and attempt < max_attempts - 1:
+            if reask and attempt < max_attempts:
                 await self._task.queue_frame(TTSSpeakFrame(text=reask))
         return None