rasa-pro 3.13.0.dev20250612__py3-none-any.whl → 3.13.0.dev20250613__py3-none-any.whl

rasa/core/policies/enterprise_search_prompt_with_relevancy_check_and_citation_template.jinja2

@@ -0,0 +1,63 @@
+Given the following information, please provide an answer based on the provided documents and the context of the recent conversation.
+If the answer is not known or cannot be determined from the provided documents or context, please state that you do not know to the user.
+### Relevant Documents
+Use the following documents to answer the question:
+{% for doc in docs %}
+{{ loop.cycle("*")}}. {{ doc.metadata }}
+{{ doc.text }}
+{% endfor %}
+
+{% if citation_enabled %}
+### Citing Sources
+Find the sources from the documents that are most relevant to answering the question.
+The sources must be extracted from the given document metadata source property and not from the conversation context.
+If there are no relevant sources, write "No relevant sources" instead.
+
+For each source you cite, follow a 1-based numbering system for citations.
+Start with [1] for the first source you refer to, regardless of its index in the provided list of documents.
+If you cite another source, use the next number in sequence, [2], and so on.
+Ensure each source is only assigned one number, even if referenced multiple times.
+If you refer back to a previously cited source, use its originally assigned number.
+
+For example, if you first cite the third source in the list, refer to it as [1].
+If you then cite the first source in the list, refer to it as [2].
+If you mention the third source again, still refer to it as [1].
+
+Don't say "According to Source [1]" when answering. Instead, make references to sources relevant to each section of the answer solely by adding the bracketed number at the end of the relevant sentence.
+#### Formatting
+First print the answer with in-text citations which follow a numbered order starting with index 1, then add the sources section.
+The format of your overall answer must look like what's shown between the <example></example> tags.
+Make sure to follow the formatting exactly and remove any line breaks or whitespaces between the answer and the Sources section.
+<example>
+You can use flows to model business logic in Rasa assistants. [1] You can use the Enterprise Search Policy to search vector stores for relevant knowledge base documents. [2]
+Sources:
+[1] https://rasa.com/docs/rasa-pro/concepts/flows
+[2] https://rasa.com/docs/rasa-pro/concepts/policies/enterprise-search-policy
+</example>
+{% endif %}
+
+{% if slots|length > 0 %}
+### Slots or Variables
+Here are the variables of the currently active conversation which may be used to answer the question:
+{% for slot in slots -%}
+- name: {{ slot.name }}, value: {{ slot.value }}, type: {{ slot.type }}
+{% endfor %}
+{% endif %}
+### Current Conversation
+Transcript of the current conversation, use it to determine the context of the question:
+{{ current_conversation }}
+
+
+## Answering the Question
+Based on the above sections, please formulate an answer to the question or request in the user's last message.
+It is important that you ensure the answer is grounded in the provided documents and conversation context.
+Avoid speculating or making assumptions beyond the given information and keep your answers short, 2 to 3 sentences at most.
+
+{% if citation_enabled %}
+If you are unable to find an answer in the given relevant documents, do not cite sources from elsewhere in the conversation context.
+{% endif %}
+
+{% if check_relevancy %}
+If answer is not relevant output: "[NO_RELEVANT_ANSWER_FOUND]"
+{% endif %}
+Your answer:

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
@@ -31,22 +32,19 @@ from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
     LLM_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_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
@@ -63,7 +61,7 @@ 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,
@@ -111,14 +109,14 @@ NLU_ABSTENTION_THRESHOLD = "nlu_abstention_threshold"
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME,
-    "temperature": 0.0,
-    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TEMPERATURE_CONFIG_KEY: 0.0,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY: DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     TIMEOUT_CONFIG_KEY: 5,
 }
 
 DEFAULT_EMBEDDINGS_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
-    "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
 }
 
 DEFAULT_INTENTLESS_PROMPT_TEMPLATE = importlib.resources.open_text(
@@ -323,6 +321,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.
 
@@ -344,8 +345,6 @@ 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,
-            LLM_CONFIG_KEY: DEFAULT_LLM_CONFIG,
-            EMBEDDINGS_CONFIG_KEY: DEFAULT_EMBEDDINGS_CONFIG,
             PROMPT_CONFIG_KEY: DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
         }
 
@@ -378,16 +377,25 @@ 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
-        self.config[LLM_CONFIG_KEY] = resolve_model_client_config(
-            self.config.get(LLM_CONFIG_KEY), IntentlessPolicy.__name__
+        self.config[LLM_CONFIG_KEY] = combine_custom_and_default_config(
+            resolve_model_client_config(
+                self.config.get(LLM_CONFIG_KEY), IntentlessPolicy.__name__
+            ),
+            DEFAULT_LLM_CONFIG,
         )
 
         # Resolve embeddings config
-        self.config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
-            self.config.get(EMBEDDINGS_CONFIG_KEY), IntentlessPolicy.__name__
+        self.config[EMBEDDINGS_CONFIG_KEY] = combine_custom_and_default_config(
+            resolve_model_client_config(
+                self.config.get(EMBEDDINGS_CONFIG_KEY), IntentlessPolicy.__name__
+            ),
+            DEFAULT_EMBEDDINGS_CONFIG,
         )
 
         self.nlu_abstention_threshold: float = self.config[NLU_ABSTENTION_THRESHOLD]

rasa/core/processor.py

@@ -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()
@@ -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.
 
@@ -1577,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,
+                    )
+                )