rasa-pro 3.11.0rc2__py3-none-any.whl → 3.11.1__py3-none-any.whl

rasa/core/persistor.py

@@ -4,6 +4,7 @@ import abc
 import os
 import shutil
 from enum import Enum
+from pathlib import Path
 from typing import TYPE_CHECKING, List, Optional, Text, Tuple, Union
 
 import structlog
@@ -122,7 +123,8 @@ class Persistor(abc.ABC):
 
     def persist(self, trained_model: str) -> None:
         """Uploads a trained model persisted in the `target_dir` to cloud storage."""
-        file_key = self._create_file_key(trained_model)
+        absolute_file_key = self._create_file_key(trained_model)
+        file_key = Path(absolute_file_key).name
         self._persist_tar(file_key, trained_model)
 
     def retrieve(self, model_name: Text, target_path: Text) -> Text:
@@ -141,7 +143,8 @@ class Persistor(abc.ABC):
             # ensure backward compatibility
             tar_name = self._tar_name(model_name)
         tar_name = self._create_file_key(tar_name)
-        self._retrieve_tar(tar_name)
+        target_filename = os.path.basename(tar_name)
+        self._retrieve_tar(target_filename)
         self._copy(os.path.basename(tar_name), target_path)
 
         if os.path.isdir(target_path):
@@ -149,6 +152,36 @@ class Persistor(abc.ABC):
 
         return target_path
 
+    def size_of_persisted_model(self, model_name: Text) -> int:
+        """Returns the size of the model that has been persisted to cloud storage.
+
+        Args:
+            model_name: The name of the model to retrieve.
+        """
+        tar_name = model_name
+        if not model_name.endswith(MODEL_ARCHIVE_EXTENSION):
+            # ensure backward compatibility
+            tar_name = self._tar_name(model_name)
+        tar_name = self._create_file_key(tar_name)
+        target_filename = os.path.basename(tar_name)
+        return self._retrieve_tar_size(target_filename)
+
+    def _retrieve_tar_size(self, filename: Text) -> int:
+        """Returns the size of the model that has been persisted to cloud storage."""
+        structlogger.warning(
+            "persistor.retrieve_tar_size.not_implemented",
+            filename=filename,
+            event_info=(
+                "This method should be implemented in the persistor. "
+                "The default implementation will download the model "
+                "to calculate the size. Most persistors should override "
+                "this method to avoid downloading the model and get the "
+                "size directly from the cloud storage."
+            ),
+        )
+        self._retrieve_tar(filename)
+        return os.path.getsize(os.path.basename(filename))
+
     @abc.abstractmethod
     def _retrieve_tar(self, filename: Text) -> None:
         """Downloads a model previously persisted to cloud storage."""
@@ -197,10 +230,7 @@ class Persistor(abc.ABC):
                 f"{REMOTE_STORAGE_PATH_ENV} is deprecated and will be "
                 "removed in future versions. "
                 "Please use the -m path/to/model.tar.gz option to "
-                "specify the model path when loading a model."
-                "Or use --output and --fixed-model-name to specify the "
-                "output directory and the model name when saving a "
-                "trained model to remote storage.",
+                "specify the model path when loading a model.",
             )
 
         file_key = os.path.basename(model_path)
@@ -272,50 +302,48 @@ class AWSPersistor(Persistor):
         with open(tar_path, "rb") as f:
             self.s3.Object(self.bucket_name, file_key).put(Body=f)
 
-    def _retrieve_tar(self, model_path: Text) -> None:
+    def _retrieve_tar_size(self, model_path: Text) -> int:
+        """Returns the size of the model that has been persisted to s3."""
+        try:
+            obj = self.s3.Object(self.bucket_name, model_path)
+            return obj.content_length
+        except Exception:
+            raise ModelNotFound()
+
+    def _retrieve_tar(self, target_filename: str) -> None:
         """Downloads a model that has previously been persisted to s3."""
         from botocore import exceptions
 
