rasa-pro 3.11.0a3__py3-none-any.whl → 3.11.0a4.dev1__py3-none-any.whl

rasa/core/actions/action.py

@@ -13,6 +13,8 @@ from typing import (
     cast,
 )
 
+from jsonschema import Draft202012Validator
+
 import rasa.core
 import rasa.shared.utils.io
 from rasa.core.actions.custom_action_executor import (
@@ -101,7 +103,6 @@ if TYPE_CHECKING:
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.events import IntentPrediction
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -113,6 +114,7 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
     from rasa.core.actions.action_trigger_search import ActionTriggerSearch
     from rasa.core.actions.two_stage_fallback import TwoStageFallbackAction
     from rasa.core.actions.action_hangup import ActionHangup
+    from rasa.core.actions.action_repeat_bot_messages import ActionRepeatBotMessages
     from rasa.dialogue_understanding.patterns.cancel import ActionCancelFlow
     from rasa.dialogue_understanding.patterns.clarify import ActionClarifyFlows
     from rasa.dialogue_understanding.patterns.correction import ActionCorrectFlowSlot
@@ -140,6 +142,7 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionTriggerChitchat(),
         ActionResetRouting(),
         ActionHangup(),
+        ActionRepeatBotMessages(),
     ]
 
 
@@ -723,6 +726,77 @@ class ActionDeactivateLoop(Action):
         return [ActiveLoop(None), SlotSet(REQUESTED_SLOT, None)]
 
 
+class RemoteActionJSONValidator:
+    """
+    A validator class for ensuring that the JSON response from a custom action executor
+    adheres to the expected schema.
+    """
+
+    @staticmethod
+    def action_response_format_spec() -> Dict[Text, Any]:
+        """Expected response schema for an Action endpoint.
+
+        Used for validation of the response returned from the
+        Action endpoint.
+
+        Returns:
+            Dict[Text, Any]: A dictionary representing the JSON schema for validation.
+        """
+        schema = {
+            "type": "object",
+            "properties": {
+                "events": EVENTS_SCHEMA,
+                "responses": {"type": "array", "items": {"type": "object"}},
+            },
+        }
+        return schema
+
+    @classmethod
+    def validate(cls, result: Dict[Text, Any]) -> bool:
+        """
+        Validate the given JSON result against the expected Action response schema.
+
+        This method uses a cached JSON schema validator to check if the provided result
+        conforms to the predefined schema.
+
+        Args:
+            result (Dict[Text, Any]): The JSON response to validate.
+
+        Returns:
+            bool: True if validation is successful.
+
+        Raises:
+            ValidationError: If the JSON response does not conform to the schema.
+        """
+        from jsonschema import ValidationError
+
+        try:
+            validator = cls.get_action_response_validator()
+            validator.validate(
+                result, RemoteActionJSONValidator.action_response_format_spec()
+            )
+            return True
+        except ValidationError as e:
+            e.message += (
+                f". Failed to validate Action server response from API, "
+                f"make sure your response from the Action endpoint is valid. "
+                f"For more information about the format visit "
+                f"{DOCS_BASE_URL}/custom-actions"
+            )
+            raise e
+
+    @classmethod
+    @lru_cache(maxsize=1)
+    def get_action_response_validator(cls) -> Draft202012Validator:
+        """
+        Retrieve a cached JSON schema validator for the Action response schema.
+
+        Returns:
+            Draft202012Validator: An instance of the JSON schema validator.
+        """
+        return Draft202012Validator(cls.action_response_format_spec())
+
+
 class RemoteAction(Action):
     def __init__(
         self,
@@ -781,37 +855,6 @@ class RemoteAction(Action):
             f"Found url '{self.action_endpoint.url}'."
         )
 
