dv-pipecat-flows 0.0.22.dev916__tar.gz → 0.0.22.dev1116__tar.gz

{dv_pipecat_flows-0.0.22.dev916/src/dv_pipecat_flows.egg-info → dv_pipecat_flows-0.0.22.dev1116}/PKG-INFO

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

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

@@ -672,6 +672,12 @@ def create_adapter(llm, context_aggregator) -> LLMAdapter:
     llm_type = type(llm).__name__
     llm_class = type(llm)
 
+    if llm_type == "OpenAIResponsesLLMService":
+        # Responses API service uses universal LLMContext — should have been caught
+        # by the LLMContextAggregatorPair check above, but handle explicitly as a fallback
+        logger.debug("Creating universal adapter for OpenAI Responses API service")
+        return UniversalLLMAdapter()
+
     if llm_type == "OpenAILLMService":
         logger.debug("Creating OpenAI adapter")
         return OpenAIAdapter()

{dv_pipecat_flows-0.0.22.dev916 → dv_pipecat_flows-0.0.22.dev1116}/src/pipecat_flows/manager.py

@@ -154,9 +154,6 @@ class FlowManager:
         self._initialized = False
         self._context_aggregator = context_aggregator
         self._pending_transition: Optional[Dict[str, Any]] = None
-        self._transition_lock = asyncio.Lock()
-        self._transition_watchdog_task: Optional[asyncio.Task] = None
-        self._transition_attempt_count: int = 0
         self._pending_function_results: Dict[str, Dict[str, Any]] = {}  # Store function results for extraction
         self._context_strategy = context_strategy or ContextStrategyConfig(
             strategy=ContextStrategy.APPEND
@@ -572,7 +569,6 @@ class FlowManager:
                         "result": result,
                     }
                     self._pending_transition = transition_info
-                    self._start_transition_watchdog()
 
                     properties = FunctionCallResultProperties(
                         run_llm=False,  # Don't run LLM until transition completes
@@ -666,121 +662,19 @@ class FlowManager:
         return metadata if metadata else None
 
     async def _check_and_execute_transition(self) -> None:
-        """Check if all functions are complete and execute transition if so.
-
-        Uses asyncio.shield to protect the transition from cancellation by
-        the aggregator's task management during user interruptions. A lock
-        prevents concurrent execution if both the on_context_updated callback
-        and the watchdog try to run simultaneously.
-        """
+        """Check if all functions are complete and execute transition if so."""
         if not self._pending_transition:
             return
 
         # Check if all function calls are complete using Pipecat's state
         assistant_aggregator = self._context_aggregator.assistant()
         if not assistant_aggregator.has_function_calls_in_progress:
-            if self._transition_lock.locked():
-                # Another transition execution is already in progress
-                return
-
-            async with self._transition_lock:
-                # Re-check after acquiring lock (another path may have completed it)
-                if not self._pending_transition:
-                    return
-
-                transition_info = self._pending_transition
-                try:
-                    await asyncio.shield(self._execute_transition(transition_info))
-                    # Transition succeeded — clear pending state and watchdog
-                    self._pending_transition = None
-                    self._cancel_transition_watchdog()
-                except asyncio.CancelledError:
-                    # asyncio.shield caught cancellation from the aggregator's
-                    # task management during an interruption. The shielded inner
-                    # coroutine continues running independently. The watchdog
-                    # will verify completion or retry.
-                    logger.warning(
-                        "Transition execution shielded from cancellation; "
-                        "watchdog will ensure completion"
-                    )
-                except Exception as e:
-                    # Hard failure — clear pending transition to avoid infinite retry
-                    logger.error(f"Transition execution failed: {e}")
-                    self._pending_transition = None
-                    self._cancel_transition_watchdog()
-
-    async def _transition_watchdog(self) -> None:
-        """Safety net that retries pending transitions if they don't complete.
-
-        Waits a short interval then checks if _pending_transition is still set.
-        If so, the on_context_updated path failed (stuck or cancelled) and we
-        retry the transition with the transition_message stripped to avoid
-        duplicate TTS output. Max 2 retries.
-        """
-        max_attempts = 2
-        interval = 2.0
-        try:
-            while (
-                self._pending_transition
-                and self._transition_attempt_count < max_attempts
-            ):
-                await asyncio.sleep(interval)
-
-                if not self._pending_transition:
-                    logger.debug("Transition watchdog: transition completed normally")
-                    return
-
-                self._transition_attempt_count += 1
-                logger.warning(
-                    f"Transition watchdog: pending transition still active, "
-                    f"attempt {self._transition_attempt_count}/{max_attempts}"
-                )
-
-                transition_info = self._pending_transition
-                try:
-                    # Strip transition_message on retry to avoid duplicate TTS
-                    retry_info = dict(transition_info)
-                    if isinstance(retry_info.get("result"), dict):
-                        retry_info["result"] = {
-                            k: v
-                            for k, v in retry_info["result"].items()
-                            if k != "transition_message"
-                        }
-                    async with self._transition_lock:
-                        if not self._pending_transition:
-                            return
-                        await self._execute_transition(retry_info)
-                        self._pending_transition = None
-                        logger.info("Transition watchdog: retry succeeded")
-                        return
-                except Exception as e:
-                    logger.error(f"Transition watchdog: retry failed: {e}")
-
-            if self._pending_transition:
-                logger.error(
-                    f"Transition watchdog: exhausted {max_attempts} attempts, "
-                    f"giving up on transition for "
-                    f"{self._pending_transition.get('function_name')}"
-                )
-                self._pending_transition = None
-        except asyncio.CancelledError:
-            pass
-        finally:
-            self._transition_attempt_count = 0
-
-    def _start_transition_watchdog(self) -> None:
-        """Start (or restart) the transition watchdog task."""
-        self._cancel_transition_watchdog()
-        self._transition_attempt_count = 0
-        self._transition_watchdog_task = asyncio.ensure_future(
-            self._transition_watchdog()
-        )
-
-    def _cancel_transition_watchdog(self) -> None:
-        """Cancel any running transition watchdog."""
-        if self._transition_watchdog_task and not self._transition_watchdog_task.done():
-            self._transition_watchdog_task.cancel()
-            self._transition_watchdog_task = None
+            transition_info = self._pending_transition
+            self._pending_transition = None
+            try:
+                await self._execute_transition(transition_info)
+            except Exception as e:
+                logger.error(f"Transition execution failed: {e}")
 
     async def _execute_transition(self, transition_info: Dict[str, Any]) -> None:
         """Execute the stored transition."""
@@ -798,11 +692,12 @@ class FlowManager:
             transition_message = result.get("transition_message")
 
         try:
-            # Execute transition_message as a pre_action (same behavior as node pre_actions)
+            # Queue transition_message TTS without waiting for completion.
+            # Using _execute_actions would block on _ongoing_actions_finished_event.wait()
+            # which deadlocks if the user interrupts (ActionFinishedFrame gets dropped).
             if transition_message:
                 logger.debug(f"Speaking transition message: {transition_message[:50]}...")
-                transition_action = {"type": "tts_say", "text": transition_message}
-                await self._execute_actions(pre_actions=[transition_action])
+                await self._task.queue_frame(TTSSpeakFrame(text=transition_message))
 
             if next_node:  # Function-returned next node (consolidated function)
                 if isinstance(next_node, str):  # Static flow
@@ -1143,7 +1038,6 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # - Normal transition flow (already cleared in _check_and_execute_transition)
             # - Direct calls to set_node/set_node_from_config
             self._pending_transition = None
-            self._cancel_transition_watchdog()
 
             # Stop idle processor during node transition to prevent timeout interruptions
             await self._task.queue_frame(StopUserIdleProcessorFrame())
@@ -1241,12 +1135,23 @@ In all of these cases, you can provide a `name` in your new node's config for de
                 standard_functions, original_configs=functions_list
             )
 
