rasa-pro 3.12.0rc2__py3-none-any.whl → 3.12.1.dev1__py3-none-any.whl

rasa/engine/language.py

@@ -2,6 +2,8 @@ from dataclasses import dataclass
 from typing import Any, Dict, Text
 
 from langcodes import Language as LangcodesLanguage
+from langcodes import standardize_tag
+from langcodes.tag_parser import LanguageTagError
 
 from rasa.shared.exceptions import RasaException
 
@@ -30,9 +32,14 @@ class Language:
         Raises:
             RasaException: If the language code or custom language code is invalid.
         """
-        language = LangcodesLanguage.make(language_code)
-        cls.validate_language(language)
+        if cls.is_custom_language_code(language_code):
+            cls.validate_custom_language_code(language_code)
+        elif not cls.is_language_code_bcp_47_standard(language_code):
+            raise RasaException(
+                f"Language '{language_code}' is not a BCP 47 standard language code."
+            )
 
+        language = LangcodesLanguage.get(language_code)
         return cls(
             code=language_code,
             label=cls.get_language_label(language),
@@ -40,7 +47,38 @@ class Language:
         )
 
     @staticmethod
-    def get_language_label(language: LangcodesLanguage) -> str:
+    def is_language_code_bcp_47_standard(language_code: str) -> bool:
+        """Checks if a language code is a BCP 47 standard language code.
+
+        Args:
+            language_code: The language code to check.
+
+        Returns:
+            `True` if the language code is a BCP 47 standard, `False` otherwise.
+        """
+        try:
+            standardized_language_code = standardize_tag(language_code)
+            return (
+                standardized_language_code == language_code
+                and LangcodesLanguage.get(language_code).is_valid()
+            )
+        except LanguageTagError:
+            return False
+
+    @staticmethod
+    def is_custom_language_code(language_code: str) -> bool:
+        """Checks if a language code is a custom language code.
+
+        Args:
+            language_code: The language code to check.
+
+        Returns:
+            `True` if the language code is a custom language code, `False` otherwise.
+        """
+        return language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX)
+
+    @classmethod
+    def get_language_label(cls, language: LangcodesLanguage) -> str:
         """Gets the display name of a language.
 
         For custom languages (in the format "x-<base_lang>-<custom_label>"),
@@ -55,11 +93,11 @@ class Language:
         """
         language_code = str(language)
 
-        if language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
+        if cls.is_custom_language_code(language_code):
             # If it's a custom language, derive the label from the base language code.
-            parts = language_code.split("-")
-            base_language_code = parts[1]
-            base_language = LangcodesLanguage.make(base_language_code)
+            without_prefix = language_code[len(CUSTOM_LANGUAGE_CODE_PREFIX) :]
+            base_language_code, _ = without_prefix.rsplit("-", 1)
+            base_language = LangcodesLanguage.get(base_language_code)
             return base_language.display_name()
         else:
             return language.display_name()
@@ -79,15 +117,15 @@ class Language:
 
         language_code = str(language)
         if language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
-            cls.validate_custom_language(language_code)
+            cls.validate_custom_language_code(language_code)
 
-    @staticmethod
-    def validate_custom_language(custom_language_code: str) -> None:
+    @classmethod
+    def validate_custom_language_code(cls, custom_language_code: str) -> None:
         """Validates a custom language code.
 
         A valid custom language code should adhere to the format:
           "x-<existing_language_code>-<custom_label>"
-        Example: x-en-formal
+        Example: x-en-formal or x-en-US-formal.
 
         Args:
             custom_language_code: The custom language code to validate.
@@ -102,29 +140,33 @@ class Language:
                 f"start with '{CUSTOM_LANGUAGE_CODE_PREFIX}'."
             )
 
-        # Split the language code into parts.
-        parts = custom_language_code.split("-")
-        if len(parts) != 3:
+        # Remove the custom prefix.
+        without_prefix = custom_language_code[len(CUSTOM_LANGUAGE_CODE_PREFIX) :]
+        if "-" not in without_prefix:
             raise RasaException(
                 f"Custom language '{custom_language_code}' must be in the format "
                 f"'{CUSTOM_LANGUAGE_CODE_PREFIX}<language_code>-<custom_label>'."
             )
 