-    @staticmethod
-    def action_response_format_spec() -> Dict[Text, Any]:
-        """Expected response schema for an Action endpoint.
-
-        Used for validation of the response returned from the
-        Action endpoint.
-        """
-        schema = {
-            "type": "object",
-            "properties": {
-                "events": EVENTS_SCHEMA,
-                "responses": {"type": "array", "items": {"type": "object"}},
-            },
-        }
-        return schema
-
-    def _validate_action_result(self, result: Dict[Text, Any]) -> bool:
-        from jsonschema import ValidationError, validate
-
-        try:
-            validate(result, self.action_response_format_spec())
-            return True
-        except ValidationError as e:
-            e.message += (
-                f". Failed to validate Action server response from API, "
-                f"make sure your response from the Action endpoint is valid. "
-                f"For more information about the format visit "
-                f"{DOCS_BASE_URL}/custom-actions"
-            )
-            raise e
-
     @staticmethod
     async def _utter_responses(
         responses: List[Dict[Text, Any]],
@@ -863,7 +906,6 @@ class RemoteAction(Action):
             domain=domain,
             tracker=tracker,
         )
-        self._validate_action_result(response)
 
         events_json = response.get("events", [])
         responses = response.get("responses", [])

rasa/core/actions/action_repeat_bot_messages.py

@@ -0,0 +1,72 @@
+from typing import Optional, Dict, Any, List
+
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.shared.core.constants import ACTION_REPEAT_BOT_MESSAGES
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, BotUttered, UserUttered
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class ActionRepeatBotMessages(Action):
+    """Action to repeat bot messages"""
+
+    def name(self) -> str:
+        """Return the name of the action."""
+        return ACTION_REPEAT_BOT_MESSAGES
+
+    def _get_last_bot_events(self, tracker: DialogueStateTracker) -> List[Event]:
+        """Get the last consecutive bot events before the most recent user message.
+
+        This function scans the dialogue history in reverse to find the last sequence of
+        bot responses that occurred without any user interruption. It filters out all
+        non-utterance events and stops when it encounters a user message after finding
+        bot messages.
+
+        Args:
+            tracker: DialogueStateTracker containing the conversation events.
+
+        Returns:
+            List[Event]: A list of consecutive BotUttered events that occurred
+                most recently, in chronological order. Returns an empty list
+                if no bot messages are found or if the last message was from
+                the user.
+
+        Example:
+            For events: [User1, Bot1, Bot2, User2, Bot4, Bot5, User3]
+            Returns: [Bot4, Bot5] (the last two bot events)
+            The elif condition doesn't break when it sees User3 event.
+            But it does at User2 event.
+        """
+        # filter user and bot events
+        filtered = [
+            e for e in tracker.events if isinstance(e, (BotUttered, UserUttered))
+        ]
+        bot_events: List[Event] = []
+
+        # find the last BotUttered events
+        for e in reversed(filtered):
+            if isinstance(e, BotUttered):
+                # insert instead of append because the list is reversed
+                bot_events.insert(0, e)
+
+            # stop if a UserUttered event is found
+            # only if we have collected some bot events already
+            # this condition skips the first N UserUttered events
+            elif bot_events:
+                break
+
+        return bot_events
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> List[Event]:
+        """Send the last bot messages to the channel again"""
+        bot_events = self._get_last_bot_events(tracker)
+        return bot_events

rasa/core/actions/e2e_stub_custom_action_executor.py

@@ -61,8 +61,12 @@ class E2EStubCustomActionExecutor(CustomActionExecutor):
         domain: "Domain",
         include_domain: bool = False,
     ) -> Dict[Text, Any]:
+        from rasa.core.actions.action import RemoteActionJSONValidator
+
         structlogger.debug(
             "action.e2e_stub_custom_action_executor.run",
             action_name=self.action_name,
         )
-        return self.stub_custom_action.as_dict()
+        response = self.stub_custom_action.as_dict()
+        RemoteActionJSONValidator.validate(response)
+        return response

rasa/core/actions/http_custom_action_executor.py

@@ -66,6 +66,8 @@ class HTTPCustomActionExecutor(CustomActionExecutor):
         Raises:
             RasaException: If an error occurs while making the HTTP request.
         """
+        from rasa.core.actions.action import RemoteActionJSONValidator
+
         try:
             logger.debug(
                 "Calling action endpoint to run action '{}'.".format(self.action_name)
@@ -80,6 +82,8 @@ class HTTPCustomActionExecutor(CustomActionExecutor):
             if response is None:
                 response = {}
 
+            RemoteActionJSONValidator.validate(response)
+
             return response
 
         except ClientResponseError as e:

rasa/core/channels/socketio.py

@@ -37,7 +37,11 @@ class SocketBlueprint(Blueprint):
         :param options: Options to be used while registering the
             blueprint into the app.
         """