+            # Collect mirror_context messages from tts_say pre-actions
+            mirror_messages = []
+            for action in node_config.get("pre_actions", []):
+                if (
+                    action.get("type") == "tts_say"
+                    and action.get("mirror_context", True)
+                    and action.get("text")
+                ):
+                    mirror_messages.append({"role": "assistant", "content": action["text"]})
+
             # Update LLM context
             await self._update_llm_context(
                 role_messages=node_config.get("role_messages"),
                 task_messages=node_config["task_messages"],
                 functions=formatted_tools,
                 strategy=node_config.get("context_strategy"),
+                mirror_messages=mirror_messages,
             )
             logger.debug("Updated LLM context")
 
@@ -1292,6 +1197,7 @@ In all of these cases, you can provide a `name` in your new node's config for de
         task_messages: List[dict],
         functions: List[dict],
         strategy: Optional[ContextStrategyConfig] = None,
+        mirror_messages: Optional[List[dict]] = None,
     ) -> None:
         """Update LLM context with new messages and functions.
 
@@ -1300,6 +1206,9 @@ In all of these cases, you can provide a `name` in your new node's config for de
             task_messages: Task messages to add to context.
             functions: New functions to make available.
             strategy: Optional context update configuration.
+            mirror_messages: Optional assistant messages from tts_say pre-actions
+                with mirror_context=True. These are appended after task_messages
+                so the LLM sees what was spoken to the user.
 
         Raises:
             FlowError: If context update fails.
@@ -1349,6 +1258,12 @@ In all of these cases, you can provide a `name` in your new node's config for de
             # Add task messages
             messages.extend(task_messages)
 
+            # Add mirror messages (tts_say text mirrored as assistant context)
+            # Placed after task_messages so the LLM sees: [system instructions] + [what was spoken]
+            if mirror_messages:
+                messages.extend(mirror_messages)
+                logger.debug(f"Added {len(mirror_messages)} mirror message(s) to LLM context")
+
             # For first node or RESET/RESET_WITH_SUMMARY strategy, use update frame
             frame_type = (
                 LLMMessagesUpdateFrame