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

{dv_pipecat_flows-0.0.0.dev2087/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.dev2087
+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.dev2087 → 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.dev2087
+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.dev2087 → dv_pipecat_flows-0.0.0.dev2098}/src/dv_pipecat_flows.egg-info/SOURCES.txt

@@ -101,7 +101,6 @@ src/pipecat_flows/__init__.py
 src/pipecat_flows/actions.py
 src/pipecat_flows/adapters.py
 src/pipecat_flows/condition_evaluator.py
-src/pipecat_flows/data_extractor.py
 src/pipecat_flows/exceptions.py
 src/pipecat_flows/flow_validator.py
 src/pipecat_flows/manager.py

{dv_pipecat_flows-0.0.0.dev2087 → dv_pipecat_flows-0.0.0.dev2098}/src/pipecat_flows/adapters.py

@@ -176,9 +176,9 @@ class LLMAdapter:
 
         Args:
             llm_service: The underlying LLM service (exposes ``_client`` +
-                ``_model``, same convention as ``DataExtractor`` uses).
-            system_prompt: System message text (built by
-                :func:`render_router_system_prompt`).
+                ``_model``).
+            system_prompt: System message text (authored by the backend
+                lowerer and shipped via ``task_messages[0].content``).
             response_schema: JSON Schema constraining the output (built by
                 :func:`build_router_response_schema`).
             context_messages: Recent conversation turns to include as user