-        self.ctx.sio.attach(app, self.ctx.socketio_path)
+        if self.ctx.socketio_path:
+            path = self.ctx.socketio_path
+        else:
+            path = options.get("url_prefix", "/socket.io")
+        self.ctx.sio.attach(app, path)
         super().register(app, options)
 
 

rasa/core/channels/voice_ready/utils.py

@@ -2,16 +2,17 @@ import structlog
 from dataclasses import dataclass
 from typing import Optional
 
-from rasa.utils.licensing import (
-    PRODUCT_AREA,
-    VOICE_SCOPE,
-    validate_license_from_env,
-)
 
 structlogger = structlog.get_logger()
 
 
 def validate_voice_license_scope() -> None:
+    from rasa.utils.licensing import (
+        PRODUCT_AREA,
+        VOICE_SCOPE,
+        validate_license_from_env,
+    )
+
     """Validate that the correct license scope is present."""
     structlogger.info(
         f"Validating current Rasa Pro license scope which must include "

rasa/core/channels/voice_stream/browser_audio.py

@@ -71,7 +71,7 @@ class BrowserAudioInputChannel(VoiceInputChannel):
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
         """Defines a Sanic bluelogger.debug."""
-        blueprint = Blueprint("socketio_webhook", __name__)
+        blueprint = Blueprint("browser_audio", __name__)
 
         @blueprint.route("/", methods=["GET"])
         async def health(_: Request) -> HTTPResponse:

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -131,7 +131,7 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
         """Defines a Sanic bluelogger.debug."""
-        blueprint = Blueprint("socketio_webhook", __name__)
+        blueprint = Blueprint("twilio_media_streams", __name__)
 
         @blueprint.route("/", methods=["GET"])
         async def health(_: Request) -> HTTPResponse:

rasa/core/nlg/contextual_response_rephraser.py

@@ -30,6 +30,9 @@ from rasa.shared.utils.llm import (
     try_instantiate_llm_client,
 )
 from rasa.utils.endpoints import EndpointConfig
+from rasa.shared.utils.llm import (
+    tracker_as_readable_transcript,
+)
 
 from rasa.core.nlg.summarize import summarize_conversation
 
@@ -41,6 +44,8 @@ RESPONSE_REPHRASING_KEY = "rephrase"
 
 RESPONSE_REPHRASING_TEMPLATE_KEY = "rephrase_prompt"
 
+RESPONSE_SUMMARISE_CONVERSATION_KEY = "summarize_conversation"
+
 DEFAULT_REPHRASE_ALL = False
 
 DEFAULT_LLM_CONFIG = {
@@ -212,13 +217,25 @@ class ContextualResponseRephraser(TemplatedNaturalLanguageGenerator):
         if not (response_text := response.get(KEY_RESPONSES_TEXT)):
             return response
 
+        prompt_template_text = self._template_for_response_rephrasing(response)
+
+        # Retrieve inputs for the dynamic prompt
+        transcript = tracker_as_readable_transcript(tracker, max_turns=5)
         latest_message = self._last_message_if_human(tracker)
         current_input = f"{USER}: {latest_message}" if latest_message else ""
 
-        prompt_template_text = self._template_for_response_rephrasing(response)
+        # Only summarise conversation history if flagged
+        summarize_conversation_flag = response.get("metadata", {}).get(
+            RESPONSE_SUMMARISE_CONVERSATION_KEY, False
+        )
+        if summarize_conversation_flag:
+            history = await self._create_history(tracker)
+        else:
+            history = transcript
+            current_input = ""
 
         prompt = Template(prompt_template_text).render(
-            history=await self._create_history(tracker),
+            history=history,
             suggested_response=response_text,
             current_input=current_input,
             slots=tracker.current_slot_values(),

rasa/core/persistor.py

@@ -8,12 +8,14 @@ from typing import TYPE_CHECKING, List, Optional, Text, Tuple, Union
 
 import structlog
 
+from rasa.exceptions import ModelNotFound
 import rasa.shared.utils.common
 import rasa.utils.common
 from rasa.constants import (
     HTTP_STATUS_FORBIDDEN,
     HTTP_STATUS_NOT_FOUND,
     MODEL_ARCHIVE_EXTENSION,
+    DEFAULT_BUCKET_NAME,
 )
 from rasa.env import (
     AWS_ENDPOINT_URL_ENV,
@@ -28,6 +30,7 @@ from rasa.shared.utils.io import raise_warning
 
 if TYPE_CHECKING:
     from azure.storage.blob import ContainerClient
+    import botocore
 
 structlogger = structlog.get_logger()
 
@@ -86,14 +89,15 @@ def get_persistor(storage: StorageType) -> Optional[Persistor]:
 
     if storage == RemoteStorageType.AWS.value:
         return AWSPersistor(
-            os.environ.get(BUCKET_NAME_ENV), os.environ.get(AWS_ENDPOINT_URL_ENV)
+            os.environ.get(BUCKET_NAME_ENV, DEFAULT_BUCKET_NAME),
+            os.environ.get(AWS_ENDPOINT_URL_ENV),
         )
     if storage == RemoteStorageType.GCS.value:
-        return GCSPersistor(os.environ.get(BUCKET_NAME_ENV))
+        return GCSPersistor(os.environ.get(BUCKET_NAME_ENV, DEFAULT_BUCKET_NAME))
 
     if storage == RemoteStorageType.AZURE.value:
         return AzurePersistor(
-            os.environ.get(AZURE_CONTAINER_ENV),
+            os.environ.get(AZURE_CONTAINER_ENV, DEFAULT_BUCKET_NAME),
             os.environ.get(AZURE_ACCOUNT_NAME_ENV),
             os.environ.get(AZURE_ACCOUNT_KEY_ENV),
         )
@@ -181,7 +185,7 @@ class Persistor(abc.ABC):
 
     @staticmethod
     def _create_file_key(model_path: str) -> Text:
-        """Appends remote storage folders when provided to upload or retrieve file"""
+        """Appends remote storage folders when provided to upload or retrieve file."""
         bucket_object_path = os.environ.get(REMOTE_STORAGE_PATH_ENV)
 
         # To keep the backward compatibility, if REMOTE_STORAGE_PATH is not provided,
@@ -235,8 +239,7 @@ class AWSPersistor(Persistor):
         try:
             self.s3.meta.client.head_bucket(Bucket=bucket_name)
         except botocore.exceptions.ClientError as e:
-            error_code = int(e.response["Error"]["Code"])
-            if error_code == HTTP_STATUS_FORBIDDEN:
+            if self.error_code(e) == HTTP_STATUS_FORBIDDEN:
                 log = (
                     f"Access to the specified bucket '{bucket_name}' is forbidden. "
                     "Please make sure you have the necessary "
@@ -248,7 +251,7 @@ class AWSPersistor(Persistor):
                     event_info=log,
                 )
                 raise RasaException(log)
-            elif error_code == HTTP_STATUS_NOT_FOUND:
+            elif self.error_code(e) == HTTP_STATUS_NOT_FOUND:
                 log = (
                     f"The specified bucket '{bucket_name}' does not exist. "
                     "Please make sure to create the bucket first."
@@ -260,6 +263,10 @@ class AWSPersistor(Persistor):
                 )
                 raise RasaException(log)
 
+    @staticmethod
+    def error_code(e: botocore.exceptions.ClientError) -> int:
+        return int(e.response["Error"]["Code"])
+
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to s3."""
         with open(tar_path, "rb") as f:
@@ -267,9 +274,26 @@ class AWSPersistor(Persistor):
 
     def _retrieve_tar(self, model_path: Text) -> None:
         """Downloads a model that has previously been persisted to s3."""
-        tar_name = os.path.basename(model_path)
-        with open(tar_name, "wb") as f:
-            self.bucket.download_fileobj(model_path, f)
+        import botocore
+
+        target_filename = os.path.basename(model_path)
+        try:
+            with open(target_filename, "wb") as f:
+                self.bucket.download_fileobj(model_path, f)
+        except botocore.exceptions.ClientError as e:
+            if self.error_code(e) == HTTP_STATUS_NOT_FOUND:
+                log = (
+                    f"Model '{target_filename}' not found in the specified bucket "
+                    f"'{self.bucket_name}'. Please make sure the model exists "
+                    f"in the bucket."
+                )
+                structlogger.error(
+                    "gcp_persistor.retrieve_tar.model_not_found",
+                    bucket_name=self.bucket_name,
+                    target_filename=target_filename,
+                    event_info=log,
+                )
+                raise ModelNotFound() from e
 
 
 class GCSPersistor(Persistor):
@@ -294,32 +318,57 @@ class GCSPersistor(Persistor):
 
     def _ensure_bucket_exists(self, bucket_name: Text) -> None:
         from google.cloud import exceptions
+        from google.auth import exceptions as auth_exceptions
 
         try:
             self.storage_client.get_bucket(bucket_name)
-        except exceptions.NotFound:
+        except auth_exceptions.GoogleAuthError as e:
             log = (
-                f"The specified bucket '{bucket_name}' does not exist. "
-                "Please make sure to create the bucket first."
+                f"An error occurred while authenticating with Google Cloud "
+                f"Storage. Please make sure you have the necessary credentials "
+                f"to access the bucket '{bucket_name}'."
+            )
+            structlogger.error(
+                "gcp_persistor.ensure_bucket_exists.authentication_error",
+                bucket_name=bucket_name,
+                event_info=log,
+            )
+            raise RasaException(log) from e
+        except exceptions.NotFound as e:
+            log = (
+                f"The specified Google Cloud Storage bucket '{bucket_name}' "
+                f"does not exist. Please make sure to create the bucket first or "
+                f"provide an alternative valid bucket name."
             )
             structlogger.error(
                 "gcp_persistor.ensure_bucket_exists.bucket_not_found",
                 bucket_name=bucket_name,
                 event_info=log,
             )
-            raise RasaException(log)
-        except exceptions.Forbidden:
+            raise RasaException(log) from e
+        except exceptions.Forbidden as e:
             log = (
-                f"Access to the specified bucket '{bucket_name}' is forbidden. "
-                "Please make sure you have the necessary "
-                "permission to access the bucket. "
+                f"Access to the specified Google Cloud storage bucket '{bucket_name}' "
+                f"is forbidden. Please make sure you have the necessary "
+                f"permission to access the bucket. "
             )
             structlogger.error(
                 "gcp_persistor.ensure_bucket_exists.bucket_access_forbidden",
                 bucket_name=bucket_name,
                 event_info=log,
             )
-            raise RasaException(log)
+            raise RasaException(log) from e
+        except ValueError as e:
+            # bucket_name is None
+            log = (
+                "The specified Google Cloud Storage bucket name is None. Please "
+                "make sure to provide a valid bucket name."
+            )
+            structlogger.error(
+                "gcp_persistor.ensure_bucket_exists.bucket_name_none",
+                event_info=log,
+            )
+            raise RasaException(log) from e
 
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to GCS."""
@@ -328,8 +377,24 @@ class GCSPersistor(Persistor):
 
     def _retrieve_tar(self, target_filename: Text) -> None:
         """Downloads a model that has previously been persisted to GCS."""
+        from google.api_core import exceptions
+
         blob = self.bucket.blob(target_filename)
-        blob.download_to_filename(target_filename)
+        try:
+            blob.download_to_filename(target_filename)
+        except exceptions.NotFound as e:
+            log = (
+                f"Model '{target_filename}' not found in the specified bucket "
+                f"'{self.bucket_name}'. Please make sure the model exists "
+                f"in the bucket."
+            )
+            structlogger.error(
+                "gcp_persistor.retrieve_tar.model_not_found",
+                bucket_name=self.bucket_name,
+                target_filename=target_filename,
+                event_info=log,
+            )
+            raise ModelNotFound() from e
 
 
 class AzurePersistor(Persistor):
@@ -355,7 +420,8 @@ class AzurePersistor(Persistor):
         else:
             log = (
                 f"The specified container '{self.container_name}' does not exist."
-                "Please make sure to create the container first."
+                "Please make sure to create the bucket first or "
+                f"provide an alternative valid bucket name."
             )
             structlogger.error(
                 "azure_persistor.ensure_container_exists.container_not_found",