-        target_filename = os.path.basename(model_path)
-        bucket_objects = list(self.bucket.objects.all())
-
-        model_found = False
-
         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."
         )
 
-        for obj in bucket_objects:
-            if model_path not in obj.key:
-                continue
+        try:
+            with open(target_filename, "wb") as f:
+                self.bucket.download_fileobj(target_filename, f)
+
             structlogger.debug(
-                "aws_persistor.retrieve_tar.object_found", object_key=obj.key
+                "aws_persistor.retrieve_tar.object_found", object_key=target_filename
             )
-
-            try:
-                with open(target_filename, "wb") as f:
-                    self.bucket.download_fileobj(obj.key, f)
-                    model_found = True
-                    break
-            except exceptions.ClientError as exc:
-                if self._error_code(exc) == HTTP_STATUS_NOT_FOUND:
-                    structlogger.error(
-                        "aws_persistor.retrieve_tar.model_not_found",
-                        bucket_name=self.bucket_name,
-                        target_filename=target_filename,
-                        event_info=log,
-                    )
-                    raise ModelNotFound() from exc
-        if not model_found:
+        except exceptions.ClientError as exc:
+            if self._error_code(exc) == HTTP_STATUS_NOT_FOUND:
+                structlogger.error(
+                    "aws_persistor.retrieve_tar.model_not_found",
+                    bucket_name=self.bucket_name,
+                    target_filename=target_filename,
+                    event_info=log,
+                )
+                raise ModelNotFound() from exc
+        except exceptions.BotoCoreError as exc:
             structlogger.error(
-                "aws_persistor.retrieve_tar.model_not_found",
+                "aws_persistor.retrieve_tar.model_download_error",
                 bucket_name=self.bucket_name,
                 target_filename=target_filename,
                 event_info=log,
             )
-            raise ModelNotFound()
+            raise ModelNotFound() from exc
 
 
 class GCSPersistor(Persistor):
@@ -397,6 +425,14 @@ class GCSPersistor(Persistor):
         blob = self.bucket.blob(file_key)
         blob.upload_from_filename(tar_path)
 
+    def _retrieve_tar_size(self, target_filename: Text) -> int:
+        """Returns the size of the model that has been persisted to GCS."""
+        try:
+            blob = self.bucket.blob(target_filename)
+            return blob.size
+        except Exception:
+            raise ModelNotFound()
+
     def _retrieve_tar(self, target_filename: Text) -> None:
         """Downloads a model that has previously been persisted to GCS."""
         from google.api_core import exceptions
@@ -404,6 +440,10 @@ class GCSPersistor(Persistor):
         blob = self.bucket.blob(target_filename)
         try:
             blob.download_to_filename(target_filename)
