rasa-pro 3.11.0rc1__py3-none-any.whl → 3.11.0rc3__py3-none-any.whl

rasa/cli/inspect.py

@@ -5,6 +5,7 @@ from typing import List, Text
 
 from sanic import Sanic
 
+from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
 from rasa.core import constants
@@ -70,4 +71,5 @@ def inspect(args: argparse.Namespace) -> None:
     args.credentials = None
     args.server_listeners = [(after_start_hook_open_inspector, "after_server_start")]
 
+    telemetry.track_inspect_started(args.connector)
     rasa.cli.run.run(args)

rasa/cli/studio/studio.py

@@ -1,5 +1,5 @@
 import argparse
-from typing import List, Optional
+from typing import List, Optional, Tuple
 from urllib.parse import ParseResult, urlparse
 
 import questionary
@@ -149,7 +149,7 @@ def _configure_studio_url() -> Optional[str]:
     return studio_url
 
 
-def _get_advanced_config(studio_url: str) -> tuple:
+def _get_advanced_config(studio_url: str) -> Tuple:
     """Get the advanced configuration values for Rasa Studio."""
     keycloak_url = questionary.text(
         "Please provide your Rasa Studio Keycloak URL",
@@ -167,7 +167,7 @@ def _get_advanced_config(studio_url: str) -> tuple:
     return keycloak_url, realm_name, client_id
 
 
-def _get_default_config(studio_url: str) -> tuple:
+def _get_default_config(studio_url: str) -> Tuple:
     """Get the default configuration values for Rasa Studio."""
     keycloak_url = studio_url + "auth/"
     realm_name = DEFAULT_REALM_NAME
@@ -178,6 +178,7 @@ def _get_default_config(studio_url: str) -> tuple:
         f"Keycloak URL: {keycloak_url}, "
         f"Realm Name: '{realm_name}', "
         f"Client ID: '{client_id}'. "
+        f"SSL verification is enabled."
         f"You can use '--advanced' to configure these settings."
     )
 
@@ -185,7 +186,11 @@ def _get_default_config(studio_url: str) -> tuple:
 
 
 def _create_studio_config(
-    studio_url: str, keycloak_url: str, realm_name: str, client_id: str
+    studio_url: str,
+    keycloak_url: str,
+    realm_name: str,
+    client_id: str,
+    disable_verify: bool = False,
 ) -> StudioConfig:
     """Create a StudioConfig object with the provided parameters."""
     return StudioConfig(
@@ -193,6 +198,7 @@ def _create_studio_config(
         studio_url=studio_url + "api/graphql/",
         client_id=client_id,
         realm_name=realm_name,
+        disable_verify=disable_verify,
     )
 
 
@@ -227,19 +233,23 @@ def _configure_studio_config(args: argparse.Namespace) -> StudioConfig:
 
     # create a configuration and auth object to try to reach the studio
     studio_config = _create_studio_config(
-        studio_url, keycloak_url, realm_name, client_id
+        studio_url,
+        keycloak_url,
+        realm_name,
+        client_id,
+        disable_verify=args.disable_verify,
     )
 
-    if args.disable_verify:
+    if studio_config.disable_verify:
         rasa.shared.utils.cli.print_info(
             "Disabling SSL verification for the Rasa Studio authentication server."
         )
-        studio_auth = StudioAuth(studio_config, verify=False)
     else:
         rasa.shared.utils.cli.print_info(
             "Enabling SSL verification for the Rasa Studio authentication server."
         )
-        studio_auth = StudioAuth(studio_config, verify=True)
+
+    studio_auth = StudioAuth(studio_config)
 
     if _check_studio_auth(studio_auth):
         return studio_config

rasa/core/actions/action_repeat_bot_messages.py

@@ -3,6 +3,15 @@ from typing import Optional, Dict, Any, List
 from rasa.core.actions.action import Action
 from rasa.core.channels import OutputChannel
 from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.repeat import (
+    RepeatBotMessagesPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.user_silence import (
+    UserSilencePatternFlowStackFrame,
+)
 from rasa.shared.core.constants import ACTION_REPEAT_BOT_MESSAGES
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import Event, BotUttered, UserUttered
@@ -39,6 +48,14 @@ class ActionRepeatBotMessages(Action):
             The elif condition doesn't break when it sees User3 event.
             But it does at User2 event.
         """
+        # Skip action if we are in a collect information step whose
+        # default behavior is to repeat anyways
+        top_frame = tracker.stack.top(
+            lambda frame: isinstance(frame, RepeatBotMessagesPatternFlowStackFrame)
+            or isinstance(frame, UserSilencePatternFlowStackFrame)
+        )
+        if isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            return []
         # filter user and bot events
         filtered = [
             e for e in tracker.events if isinstance(e, (BotUttered, UserUttered))

rasa/core/channels/channel.py

@@ -313,6 +313,23 @@ class OutputChannel:
             button_msg = cli_utils.button_to_string(button, idx)
             await self.send_text_message(recipient_id, button_msg)
 
+    async def send_text_with_buttons_concise(
+        self,
+        recipient_id: str,
+        text: str,
+        buttons: List[Dict[str, Any]],
+        **kwargs: Any,
+    ) -> None:
+        """Sends buttons in a concise format, useful for voice channels."""
+        if text.strip()[-1] not in {".", "!", "?", ":"}:
+            text += "."
+        text += " "
+        for idx, button in enumerate(buttons):
+            text += button["title"]
+            if idx != len(buttons) - 1:
+                text += ", "
+        await self.send_text_message(recipient_id, text)
+
     async def send_quick_replies(
         self,
         recipient_id: Text,

rasa/core/channels/development_inspector.py

@@ -187,5 +187,8 @@ class TrackerStream:
         if not self._connected_clients:
             return
         await asyncio.wait(
-            [self._send(websocket, message) for websocket in self._connected_clients]
+            [
+                asyncio.create_task(self._send(websocket, message))
+                for websocket in self._connected_clients
+            ]
         )

rasa/core/channels/voice_ready/audiocodes.py

@@ -21,6 +21,7 @@ from sanic.exceptions import NotFound, SanicException, ServerError
 from sanic.request import Request
 from sanic.response import HTTPResponse
 
+from rasa.utils.io import remove_emojis
 
 structlogger = structlog.get_logger()
 
@@ -73,7 +74,7 @@ class Conversation:
     @staticmethod
     def get_metadata(activity: Dict[Text, Any]) -> Optional[Dict[Text, Any]]:
         """Get metadata from the activity."""
-        return activity.get("parameters")
+        return asdict(map_call_params(activity["parameters"]))
 
     @staticmethod
     def _handle_event(event: Dict[Text, Any]) -> Text:
@@ -87,17 +88,16 @@ class Conversation:
 
         if event["name"] == EVENT_START:
             text = f"{INTENT_MESSAGE_PREFIX}{USER_INTENT_SESSION_START}"
-            event_params = asdict(map_call_params(event["parameters"]))
         elif event["name"] == EVENT_DTMF:
             text = f"{INTENT_MESSAGE_PREFIX}vaig_event_DTMF"
             event_params = {"value": event["value"]}
+            text += json.dumps(event_params)
         else:
             structlogger.warning(
                 "audiocodes.handle.event.unknown_event", event_payload=event
             )
             return ""
 
-        text += json.dumps(event_params)
         return text
 
     def is_active_conversation(self, now: datetime, delta: timedelta) -> bool:
@@ -383,7 +383,7 @@ class AudiocodesInput(InputChannel):
             {"conversation": <conversation_id>, "reason": Optional[Text]}.
             """
             self._get_conversation(request.token, conversation_id)
-            reason = json.dumps({"reason": request.json.get("reason")})
+            reason = {"reason": request.json.get("reason")}
             await on_new_message(
                 UserMessage(
                     text=f"{INTENT_MESSAGE_PREFIX}session_end",
@@ -449,6 +449,7 @@ class AudiocodesOutput(OutputChannel):
         self, recipient_id: Text, text: Text, **kwargs: Any
     ) -> None:
         """Send a text message."""
+        text = remove_emojis(text)
         await self.add_message({"type": "message", "text": text})
 
     async def send_image_url(
@@ -471,6 +472,16 @@ class AudiocodesOutput(OutputChannel):
         """Indicate that the conversation should be ended."""
         await self.add_message({"type": "event", "name": "hangup"})
 
+    async def send_text_with_buttons(
+        self,
+        recipient_id: str,
+        text: str,
+        buttons: List[Dict[str, Any]],
+        **kwargs: Any,
+    ) -> None:
+        """Uses the concise button output format for voice channels."""
+        await self.send_text_with_buttons_concise(recipient_id, text, buttons, **kwargs)
+
 
 class WebsocketOutput(AudiocodesOutput):
     def __init__(self, ws: Any, conversation_id: Text) -> None:

rasa/core/channels/voice_ready/jambonz.py

@@ -1,4 +1,4 @@
-from typing import Any, Awaitable, Callable, Dict, Optional, Text
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
 
 import structlog
 from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
@@ -14,7 +14,7 @@ from sanic.request import Request
 from sanic.response import HTTPResponse
 
 from rasa.shared.utils.common import mark_as_beta_feature
-
+from rasa.utils.io import remove_emojis
 
 structlogger = structlog.get_logger()
 
@@ -87,6 +87,7 @@ class JambonzWebsocketOutput(OutputChannel):
         self, recipient_id: Text, text: Text, **kwargs: Any
     ) -> None:
         """Send a text message."""
+        text = remove_emojis(text)
         await self.add_message({"type": "message", "text": text})
 
     async def send_image_url(
@@ -108,3 +109,13 @@ class JambonzWebsocketOutput(OutputChannel):
     async def hangup(self, recipient_id: Text, **kwargs: Any) -> None:
         """Indicate that the conversation should be ended."""
         await send_ws_hangup_message(DEFAULT_HANGUP_DELAY_SECONDS, self.ws)
+
+    async def send_text_with_buttons(
+        self,
+        recipient_id: str,
+        text: str,
+        buttons: List[Dict[str, Any]],
+        **kwargs: Any,
+    ) -> None:
+        """Uses the concise button output format for voice channels."""
+        await self.send_text_with_buttons_concise(recipient_id, text, buttons, **kwargs)

rasa/core/channels/voice_ready/twilio_voice.py

@@ -358,38 +358,23 @@ class TwilioVoiceCollectingOutputChannel(CollectingOutputChannel):
         """Name of the output channel."""
         return "twilio_voice"
 
-    @staticmethod
-    def _emoji_warning(text: Text) -> None:
-        """Raises a warning if text contains an emoji."""
-        emoji_regex = rasa.utils.io.get_emoji_regex()
-        if emoji_regex.findall(text):
-            rasa.shared.utils.io.raise_warning(
-                "Text contains an emoji in a voice response. "
-                "Review responses to provide a voice-friendly alternative."
-            )
-
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any
     ) -> None:
         """Sends the text message after removing emojis."""
-        self._emoji_warning(text)
+        text = rasa.utils.io.remove_emojis(text)
         for message_part in text.strip().split("\n\n"):
             await self._persist_message(self._message(recipient_id, text=message_part))
 
     async def send_text_with_buttons(
         self,
-        recipient_id: Text,
-        text: Text,
-        buttons: List[Dict[Text, Any]],
+        recipient_id: str,
+        text: str,
+        buttons: List[Dict[str, Any]],
         **kwargs: Any,
     ) -> None:
-        """Convert buttons into a voice representation."""
-        self._emoji_warning(text)
-        await self._persist_message(self._message(recipient_id, text=text))
-
-        for b in buttons:
-            self._emoji_warning(b["title"])
-            await self._persist_message(self._message(recipient_id, text=b["title"]))
+        """Uses the concise button output format for voice channels."""
+        await self.send_text_with_buttons_concise(recipient_id, text, buttons, **kwargs)
 
     async def send_image_url(
         self, recipient_id: Text, image: Text, **kwargs: Any

rasa/core/channels/voice_stream/asr/asr_event.py

@@ -14,5 +14,5 @@ class NewTranscript(ASREvent):
 
 
 @dataclass
-class UserStartedSpeaking(ASREvent):
+class UserIsSpeaking(ASREvent):
     pass

rasa/core/channels/voice_stream/asr/azure.py

@@ -7,7 +7,7 @@ from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineC
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
-    UserStartedSpeaking,
+    UserIsSpeaking,
 )
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.shared.exceptions import ConnectionException
@@ -31,9 +31,9 @@ class AzureASR(ASREngine[AzureASRConfig]):
             asyncio.Queue()
         )
 
-    def signal_user_started_speaking(self, event: Any) -> None:
-        """Replace the unspecific azure event with a specific start event."""
-        self.fill_queue(UserStartedSpeaking())
+    def signal_user_is_speaking(self, event: Any) -> None:
+        """Replace the azure event with a generic is speaking event."""
+        self.fill_queue(UserIsSpeaking())
 
     def fill_queue(self, event: Any) -> None:
         """Either puts the event or a dedicated ASR Event into the queue."""
@@ -60,9 +60,7 @@ class AzureASR(ASREngine[AzureASRConfig]):
             audio_config=audio_config,
         )
         self.speech_recognizer.recognized.connect(self.fill_queue)
-        self.speech_recognizer.speech_start_detected.connect(
-            self.signal_user_started_speaking
-        )
+        self.speech_recognizer.recognizing.connect(self.signal_user_is_speaking)
         self.speech_recognizer.start_continuous_recognition_async()
         self.is_recognizing = True
 

rasa/core/channels/voice_stream/asr/deepgram.py

@@ -10,7 +10,7 @@ from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineC
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
-    UserStartedSpeaking,
+    UserIsSpeaking,
 )
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 
@@ -49,7 +49,7 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
     def _get_query_params(self) -> str:
         return (
             f"encoding=mulaw&sample_rate={HERTZ}&endpointing={self.config.endpointing}"
-            f"&vad_events=true&language={self.config.language}"
+            f"&vad_events=true&language={self.config.language}&interim_results=true"
             f"&model={self.config.model}&smart_format={str(self.config.smart_format).lower()}"
         )
 
