dv-pipecat-flows 0.0.0.dev2093__tar.gz → 0.0.0.dev2098__tar.gz

{dv_pipecat_flows-0.0.0.dev2093/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.0.dev2098}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-flows
-Version: 0.0.0.dev2093
+Version: 0.0.0.dev2098
 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.dev2093 → dv_pipecat_flows-0.0.0.dev2098}/src/pipecat_flows/manager.py

@@ -78,6 +78,7 @@ from pipecat_flows.exceptions import (
     RouterProviderError,
 )
 from pipecat_flows.router_mode import (
+    BACK_BRANCH_ID,
     REPROMPT_IN_PLACE,
     UNCLEAR_BRANCH_ID,
     build_router_response_schema,
@@ -218,6 +219,12 @@ class FlowManager:
         # backwards-compatible if a downstream installs an older engine.
         self._user_turn_observer: Optional[Any] = None
 
+        self._current_node_entered_ts: float = 0.0
+        self._previous_node_entered_ts: float = 0.0
+
+        self._current_llm_router_name: Optional[str] = None
+        self._previous_llm_router_name: Optional[str] = None
+
         # Set up static or dynamic mode
         if flow_config:
             warnings.warn(
@@ -967,6 +974,24 @@ In all of these cases, you can provide a `name` in your new node's config for de
 
         # Case 1: bare string (Speak / single-target Action).
         if isinstance(auto_transition, str):
+            if node_config.get("interruptible", False):
+                observer = self._user_turn_observer
+                user_barged_in = (
+                    observer is not None
+                    and observer.last_user_stopped_ts
+                    >= self._current_node_entered_ts
+                )
+                if user_barged_in and self._current_llm_router_name:
+                    next_cfg = self._nodes.get(auto_transition) or {}
+                    if next_cfg.get("llm_mode") != "router":
+                        logger.info(
+                            f"Interruptible Speak '{node_config.get('name')}': "
+                            f"caller barged in; natural-next "
+                            f"'{auto_transition}' is not a Router; routing "
+                            f"to most-recent Router "
+                            f"'{self._current_llm_router_name}' instead"
+                        )
+                        return self._current_llm_router_name
             return auto_transition
 
         return None
@@ -1001,7 +1026,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # and drops the OpenAILLMContextFrame upstream of the main LLM.
             current_cfg = self._nodes.get(self._current_node) or {}
             needs_deferred_flush = False
-            if current_cfg.get("uninterruptible"):
+            if not current_cfg.get("interruptible", False):
                 needs_deferred_flush = await self._exit_speak_guard(
                     current_cfg, target
                 )
@@ -1030,15 +1055,15 @@ In all of these cases, you can provide a `name` in your new node's config for de
         node_config = self._nodes.get(self._current_node) or {}
         return bool(node_config.get("suppress_llm_text"))
 
-    def is_speak_uninterruptible(self) -> bool:
-        """True when the current node has ``uninterruptible`` set, so
-        :class:`pipecat_flows.processors.SpeakInterruptionGuard` swallows the
-        interruption cascade and the bot's scripted line lands intact.
+    def is_speak_interruptible(self) -> bool:
+        """True when the current node has ``interruptible`` set, so
+        :class:`pipecat_flows.processors.SpeakInterruptionGuard` lets the
+        interruption cascade through and the caller can barge in.
         """
         if not getattr(self, "_current_node", None):
             return False
         node_config = self._nodes.get(self._current_node) or {}
-        return bool(node_config.get("uninterruptible"))
+        return bool(node_config.get("interruptible", False))
 
     async def _enter_speak_guard(self, node_config: Dict[str, Any]) -> None:
         """Reset the user aggregator's recency timers so the
@@ -1141,8 +1166,9 @@ 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.
-        timeout_s = float(node_config.get("router_wait_for_user_timeout", 15.0))
         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:
             entry_ts = time.monotonic()
             if observer.last_user_stopped_ts >= entry_ts:
@@ -1206,6 +1232,40 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 f"lowerer fills it"
             )
 
+        back_routing_enabled = (
+            self._previous_llm_router_name is not None
+            and self._previous_llm_router_name != node_id
+        )
+        if back_routing_enabled:
+            prev_cfg = self._nodes.get(self._previous_llm_router_name) or {}
+            prev_descriptions = prev_cfg.get("router_branch_descriptions") or {}
+            prev_desc_block = "\n".join(
+                f"  - {bid}: {desc}" for bid, desc in prev_descriptions.items()
+            ) or "  (previous router branches unavailable)"
+            branches = list(branches) + [
+                {"id": BACK_BRANCH_ID, "next": self._previous_llm_router_name}
+            ]
+            system_prompt = (
+                system_prompt
+                + "\n\n## Re-routing to previous Router\n"
+                + f"In addition to your branches above, you may pick "
+                + f"`{BACK_BRANCH_ID}` if the caller's reply is clearly NOT "
+                + f"answering this Router's question and instead contradicts "
+                + f"or changes the prior intent. The previous Router "
+                + f"(`{self._previous_llm_router_name}`) can re-classify into:\n"
+                + prev_desc_block
+                + "\n\nOnly pick this when the caller's reply belongs at the "
+                + "previous decision level — otherwise prefer your own branches."
+            )
+
+        # Log the FULL router system prompt actually being used at runtime, so we
+        # can confirm what the classifier sees (branches/extract/reasoning) rather
+        # than just the sha1 hash logged after the pick below.
+        logger.info(
+            f"Router '{node_id}' system prompt ({len(system_prompt)} chars):\n"
+            f"{system_prompt}"
+        )
+
         schema = build_router_response_schema(branches, extract)
         valid_branch_ids = [b["id"] for b in branches if isinstance(b, dict) and b.get("id")]
         valid_branch_ids.append(UNCLEAR_BRANCH_ID)
@@ -1350,6 +1410,16 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     f"router_unclear observer failed for {node_id}: {observer_exc!r}"
                 )
 
