rasa-pro 3.9.18__py3-none-any.whl → 3.10.4__py3-none-any.whl

rasa/core/agent.py

@@ -1,38 +1,42 @@
 from __future__ import annotations
-from asyncio import AbstractEventLoop, CancelledError
+
 import functools
 import logging
 import os
+import uuid
+from asyncio import AbstractEventLoop, CancelledError
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Text, Union
-import uuid
 
 import aiohttp
 from aiohttp import ClientError
 
+import rasa.shared.utils.io
 from rasa.core import jobs
 from rasa.core.channels.channel import OutputChannel, UserMessage
 from rasa.core.constants import DEFAULT_REQUEST_TIMEOUT
-from rasa.core.http_interpreter import RasaNLUHttpInterpreter
-from rasa.shared.core.domain import Domain
 from rasa.core.exceptions import AgentNotReady
-from rasa.shared.constants import DEFAULT_SENDER_ID
+from rasa.core.http_interpreter import RasaNLUHttpInterpreter
 from rasa.core.lock_store import InMemoryLockStore, LockStore
 from rasa.core.nlg import NaturalLanguageGenerator, TemplatedNaturalLanguageGenerator
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.core.processor import MessageProcessor
-from rasa.core.tracker_store import FailSafeTrackerStore, InMemoryTrackerStore
-from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
+from rasa.core.tracker_store import (
+    FailSafeTrackerStore,
+    InMemoryTrackerStore,
+    TrackerStore,
+)
+from rasa.core.utils import AvailableEndpoints
 from rasa.exceptions import ModelNotFound
+from rasa.nlu.persistor import StorageType
 from rasa.nlu.utils import is_url
+from rasa.shared.constants import DEFAULT_SENDER_ID
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
 from rasa.shared.exceptions import RasaException
-import rasa.shared.utils.io
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
 
-from rasa.core.tracker_store import TrackerStore
-from rasa.core.utils import AvailableEndpoints
-
 logger = logging.getLogger(__name__)
 
 