-        # Validate the base language code using langcodes.
-        base_language_code = parts[1]
-        base_language = LangcodesLanguage.make(base_language_code)
-        if not base_language.is_valid():
+        base_language_code, custom_label = without_prefix.rsplit("-", 1)
+        if not base_language_code:
             raise RasaException(
-                f"Base language '{base_language_code}' in custom language "
-                f"'{custom_language_code}' is not a valid language code."
+                f"Base language in '{custom_language_code}' cannot be empty. "
+                f"Expected custom language code format is "
+                f"'{CUSTOM_LANGUAGE_CODE_PREFIX}<language_code>-<custom_label>'."
             )
-
-        # Ensure the custom label is not empty.
-        custom_label = parts[2]
         if not custom_label:
             raise RasaException(
-                f"Custom label in custom language "
-                f"'{custom_language_code}' cannot be empty."
+                f"Custom label in '{custom_language_code}' cannot be empty."
+                f"Expected custom language code format is "
+                f"'{CUSTOM_LANGUAGE_CODE_PREFIX}<language_code>-<custom_label>'."
+            )
+
+        # Validate the base language code using langcodes.
+        if not cls.is_language_code_bcp_47_standard(base_language_code):
+            raise RasaException(
+                f"Base language '{base_language_code}' in custom language "
+                f"'{custom_language_code}' is not a valid language code."
             )
 
     def as_dict(self) -> Dict[Text, Any]:

rasa/engine/validation.py

@@ -89,6 +89,7 @@ from rasa.shared.core.flows import Flow, FlowsList
 from rasa.shared.core.slots import Slot
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.utils.common import display_research_study_prompt
 
 TypeAnnotation = Union[TypeVar, Text, Type, Optional[AvailableEndpoints]]
 
@@ -1449,4 +1450,5 @@ def validate_api_type_config_key_usage(
                     f"For other providers, please use the '{PROVIDER_CONFIG_KEY}' key."
                 ),
             )
+            display_research_study_prompt()
             sys.exit(1)

rasa/llm_fine_tuning/conversations.py

@@ -1,17 +1,7 @@
 from dataclasses import dataclass, field
 from typing import Any, Dict, Iterator, List, Optional, Union
 
-from rasa.dialogue_understanding.commands import (
-    CancelFlowCommand,
-    ChitChatAnswerCommand,
-    ClarifyCommand,
-    Command,
-    HumanHandoffCommand,
-    KnowledgeAnswerCommand,
-    SetSlotCommand,
-    SkipQuestionCommand,
-    StartFlowCommand,
-)
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.e2e_test.e2e_test_case import TestCase, TestStep
 from rasa.shared.core.constants import USER
 
@@ -19,7 +9,7 @@ from rasa.shared.core.constants import USER
 @dataclass
 class ConversationStep:
     original_test_step: TestStep
-    llm_commands: List[Command]
+    llm_commands: List[PromptCommand]
     llm_prompt: str
     failed_rephrasings: List[str] = field(default_factory=list)
     passed_rephrasings: List[str] = field(default_factory=list)
@@ -38,25 +28,7 @@ class ConversationStep:
         return data
 
     def _commands_to_str(self) -> List[str]:
-        output = []
-        for command in self.llm_commands:
-            if isinstance(command, StartFlowCommand):
-                output.append(f"StartFlow({command.flow})")
-            elif isinstance(command, SetSlotCommand):
-                output.append(f"SetSlot({command.name}, {command.value})")
-            elif isinstance(command, ClarifyCommand):
-                output.append(f"Clarify({', '.join(command.options)})")
-            elif isinstance(command, CancelFlowCommand):
-                output.append("CancelFlow()")
-            elif isinstance(command, ChitChatAnswerCommand):
-                output.append("ChitChat()")
-            elif isinstance(command, SkipQuestionCommand):
-                output.append("SkipQuestion()")
-            elif isinstance(command, KnowledgeAnswerCommand):
-                output.append("SearchAndReply()")
-            elif isinstance(command, HumanHandoffCommand):
-                output.append("HumanHandoff()")
-        return output
+        return [command.to_dsl() for command in self.llm_commands]
 
     def commands_as_string(self) -> str:
         return "\n".join(self._commands_to_str())

rasa/llm_fine_tuning/llm_data_preparation_module.py

@@ -4,8 +4,10 @@ from typing import Any, Dict, List, Optional
 import structlog
 from tqdm import tqdm
 
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.llm_fine_tuning.conversations import Conversation, ConversationStep
 from rasa.llm_fine_tuning.storage import StorageContext
+from rasa.llm_fine_tuning.utils import commands_as_string
 
 LLM_DATA_PREPARATION_MODULE_STORAGE_LOCATION = "3_llm_finetune_data/llm_ft_data.jsonl"
 
@@ -15,7 +17,7 @@ structlogger = structlog.get_logger()
 @dataclass
 class LLMDataExample:
     prompt: str
-    output: str
+    output: List[PromptCommand]
     original_test_name: str
     original_user_utterance: str
     rephrased_user_utterance: str
@@ -23,7 +25,7 @@ class LLMDataExample:
     def as_dict(self) -> Dict[str, Any]:
         return {
             "prompt": self.prompt,
-            "output": self.output,
+            "output": commands_as_string(self.output),
             "original_test_name": self.original_test_name,
             "original_user_utterance": self.original_user_utterance,
             "rephrased_user_utterance": self.rephrased_user_utterance,
@@ -38,7 +40,7 @@ def _create_data_point(
 ) -> LLMDataExample:
     return LLMDataExample(
         prompt,
-        step.commands_as_string(),
+        step.llm_commands,
         conversation.get_full_name(),
         step.original_test_step.text,
         rephrased_user_message,

rasa/llm_fine_tuning/paraphrasing/rephrase_validator.py

@@ -1,18 +1,18 @@
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Type
 
 import structlog
 
 from rasa.dialogue_understanding.commands import Command, SetSlotCommand
-from rasa.dialogue_understanding.generator import SingleStepLLMCommandGenerator
+from rasa.dialogue_understanding.generator.llm_based_command_generator import (
+    LLMBasedCommandGenerator,
+)
 from rasa.llm_fine_tuning.conversations import Conversation, ConversationStep
 from rasa.llm_fine_tuning.paraphrasing.rephrased_user_message import (
     RephrasedUserMessage,
 )
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.exceptions import ProviderClientAPIException
-from rasa.shared.utils.llm import (
-    llm_factory,
-)
+from rasa.shared.utils.llm import llm_factory
 
 structlogger = structlog.get_logger()
 
@@ -26,6 +26,7 @@ class RephraseValidator:
         self,
         rephrasings: List[RephrasedUserMessage],
         conversation: Conversation,
+        llm_command_generator: Type[LLMBasedCommandGenerator],
     ) -> List[RephrasedUserMessage]:
         """Split rephrased user messages into passing and failing.
 
@@ -38,6 +39,7 @@ class RephraseValidator:
         Args:
             rephrasings: The rephrased user messages.
             conversation: The conversation.
+            llm_command_generator: A LLM based command generator class.
 
         Returns:
             A list of rephrased user messages including the passing and failing
@@ -49,7 +51,9 @@ class RephraseValidator:
             current_rephrasings = rephrasings[i]
 
             for rephrase in current_rephrasings.rephrasings:
-                if await self._validate_rephrase_is_passing(rephrase, step):
+                if await self._validate_rephrase_is_passing(
+                    rephrase, step, llm_command_generator
+                ):
                     current_rephrasings.passed_rephrasings.append(rephrase)
                 else:
                     current_rephrasings.failed_rephrasings.append(rephrase)
@@ -60,25 +64,26 @@ class RephraseValidator:
         self,
         rephrase: str,
         step: ConversationStep,
+        llm_command_generator: Type[LLMBasedCommandGenerator],
     ) -> bool:
         prompt = self._update_prompt(
             rephrase, step.original_test_step.text, step.llm_prompt
         )
 
-        action_list = await self._invoke_llm(prompt)
+        action_list = await self._invoke_llm(
+            prompt, llm_command_generator.get_default_llm_config()
+        )
 
         commands_from_original_utterance = step.llm_commands
-        commands_from_rephrased_utterance = (
-            SingleStepLLMCommandGenerator.parse_commands(action_list, None, self.flows)
+        commands_from_rephrased_utterance = llm_command_generator.parse_commands(  # type: ignore
+            action_list, None, self.flows
         )
         return self._check_commands_match(
             commands_from_original_utterance, commands_from_rephrased_utterance
         )
 
-    async def _invoke_llm(self, prompt: str) -> str:
-        from rasa.dialogue_understanding.generator.constants import DEFAULT_LLM_CONFIG
-
-        llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
+    async def _invoke_llm(self, prompt: str, default_llm_config: Dict[str, Any]) -> str:
+        llm = llm_factory(self.llm_config, default_llm_config)
 
         try:
             llm_response = await llm.acompletion(prompt)

rasa/llm_fine_tuning/paraphrasing_module.py

@@ -1,8 +1,11 @@
-from typing import Any, Dict, List, Tuple
+from typing import Any, Dict, List, Tuple, Type
 
 import structlog
 from tqdm import tqdm
 
+from rasa.dialogue_understanding.generator.llm_based_command_generator import (
+    LLMBasedCommandGenerator,
+)
 from rasa.llm_fine_tuning.conversations import Conversation
 from rasa.llm_fine_tuning.paraphrasing.conversation_rephraser import (
     ConversationRephraser,
@@ -25,6 +28,7 @@ async def create_paraphrased_conversations(
     rephrase_config: Dict[str, Any],
     num_rephrases: int,
     flows: FlowsList,
+    llm_command_generator: Type[LLMBasedCommandGenerator],
     llm_command_generator_config: Dict[str, Any],
     storage_context: StorageContext,
 ) -> Tuple[List[Conversation], Dict[str, Any]]:
@@ -71,7 +75,7 @@ async def create_paraphrased_conversations(
             rephrasings = _filter_rephrasings(rephrasings, conversations[i])
             # check if the rephrasings are still producing the same commands
             rephrasings = await validator.validate_rephrasings(
-                rephrasings, current_conversation
+                rephrasings, current_conversation, llm_command_generator
             )
         except ProviderClientAPIException as e:
             structlogger.error(

rasa/llm_fine_tuning/train_test_split_module.py

@@ -1,27 +1,18 @@
 import random
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Any, Dict, List, Protocol, Set, Tuple
+from typing import Any, Dict, List, Protocol, Set, Tuple, Type
 
 import structlog
 
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.e2e_test.e2e_test_case import TestSuite
 from rasa.llm_fine_tuning.llm_data_preparation_module import LLMDataExample
 from rasa.llm_fine_tuning.storage import StorageContext
+from rasa.llm_fine_tuning.utils import commands_as_string
 
 TRAIN_TEST_MODULE_STORAGE_LOCATION = "4_train_test_split"
 
-SUPPORTED_COMMANDS = [
-    "SetSlot",
-    "StartFlow",
-    "CancelFlow",
-    "ChitChat",
-    "SkipQuestion",
-    "SearchAndReply",
-    "HumanHandoff",
-    "Clarify",
-]
-
 INSTRUCTION_DATA_FORMAT = "instruction"
 CONVERSATIONAL_DATA_FORMAT = "conversational"
 
@@ -77,17 +68,19 @@ class ConversationalDataFormat(DataExampleFormat):
         }
 
 
-def _get_command_types_covered_by_llm_data_point(commands: LLMDataExample) -> Set[str]:
+def _get_command_types_covered_by_llm_data_point(
+    data_point: LLMDataExample,
+) -> Set[Type[PromptCommand]]:
     """Get the command types covered by the LLM data point.
 
     This function returns the set of command types from the output present in a
-    LLMDataExample object. Eg: The function returns {'SetSlot', 'StartFlow'} when the
-    LLMDataExample.output is 'SetSlot(slot, abc), SetSlot(slot, cde), StartFlow(xyz)'.
+    LLMDataExample object. Eg: The function returns {'SetSlotCommand',
+    'StartFlowCommand'} when the LLMDataExample.output is 'SetSlotCommand(slot, abc),
+    SetSlotCommand(slot, cde), StartFlowCommand(xyz)'.
     """
     commands_covered = set()
-    for command in SUPPORTED_COMMANDS:
-        if command in commands.output:
-            commands_covered.add(command)
+    for command in data_point.output:
+        commands_covered.add(command.__class__)
     return commands_covered
 
 
@@ -146,14 +139,18 @@ def _get_minimum_test_case_groups_to_cover_all_commands(
         {
             "test_case_name": "t1",
             "data_examples": [],
-            "commands": {"SetSlot", "CancelFlow"}
+            "commands": {"SetSlotCommand", "CancelFlowCommand"}
         },
-        {"test_case_name": "t2", "data_examples": [], "commands": {"CancelFlow"}},
-        {"test_case_name": "t3", "data_examples": [], "commands": {"StartFlow"}},
+        {
+            "test_case_name": "t2",
+            "data_examples": [],
+            "commands": {"CancelFlowCommand"}
+        },
+        {"test_case_name": "t3", "data_examples": [], "commands": {"StartFlowCommand"}},
         {
             "test_case_name": "t4",
             "data_examples": [],
-            "commands": {"SetSlot", "StartFlow"}
+            "commands": {"SetSlotCommand", "StartFlowCommand"}
         },
     ]
 
@@ -166,7 +163,7 @@ def _get_minimum_test_case_groups_to_cover_all_commands(
         command for test_group in grouped_data for command in test_group[KEY_COMMANDS]
     )
     selected_test_cases = []
-    covered_commands: Set[str] = set()
+    covered_commands: Set[Type[PromptCommand]] = set()
 
     while covered_commands != all_commands:
         # Find the test case group that covers the most number of uncovered commands
@@ -187,7 +184,7 @@ def _get_minimum_test_case_groups_to_cover_all_commands(
 
     structlogger.info(
         "llm_fine_tuning.train_test_split_module.command_coverage_in_train_dataset",
-        covered_commands=covered_commands,
+        covered_commands=[command.__name__ for command in covered_commands],
     )
     return selected_test_cases
 
@@ -205,7 +202,10 @@ def _get_finetuning_data_in_instruction_data_format(
         data: List[Dict[str, Any]],
     ) -> List[DataExampleFormat]:
         return [
-            InstructionDataFormat(llm_data_example.prompt, llm_data_example.output)
+            InstructionDataFormat(
+                llm_data_example.prompt,
+                commands_as_string(llm_data_example.output),
+            )
             for test_group in data
             for llm_data_example in test_group[KEY_DATA_EXAMPLES]
         ]
@@ -232,7 +232,7 @@ def _get_finetuning_data_in_conversational_data_format(
                 [
                     ConversationalMessageDataFormat("user", llm_data_example.prompt),
                     ConversationalMessageDataFormat(
-                        "assistant", llm_data_example.output
+                        "assistant", commands_as_string(llm_data_example.output)
                     ),
                 ]
             )
@@ -271,7 +271,7 @@ def _check_and_log_missing_validation_dataset_command_coverage(
         structlogger.warning(
             "llm_fine_tuning.train_test_split_module.missing_commands_in_validation_dat"
             "aset",
-            missing_commands=missing_commands,
+            missing_commands=[command.__name__ for command in missing_commands],
         )
 
 

rasa/llm_fine_tuning/utils.py

@@ -0,0 +1,7 @@
+from typing import List
+
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
+
+
+def commands_as_string(commands: List[PromptCommand], delimiter: str = "\n") -> str:
+    return delimiter.join([command.to_dsl() for command in commands])

rasa/model_training.py

@@ -140,6 +140,7 @@ def _check_unresolved_slots(domain: Domain, stories: StoryGraph) -> None:
                 f"whether there is a spelling error."
             ),
         )
+        rasa.shared.utils.common.display_research_study_prompt()
         sys.exit(1)
 
 
@@ -296,6 +297,7 @@ async def _train_graph(
                     f"model within the directory '{output_path}'."
                 ),
             )
+            rasa.shared.utils.common.display_research_study_prompt()
             sys.exit(1)
 
         rasa.shared.utils.common.mark_as_experimental_feature(
@@ -377,7 +379,7 @@ async def _train_graph(
                     f"Your Rasa model is trained and saved at '{full_model_path}'."
                 ),
             )
-
+        rasa.shared.utils.common.display_research_study_prompt()
         return TrainingResult(str(full_model_path), 0)
 
 

rasa/server.py

@@ -1147,6 +1147,7 @@ def create_app(
                 f"An unexpected error occurred during training. Error: {e}",
             )
         finally:
+            rasa.shared.utils.common.display_research_study_prompt()
             with app.ctx.active_training_processes.get_lock():
                 app.ctx.active_training_processes.value -= 1
 

rasa/shared/constants.py

@@ -194,6 +194,9 @@ PROVIDER_CONFIG_KEY = "provider"
 REQUEST_TIMEOUT_CONFIG_KEY = "request_timeout"  # deprecated
 TIMEOUT_CONFIG_KEY = "timeout"
 
+TEMPERATURE_CONFIG_KEY = "temperature"
+MAX_TOKENS_CONFIG_KEY = "max_tokens"
+
 DEPLOYMENT_NAME_CONFIG_KEY = "deployment_name"
 DEPLOYMENT_CONFIG_KEY = "deployment"
 EMBEDDINGS_CONFIG_KEY = "embeddings"
@@ -264,6 +267,7 @@ LITELLM_SSL_CERTIFICATE_ENV_VAR = "SSL_CERTIFICATE"
 
 OPENAI_PROVIDER = "openai"
 AZURE_OPENAI_PROVIDER = "azure"
+ANTHROPIC_PROVIDER = "anthropic"
 SELF_HOSTED_PROVIDER = "self-hosted"
 HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER = "huggingface_local"
 RASA_PROVIDER = "rasa"

rasa/shared/core/domain.py

@@ -52,6 +52,7 @@ from rasa.shared.core.constants import (
     SlotMappingType,
 )
 from rasa.shared.core.events import SlotSet, UserUttered
+from rasa.shared.core.flows.constants import KEY_TRANSLATION
 from rasa.shared.core.slots import (
     AnySlot,
     CategoricalSlot,
@@ -117,6 +118,7 @@ RESPONSE_KEYS_TO_INTERPOLATE = [
     KEY_RESPONSES_BUTTONS,
     KEY_RESPONSES_ATTACHMENT,
     KEY_RESPONSES_QUICK_REPLIES,
+    KEY_TRANSLATION,
 ]
 
 ALL_DOMAIN_KEYS = [
@@ -2105,6 +2107,10 @@ class Domain:
 
         return read_yaml(raw_yaml_content, expand_env_vars=cls.expand_env_vars)
 
+    def remove_builtin_slots(self) -> None:
+        """Remove all builtin slots from the domain."""
+        self.slots = [slot for slot in self.slots if not slot.is_builtin]
+
 
 def warn_about_duplicates_found_during_domain_merging(
     duplicates: Dict[Text, List[Text]],

rasa/shared/importers/importer.py

@@ -34,6 +34,7 @@ from rasa.shared.core.events import ActionExecuted, UserUttered
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.slots import StrictCategoricalSlot
 from rasa.shared.core.training_data.structures import StoryGraph
+from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.constants import ACTION_NAME, ENTITIES
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
@@ -536,6 +537,14 @@ class LanguageImporter(PassThroughImporter):
         if domain.is_empty():
             return domain
 
+        domain.remove_builtin_slots()
+        slot_name = rasa.shared.core.constants.LANGUAGE_SLOT
+        if any(slot.name == slot_name for slot in domain.slots):
+            raise RasaException(
+                f"The '{slot_name}' slot is a builtin slot that cannot be overridden. "
+                f"Please remove its definition from your domain configuration."
+            )
+
         config = self._importer.get_config()
         language = config.get(CONFIG_LANGUAGE_KEY)
         additional_languages = config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY) or []
@@ -545,7 +554,6 @@ class LanguageImporter(PassThroughImporter):
             values.append(language)
 
         # Prepare the serialized representation of the language slot
-        slot_name = rasa.shared.core.constants.LANGUAGE_SLOT
         serialized_slot: Dict[Text, Any] = {
             "type": StrictCategoricalSlot.type_name,
             "initial_value": language,