rasa-pro 3.13.0.dev5__py3-none-any.whl → 3.13.0.dev8__py3-none-any.whl

rasa/shared/core/domain.py

@@ -32,6 +32,7 @@ from ruamel.yaml.scalarstring import DoubleQuotedScalarString
 import rasa.shared.core.slot_mappings
 import rasa.shared.utils.common
 import rasa.shared.utils.io
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.constants import (
     DEFAULT_CARRY_OVER_SLOTS_TO_NEW_SESSION,
     DEFAULT_SESSION_EXPIRATION_TIME_IN_MINUTES,
@@ -48,6 +49,7 @@ from rasa.shared.core.constants import (
     ACTION_SHOULD_SEND_DOMAIN,
     KEY_MAPPING_TYPE,
     KNOWLEDGE_BASE_SLOT_NAMES,
+    SILENCE_TIMEOUT_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
 )
@@ -306,6 +308,11 @@ class Domain:
         responses = data.get(KEY_RESPONSES, {})
 
         domain_slots = data.get(KEY_SLOTS, {})
+        for slot_name, slot in domain_slots.items():
+            if slot_name == SILENCE_TIMEOUT_SLOT:
+                slot["initial_value"] = (
+                    AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout
+                )
         slots = cls.collect_slots(domain_slots)
         domain_actions = data.get(KEY_ACTIONS, [])
         actions = cls._collect_action_names(domain_actions)

rasa/shared/core/events.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import abc
 import copy
 import json
@@ -6,7 +8,7 @@ import re
 import time
 import uuid
 from abc import ABC
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -107,6 +109,8 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
+INVALID_DATETIME_ERROR_MESSAGE = "`anonymized_at` must be a datetime object."
+
 
 def deserialise_events(serialized_events: List[Dict[Text, Any]]) -> List["Event"]:
     """Convert a list of dictionaries to a list of corresponding events.
@@ -451,6 +455,7 @@ class UserUttered(Event):
         message_id: Optional[Text] = None,
         metadata: Optional[Dict] = None,
         use_text_for_featurization: Optional[bool] = None,
+        anonymized_at: Optional[float] = None,
     ) -> None:
         """Creates event for incoming user message.
 
@@ -465,6 +470,7 @@ class UserUttered(Event):
             message_id: Unique ID for message.
             use_text_for_featurization: `True` if the message's text was used to predict
                 next action. `False` if the message's intent was used.
+            anonymized_at: When the event was anonymized in the tracker store.
 
         """
         self.text = text
@@ -498,6 +504,27 @@ class UserUttered(Event):
         if parse_data:
             self.parse_data.update(**parse_data)
 
+        self._anonymized_at: Optional[datetime] = (
+            datetime.fromtimestamp(anonymized_at, tz=timezone.utc)
+            if anonymized_at is not None
+            else None
+        )
+
+    @property
+    def anonymized_at(self) -> Optional[datetime]:
+        """Returns the time when the event was anonymized in the tracker store.
+
+        If the event was not anonymized, it returns None.
+        """
+        return self._anonymized_at
+
+    @anonymized_at.setter
+    def anonymized_at(self, value: Optional[datetime]) -> None:
+        """Sets the time when the event was anonymized in the tracker store."""
+        if value is not None and not isinstance(value, datetime):
+            raise ValueError(INVALID_DATETIME_ERROR_MESSAGE)
+        self._anonymized_at = value
+
     @staticmethod
     def _from_parse_data(
         text: Text,
@@ -506,6 +533,7 @@ class UserUttered(Event):
         input_channel: Optional[Text] = None,
         message_id: Optional[Text] = None,
         metadata: Optional[Dict] = None,
+        anonymized_at: Optional[float] = None,
     ) -> "UserUttered":
         return UserUttered(
             text,
@@ -516,6 +544,7 @@ class UserUttered(Event):
             input_channel,
             message_id,
             metadata,
+            anonymized_at,
         )
 
     def __hash__(self) -> int:
@@ -614,6 +643,9 @@ class UserUttered(Event):
                 "input_channel": getattr(self, "input_channel", None),
                 "message_id": getattr(self, "message_id", None),
                 "metadata": self.metadata,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
             }
         )
         return _dict
@@ -673,6 +705,7 @@ class UserUttered(Event):
                     parameters.get("input_channel"),
                     parameters.get("message_id"),
                     parameters.get("metadata"),
+                    parameters.get("anonymized_at"),
                 )
             ]
         except KeyError as e:
@@ -900,6 +933,7 @@ class BotUttered(SkipEventInMDStoryMixin):
         data: Optional[Dict] = None,
         metadata: Optional[Dict[Text, Any]] = None,
         timestamp: Optional[float] = None,
+        anonymized_at: Optional[float] = None,
     ) -> None:
         """Creates event for a bot response.
 
@@ -908,11 +942,32 @@ class BotUttered(SkipEventInMDStoryMixin):
             data: Additional data for more complex utterances (e.g. buttons).
             timestamp: When the event was created.
             metadata: Additional event metadata.
+            anonymized_at: When the event was anonymized in the tracker store.
         """
         self.text = text
         self.data = data or {}
+        self._anonymized_at: Optional[datetime] = (
+            datetime.fromtimestamp(anonymized_at, tz=timezone.utc)
+            if anonymized_at is not None
+            else None
+        )
         super().__init__(timestamp, metadata)
 
+    @property
+    def anonymized_at(self) -> Optional[datetime]:
+        """Returns the time when the event was anonymized in the tracker store.
+
+        If the event was not anonymized, it returns None.
+        """
+        return self._anonymized_at
+
+    @anonymized_at.setter
+    def anonymized_at(self, value: Optional[datetime]) -> None:
+        """Sets the time when the event was anonymized in the tracker store."""
+        if value is not None and not isinstance(value, datetime):
+            raise ValueError(INVALID_DATETIME_ERROR_MESSAGE)
+        self._anonymized_at = value
+
     def __members(self) -> Tuple[Optional[Text], Text, Text]:
         data_no_nones = {k: v for k, v in self.data.items() if v is not None}
         meta_no_nones = {k: v for k, v in self.metadata.items() if v is not None}
@@ -999,7 +1054,16 @@ class BotUttered(SkipEventInMDStoryMixin):
     def as_dict(self) -> Dict[Text, Any]:
         """Returns serialized event."""
         d = super().as_dict()
-        d.update({"text": self.text, "data": self.data, "metadata": self.metadata})
+        d.update(
+            {
+                "text": self.text,
+                "data": self.data,
+                "metadata": self.metadata,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
+            }
+        )
         return d
 
     @classmethod
@@ -1010,6 +1074,7 @@ class BotUttered(SkipEventInMDStoryMixin):
                 parameters.get("data"),
                 parameters.get("metadata"),
                 parameters.get("timestamp"),
+                parameters.get("anonymized_at"),
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse bot uttered event. {e}")
@@ -1034,6 +1099,7 @@ class SlotSet(Event):
         timestamp: Optional[float] = None,
         metadata: Optional[Dict[Text, Any]] = None,
         filled_by: Optional[str] = None,
+        anonymized_at: Optional[float] = None,
     ) -> None:
         """Creates event to set slot.
 
@@ -1046,8 +1112,28 @@ class SlotSet(Event):
         self.key = key
         self.value = value
         self._filled_by = filled_by
+        self._anonymized_at: Optional[datetime] = (
+            datetime.fromtimestamp(anonymized_at, tz=timezone.utc)
+            if anonymized_at is not None
+            else None
+        )
         super().__init__(timestamp, metadata)
 
+    @property
+    def anonymized_at(self) -> Optional[datetime]:
+        """Returns the time when the event was anonymized in the tracker store.
+
+        If the event was not anonymized, it returns None.
+        """
+        return self._anonymized_at
+
+    @anonymized_at.setter
+    def anonymized_at(self, value: Optional[datetime]) -> None:
+        """Sets the time when the event was anonymized in the tracker store."""
+        if value is not None and not isinstance(value, datetime):
+            raise ValueError(INVALID_DATETIME_ERROR_MESSAGE)
+        self._anonymized_at = value
+
     def __repr__(self) -> Text:
         """Returns text representation of event."""
         return f"SlotSet(key: {self.key}, value: {self.value})"
@@ -1092,7 +1178,16 @@ class SlotSet(Event):
     def as_dict(self) -> Dict[Text, Any]:
         """Returns serialized event."""
         d = super().as_dict()
-        d.update({"name": self.key, "value": self.value, "filled_by": self.filled_by})
+        d.update(
+            {
+                "name": self.key,
+                "value": self.value,
+                "filled_by": self.filled_by,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
+            }
+        )
         return d
 
     @classmethod
@@ -1104,6 +1199,7 @@ class SlotSet(Event):
                 parameters.get("timestamp"),
                 parameters.get("metadata"),
                 filled_by=parameters.get("filled_by"),
+                anonymized_at=parameters.get("anonymized_at"),
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse set slot event. {e}")

rasa/shared/core/flows/flow.py

@@ -406,8 +406,7 @@ class Flow:
             structlogger.error(
                 "command_generator.validate_flow_starting_conditions.error",
                 predicate=self.guard_condition,
-                context=context,
-                slots=slots,
+                flow_id=self.id,
                 error=str(e),
             )
             return False

rasa/shared/core/flows/flows_yaml_schema.json

@@ -244,6 +244,9 @@
                                         }
                                     }
                                 }
