rasa-pro 3.13.0.dev3__py3-none-any.whl → 3.13.0.dev5__py3-none-any.whl

rasa/core/channels/inspector/src/components/Chat.tsx

@@ -40,7 +40,7 @@ export const Chat = ({ sx, events, ...props }: Props) => {
 
   // collect user and bot messages
   const messages: MessageContent[] = events
-    .filter((event: Event) => event.event === "user" || event.event === "bot")
+    .filter((event: Event) => event.event === "user" || event.event === "bot" || event.event === "session_ended")
     // @ts-expect-error 
     .flatMap((event: Event) => {
       if (event.event === "user") {
@@ -58,7 +58,28 @@ export const Chat = ({ sx, events, ...props }: Props) => {
             html: `<div>${commands.join("")}</div>`,
           },
         ];
-      } else {
+      } else if (event.event === "session_ended") {
+        return [
+          {
+            role: "system",
+            html: `<div>
+              session ended
+              <div style="margin-top: 8px;">
+                <button 
+                  onclick="(() => {
+                     window.restartConversation();
+                     return false;
+                   })()"
+                  style="background-color: transparent; border: 1px solid #ccc; border-radius: 4px; padding: 4px 12px; cursor: pointer; font-size: 14px;"
+                >
+                  Start a new conversation
+                </button>
+              </div>
+            </div>`,
+          }
+        ]
+      }
+       else {
         return [
           {
             role: event.event,

rasa/core/channels/inspector/src/components/DiagramFlow.tsx

@@ -2,6 +2,7 @@ import { Box, Button, Flex, Heading, Text } from "@chakra-ui/react";
 import mermaid from "mermaid";
 import { useOurTheme } from "../theme";
 import { formatFlow } from "../helpers/formatters";
+import { restartConversation } from "../helpers/conversation";
 import { useEffect, useRef, useState } from "react";
 import { Flow, Slot, Stack } from "../types";
 import { NoActiveFlow } from "./NoActiveFlow";
@@ -51,11 +52,7 @@ export const DiagramFlow = ({ stackFrame, stepTrail, flows, slots }: Props) => {
   }, [text, flow, slots, stackFrame]);
 
   const handleRestartConversation = () => {
-    // unset the sender id from the query parameters
-    const url = new URL(window.location.href);
-    url.searchParams.delete("sender");
-    window.history.pushState(null, "", url.toString());
-    location.reload();
+    restartConversation();
   };
 
   const scrollSx = {

rasa/core/channels/inspector/src/helpers/conversation.ts

@@ -0,0 +1,16 @@
+export const restartConversation = () => {
+  // unset the sender id from the query parameters
+  const url = new URL(window.location.href);
+  url.searchParams.delete("sender");
+  window.history.pushState(null, "", url.toString());
+  location.reload();
+};
+
+// Make the function available on the window object
+declare global {
+  interface Window {
+    restartConversation: typeof restartConversation;
+  }
+}
+
+window.restartConversation = restartConversation;

rasa/core/channels/inspector/src/types.ts

@@ -5,7 +5,7 @@ export interface Slot {
 }
 
 export interface Event {
-  event: "user" | "bot" | "flow_completed" | "flow_started" | "stack" | "restart";
+  event: "user" | "bot" | "flow_completed" | "flow_started" | "stack" | "restart" | "session_ended";
   text?: string;
   timestamp: string;
   update?: string;

rasa/core/channels/voice_ready/audiocodes.py

@@ -6,7 +6,18 @@ import uuid
 from collections import defaultdict
 from dataclasses import asdict
 from datetime import datetime, timedelta, timezone
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Text, Union
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Text,
+    Tuple,
+    Union,
+)
 
 import structlog
 from jsonschema import ValidationError, validate
@@ -76,32 +87,45 @@ class Conversation:
 
     @staticmethod
     def get_metadata(activity: Dict[Text, Any]) -> Optional[Dict[Text, Any]]:
-        """Get metadata from the activity."""
-        return asdict(map_call_params(activity["parameters"]))
+        """Get metadata from the activity.
+
+        ONLY used for activities NOT for events (see _handle_event)."""
+        return activity.get("parameters")
 
     @staticmethod
-    def _handle_event(event: Dict[Text, Any]) -> Text:
-        """Handle start and DTMF event and return the corresponding text."""
+    def _handle_event(event: Dict[Text, Any]) -> Tuple[Text, Dict[Text, Any]]:
+        """Handle events and return a tuple of text and metadata.
+
+        Args:
+            event: The event to handle.
+
+        Returns:
+            Tuple of text and metadata.
+            text is either /session_start or /vaig_event_<event_name>
+            metadata is a dictionary with the event parameters.
+        """
         structlogger.debug("audiocodes.handle.event", event_payload=event)
         if "name" not in event:
             structlogger.warning(
                 "audiocodes.handle.event.no_name_key", event_payload=event
             )
-            return ""
+            return "", {}
 
         if event["name"] == EVENT_START:
             text = f"{INTENT_MESSAGE_PREFIX}{USER_INTENT_SESSION_START}"
+            metadata = asdict(map_call_params(event.get("parameters", {})))
         elif event["name"] == EVENT_DTMF:
             text = f"{INTENT_MESSAGE_PREFIX}vaig_event_DTMF"
-            event_params = {"value": event["value"]}
-            text += json.dumps(event_params)
+            metadata = {"value": event["value"]}
         else:
-            structlogger.warning(
-                "audiocodes.handle.event.unknown_event", event_payload=event
-            )
-            return ""
+            # handle other events described by Audiocodes
+            # https://techdocs.audiocodes.com/voice-ai-connect/#VAIG_Combined/inactivity-detection.htm?TocPath=Bot%2520integration%257CReceiving%2520notifications%257C_____3
+            text = f"{INTENT_MESSAGE_PREFIX}vaig_event_{event['name']}"
+            metadata = {**event.get("parameters", {})}
+            if "value" in event:
+                metadata["value"] = event["value"]
 
-        return text
+        return text, metadata
 
     def is_active_conversation(self, now: datetime, delta: timedelta) -> bool:
         """Check if the conversation is active."""
@@ -141,16 +165,18 @@ class Conversation:
             self.activity_ids.append(activity[ACTIVITY_ID_KEY])
             if activity["type"] == ACTIVITY_MESSAGE:
                 text = activity["text"]
+                metadata = self.get_metadata(activity)
             elif activity["type"] == ACTIVITY_EVENT:
-                text = self._handle_event(activity)
+                text, metadata = self._handle_event(activity)
             else:
                 structlogger.warning(
                     "audiocodes.handle.activities.unknown_activity_type",
                     activity=activity,
                 )
+                continue
+
             if not text:
                 continue
-            metadata = self.get_metadata(activity)
             user_msg = UserMessage(
                 text=text,
                 input_channel=input_channel_name,

rasa/core/channels/voice_ready/twilio_voice.py

@@ -13,14 +13,19 @@ from rasa.core.channels.channel import (
     CollectingOutputChannel,
     InputChannel,
     UserMessage,
+    create_auth_requested_response_provider,
+    requires_basic_auth,
 )
 from rasa.core.channels.voice_ready.utils import CallParameters
 from rasa.shared.core.events import BotUttered
-from rasa.shared.exceptions import InvalidConfigException
+from rasa.shared.exceptions import InvalidConfigException, RasaException
 
 logger = structlog.get_logger(__name__)
 
 
+TWILIO_VOICE_PATH = "webhooks/twilio_voice/webhook"
+
+
 def map_call_params(form: RequestParameters) -> CallParameters:
     """Map the Audiocodes parameters to the CallParameters dataclass."""
     return CallParameters(
@@ -120,6 +125,14 @@ class TwilioVoiceInput(InputChannel):
         """Load custom configurations."""
         credentials = credentials or {}
 
+        username = credentials.get("username")
+        password = credentials.get("password")
+        if (username is None) != (password is None):
+            raise RasaException(
+                "In TwilioVoice channel, either both username and password "
+                "or neither should be provided. "
+            )
+
         return cls(
             credentials.get(
                 "reprompt_fallback_phrase",
@@ -129,6 +142,8 @@ class TwilioVoiceInput(InputChannel):
             credentials.get("speech_timeout", "5"),
             credentials.get("speech_model", "default"),
             credentials.get("enhanced", "false"),
+            username=username,
+            password=password,
         )
 
     def __init__(
@@ -138,6 +153,8 @@ class TwilioVoiceInput(InputChannel):
         speech_timeout: Text = "5",
         speech_model: Text = "default",
         enhanced: Text = "false",
+        username: Optional[Text] = None,
+        password: Optional[Text] = None,
     ) -> None:
         """Creates a connection to Twilio voice.
 
@@ -153,6 +170,8 @@ class TwilioVoiceInput(InputChannel):
         self.speech_timeout = speech_timeout
         self.speech_model = speech_model
         self.enhanced = enhanced
+        self.username = username
+        self.password = password
 
         self._validate_configuration()
 
@@ -161,6 +180,9 @@ class TwilioVoiceInput(InputChannel):
         if self.assistant_voice not in self.SUPPORTED_VOICES:
             self._raise_invalid_voice_exception()
 
+        if (self.username is None) != (self.password is None):
+            self._raise_invalid_credentials_exception()
+
         try:
             int(self.speech_timeout)
         except ValueError:
@@ -246,6 +268,13 @@ class TwilioVoiceInput(InputChannel):
             return response.json({"status": "ok"})
 
         @twilio_voice_webhook.route("/webhook", methods=["POST"])
+        @requires_basic_auth(
+            username=self.username,
+            password=self.password,
+            auth_request_provider=create_auth_requested_response_provider(
+                TWILIO_VOICE_PATH
+            ),
+        )
         async def receive(request: Request) -> HTTPResponse:
             sender_id = request.form.get("From")
             text = request.form.get("SpeechResult")
@@ -310,6 +339,11 @@ class TwilioVoiceInput(InputChannel):
                 twilio_response = self._build_twilio_voice_response(
                     [{"text": last_response_text}]
                 )
+
+            logger.debug(
+                "twilio_voice.webhook.twilio_response",
+                twilio_response=str(twilio_response),
+            )
             return response.text(str(twilio_response), content_type="text/xml")
 
         return twilio_voice_webhook
@@ -329,6 +363,13 @@ class TwilioVoiceInput(InputChannel):
             enhanced=self.enhanced,
         )
 
+        if not messages:
+            # In case bot has a greet message disabled
+            # or if the bot is not configured to send an initial message
+            # we need to send a voice response with speech settings
+            voice_response.append(gather)
+            return voice_response
+
         # Add pauses between messages.
         # Add a listener to the last message to listen for user response.
         for i, message in enumerate(messages):
@@ -347,6 +388,12 @@ class TwilioVoiceInput(InputChannel):
 
         return voice_response
 
+    def _raise_invalid_credentials_exception(self) -> None:
+        raise InvalidConfigException(
+            "In TwilioVoice channel, either both username and password "
+            "or neither should be provided. "
+        )
+
 
 class TwilioVoiceCollectingOutputChannel(CollectingOutputChannel):
     """Output channel that collects send messages in a list.

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

@@ -54,13 +54,22 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
                     async for data in response.content.iter_chunked(1024):
                         yield self.engine_bytes_to_rasa_audio_bytes(data)
                     return
+                elif response.status == 401:
+                    structlogger.error(
+                        "azure.synthesize.rest.authentication_failed",
+                        status_code=response.status,
+                    )
+                    raise TTSError(
+                        f"Authentication failed. Please check your API key: {response.status}"  # noqa: E501
+                    )
                 else:
+                    response_text = await response.text()
                     structlogger.error(
                         "azure.synthesize.rest.failed",
                         status_code=response.status,
-                        msg=response.text(),
+                        msg=response_text,
                     )
-                    raise TTSError(f"TTS failed: {response.text()}")
+                    raise TTSError(f"TTS failed: {response_text}")
         except ClientConnectorError as e:
             raise TTSError(e)
         except TimeoutError as e:

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import base64
 import json
 import uuid
-from typing import Any, Awaitable, Callable, Dict, Optional, Text, Tuple
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Optional, Text, Tuple
 
 import structlog
 from sanic import (  # type: ignore[attr-defined]
@@ -12,7 +14,11 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
-from rasa.core.channels import UserMessage
+from rasa.core.channels import InputChannel, UserMessage
+from rasa.core.channels.channel import (
+    create_auth_requested_response_provider,
+    requires_basic_auth,
+)
 from rasa.core.channels.voice_ready.utils import CallParameters
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.call_state import call_state
@@ -25,10 +31,24 @@ from rasa.core.channels.voice_stream.voice_channel import (
     VoiceInputChannel,
     VoiceOutputChannel,
 )
+from rasa.shared.exceptions import RasaException
+
+if TYPE_CHECKING:
+    from twilio.twiml.voice_response import VoiceResponse
 
 logger = structlog.get_logger(__name__)
 
 
+TWILIO_MEDIA_STREAMS_WEBHOOK_PATH = "webhooks/twilio_media_streams/webhook"
+TWILIO_MEDIA_STREAMS_WEBSOCKET_PATH = "webhooks/twilio_media_streams/websocket"
+
+
+CALL_SID_REQUEST_KEY = "CallSid"
+FROM_NUMBER_REQUEST_KEY = "From"
+TO_NUMBER_REQUEST_KEY = "To"
+DIRECTION_REQUEST_KEY = "Direction"
+
+
 def map_call_params(data: Dict[Text, Any]) -> CallParameters:
     """Map the twilio stream parameters to the CallParameters dataclass."""
     stream_sid = data["streamSid"]
@@ -77,6 +97,40 @@ class TwilioMediaStreamsOutputChannel(VoiceOutputChannel):
 
 
 class TwilioMediaStreamsInputChannel(VoiceInputChannel):
+    def __init__(
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        monitor_silence: bool = False,
+        username: Optional[Text] = None,
+        password: Optional[Text] = None,
+    ):
+        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        self.username = username
+        self.password = password
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+        credentials = credentials or {}
+
+        username = credentials.get("username")
+        password = credentials.get("password")
+        if (username is None) != (password is None):
+            raise RasaException(
+                "In TwilioMediaStreams channel, either both username and password "
+                "or neither should be provided. "
+            )
+
+        return cls(
+            credentials["server_url"],
+            credentials["asr"],
+            credentials["tts"],
+            credentials.get("monitor_silence", False),
+            username=username,
+            password=password,
+        )
+
     @classmethod
     def name(cls) -> str:
         return "twilio_media_streams"
@@ -130,16 +184,6 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             self.tts_cache,
         )
 
-    def websocket_stream_url(self) -> str:
-        """Returns the websocket stream URL."""
-        # depending on the config value, the url might contain http as a
-        # protocol or not - we'll make sure both work
-        if self.server_url.startswith("http"):
-            base_url = self.server_url.replace("http", "ws")
-        else:
-            base_url = f"wss://{self.server_url}"
-        return f"{base_url}/webhooks/twilio_media_streams/websocket"
-
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
@@ -151,22 +195,20 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             return response.json({"status": "ok"})
 
         @blueprint.route("/webhook", methods=["POST"])
+        @requires_basic_auth(
+            username=self.username,
+            password=self.password,
+            auth_request_provider=create_auth_requested_response_provider(
+                realm=TWILIO_MEDIA_STREAMS_WEBHOOK_PATH
+            ),
+        )
         async def receive(request: Request) -> HTTPResponse:
-            from twilio.twiml.voice_response import Connect, VoiceResponse
-
-            voice_response = VoiceResponse()
-            start = Connect()
-            stream = start.stream(url=self.websocket_stream_url())
-            # pass information about the call to the webhook - so we can
-            # store it in the input channel
-            stream.parameter(name="call_id", value=request.form.get("CallSid", None))
-            stream.parameter(name="user_phone", value=request.form.get("From", None))
-            stream.parameter(name="bot_phone", value=request.form.get("To", None))
-            stream.parameter(
-                name="direction", value=request.form.get("Direction", None)
-            )
+            voice_response = self._build_twilio_response(request)
 
-            voice_response.append(start)
+            logger.debug(
+                "twilio_media_streams.webhook.twilio_response",
+                twilio_response=str(voice_response),
+            )
 
             return response.text(str(voice_response), content_type="text/xml")
 
@@ -175,3 +217,36 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             await self.run_audio_streaming(on_new_message, ws)
 
         return blueprint
+
+    def _websocket_stream_url(self) -> str:
+        """Returns the websocket stream URL."""
+        # depending on the config value, the url might contain http as a
+        # protocol or not - we'll make sure both work
+        if self.server_url.startswith("http"):
+            base_url = self.server_url.replace("http", "ws")
+        else:
+            base_url = f"wss://{self.server_url}"
+        return f"{base_url}/{TWILIO_MEDIA_STREAMS_WEBSOCKET_PATH}"
+
+    def _build_twilio_response(self, request: Request) -> VoiceResponse:
+        from twilio.twiml.voice_response import Connect, VoiceResponse
+
+        voice_response = VoiceResponse()
+        start = Connect()
+        stream = start.stream(url=self._websocket_stream_url())
+        # pass information about the call to the webhook - so we can
+        # store it in the input channel
+        stream.parameter(
+            name="call_id", value=request.form.get(CALL_SID_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="user_phone", value=request.form.get(FROM_NUMBER_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="bot_phone", value=request.form.get(TO_NUMBER_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="direction", value=request.form.get(DIRECTION_REQUEST_KEY, None)
+        )
+        voice_response.append(start)
+        return voice_response

rasa/core/channels/voice_stream/voice_channel.py

@@ -42,6 +42,11 @@ from rasa.utils.io import remove_emojis
 
 logger = structlog.get_logger(__name__)
 
+# define constants for the voice channel
+USER_CONVERSATION_SESSION_END = "/session_end"
+USER_CONVERSATION_SESSION_START = "/session_start"
+USER_CONVERSATION_SILENCE_TIMEOUT = "/silence_timeout"
+
 
 @dataclass
 class VoiceChannelAction:
@@ -189,6 +194,7 @@ class VoiceOutputChannel(OutputChannel):
         collected_audio_bytes = RasaAudioBytes(b"")
         seconds_marker = -1
         last_sent_offset = 0
+        logger.debug("voice_channel.sending_audio", text=text)
 
         # Send start marker before first chunk
         try:
@@ -334,7 +340,7 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         output_channel = self.create_output_channel(channel_websocket, tts_engine)
         message = UserMessage(
-            "/session_start",
+            USER_CONVERSATION_SESSION_START,
             output_channel,
             call_parameters.stream_id,
             input_channel=self.name(),
@@ -393,6 +399,9 @@ class VoiceInputChannel(InputChannel):
                     await asr_engine.send_audio_chunks(channel_action.audio_bytes)
                 elif isinstance(channel_action, EndConversationAction):
                     # end stream event came from the other side
+                    await self.handle_disconnect(
+                        channel_websocket, on_new_message, tts_engine, call_parameters
+                    )
                     break
 
         async def receive_asr_events() -> None:
@@ -462,10 +471,27 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserSilence):
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                "/silence_timeout",
+                USER_CONVERSATION_SILENCE_TIMEOUT,
                 output_channel,
                 call_parameters.stream_id,
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )
             await on_new_message(message)
+
+    async def handle_disconnect(
+        self,
+        channel_websocket: Websocket,
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+        tts_engine: TTSEngine,
+        call_parameters: CallParameters,
+    ) -> None:
+        """Handle disconnection from the channel."""
+        output_channel = self.create_output_channel(channel_websocket, tts_engine)
+        message = UserMessage(
+            text=USER_CONVERSATION_SESSION_END,
+            output_channel=output_channel,
+            sender_id=call_parameters.stream_id,
+            input_channel=self.name(),
+        )
+        await on_new_message(message)

rasa/core/concurrent_lock_store.py

@@ -1,9 +1,10 @@
 import json
-import logging
 import time
 from collections import deque
 from typing import Deque, Optional, Text
 
+import structlog
+
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
     DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
@@ -19,7 +20,7 @@ DEFAULT_PORT = 6379
 
 DEFAULT_HOSTNAME = "localhost"
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.getLogger(__name__)
 
 LAST_ISSUED_TICKET_NUMBER_SUFFIX = "last_issued_ticket_number"
 
@@ -105,7 +106,10 @@ class ConcurrentRedisLockStore(LockStore):
 
         self.key_prefix = DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
         if key_prefix:
-            logger.debug(f"Setting non-default redis key prefix: '{key_prefix}'.")
+            structlogger.debug(
+                "concurrent_redis_lock_store._set_key_prefix.non_default_key_prefix",
+                event_info=f"Setting non-default redis key prefix: '{key_prefix}'.",
+            )
             self._set_key_prefix(key_prefix)
 
         super().__init__()
@@ -116,9 +120,13 @@ class ConcurrentRedisLockStore(LockStore):
                 key_prefix + ":" + DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
             )
         else:
-            logger.warning(
-                f"Omitting provided non-alphanumeric redis key prefix: '{key_prefix}'. "
-                f"Using default '{self.key_prefix}' instead."
+            structlogger.warning(
+                "concurrent_redis_lock_store._set_key_prefix.default_instead_of_invalid_key_prefix",
+                event_info=(
+                    f"Omitting provided non-alphanumeric "
+                    f"redis key prefix: '{key_prefix}'. "
+                    f"Using default '{self.key_prefix}' instead."
+                ),
             )
 
     def issue_ticket(
@@ -129,7 +137,10 @@ class ConcurrentRedisLockStore(LockStore):
         It's configured with `lock_lifetime` and associated with `conversation_id`.
         Creates a new lock if none is found.
         """
-        logger.debug(f"Issuing ticket for conversation '{conversation_id}'.")
+        structlogger.debug(
+            "concurrent_redis_lock_store.issue_ticket",
+            event_info=f"Issuing ticket for conversation '{conversation_id}'.",
+        )
         try:
             lock = self.get_or_create_lock(conversation_id)
             lock.remove_expired_tickets()
@@ -164,9 +175,12 @@ class ConcurrentRedisLockStore(LockStore):
         redis_keys = self.red.keys(pattern)
 
         if not redis_keys:
-            logger.debug(
-                f"The lock store does not contain any key-value "
-                f"items for conversation '{conversation_id}'."
+            structlogger.debug(
+                "concurrent_redis_lock_store.delete_lock_key_not_found",
+                event_info=(
+                    f"The lock store does not contain any key-value "
+                    f"items for conversation '{conversation_id}'."
+                ),
             )
             return None