rasa-pro 3.13.0.dev20250613__py3-none-any.whl → 3.13.0rc2__py3-none-any.whl

rasa/shared/utils/common.py

@@ -384,7 +384,7 @@ def display_research_study_prompt() -> None:
 {separator}
 Want to help shape the future of Rasa Pro?
 Share your feedback in a short conversation with our team.
-Sign up at: https://calendly.com/alvaro-rasa/rasa-pro-installation
+Sign up at: https://feedback.rasa.com
 {separator}
 """
     print_success(message)

rasa/shared/utils/configs.py

@@ -0,0 +1,110 @@
+from typing import Optional
+
+import structlog
+
+from rasa.shared.utils.io import raise_deprecation_warning
+
+structlogger = structlog.get_logger()
+
+
+def resolve_aliases(config: dict, deprecated_alias_mapping: dict) -> dict:
+    """
+    Resolve aliases in the configuration to standard keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        deprecated_alias_mapping: Dictionary mapping aliases to
+            their standard keys.
+
+    Returns:
+        New dictionary containing the processed configuration.
+    """
+    config = config.copy()
+
+    for alias, standard_key in deprecated_alias_mapping.items():
+        # We check for the alias instead of the standard key because our goal is to
+        # update the standard key when the alias is found. Since the standard key is
+        # always included in the default component configurations, we overwrite it
+        # with the alias value if the alias exists.
+        if alias in config:
+            config[standard_key] = config.pop(alias)
+
+    return config
+
+
+def raise_deprecation_warnings(
+    config: dict,
+    deprecated_alias_mapping: dict,
+    source: Optional[str] = None,
+) -> None:
+    """
+    Raises warnings for deprecated keys in the configuration.
+
+    Args:
+        config: Dictionary containing the configuration.
+        deprecated_alias_mapping: Dictionary mapping deprecated keys to
+            their standard keys.
+
+    Raises:
+        DeprecationWarning: If any deprecated key is found in the config.
+    """
+    for alias, standard_key in deprecated_alias_mapping.items():
+        if alias in config:
+            source = f"{source}: " or ""
+            raise_deprecation_warning(
+                message=(
+                    f"{source}"
+                    f"'{alias}' is deprecated and will be removed in "
+                    f"4.0.0. Use '{standard_key}' instead."
+                )
+            )
+
+
+def validate_required_keys(config: dict, required_keys: list) -> None:
+    """
+    Validates that the passed config contains all the required keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        required_keys: List of keys that must be present in the config.
+
+    Raises:
+        ValueError: If any required key is missing.
+    """
+    missing_keys = [key for key in required_keys if key not in config]
+    if missing_keys:
+        message = f"Missing required keys '{missing_keys}' for configuration."
+        structlogger.error(
+            "validate_required_keys",
+            message=message,
+            missing_keys=missing_keys,
+            config=config,
+        )
+        raise ValueError(message)
+
+
+def validate_forbidden_keys(config: dict, forbidden_keys: list) -> None:
+    """
+    Validates that the passed config doesn't contain any forbidden keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        forbidden_keys: List of keys that are forbidden in the config.
+
+    Raises:
+        ValueError: If any forbidden key is present.
+    """
+    forbidden_keys_in_config = set(config.keys()).intersection(set(forbidden_keys))
+
+    if forbidden_keys_in_config:
+        message = (
+            f"Forbidden keys '{forbidden_keys_in_config}' present "
+            f"in the configuration."
+        )
+        structlogger.error(
+            "validate_forbidden_keys",
+            message=message,
+            forbidden_keys=forbidden_keys_in_config,
+            config=config,
+        )
+        raise ValueError(message)

rasa/shared/utils/constants.py

@@ -2,9 +2,6 @@ DEFAULT_ENCODING = "utf-8"
 
 READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR = "READ_YAML_FILE_CACHE_MAXSIZE"
 DEFAULT_READ_YAML_FILE_CACHE_MAXSIZE = 256
-RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME = (
-    "RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS"
-)
 
 LOG_COMPONENT_SOURCE_METHOD_INIT = "init"
 LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON = "fingerprint_addon"

rasa/shared/utils/llm.py

@@ -6,6 +6,7 @@ import logging
 from copy import deepcopy
 from datetime import datetime
 from functools import wraps
+from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -24,6 +25,9 @@ from typing import (
 import structlog
 from pydantic import BaseModel, Field
 
+import rasa.cli.telemetry
+import rasa.cli.utils
+import rasa.shared.utils.cli
 import rasa.shared.utils.io
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.constants import (
@@ -31,12 +35,15 @@ from rasa.shared.constants import (
     CONFIG_PIPELINE_KEY,
     CONFIG_POLICIES_KEY,
     DEFAULT_PROMPT_PACKAGE_NAME,
+    ENDPOINTS_NLG_KEY,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_GROUPS_CONFIG_KEY,
     MODELS_CONFIG_KEY,
+    PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
@@ -85,13 +92,15 @@ USER = "USER"
 
 AI = "AI"
 
-DEFAULT_OPENAI_GENERATE_MODEL_NAME = "gpt-3.5-turbo"
+DEFAULT_OPENAI_GENERATE_MODEL_NAME = "gpt-4o-2024-11-20"
 
-DEFAULT_OPENAI_CHAT_MODEL_NAME = "gpt-3.5-turbo"
+DEFAULT_OPENAI_CHAT_MODEL_NAME = "gpt-4o-2024-11-20"
+
+DEFAULT_ENTERPRISE_SEARCH_POLICY_MODEL_NAME = "gpt-4.1-mini-2025-04-14"
 
 DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED = "gpt-4-0613"
 
-DEFAULT_OPENAI_EMBEDDING_MODEL_NAME = "text-embedding-ada-002"
+DEFAULT_OPENAI_EMBEDDING_MODEL_NAME = "text-embedding-3-large"
 
 DEFAULT_OPENAI_TEMPERATURE = 0.7
 
@@ -574,7 +583,7 @@ def embedder_factory(
     ```
     {
        "provider": "openai",
-       "model": "text-embedding-3-small",
+       "model": "text-embedding-3-large",
        "timeout": 10,
        "num_retries": 3,
     }
@@ -587,7 +596,7 @@ def embedder_factory(
         "models": [
             {
                 "provider": "openai",
-                "model": "test-embedding-3-small",
+                "model": "test-embedding-3-large",
                 "api_key": "test"
             },
         ],
@@ -950,6 +959,34 @@ async def create_tracker_for_user_step(
     await agent.tracker_store.save(tracker)
 
 
+def check_prompt_config_keys_and_warn_if_deprecated(
+    config: dict, component_source: str
+) -> None:
+    """Checks and warns about deprecated config parameters."""
+    if PROMPT_CONFIG_KEY in config and PROMPT_TEMPLATE_CONFIG_KEY in config:
+        structlogger.warning(
+            f"{component_source}.init"
+            ".both_deprecated_and_non_deprecated_config_keys_used_at_the_same_time",
+            event_info=(
+                f"Both '{PROMPT_CONFIG_KEY}' and '{PROMPT_TEMPLATE_CONFIG_KEY}' "
+                f"are present in the config. '{PROMPT_CONFIG_KEY}' will be ignored "
+                f"in favor of {PROMPT_TEMPLATE_CONFIG_KEY}."
+            ),
+        )
+
+    # 'prompt' config key is deprecated in favor of 'prompt_template'
+    if PROMPT_CONFIG_KEY in config:
+        structlogger.warning(
+            f"{component_source}.init.deprecated_config_key",
+            event_info=(
+                f"The config parameter '{PROMPT_CONFIG_KEY}' is deprecated "
+                "and will be removed in Rasa 4.0.0. "
+                f"Please use the config parameter '{PROMPT_TEMPLATE_CONFIG_KEY}'"
+                f" instead. "
+            ),
+        )
+
+
 def _get_llm_command_generator_config(
     config: Dict[Text, Any],
 ) -> Optional[Dict[Text, Any]]:
@@ -994,7 +1031,7 @@ def _get_command_generator_prompt(
         model_groups=endpoints.get(MODEL_GROUPS_CONFIG_KEY),
     )
     return get_default_prompt_template_based_on_model(
-        llm_config=llm_config,
+        llm_config=llm_config or {},
         model_prompt_mapping=MODEL_PROMPT_MAPPER,
         default_prompt_path=DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
         fallback_prompt_path=FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
@@ -1022,8 +1059,7 @@ def _get_enterprise_search_prompt(config: Dict[Text, Any]) -> Text:
 def get_system_default_prompts(
     config: Dict[Text, Any], endpoints: Dict[Text, Any]
 ) -> SystemPrompts:
-    """
-    Returns the system default prompts for the component.
+    """Returns the system default prompts for the component.
 
     Args:
         config: The config.yml file data.
@@ -1041,3 +1077,82 @@ def get_system_default_prompts(
         enterprise_search=_get_enterprise_search_prompt(config),
         contextual_response_rephraser=DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
     )
+
+
+def collect_custom_prompts(
+    config: Dict[Text, Any],
+    endpoints: Dict[Text, Any],
+    project_root: Optional[Path] = None,
+) -> Dict[Text, Text]:
+    """Collects custom prompts from the project configuration and endpoints.
+
+    Args:
+        config: The configuration dictionary of the project.
+        endpoints: The endpoints configuration dictionary.
+        project_root: The root directory of the project.
+
+    Returns:
+        A dictionary containing custom prompts.
+        The keys are:
+            - 'contextual_response_rephraser'
+            - 'command_generator'
+            - 'enterprise_search'
+    """
+    from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+    from rasa.dialogue_understanding.generator.llm_based_command_generator import (
+        LLMBasedCommandGenerator,
+    )
+    from rasa.studio.prompts import (
+        COMMAND_GENERATOR_NAME,
+        CONTEXTUAL_RESPONSE_REPHRASER_NAME,
+        ENTERPRISE_SEARCH_NAME,
+    )
+
+    prompts: Dict[Text, Text] = {}
+    project_root = project_root or Path(".").resolve()
+
+    def _read_prompt(root: Path, path_in_yaml: Text) -> Optional[Text]:
+        if not path_in_yaml:
+            return None
+
+        prompt_path = (
+            (root / path_in_yaml).resolve()
+            if not Path(path_in_yaml).is_absolute()
+            else Path(path_in_yaml)
+        )
+        if prompt_path.exists():
+            return prompt_path.read_text(encoding="utf-8")
+
+        structlogger.warning(
+            "utils.llm.collect_custom_prompts.prompt_not_found",
+            event_info=(f"Prompt file '{prompt_path}' not found. "),
+            prompt_path=prompt_path,
+            project_root=root,
+        )
+        return None
+
+    # contextual_response_rephraser
+    nlg_conf = endpoints.get(ENDPOINTS_NLG_KEY) or {}
+    if prompt_text := _read_prompt(project_root, nlg_conf.get(PROMPT_CONFIG_KEY)):
+        prompts[CONTEXTUAL_RESPONSE_REPHRASER_NAME] = prompt_text
+
+    # command_generator
+    command_generator_classes = {
+        cls.__name__ for cls in all_subclasses(LLMBasedCommandGenerator)
+    }
+    for component in config.get(CONFIG_PIPELINE_KEY, []):
+        if component.get(CONFIG_NAME_KEY) in command_generator_classes:
+            if prompt_text := _read_prompt(
+                project_root, component.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            ):
+                prompts[COMMAND_GENERATOR_NAME] = prompt_text
+                break
+
+    # enterprise_search
+    for policy in config.get(CONFIG_POLICIES_KEY, []):
+        if policy.get(CONFIG_NAME_KEY) == EnterpriseSearchPolicy.__name__:
+            if prompt_text := _read_prompt(project_root, policy.get(PROMPT_CONFIG_KEY)):
+                prompts[ENTERPRISE_SEARCH_NAME] = prompt_text
+            break
+
+    return prompts

rasa/shared/utils/pykwalify_extensions.py

@@ -8,11 +8,6 @@ from typing import Any, Dict, List, Text, Union
 
 from pykwalify.errors import SchemaError
 
-from rasa.shared.utils.constants import (
-    RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME,
-)
-from rasa.utils.beta import ensure_beta_feature_is_enabled
-
 
 def require_response_keys(
     responses: List[Dict[Text, Any]], _: Dict, __: Text
@@ -31,10 +26,6 @@ def require_response_keys(
 
         conditions = response.get("condition", [])
         if isinstance(conditions, str):
-            ensure_beta_feature_is_enabled(
-                "predicates in response conditions",
-                RASA_PRO_BETA_PREDICATES_IN_RESPONSE_CONDITIONS_ENV_VAR_NAME,
-            )
             continue
 
         for condition in conditions:

rasa/studio/constants.py

@@ -14,6 +14,7 @@ RASA_STUDIO_CLI_DISABLE_VERIFY_KEY_ENV = "RASA_STUDIO_CLI_DISABLE_VERIFY_KEY"
 
 STUDIO_NLU_FILENAME = "studio_nlu.yml"
 STUDIO_DOMAIN_FILENAME = "studio_domain.yml"
+DOMAIN_FILENAME = "domain.yml"
 STUDIO_FLOWS_FILENAME = "studio_flows.yml"
 STUDIO_CONFIG_FILENAME = "studio_config.yml"
 STUDIO_ENDPOINTS_FILENAME = "studio_endpoints.yml"

rasa/studio/data_handler.py

@@ -45,15 +45,33 @@ class StudioDataHandler:
         intent_names: Optional[List[str]] = None,
         entity_names: Optional[List[str]] = None,
     ) -> dict:
+        from rasa.studio.prompts import (
+            COMMAND_GENERATOR_NAME,
+            CONTEXTUAL_RESPONSE_REPHRASER_NAME,
+            ENTERPRISE_SEARCH_NAME,
+        )
+
         request = {
-            "query": (
-                "query ExportAsEncodedYaml($input: ExportAsEncodedYamlInput!) "
-                "{ exportAsEncodedYaml(input: $input) "
-                "{ ... on ExportModernAsEncodedYamlOutput "
-                "{ nlu flows domain endpoints config } "
-                "... on ExportClassicAsEncodedYamlOutput "
-                "{ nlu domain }}}"
-            ),
+            "query": "query ExportAsEncodedYaml($input: ExportAsEncodedYamlInput!) {\n"
+            "  exportAsEncodedYaml(input: $input) {\n"
+            "    ... on ExportModernAsEncodedYamlOutput {\n"
+            "      nlu\n"
+            "      flows\n"
+            "      domain\n"
+            "      endpoints\n"
+            "      config\n"
+            "      prompts {\n"
+            f"        {COMMAND_GENERATOR_NAME}\n"
+            f"        {CONTEXTUAL_RESPONSE_REPHRASER_NAME}\n"
+            f"        {ENTERPRISE_SEARCH_NAME}\n"
+            "      }\n"
+            "    }\n"
+            "    ... on ExportClassicAsEncodedYamlOutput {\n"
+            "      nlu\n"
+            "      domain\n"
+            "    }\n"
+            "  }\n"
+            "}\n",
             "variables": {"input": {"assistantName": self.assistant_name}},
         }
         if intent_names or entity_names:
@@ -97,7 +115,6 @@ class StudioDataHandler:
             },
             verify=verify,
         )
-
         if res.status_code != 200:
             raise RasaException(
                 f"Download from Studio with URL: "
@@ -161,6 +178,9 @@ class StudioDataHandler:
     def get_endpoints(self) -> Optional[str]:
         return self.endpoints
 
+    def get_prompts(self) -> Optional[dict]:
+        return self.prompts
+
     def _validate_response(self, response: dict) -> bool:
         """Validates the response from Rasa Studio.
 