+                            },
+                            "silence_timeout": {
+                                "type": "number"
                             }
                         }
                     }

rasa/shared/core/flows/steps/collect.py

@@ -1,16 +1,23 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Set, Text
+from typing import Any, Dict, List, Optional, Set, Text, Union
+
+import structlog
 
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.slots import SlotRejection
+from rasa.shared.exceptions import RasaException
 
 DEFAULT_ASK_BEFORE_FILLING = False
 DEFAULT_RESET_AFTER_FLOW_ENDS = True
 DEFAULT_FORCE_SLOT_FILLING = False
 
+logger = structlog.get_logger(__name__)
+
+SilenceTimeoutInstructionType = Union[int, float, Dict[str, Any]]
+
 
 @dataclass
 class CollectInformationFlowStep(FlowStep):
@@ -30,6 +37,8 @@ class CollectInformationFlowStep(FlowStep):
     """Whether to reset the slot value at the end of the flow."""
     force_slot_filling: bool = False
     """Whether to keep only the SetSlot command for the collected slot."""
+    silence_timeout: Optional[float] = None
+    """The silence timeout for the collect information step."""
 
     @classmethod
     def from_json(
@@ -44,6 +53,11 @@ class CollectInformationFlowStep(FlowStep):
         Returns:
             A CollectInformationFlowStep object
         """
+
+        silence_timeout = cls._deserialise_silence_timeout(
+            data.get("silence_timeout", None)
+        )
+
         base = super().from_json(flow_id, data)
         return CollectInformationFlowStep(
             collect=data["collect"],
@@ -58,14 +72,40 @@ class CollectInformationFlowStep(FlowStep):
                 for rejection in data.get("rejections", [])
             ],
             force_slot_filling=data.get("force_slot_filling", False),
+            silence_timeout=silence_timeout,
             **base.__dict__,
         )
 
+    @staticmethod
+    def _deserialise_silence_timeout(
+        silence_timeout_json: Optional[SilenceTimeoutInstructionType],
+    ) -> Optional[float]:
+        """Deserialize silence timeout from JSON."""
+        if not silence_timeout_json:
+            return None
+
+        if not isinstance(silence_timeout_json, (int, float)):
+            raise RasaException(
+                f"Invalid silence timeout value: {silence_timeout_json}. "
+                "If defined at collect step, silence timeout must be a number."
+            )
+
+        silence_timeout = silence_timeout_json
+
+        if silence_timeout and silence_timeout < 0:
+            raise RasaException(
+                f"Invalid silence timeout value: {silence_timeout}. "
+                "Silence timeout must be a non-negative number."
+            )
+        return silence_timeout
+
     @staticmethod
     def _default_utter(collect: str) -> str:
         return f"{UTTER_ASK_PREFIX}{collect}"
 
-    def as_json(self) -> Dict[str, Any]:  # type: ignore[override]
+    def as_json(
+        self, step_properties: Optional[Dict[Text, Any]] = None
+    ) -> Dict[str, Any]:
         """Serialize the CollectInformationFlowStep object.
 
         Returns:
@@ -78,6 +118,9 @@ class CollectInformationFlowStep(FlowStep):
         data["reset_after_flow_ends"] = self.reset_after_flow_ends
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
         data["force_slot_filling"] = self.force_slot_filling
+        if self.silence_timeout:
+            data["silence_timeout"] = self.silence_timeout
+
         return super().as_json(step_properties=data)
 
     @property
@@ -100,6 +143,7 @@ class CollectInformationFlowStep(FlowStep):
                 and self.ask_before_filling == other.ask_before_filling
                 and self.reset_after_flow_ends == other.reset_after_flow_ends
                 and self.force_slot_filling == other.force_slot_filling
+                and self.silence_timeout == other.silence_timeout
                 and super().__eq__(other)
             )
         return False

