dv-pipecat-flows 0.0.22.dev2300__tar.gz → 0.0.22.dev2500__tar.gz

{dv_pipecat_flows-0.0.22.dev2300/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.22.dev2500}/PKG-INFO

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

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

@@ -623,6 +623,7 @@ class FlowManager:
         transition_to: Optional[str],
         transition_callback: Optional[Callable] = None,
         state_update_keys: Optional[List[str]] = None,
+        router_node_meta: Optional[Dict[str, Any]] = None,
     ) -> Callable:
         """Create a transition function for the given name and handler.
 
@@ -668,6 +669,7 @@ class FlowManager:
                 # ``_set_node`` after the transition. Mirrors the
                 # ``state.update(extracted)`` that ``_run_router_node`` does
                 # on the non-flattened path.
+                extract_update: Dict[str, Any] = {}
                 if state_update_keys and params.arguments:
                     extract_update = {
                         key: params.arguments[key]
@@ -681,6 +683,53 @@ class FlowManager:
                             f"{list(extract_update.keys())} function={name}"
                         )
 
+                # Flattened-router observability: when this function bypasses
+                # an llm_router (router_node_meta set by backend wiring), the
+                # router was never ``_set_node``'d, so its on_node_entered +
+                # on_variables_extracted events never fired naturally. Emit
+                # them synthetically here so the FE canvas highlights the
+                # bypassed router and displays the extracted variables (e.g.
+                # ``state["language"]``) — same visual continuity as the
+                # non-flattened classifier path. Gated by the same
+                # ``state["observable"]`` flag as the natural fires, so prod
+                # calls (no SSE subscriber) skip the publish overhead.
+                if router_node_meta and self.state.get("observable"):
+                    _router_id = router_node_meta.get("id") or router_node_meta.get("name")
+                    _router_label = router_node_meta.get("name") or _router_id
+                    _router_kind = router_node_meta.get("kind") or "router_node"
+                    if self.on_node_entered and _router_id:
+                        _prev_node_id = self._current_node
+                        _prev_cfg = (
+                            self._nodes.get(_prev_node_id) if _prev_node_id else None
+                        )
+                        _from_label = (_prev_cfg or {}).get("name") if _prev_cfg else None
+                        self._fire_and_forget_observe(
+                            self.on_node_entered(
+                                {
+                                    "from_node_id": _prev_node_id,
+                                    "from_label": _from_label,
+                                    "node_id": _router_id,
+                                    "label": _router_label,
+                                    "kind": _router_kind,
+                                    "synthetic": "flattened_router",
+                                    "ts": time.time(),
+                                }
+                            ),
+                            label=f"flattened_router_entered:{_router_id}",
+                        )
+                    if self.on_variables_extracted and extract_update and _router_id:
+                        self._fire_and_forget_observe(
+                            self.on_variables_extracted(
+                                {
+                                    "node_id": _router_id,
+                                    "variables": dict(extract_update),
+                                    "source": "flattened_router",
+                                    "ts": time.time(),
+                                }
+                            ),
+                            label=f"flattened_router_variables_extracted:{_router_id}",
+                        )
+
                 function_call_id = await start_tracking(
                     transcript_handler=self._transcript_handler,
                     tool_name=name,
@@ -931,6 +980,7 @@ class FlowManager:
         transition_to: Optional[str] = None,
         transition_callback: Optional[Callable] = None,
         state_update_keys: Optional[List[str]] = None,
+        router_node_meta: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Register a function with the LLM if not already registered.
 
@@ -959,6 +1009,7 @@ class FlowManager:
                     transition_to,
                     transition_callback,
                     state_update_keys=state_update_keys,
+                    router_node_meta=router_node_meta,
                 )
 
                 # Register function with LLM (or LLMSwitcher).
@@ -2535,6 +2586,39 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 await self._short_circuit_to(pure_code_target)
                 return
 
+            # ``pure_code_target is None`` for a node that SHOULD be
+            # pure-code-dispatched is an author-config failure: condition
+            # router with no matching rule + no ``router_default_next``
+            # (or default points at a deleted node and the backend's
+            # ``_resolve_node_ref`` returned None), or an action node
+            # with success/failure both pointing at deleted targets.
+            # Falling through to LLM dispatch below makes no sense — these
+            # nodes have ``task_messages: []`` (no LLM context), so the
+            # bot just sits silent until ``user_idle_processor`` fires
+            # the generic "Sorry, could you please repeat that?" prompt.
+            # End the call gracefully with a logged error so the misconfig
+            # is visible instead of silently degrading.
+            auto_transition = node_config.get("auto_transition")
+            if auto_transition == "__condition__" or isinstance(auto_transition, dict):
+                self._current_node = node_id
+                logger.error(
+                    f"Pure-code dispatch on '{node_id}' resolved no target "
+                    f"(auto_transition={auto_transition!r}). Ending the call "
+                    f"gracefully — this is an author-config error: a condition "
+                    f"router with no matching rule + no valid router_default_next, "
+                    f"OR an action node whose success/failure targets were deleted."
+                )
+                try:
+                    await self._action_manager.execute_actions(
+                        [{"type": "end_conversation"}]
+                    )
+                except Exception as end_exc:
+                    logger.warning(
+                        f"end_conversation action failed during graceful-end on "
+                        f"'{node_id}': {end_exc!r}"
+                    )
+                return
+
             # Router-mode LLM short-circuit: if this node uses constrained
             # JSON output (llm_mode="router"), run the small classification
             # call, parse the response, recurse into the chosen branch.
@@ -2611,6 +2695,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     transition_to=schema.transition_to,
                     transition_callback=schema.transition_callback,
                     state_update_keys=schema.state_update_keys,
+                    router_node_meta=schema.router_node_meta,
                 )
 
             async def register_direct_function(func):

{dv_pipecat_flows-0.0.22.dev2300 → dv_pipecat_flows-0.0.22.dev2500}/src/pipecat_flows/types.py

@@ -279,6 +279,16 @@ class FlowsFunctionSchema:
     # transitions and still propagate the router's ``router_extract``
     # variables (e.g. ``language``) into state. Empty/None = no-op.
     state_update_keys: Optional[List[str]] = None
+    # Identity of the LLM-router this function bypassed in the flatten path
+    # (``agent_node → llm_router``). When set, the engine emits a synthetic
+    # ``on_node_entered`` for the router and an ``on_variables_extracted``
+    # for the LLM's args at function-call time — so the FE canvas still
+    # highlights the bypassed router AND displays the extracted variables
+    # (e.g. "language") even though the router's classifier turn never ran.
+    # Shape: ``{"id": <node_uuid>, "name": <node_name>, "kind": "router_node"}``
+    # None means this function is a direct agent→non-router transition;
+    # no synthetic events fire.
+    router_node_meta: Optional[Dict[str, Any]] = None
 
     def __post_init__(self):
         """Validate the schema configuration.