dv-pipecat-flows 0.0.22.dev2100__tar.gz → 0.0.22.dev2200__tar.gz

{dv_pipecat_flows-0.0.22.dev2100/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.22.dev2200}/PKG-INFO

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

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

@@ -622,6 +622,7 @@ class FlowManager:
         handler: Optional[Callable | FlowsDirectFunctionWrapper],
         transition_to: Optional[str],
         transition_callback: Optional[Callable] = None,
+        state_update_keys: Optional[List[str]] = None,
     ) -> Callable:
         """Create a transition function for the given name and handler.
 
@@ -630,6 +631,14 @@ class FlowManager:
             handler: Optional function to process data.
             transition_to: Optional node to transition to (static flows).
             transition_callback: Optional callback for dynamic transitions.
+            state_update_keys: Optional list of argument names — when the
+                LLM calls this function, the named keys from
+                ``params.arguments`` are copied into ``flow_manager.state``
+                before the transition resolves. Used by backend wiring to
+                flatten ``agent_node → llm_router`` transitions and still
+                propagate the router's ``router_extract`` variables (e.g.
+                ``language``) into state, preserving parity with
+                ``_run_router_node``'s ``state.update(extracted)``.
 
         Returns:
             Async function that handles the tool invocation.
@@ -652,6 +661,26 @@ class FlowManager:
             function_start_time = time.time()
             try:
                 logger.debug(f"Function called: {name}")
+                # Flattened-router extract: copy LLM-supplied args into
+                # ``flow_manager.state`` BEFORE the transition resolves, so
+                # downstream nodes (e.g. Speak picking variant by
+                # ``state["language"]``) see the new values on their first
+                # ``_set_node`` after the transition. Mirrors the
+                # ``state.update(extracted)`` that ``_run_router_node`` does
+                # on the non-flattened path.
+                if state_update_keys and params.arguments:
+                    extract_update = {
+                        key: params.arguments[key]
+                        for key in state_update_keys
+                        if key in params.arguments
+                    }
+                    if extract_update:
+                        self.state.update(extract_update)
+                        logger.debug(
+                            f"[FLATTENED_ROUTER_EXTRACT] state.update keys="
+                            f"{list(extract_update.keys())} function={name}"
+                        )
+
                 function_call_id = await start_tracking(
                     transcript_handler=self._transcript_handler,
                     tool_name=name,
@@ -901,6 +930,7 @@ class FlowManager:
         handler: Optional[Callable | FlowsDirectFunctionWrapper],
         transition_to: Optional[str] = None,
         transition_callback: Optional[Callable] = None,
+        state_update_keys: Optional[List[str]] = None,
     ) -> None:
         """Register a function with the LLM if not already registered.
 
@@ -924,7 +954,11 @@ class FlowManager:
 
                 # Create transition function
                 transition_func = await self._create_transition_func(
-                    name, handler, transition_to, transition_callback
+                    name,
+                    handler,
+                    transition_to,
+                    transition_callback,
+                    state_update_keys=state_update_keys,
                 )
 
                 # Register function with LLM (or LLMSwitcher).
@@ -2322,8 +2356,26 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     isinstance(a, dict) and a.get("type") == "tts_say"
                     for a in pre_actions
                 ):
+                    # ``Event.wait()`` that's never set hangs forever — a bare
+                    # ``await`` here was a transition-deadlock vector when the
+                    # ``BotStoppedSpeakingFrame`` never reaches ActionManager
+                    # (cancelled pipeline, dropped frame, abruptly closed
+                    # transport). Mirror ``actions.py:_maybe_wait_for_ongoing_
+                    # actions_to_finish``'s 60s ``wait_for`` backstop so the
+                    # node still transitions instead of permanently parking.
+                    from pipecat_flows.actions import ONGOING_ACTIONS_WAIT_TIMEOUT_S
                     try:
-                        await self._action_manager._ongoing_actions_finished_event.wait()
+                        await asyncio.wait_for(
+                            self._action_manager._ongoing_actions_finished_event.wait(),
+                            timeout=ONGOING_ACTIONS_WAIT_TIMEOUT_S,
+                        )
+                    except asyncio.TimeoutError:
+                        logger.warning(
+                            f"audio-wait on '{node_id}' timed out after "
+                            f"{ONGOING_ACTIONS_WAIT_TIMEOUT_S}s — "
+                            f"BotStoppedSpeakingFrame never arrived; continuing "
+                            f"with short-circuit to avoid a permanent hang"
+                        )
                     except Exception as wait_exc:
                         logger.warning(
                             f"audio-wait on '{node_id}' failed ({wait_exc!r}); "
@@ -2558,6 +2610,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
                     handler=schema.handler,
                     transition_to=schema.transition_to,
                     transition_callback=schema.transition_callback,
+                    state_update_keys=schema.state_update_keys,
                 )
 
             async def register_direct_function(func):

{dv_pipecat_flows-0.0.22.dev2100 → dv_pipecat_flows-0.0.22.dev2200}/src/pipecat_flows/types.py

@@ -273,6 +273,12 @@ class FlowsFunctionSchema:
     handler: Optional[FunctionHandler] = None
     transition_to: Optional[str] = None
     transition_callback: Optional[Callable] = None
+    # When the LLM calls this function, copy these keys from
+    # ``params.arguments`` into ``flow_manager.state`` BEFORE the transition
+    # resolves. Used by backend wiring to flatten ``agent_node → llm_router``
+    # 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
 
     def __post_init__(self):
         """Validate the schema configuration.