+
+            structlogger.debug(
+                "gcs_persistor.retrieve_tar.object_found", object_key=target_filename
+            )
         except exceptions.NotFound as exc:
             log = (
                 f"Model '{target_filename}' not found in the specified bucket "
@@ -460,24 +500,28 @@ class AzurePersistor(Persistor):
         with open(tar_path, "rb") as data:
             self._container_client().upload_blob(name=file_key, data=data)
 
-    def _retrieve_tar(self, target_filename: Text) -> None:
-        """Downloads a model that has previously been persisted to Azure."""
+    def _retrieve_tar_size(self, target_filename: Text) -> int:
+        """Returns the size of the model that has been persisted to Azure."""
         try:
-            blob_list = self._container_client().list_blobs()
-
-            for blob in blob_list:
-                if target_filename not in blob.name:
-                    continue
+            blob_client = self._container_client().get_blob_client(target_filename)
+            properties = blob_client.get_blob_properties()
+            return properties.size
+        except Exception:
+            raise ModelNotFound()
 
-                structlogger.debug(
-                    "azure_persistor.retrieve_tar.blob_found", blob_name=blob.name
-                )
+    def _retrieve_tar(self, target_filename: Text) -> None:
+        """Downloads a model that has previously been persisted to Azure."""
+        from azure.core.exceptions import AzureError
 
-                with open(target_filename, "wb") as model_file:
-                    blob_client = self._container_client().get_blob_client(blob.name)
-                    download_stream = blob_client.download_blob()
-                    model_file.write(download_stream.readall())
-        except Exception as exc:
+        try:
+            with open(target_filename, "wb") as model_file:
+                blob_client = self._container_client().get_blob_client(target_filename)
+                download_stream = blob_client.download_blob()
+                model_file.write(download_stream.readall())
+            structlogger.debug(
+                "azure_persistor.retrieve_tar.blob_found", blob_name=target_filename
+            )
+        except AzureError as exc:
             log = (
                 f"An exception occurred while trying to download "
                 f"the model '{target_filename}' in the specified container "

rasa/core/policies/enterprise_search_policy.py

@@ -51,7 +51,7 @@ from rasa.shared.constants import (
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
-    MODEL_GROUP_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.constants import (
     ACTION_CANCEL_FLOW,
@@ -337,12 +337,12 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
             or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
             embeddings_model_group_id=self.embeddings_config.get(
-                MODEL_GROUP_CONFIG_KEY
+                MODEL_GROUP_ID_CONFIG_KEY
             ),
             llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
             or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_config.get(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
             citation_enabled=self.citation_enabled,
         )
         self.persist()
@@ -538,12 +538,12 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
             or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
             embeddings_model_group_id=self.embeddings_config.get(
-                MODEL_GROUP_CONFIG_KEY
+                MODEL_GROUP_ID_CONFIG_KEY
             ),
             llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
             or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_config.get(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
             citation_enabled=self.citation_enabled,
         )
         return self._create_prediction(

rasa/core/policies/flows/flow_executor.py

@@ -487,7 +487,8 @@ def validate_collect_step(
     step: CollectInformationFlowStep,
     stack: DialogueStack,
     available_actions: List[str],
-    slots: Dict[Text, Slot],
+    slots: Dict[str, Slot],
+    flow_name: str,
 ) -> bool:
     """Validate that a collect step can be executed.
 
@@ -510,12 +511,12 @@ def validate_collect_step(
         slot_name=step.collect,
     )
 
-    cancel_flow_and_push_internal_error(stack)
+    cancel_flow_and_push_internal_error(stack, flow_name)
 
     return False
 
 
-def cancel_flow_and_push_internal_error(stack: DialogueStack) -> None:
+def cancel_flow_and_push_internal_error(stack: DialogueStack, flow_name: str) -> None:
     """Cancel the top user flow and push the internal error pattern."""
     top_frame = stack.top()
 
@@ -527,7 +528,7 @@ def cancel_flow_and_push_internal_error(stack: DialogueStack) -> None:
         canceled_frames = CancelFlowCommand.select_canceled_frames(stack)
         stack.push(
             CancelPatternFlowStackFrame(
-                canceled_name=top_frame.flow_id,
+                canceled_name=flow_name,
                 canceled_frames=canceled_frames,
             )
         )
@@ -539,6 +540,7 @@ def validate_custom_slot_mappings(
     stack: DialogueStack,
     tracker: DialogueStateTracker,
     available_actions: List[str],
+    flow_name: str,
 ) -> bool:
     """Validate a slot with custom mappings.
 
@@ -559,7 +561,7 @@ def validate_custom_slot_mappings(
                     action=step.collect_action,
                     collect=step.collect,
                 )
-                cancel_flow_and_push_internal_error(stack)
+                cancel_flow_and_push_internal_error(stack, flow_name)
                 return False
 
     return True
@@ -599,7 +601,12 @@ def run_step(
 
     if isinstance(step, CollectInformationFlowStep):
         return _run_collect_information_step(
-            available_actions, initial_events, stack, step, tracker
+            available_actions,
+            initial_events,
+            stack,
+            step,
+            tracker,
+            flow.readable_name(),
         )
 
     elif isinstance(step, ActionFlowStep):
@@ -719,15 +726,18 @@ def _run_collect_information_step(
     stack: DialogueStack,
     step: CollectInformationFlowStep,
     tracker: DialogueStateTracker,
+    flow_name: str,
 ) -> FlowStepResult:
-    is_step_valid = validate_collect_step(step, stack, available_actions, tracker.slots)
+    is_step_valid = validate_collect_step(
+        step, stack, available_actions, tracker.slots, flow_name
+    )
 
     if not is_step_valid:
         # if we return any other FlowStepResult, the assistant will stay silent
         # instead of triggering the internal error pattern
         return ContinueFlowWithNextStep(events=initial_events)
     is_mapping_valid = validate_custom_slot_mappings(
-        step, stack, tracker, available_actions
+        step, stack, tracker, available_actions, flow_name
     )
 
     if not is_mapping_valid:

rasa/core/policies/intentless_policy.py

@@ -39,7 +39,7 @@ from rasa.shared.constants import (
     PROVIDER_CONFIG_KEY,
     OPENAI_PROVIDER,
     TIMEOUT_CONFIG_KEY,
-    MODEL_GROUP_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
 from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
@@ -558,11 +558,13 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
             embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
             or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
-            embeddings_model_group_id=self.embeddings_property(MODEL_GROUP_CONFIG_KEY),
+            embeddings_model_group_id=self.embeddings_property(
+                MODEL_GROUP_ID_CONFIG_KEY
+            ),
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_property(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
         )
 
         self.persist()
@@ -642,11 +644,13 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
             embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
             or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
-            embeddings_model_group_id=self.embeddings_property(MODEL_GROUP_CONFIG_KEY),
+            embeddings_model_group_id=self.embeddings_property(
+                MODEL_GROUP_ID_CONFIG_KEY
+            ),
             llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
             llm_model=self.llm_property(MODEL_CONFIG_KEY)
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_property(MODEL_GROUP_CONFIG_KEY),
+            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
             score=score,
         )
 

rasa/core/processor.py

@@ -1279,11 +1279,13 @@ class MessageProcessor:
             tracker.update(events[0])
             return self.should_predict_another_action(action.name())
         except Exception:
-            logger.exception(
-                f"Encountered an exception while running action '{action.name()}'."
-                "Bot will continue, but the actions events are lost. "
-                "Please check the logs of your action server for "
-                "more information."
+            structlogger.exception(
+                "rasa.core.processor.run_action.exception",
+                event_info=f"Encountered an exception while "
+                f"running action '{action.name()}'."
+                f"Bot will continue, but the actions events are lost. "
+                f"Please check the logs of your action server for "
+                f"more information.",
             )
             events = []
 

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -113,6 +113,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         )
 
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
+        self.repeat_command_enabled = self.is_repeat_command_enabled()
 
     ### Implementations of LLMBasedCommandGenerator parent
     @staticmethod
@@ -458,7 +459,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             "current_slot": current_slot,
             "current_slot_description": current_slot_description,
             "user_message": latest_user_message,
-            "is_repeat_command_enabled": self.is_repeat_command_enabled(),
+            "is_repeat_command_enabled": self.repeat_command_enabled,
         }
 
         return self.compile_template(self.prompt_template).render(**inputs)

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -111,6 +111,15 @@ slots:
     type: bool
     mappings:
       - type: from_llm
+  silence_timeout:
+    type: float
+    initial_value: 6.0
+    max_value: 1000000
+  consecutive_silence_timeouts:
+    type: float
+    initial_value: 0.0
+    max_value: 1000000
+
 
 flows:
   pattern_cancel_flow:

rasa/e2e_test/aggregate_test_stats_calculator.py

@@ -35,6 +35,7 @@ class AggregateTestStatsCalculator:
         self.test_cases = test_cases
 
         self.failed_assertion_set: Set["Assertion"] = set()
+        self.failed_test_cases_without_assertion_failure: Set[str] = set()
         self.passed_count_mapping = {
             subclass_type: 0
             for subclass_type in _get_all_assertion_subclasses().keys()
@@ -89,8 +90,14 @@ class AggregateTestStatsCalculator:
         passed_test_case_names = [
             passed.test_case.name for passed in self.passed_results
         ]
+        # We filter out test cases that failed without an assertion failure
+        filtered_test_cases = [
+            test_case
+            for test_case in self.test_cases
+            if test_case.name not in self.failed_test_cases_without_assertion_failure
+        ]
 
-        for test_case in self.test_cases:
+        for test_case in filtered_test_cases:
             if test_case.name in passed_test_case_names:
                 for step in test_case.steps:
                     if step.assertions is None:
@@ -118,6 +125,9 @@ class AggregateTestStatsCalculator:
                     "no_assertion_failure_in_failed_result",
                     test_case=failed.test_case.name,
                 )
+                self.failed_test_cases_without_assertion_failure.add(
+                    failed.test_case.name
+                )
                 continue
 
             self.failed_assertion_set.add(failed.assertion_failure.assertion)

rasa/e2e_test/assertions.py

@@ -71,6 +71,7 @@ class AssertionType(Enum):
     SLOT_WAS_SET = "slot_was_set"
     SLOT_WAS_NOT_SET = "slot_was_not_set"
     BOT_UTTERED = "bot_uttered"
+    BOT_DID_NOT_UTTER = "bot_did_not_utter"
     GENERATIVE_RESPONSE_IS_RELEVANT = "generative_response_is_relevant"
     GENERATIVE_RESPONSE_IS_GROUNDED = "generative_response_is_grounded"
 
@@ -722,6 +723,7 @@ class BotUtteredAssertion(Assertion):
     ) -> Tuple[Optional[AssertionFailure], Optional[Event]]:
         """Run the bot_uttered assertion on the given events for that user turn."""
         matching_event = None
+        error_messages = []
 
         if self.utter_name is not None:
             try:
@@ -732,11 +734,8 @@ class BotUtteredAssertion(Assertion):
                     and event.metadata.get("utter_action") == self.utter_name
                 )
             except StopIteration:
-                error_message = f"Bot did not utter '{self.utter_name}' response."
-                error_message += assertion_order_error_message
-
-                return self._generate_assertion_failure(
-                    error_message, prior_events, turn_events, self.line
+                error_messages.append(
+                    f"Bot did not utter '{self.utter_name}' response."
                 )
 
         if self.text_matches is not None:
@@ -748,16 +747,11 @@ class BotUtteredAssertion(Assertion):
                     if isinstance(event, BotUttered) and pattern.search(event.text)
                 )
             except StopIteration:
-                error_message = (
+                error_messages.append(
                     f"Bot did not utter any response which "
                     f"matches the provided text pattern "
                     f"'{self.text_matches}'."
                 )
-                error_message += assertion_order_error_message
-
-                return self._generate_assertion_failure(
-                    error_message, prior_events, turn_events, self.line
-                )
 
         if self.buttons:
             try:
@@ -767,13 +761,16 @@ class BotUtteredAssertion(Assertion):
                     if isinstance(event, BotUttered) and self._buttons_match(event)
                 )
             except StopIteration:
-                error_message = (
+                error_messages.append(
                     "Bot did not utter any response with the expected buttons."
                 )
-                error_message += assertion_order_error_message
-                return self._generate_assertion_failure(
-                    error_message, prior_events, turn_events, self.line
-                )
+
+        if error_messages:
+            error_message = " ".join(error_messages)
+            error_message += assertion_order_error_message
+            return self._generate_assertion_failure(
+                error_message, prior_events, turn_events, self.line
+            )
 
         return None, matching_event
 
@@ -803,6 +800,126 @@ class BotUtteredAssertion(Assertion):
         return hash(json.dumps(self.as_dict()))
 
 
+@dataclass
+class BotDidNotUtterAssertion(Assertion):
+    """Class for the 'bot_did_not_utter' assertion."""
+
+    utter_name: Optional[str] = None
+    text_matches: Optional[str] = None
+    buttons: Optional[List[AssertedButton]] = None
+    line: Optional[int] = None
+
+    @classmethod
+    def type(cls) -> str:
+        return AssertionType.BOT_DID_NOT_UTTER.value
+
+    @staticmethod
+    def from_dict(assertion_dict: Dict[Text, Any]) -> BotDidNotUtterAssertion:
+        """Creates a BotDidNotUtterAssertion from a dictionary."""
+        assertion_dict = assertion_dict.get(AssertionType.BOT_DID_NOT_UTTER.value, {})
+        utter_name = assertion_dict.get("utter_name")
+        text_matches = assertion_dict.get("text_matches")
+        buttons = [
+            AssertedButton.from_dict(button)
+            for button in assertion_dict.get("buttons", [])
+        ]
+
+        if not utter_name and not text_matches and not buttons:
+            raise RasaException(
+                "A 'bot_did_not_utter' assertion is empty. "
+                "It should contain at least one of the allowed properties: "
+                "'utter_name', 'text_matches', or 'buttons'."
+            )
+
+        return BotDidNotUtterAssertion(
+            utter_name=utter_name,
+            text_matches=text_matches,
+            buttons=buttons,
+            line=assertion_dict.lc.line + 1 if hasattr(assertion_dict, "lc") else None,
+        )
+
+    def run(
+        self,
+        turn_events: List[Event],
+        prior_events: List[Event],
+        assertion_order_error_message: str = "",
+        **kwargs: Any,
+    ) -> Tuple[Optional[AssertionFailure], Optional[Event]]:
+        """Checks that the bot did not utter the specified messages or buttons."""
+        for event in turn_events:
+            if isinstance(event, BotUttered):
+                error_messages = []
+                if self._utter_name_matches(event):
+                    error_messages.append(
+                        f"Bot uttered a forbidden utterance '{self.utter_name}'."
+                    )
+                if self._text_matches(event):
+                    error_messages.append(
+                        f"Bot uttered a forbidden message matching "
+                        f"the pattern '{self.text_matches}'."
+                    )
+                if self._buttons_match(event):
+                    error_messages.append(
+                        "Bot uttered a forbidden response with specified buttons."
+                    )
+
+                if error_messages:
+                    error_message = " ".join(error_messages)
+                    error_message += assertion_order_error_message
+                    return self._generate_assertion_failure(
+                        error_message, prior_events, turn_events, self.line
+                    )
+        return None, None
+
+    def _utter_name_matches(self, event: BotUttered) -> bool:
+        if self.utter_name is not None:
+            if event.metadata.get("utter_action") == self.utter_name:
+                return True
+        return False
+
+    def _text_matches(self, event: BotUttered) -> bool:
+        if self.text_matches is not None:
+            pattern = re.compile(self.text_matches)
+            if pattern.search(event.text):
+                return True
+        return False
+
+    def _buttons_match(self, event: BotUttered) -> bool:
+        """Check if the bot response contains any of the forbidden buttons."""
+        if self.buttons is None:
+            return False
+
+        actual_buttons = event.data.get("buttons", [])
+        if not actual_buttons:
+            return False
+
+        for actual_button in actual_buttons:
+            if any(
+                self._is_forbidden_button(actual_button, forbidden_button)
+                for forbidden_button in self.buttons
+            ):
+                return True
+        return False
+
+    @staticmethod
+    def _is_forbidden_button(
+        actual_button: Dict[str, Any], forbidden_button: AssertedButton
+    ) -> bool:
+        """Check if the button matches any of the forbidden buttons."""
+        actual_title = actual_button.get("title")
+        actual_payload = actual_button.get("payload")
+
+        title_matches = forbidden_button.title == actual_title
+        payload_matches = forbidden_button.payload == actual_payload
+        if title_matches and payload_matches:
+            return True
+        return False
+
+    def __hash__(self) -> int:
+        """Hash method to ensure the assertion is hashable."""
+        return hash(json.dumps(self.as_dict()))
+
+
 @dataclass
 class GenerativeResponseMixin(Assertion):
     """Mixin class for storing generative response assertions."""