rasa-pro 3.12.0.dev9__py3-none-any.whl → 3.12.0.dev10__py3-none-any.whl

rasa/dialogue_understanding_test/test_case_simulation/test_case_tracker_simulator.py

@@ -20,7 +20,7 @@ from rasa.dialogue_understanding_test.test_case_simulation.exception import (
 )
 from rasa.dialogue_understanding_test.utils import filter_metadata
 from rasa.e2e_test.e2e_test_case import Fixture, Metadata
-from rasa.shared.core.constants import MAPPING_TYPE, SlotMappingType
+from rasa.shared.core.constants import KEY_MAPPING_TYPE, SlotMappingType
 from rasa.shared.core.events import BotUttered, SlotSet, UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import COMMANDS, ENTITIES, INTENT
@@ -329,7 +329,7 @@ class TestCaseTrackerSimulator:
                 # Use the SetSlotExtractor.NLU extractor if the slot mapping type is
                 # not FROM_LLM.
                 elif SlotMappingType.FROM_LLM.value not in [
-                    mapping[MAPPING_TYPE] for mapping in slot_definition.mappings
+                    mapping[KEY_MAPPING_TYPE] for mapping in slot_definition.mappings
                 ]:
                     command.extractor = SetSlotExtractor.NLU.value
 

rasa/shared/core/constants.py

@@ -51,6 +51,8 @@ ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
 ACTION_HANGUP = "action_hangup"
 ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
+ACTION_BLOCK_DIGRESSION = "action_block_digression"
+ACTION_CONTINUE_DIGRESSION = "action_continue_digression"
 
 ACTION_METADATA_EXECUTION_SUCCESS = "execution_success"
 ACTION_METADATA_EXECUTION_ERROR_MESSAGE = "execution_error_message"