rasa/shared/core/slots.py

@@ -311,6 +311,34 @@ class Slot(ABC):
         """Indicates if the slot requires validation."""
         return True if self.validation else False
 
+    def to_dict(
+        self,
+        *,
+        include_private: bool = False,
+    ) -> Dict[str, Any]:
+        """Return a dictionary with attributes of this slot instance.
+
+        Args:
+            include_private: If `True`, private attributes are included.
+
+        Returns:
+            A plain `dict` that can be JSON-serialised.
+        """
+        result: Dict[str, Any] = {}
+
+        for attr, value in vars(self).items():
+            if not include_private and attr.startswith("_"):
+                continue
+
+            if attr == "mappings":
+                result[attr] = [mapping.as_dict() for mapping in value]
+                continue
+
+            result[attr] = value
+
+        result.setdefault("type", self.type_name)
+        return result
+
 
 class FloatSlot(Slot):
     """A slot storing a float value."""

rasa/shared/exceptions.py

@@ -165,3 +165,7 @@ class ProviderClientAPIException(RasaException):
 
 class ProviderClientValidationError(RasaException):
     """Raised for errors that occur during validation of the API client."""
+
+
+class FinetuningDataPreparationException(RasaException):
+    """Raised when there is an error in data preparation for fine-tuning."""