@@ -199,6 +219,7 @@ class StudioDataHandler:
         self.flows = self._decode_response(return_data.get("flows"))
         self.config = self._decode_response(return_data.get("config"))
         self.endpoints = self._decode_response(return_data.get("endpoints"))
+        self.prompts = return_data.get("prompts")
 
         if not self.has_nlu() and not self.has_flows():
             raise RasaException("No nlu or flows data in Studio response.")

rasa/studio/download.py

@@ -0,0 +1,171 @@
+import argparse
+import shutil
+from pathlib import Path
+from typing import Dict
+
+import questionary
+import structlog
+from ruamel import yaml
+from ruamel.yaml.scalarstring import LiteralScalarString
+
+import rasa.cli.utils
+import rasa.shared.utils.cli
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_DATA_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+from rasa.shared.core.flows.yaml_flows_io import FlowsList
+from rasa.shared.nlu.training_data.training_data import (
+    DEFAULT_TRAINING_DATA_OUTPUT_PATH,
+)
+from rasa.shared.utils.yaml import read_yaml, write_yaml
+from rasa.studio.config import StudioConfig
+from rasa.studio.constants import DOMAIN_FILENAME
+from rasa.studio.data_handler import StudioDataHandler
+from rasa.studio.prompts import handle_prompts
+from rasa.studio.pull.data import _dump_flows_as_separate_files
+from rasa.studio.utils import validate_argument_paths
+
+structlogger = structlog.get_logger()
+
+
+def handle_download(args: argparse.Namespace) -> None:
+    """Download an assistant from Studio and store it in `<assistant_name>/`.
+
+    Args:
+        args: The command line arguments.
+    """
+    validate_argument_paths(args)
+    assistant_name = args.assistant_name
+    target_root = _prepare_target_directory(assistant_name)
+
+    handler = StudioDataHandler(
+        studio_config=StudioConfig.read_config(), assistant_name=assistant_name
+    )
+    handler.request_all_data()
+
+    _handle_config(handler, target_root)
+    _handle_endpoints(handler, target_root)
+    _handle_domain(handler, target_root)
+    _handle_data(handler, target_root)
+
+    if prompts := handler.get_prompts():
+        handle_prompts(prompts, target_root)
+
+    structlogger.info(
+        "studio.download.success",
+        event_info=f"Downloaded assistant '{assistant_name}' from Studio.",
+        assistant_name=assistant_name,
+    )
+    rasa.shared.utils.cli.print_success(
+        f"Downloaded assistant '{assistant_name}' from Studio."
+    )
+
+
+def _prepare_target_directory(assistant_name: str) -> Path:
+    """Create (or overwrite) the directory where everything is stored.
+
+    Args:
+        assistant_name: The name of the assistant to download.
+
+    Returns:
+        The path to the target directory where the assistant will be stored.
+    """
+    target_root = Path(assistant_name)
+
+    if target_root.exists():
+        overwrite = questionary.confirm(
+            f"Directory '{assistant_name}' already exists. Overwrite it?"
+        ).ask()
+        if not overwrite:
+            rasa.shared.utils.cli.print_error_and_exit("Download cancelled.")
+
+        shutil.rmtree(target_root)
+
+    target_root.mkdir(parents=True, exist_ok=True)
+    return target_root
+
+
+def _handle_config(handler: StudioDataHandler, root: Path) -> None:
+    """Download and persist the assistant’s config file.
+
+    Args:
+        handler: The data handler to retrieve the config from.
+        root: The root directory where the config file will be stored.
+    """
+    config_data = handler.get_config()
+    if not config_data:
+        rasa.shared.utils.cli.print_error_and_exit("No config data found.")
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    config_path.write_text(config_data, encoding="utf-8")
+
+
+def _handle_endpoints(handler: StudioDataHandler, root: Path) -> None:
+    """Download and persist the assistant’s endpoints file.
+
+    Args:
+        handler: The data handler to retrieve the endpoints from.
+        root: The root directory where the endpoints file will be stored.
+    """
+    endpoints_data = handler.get_endpoints()
+    if not endpoints_data:
+        rasa.shared.utils.cli.print_error_and_exit("No endpoints data found.")
+
+    endpoints_path = root / DEFAULT_ENDPOINTS_PATH
+    endpoints_path.write_text(endpoints_data, encoding="utf-8")
+
+
+def _handle_domain(handler: StudioDataHandler, root: Path) -> None:
+    """Persist the assistant’s domain file.
+
+    Args:
+        handler: The data handler to retrieve the domain from.
+        root: The root directory where the domain file will be stored.
+    """
+    domain_yaml = handler.domain
+    data = read_yaml(domain_yaml)
+    target = root / DOMAIN_FILENAME
+    write_yaml(
+        data=data,
+        target=target,
+        should_preserve_key_order=True,
+    )
+
+
+def _handle_data(handler: StudioDataHandler, root: Path) -> None:
+    """Persist NLU data and flows.
+
+    Args:
+        handler: The data handler to retrieve the NLU data and flows from.
+        root: The root directory where the NLU data and flows will be stored.
+    """
+    data_path = root / DEFAULT_DATA_PATH
+    data_path.mkdir(parents=True, exist_ok=True)
+
+    if handler.has_nlu():
+        nlu_yaml = handler.nlu
+        nlu_data = read_yaml(nlu_yaml)
+        if nlu_data.get("nlu"):
+            pretty_write_nlu_yaml(
+                nlu_data, data_path / DEFAULT_TRAINING_DATA_OUTPUT_PATH
+            )
+
+    if handler.has_flows():
+        flows_yaml = handler.flows
+        data = read_yaml(flows_yaml)
+        flows_data = data.get("flows", {})
+        flows_list = FlowsList.from_json(flows_data)
+        _dump_flows_as_separate_files(flows_list.underlying_flows, data_path)
+
+
+def pretty_write_nlu_yaml(data: Dict, file: Path) -> None:
+    """Writes the NLU YAML in a pretty way."""
+    dumper = yaml.YAML()
+    if nlu_data := data.get("nlu"):
+        for item in nlu_data:
+            if item.get("examples"):
+                item["examples"] = LiteralScalarString(item["examples"])
+    with file.open("w", encoding="utf-8") as outfile:
+        dumper.dump(data, outfile)

