rasa-pro 3.11.7__py3-none-any.whl → 3.11.9__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

@@ -96,10 +96,13 @@ class Conversation:
             event_params = {"value": event["value"]}
             text += json.dumps(event_params)
         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']}"
+            event_params = {**event.get("parameters", {})}
+            if "value" in event:
+                event_params["value"] = event["value"]
+            text += json.dumps(event_params)
 
         return text
 

rasa/core/channels/voice_ready/jambonz.py

@@ -1,25 +1,30 @@
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
 
 import structlog
-from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
+from sanic import Blueprint, Websocket, response  # type: ignore[attr-defined]
+from sanic.request import Request
+from sanic.response import HTTPResponse
+
+from rasa.core.channels.channel import (
+    InputChannel,
+    OutputChannel,
+    UserMessage,
+    requires_basic_auth,
+)
 from rasa.core.channels.voice_ready.jambonz_protocol import (
+    CHANNEL_NAME,
     send_ws_text_message,
     websocket_message_handler,
     send_ws_hangup_message,
 )
 from rasa.core.channels.voice_ready.utils import validate_voice_license_scope
 from rasa.shared.exceptions import RasaException
-from sanic import Blueprint, response, Websocket  # type: ignore[attr-defined]
-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()
 
-CHANNEL_NAME = "jambonz"
-
 DEFAULT_HANGUP_DELAY_SECONDS = 1
 
 
@@ -32,12 +37,27 @@ class JambonzVoiceReadyInput(InputChannel):
 
     @classmethod
     def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
-        return cls()
+        if not credentials:
+            return cls()
+
+        username = credentials.get("username")
+        password = credentials.get("password")
+        if (username is None) != (password is None):
+            raise RasaException(
+                "In Jambonz channel, either both username and password "
+                "or neither should be provided. "
+            )
 
-    def __init__(self) -> None:
+        return cls(username, password)
+
+    def __init__(
+        self, username: Optional[Text] = None, password: Optional[Text] = None
+    ) -> None:
         """Initializes the JambonzVoiceReadyInput channel."""
         mark_as_beta_feature("Jambonz Channel")
         validate_voice_license_scope()
+        self.username = username
+        self.password = password
 
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
@@ -50,6 +70,7 @@ class JambonzVoiceReadyInput(InputChannel):
             return response.json({"status": "ok"})
 
         @jambonz_webhook.websocket("/websocket", subprotocols=["ws.jambonz.org"])  # type: ignore
+        @requires_basic_auth(self.username, self.password)
         async def websocket(request: Request, ws: Websocket) -> None:
             """Triggered on new websocket connection."""
             async for message in ws:

rasa/core/channels/voice_ready/jambonz_protocol.py

@@ -11,6 +11,7 @@ from sanic import Websocket  # type: ignore[attr-defined]
 
 
 structlogger = structlog.get_logger()
+CHANNEL_NAME = "jambonz"
 
 
 @dataclass
@@ -207,6 +208,7 @@ async def handle_new_session(
         output_channel=output_channel,
         sender_id=message.call_sid,
         metadata=asdict(message.call_params),
+        input_channel=CHANNEL_NAME,
     )
     await send_config_ack(message.message_id, ws)
     await on_new_message(user_msg)
@@ -239,6 +241,7 @@ async def handle_gather_completed(
         output_channel = JambonzWebsocketOutput(ws, transcript_result.call_sid)
         user_msg = UserMessage(
             text=most_likely_transcript.text,
+            input_channel=CHANNEL_NAME,
             output_channel=output_channel,
             sender_id=transcript_result.call_sid,
             metadata={},
@@ -289,6 +292,7 @@ async def handle_call_status(
         output_channel = JambonzWebsocketOutput(ws, call_status.call_sid)
         user_msg = UserMessage(
             text="/session_end",
+            input_channel=CHANNEL_NAME,
             output_channel=output_channel,
             sender_id=call_status.call_sid,
             metadata={},

rasa/core/channels/voice_ready/twilio_voice.py

@@ -1,25 +1,31 @@
+from dataclasses import asdict
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
+
+import structlog
 from sanic import Blueprint, response
 from sanic.request import Request, RequestParameters
 from sanic.response import HTTPResponse
-from twilio.twiml.voice_response import VoiceResponse, Gather
-from typing import Text, Callable, Awaitable, List, Any, Dict, Optional
-from dataclasses import asdict
+from twilio.twiml.voice_response import Gather, VoiceResponse
 
-import structlog
-import rasa.utils.io
 import rasa.shared.utils.io
-from rasa.shared.core.events import BotUttered
-from rasa.shared.exceptions import InvalidConfigException
+import rasa.utils.io
 from rasa.core.channels.channel import (
-    InputChannel,
     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, 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(
@@ -119,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",
@@ -128,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__(
@@ -137,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.
 
@@ -152,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()
 
@@ -160,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:
@@ -245,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")
@@ -309,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
@@ -328,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):
@@ -346,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/asr/asr_event.py

@@ -16,3 +16,8 @@ class NewTranscript(ASREvent):
 @dataclass
 class UserIsSpeaking(ASREvent):
     pass
+
+
+@dataclass
+class UserSilence(ASREvent):
+    pass

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

@@ -1,6 +1,6 @@
 import os
-from typing import AsyncIterator, Dict, Optional
 from dataclasses import dataclass
+from typing import AsyncIterator, Dict, Optional
 
 import aiohttp
 import structlog
@@ -15,7 +15,6 @@ from rasa.core.channels.voice_stream.tts.tts_engine import (
 from rasa.shared.constants import AZURE_SPEECH_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
-
 structlogger = structlog.get_logger()
 
 
@@ -54,13 +53,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:
@@ -98,7 +106,7 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
             language="en-US",
             voice="en-US-JennyNeural",
             timeout=10,
-            speech_region="germanywestcentral",
+            speech_region="eastus",
         )
 
     @classmethod

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -1,31 +1,54 @@
+from __future__ import annotations
+
 import base64
 import json
 import uuid
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Optional, Text, Tuple
 
 import structlog
-from typing import Any, Awaitable, Callable, Dict, Optional, Text, Tuple
-
-from sanic import Blueprint, HTTPResponse, Request, response
-from sanic import Websocket  # type: ignore
-
+from sanic import (  # type: ignore[attr-defined]
+    Blueprint,
+    HTTPResponse,
+    Request,
+    Websocket,
+    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
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
-from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.voice_channel import (
+    ContinueConversationAction,
     EndConversationAction,
     NewAudioAction,
     VoiceChannelAction,
-    ContinueConversationAction,
     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"]
@@ -74,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"
@@ -126,16 +183,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:
@@ -147,22 +194,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")
 
@@ -171,3 +216,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