rasa/shared/providers/_configs/azure_openai_client_config.py

@@ -23,6 +23,8 @@ from rasa.shared.constants import (
     DEPLOYMENT_NAME_CONFIG_KEY,
     ENGINE_CONFIG_KEY,
     LANGCHAIN_TYPE_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
+    MAX_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     N_REPHRASES_CONFIG_KEY,
@@ -71,6 +73,8 @@ DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
     MODEL_NAME_CONFIG_KEY: MODEL_CONFIG_KEY,
     # Timeout aliases
     REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+    # Max tokens aliases
+    MAX_TOKENS_CONFIG_KEY: MAX_COMPLETION_TOKENS_CONFIG_KEY,
 }
 
 REQUIRED_KEYS = [DEPLOYMENT_CONFIG_KEY]

rasa/shared/providers/_configs/openai_client_config.py

@@ -10,6 +10,8 @@ from rasa.shared.constants import (
     API_TYPE_CONFIG_KEY,
     API_VERSION_CONFIG_KEY,
     LANGCHAIN_TYPE_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
+    MAX_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     N_REPHRASES_CONFIG_KEY,
@@ -48,6 +50,8 @@ DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
     OPENAI_API_VERSION_CONFIG_KEY: API_VERSION_CONFIG_KEY,
     # Timeout aliases
     REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+    # Max tokens aliases
+    MAX_TOKENS_CONFIG_KEY: MAX_COMPLETION_TOKENS_CONFIG_KEY,
 }
 
 REQUIRED_KEYS = [MODEL_CONFIG_KEY]

rasa/shared/providers/embedding/_base_litellm_embedding_client.py

@@ -70,7 +70,10 @@ class _BaseLiteLLMEmbeddingClient:
     def _embedding_fn_args(self) -> Dict[str, Any]:
         """Returns the arguments to be passed to the embedding function."""
         return {
+            # Parameters set through config, can override drop_params
             **self._litellm_extra_parameters,
+            # Model name is constructed in the LiteLLM format from the provided config
+            # Non-overridable to ensure consistency
             "model": self._litellm_model_name,
         }
 

rasa/shared/providers/llm/_base_litellm_client.py

@@ -84,12 +84,15 @@ class _BaseLiteLLMClient:
     @property
     def _completion_fn_args(self) -> dict:
         return {
-            **self._litellm_extra_parameters,
-            "model": self._litellm_model_name,
             # Since all providers covered by LiteLLM use the OpenAI format, but
             # not all support every OpenAI parameter, raise an exception if
             # provider/model uses unsupported parameter
             "drop_params": False,
+            # All other parameters set through config, can override drop_params
+            **self._litellm_extra_parameters,
+            # Model name is constructed in the LiteLLM format from the provided config
+            # Non-overridable to ensure consistency
+            "model": self._litellm_model_name,
         }
 
     def validate_client_setup(self) -> None: