rasa-pro 3.12.0rc2__py3-none-any.whl → 3.12.0rc3__py3-none-any.whl

rasa/dialogue_understanding/generator/prompt_templates/command_prompt_v2_gpt_4o_2024_11_20_template.jinja2

@@ -1,73 +1,46 @@
 ## Task Description
 Your task is to analyze the current conversation context and generate a list of actions to start new business processes that we call flows, to extract slots, or respond to small talk and knowledge requests.
 
---
+---
+
+## Available Flows and Slots
+Use the following structured data:
+```json
+{"flows":[{% for flow in available_flows %}{"name":"{{ flow.name }}","description":"{{ flow.description }}"{% if flow.slots %},"slots":[{% for slot in flow.slots %}{"name":"{{ slot.name }}"{% if slot.description %},"description":"{{ slot.description }}"{% endif %}{% if slot.allowed_values %},"allowed_values":{{ slot.allowed_values }}{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]}
+```
+
+---
 
 ## Available Actions:
-* `start flow flow_name`: Starting a flow. For example, `start flow transfer_money` or `start flow list_contacts`
-* `set slot slot_name slot_value`: Slot setting. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values
-* `cancel flow`: Cancelling the current flow
+* `start flow flow_name`: Starting a flow. For example, `start flow transfer_money` or `start flow list_contacts`.
+* `set slot slot_name slot_value`: Slot setting. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values.
+* `cancel flow`: Cancelling the current flow.
 * `disambiguate flows flow_name1 flow_name2 ... flow_name_n`: Disambiguate which flow should be started when user input is ambiguous by listing the potential flows as options. For example, `disambiguate flows list_contacts add_contact remove_contact ...` if the user just wrote "contacts".
-* `provide info`: Responding to the user's questions by supplying relevant information, such as answering FAQs or explaining services
+* `provide info`: Responding to the user's questions by supplying relevant information, such as answering FAQs or explaining services.
 * `offtopic reply`: Responding to casual or social user messages that are unrelated to any flows, engaging in friendly conversation and addressing off-topic remarks.
-* `hand over`: Handing over to a human, in case the user seems frustrated or explicitly asks to speak to one
+* `hand over`: Handing over to a human, in case the user seems frustrated or explicitly asks to speak to one.
 
---
+---
 
 ## General Tips
 * Do not fill slots with abstract values or placeholders.
+* For categorical slots try to match the user message with allowed slot values. Use "other" if you cannot match it.
+* Set the boolean slots based on the user response. Map positive responses to `True`, and negative to `False`.
+* Extract text slot values exactly as provided by the user. Avoid assumptions, format changes, or partial extractions.
 * Only use information provided by the user.
 * Use clarification in ambiguous cases.
 * Multiple flows can be started. If a user wants to digress into a second flow, you do not need to cancel the current flow.
+* Do not cancel the flow unless the user explicitly requests it.
 * Strictly adhere to the provided action format.
-* For categorical slots try to match the user message with potential slot values. Use "other" if you cannot match it
 * Focus on the last message and take it one step at a time.
 * Use the previous conversation steps only to aid understanding.
 
---
-
-## Available Flows and Slots
-Use the following structured date:
-```json
-{
-    "flows": [
-        {% for flow in available_flows %}{
-            "name": "{{ flow.name }}",
-            "description": "{{ flow.description }}"{% if flow.slots %},
-            "slots": [{% for slot in flow.slots %}
-                {
-                    "name": "{{ slot.name }}"{% if slot.description %},
-                    "description": "{{ slot.description }}"{% endif %}{% if slot.allowed_values %},
-                    "allowed_values": {{ slot.allowed_values }}{% endif %}
-                }{% if not loop.last %},{% endif %}{% endfor %}
-            ]{% endif %}
-        }{% if not loop.last %},
-        {% endif %}{% endfor %}
-    ]
-}
-```
-
---
+---
 
 ## Current State
-{% if current_flow != None %}Use the following structured date:
+{% if current_flow != None %}Use the following structured data:
 ```json
-{
-    "active_flow": "{{ current_flow }}",
-    "current_step": {
-        "requested_slot": "{{ current_slot }}",
-        "requested_slot_description": "{{ current_slot_description }}"
-    },
-    "slots": [{% for slot in flow_slots %}
-        {
-            "name": "{{ slot.name }}",
-            "value": "{{ slot.value }}",
-            "type": "{{ slot.type }}"{% if slot.description %},
-            "description": "{{ slot.description }}"{% endif %}{% if slot.allowed_values %},
-            "allowed_values": "{{ slot.allowed_values }}"{% endif %}
-        }{% if not loop.last %},{% endif %}{% endfor %}
-    ]
-}
+{"active_flow":"{{ current_flow }}","current_step":{"requested_slot":"{{ current_slot }}","requested_slot_description":"{{ current_slot_description }}"},"slots":[{% for slot in flow_slots %}{"name":"{{ slot.name }}","value":"{{ slot.value }}","type":"{{ slot.type }}"{% if slot.description %},"description":"{{ slot.description }}"{% endif %}{% if slot.allowed_values %},"allowed_values":"{{ slot.allowed_values }}"{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]}
 ```{% else %}
 You are currently not inside any flow.{% endif %}
 
@@ -79,6 +52,6 @@ You are currently not inside any flow.{% endif %}
 ---
 
 ## Task
-Create an action list with one action per line in response to the users last message: """{{ user_message }}""".
+Create an action list with one action per line in response to the user's last message: """{{ user_message }}""".
 
 Your action list:

rasa/dialogue_understanding/generator/single_step/compact_llm_command_generator.py

@@ -1,3 +1,4 @@
+import copy
 from typing import Any, Dict, List, Optional, Text
 
 import structlog
@@ -19,10 +20,16 @@ from rasa.dialogue_understanding.generator.command_parser import (
 )
 from rasa.dialogue_understanding.generator.constants import (
     COMMAND_PROMPT_FILE_NAME,
-    DEFAULT_LLM_CONFIG,
+    DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     FLOW_RETRIEVAL_KEY,
     LLM_BASED_COMMAND_GENERATOR_CONFIG_FILE,
     LLM_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CLAUDE_3_5_SONNET_20240620,
+    MODEL_NAME_GPT_4O_2024_11_20,
+    OPENAI_PROVIDER,
+    PROVIDER_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
@@ -36,9 +43,14 @@ from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.constants import (
+    ANTHROPIC_PROVIDER,
+    AWS_BEDROCK_PROVIDER,
+    AZURE_OPENAI_PROVIDER,
     EMBEDDINGS_CONFIG_KEY,
+    MAX_TOKENS_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
     ROUTE_TO_CALM_SLOT,
+    TEMPERATURE_CONFIG_KEY,
 )
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -61,18 +73,38 @@ from rasa.utils.log_utils import log_llm
 structlogger = structlog.get_logger()
 
 
+DEFAULT_LLM_CONFIG = {
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: MODEL_NAME_GPT_4O_2024_11_20,
+    TEMPERATURE_CONFIG_KEY: 0.0,
+    MAX_TOKENS_CONFIG_KEY: DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TIMEOUT_CONFIG_KEY: 7,
+}
+
 MODEL_PROMPT_MAPPER = {
-    "openai/gpt-4o-2024-11-20": "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2",
-    "azure/gpt-4o-2024-11-20": "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2",
-    "bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0": (
+    f"{OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
+        "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+    ),
+    f"{AZURE_OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
+        "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+    ),
+    f"{AWS_BEDROCK_PROVIDER}/anthropic.{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}-v1:0": (
         "command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
     ),
-    "anthropic/claude-3-5-sonnet-20240620": (
+    f"{ANTHROPIC_PROVIDER}/{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}": (
         "command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
     ),
 }
 
-DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME = "command_prompt_v2_default.jinja2"
+# When model is not configured, then we use the default prompt template
+DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
+    "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+)
+# When the configured model is not found in the model prompt mapper, then we use the
+# fallback prompt template
+FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
+    "command_prompt_v2_fallback_other_models_template.jinja2"
+)
 
 
 class CommandParserValidatorSingleton:
@@ -154,25 +186,19 @@ class CompactLLMCommandGenerator(LLMBasedCommandGenerator):
             **kwargs,
         )
 
-        # Get the default prompt template based on the model name
-        default_command_prompt_template = get_default_prompt_template_based_on_model(
-            self.config.get(LLM_CONFIG_KEY, {}) or {},
-            MODEL_PROMPT_MAPPER,
-            DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+        # Get the prompt template from the config or the default prompt template.
+        self.prompt_template = self.resolve_component_prompt_template(
+            self.config, prompt_template
         )
 
-        # Set the prompt template either from the config or the default prompt template.
-        self.prompt_template = prompt_template or get_prompt_template(
-            self.config.get(PROMPT_TEMPLATE_CONFIG_KEY),
-            default_command_prompt_template,
+        # Set the command syntax version to v2
+        CommandSyntaxManager.set_syntax_version(
+            self.get_component_command_syntax_version()
         )
 
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
         self.repeat_command_enabled = self.is_repeat_command_enabled()
 
-        # Set the command syntax version to v2
-        CommandSyntaxManager.set_syntax_version(CommandSyntaxVersion.v2)
-
     ### Implementations of LLMBasedCommandGenerator parent
     @staticmethod
     def get_default_config() -> Dict[str, Any]:
@@ -219,7 +245,7 @@ class CompactLLMCommandGenerator(LLMBasedCommandGenerator):
         llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
         cls.perform_llm_health_check(
             llm_config,
-            DEFAULT_LLM_CONFIG,
+            cls.get_default_llm_config(),
             "compact_llm_command_generator.load",
             cls.__name__,
         )
@@ -508,15 +534,41 @@ class CompactLLMCommandGenerator(LLMBasedCommandGenerator):
             config.get(FLOW_RETRIEVAL_KEY, {}).get(EMBEDDINGS_CONFIG_KEY),
             FlowRetrieval.__name__,
         )
+
+        # Create a copy of the config to avoid modifying the original config
+        # and update the llm config with the resolved llm config.
+        _config_copy = copy.deepcopy(config)
+        _config_copy[LLM_CONFIG_KEY] = llm_config
+        prompt_template = cls.resolve_component_prompt_template(_config_copy)
+
+        return deep_container_fingerprint(
+            [prompt_template, llm_config, embedding_config]
+        )
+
+    @staticmethod
+    def get_default_llm_config() -> Dict[str, Any]:
+        """Get the default LLM config for the command generator."""
+        return DEFAULT_LLM_CONFIG
+
+    @staticmethod
+    def get_component_command_syntax_version() -> CommandSyntaxVersion:
+        return CommandSyntaxVersion.v2
+
+    @staticmethod
+    def resolve_component_prompt_template(
+        config: Dict[str, Any], prompt_template: Optional[str] = None
+    ) -> Optional[str]:
+        """Get the prompt template from the config or the default prompt template."""
+        # Get the default prompt template based on the model name.
         default_command_prompt_template = get_default_prompt_template_based_on_model(
-            llm_config or {},
+            config.get(LLM_CONFIG_KEY, {}) or {},
             MODEL_PROMPT_MAPPER,
             DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+            FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
         )
-        prompt_template = get_prompt_template(
+
+        # Return the prompt template either from the config or the default prompt.
+        return prompt_template or get_prompt_template(
             config.get(PROMPT_TEMPLATE_CONFIG_KEY),
             default_command_prompt_template,
         )
-        return deep_container_fingerprint(
-            [prompt_template, llm_config, embedding_config]
-        )

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -8,6 +8,7 @@ from rasa.dialogue_understanding.commands.command_syntax_manager import (
     CommandSyntaxVersion,
 )
 from rasa.dialogue_understanding.generator.constants import (
+    DEFAULT_LLM_CONFIG,
     FLOW_RETRIEVAL_KEY,
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
@@ -71,18 +72,14 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
                     "Please use the config parameter 'prompt_template' instead. "
                 ),
             )
-        config_prompt = (
-            config.get(PROMPT_CONFIG_KEY)
-            or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
-            or None
-        )
-        self.prompt_template = prompt_template or get_prompt_template(
-            config_prompt,
-            DEFAULT_COMMAND_PROMPT_TEMPLATE,
+        self.prompt_template = self.resolve_component_prompt_template(
+            config, prompt_template
         )
 
         # Set the command syntax version to v1
-        CommandSyntaxManager.set_syntax_version(CommandSyntaxVersion.v1)
+        CommandSyntaxManager.set_syntax_version(
+            self.get_component_command_syntax_version()
+        )
 
     @staticmethod
     def get_default_config() -> Dict[str, Any]:
@@ -98,15 +95,7 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
     @classmethod
     def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint for the graph."""
-        config_prompt = (
-            config.get(PROMPT_CONFIG_KEY)
-            or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
-            or None
-        )
-        prompt_template = get_prompt_template(
-            config_prompt,
-            DEFAULT_COMMAND_PROMPT_TEMPLATE,
-        )
+        prompt_template = cls.resolve_component_prompt_template(config)
         llm_config = resolve_model_client_config(
             config.get(LLM_CONFIG_KEY), SingleStepLLMCommandGenerator.__name__
         )
@@ -117,3 +106,28 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
         return deep_container_fingerprint(
             [prompt_template, llm_config, embedding_config]
         )
+
+    @staticmethod
+    def get_default_llm_config() -> Dict[str, Any]:
+        """Get the default LLM config for the command generator."""
+        return DEFAULT_LLM_CONFIG
+
+    @staticmethod
+    def get_component_command_syntax_version() -> CommandSyntaxVersion:
+        return CommandSyntaxVersion.v1
+
+    @staticmethod
+    def resolve_component_prompt_template(
+        config: Dict[str, Any], prompt_template: Optional[str] = None
+    ) -> Optional[str]:
+        """Get the prompt template from the config or the default prompt template."""
+        # Get the default prompt template based on the model name.
+        config_prompt = (
+            config.get(PROMPT_CONFIG_KEY)
+            or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            or None
+        )
+        return prompt_template or get_prompt_template(
+            config_prompt,
+            DEFAULT_COMMAND_PROMPT_TEMPLATE,
+        )

rasa/dialogue_understanding/processor/command_processor.py

@@ -42,6 +42,7 @@ from rasa.dialogue_understanding.stack.frames import (
 from rasa.dialogue_understanding.stack.utils import (
     filled_slots_for_active_flow,
     top_flow_frame,
+    top_user_flow_frame,
 )
 from rasa.engine.graph import ExecutionContext
 from rasa.shared.constants import (
@@ -430,28 +431,22 @@ def clean_up_commands(
                 command=command,
             )
 
-        elif isinstance(command, StartFlowCommand) and command.flow == active_flow:
-            # drop a start flow command if the starting flow is equal to the currently
-            # active flow
-            structlogger.debug(
-                "command_processor.clean_up_commands.skip_command_flow_already_active",
-                command=command,
+        elif isinstance(command, StartFlowCommand):
+            top_user_frame = top_user_flow_frame(
+                tracker.stack, ignore_call_and_link_frames=False
             )
+            top_flow_id = top_user_frame.flow_id if top_user_frame else ""
 
-        elif isinstance(command, StartFlowCommand) and active_flow is not None:
-            # push handle digressions command if we are at a collect step of
-            # a flow and a new flow is started
-            collect_info = get_current_collect_step(tracker.stack, all_flows)
-            current_flow = all_flows.flow_by_id(active_flow)
-            current_flow_condition = current_flow and (
-                current_flow.ask_confirm_digressions or current_flow.block_digressions
-            )
+            if top_flow_id == command.flow:
+                # drop a start flow command if the starting flow is equal
+                # to the currently active flow
+                structlogger.debug(
+                    "command_processor.clean_up_commands.skip_command_flow_already_active",
+                    command=command,
+                )
+                continue
 
-            if collect_info and (
-                collect_info.ask_confirm_digressions
-                or collect_info.block_digressions
-                or current_flow_condition
-            ):
+            if should_add_handle_digressions_command(tracker, all_flows, top_flow_id):
                 clean_commands.append(HandleDigressionsCommand(flow=command.flow))
                 structlogger.debug(
                     "command_processor.clean_up_commands.push_handle_digressions",
@@ -848,3 +843,28 @@ def filter_cannot_handle_command_for_skipped_slots(
             and CANNOT_HANDLE_REASON == command.reason
         )
     ]
+
+
+def should_add_handle_digressions_command(
+    tracker: DialogueStateTracker, all_flows: FlowsList, top_flow_id: str
+) -> bool:
+    """Check if a handle digressions command should be added to the commands.
+
+    The command should replace a StartFlow command only if we are at a collect step of
+    a flow and a new flow is predicted by the command generator to start.
+    """
+    current_flow = all_flows.flow_by_id(top_flow_id)
+    current_flow_condition = current_flow and (
+        current_flow.ask_confirm_digressions or current_flow.block_digressions
+    )
+
+    collect_info = get_current_collect_step(tracker.stack, all_flows)
+
+    if collect_info and (
+        collect_info.ask_confirm_digressions
+        or collect_info.block_digressions
+        or current_flow_condition
+    ):
+        return True
+
+    return False

rasa/dialogue_understanding/stack/utils.py

@@ -63,7 +63,9 @@ def top_flow_frame(
     return None
 
 
-def top_user_flow_frame(dialogue_stack: DialogueStack) -> Optional[UserFlowStackFrame]:
+def top_user_flow_frame(
+    dialogue_stack: DialogueStack, ignore_call_and_link_frames: bool = True
+) -> Optional[UserFlowStackFrame]:
     """Returns the topmost user flow frame from the tracker.
 
     User flows are flows that are created by developers of an assistant and
@@ -75,16 +77,19 @@ def top_user_flow_frame(dialogue_stack: DialogueStack) -> Optional[UserFlowStack
 
     Args:
         dialogue_stack: The dialogue stack to use.
+        ignore_call_and_link_frames: Whether to ignore user frames of type `call`
+            and `link`. By default, these frames are ignored.
 
     Returns:
     The topmost user flow frame from the tracker.
     """
     for frame in reversed(dialogue_stack.frames):
-        if (
-            isinstance(frame, UserFlowStackFrame)
-            and frame.frame_type != FlowStackFrameType.CALL
-            and frame.frame_type != FlowStackFrameType.LINK
-        ):
+        if isinstance(frame, UserFlowStackFrame):
+            if ignore_call_and_link_frames and (
+                frame.frame_type == FlowStackFrameType.CALL
+                or frame.frame_type == FlowStackFrameType.LINK
+            ):
+                continue
             return frame
     return None
 

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/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())