@@ -374,8 +374,7 @@ class OpenAIAdapter(LLMAdapter):
         """OpenAI / Azure constrained completion via ``response_format``
         ``json_schema``. Returns the raw JSON string emitted by the model.
 
-        Mirrors the direct-client pattern already used by ``DataExtractor``:
-        accesses ``llm_service._client`` and ``llm_service._model``, makes a
+        Accesses ``llm_service._client`` and ``llm_service._model``, makes a
         one-shot ``chat.completions.create`` outside the streaming pipeline.
 
         Uses ``strict: True`` so OpenAI enforces the schema server-side

{dv_pipecat_flows-0.0.0.dev2087 → dv_pipecat_flows-0.0.0.dev2098}/src/pipecat_flows/manager.py

@@ -68,7 +68,6 @@ from pipecat.transports.base_transport import BaseTransport
 from pipecat_flows.actions import ActionError, ActionManager
 from pipecat_flows.adapters import create_adapter
 from pipecat_flows.condition_evaluator import evaluate_conditions
-from pipecat_flows.data_extractor import DataExtractor
 from pipecat_flows.exceptions import (
     AutoTransitionDepthError,
     FlowError,
@@ -79,12 +78,12 @@ 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,
     parse_router_response,
     pick_branch_target,
-    render_router_system_prompt,
 )
 from pipecat_flows.types import (
     ActionConfig,
@@ -175,8 +174,12 @@ class FlowManager:
         self._llm = llm
         self._action_manager = ActionManager(task, flow_manager=self)
         self._adapter = create_adapter(llm, context_aggregator)
-        self._data_extractor = DataExtractor()
         self._initialized = False
+        # Stashed by _run_router_node right after the LLM picks a branch and
+        # read by _set_node when it tool-logs the transition. Lets the router
+        # rationale + prompt_sha1 land in the transition tool-log args. Cleared
+        # by _set_node after read so it can't leak into an unrelated next hop.
+        self._last_router_pick: Optional[Dict[str, Any]] = None
         self._context_aggregator = context_aggregator
         self._pending_transition: Optional[Dict[str, Any]] = None
         self._pending_function_results: Dict[str, Dict[str, Any]] = {}  # Store function results for extraction
@@ -216,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(
@@ -912,69 +921,6 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 )
         await self._set_node(node_id, node_config)
 
-    async def _process_data_extraction(self, node_id: str, node_config: NodeConfig) -> None:
-        """Process data extraction for the current node.
-
-        Args:
-            node_id: The current node ID
-            node_config: The node configuration containing extraction settings
-        """
-        # Get extraction config from runtime config or node config
-        runtime_config = self.state.get("nodes_runtime_config", {})
-        node_runtime = runtime_config.get(node_id, {})
-        extraction_config = node_runtime.get("data_extraction", [])
-
-        # Also check node_config directly if not in runtime
-        if not extraction_config and "data_extraction" in node_config:
-            extraction_config = node_config["data_extraction"]
-            # Convert to dict format if needed
-            if extraction_config and hasattr(extraction_config[0], "model_dump"):
-                extraction_config = [field.model_dump() for field in extraction_config]
-
-        if not extraction_config:
-            return
-
-        logger.debug(f"Processing data extraction for node {node_id}: {len(extraction_config)} fields")
-
-        try:
-            # Get conversation context for conversation-type extractions
-            conversation_context = None
-            has_conversation_fields = any(
-                f.get("extraction_type") == "conversation" for f in extraction_config
-            )
-            if has_conversation_fields:
-                try:
-                    conversation_context = self.get_current_context()
-                except Exception as e:
-                    logger.warning(f"Could not get conversation context for extraction: {e}")
-
-            # Process all extractions
-            extracted_data = await self._data_extractor.process_node_extractions(
-                node_name=node_id,
-                extraction_config=extraction_config,
-                function_results=self._pending_function_results.copy() if self._pending_function_results else None,
-                conversation_context=conversation_context,
-                llm_service=self._llm if has_conversation_fields else None,
-            )
-
-            # Store extracted data in state
-            if extracted_data:
-                if "extracted_data" not in self.state:
-                    self.state["extracted_data"] = {}
-                if node_id not in self.state["extracted_data"]:
-                    self.state["extracted_data"][node_id] = {}
-
-                self.state["extracted_data"][node_id].update(extracted_data)
-                logger.info(f"Stored {len(extracted_data)} extracted fields for node {node_id}")
-
-            # Clear pending function results after extraction
-            self._pending_function_results.clear()
-
-        except Exception as e:
-            logger.error(f"Error during data extraction for node {node_id}: {e}")
-            # Clear pending results even on error
-            self._pending_function_results.clear()
-
     # ------------------------------------------------------------------
     # Pure-code dispatch primitives (auto_transition + condition_evaluator).
     # Used by Speak / Action / Condition-Router to skip the LLM round-trip.
@@ -1028,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
@@ -1062,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
                 )
@@ -1091,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
@@ -1144,11 +1108,11 @@ In all of these cases, you can provide a `name` in your new node's config for de
         if not self._context_aggregator or target_node_config is None:
             return False
         target_kind = target_node_config.get("type")
-        if target_kind in ("speak", "action"):
+        if target_kind in ("speak_node", "action_node"):
             return False
         is_terminal = bool(target_node_config.get("terminal")) or target_kind in (
             "end_node",
-            "transfer",
+            "transfer_node",
         )
         is_cond_router = target_node_config.get("auto_transition") == "__condition__"
         user_agg = self._context_aggregator.user()
@@ -1202,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:
@@ -1250,24 +1215,58 @@ In all of these cases, you can provide a `name` in your new node's config for de
 
         branches = node_config.get("router_branches") or []
         extract = node_config.get("router_extract") or {}
-        branch_descriptions = node_config.get("router_branch_descriptions") or {}
 
-        # Temporary diagnostic — answers "did router_branch_descriptions
-        # actually reach the engine, or is the lowerer/pydantic layer still
-        # silently dropping it?" Remove after verifying.
-        logger.debug(
-            f"Router '{node_id}' descriptions present={bool(branch_descriptions)} "
-            f"keys={list(branch_descriptions.keys())} "
-            f"sample={next(iter(branch_descriptions.items()), None)}"
+        # Backend lowerer is the single source of truth for the router prompt.
+        # It writes the rendered prompt into task_messages[0].content at publish
+        # time; we read it verbatim here. No runtime re-rendering — keeps prompt
+        # authoring in the backend repo and avoids drift between lowering-time
+        # and runtime prompts.
+        tm = node_config.get("task_messages") or []
+        system_prompt = (
+            tm[0].get("content", "") if tm and isinstance(tm[0], dict) else ""
         )
+        if not system_prompt:
+            raise RouterParseError(
+                f"router node '{node_id}' has no rendered system prompt in "
+                f"task_messages[0].content — re-publish the agent so the "
+                f"lowerer fills it"
+            )
 
-        schema = build_router_response_schema(branches, extract)
-        system_prompt = render_router_system_prompt(
-            branches, extract, branch_descriptions
+        back_routing_enabled = (
+            self._previous_llm_router_name is not None
+            and self._previous_llm_router_name != node_id
         )
-        logger.debug(
-            f"Router '{node_id}' rendered system_prompt ({len(system_prompt)} chars):\n{system_prompt}"
+        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)
 
@@ -1340,6 +1339,13 @@ In all of these cases, you can provide a `name` in your new node's config for de
             f"Router '{node_id}' picked branch_id='{branch_id}' "
             f"rationale={rationale!r} prompt_sha1={prompt_hash}"
         )
+        # Hand off to the next _set_node so it can surface this in the
+        # transition tool-log args. Cleared by _set_node after read.
+        self._last_router_pick = {
+            "branch_id": branch_id,
+            "rationale": rationale,
+            "prompt_sha1": prompt_hash,
+        }
 
         # Write extracted variables into shared state so downstream nodes
         # (Condition routers, Speak template substitutions) can read them.
@@ -1404,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,
@@ -1595,6 +1611,39 @@ 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
+        # actual outgoing node (legacy path resets _current_node only at L1796
+        # of the success arm; v2 paths early-latch at L1546).
+        transition_start_time = time.time()
+        previous_node_id = self._current_node
+        router_pick = self._last_router_pick
+        self._last_router_pick = None
+        transition_tool_name = f"transition_to_{node_id}"
+        transition_args: Dict[str, Any] = {
+            "from_node_id": previous_node_id,
+            "to_node_id": node_id,
+        }
+        if router_pick:
+            transition_args.update(router_pick)
+        transition_call_id = await start_tracking(
+            transcript_handler=getattr(self, "_transcript_handler", None),
+            tool_name=transition_tool_name,
+            args=transition_args,
+            tool_phase="on_call",
+            tool_type="transition",
+            current_node=previous_node_id,
+            logger=logger,
+        )
+
         try:
             # Clear any pending transition state when starting a new node
             # This ensures clean state regardless of how we arrived here:
@@ -1612,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)
 
@@ -1715,9 +1764,6 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # Apply node-level overrides if any
             await self._apply_node_overrides(node_id)
 
-            # Process data extraction for the node (function results from previous node)
-            await self._process_data_extraction(node_id, node_config)
-
             # Pure-code short-circuit: if this node is a Speak / Action /
             # Condition-Router (has `auto_transition`), skip tools+context+
             # LLMRunFrame entirely and recurse directly into the target node.
@@ -1886,16 +1932,42 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # node_entered observer is now emitted at the *top* of _set_node
             # so short-circuit paths (auto_transition / router-mode) get it too.
 
+            await complete_tracking(
+                transcript_handler=getattr(self, "_transcript_handler", None),
+                function_call_id=transition_call_id,
+                tool_name=transition_tool_name,
+                function_start_time=transition_start_time,
+                response_data={
+                    "to_node_id": node_id,
+                    "to_node_label": node_config.get("label"),
+                },
+                status_code=200,
+                logger=logger,
+            )
+
         except Exception as e:
             # If setup crashed inside an uninterruptible node, the guard is
             # 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
             logger.error(f"Error setting node {node_id}: {str(e)}")
+            try:
+                await complete_tracking(
+                    transcript_handler=getattr(self, "_transcript_handler", None),
+                    function_call_id=transition_call_id,
+                    tool_name=transition_tool_name,
+                    function_start_time=transition_start_time,
+                    response_data=None,
+                    status_code=500,
+                    error_details={"error": str(e), "type": type(e).__name__},
+                    logger=logger,
+                )
+            except Exception as track_exc:
+                logger.warning(f"complete_tracking failed for {transition_tool_name}: {track_exc!r}")
             raise FlowError(f"Failed to set node {node_id}: {str(e)}") from e
 
     def _schedule_deferred_post_actions(self, post_actions: List[ActionConfig]) -> None:

{dv_pipecat_flows-0.0.0.dev2087 → 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.dev2087 → dv_pipecat_flows-0.0.0.dev2098}/src/pipecat_flows/router_mode.py

@@ -16,12 +16,15 @@ writes extracted variables into ``flow_manager.state``, and recurses into
 
 This module is the pure data-shaping layer:
     * :func:`build_router_response_schema` — JSON Schema for the constrained call
-    * :func:`render_router_system_prompt` — system message text for the call
     * :func:`parse_router_response` — extracts ``{branch, extracted}`` from a
       provider response (string/dict/tool-call), with defensive fallbacks
     * :func:`pick_branch_target` — resolves the parsed branch_id to a target
       node name (and handles the unclear sentinel + attempt counter)
 
+The router system prompt itself is authored by the backend lowerer
+(``new_calling_agent_backend/agent/commons/flow_lowering.py``) and shipped
+verbatim in ``task_messages[0].content``; the engine reads it directly.
+
 The actual LLM call orchestration lives in ``manager.py:_run_router_node`` —
 this module provides the helpers it composes.
 """
