rasa-pro 3.10.16__py3-none-any.whl → 3.11.0__py3-none-any.whl

rasa/core/channels/{audiocodes.py → voice_ready/audiocodes.py}

@@ -1,32 +1,59 @@
 import copy
-import datetime
+from datetime import datetime, timezone, timedelta
 import json
-import logging
 import uuid
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
+from dataclasses import asdict
 
 import structlog
 from jsonschema import ValidationError, validate
 from rasa.core import jobs
 from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
-from rasa.core.channels.voice_aware.utils import validate_voice_license_scope
+from rasa.core.channels.voice_ready.utils import (
+    validate_voice_license_scope,
+    CallParameters,
+)
 from rasa.shared.constants import INTENT_MESSAGE_PREFIX
+from rasa.shared.core.constants import USER_INTENT_SESSION_START
 from rasa.shared.exceptions import RasaException
 from sanic import Blueprint, response
 from sanic.exceptions import NotFound, SanicException, ServerError
 from sanic.request import Request
 from sanic.response import HTTPResponse
 
+from rasa.utils.io import remove_emojis
 
-logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
 CHANNEL_NAME = "audiocodes"
 KEEP_ALIVE_SECONDS = 120
 KEEP_ALIVE_EXPIRATION_FACTOR = 1.5
-
-
-class Unauthorized(SanicException):
+EVENT_START = "start"
+EVENT_DTMF = "DTMF"
+ACTIVITY_MESSAGE = "message"
+ACTIVITY_EVENT = "event"
+INFO_UNKNOWN = "unknown"
+ACTIVITY_ID_KEY = "id"
+CREDENTIALS_TOKEN_KEY = "token"
+CREDENTIALS_USE_WEBSOCKET_KEY = "use_websocket"
+CREDENTIALS_KEEP_ALIVE_KEY = "keep_alive"
+CREDENTIALS_KEEP_ALIVE_EXPIRATION_FACTOR_KEY = "keep_alive_expiration_factor"
+CLEANUP_INTERVAL_MINUTES = 10
+
+
+def map_call_params(parameters: Dict[Text, Any]) -> CallParameters:
+    """Map the Audiocodes parameters to the CallParameters dataclass."""
+    return CallParameters(
+        call_id=parameters.get("vaigConversationId"),
+        user_phone=parameters.get("callee"),
+        bot_phone=parameters.get("caller"),
+        user_name=parameters.get("callerDisplayName"),
+        user_host=parameters.get("callerHost"),
+        bot_host=parameters.get("calleeHost"),
+    )
+
+
+class HttpUnauthorized(SanicException):
     """**Status**: 401 Not Authorized."""
 
     status_code = 401
@@ -41,30 +68,43 @@ class Conversation:
         self.update()
 
     def update(self) -> None:
-        self.last_activity: datetime.datetime = datetime.datetime.utcnow()
+        """Update the last activity time."""
+        self.last_activity: datetime = datetime.now(timezone.utc)
 
     @staticmethod
     def get_metadata(activity: Dict[Text, Any]) -> Optional[Dict[Text, Any]]:
-        return activity.get("parameters")
+        """Get metadata from the activity."""
+        return asdict(map_call_params(activity["parameters"]))
 
     @staticmethod
     def _handle_event(event: Dict[Text, Any]) -> Text:
-        text = f'{INTENT_MESSAGE_PREFIX}vaig_event_{event["name"]}'
-        event_params = {}
-        if "parameters" in event:
-            event_params.update(event["parameters"])
-        if "value" in event:
-            event_params.update({"value": event["value"]})
-        if len(event_params) > 0:
+        """Handle start and DTMF event and return the corresponding text."""
+        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 ""
+
+        if event["name"] == EVENT_START:
+            text = f"{INTENT_MESSAGE_PREFIX}{USER_INTENT_SESSION_START}"
+        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 ""
+
         return text
 
-    def is_active_conversation(
-        self, now: datetime.datetime, delta: datetime.timedelta
-    ) -> bool:
+    def is_active_conversation(self, now: datetime, delta: timedelta) -> bool:
+        """Check if the conversation is active."""
         if now - self.last_activity > delta:
-            logger.warning(
-                f"Conversation {self.conversation_id} is invalid due to inactivity"
+            structlogger.warning(
+                "audiocodes.conversation.inactive", conversation=self.conversation_id
             )
             return False
         return True
@@ -75,24 +115,25 @@ class Conversation:
         output_channel: OutputChannel,
         on_new_message: Callable[[UserMessage], Awaitable[Any]],
     ) -> None:
-        logger.debug("(handle_activities) --- Activities:")
+        """Handle activities sent by Audiocodes."""
+        structlogger.debug("audiocodes.handle.activities")
         for activity in message["activities"]:
             text = None
-            if activity["id"] in self.activity_ids:
-                logger.warning(
-                    "Got activity that already handled. Activity ID:"
-                    f' {activity["id"]}'
+            if activity[ACTIVITY_ID_KEY] in self.activity_ids:
+                structlogger.warning(
+                    "audiocodes.handle.activities.duplicate_activity",
+                    activity_id=activity[ACTIVITY_ID_KEY],
                 )
                 continue
-            self.activity_ids.append(activity["id"])
-            if activity["type"] == "message":
+            self.activity_ids.append(activity[ACTIVITY_ID_KEY])
+            if activity["type"] == ACTIVITY_MESSAGE:
                 text = activity["text"]
-            elif activity["type"] == "event":
+            elif activity["type"] == ACTIVITY_EVENT:
                 text = self._handle_event(activity)
             else:
-                logger.warning(
-                    "Received an activity from audiocodes that we can not "
-                    f"handle. Activity: {activity}"
+                structlogger.warning(
+                    "audiocodes.handle.activities.unknown_activity_type",
+                    activity=activity,
                 )
             if not text:
                 continue
@@ -111,13 +152,14 @@ class Conversation:
                 elif isinstance(user_msg.text, str):
                     anonymized_info = user_msg.text
                 else:
-                    anonymized_info = "unknown"
+                    anonymized_info = INFO_UNKNOWN
 
                 structlogger.exception(
                     "audiocodes.handle.activities.failure",
                     user_message=copy.deepcopy(anonymized_info),
+                    error=e,
+                    exc_info=True,
                 )
-                logger.debug(e, exc_info=True)
 
                 await output_channel.send_custom_json(
                     self.conversation_id,
@@ -158,11 +200,12 @@ class AudiocodesInput(InputChannel):
             raise RasaException(f"Invalid credentials: {e.message}")
 
         return cls(
-            credentials.get("token", ""),
-            credentials.get("use_websocket", True),
-            credentials.get("keep_alive", KEEP_ALIVE_SECONDS),
+            credentials.get(CREDENTIALS_TOKEN_KEY, ""),
+            credentials.get(CREDENTIALS_USE_WEBSOCKET_KEY, True),
+            credentials.get(CREDENTIALS_KEEP_ALIVE_KEY, KEEP_ALIVE_SECONDS),
             credentials.get(
-                "keep_alive_expiration_factor", KEEP_ALIVE_EXPIRATION_FACTOR
+                CREDENTIALS_KEEP_ALIVE_EXPIRATION_FACTOR_KEY,
+                KEEP_ALIVE_EXPIRATION_FACTOR,
             ),
         )
 
@@ -185,12 +228,12 @@ class AudiocodesInput(InputChannel):
         if self.scheduler_job:
             self.scheduler_job.remove()
         self.scheduler_job = (await jobs.scheduler()).add_job(
-            self.clean_old_conversations, "interval", minutes=10
+            self.clean_old_conversations, "interval", minutes=CLEANUP_INTERVAL_MINUTES
         )
 
     def _check_token(self, token: Optional[Text]) -> None:
         if not token:
-            raise Unauthorized("Authentication token required.")
+            raise HttpUnauthorized("Authentication token required.")
 
     def _get_conversation(
         self, token: Optional[Text], conversation_id: Text
@@ -203,14 +246,11 @@ class AudiocodesInput(InputChannel):
         return conversation
 
     def clean_old_conversations(self) -> None:
-        logger.debug(
-            "Performing clean old conversations, current number:"
-            f" {len(self.conversations)}"
-        )
-        now = datetime.datetime.utcnow()
-        delta = datetime.timedelta(
-            seconds=self.keep_alive * self.keep_alive_expiration_factor
+        structlogger.debug(
+            "audiocodes.clean_old_conversations", current_number=len(self.conversations)
         )
+        now = datetime.now(timezone.utc)
+        delta = timedelta(seconds=self.keep_alive * self.keep_alive_expiration_factor)
         self.conversations = {
             k: v
             for k, v in self.conversations.items()
@@ -221,9 +261,8 @@ class AudiocodesInput(InputChannel):
         conversation_id = body["conversation"]
         if conversation_id in self.conversations:
             raise ServerError("Conversation already exists")
-        logger.debug(
-            "(handle_start_conversation) --- New Conversation has arrived."
-            f" Conversation: {conversation_id}"
+        structlogger.debug(
+            "audiocodes.handle_start_conversation", conversation=conversation_id
         )
         self.conversations[conversation_id] = Conversation(conversation_id)
         urls = {
@@ -248,16 +287,15 @@ class AudiocodesInput(InputChannel):
             """Triggered on new websocket connection."""
             if self.use_websocket is False:
                 raise ConnectionRefusedError("websocket is unavailable")
-            logger.debug(
-                "(new_client_connection) --- New client is trying to connect."
-                f" Conversation: {conversation_id}"
+            structlogger.debug(
+                "audiocodes.new_client_connection", conversation=conversation_id
             )
             conversation = self._get_conversation(request.token, conversation_id)
             if conversation:
                 if conversation.ws:
-                    logger.debug(
-                        "(new_client_connection) --- The client was already connected."
-                        f" Conversation: {conversation_id}"
+                    structlogger.debug(
+                        "audiocodes.new_client_connection.already_connected",
+                        conversation=conversation_id,
                     )
                 else:
                     conversation.ws = ws
@@ -265,11 +303,9 @@ class AudiocodesInput(InputChannel):
             try:
                 await ws.recv()
             except Exception:
-                logger.debug(
-                    (
-                        "(new_client_connection) --- Websocket was closed by client: "
-                        f"{conversation_id}"
-                    )
+                structlogger.warning(
+                    "audiocodes.new_client_connection.closed",
+                    conversation=conversation_id,
                 )
                 if conversation:
                     conversation.ws = None
@@ -308,10 +344,7 @@ class AudiocodesInput(InputChannel):
             Example of payload:
             {"conversation": <conversation_id>, "activities": List[Activity]}.
             """
-            logger.debug(
-                "(on_activities) --- New activities from the user. Conversation: "
-                f"{conversation_id}"
-            )
+            structlogger.debug("audiocodes.on_activities", conversation=conversation_id)
             conversation = self._get_conversation(request.token, conversation_id)
             if conversation is None:
                 return response.json({})
@@ -350,16 +383,21 @@ 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}vaig_event_end{reason}",
+                    text=f"{INTENT_MESSAGE_PREFIX}session_end",
                     output_channel=None,
                     sender_id=conversation_id,
+                    metadata=reason,
                 )
             )
             del self.conversations[conversation_id]
-            logger.debug("(disconnect) --- Conversation was deleted")
+            structlogger.debug(
+                "audiocodes.disconnect",
+                conversation=conversation_id,
+                request=request.json,
+            )
             return response.json({})
 
         @ac_webhook.route("/conversation/<conversation_id>/keepalive", methods=["POST"])
@@ -397,7 +435,7 @@ class AudiocodesOutput(OutputChannel):
         )
         message.update(
             {
-                "timestamp": datetime.datetime.utcnow().isoformat("T")[:-3] + "Z",
+                "timestamp": datetime.now(timezone.utc).isoformat("T")[:-3] + "Z",
                 "id": str(uuid.uuid4()),
             }
         )
@@ -411,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(
@@ -429,6 +468,20 @@ class AudiocodesOutput(OutputChannel):
         """Send an activity."""
         await self.add_message(json_message)
 
+    async def hangup(self, recipient_id: Text, **kwargs: Any) -> None:
+        """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_aware → voice_ready}/jambonz.py

@@ -1,26 +1,29 @@
-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
-from rasa.core.channels.voice_aware.jambonz_protocol import (
+from rasa.core.channels.voice_ready.jambonz_protocol import (
     send_ws_text_message,
     websocket_message_handler,
+    send_ws_hangup_message,
 )
-from rasa.core.channels.voice_aware.utils import validate_voice_license_scope
+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_experimental_feature
-
+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
+
 
-class JambonzVoiceAwareInput(InputChannel):
+class JambonzVoiceReadyInput(InputChannel):
     """Connector for the Jambonz platform."""
 
     @classmethod
@@ -32,8 +35,8 @@ class JambonzVoiceAwareInput(InputChannel):
         return cls()
 
     def __init__(self) -> None:
-        """Initializes the JambonzVoiceAwareInput channel."""
-        mark_as_experimental_feature("Jambonz Channel")
+        """Initializes the JambonzVoiceReadyInput channel."""
+        mark_as_beta_feature("Jambonz Channel")
         validate_voice_license_scope()
 
     def blueprint(
@@ -84,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(
@@ -101,3 +105,17 @@ class JambonzWebsocketOutput(OutputChannel):
     ) -> None:
         """Send an activity."""
         await self.add_message(json_message)
+
+    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_aware → voice_ready}/jambonz_protocol.py

@@ -5,6 +5,8 @@ from typing import Any, Awaitable, Callable, Dict, List, Text
 
 import structlog
 from rasa.core.channels.channel import UserMessage
+from rasa.core.channels.voice_ready.utils import CallParameters
+from dataclasses import asdict
 from sanic import Websocket  # type: ignore[attr-defined]
 
 
@@ -17,12 +19,20 @@ class NewSessionMessage:
 
     call_sid: str
     message_id: str
+    call_params: CallParameters
 
     @staticmethod
     def from_message(message: Dict[str, Any]) -> "NewSessionMessage":
+        structlogger.debug("jambonz.websocket.message.new_session", message=message)
+        call_params = CallParameters(
+            call_id=message.get("call_sid"),
+            user_phone=message.get("data", {}).get("from"),
+            bot_phone=message.get("data", {}).get("to"),
+        )
         return NewSessionMessage(
             message.get("call_sid"),
             message.get("msgid"),
+            call_params,
         )
 
 
@@ -82,6 +92,10 @@ class CallStatusChanged:
 
     @staticmethod
     def from_message(message: Dict[str, Any]) -> "CallStatusChanged":
+        structlogger.debug(
+            "jambonz.websocket.message.call_status_changed",
+            message=message,
+        )
         return CallStatusChanged(
             message.get("call_sid"), message.get("data", {}).get("call_status")
         )
@@ -145,7 +159,7 @@ async def websocket_message_handler(
         await handle_session_reconnect(session_reconnect)
     elif message.get("type") == "call:status":
         call_status = CallStatusChanged.from_message(message)
-        await handle_call_status(call_status)
+        await handle_call_status(call_status, on_new_message, ws)
     elif message.get("type") == "verb:hook" and message.get("hook") == "/gather":
         hook_trigger_reason = message.get("data", {}).get("reason")
 
@@ -184,7 +198,7 @@ async def handle_new_session(
     ws: Websocket,
 ) -> None:
     """Handle new session message."""
-    from rasa.core.channels.voice_aware.jambonz import JambonzWebsocketOutput
+    from rasa.core.channels.voice_ready.jambonz import JambonzWebsocketOutput
 
     structlogger.debug("jambonz.websocket.message.new_call", call_sid=message.call_sid)
     output_channel = JambonzWebsocketOutput(ws, message.call_sid)
@@ -192,7 +206,7 @@ async def handle_new_session(
         text="/session_start",
         output_channel=output_channel,
         sender_id=message.call_sid,
-        metadata={},
+        metadata=asdict(message.call_params),
     )
     await send_config_ack(message.message_id, ws)
     await on_new_message(user_msg)
@@ -208,7 +222,7 @@ async def handle_gather_completed(
 
     This includes results of gather calles with their transcription.
     """
-    from rasa.core.channels.voice_aware.jambonz import JambonzWebsocketOutput
+    from rasa.core.channels.voice_ready.jambonz import JambonzWebsocketOutput
 
     if not transcript_result.is_final:
         # in case of a non final transcript, we are going to wait for the final
@@ -256,7 +270,11 @@ async def handle_gather_timeout(gather_timeout: GatherTimeout, ws: Websocket) ->
     await send_gather_input(ws)
 
 
-async def handle_call_status(call_status: CallStatusChanged) -> None:
+async def handle_call_status(
+    call_status: CallStatusChanged,
+    on_new_message: Callable[[UserMessage], Awaitable[Any]],
+    ws: Websocket,
+) -> None:
     """Handle changes in the call status."""
     structlogger.debug(
         "jambonz.websocket.message.call_status_changed",
@@ -264,6 +282,19 @@ async def handle_call_status(call_status: CallStatusChanged) -> None:
         message=call_status.status,
     )
 
+    if call_status.status == "completed":
+        structlogger.debug("jambonz.websocket.message.call_completed")
+        from rasa.core.channels.voice_ready.jambonz import JambonzWebsocketOutput
+
+        output_channel = JambonzWebsocketOutput(ws, call_status.call_sid)
+        user_msg = UserMessage(
+            text="/session_end",
+            output_channel=output_channel,
+            sender_id=call_status.call_sid,
+            metadata={},
+        )
+        await on_new_message(user_msg)
+
 
 async def handle_session_reconnect(session_reconnect: SessionReconnect) -> None:
     """Handle session reconnect message."""
@@ -301,6 +332,7 @@ async def send_config_ack(message_id: str, ws: Websocket) -> None:
 
 async def send_gather_input(ws: Websocket) -> None:
     """Send a gather input command to jambonz."""
+    structlogger.debug("jambonz.websocket.send.gather")
     await ws.send(
         json.dumps(
             {
@@ -342,3 +374,23 @@ async def send_ws_text_message(ws: Websocket, text: Text) -> None:
             }
         )
     )
+
+
+async def send_ws_hangup_message(hangup_delay_seconds: int, ws: Websocket) -> None:
+    """Send a hangup message to the websocket using the jambonz interface."""
+    structlogger.debug("jambonz.websocket.send.hangup")
+    await ws.send(
+        json.dumps(
+            {
+                "type": "command",
+                "command": "redirect",
+                "queueCommand": True,
+                "data": [
+                    {"pause": {"length": hangup_delay_seconds}},
+                    {
+                        "hangup": {},
+                    },
+                ],
+            }
+        )
+    )