rasa/studio/link.py

@@ -167,7 +167,7 @@ def handle_link(args: argparse.Namespace) -> None:
     Args:
         args: The command line arguments.
     """
-    assistant_name: Text = args.assistant_name[0]
+    assistant_name: Text = args.assistant_name
     studio_cfg = get_studio_config()
     assistant_exists = _ensure_assistant_exists(assistant_name, studio_cfg, args)
     if not assistant_exists:
@@ -179,8 +179,19 @@ def handle_link(args: argparse.Namespace) -> None:
     link_file = _link_file(project_root)
 
     if link_file.exists():
+        linked_assistant_name = read_assistant_name(project_root)
+        if linked_assistant_name == assistant_name:
+            rasa.shared.utils.cli.print_info(
+                f"Project is already linked to assistant '{assistant_name}'."
+            )
+            sys.exit(0)
+
         overwrite = questionary.confirm(
-            f"This project is already linked " f"(link file '{link_file}').\nOverwrite?"
+            f"Project is currently linked to the following Rasa Studio assistant:\n\n"
+            f"  Assistant name: {linked_assistant_name}\n"
+            f"  Studio URL: {studio_cfg.studio_url}\n"
+            f"  Keycloak Auth URL: {studio_cfg.authentication_server_url}\n\n"
+            f"Do you want to overwrite it with the new assistant '{assistant_name}'?"
         ).ask()
         if not overwrite:
             rasa.shared.utils.cli.print_info(