@@ -41,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",
@@ -135,90 +143,6 @@ def build_router_response_schema(
     }
 
 
-def render_router_system_prompt(
-    branches: List[RouterBranch],
-    extract: Optional[Dict[str, ExtractSpec]] = None,
-    branch_descriptions: Optional[Dict[str, str]] = None,
-) -> str:
-    """Build the router's system message.
-
-    Kept short on purpose — every token here is paid on every router call (or
-    cached, if prompt-caching is wired). Lists each branch with its description
-    so the LLM knows when to pick which; appends the extract-vars block when
-    the node asks for any.
-
-    Args:
-        branches: NodeConfig ``router_branches`` list (carries id + next).
-        extract: NodeConfig ``router_extract`` map.
-        branch_descriptions: Optional override map ``{branch_id: description}``.
-            The backend lowerer pulls descriptions from the matching edges'
-            ``condition`` field, not from the branches list itself, so this
-            argument is how the orchestrator passes them in.
-
-    Returns:
-        System-prompt string. Engine appends the recent conversation turns
-        as a follow-on user message (see ``router_context_window``).
-    """
-    descriptions = branch_descriptions or {}
-    branch_lines: List[str] = []
-    for br in branches or []:
-        if not isinstance(br, dict):
-            continue
-        bid = br.get("id")
-        if not bid:
-            continue
-        desc = descriptions.get(bid) or "(no description)"
-        branch_lines.append(f"- {bid}: {desc}")
-    branch_lines.append(
-        f"- {UNCLEAR_BRANCH_ID}: pick this when no branch above clearly fits "
-        f"what the user said"
-    )
-
-    extract_block = ""
-    if extract:
-        extract_rows: List[str] = []
-        for name, spec in extract.items():
-            if not isinstance(spec, dict):
-                extract_rows.append(f"- {name} (string)")
-                continue
-            t = spec.get("type", "string")
-            desc = spec.get("description", "")
-            tail = f" ({t}) — {desc}" if desc else f" ({t})"
-            extract_rows.append(f"- {name}{tail}")
-        extract_block = (
-            "\n\n## Also extract these variables (use null if the user didn't say):\n"
-            + "\n".join(extract_rows)
-        )
-
-    reasoning_block = (
-        "\n\n## How to reason\n"
-        "Read the user's MOST RECENT message in full before picking. When it "
-        "contains BOTH a negation (\"no\", \"not\", \"don't\", \"won't\", "
-        "\"can't\", \"nahi\", \"nahin\") AND a positive-sounding action "
-        "statement — in either order — the negation scopes over the whole "
-        "message. Do NOT pick a positive branch just because one sub-clause "
-        "matches its description. Pick a negative-sense branch if one fits; "
-        "otherwise __unclear__.\n\n"
-        "Example: \"no I don't think so I'll be able to pay\" — negation at "
-        "the start scopes over \"I'll be able to pay\". Pick a "
-        "\"cannot pay\"-style branch if present, else __unclear__.\n\n"
-        "## Strong default\n"
-        "If the message is ambiguous or self-contradictory and you can't "
-        "defend your pick by quoting the user, prefer __unclear__. A reprompt "
-        "costs one turn; a confident misroute costs the call."
-    )
-
-    return (
-        "You are a branch-routing classifier for a conversational agent. Read "
-        "the conversation so far and pick the one branch_id that best matches "
-        "what the user said. Emit JSON with `rationale` first (1-2 sentences "
-        "citing the user's words), then `branch`, then `extracted`.\n\n"
-        "## Branches\n" + "\n".join(branch_lines)
-        + extract_block
-        + reasoning_block
-    )
-
-
 def parse_router_response(
     raw: Any,
     valid_branch_ids: List[str],

{dv_pipecat_flows-0.0.0.dev2087 → 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]