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

rasa/dialogue_understanding_test/du_test_case.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple
 
 from pydantic import BaseModel, Field
 
-from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.dialogue_understanding.generator.command_parser import parse_commands
 from rasa.dialogue_understanding_test.command_comparison import are_command_lists_equal
 from rasa.dialogue_understanding_test.constants import (
@@ -30,6 +30,7 @@ from rasa.shared.nlu.constants import (
 KEY_USAGE = "usage"
 KEY_PROMPT_TOKENS = "prompt_tokens"
 KEY_COMPLETION_TOKENS = "completion_tokens"
+KEY_CHOICES = "choices"
 
 
 class DialogueUnderstandingOutput(BaseModel):
@@ -65,11 +66,18 @@ class DialogueUnderstandingOutput(BaseModel):
     """
 
     # Dict with component name as key and list of commands as value
-    commands: Dict[str, List[Command]]
+    commands: Dict[str, List[PromptCommand]]
     # List of prompts
     prompts: Optional[List[Dict[str, Any]]] = None
 
-    def get_predicted_commands(self) -> List[Command]:
+    class Config:
+        """Skip validation for PromptCommand protocol as pydantic does not know how to
+        serialize or handle instances of a protocol.
+        """
+
+        arbitrary_types_allowed = True
+
+    def get_predicted_commands(self) -> List[PromptCommand]:
         """Get all commands from the output."""
         return [
             command
@@ -77,15 +85,33 @@ class DialogueUnderstandingOutput(BaseModel):
             for command in predicted_commands
         ]
 
-    def get_component_names_that_predicted_commands(self) -> List[str]:
-        """Get all component names that have predicted commands."""
-        if self.commands is None:
-            return []
-        return [
-            component_name
-            for component_name, predicted_commands in self.commands.items()
-            if predicted_commands
-        ]
+    def get_component_names_that_predicted_commands_or_have_llm_response(
+        self,
+    ) -> List[str]:
+        """Get all component names that have predicted commands or recieved
+        non-empty response from LLM.
+        """
+        component_names_that_predicted_commands = (
+            [
+                component_name
+                for component_name, predicted_commands in self.commands.items()
+                if predicted_commands
+            ]
+            if self.commands
+            else []
+        )
+        components_with_prompts = (
+            [
+                str(prompt.get(KEY_COMPONENT_NAME, None))
+                for prompt in self.prompts
+                if prompt.get(KEY_LLM_RESPONSE_METADATA, None)
+            ]
+            if self.prompts
+            else []
+        )
+        return list(
+            set(component_names_that_predicted_commands + components_with_prompts)
+        )
 
     def get_component_name_to_prompt_info(self) -> Dict[str, List[Dict[str, Any]]]:
         """Return a dictionary of component names to prompt information.
@@ -112,7 +138,9 @@ class DialogueUnderstandingOutput(BaseModel):
             return {}
 
         data: Dict[str, List[Dict[str, Any]]] = {}
-        relevant_component_names = self.get_component_names_that_predicted_commands()
+        relevant_component_names = (
+            self.get_component_names_that_predicted_commands_or_have_llm_response()
+        )
 
         for prompt_data in self.prompts:
             component_name = prompt_data[KEY_COMPONENT_NAME]
@@ -144,6 +172,11 @@ class DialogueUnderstandingOutput(BaseModel):
                         KEY_COMPLETION_TOKENS
                     )
 
+            choices = prompt_data.get(KEY_LLM_RESPONSE_METADATA, {}).get(KEY_CHOICES)
+            if choices and len(choices) > 0:
+                # Add the action list returned by the LLM to the prompt_info
+                prompt_info[KEY_CHOICES] = choices[0]
+
             data[component_name].append(prompt_info)
 
         return data
@@ -155,9 +188,16 @@ class DialogueUnderstandingTestStep(BaseModel):
     template: Optional[str] = None
     line: Optional[int] = None
     metadata_name: Optional[str] = None
-    commands: Optional[List[Command]] = None
+    commands: Optional[List[PromptCommand]] = None
     dialogue_understanding_output: Optional[DialogueUnderstandingOutput] = None
 
+    class Config:
+        """Skip validation for PromptCommand protocol as pydantic does not know how to
+        serialize or handle instances of a protocol.
+        """
+
+        arbitrary_types_allowed = True
+
     def as_dict(self) -> Dict[str, Any]:
         if self.actor == ACTOR_USER:
             if self.commands:
@@ -178,7 +218,7 @@ class DialogueUnderstandingTestStep(BaseModel):
     def from_dict(
         step: Dict[str, Any],
         flows: FlowsList,
-        custom_command_classes: List[Command] = [],
+        custom_command_classes: List[PromptCommand] = [],
         remove_default_commands: List[str] = [],
     ) -> "DialogueUnderstandingTestStep":
         """Creates a DialogueUnderstandingTestStep from a dictionary.
@@ -224,7 +264,7 @@ class DialogueUnderstandingTestStep(BaseModel):
             commands=commands,
         )
 
-    def get_predicted_commands(self) -> List[Command]:
+    def get_predicted_commands(self) -> List[PromptCommand]:
         """Get all predicted commands from the test case."""
         if self.dialogue_understanding_output is None:
             return []
@@ -314,7 +354,7 @@ class DialogueUnderstandingTestCase(BaseModel):
         input_test_case: Dict[str, Any],
         flows: FlowsList,
         file: Optional[str] = None,
-        custom_command_classes: List[Command] = [],
+        custom_command_classes: List[PromptCommand] = [],
         remove_default_commands: List[str] = [],
     ) -> "DialogueUnderstandingTestCase":
         """Creates a DialogueUnderstandingTestCase from a dictionary.
@@ -361,7 +401,7 @@ class DialogueUnderstandingTestCase(BaseModel):
 
         return [step.to_str() for step in steps]
 
-    def get_expected_commands(self) -> List[Command]:
+    def get_expected_commands(self) -> List[PromptCommand]:
         """Get all commands from the test steps."""
         return [
             command

rasa/dialogue_understanding_test/du_test_result.py

@@ -5,16 +5,13 @@ from typing import Any, Dict, List, Optional, Text
 import numpy as np
 from pydantic import BaseModel
 
-from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.dialogue_understanding_test.du_test_case import (
     DialogueUnderstandingTestCase,
     DialogueUnderstandingTestStep,
 )
 from rasa.dialogue_understanding_test.utils import get_command_comparison
-from rasa.shared.nlu.constants import (
-    KEY_SYSTEM_PROMPT,
-    KEY_USER_PROMPT,
-)
+from rasa.shared.nlu.constants import KEY_SYSTEM_PROMPT, KEY_USER_PROMPT
 
 if typing.TYPE_CHECKING:
     from rasa.dialogue_understanding_test.command_metric_calculation import (
@@ -46,7 +43,7 @@ class DialogueUnderstandingTestResult(BaseModel):
     passed: bool
     error_line: Optional[int] = None
 
-    def get_expected_commands(self) -> List[Command]:
+    def get_expected_commands(self) -> List[PromptCommand]:
         return self.test_case.get_expected_commands()
 
 
@@ -60,10 +57,17 @@ class FailedTestStep(BaseModel):
     pass_status: bool
     command_generators: List[str]
     prompts: Optional[Dict[str, List[Dict[str, Any]]]] = None
-    expected_commands: List[Command]
-    predicted_commands: Dict[str, List[Command]]
+    expected_commands: List[PromptCommand]
+    predicted_commands: Dict[str, List[PromptCommand]]
     conversation_with_diff: List[str]
 
+    class Config:
+        """Skip validation for PromptCommand protocol as pydantic does not know how to
+        serialize or handle instances of a protocol.
+        """
+
+        arbitrary_types_allowed = True
+
     @classmethod
     def from_dialogue_understanding_test_step(
         cls,
@@ -74,13 +78,13 @@ class FailedTestStep(BaseModel):
         user_utterance = step.text or ""
         line_number = step.line or -1
 
-        predicted_commands: Dict[str, List[Command]] = {}
+        predicted_commands: Dict[str, List[PromptCommand]] = {}
         prompts: Optional[Dict[str, List[Dict[str, Any]]]] = None
         command_generators: List[str] = []
 
         if step.dialogue_understanding_output:
             predicted_commands = step.dialogue_understanding_output.commands
-            command_generators = step.dialogue_understanding_output.get_component_names_that_predicted_commands()  # noqa: E501
+            command_generators = step.dialogue_understanding_output.get_component_names_that_predicted_commands_or_have_llm_response()  # noqa: E501
             prompts = (
                 step.dialogue_understanding_output.get_component_name_to_prompt_info()
             )

rasa/dialogue_understanding_test/io.py

@@ -8,6 +8,7 @@ import rasa.shared.data
 from rasa.dialogue_understanding_test.command_metric_calculation import CommandMetrics
 from rasa.dialogue_understanding_test.constants import SCHEMA_FILE_PATH
 from rasa.dialogue_understanding_test.du_test_case import (
+    KEY_CHOICES,
     KEY_COMPLETION_TOKENS,
     KEY_PROMPT_TOKENS,
 )
@@ -309,6 +310,7 @@ def print_failed_cases(
                 print_prompt(step)
             rich.print("\n[red3]-- CONVERSATION --[/red3]")
             rich.print("\n".join(step.conversation_with_diff))
+            print_llm_output(step)
 
 
 def print_prompt(step: FailedTestStep) -> None:
@@ -341,6 +343,18 @@ def print_prompt(step: FailedTestStep) -> None:
             )
 
 
+def print_llm_output(step: FailedTestStep) -> None:
+    if not step.prompts:
+        return
+
+    for component, component_prompts in step.prompts.items():
+        for prompt_data in component_prompts:
+            if KEY_CHOICES in prompt_data:
+                rich.print("\n[red3]-- CHOICES --[/red3]")
+                rich.print(prompt_data.get(KEY_CHOICES))
+                rich.print("[red3]-------------[/red3]")
+
+
 def print_command_summary(metrics: Dict[str, CommandMetrics]) -> None:
     """Print the command summary.
 

rasa/e2e_test/assertions.py

@@ -972,7 +972,7 @@ class GenerativeResponseMixin(Assertion):
         data.pop("metric_adjective")
         return data
 
-    def _render_prompt(self, step_text: str, matching_event: BotUttered) -> str:
+    def _render_prompt(self, matching_event: BotUttered) -> str:
         raise NotImplementedError
 
     def _get_processed_output(self, parsed_llm_output: Dict[str, Any]) -> List[Any]:
@@ -999,7 +999,7 @@ class GenerativeResponseMixin(Assertion):
     ) -> Tuple[Optional[AssertionFailure], Optional[Event]]:
         """Run the LLM evaluation on the given event."""
         bot_message = matching_event.text
-        prompt = self._render_prompt(step_text, matching_event)
+        prompt = self._render_prompt(matching_event)
         llm_response = self._invoke_llm(llm_judge_config, prompt)
 
         try:
@@ -1160,9 +1160,9 @@ class GenerativeResponseIsRelevantAssertion(GenerativeResponseMixin):
     def type(cls) -> str:
         return AssertionType.GENERATIVE_RESPONSE_IS_RELEVANT.value
 
-    def _render_prompt(self, step_text: str, matching_event: BotUttered) -> str:
+    def _render_prompt(self, matching_event: BotUttered) -> str:
         """Render the prompt."""
-        inputs = _get_prompt_inputs(self.type(), step_text, matching_event)
+        inputs = _get_prompt_inputs(self.type(), matching_event)
         prompt_template = _get_default_prompt_template(
             DEFAULT_ANSWER_RELEVANCE_PROMPT_TEMPLATE_FILE_NAME
         )
@@ -1206,11 +1206,10 @@ class GenerativeResponseIsGroundedAssertion(GenerativeResponseMixin):
     def type(cls) -> str:
         return AssertionType.GENERATIVE_RESPONSE_IS_GROUNDED.value
 
-    def _render_prompt(self, step_text: str, matching_event: BotUttered) -> str:
+    def _render_prompt(self, matching_event: BotUttered) -> str:
         """Render the prompt."""
         inputs = _get_prompt_inputs(
             assertion_type=self.type(),
-            step_text=step_text,
             matching_event=matching_event,
             ground_truth=self.ground_truth,
         )
@@ -1336,12 +1335,11 @@ def _get_default_prompt_template(default_prompt_template_file_name: str) -> str:
 
 def _get_prompt_inputs(
     assertion_type: str,
-    step_text: str,
     matching_event: BotUttered,
     ground_truth: Optional[str] = None,
 ) -> Dict[str, Any]:
     if assertion_type == AssertionType.GENERATIVE_RESPONSE_IS_RELEVANT.value:
-        return {"num_variations": "3", "user_message": step_text}
+        return {"num_variations": "3", "bot_message": matching_event.text}
     elif assertion_type == AssertionType.GENERATIVE_RESPONSE_IS_GROUNDED.value:
         ground_truth_event_metadata = matching_event.metadata.get(
             SEARCH_RESULTS_METADATA_KEY, ""

rasa/e2e_test/llm_judge_prompts/answer_relevance_prompt_template.jinja2

@@ -84,6 +84,10 @@ These are a few examples of how to generate question variations and identify non
 
 ## Task Inputs
 
-- **Input Answer**: {{ user_message }}
+- **Input Answer**: {{ bot_message }}
+
+## Task Outputs
+
+Do not include any additional explanations in your output. Only provide the JSON object as described in the task steps.
 
 Your output:

rasa/e2e_test/llm_judge_prompts/groundedness_prompt_template.jinja2

@@ -162,4 +162,8 @@ These are a few examples of how to evaluate the correctness of the answer based
 - **Input Answer**: {{ bot_message }}
 - **Ground Truth**: {{ ground_truth }}
 
+## Task Outputs
+
+Do not include any additional explanations in your output. Only provide the JSON object as described in the task steps.
+
 Your output:

rasa/e2e_test/utils/io.py

@@ -49,7 +49,6 @@ if TYPE_CHECKING:
     from rasa.e2e_test.e2e_test_result import TestResult
 
 
-RASA_PRO_BETA_E2E_ASSERTIONS_ENV_VAR_NAME = "RASA_PRO_BETA_E2E_ASSERTIONS"
 RASA_PRO_BETA_STUB_CUSTOM_ACTION_ENV_VAR_NAME = "RASA_PRO_BETA_STUB_CUSTOM_ACTION"
 
 structlogger = structlog.get_logger()
@@ -278,16 +277,6 @@ def split_into_passed_failed(
     return passed_cases, failed_cases
 
 
-def has_test_case_with_assertions(test_cases: List[TestCase]) -> bool:
-    """Check if the test cases contain assertions."""
-    try:
-        next(test_case for test_case in test_cases if test_case.uses_assertions())
-    except StopIteration:
-        return False
-
-    return True
-
-
 @lru_cache(maxsize=1)
 def extract_test_case_from_path(path: str) -> Tuple[str, str]:
     """Extract test case from path if specified.
@@ -442,7 +431,6 @@ def read_test_cases(path: str) -> TestSuite:
     fixtures: Dict[str, Fixture] = {}
     metadata: Dict[str, Metadata] = {}
     stub_custom_actions: Dict[str, StubCustomAction] = {}
-    beta_flag_verified = False
 
     # Process each test file
     for test_file in test_files:
@@ -460,10 +448,6 @@ def read_test_cases(path: str) -> TestSuite:
         stub_custom_actions.update(
             extract_stub_custom_actions(test_file_content, test_file)
         )
-
-        beta_flag_verified = verify_beta_feature_flag_for_assertions(
-            test_cases, beta_flag_verified
-        )
         input_test_cases.extend(test_cases)
 
     validate_test_case(test_case_name, input_test_cases, fixtures, metadata)
@@ -489,27 +473,6 @@ def check_beta_feature_flag_for_custom_actions_stubs() -> None:
         rasa.shared.utils.cli.print_error_and_exit(str(exc))
 
 
-def verify_beta_feature_flag_for_assertions(
-    test_cases: List[TestCase], beta_flag_verified: bool
-) -> bool:
-    """Verify the beta feature flag for assertions."""
-    if beta_flag_verified:
-        return True
-
-    if not has_test_case_with_assertions(test_cases):
-        return beta_flag_verified
-
-    try:
-        ensure_beta_feature_is_enabled(
-            "end-to-end testing with assertions",
-            RASA_PRO_BETA_E2E_ASSERTIONS_ENV_VAR_NAME,
-        )
-    except BetaNotEnabledException as exc:
-        rasa.shared.utils.cli.print_error_and_exit(str(exc))
-
-    return True
-
-
 def _save_coverage_report(
     report: Optional[pd.DataFrame], test_status: str, output_dir: str
 ) -> None:

rasa/engine/graph.py

@@ -640,3 +640,4 @@ class GraphModelConfiguration:
     language: Optional[Text]
     core_target: Optional[Text]
     nlu_target: Optional[Text]
+    additional_languages: Optional[List[Text]]

rasa/engine/language.py

@@ -0,0 +1,140 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Text
+
+from langcodes import Language as LangcodesLanguage
+
+from rasa.shared.exceptions import RasaException
+
+CUSTOM_LANGUAGE_CODE_PREFIX = "x-"
+
+
+@dataclass(frozen=True)
+class Language:
+    code: str
+    label: str
+    is_default: bool
+
+    @classmethod
+    def from_language_code(
+        cls, language_code: str, is_default: bool = False
+    ) -> "Language":
+        """Creates a Language object from a language code.
+
+        Args:
+            language_code: The language code.
+            is_default: Whether the language is the default language.
+
+        Returns:
+            A Language object.
+
+        Raises:
+            RasaException: If the language code or custom language code is invalid.
+        """
+        language = LangcodesLanguage.make(language_code)
+        cls.validate_language(language)
+
+        return cls(
+            code=language_code,
+            label=cls.get_language_label(language),
+            is_default=is_default,
+        )
+
+    @staticmethod
+    def get_language_label(language: LangcodesLanguage) -> str:
+        """Gets the display name of a language.
+
+        For custom languages (in the format "x-<base_lang>-<custom_label>"),
+        the label is derived from the base language code.
+        This method considers that the language code has previously been validated.
+
+        Args:
+            language: The language code.
+
+        Returns:
+            The display name of the language.
+        """
+        language_code = str(language)
+
+        if language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
+            # 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)
+            return base_language.display_name()
+        else:
+            return language.display_name()
+
+    @classmethod
+    def validate_language(cls, language: LangcodesLanguage) -> None:
+        """Validates a language code.
+
+        Args:
+            language: The language object to validate.
+
+        Raises:
+            RasaException: If the language validation fails.
+        """
+        if not language.is_valid():
+            raise RasaException(f"Language '{language}' is not a valid language code.")
+
+        language_code = str(language)
+        if language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
+            cls.validate_custom_language(language_code)
+
+    @staticmethod
+    def validate_custom_language(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
+
+        Args:
+            custom_language_code: The custom language code to validate.
+
+        Raises:
+            RasaException: If the custom language code validation fails.
+        """
+        # Ensure the custom language code starts with the custom prefix.
+        if not custom_language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
+            raise RasaException(
+                f"Custom language '{custom_language_code}' must "
+                f"start with '{CUSTOM_LANGUAGE_CODE_PREFIX}'."
+            )
+
+        # Split the language code into parts.
+        parts = custom_language_code.split("-")
+        if len(parts) != 3:
+            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():
+            raise RasaException(
+                f"Base language '{base_language_code}' in custom language "
+                f"'{custom_language_code}' is not a valid language code."
+            )
+
+        # 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."
+            )
+
+    def as_dict(self) -> Dict[Text, Any]:
+        """Converts the Language dataclass instance into a dictionary.
+
+        Returns:
+            A dictionary representing the Language object.
+        """
+        return {
+            "code": self.code,
+            "label": self.label,
+            "is_default": self.is_default,
+        }

rasa/engine/recipes/config_files/default_config.yml

@@ -9,6 +9,10 @@ assistant_id: placeholder_default
 # Configuration for the Rasa NLU components.
 # https://rasa.com/docs/rasa-pro/nlu-based-assistants/components
 language: en
+additional_languages:
+  - it
+  - de
+  - es
 
 pipeline:
   - name: WhitespaceTokenizer

rasa/engine/recipes/default_recipe.py

@@ -49,6 +49,7 @@ from rasa.graph_components.providers.training_tracker_provider import (
 )
 from rasa.shared.constants import (
     ASSISTANT_ID_KEY,
+    CONFIG_ADDITIONAL_LANGUAGES_KEY,
     CONFIG_LANGUAGE_KEY,
     CONFIG_NAME_KEY,
     CONFIG_PIPELINE_KEY,
@@ -247,6 +248,7 @@ class DefaultV1Recipe(Recipe):
             language=config.get(CONFIG_LANGUAGE_KEY),
             core_target=core_target,
             nlu_target=f"{GRAPH_NODE_RUN_PREFIX}{RegexMessageHandler.__name__}",
+            additional_languages=config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY),
         )
 
     def _create_train_nodes(

rasa/engine/recipes/graph_recipe.py

@@ -5,6 +5,7 @@ from rasa.engine.graph import GraphModelConfiguration, GraphSchema
 from rasa.engine.recipes.recipe import Recipe
 from rasa.shared.constants import (
     ASSISTANT_ID_KEY,
+    CONFIG_ADDITIONAL_LANGUAGES_KEY,
     CONFIG_LANGUAGE_KEY,
     DOCS_URL_GRAPH_RECIPE,
 )
@@ -76,4 +77,5 @@ class GraphV1Recipe(Recipe):
             language=config.get(CONFIG_LANGUAGE_KEY),
             core_target=core_target,
             nlu_target=nlu_target,
+            additional_languages=config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY),
         )

rasa/engine/storage/local_model_storage.py

@@ -240,6 +240,7 @@ class LocalModelStorage(ModelStorage):
             training_type=model_configuration.training_type,
             project_fingerprint=rasa.model.project_fingerprint(),
             language=model_configuration.language,
+            additional_languages=model_configuration.additional_languages,
             core_target=model_configuration.core_target,
             nlu_target=model_configuration.nlu_target,
         )

rasa/engine/storage/storage.py

@@ -7,7 +7,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Generator, Optional, Text, Tuple, Union
+from typing import Any, Dict, Generator, List, Optional, Text, Tuple, Union
 
 from packaging import version
 
@@ -142,6 +142,7 @@ class ModelMetadata:
     core_target: Optional[Text]
     nlu_target: Text
     language: Optional[Text]
+    additional_languages: Optional[List[Text]]
     training_type: TrainingType = TrainingType.BOTH
 
     def __post_init__(self) -> None:
@@ -171,6 +172,7 @@ class ModelMetadata:
             "core_target": self.core_target,
             "nlu_target": self.nlu_target,
             "language": self.language,
+            "additional_languages": self.additional_languages,
         }
 
     @classmethod
@@ -198,4 +200,5 @@ class ModelMetadata:
             core_target=serialized["core_target"],
             nlu_target=serialized["nlu_target"],
             language=serialized["language"],
+            additional_languages=serialized.get("additional_languages"),
         )

rasa/llm_fine_tuning/conversations.py

@@ -45,7 +45,7 @@ class ConversationStep:
             elif isinstance(command, SetSlotCommand):
                 output.append(f"SetSlot({command.name}, {command.value})")
             elif isinstance(command, ClarifyCommand):
-                output.append(f"Clarify({command.options})")
+                output.append(f"Clarify({', '.join(command.options)})")
             elif isinstance(command, CancelFlowCommand):
                 output.append("CancelFlow()")
             elif isinstance(command, ChitChatAnswerCommand):

rasa/model_manager/runner_service.py

@@ -258,10 +258,13 @@ def run_bot(
 
 async def update_bot_status(bot: BotSession) -> None:
     """Update the status of a bot based on the process return code."""
-    if bot.has_died_recently():
-        set_bot_status_to_stopped(bot)
-    elif await bot.completed_startup_recently():
-        set_bot_status_to_running(bot)
+    try:
+        if bot.has_died_recently():
+            set_bot_status_to_stopped(bot)
+        elif await bot.completed_startup_recently():
+            set_bot_status_to_running(bot)
+    except Exception as e:
+        structlogger.error("model_runner.update_bot_status.error", error=str(e))
 
 
 def terminate_bot(bot: BotSession) -> None: