rasa-pro 3.16.4.dev2__tar.gz → 3.16.4.dev3__tar.gz

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.16.4.dev2
+Version: 3.16.4.dev3
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.16.4.dev2"
+version = "3.16.4.dev3"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -586,6 +586,7 @@ convention = "google"
 
 
 
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/rasa/core/channels/inspector-nextgen/src/utils/voice/audiostream.ts

@@ -124,6 +124,10 @@ export const createAudioQueue = (socket: Socket): AudioQueue => {
     clear: function () {
       this.buffer = new Float32Array(0);
       this.marks = [];
+      // Also zero the AudioWorklet's internal buffer so audio stops
+      // immediately — clearing the JS queue alone leaves whatever frame
+      // the worklet already consumed still playing.
+      globalPlaybackNode?.port.postMessage("clear");
     },
   };
 };

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/rasa/core/channels/inspector-nextgen/src/utils/voice/playback-processor.ts

@@ -6,8 +6,13 @@ class PlaybackProcessor extends AudioWorkletProcessor {
     this.audioBuffer = new Float32Array(0);
 
     // Set up message handling from the main thread
-    this.port.onmessage = (event: MessageEvent<Float32Array>) => {
-      this.audioBuffer = event.data;
+    this.port.onmessage = (event: MessageEvent<Float32Array | "clear">) => {
+      if (event.data === "clear") {
+        // Immediately silence the worklet — barge-in interrupt
+        this.audioBuffer = new Float32Array(0);
+      } else {
+        this.audioBuffer = event.data;
+      }
     };
 
     // Request initial audio data

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/rasa/core/channels/voice_stream/barge_in/barge_in_prompt_template.jinja2

@@ -7,6 +7,7 @@ BACKCHANNEL: The user is passively signaling they are listening. They are NOT tr
 
 INTERRUPT: The user is actively trying to speak, respond, or take over the conversation. This includes:
 - Any direct answer to a question the assistant asked
+- IMPORTANT: If the assistant's current or previous line contains a question (ends with "?", asks "or", offers a choice, or requests information), then ANY user reply — even a single word like "yes", "no", "yeah", "this one", "that number" — is a direct answer and MUST be classified as INTERRUPT. Short answers to questions are NEVER backchannels.
 - Any new information, correction, or request
 - Any attempt to start a new sentence or thought
 - Any command to stop or pause

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/rasa/core/channels/voice_stream/tts/cartesia.py

@@ -166,6 +166,7 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
         await super().stop_streaming()
         if self.stream_state == self.stream_state.SENDING_RESPONSE_CHUNKS:
             self.stream_state = self.stream_state.INTERRUPTED
+            await self.signal_interrupt()
         elif self.stream_state == self.stream_state.RESPONSE_CHUNKS_SENT:
             self.stream_state = self.stream_state.NO_STREAMING
             await self.signal_interrupt()

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/rasa/core/channels/voice_stream/tts/deepgram.py

@@ -144,6 +144,7 @@ class DeepgramTTS(TTSEngine[DeepgramTTSConfig]):
         await super().stop_streaming()
         if self.stream_state == self.stream_state.SENDING_RESPONSE_CHUNKS:
             self.stream_state = self.stream_state.INTERRUPTED
+            await self.signal_interrupt()
         elif self.stream_state == self.stream_state.RESPONSE_CHUNKS_SENT:
             self.stream_state = self.stream_state.NO_STREAMING
             await self.signal_interrupt()

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/rasa/core/channels/voice_stream/tts/rime.py

@@ -212,6 +212,7 @@ class RimeTTS(TTSEngine[RimeTTSConfig]):
         await super().stop_streaming()
         if self.stream_state == self.stream_state.SENDING_RESPONSE_CHUNKS:
             self.stream_state = self.stream_state.INTERRUPTED
+            await self.signal_interrupt()
         elif self.stream_state == self.stream_state.RESPONSE_CHUNKS_SENT:
             self.stream_state = self.stream_state.NO_STREAMING
             await self.signal_interrupt()

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/rasa/core/channels/voice_stream/voice_channel.py

@@ -910,10 +910,11 @@ class VoiceOutputChannel(OutputChannel):
                 # fallback to non-streaming synthesis
                 return
 
-            if self.tts_engine.stream_state == StreamState.INTERRUPTED:
-                await self.tts_engine.signal_interrupt()
-            else:
+            if self.tts_engine.stream_state != StreamState.INTERRUPTED:
                 await self.tts_engine.signal_text_done()
+            # If INTERRUPTED: stop_streaming() already sent Clear to the TTS
+            # engine; sending a second Clear would leave a stale Cleared
+            # message in the WebSocket buffer and break the next turn's audio.
             self.tts_engine.stream_state = StreamState.RESPONSE_CHUNKS_SENT
 
             if self.audio_sender_task:

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.16.4.dev2"
+__version__ = "3.16.4.dev3"

{rasa_pro-3.16.4.dev2 → rasa_pro-3.16.4.dev3}/rasa/voice_agent/agent.py

@@ -273,6 +273,9 @@ class VoiceLLMAgent:
         # Skills completed in this session (for before_end gate).
         self._completed_skills: Set[str] = set()
 
+        # Set to True once all before_end skills are done — gates end_voice_call.
+        self._ready_to_end: bool = not bool(self.config.conversation.before_end)
+
         self.system_prompt = self._compile_system_prompt(include_ack_rule=True)
         # Variant used for iter > 0 of the agentic loop: the ack rule is
         # stripped because the iter-0 ack has already played.  Keeping the
@@ -708,7 +711,9 @@ class VoiceLLMAgent:
                 "Call activate_skill(skill_name) as soon as the user's "
                 "intent matches a skill. Do NOT ask preliminary questions "
                 "first — the framework handles prerequisites (like "
-                "authentication) automatically after activation.\n"
+                "authentication) automatically after activation. "
+                "Never mention skill names, tool names, or activation "
+                "to the user — use natural language instead.\n"
             ),
         ]
         for skill in self.config.skills:
@@ -1056,8 +1061,8 @@ class VoiceLLMAgent:
         a tool is only shown when all its session conditions are met.
 
         In routing phase (no active skill), only always-available tools
-        are exposed.  Framework tools (``activate_skill``,
-        ``complete_skill``, ``end_voice_call``) are handled separately.
+        are exposed.  Framework tools (``activate_skill``, ``complete_skill``,
+        ``prepare_end``, ``end_voice_call``) are handled separately.
         """
         all_registered = set(self.tools.get_tool_names())
 
@@ -1231,66 +1236,102 @@ class VoiceLLMAgent:
                 return False
         return True
 
-    def _handle_end_voice_call(self) -> Dict[str, Any]:
-        """Framework tool: end the voice call.
+    def _handle_prepare_end(self) -> Dict[str, Any]:
+        """Framework tool: initiate the call wrap-up sequence.
 
-        Checks the ``before_end`` gate first.  If all required skills
-        are completed, returns ``{"ended": true}`` which the agentic
-        loop uses as the hangup signal.  Otherwise auto-activates the
-        first pending required skill (e.g. Feedback for NPS collection).
+        Called by the LLM when the user signals they want to end the call.
+        If all ``before_end`` skills are already complete, marks the call
+        as ready to end and the LLM can immediately call ``end_voice_call``.
+        Otherwise activates the first pending skill (e.g. Feedback) and
+        returns a message so the LLM knows to wait before saying goodbye.
         """
-        if not self._check_before_end_satisfied():
-            pending = [
-                s for s in self.config.conversation.before_end
-                if s not in self._completed_skills
-            ]
-            first = self._name_to_skill.get(pending[0]) if pending else None
-            if first:
-                logger.info(
-                    "voice_agent.before_end_auto_activate: skill=%s",
-                    first.name,
-                )
-                self._activate_with_requires(first)
-                self._recompile_prompts()
-                return {
-                    "status": "before_end_activated",
-                    "skill": first.name,
-                    "message": (
-                        f"Before ending, complete {first.name} first. "
-                        f"It has been activated."
-                    ),
-                }
+        if self._check_before_end_satisfied():
+            self._ready_to_end = True
+            logger.info("voice_agent.prepare_end: ready=true")
             return {
-                "error": "Cannot end call yet — required skills not found."
+                "status": "ready",
+                "message": "All wrap-up steps done. Say goodbye and call end_voice_call.",
             }
+
+        pending = [
+            s for s in self.config.conversation.before_end
+            if s not in self._completed_skills
+        ]
+        first = self._name_to_skill.get(pending[0]) if pending else None
+        if first:
+            logger.info(
+                "voice_agent.prepare_end_activate: skill=%s", first.name
+            )
+            self._activate_with_requires(first)
+            self._recompile_prompts()
+            return {
+                "status": "wrap_up_required",
+                "pending": pending,
+                "message": (
+                    f"{first.name} has been activated. "
+                    f"Complete it before ending the call."
+                ),
+            }
+        return {"error": "Cannot prepare end — required skills not found."}
+
+    def _handle_end_voice_call(self) -> Dict[str, Any]:
+        """Framework tool: end the voice call.
+
+        Only reachable once ``_ready_to_end`` is True (i.e. after
+        ``prepare_end`` confirms all before_end skills are complete).
+        """
         logger.info("voice_agent.end_voice_call: ended=true")
         return {"ended": True}
 
-    def _handle_activate_skill(self, skill_name: str) -> Dict[str, Any]:
+    def _handle_activate_skill(
+        self, skill_name: str, fresh: bool = False
+    ) -> Dict[str, Any]:
         """Framework tool: explicitly activate a skill by name.
 
-        If the skill (or a prerequisite) is already on the stack from a
-        prior interrupted flow, **resume** it — preserving session state
-        so the user can pick up where they left off (e.g. try a password
-        they just remembered).
-
-        Otherwise, start a **new instance** — clearing prerequisite
-        state so ``requires`` are evaluated fresh.
+        Args:
+            skill_name: The skill to activate.
+            fresh: When True the user wants a completely new context
+                (e.g. different phone number).  Prerequisite state is
+                force-cleared and interrupted flows are ignored.  When
+                False (default), completed prerequisites are preserved
+                and interrupted flows are resumed.
         """
         skill = self._name_to_skill.get(skill_name)
         if skill is None:
             return {"error": f"Unknown skill: {skill_name}"}
 
-        if skill is self._active_skill:
+        if skill is self._active_skill and not fresh:
             return {"status": "already_active", "skill": skill_name}
 
-        # Check if this is a resume of an interrupted flow.
-        interrupted = self._find_interrupted_flow(skill)
+        # --- fresh=true: new context, force-reset everything ---
+        if fresh:
+            if self._active_skill is not None:
+                self._skill_stack.append({
+                    "skill": self._active_skill,
+                    "phase_index": self._active_phase_index,
+                    "reason": "digression",
+                })
+                logger.info(
+                    "voice_agent.skill_suspended: skill=%s phase=%d "
+                    "reason=digression",
+                    self._active_skill.name,
+                    self._active_phase_index,
+                )
+            self._force_reset_skill_state(skill)
+            self._activate_with_requires(skill)
+            logger.info(
+                "voice_agent.skill_activate_fresh: skill=%s",
+                skill_name,
+            )
+            return {"status": "activated", "skill": self._active_skill.name}
 
+        # --- fresh=false: check for interrupted flow to resume ---
+        interrupted = self._find_interrupted_flow(skill)
         if interrupted:
             return self._resume_interrupted_flow(interrupted)
 
-        # New instance — push current skill as digression, activate fresh.
+        # --- fresh=false, nothing on stack: new instance, skip
+        #     already-completed prereqs ---
         if self._active_skill is not None:
             self._skill_stack.append({
                 "skill": self._active_skill,
@@ -1298,7 +1339,8 @@ class VoiceLLMAgent:
                 "reason": "digression",
             })
             logger.info(
-                "voice_agent.skill_suspended: skill=%s phase=%d reason=digression",
+                "voice_agent.skill_suspended: skill=%s phase=%d "
+                "reason=digression",
                 self._active_skill.name,
                 self._active_phase_index,
             )
@@ -1394,6 +1436,26 @@ class VoiceLLMAgent:
                 )
         self._completed_skills.discard(skill.name)
 
+    def _force_reset_skill_state(self, skill: SkillConfig) -> None:
+        """Unconditionally clear prereq state (fresh=true path).
+
+        Unlike ``_reset_skill_state``, this resets even previously
+        completed prerequisites — used when the user explicitly wants
+        a new context (different phone number, different account).
+        """
+        for req_name in skill.requires:
+            req_skill = self._name_to_skill.get(req_name)
+            if req_skill:
+                self._completed_skills.discard(req_name)
+                for key in req_skill.tracked_state_keys():
+                    self.ctx.session.pop(key, None)
+                logger.info(
+                    "voice_agent.skill_state_force_reset: skill=%s keys=%s",
+                    req_name,
+                    req_skill.tracked_state_keys(),
+                )
+        self._completed_skills.discard(skill.name)
+
     def _activate_with_requires(
         self, skill: SkillConfig, _visited: Optional[Set[str]] = None
     ) -> None:
@@ -1484,6 +1546,9 @@ class VoiceLLMAgent:
             skill.name,
             sorted(self._completed_skills),
         )
+        if not self._ready_to_end and self._check_before_end_satisfied():
+            self._ready_to_end = True
+            logger.info("voice_agent.ready_to_end: all before_end skills done")
 
         # ``then`` chaining — activate successor
         if skill.then:
@@ -1579,6 +1644,9 @@ class VoiceLLMAgent:
                         "retrying a password or checking a different bill. "
                         "The framework will pick up where the previous "
                         "skill left off. "
+                        "IMPORTANT: Do not mention this tool, skill names, "
+                        "or activation to the user in your spoken response. "
+                        "Use natural language like 'Let me look into that'. "
                         f"Available: {skill_list}."
                     ),
                     "parameters": {
@@ -1591,7 +1659,19 @@ class VoiceLLMAgent:
                                     f"One of: {skill_list}."
                                 ),
                                 "enum": activatable,
-                            }
+                            },
+                            "fresh": {
+                                "type": "boolean",
+                                "description": (
+                                    "Set to true when the user wants a "
+                                    "fresh start — different phone number, "
+                                    "different account, starting over. "
+                                    "Prerequisites like authentication "
+                                    "will re-run from scratch. Default "
+                                    "false: completed prerequisites are "
+                                    "preserved."
+                                ),
+                            },
                         },
                         "required": ["skill_name"],
                     },
@@ -1617,32 +1697,44 @@ class VoiceLLMAgent:
                 },
             })
 
-        # end_voice_call — always available framework tool.
-        # The before_end gate ensures required skills are completed first.
-        before_end = self.config.conversation.before_end
-        if before_end:
-            gate_note = (
-                f" Required skills before ending: "
-                f"{', '.join(before_end)}."
-            )
-        else:
-            gate_note = ""
-        schemas.append({
-            "type": "function",
-            "function": {
-                "name": "end_voice_call",
-                "description": (
-                    "End the phone call. Call this when the user is done "
-                    "and ready to hang up. Say a brief goodbye first, "
-                    "then call this tool."
-                    + gate_note
-                ),
-                "parameters": {
-                    "type": "object",
-                    "properties": {},
+        # prepare_end — available during routing only (no active skill).
+        # Initiates wrap-up; before_end skills run before end_voice_call.
+        if self._active_skill is None:
+            schemas.append({
+                "type": "function",
+                "function": {
+                    "name": "prepare_end",
+                    "description": (
+                        "Call this when the user has indicated they have "
+                        "nothing else they need help with. Do NOT say a "
+                        "farewell or goodbye before calling this — the call "
+                        "does not end here. Wrap-up steps may follow. Say "
+                        "goodbye only when end_voice_call becomes available."
+                    ),
+                    "parameters": {
+                        "type": "object",
+                        "properties": {},
+                    },
+                },
+            })
+
+        # end_voice_call — only available once _ready_to_end is True
+        # (i.e. after prepare_end confirmed all before_end skills are done).
+        if self._ready_to_end:
+            schemas.append({
+                "type": "function",
+                "function": {
+                    "name": "end_voice_call",
+                    "description": (
+                        "End the phone call. Say a brief goodbye, then "
+                        "call this tool."
+                    ),
+                    "parameters": {
+                        "type": "object",
+                        "properties": {},
+                    },
                 },
-            },
-        })
+            })
 
         return schemas
 
@@ -2382,10 +2474,13 @@ class VoiceLLMAgent:
             # --- Framework tool interception ---
             if tc.name == "activate_skill":
                 result = self._handle_activate_skill(
-                    tc.arguments.get("skill_name", "")
+                    tc.arguments.get("skill_name", ""),
+                    fresh=tc.arguments.get("fresh", False),
                 )
             elif tc.name == "complete_skill":
                 result = self._handle_complete_skill()
+            elif tc.name == "prepare_end":
+                result = self._handle_prepare_end()
             elif tc.name == "end_voice_call":
                 result = self._handle_end_voice_call()
             else:
@@ -2419,7 +2514,7 @@ class VoiceLLMAgent:
             # Handles phase advancement (phased skills) and skill-level
             # auto-completion (non-phased bounded skills).
             if tc.name not in (
-                "activate_skill", "complete_skill", "end_voice_call"
+                "activate_skill", "complete_skill", "prepare_end", "end_voice_call"
             ):
                 on_complete = self._check_and_advance()
                 if on_complete:
@@ -2436,6 +2531,19 @@ class VoiceLLMAgent:
                         "role": "system",
                         "content": resume_prompt.strip(),
                     })
+                elif tc.name == "complete_skill" and self._active_skill is None:
+                    # Back to routing after skill completion — remind LLM
+                    # about prepare_end so it doesn't farewell without calling it.
+                    messages.append({
+                        "role": "system",
+                        "content": (
+                            "If the user has already indicated they are done "
+                            "and have no other queries, call prepare_end. "
+                            "If you haven't yet asked whether they need "
+                            "anything else, ask that first before calling "
+                            "prepare_end."
+                        ),
+                    })
 
         return messages