@@ -81,6 +83,8 @@ DEFAULT_ACTION_NAMES = [
     ACTION_RESET_ROUTING,
     ACTION_HANGUP,
     ACTION_REPEAT_BOT_MESSAGES,
+    ACTION_BLOCK_DIGRESSION,
+    ACTION_CONTINUE_DIGRESSION,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"
@@ -137,7 +141,8 @@ DEFAULT_SLOT_NAMES = {
 
 SLOT_MAPPINGS = "mappings"
 MAPPING_CONDITIONS = "conditions"
-MAPPING_TYPE = "type"
+KEY_MAPPING_TYPE = "type"
+KEY_ALLOW_NLU_CORRECTION = "allow_nlu_correction"
 
 
 class SlotMappingType(Enum):
@@ -159,6 +164,18 @@ class SlotMappingType(Enum):
         return not (self == SlotMappingType.CUSTOM or self == SlotMappingType.FROM_LLM)
 
 
+class SetSlotExtractor(Enum):
+    """The extractors that can set a slot."""
+
+    LLM = "LLM"
+    COMMAND_PAYLOAD_READER = "CommandPayloadReader"
+    NLU = "NLU"
+    CUSTOM = "CUSTOM"
+
+    def __str__(self) -> str:
+        return self.value
+
+
 # the keys for `State` (USER, PREVIOUS_ACTION, SLOTS, ACTIVE_LOOP)
 # represent the origin of a `SubState`
 USER = "user"
@@ -181,3 +198,7 @@ POLICY_NAME_RULE = "RulePolicy"
 CLASSIFIER_NAME_FALLBACK = "FallbackClassifier"
 
 POLICIES_THAT_EXTRACT_ENTITIES = {"TEDPolicy"}
+
+# digression constants
+KEY_ASK_CONFIRM_DIGRESSIONS = "ask_confirm_digressions"
+KEY_BLOCK_DIGRESSIONS = "block_digressions"

rasa/shared/core/domain.py

@@ -47,9 +47,9 @@ from rasa.shared.constants import (
 from rasa.shared.core.constants import (
     ACTION_SHOULD_SEND_DOMAIN,
     ACTIVE_LOOP,
+    KEY_MAPPING_TYPE,
     KNOWLEDGE_BASE_SLOT_NAMES,
     MAPPING_CONDITIONS,
-    MAPPING_TYPE,
     SLOT_MAPPINGS,
     SlotMappingType,
 )
@@ -596,7 +596,7 @@ class Domain:
                     ),
                 )
                 slot_dict[slot_name][SLOT_MAPPINGS] = [
-                    {MAPPING_TYPE: SlotMappingType.FROM_LLM.value}
+                    {KEY_MAPPING_TYPE: SlotMappingType.FROM_LLM.value}
                 ]
 
             slot = slot_class(slot_name, **slot_dict[slot_name])
@@ -1570,7 +1570,9 @@ class Domain:
 
                 for mapping in slot.mappings:
                     mapping_conditions = mapping.get(MAPPING_CONDITIONS)
-                    if mapping[MAPPING_TYPE] != str(SlotMappingType.FROM_ENTITY) or (
+                    if mapping[KEY_MAPPING_TYPE] != str(
+                        SlotMappingType.FROM_ENTITY
+                    ) or (
                         mapping_conditions
                         and mapping_conditions[0].get(ACTIVE_LOOP) is not None
                     ):
@@ -2021,7 +2023,7 @@ class Domain:
         for slot in self.slots:
             total_mappings += len(slot.mappings)
             for mapping in slot.mappings:
-                if mapping[MAPPING_TYPE] == str(SlotMappingType.CUSTOM):
+                if mapping[KEY_MAPPING_TYPE] == str(SlotMappingType.CUSTOM):
                     custom_mappings += 1
 
                 if MAPPING_CONDITIONS in mapping:

rasa/shared/core/events.py

@@ -1032,6 +1032,7 @@ class SlotSet(Event):
         value: Optional[Any] = None,
         timestamp: Optional[float] = None,
         metadata: Optional[Dict[Text, Any]] = None,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Creates event to set slot.
 
@@ -1043,6 +1044,7 @@ class SlotSet(Event):
         """
         self.key = key
         self.value = value
+        self._filled_by = filled_by
         super().__init__(timestamp, metadata)
 
     def __repr__(self) -> Text:
@@ -1060,6 +1062,14 @@ class SlotSet(Event):
 
         return (self.key, self.value) == (other.key, other.value)
 
+    @property
+    def filled_by(self) -> Optional[str]:
+        return self._filled_by
+
+    @filled_by.setter
+    def filled_by(self, value: str) -> None:
+        self._filled_by = value
+
     def as_story_string(self) -> Text:
         """Returns text representation of event."""
         props = json.dumps({self.key: self.value}, ensure_ascii=False)
@@ -1081,7 +1091,7 @@ 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})
+        d.update({"name": self.key, "value": self.value, "filled_by": self.filled_by})
         return d
 
     @classmethod
@@ -1092,13 +1102,14 @@ class SlotSet(Event):
                 parameters.get("value"),
                 parameters.get("timestamp"),
                 parameters.get("metadata"),
+                filled_by=parameters.get("filled_by"),
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse set slot event. {e}")
 
     def apply_to(self, tracker: "DialogueStateTracker") -> None:
         """Applies event to current conversation state."""
-        tracker._set_slot(self.key, self.value)
+        tracker._set_slot(self.key, self.value, self.filled_by)
 
 
 class Restarted(AlwaysEqualEventMixin):

rasa/shared/core/flows/flow.py

@@ -11,6 +11,10 @@ from pypred import Predicate
 
 import rasa.shared.utils.io
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.constants import (
+    KEY_ASK_CONFIRM_DIGRESSIONS,
+    KEY_BLOCK_DIGRESSIONS,
+)
 from rasa.shared.core.flows.flow_path import FlowPath, FlowPathsList, PathNode
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.flows.flow_step_links import (
@@ -33,6 +37,7 @@ from rasa.shared.core.flows.steps.constants import (
     START_STEP,
 )
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
+from rasa.shared.core.flows.utils import extract_digression_prop
 from rasa.shared.core.slots import Slot
 
 structlogger = structlog.get_logger()
@@ -62,6 +67,10 @@ class Flow:
     """The path to the file where the flow is stored."""
     persisted_slots: List[str] = field(default_factory=list)
     """The list of slots that should be persisted after the flow ends."""
+    ask_confirm_digressions: List[str] = field(default_factory=list)
+    """The flow ids for which the assistant should ask for confirmation."""
+    block_digressions: List[str] = field(default_factory=list)
+    """The flow ids that the assistant should block from digressing to."""
 
     @staticmethod
     def from_json(
@@ -98,6 +107,10 @@ class Flow:
             # data. When the model is trained, take the provided file_path.
             file_path=data.get("file_path") if "file_path" in data else file_path,
             persisted_slots=data.get("persisted_slots", []),
+            ask_confirm_digressions=extract_digression_prop(
+                KEY_ASK_CONFIRM_DIGRESSIONS, data
+            ),
+            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
         )
 
     def get_full_name(self) -> str:
@@ -172,6 +185,10 @@ class Flow:
             data["file_path"] = self.file_path
         if self.persisted_slots:
             data["persisted_slots"] = self.persisted_slots
+        if self.ask_confirm_digressions:
+            data[KEY_ASK_CONFIRM_DIGRESSIONS] = self.ask_confirm_digressions
+        if self.block_digressions:
+            data[KEY_BLOCK_DIGRESSIONS] = self.block_digressions
 
         return data
 

rasa/shared/core/flows/flows_yaml_schema.json

@@ -217,6 +217,12 @@
                             "reset_after_flow_ends": {
                                 "type": "boolean"
                             },
+                            "ask_confirm_digressions": {
+                                "$ref": "#/$defs/ask_confirm_digressions"
+                            },
+                            "block_digressions": {
+                                "$ref": "#/$defs/block_digressions"
+                            },
                             "utter": {
                                 "type": "string"
                             },
@@ -247,6 +253,32 @@
                 }
             }
         },
+        "ask_confirm_digressions": {
+            "oneOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            ]
+        },
+        "block_digressions": {
+            "oneOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            ]
+        },
         "flow": {
             "required": [
                 "steps",
@@ -282,6 +314,12 @@
                 },
                 "persisted_slots": {
                     "$ref": "#/$defs/persisted_slots"
+                },
+                "ask_confirm_digressions": {
+                    "$ref": "#/$defs/ask_confirm_digressions"
+                },
+                "block_digressions": {
+                    "$ref": "#/$defs/block_digressions"
                 }
             }
         },

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

@@ -1,10 +1,15 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any, Dict, List, Set, Text
 
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
+from rasa.shared.core.constants import (
+    KEY_ASK_CONFIRM_DIGRESSIONS,
+    KEY_BLOCK_DIGRESSIONS,
+)
 from rasa.shared.core.flows.flow_step import FlowStep
+from rasa.shared.core.flows.utils import extract_digression_prop
 
 
 @dataclass
@@ -59,6 +64,10 @@ class CollectInformationFlowStep(FlowStep):
     """Whether to always ask the question even if the slot is already filled."""
     reset_after_flow_ends: bool = True
     """Whether to reset the slot value at the end of the flow."""
+    ask_confirm_digressions: List[str] = field(default_factory=list)
+    """The flow id digressions for which the assistant should ask for confirmation."""
+    block_digressions: List[str] = field(default_factory=list)
+    """The flow id digressions that should be blocked during the flow step."""
 
     @classmethod
     def from_json(
@@ -86,6 +95,10 @@ class CollectInformationFlowStep(FlowStep):
                 SlotRejection.from_dict(rejection)
                 for rejection in data.get("rejections", [])
             ],
+            ask_confirm_digressions=extract_digression_prop(
+                KEY_ASK_CONFIRM_DIGRESSIONS, data
+            ),
+            block_digressions=extract_digression_prop(KEY_BLOCK_DIGRESSIONS, data),
             **base.__dict__,
         )
 
@@ -101,6 +114,10 @@ class CollectInformationFlowStep(FlowStep):
         data["ask_before_filling"] = self.ask_before_filling
         data["reset_after_flow_ends"] = self.reset_after_flow_ends
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
+        data["ask_confirm_digressions"] = self.ask_confirm_digressions
+        data["block_digressions"] = (
+            self.block_digressions if self.block_digressions else False
+        )
 
         return data
 

rasa/shared/core/flows/utils.py

@@ -1,9 +1,10 @@
-from typing import Set
+from typing import Any, Dict, List, Set
 
 from rasa.shared.utils.io import raise_deprecation_warning
 
 RESET_PROPERTY_NAME = "reset_after_flow_ends"
 PERSIST_PROPERTY_NAME = "persisted_slots"
+ALL_LABEL = "ALL"
 
 
 def warn_deprecated_collect_step_config(flow_id: str, collect_step: str) -> None:
@@ -38,3 +39,17 @@ def get_invalid_slot_persistence_config_error_message(
         f"are neither used in a collect step nor a set_slot step of the flow. "
         f"Please remove such slots from the '{PERSIST_PROPERTY_NAME}' property."
     )
+
+
+def extract_digression_prop(prop: str, data: Dict[str, Any]) -> List[str]:
+    """Extracts the digression property from the data.
+
+    There can be two types of properties: ask_confirm_digressions and
+    block_digressions.
+    """
+    digression_property = data.get(prop, [])
+
+    if isinstance(digression_property, bool):
+        digression_property = [ALL_LABEL] if digression_property else []
+
+    return digression_property

rasa/shared/core/slot_mappings.py

@@ -6,8 +6,8 @@ from rasa.shared.constants import DOCS_URL_NLU_BASED_SLOTS, IGNORED_INTENTS
 from rasa.shared.core.constants import (
     ACTIVE_FLOW,
     ACTIVE_LOOP,
+    KEY_MAPPING_TYPE,
     MAPPING_CONDITIONS,
-    MAPPING_TYPE,
     REQUESTED_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
@@ -59,11 +59,11 @@ class SlotMapping:
             )
 
         try:
-            mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
+            mapping_type = SlotMappingType(mapping.get(KEY_MAPPING_TYPE))
         except ValueError:
             raise InvalidDomain(
                 f"Your domain uses an invalid slot mapping of type "
-                f"'{mapping.get(MAPPING_TYPE)}' for slot '{slot_name}'. Please see "
+                f"'{mapping.get(KEY_MAPPING_TYPE)}' for slot '{slot_name}'. Please see "
                 f"{DOCS_URL_NLU_BASED_SLOTS} for more information."
             )
 
@@ -299,7 +299,7 @@ class SlotFillingManager:
     def _verify_mapping_conditions(
         self, mapping: Dict[Text, Any], slot_name: Text
     ) -> bool:
-        if mapping.get(MAPPING_CONDITIONS) and mapping[MAPPING_TYPE] != str(
+        if mapping.get(MAPPING_CONDITIONS) and mapping[KEY_MAPPING_TYPE] != str(
             SlotMappingType.FROM_TRIGGER_INTENT
         ):
             if not self._matches_mapping_conditions(mapping, slot_name):
@@ -374,7 +374,7 @@ class SlotFillingManager:
     ) -> bool:
         from rasa.core.actions.forms import FormAction
 
-        if mapping[MAPPING_TYPE] != str(SlotMappingType.FROM_ENTITY):
+        if mapping[KEY_MAPPING_TYPE] != str(SlotMappingType.FROM_ENTITY):
             return False
 
         form_name = self.tracker.active_loop_name
@@ -495,7 +495,7 @@ def extract_slot_value(
 
     for mapping in slot.mappings:
         mapping_type = SlotMappingType(
-            mapping.get(MAPPING_TYPE, SlotMappingType.FROM_LLM.value)
+            mapping.get(KEY_MAPPING_TYPE, SlotMappingType.FROM_LLM.value)
         )
 
         if mapping_type in [SlotMappingType.FROM_LLM, SlotMappingType.CUSTOM]:

rasa/shared/core/slots.py

@@ -41,6 +41,7 @@ class Slot(ABC):
         influence_conversation: bool = True,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Create a Slot.
 
@@ -57,6 +58,7 @@ class Slot(ABC):
                 such as `return_value`.
             shared_for_coexistence: If `True` the slot is not forgotten after either
                 dm1 or CALM finishes.
+            filled_by: The name of the extractor that fills the slot.
         """
         self.name = name
         self.mappings = mappings
@@ -67,6 +69,7 @@ class Slot(ABC):
         self._has_been_set = False
         self.is_builtin = is_builtin
         self.shared_for_coexistence = shared_for_coexistence
+        self._filled_by = filled_by
 
     def feature_dimensionality(self) -> int:
         """How many features this single slot creates.
@@ -132,6 +135,16 @@ class Slot(ABC):
         self._value = value
         self._has_been_set = True
 
+    @property
+    def filled_by(self) -> Optional[str]:
+        """Gets the slot's latest value extractor."""
+        return self._filled_by
+
+    @filled_by.setter
+    def filled_by(self, extractor: str) -> None:
+        """Sets the slot's latest value extractor."""
+        self._filled_by = extractor
+
     def has_same_coerced_value(self, other_value: Any) -> bool:
         """Checks if the coerced value of is the same as the slot value.
 
@@ -215,6 +228,7 @@ class FloatSlot(Slot):
         influence_conversation: bool = True,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Creates a FloatSlot.
 
@@ -230,6 +244,7 @@ class FloatSlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
+            filled_by=filled_by,
         )
         self.max_value = max_value
         self.min_value = min_value
@@ -387,6 +402,7 @@ class CategoricalSlot(Slot):
         influence_conversation: bool = True,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Creates a `Categorical  Slot` (see parent class for detailed docstring)."""
         super().__init__(
@@ -397,6 +413,7 @@ class CategoricalSlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
+            filled_by=filled_by,
         )
         if values and None in values:
             rasa.shared.utils.io.raise_warning(
@@ -607,6 +624,7 @@ class AnySlot(Slot):
         influence_conversation: bool = False,
         is_builtin: bool = False,
         shared_for_coexistence: bool = False,
+        filled_by: Optional[str] = None,
     ) -> None:
         """Creates an `Any  Slot` (see parent class for detailed docstring).
 
@@ -630,6 +648,7 @@ class AnySlot(Slot):
             influence_conversation,
             is_builtin,
             shared_for_coexistence,
+            filled_by=filled_by,
         )
 
     def __eq__(self, other: Any) -> bool:

rasa/shared/core/trackers.py

@@ -916,11 +916,13 @@ class DialogueStateTracker:
                 continue
             slot.reset()
 
-    def _set_slot(self, key: Text, value: Any) -> None:
+    def _set_slot(self, key: Text, value: Any, filled_by: Optional[str] = None) -> None:
         """Sets the value of a slot if that slot exists."""
         if key in self.slots:
             slot = self.slots[key]
             slot.value = value
+            if filled_by is not None:
+                slot.filled_by = filled_by
         else:
             logger.error(
                 f"Tried to set non existent slot '{key}'. Make sure you "

rasa/shared/nlu/constants.py

@@ -55,3 +55,4 @@ SPLIT_ENTITIES_BY_COMMA_DEFAULT_VALUE = True
 SINGLE_ENTITY_ALLOWED_INTERLEAVING_CHARSET = {".", ",", " ", ";"}
 
 SET_SLOT_COMMAND = "set slot"
+HANDLE_DIGRESSIONS_COMMAND = "handle digressions"

rasa/shared/providers/llm/_base_litellm_client.py

@@ -181,46 +181,6 @@ class _BaseLiteLLMClient:
                 )
             raise ProviderClientAPIException(e, message)
 
-    @suppress_logs(log_level=logging.WARNING)
-    async def acompletion_with_system(
-        self, formatted_messages: Union[List[str], str]
-    ) -> LLMResponse:
-        """Asynchronously generate completions for given list of messages.
-
-        Args:
-            messages: List of messages or a single message to generate the
-                completion for.
-
-        Returns:
-            List of message completions.
-
-        Raises:
-            ProviderClientAPIException: If the API request fails.
-        """
-        try:
-            # formatted_messages = self._format_messages(messages)
-            arguments = resolve_environment_variables(self._completion_fn_args)
-            response = await acompletion(messages=formatted_messages, **arguments)
-            return self._format_response(response)
-        except Exception as e:
-            message = ""
-            from rasa.shared.providers.llm.self_hosted_llm_client import (
-                SelfHostedLLMClient,
-            )
-
-            if isinstance(self, SelfHostedLLMClient):
-                message = (
-                    "If you are using 'provider=self-hosted' to call a hosted vllm "
-                    "server make sure your config is correctly setup. You should have "
-                    "the following mandatory keys in your config: "
-                    "provider=self-hosted; "
-                    "model='<your-vllm-model-name>'; "
-                    "api_base='your-hosted-vllm-serv'."
-                    "In case you are getting OpenAI connection errors, such as missing "
-                    "API key, your configuration is incorrect."
-                )
-            raise ProviderClientAPIException(e, message)
-
     def _format_messages(self, messages: Union[List[str], str]) -> List[Dict[str, str]]:
         """Formats messages (or a single message) to OpenAI format."""
         if isinstance(messages, str):

rasa/shared/utils/llm.py

@@ -6,7 +6,6 @@ from typing import (
     Any,
     Callable,
     Dict,
-    List,
     Optional,
     Text,
     Type,
@@ -238,90 +237,6 @@ def tracker_as_readable_transcript(
     return "\n".join(transcript)
 
 
-def sanitize_command_for_prompt(cmd_dict):
-    command = ""
-    if cmd_dict["command"] == "start flow":
-        command = f"start {cmd_dict['flow']}"
-    elif cmd_dict["command"] == "set slot":
-        command = f"set {cmd_dict['name']} {cmd_dict['value']}"
-    elif cmd_dict["command"] == "skip question":
-        command = "skip"
-    elif cmd_dict["command"] == "clarify":
-        command = f"clarify {' '.join(cmd_dict['options'])}"
-    elif cmd_dict["command"] == "knowledge":
-        command = "search"
-    elif cmd_dict["command"] == "chitchat":
-        command = "chat"
-    elif cmd_dict["command"] == "cancel flow":
-        command = "cancel"
-    else:
-        command = cmd_dict["command"]
-
-    return command
-
-
-def tracker_as_message_list(
-    tracker: "DialogueStateTracker",
-    max_turns: Optional[int] = 20,
-) -> List[str]:
-    """Creates a readable dialogue from a tracker.
-
-    Args:
-        tracker: the tracker to convert
-        max_turns: the maximum number of turns to include in the transcript
-
-    Example:
-        >>> tracker = Tracker(
-        ...     sender_id="test",
-        ...     slots=[],
-        ...     events=[
-        ...         UserUttered("hello"),
-        ...         BotUttered("hi"),
-        ...     ],
-        ... )
-        >>> tracker_as_readable_transcript(tracker)
-        USER: hello
-        AI: hi
-
-    Returns:
-    A string representing the transcript of the tracker
-    """
-    messages = []
-
-    # using `applied_events` rather than `events` means that only events after the
-    # most recent `Restart` or `SessionStarted` are included in the transcript
-    # last_commands = None
-    for event in tracker.applied_events():
-        if isinstance(event, UserUttered):
-            if event.has_triggered_error:
-                first_error = event.error_commands[0]
-                error_type = first_error.get("error_type")
-                message = ERROR_PLACEHOLDER.get(
-                    error_type, ERROR_PLACEHOLDER["default"]
-                )
-            else:
-                message = sanitize_message_for_prompt(event.text)
-                # last_commands = event.commands
-            messages.append({"role": "user", "content": message})
-            # messages.append({"role": "system", "content": ' \n '.join([sanitize_command_for_prompt(cmd) for cmd in last_commands])})  # noqa: E501
-            # transcript.append(f"{human_prefix}: {message}")
-
-        elif isinstance(event, BotUttered):
-            messages.append(
-                {
-                    "role": "assistant",
-                    "content": f"{sanitize_message_for_prompt(event.text)}",
-                }
-            )
-            # transcript.append(f"{ai_prefix}: {sanitize_message_for_prompt(event.text)}")  # noqa: E501
-
-    if max_turns:
-        messages = messages[-max_turns:]
-        # transcript = transcript[-max_turns:]
-
-    return messages
-
-
 def sanitize_message_for_prompt(text: Optional[str]) -> str:
     """Removes new lines from a string.
 
@@ -765,7 +680,7 @@ def allowed_values_for_slot(slot: Slot) -> Union[str, None]:
     if isinstance(slot, BooleanSlot):
         return str([True, False])
     if isinstance(slot, CategoricalSlot):
-        return str([v for v in slot.values if v != "__other__"] + ["other"])
+        return str([v for v in slot.values if v != "__other__"])
     else:
         return None
 

rasa/shared/utils/schemas/domain.yml

@@ -78,7 +78,6 @@ mapping:
           mappings:
            type: "seq"
            required: False
-           allowempty: False
            sequence:
               - type: "map"
                 allowempty: True