@@ -66,16 +66,18 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
     def engine_event_to_asr_event(self, e: Any) -> Optional[ASREvent]:
         """Translate an engine event to a common ASREvent."""
         data = json.loads(e)
-        if data.get("is_final"):
+        if "is_final" in data:
             transcript = data["channel"]["alternatives"][0]["transcript"]
-            if data.get("speech_final"):
-                full_transcript = self.accumulated_transcript + transcript
-                self.accumulated_transcript = ""
-                return NewTranscript(full_transcript)
-            else:
-                self.accumulated_transcript += transcript
-        elif data.get("type") == "SpeechStarted":
-            return UserStartedSpeaking()
+            if data["is_final"]:
+                if data.get("speech_final"):
+                    full_transcript = self.accumulated_transcript + transcript
+                    self.accumulated_transcript = ""
+                    if full_transcript:
+                        return NewTranscript(full_transcript)
+                else:
+                    self.accumulated_transcript += transcript
+            elif transcript:
+                return UserIsSpeaking()
         return None
 
     @staticmethod

rasa/core/channels/voice_stream/voice_channel.py

@@ -2,13 +2,10 @@ import asyncio
 import structlog
 import copy
 from dataclasses import asdict, dataclass
-from typing import Any, AsyncIterator, Awaitable, Callable, Dict, Optional, Tuple
+from typing import Any, AsyncIterator, Awaitable, Callable, Dict, List, Optional, Tuple
 
 from rasa.core.channels.voice_stream.util import generate_silence
-from rasa.shared.core.constants import (
-    SILENCE_TIMEOUT_DEFAULT_VALUE,
-    SLOT_SILENCE_TIMEOUT,
-)
+from rasa.shared.core.constants import SLOT_SILENCE_TIMEOUT
 from rasa.shared.utils.common import (
     class_from_module_path,
     mark_as_beta_feature,
@@ -24,7 +21,7 @@ from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
-    UserStartedSpeaking,
+    UserIsSpeaking,
 )
 from sanic import Websocket  # type: ignore
 
@@ -40,6 +37,7 @@ from rasa.core.channels.voice_stream.tts.azure import AzureTTS
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
+from rasa.utils.io import remove_emojis
 
 logger = structlog.get_logger(__name__)
 
@@ -157,9 +155,20 @@ class VoiceOutputChannel(OutputChannel):
                 self.tracker_state["slots"][SLOT_SILENCE_TIMEOUT]
             )
 
+    async def send_text_with_buttons(
+        self,
+        recipient_id: str,
+        text: str,
+        buttons: List[Dict[str, Any]],
+        **kwargs: Any,
+    ) -> None:
+        """Uses the concise button output format for voice channels."""
+        await self.send_text_with_buttons_concise(recipient_id, text, buttons, **kwargs)
+
     async def send_text_message(
         self, recipient_id: str, text: str, **kwargs: Any
     ) -> None:
+        text = remove_emojis(text)
         self.update_silence_timeout()
         cached_audio_bytes = self.tts_cache.get(text)
         collected_audio_bytes = RasaAudioBytes(b"")
@@ -221,11 +230,18 @@ class VoiceOutputChannel(OutputChannel):
 
 
 class VoiceInputChannel(InputChannel):
-    def __init__(self, server_url: str, asr_config: Dict, tts_config: Dict):
+    def __init__(
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        monitor_silence: bool = False,
+    ):
         validate_voice_license_scope()
         self.server_url = server_url
         self.asr_config = asr_config
         self.tts_config = tts_config
+        self.monitor_silence = monitor_silence
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
 
     async def handle_silence_timeout(
@@ -235,10 +251,14 @@ class VoiceInputChannel(InputChannel):
         tts_engine: TTSEngine,
         call_parameters: CallParameters,
     ) -> None:
-        timeout = call_state.silence_timeout or SILENCE_TIMEOUT_DEFAULT_VALUE
-        logger.info("voice_channel.silence_timeout_watch_started", timeout=timeout)
+        timeout = call_state.silence_timeout
+        if not timeout:
+            return
+        if not self.monitor_silence:
+            return
+        logger.debug("voice_channel.silence_timeout_watch_started", timeout=timeout)
         await asyncio.sleep(timeout)
-        logger.info("voice_channel.silence_timeout_tripped")
+        logger.debug("voice_channel.silence_timeout_tripped")
         output_channel = self.create_output_channel(voice_websocket, tts_engine)
         message = UserMessage(
             "/silence_timeout",
@@ -249,10 +269,23 @@ class VoiceInputChannel(InputChannel):
         )
         await on_new_message(message)
 
+    @staticmethod
+    def _cancel_silence_timeout_watcher() -> None:
+        """Cancels the silent timeout task if it exists."""
+        if call_state.silence_timeout_watcher:
+            logger.debug("voice_channel.cancelling_current_timeout_watcher_task")
+            call_state.silence_timeout_watcher.cancel()
+            call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
+
     @classmethod
     def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
         credentials = credentials or {}
-        return cls(credentials["server_url"], credentials["asr"], credentials["tts"])
+        return cls(
+            credentials["server_url"],
+            credentials["asr"],
+            credentials["tts"],
+            credentials.get("monitor_silence", False),
+        )
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         raise NotImplementedError
@@ -311,11 +344,14 @@ class VoiceInputChannel(InputChannel):
                 is_bot_speaking_after = call_state.is_bot_speaking
 
                 if not is_bot_speaking_before and is_bot_speaking_after:
-                    logger.info("voice_channel.bot_started_speaking")
+                    logger.debug("voice_channel.bot_started_speaking")
+                    # relevant when the bot speaks multiple messages in one turn
+                    self._cancel_silence_timeout_watcher()
 
                 # we just stopped speaking, starting a watcher for silence timeout
                 if is_bot_speaking_before and not is_bot_speaking_after:
-                    logger.info("voice_channel.bot_stopped_speaking")
+                    logger.debug("voice_channel.bot_stopped_speaking")
+                    self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
                         asyncio.create_task(
                             self.handle_silence_timeout(
@@ -342,12 +378,20 @@ class VoiceInputChannel(InputChannel):
                     call_parameters,
                 )
 
+        audio_forwarding_task = asyncio.create_task(consume_audio_bytes())
+        asr_event_task = asyncio.create_task(consume_asr_events())
         await asyncio.wait(
-            [consume_audio_bytes(), consume_asr_events()],
+            [audio_forwarding_task, asr_event_task],
             return_when=asyncio.FIRST_COMPLETED,
         )
+        if not audio_forwarding_task.done():
+            audio_forwarding_task.cancel()
+        if not asr_event_task.done():
+            asr_event_task.cancel()
         await tts_engine.close_connection()
         await asr_engine.close_connection()
+        await channel_websocket.close()
+        self._cancel_silence_timeout_watcher()
 
     def create_output_channel(
         self, voice_websocket: Websocket, tts_engine: TTSEngine
@@ -365,7 +409,7 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         """Handle a new event from the ASR system."""
         if isinstance(e, NewTranscript) and e.text:
-            logger.info(
+            logger.debug(
                 "VoiceInputChannel.handle_asr_event.new_transcript", transcript=e.text
             )
             call_state.is_user_speaking = False  # type: ignore[attr-defined]
@@ -378,8 +422,6 @@ class VoiceInputChannel(InputChannel):
                 metadata=asdict(call_parameters),
             )
             await on_new_message(message)
-        elif isinstance(e, UserStartedSpeaking):
-            if call_state.silence_timeout_watcher:
-                call_state.silence_timeout_watcher.cancel()
-                call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
+        elif isinstance(e, UserIsSpeaking):
+            self._cancel_silence_timeout_watcher()
             call_state.is_user_speaking = True  # type: ignore[attr-defined]