@@ -194,7 +198,7 @@ async def _schedule_model_pulling(
 async def load_agent(
     model_path: Optional[Text] = None,
     model_server: Optional[EndpointConfig] = None,
-    remote_storage: Optional[Text] = None,
+    remote_storage: Optional[StorageType] = None,
     endpoints: Optional[AvailableEndpoints] = None,
     loop: Optional[AbstractEventLoop] = None,
 ) -> Agent:
@@ -203,15 +207,15 @@ async def load_agent(
     Args:
         model_path: Path to the model if it's on disk.
         model_server: Configuration for a potential server which serves the model.
-        remote_storage: URL of remote storage for model.
+        remote_storage: Remote storage to use for loading the model.
         endpoints: Endpoint configuration.
         loop: Optional async loop to pass to broker creation.
 
     Returns:
         The instantiated `Agent` or `None`.
     """
-    from rasa.core.tracker_store import TrackerStore
     from rasa.core.brokers.broker import EventBroker
+    from rasa.core.tracker_store import TrackerStore
 
     tracker_store = None
     lock_store = None
@@ -299,7 +303,7 @@ class Agent:
         action_endpoint: Optional[EndpointConfig] = None,
         fingerprint: Optional[Text] = None,
         model_server: Optional[EndpointConfig] = None,
-        remote_storage: Optional[Text] = None,
+        remote_storage: Optional[StorageType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional[AvailableEndpoints] = None,
     ):
@@ -329,11 +333,11 @@ class Agent:
         action_endpoint: Optional[EndpointConfig] = None,
         fingerprint: Optional[Text] = None,
         model_server: Optional[EndpointConfig] = None,
-        remote_storage: Optional[Text] = None,
+        remote_storage: Optional[StorageType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional[AvailableEndpoints] = None,
     ) -> Agent:
-        """Constructs a new agent and loads the processer and model."""
+        """Constructs a new agent and loads the processor and model."""
         agent = Agent(
             domain=domain,
             generator=generator,

rasa/core/channels/__init__.py

@@ -22,6 +22,7 @@ from rasa.core.channels.slack import SlackInput
 from rasa.core.channels.telegram import TelegramInput
 from rasa.core.channels.twilio import TwilioInput
 from rasa.core.channels.twilio_voice import TwilioVoiceInput
+from rasa.core.channels.voice_aware.jambonz import JambonzVoiceAwareInput
 from rasa.core.channels.webexteams import WebexTeamsInput
 from rasa.core.channels.hangouts import HangoutsInput
 from rasa.core.channels.audiocodes import AudiocodesInput
@@ -47,6 +48,7 @@ input_channel_classes: List[Type[InputChannel]] = [
     AudiocodesInput,
     DevelopmentInspectInput,
     CVGInput,
+    JambonzVoiceAwareInput,
 ]
 
 # Mapping from an input channel name to its class to allow name based lookup.

rasa/core/channels/audiocodes.py

@@ -9,6 +9,7 @@ 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.shared.constants import INTENT_MESSAGE_PREFIX
 from rasa.shared.exceptions import RasaException
 from sanic import Blueprint, response
@@ -16,11 +17,6 @@ from sanic.exceptions import NotFound, SanicException, ServerError
 from sanic.request import Request
 from sanic.response import HTTPResponse
 
-from rasa.utils.licensing import (
-    PRODUCT_AREA,
-    VOICE_SCOPE,
-    validate_license_from_env,
-)
 
 logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
@@ -30,17 +26,6 @@ KEEP_ALIVE_SECONDS = 120
 KEEP_ALIVE_EXPIRATION_FACTOR = 1.5
 
 
-def validate_voice_license_scope() -> None:
-    """Validate that the correct license scope is present."""
-    logger.info(
-        f"Validating current Rasa Pro license scope which must include "
-        f"the '{VOICE_SCOPE}' scope to use the voice channel."
-    )
-
-    voice_product_scope = PRODUCT_AREA + " " + VOICE_SCOPE
-    validate_license_from_env(product_area=voice_product_scope)
-
-
 class Unauthorized(SanicException):
     """**Status**: 401 Not Authorized."""
 

rasa/core/channels/inspector/dist/index.html

@@ -17,7 +17,6 @@
   <script>
     const chatDiv = document.getElementById("rasa-chat-widget");
     const websocketUrl = window.location.origin.replace("http", "ws");
-    const initialPayload = "/session_start";
     const maxHeight = document.documentElement.scrollHeight - 130;
     // 21 and 25 are the rem number we're using for the columns. We add 0.75rem for the padding
     // A potential improvement would be to add a onresize event for both width and height
@@ -29,7 +28,6 @@
     const columnWidth = remReference * parseFloat(getComputedStyle(document.documentElement).fontSize);
 
     chatDiv.setAttribute("data-websocket-url", websocketUrl);
-    chatDiv.setAttribute("data-initial-payload", initialPayload);
     chatDiv.setAttribute("data-close-on-outside-click", false);
     chatDiv.setAttribute("data-height", maxHeight);
     chatDiv.setAttribute("data-width", columnWidth);

rasa/core/channels/inspector/index.html

@@ -15,7 +15,6 @@
   <script>
     const chatDiv = document.getElementById("rasa-chat-widget");
     const websocketUrl = window.location.origin.replace("http", "ws");
-    const initialPayload = "/session_start";
     const maxHeight = document.documentElement.scrollHeight - 130;
     // 21 and 25 are the rem number we're using for the columns. We add 0.75rem for the padding
     // A potential improvement would be to add a onresize event for both width and height
@@ -27,7 +26,6 @@
     const columnWidth = remReference * parseFloat(getComputedStyle(document.documentElement).fontSize);
 
     chatDiv.setAttribute("data-websocket-url", websocketUrl);
-    chatDiv.setAttribute("data-initial-payload", initialPayload);
     chatDiv.setAttribute("data-close-on-outside-click", false);
     chatDiv.setAttribute("data-height", maxHeight);
     chatDiv.setAttribute("data-width", columnWidth);

rasa/core/channels/voice_aware/jambonz.py

@@ -0,0 +1,103 @@
+from typing import Any, Awaitable, Callable, Dict, Optional, Text
+
+import structlog
+from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
+from rasa.core.channels.voice_aware.jambonz_protocol import (
+    send_ws_text_message,
+    websocket_message_handler,
+)
+from rasa.core.channels.voice_aware.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
+
+
+structlogger = structlog.get_logger()
+
+CHANNEL_NAME = "jambonz"
+
+
+class JambonzVoiceAwareInput(InputChannel):
+    """Connector for the Jambonz platform."""
+
+    @classmethod
+    def name(cls) -> Text:
+        return CHANNEL_NAME
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
+        return cls()
+
+    def __init__(self) -> None:
+        """Initializes the JambonzVoiceAwareInput channel."""
+        mark_as_experimental_feature("Jambonz Channel")
+        validate_voice_license_scope()
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> Blueprint:
+        jambonz_webhook = Blueprint("jambonz_webhook", __name__)
+
+        @jambonz_webhook.route("/", methods=["GET"])
+        async def health(request: Request) -> HTTPResponse:
+            """Server health route."""
+            return response.json({"status": "ok"})
+
+        @jambonz_webhook.websocket("/websocket", subprotocols=["ws.jambonz.org"])  # type: ignore
+        async def websocket(request: Request, ws: Websocket) -> None:
+            """Triggered on new websocket connection."""
+            async for message in ws:
+                await websocket_message_handler(message, on_new_message, ws)
+
+        return jambonz_webhook
+
+
+class JambonzWebsocketOutput(OutputChannel):
+    @classmethod
+    def name(cls) -> Text:
+        return CHANNEL_NAME
+
+    def __init__(self, ws: Any, conversation_id: Text) -> None:
+        self.ws = ws
+        self.conversation_id = conversation_id
+
+    async def add_message(self, message: Dict) -> None:
+        """Add metadata and add message.
+
+        Message is added to the list of
+        activities to be sent to the Jambonz Websocket server.
+        """
+        text_message = message.get("text", "")
+        structlogger.debug(
+            "jambonz.add.message",
+            class_name=self.__class__.__name__,
+            message=text_message,
+        )
+
+        # send message to jambonz
+        await send_ws_text_message(self.ws, message.get("text"))
+
+    async def send_text_message(
+        self, recipient_id: Text, text: Text, **kwargs: Any
+    ) -> None:
+        """Send a text message."""
+        await self.add_message({"type": "message", "text": text})
+
+    async def send_image_url(
+        self, recipient_id: Text, image: Text, **kwargs: Any
+    ) -> None:
+        raise RasaException("Images are not supported by this channel")
+
+    async def send_attachment(
+        self, recipient_id: Text, attachment: Text, **kwargs: Any
+    ) -> None:
+        raise RasaException("Attachments are not supported by this channel")
+
+    async def send_custom_json(
+        self, recipient_id: Text, json_message: Dict[Text, Any], **kwargs: Any
+    ) -> None:
+        """Send an activity."""
+        await self.add_message(json_message)

rasa/core/channels/voice_aware/jambonz_protocol.py

@@ -0,0 +1,344 @@
+from dataclasses import dataclass, field
+import json
+import uuid
+from typing import Any, Awaitable, Callable, Dict, List, Text
+
+import structlog
+from rasa.core.channels.channel import UserMessage
+from sanic import Websocket  # type: ignore[attr-defined]
+
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class NewSessionMessage:
+    """Message indicating a new session has been started."""
+
+    call_sid: str
+    message_id: str
+
+    @staticmethod
+    def from_message(message: Dict[str, Any]) -> "NewSessionMessage":
+        return NewSessionMessage(
+            message.get("call_sid"),
+            message.get("msgid"),
+        )
+
+
+@dataclass
+class Transcript:
+    """Transcript of a spoken utterance."""
+
+    text: str
+    confidence: float
+
+
+@dataclass
+class TranscriptResult:
+    """Result of an ASR call with potential transcripts."""
+
+    call_sid: str
+    message_id: str
+    is_final: bool
+    transcripts: List[Transcript] = field(default_factory=list)
+
+    @staticmethod
+    def from_speech_result(message: Dict[str, Any]) -> "TranscriptResult":
+        return TranscriptResult(
+            message.get("call_sid"),
+            message.get("msgid"),
+            message.get("data", {}).get("speech", {}).get("is_final", True),
+            transcripts=[
+                Transcript(t.get("transcript", ""), t.get("confidence", 1.0))
+                for t in message.get("data", {})
+                .get("speech", {})
+                .get("alternatives", [])
+            ],
+        )
+
+    @staticmethod
+    def from_dtmf_result(message: Dict[str, Any]) -> "TranscriptResult":
+        """Create a transcript result from a DTMF result.
+
+        We use the dtmf as the text with confidence 1.0
+        """
+        return TranscriptResult(
+            message.get("call_sid"),
+            message.get("msgid"),
+            is_final=True,
+            transcripts=[
+                Transcript(str(message.get("data", {}).get("digits", "")), 1.0)
+            ],
+        )
+
+
+@dataclass
+class CallStatusChanged:
+    """Message indicating a change in the call status."""
+
+    call_sid: str
+    status: str
+
+    @staticmethod
+    def from_message(message: Dict[str, Any]) -> "CallStatusChanged":
+        return CallStatusChanged(
+            message.get("call_sid"), message.get("data", {}).get("call_status")
+        )
+
+
+@dataclass
+class SessionReconnect:
+    """Message indicating a session has reconnected."""
+
+    call_sid: str
+
+    @staticmethod
+    def from_message(message: Dict[str, Any]) -> "SessionReconnect":
+        return SessionReconnect(message.get("call_sid"))
+
+
+@dataclass
+class VerbStatusChanged:
+    """Message indicating a change in the status of a verb."""
+
+    call_sid: str
+    event: str
+    id: str
+    name: str
+
+    @staticmethod
+    def from_message(message: Dict[str, Any]) -> "VerbStatusChanged":
+        return VerbStatusChanged(
+            message.get("call_sid"),
+            message.get("data", {}).get("event"),
+            message.get("data", {}).get("id"),
+            message.get("data", {}).get("name"),
+        )
+
+
+@dataclass
+class GatherTimeout:
+    """Message indicating a gather timeout."""
+
+    call_sid: str
+
+    @staticmethod
+    def from_message(message: Dict[str, Any]) -> "GatherTimeout":
+        return GatherTimeout(message.get("call_sid"))
+
+
+async def websocket_message_handler(
+    message_dump: str,
+    on_new_message: Callable[[UserMessage], Awaitable[Any]],
+    ws: Websocket,
+) -> None:
+    """Handle incoming messages from the websocket."""
+    message = json.loads(message_dump)
+
+    # parse and handle the different message types
+    if message.get("type") == "session:new":
+        new_session = NewSessionMessage.from_message(message)
+        await handle_new_session(new_session, on_new_message, ws)
+    elif message.get("type") == "session:reconnect":
+        session_reconnect = SessionReconnect.from_message(message)
+        await handle_session_reconnect(session_reconnect)
+    elif message.get("type") == "call:status":
+        call_status = CallStatusChanged.from_message(message)
+        await handle_call_status(call_status)
+    elif message.get("type") == "verb:hook" and message.get("hook") == "/gather":
+        hook_trigger_reason = message.get("data", {}).get("reason")
+
+        if hook_trigger_reason == "speechDetected":
+            transcript = TranscriptResult.from_speech_result(message)
+            await handle_gather_completed(transcript, on_new_message, ws)
+        elif hook_trigger_reason == "timeout":
+            gather_timeout = GatherTimeout.from_message(message)
+            await handle_gather_timeout(gather_timeout, ws)
+        elif hook_trigger_reason == "dtmfDetected":
+            # for now, let's handle it as normal user input with a
+            # confidence of 1.0
+            transcript = TranscriptResult.from_dtmf_result(message)
+            await handle_gather_completed(transcript, on_new_message, ws)
+        else:
+            structlogger.debug(
+                "jambonz.websocket.message.verb_hook",
+                call_sid=message.get("call_sid"),
+                reason=hook_trigger_reason,
+                message=message,
+            )
+    elif message.get("type") == "verb:status":
+        verb_status = VerbStatusChanged.from_message(message)
+        await handle_verb_status(verb_status)
+    elif message.get("type") == "jambonz:error":
+        # jambonz ran into a fatal error handling the call. the call will be
+        # terminated.
+        structlogger.error("jambonz.websocket.message.error", message=message)
+    else:
+        structlogger.warning("jambonz.websocket.message.unknown_type", message=message)
+
+
+async def handle_new_session(
+    message: NewSessionMessage,
+    on_new_message: Callable[[UserMessage], Awaitable[Any]],
+    ws: Websocket,
+) -> None:
+    """Handle new session message."""
+    from rasa.core.channels.voice_aware.jambonz import JambonzWebsocketOutput
+
+    structlogger.debug("jambonz.websocket.message.new_call", call_sid=message.call_sid)
+    output_channel = JambonzWebsocketOutput(ws, message.call_sid)
+    user_msg = UserMessage(
+        text="/session_start",
+        output_channel=output_channel,
+        sender_id=message.call_sid,
+        metadata={},
+    )
+    await send_config_ack(message.message_id, ws)
+    await on_new_message(user_msg)
+    await send_gather_input(ws)
+
+
+async def handle_gather_completed(
+    transcript_result: TranscriptResult,
+    on_new_message: Callable[[UserMessage], Awaitable[Any]],
+    ws: Websocket,
+) -> None:
+    """Handle changes to commands we have send to jambonz.
+
+    This includes results of gather calles with their transcription.
+    """
+    from rasa.core.channels.voice_aware.jambonz import JambonzWebsocketOutput
+
+    if not transcript_result.is_final:
+        # in case of a non final transcript, we are going to wait for the final
+        # one and ignore the partial one
+        structlogger.debug(
+            "jambonz.websocket.message.transcript_partial",
+            call_sid=transcript_result.call_sid,
+            number_of_transcripts=len(transcript_result.transcripts),
+        )
+        return
+
+    if transcript_result.transcripts:
+        most_likely_transcript = transcript_result.transcripts[0]
+        output_channel = JambonzWebsocketOutput(ws, transcript_result.call_sid)
+        user_msg = UserMessage(
+            text=most_likely_transcript.text,
+            output_channel=output_channel,
+            sender_id=transcript_result.call_sid,
+            metadata={},
+        )
+        structlogger.debug(
+            "jambonz.websocket.message.transcript",
+            call_sid=transcript_result.call_sid,
+            transcript=most_likely_transcript.text,
+            confidence=most_likely_transcript.confidence,
+            number_of_transcripts=len(transcript_result.transcripts),
+        )
+        await on_new_message(user_msg)
+    else:
+        structlogger.warning(
+            "jambonz.websocket.message.no_transcript",
+            call_sid=transcript_result.call_sid,
+        )
+    await send_gather_input(ws)
+
+
+async def handle_gather_timeout(gather_timeout: GatherTimeout, ws: Websocket) -> None:
+    """Handle gather timeout."""
+    structlogger.debug(
+        "jambonz.websocket.message.gather_timeout",
+        call_sid=gather_timeout.call_sid,
+    )
+    # TODO: figure out how to handle timeouts
+    await send_ws_text_message(ws, "I'm sorry, I didn't catch that.")
+    await send_gather_input(ws)
+
+
+async def handle_call_status(call_status: CallStatusChanged) -> None:
+    """Handle changes in the call status."""
+    structlogger.debug(
+        "jambonz.websocket.message.call_status_changed",
+        call_sid=call_status.call_sid,
+        message=call_status.status,
+    )
+
+
+async def handle_session_reconnect(session_reconnect: SessionReconnect) -> None:
+    """Handle session reconnect message."""
+    # there is nothing we need to do atm when a session reconnects.
+    # this happens if jambonz looses the websocket connection and reconnects
+    structlogger.debug(
+        "jambonz.websocket.message.session_reconnect",
+        call_sid=session_reconnect.call_sid,
+    )
+
+
+async def handle_verb_status(verb_status: VerbStatusChanged) -> None:
+    """Handle changes in the status of a verb."""
+    structlogger.debug(
+        "jambonz.websocket.message.verb_status_changed",
+        call_sid=verb_status.call_sid,
+        event_type=verb_status.event,
+        id=verb_status.id,
+        name=verb_status.name,
+    )
+
+
+async def send_config_ack(message_id: str, ws: Websocket) -> None:
+    """Send an ack message to jambonz including the configuration."""
+    await ws.send(
+        json.dumps(
+            {
+                "type": "ack",
+                "msgid": message_id,
+                "data": [{"config": {"notifyEvents": True}}],
+            }
+        )
+    )
+
+
+async def send_gather_input(ws: Websocket) -> None:
+    """Send a gather input command to jambonz."""
+    await ws.send(
+        json.dumps(
+            {
+                "type": "command",
+                "command": "redirect",
+                "queueCommand": True,
+                "data": [
+                    {
+                        "gather": {
+                            "input": ["speech", "digits"],
+                            "minDigits": 1,
+                            "id": uuid.uuid4().hex,
+                            "actionHook": "/gather",
+                        }
+                    }
+                ],
+            }
+        )
+    )
+
+
+async def send_ws_text_message(ws: Websocket, text: Text) -> None:
+    """Send a text message to the websocket using the jambonz interface."""
+    await ws.send(
+        json.dumps(
+            {
+                "type": "command",
+                "command": "redirect",
+                "queueCommand": True,
+                "data": [
+                    {
+                        "say": {
+                            # id can be used for status notifications
+                            "id": uuid.uuid4().hex,
+                            "text": text,
+                        }
+                    }
+                ],
+            }
+        )
+    )

rasa/core/channels/voice_aware/utils.py

@@ -0,0 +1,20 @@
+import structlog
+
+from rasa.utils.licensing import (
+    PRODUCT_AREA,
+    VOICE_SCOPE,
+    validate_license_from_env,
+)
+
+structlogger = structlog.get_logger()
+
+
+def validate_voice_license_scope() -> None:
+    """Validate that the correct license scope is present."""
+    structlogger.info(
+        f"Validating current Rasa Pro license scope which must include "
+        f"the '{VOICE_SCOPE}' scope to use the voice channel."
+    )
+
+    voice_product_scope = PRODUCT_AREA + " " + VOICE_SCOPE
+    validate_license_from_env(product_area=voice_product_scope)

rasa/core/constants.py

@@ -61,7 +61,6 @@ SEARCH_POLICY_PRIORITY = CHAT_POLICY_PRIORITY + 1
 # flow policy priority
 FLOW_POLICY_PRIORITY = SEARCH_POLICY_PRIORITY + 1
 
-
 DIALOGUE = "dialogue"
 
 # RabbitMQ message property header added to events published using `rasa export`
@@ -105,3 +104,9 @@ DEFAULT_TEMPLATE_ENGINE = RASA_FORMAT_TEMPLATE_ENGINE
 # configuration parameter used to specify the template engine to use
 # for a response
 TEMPLATE_ENGINE_CONFIG_KEY = "template"
+
+# metadata keys for bot utterance events
+UTTER_SOURCE_METADATA_KEY = "utter_source"
+DOMAIN_GROUND_TRUTH_METADATA_KEY = "domain_ground_truth"
+ACTIVE_FLOW_METADATA_KEY = "active_flow"
+STEP_ID_METADATA_KEY = "step_id"