rasa-pro 3.12.18.dev1__py3-none-any.whl → 3.13.0a1.dev2__py3-none-any.whl

rasa/core/policies/flow_policy.py

@@ -150,12 +150,12 @@ class FlowPolicy(Policy):
         except FlowCircuitBreakerTrippedException as e:
             structlogger.error(
                 "flow.circuit_breaker",
-                dialogue_stack=e.dialogue_stack,
                 number_of_steps_taken=e.number_of_steps_taken,
                 event_info=(
                     "The flow circuit breaker tripped. "
                     "There appears to be an infinite loop in the flows."
                 ),
+                error=str(e),
             )
             # end the current flow and start the internal error flow
             updated_stack = tracker.stack

rasa/core/policies/flows/flow_executor.py

@@ -9,6 +9,7 @@ from structlog.contextvars import (
     bound_contextvars,
 )
 
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.constants import ACTIVE_FLOW_METADATA_KEY, STEP_ID_METADATA_KEY
 from rasa.core.policies.flows.flow_exceptions import (
     FlowCircuitBreakerTrippedException,
@@ -24,6 +25,7 @@ from rasa.core.policies.flows.flow_step_result import (
 from rasa.dialogue_understanding.commands import CancelFlowCommand
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
+    FLOW_PATTERN_COLLECT_INFORMATION,
     CollectInformationPatternFlowStackFrame,
 )
 from rasa.dialogue_understanding.patterns.completed import (
@@ -54,6 +56,7 @@ from rasa.dialogue_understanding.stack.utils import (
 from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
 from rasa.shared.core.constants import (
     ACTION_LISTEN_NAME,
+    SILENCE_TIMEOUT_SLOT,
 )
 from rasa.shared.core.events import (
     Event,
@@ -123,7 +126,6 @@ def is_condition_satisfied(
         structlogger.error(
             "flow.predicate.error",
             predicate=predicate,
-            document=document,
             error=str(e),
         )
         return False
@@ -177,7 +179,7 @@ def select_next_step_id(
             "flow.link.failed_to_select_branch",
             current=current,
             links=next_step.links,
-            tracker=tracker,
+            sender_id=tracker.sender_id,
         )
         return None
 
@@ -191,7 +193,7 @@ def select_next_step_id(
         structlogger.error(
             "flow.step.failed_to_select_next_step",
             step=current,
-            tracker=tracker,
+            sender_id=tracker.sender_id,
         )
         return None
 
@@ -226,19 +228,6 @@ def events_from_set_slots_step(step: SetSlotsFlowStep) -> List[Event]:
     return [SlotSet(slot["key"], slot["value"]) for slot in step.slots]
 
 
-def events_for_collect_step_execution(
-    step: CollectInformationFlowStep, tracker: DialogueStateTracker
-) -> List[Event]:
-    """Create the events needed to prepare for the execution of a collect step."""
-    # reset the slots that always need to be explicitly collected
-    slot = tracker.slots.get(step.collect, None)
-
-    if slot and step.ask_before_filling:
-        return [SlotSet(step.collect, None)]
-    else:
-        return []
-
-
 def trigger_pattern_continue_interrupted(
     current_frame: DialogueStackFrame,
     stack: DialogueStack,
@@ -600,6 +589,12 @@ def run_step(
         # the START_STEP meta step
         initial_events.append(FlowStarted(flow.id, metadata=stack.current_context()))
 
+    # FLow does not start with collect step or we are not in collect information pattern
+    if _first_step_is_not_collect(
+        step, previous_step_id
+    ) and not _in_collect_information_pattern(flow):
+        _append_global_silence_timeout_event(initial_events, tracker)
+
     if isinstance(step, CollectInformationFlowStep):
         return _run_collect_information_step(
             available_actions,
@@ -629,12 +624,32 @@ def run_step(
         return ContinueFlowWithNextStep(events=initial_events)
 
     elif isinstance(step, EndFlowStep):
+        # If pattern collect information flow is ending,
+        # we need to reset the silence timeout slot to its global value.
+        if flow.id == FLOW_PATTERN_COLLECT_INFORMATION:
+            _append_global_silence_timeout_event(initial_events, tracker)
+
         return _run_end_step(flow, flows, initial_events, stack, tracker)
 
     else:
         raise FlowException(f"Unknown flow step type {type(step)}")
 
 
+def _first_step_is_not_collect(
+    step: FlowStep,
+    previous_step_id: str,
+) -> bool:
+    """Check if the first step is not a collect information step."""
+    return (previous_step_id == START_STEP) and not isinstance(
+        step, CollectInformationFlowStep
+    )
+
+
+def _in_collect_information_pattern(flow: Flow) -> bool:
+    """Check if the current flow is a collect information pattern."""
+    return flow.id == FLOW_PATTERN_COLLECT_INFORMATION
+
+
 def _run_end_step(
     flow: Flow,
     flows: FlowsList,
@@ -745,5 +760,69 @@ def _run_collect_information_step(
         step.collect, stack, step.rejections, step.utter, step.collect_action
     )
 
-    events: List[Event] = events_for_collect_step_execution(step, tracker)
+    events: List[Event] = _events_for_collect_step_execution(step, tracker)
     return ContinueFlowWithNextStep(events=initial_events + events)
+
+
+def _events_for_collect_step_execution(
+    step: CollectInformationFlowStep, tracker: DialogueStateTracker
+) -> List[Event]:
+    """Create the events needed to prepare for the execution of a collect step."""
+    # reset the slots that always need to be explicitly collected
+
+    events = _silence_timeout_events_for_collect_step(step, tracker)
+
+    slot = tracker.slots.get(step.collect, None)
+    if slot and step.ask_before_filling:
+        events.append(SlotSet(step.collect, None))
+
+    return events
+
+
+def _silence_timeout_events_for_collect_step(
+    step: CollectInformationFlowStep, tracker: DialogueStateTracker
+) -> List[Event]:
+    events: List[Event] = []
+
+    silence_timeout = (
+        AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout
+    )
+
+    if step.silence_timeout:
+        structlogger.debug(
+            "flow.step.run.adjusting_silence_timeout",
+            duration=step.silence_timeout,
+            collect=step.collect,
+        )
+
+        silence_timeout = step.silence_timeout
+    else:
+        structlogger.debug(
+            "flow.step.run.reset_silence_timeout_to_global",
+            duration=silence_timeout,
+            collect=step.collect,
+        )
+
+    current_silence_timeout = tracker.get_slot(SILENCE_TIMEOUT_SLOT)
+
+    if current_silence_timeout != silence_timeout:
+        events.append(SlotSet(SILENCE_TIMEOUT_SLOT, silence_timeout))
+
+    return events
+
+
+def _append_global_silence_timeout_event(
+    events: List[Event], tracker: DialogueStateTracker
+) -> None:
+    current_silence_timeout = tracker.get_slot(SILENCE_TIMEOUT_SLOT)
+    global_silence_timeout = (
+        AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout
+    )
+
+    if current_silence_timeout != global_silence_timeout:
+        events.append(
+            SlotSet(
+                SILENCE_TIMEOUT_SLOT,
+                AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout,
+            )
+        )

rasa/core/policies/intentless_policy.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple
 
 import structlog
 import tiktoken
+from deprecated import deprecated  # type: ignore[import]
 from jinja2 import Template
 from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings
@@ -37,18 +38,14 @@ from rasa.shared.constants import (
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
     TEMPERATURE_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
-from rasa.shared.core.events import (
-    ActionExecuted,
-    BotUttered,
-    Event,
-    UserUttered,
-)
+from rasa.shared.core.events import ActionExecuted, BotUttered, Event, UserUttered
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.policies.utils import filter_responses_for_intentless_policy
@@ -60,18 +57,22 @@ from rasa.shared.providers.embedding._langchain_embedding_client_adapter import
     _LangchainEmbeddingClientAdapter,
 )
 from rasa.shared.providers.llm.llm_client import LLMClient
-from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
+from rasa.shared.utils.constants import (
+    LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+    LOG_COMPONENT_SOURCE_METHOD_INIT,
+)
 from rasa.shared.utils.health_check.embeddings_health_check_mixin import (
     EmbeddingsHealthCheckMixin,
 )
 from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
-from rasa.shared.utils.io import deep_container_fingerprint
+from rasa.shared.utils.io import deep_container_fingerprint, raise_deprecation_warning
 from rasa.shared.utils.llm import (
     AI,
     DEFAULT_OPENAI_CHAT_MODEL_NAME,
     DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
     DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     USER,
+    check_prompt_config_keys_and_warn_if_deprecated,
     combine_custom_and_default_config,
     embedder_factory,
     get_prompt_template,
@@ -123,9 +124,12 @@ DEFAULT_EMBEDDINGS_CONFIG = {
     MODEL_CONFIG_KEY: DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
 }
 
-DEFAULT_INTENTLESS_PROMPT_TEMPLATE = importlib.resources.open_text(
+DEFAULT_INTENTLESS_PROMPT_TEMPLATE_FILE_NAME = importlib.resources.open_text(
     "rasa.core.policies", "intentless_prompt_template.jinja2"
 ).name
+DEFAULT_INTENTLESS_PROMPT_TEMPLATE = importlib.resources.read_text(
+    "rasa.core.policies", "intentless_prompt_template.jinja2"
+)
 
 INTENTLESS_PROMPT_TEMPLATE_FILE_NAME = "intentless_policy_prompt.jinja2"
 INTENTLESS_CONFIG_FILE_NAME = "config.json"
@@ -325,6 +329,9 @@ def conversation_as_prompt(conversation: Conversation) -> str:
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.POLICY_WITH_END_TO_END_SUPPORT, is_trainable=True
 )
+@deprecated(
+    reason=("The IntentlessPolicy is deprecated and will be removed in Rasa `4.0.0`.")
+)
 class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
     """Policy which uses a language model to generate the next action.
 
@@ -346,7 +353,7 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             # ensures that the policy will not override a deterministic policy
             # which utilizes the nlu predictions confidence (e.g. Memoization).
             NLU_ABSTENTION_THRESHOLD: 0.9,
-            PROMPT_CONFIG_KEY: DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
+            PROMPT_TEMPLATE_CONFIG_KEY: None,  # TODO: remove in Rasa 4.0.0
         }
 
     @staticmethod
@@ -378,6 +385,9 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         prompt_template: Optional[Text] = None,
     ) -> None:
         """Constructs a new Policy object."""
+        raise_deprecation_warning(
+            message=("Support for `IntentlessPolicy` will be removed in Rasa `4.0.0`.")
+        )
         super().__init__(config, model_storage, resource, execution_context, featurizer)
 
         # Resolve LLM config
@@ -400,11 +410,43 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         self.response_index = responses_docsearch
         self.conversation_samples_index = samples_docsearch
         self.embedder = self._create_plain_embedder(config)
-        self.prompt_template = prompt_template or rasa.shared.utils.io.read_file(
-            self.config[PROMPT_CONFIG_KEY]
+
+        # Warn if the prompt config key is used to set the prompt template
+        check_prompt_config_keys_and_warn_if_deprecated(config, "intentless_policy")
+
+        self.prompt_template = prompt_template or self._resolve_prompt_template(
+            config, LOG_COMPONENT_SOURCE_METHOD_INIT
         )
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
 
+    @classmethod
+    def _resolve_prompt_template(
+        cls: Any,
+        config: dict,
+        log_source_method: str,
+    ) -> str:
+        """Resolves the prompt template from the config.
+
+        Args:
+            config: The config to resolve the prompt template from.
+            log_source_method: The method from which the prompt template is resolved.
+
+        Returns:
+            The resolved prompt template.
+        """
+        # Prefer prompt template over prompt config key.
+        prompt_template_file = (
+            config.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            or config.get(PROMPT_CONFIG_KEY)
+            or DEFAULT_INTENTLESS_PROMPT_TEMPLATE_FILE_NAME
+        )
+        return get_prompt_template(
+            prompt_template_file,
+            DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
+            log_source_component=IntentlessPolicy.__name__,
+            log_source_method=log_source_method,
+        )
+
     @classmethod
     def _create_plain_embedder(cls, config: Dict[Text, Any]) -> Embeddings:
         """Creates an embedder that uses the OpenAI API.
@@ -721,9 +763,7 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
                 final_response_examples.append(resp)
 
         llm_response = await self.generate_answer(
-            final_response_examples,
-            conversation_samples,
-            history,
+            final_response_examples, conversation_samples, history
         )
         if not llm_response:
             structlogger.debug("intentless_policy.prediction.skip_llm_fail")
@@ -945,11 +985,8 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
     @classmethod
     def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint of intentless policy for the graph."""
-        prompt_template = get_prompt_template(
-            config.get(PROMPT_CONFIG_KEY),
-            DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
-            log_source_component=IntentlessPolicy.__name__,
-            log_source_method=LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+        prompt_template = cls._resolve_prompt_template(
+            config, LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
         )
 
         llm_config = resolve_model_client_config(

rasa/core/processor.py

@@ -12,7 +12,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, Union
 import structlog
 
 import rasa.core.actions.action
-import rasa.core.tracker_store
+import rasa.core.tracker_stores.tracker_store
 import rasa.core.utils
 import rasa.shared.core.trackers
 import rasa.shared.utils.io
@@ -34,6 +34,9 @@ from rasa.dialogue_understanding.commands import (
     CannotHandleCommand,
     Command,
     NoopCommand,
+    RestartCommand,
+    SessionEndCommand,
+    SessionStartCommand,
     SetSlotCommand,
 )
 from rasa.dialogue_understanding.commands.utils import (
@@ -72,8 +75,8 @@ from rasa.shared.core.constants import (
     ACTION_SESSION_START_NAME,
     FOLLOWUP_ACTION,
     SESSION_START_METADATA_SLOT,
+    SILENCE_TIMEOUT_SLOT,
     SLOT_CONSECUTIVE_SILENCE_TIMEOUTS,
-    SLOT_SILENCE_TIMEOUT,
     USER_INTENT_RESTART,
     USER_INTENT_SILENCE_TIMEOUT,
     SetSlotExtractor,
@@ -109,7 +112,8 @@ from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
 
 if TYPE_CHECKING:
-    from rasa.core.utils import AvailableEndpoints
+    from rasa.core.available_endpoints import AvailableEndpoints
+    from rasa.privacy.privacy_manager import BackgroundPrivacyManager
 
 logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
@@ -126,7 +130,7 @@ class MessageProcessor:
     def __init__(
         self,
         model_path: Union[Text, Path],
-        tracker_store: rasa.core.tracker_store.TrackerStore,
+        tracker_store: rasa.core.tracker_stores.tracker_store.TrackerStore,
         lock_store: LockStore,
         generator: NaturalLanguageGenerator,
         action_endpoint: Optional[EndpointConfig] = None,
@@ -135,6 +139,7 @@ class MessageProcessor:
         on_circuit_break: Optional[LambdaType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional["AvailableEndpoints"] = None,
+        privacy_manager: Optional["BackgroundPrivacyManager"] = None,
     ) -> None:
         """Initializes a `MessageProcessor`."""
         self.nlg = generator
@@ -164,6 +169,9 @@ class MessageProcessor:
         self.model_path = Path(model_path)
         self.domain = self.model_metadata.domain
         self.http_interpreter = http_interpreter
+        self.privacy_manager = privacy_manager
+        if self.privacy_manager is not None:
+            self.privacy_manager.validate_sensitive_slots_in_domain(self.domain)
 
     @staticmethod
     def _load_model(
@@ -213,15 +221,30 @@ class MessageProcessor:
 
         await self._run_prediction_loop(message.output_channel, tracker)
 
-        await self.run_anonymization_pipeline(tracker)
-
         await self.save_tracker(tracker)
 
+        self.trigger_anonymization(tracker)
+
         if isinstance(message.output_channel, CollectingOutputChannel):
             return message.output_channel.messages
 
         return None
 
+    def trigger_anonymization(self, tracker: DialogueStateTracker) -> None:
+        if self.privacy_manager is None:
+            structlogger.debug(
+                "processor.trigger_anonymization.skipping.pii_management_not_enabled",
+            )
+            return None
+
+        structlogger.info(
+            "rasa.core.processor.trigger_anonymization",
+            sender_id=tracker.sender_id,
+            event_info="Triggering anonymization for publishing anonymized "
+            "events to the event broker.",
+        )
+        return self.privacy_manager.run(tracker)
+
     async def run_action_extract_slots(
         self,
         output_channel: OutputChannel,
@@ -262,26 +285,6 @@ class MessageProcessor:
 
         return tracker
 
-    async def run_anonymization_pipeline(self, tracker: DialogueStateTracker) -> None:
-        """Run the anonymization pipeline on the new tracker events.
-
-        Args:
-            tracker: A tracker representing a conversation state.
-        """
-        anonymization_pipeline = plugin_manager().hook.get_anonymization_pipeline()
-        if anonymization_pipeline is None:
-            return None
-
-        old_tracker = await self.tracker_store.retrieve(tracker.sender_id)
-        new_events = rasa.shared.core.trackers.TrackerEventDiffEngine.event_difference(
-            old_tracker, tracker
-        )
-
-        for event in new_events:
-            body = {"sender_id": tracker.sender_id}
-            body.update(event.as_dict())
-            anonymization_pipeline.run(body)
-
     async def predict_next_for_sender_id(
         self, sender_id: Text
     ) -> Optional[Dict[Text, Any]]:
@@ -819,28 +822,8 @@ class MessageProcessor:
         )
 
         self._check_for_unseen_features(parse_data)
-        # resetting timeouts variables whenever something that is not a timeout occurs
-        if (
-            parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
-            != USER_INTENT_SILENCE_TIMEOUT
-            and tracker
-        ):
-            if (
-                SLOT_CONSECUTIVE_SILENCE_TIMEOUTS in tracker.slots
-                and tracker.slots[SLOT_CONSECUTIVE_SILENCE_TIMEOUTS].value != 0.0
-            ):
-                tracker.update(SlotSet(SLOT_CONSECUTIVE_SILENCE_TIMEOUTS, 0.0))
-            if (
-                SLOT_SILENCE_TIMEOUT in tracker.slots
-                and tracker.slots[SLOT_SILENCE_TIMEOUT].value
-                != tracker.slots[SLOT_SILENCE_TIMEOUT].initial_value
-            ):
-                tracker.update(
-                    SlotSet(
-                        SLOT_SILENCE_TIMEOUT,
-                        tracker.slots[SLOT_SILENCE_TIMEOUT].initial_value,
-                    )
-                )
+
+        self._initialise_consecutive_silence_timeout_slots(parse_data, tracker)
 
         return parse_data
 
@@ -880,19 +863,61 @@ class MessageProcessor:
                 tracker.has_coexistence_routing_slot
                 and tracker.get_slot(ROUTE_TO_CALM_SLOT) is None
             ):
-                # if we are currently not routing to either CALM or dm1
-                # we make a sticky routing to CALM if there are any commands
-                # from the trigger intent parsing
-                # or a sticky routing to dm1 if there are no commands
+                # If we are currently not routing to either CALM or DM1:
+                # - Sticky route to CALM if there are any commands
+                #   from the trigger intent parsing
+                # - Sticky route to DM1 if there are no commands present
+                route_to_calm_slot_value = self._determine_route_to_calm_slot_value(
+                    nlu_adapted_commands
+                )
                 commands += [
                     SetSlotCommand(
-                        ROUTE_TO_CALM_SLOT, len(nlu_adapted_commands) > 0
+                        ROUTE_TO_CALM_SLOT, route_to_calm_slot_value
                     ).as_dict()
                 ]
 
         parse_data[COMMANDS] = commands
         return parse_data
 
+    def _determine_route_to_calm_slot_value(
+        self, nlu_adapted_commands: List[Dict[str, Any]]
+    ) -> Optional[bool]:
+        """Determines what value should be assigned to `ROUTE_TO_CALM_SLOT`.
+
+        Returns:
+            - True: If any command other than:
+                - SessionStartCommand
+                - SessionEndCommand
+                - RestartCommand
+              is present.
+            - None: If only ignored system commands are present.
+            - False If no commands at all.
+        """
+        system_commands_to_ignore = [
+            SessionStartCommand.command(),
+            SessionEndCommand.command(),
+            RestartCommand.command(),
+        ]
+
+        # Exclude the system commands, as it doesn't originate from the user's
+        # input intent and shouldn't influence the decision for setting
+        # ROUTE_TO_CALM_SLOT.
+        intent_triggered_commands = [
+            command
+            for command in nlu_adapted_commands
+            if command.get("command") not in system_commands_to_ignore
+        ]
+
+        if len(intent_triggered_commands) > 0:
+            # There are commands other than system commands present - route to CALM
+            return True
+        elif len(nlu_adapted_commands) > 0:
+            # Only system command is present — defer routing decision
+            return None
+        else:
+            # No commands at all — route to DM1
+            return False
+
     def _update_full_retrieval_intent(self, parse_data: Dict[Text, Any]) -> None:
         """Update the parse data with the full retrieval intent.
 
@@ -1023,7 +1048,14 @@ class MessageProcessor:
 
     @staticmethod
     def _should_handle_message(tracker: DialogueStateTracker) -> bool:
-        return not tracker.is_paused() or (
+        return not tracker.is_paused() or MessageProcessor._last_user_intent_is_restart(
+            tracker
+        )
+
+    @staticmethod
+    def _last_user_intent_is_restart(tracker: DialogueStateTracker) -> bool:
+        """Check if the last user intent is a restart intent."""
+        return (
             tracker.latest_message is not None
             and tracker.latest_message.intent.get(INTENT_NAME_KEY)
             == USER_INTENT_RESTART
@@ -1570,3 +1602,31 @@ class MessageProcessor:
         )
 
         return tracker, validate_frames
+
+    @staticmethod
+    def _initialise_consecutive_silence_timeout_slots(
+        parse_data: Dict[str, Any],
+        tracker: DialogueStateTracker,
+    ) -> None:
+        # resetting timeouts variables whenever something that is not a timeout occurs
+        if (
+            parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
+            != USER_INTENT_SILENCE_TIMEOUT
+            and tracker
+        ):
+            if (
+                SLOT_CONSECUTIVE_SILENCE_TIMEOUTS in tracker.slots
+                and tracker.slots[SLOT_CONSECUTIVE_SILENCE_TIMEOUTS].value != 0.0
+            ):
+                tracker.update(SlotSet(SLOT_CONSECUTIVE_SILENCE_TIMEOUTS, 0.0))
+            if (
+                SILENCE_TIMEOUT_SLOT in tracker.slots
+                and tracker.slots[SILENCE_TIMEOUT_SLOT].value
+                != tracker.slots[SILENCE_TIMEOUT_SLOT].initial_value
+            ):
+                tracker.update(
+                    SlotSet(
+                        SILENCE_TIMEOUT_SLOT,
+                        tracker.slots[SILENCE_TIMEOUT_SLOT].initial_value,
+                    )
+                )