+        if back_routing_enabled and branch_id == BACK_BRANCH_ID:
+            back_msg = node_config.get("router_back_transition_message") or ""
+            if back_msg:
+                await self._task.queue_frame(TTSSpeakFrame(text=back_msg))
+            logger.info(
+                f"Router '{node_id}' picked back-branch -> "
+                f"{self._previous_llm_router_name} (msg={back_msg!r})"
+            )
+            return self._previous_llm_router_name
+
         target = pick_branch_target(
             branch_id=branch_id,
             node_config=node_config,
@@ -1541,6 +1611,13 @@ In all of these cases, you can provide a `name` in your new node's config for de
         if not self._initialized:
             raise FlowTransitionError(f"{self.__class__.__name__} must be initialized first")
 
+        self._previous_node_entered_ts = self._current_node_entered_ts
+        self._current_node_entered_ts = time.monotonic()
+
+        if node_config.get("llm_mode") == "router":
+            self._previous_llm_router_name = self._current_llm_router_name
+            self._current_llm_router_name = node_id
+
         # Tool-log every transition so operators see the graph traversal on
         # the same timeline as on-call API tool calls. Capture state BEFORE
         # any of the node-setup logic runs so previous_node_id reflects the
@@ -1584,7 +1661,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # Latch the guard's reactive flag (read off ``_current_node``)
             # BEFORE pre_actions execute, so the Speak's tts_say plays under
             # protection. Reset the aggregator's recency timers in lockstep.
-            if node_config.get("uninterruptible"):
+            if not node_config.get("interruptible", False):
                 self._current_node = node_id
                 await self._enter_speak_guard(node_config)
 
@@ -1873,7 +1950,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # still latched on ``_current_node`` — clear it so the pipeline
             # doesn't strand with every cancel signal being eaten.
             try:
-                if node_config.get("uninterruptible") and self._current_node == node_id:
+                if not node_config.get("interruptible", False) and self._current_node == node_id:
                     self._current_node = None
             except Exception:
                 pass

{dv_pipecat_flows-0.0.0.dev2093 → dv_pipecat_flows-0.0.0.dev2098}/src/pipecat_flows/processors/speak_interruption_guard.py

@@ -4,13 +4,13 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
-"""Swallows interruption-cascade frames while the current node is uninterruptible.
+"""Swallows interruption-cascade frames while the current node is non-interruptible.
 
 Speak / Action / Transfer / End nodes play scripted TTS that must land in full.
 The pipeline-wide ``InterruptionFrame`` cascade (cancel-task and flush the
 output audio queue in ``MediaSender``) would truncate them — so this processor
 drops the cancel signal in both directions when the FlowManager reports
-``is_speak_uninterruptible()``.
+``is_speak_interruptible()`` is False.
 
 User transcripts still pass through, so they accumulate in
 ``LLMUserContextAggregator._aggregation`` and the FlowManager flushes (or
@@ -49,35 +49,35 @@ _UPSTREAM_DROP_TYPES: Tuple[Type[Frame], ...] = (InterruptionTaskFrame,)
 
 
 class SpeakInterruptionGuard(FrameProcessor):
-    """Drops interruption-cascade frames while ``is_uninterruptible_fn()`` returns True.
+    """Drops interruption-cascade frames while ``is_interruptible_fn()`` returns False.
 
     Same holder-callback pattern as :class:`RouterModeGuard` so the manager can
     flip state via ``_current_node`` without the processor importing
     FlowManager directly.
     """
 
-    def __init__(self, is_uninterruptible_fn: Callable[[], bool], **kwargs) -> None:
+    def __init__(self, is_interruptible_fn: Callable[[], bool], **kwargs) -> None:
         super().__init__(**kwargs)
-        self._is_uninterruptible_fn = is_uninterruptible_fn
+        self._is_interruptible_fn = is_interruptible_fn
 
     async def process_frame(self, frame: Frame, direction: FrameDirection) -> None:
         await super().process_frame(frame, direction)
 
-        if not self._is_uninterruptible_fn():
+        if self._is_interruptible_fn():
             await self.push_frame(frame, direction)
             return
 
         if direction == FrameDirection.DOWNSTREAM and isinstance(frame, _DOWNSTREAM_DROP_TYPES):
             logger.debug(
                 f"SpeakInterruptionGuard dropping {type(frame).__name__} downstream "
-                f"during uninterruptible node"
+                f"during non-interruptible node"
             )
             return
 
         if direction == FrameDirection.UPSTREAM and isinstance(frame, _UPSTREAM_DROP_TYPES):
             logger.debug(
                 f"SpeakInterruptionGuard dropping {type(frame).__name__} upstream "
-                f"during uninterruptible node"
+                f"during non-interruptible node"
             )
             return
 

{dv_pipecat_flows-0.0.0.dev2093 → dv_pipecat_flows-0.0.0.dev2098}/src/pipecat_flows/router_mode.py

@@ -44,6 +44,11 @@ logger = logging.getLogger(__name__)
 # Sentinel returned by the LLM when none of the explicit branches match.
 UNCLEAR_BRANCH_ID = "__unclear__"
 
+# Synthetic branch ID injected at runtime when a Router has an upstream LLM
+# Router available, letting the classifier pick "re-route to previous Router"
+# without the author wiring an explicit edge.
+BACK_BRANCH_ID = "__back_to_previous_router__"
+
 # JSON Schema scalar type translation for ExtractSpec.type values.
 _EXTRACT_TYPE_TO_JSONSCHEMA = {
     "string": "string",

{dv_pipecat_flows-0.0.0.dev2093 → dv_pipecat_flows-0.0.0.dev2098}/src/pipecat_flows/types.py

@@ -573,6 +573,10 @@ class NodeConfig(NodeConfigRequired, total=False):
     router_exhausted_node: str
     """Target when ``router_max_unclear`` is exceeded. Typically Transfer or End."""
 
+    skip_wait_if_silent: bool
+    """If true and no user transcript has landed since this node was entered,
+    skip the wait + classifier call and route via ``router_unclear_node``."""
+
     # Router-Condition (consumed when auto_transition is the sentinel
     # ``"__condition__"`` AND ``conditions`` is set)
     conditions: List[Condition]