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

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

@@ -37,6 +37,8 @@ from rasa.shared.constants import (
     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 +87,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
 
@@ -950,6 +954,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 +1026,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 +1054,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.

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

@@ -1,4 +1,5 @@
 import base64
+import json
 import logging
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
@@ -50,7 +51,7 @@ class StudioDataHandler:
                 "query ExportAsEncodedYaml($input: ExportAsEncodedYamlInput!) "
                 "{ exportAsEncodedYaml(input: $input) "
                 "{ ... on ExportModernAsEncodedYamlOutput "
-                "{ nlu flows domain endpoints config } "
+                "{ nlu flows domain endpoints config prompts } "
                 "... on ExportClassicAsEncodedYamlOutput "
                 "{ nlu domain }}}"
             ),
@@ -161,6 +162,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.
 
@@ -200,6 +204,9 @@ class StudioDataHandler:
         self.config = self._decode_response(return_data.get("config"))
         self.endpoints = self._decode_response(return_data.get("endpoints"))
 
+        prompts_string = self._decode_response(return_data.get("prompts"))
+        self.prompts = json.loads(prompts_string) if prompts_string else None
+
         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,167 @@
+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
+
+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.
+    """
+    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)
+    handle_prompts(handler, 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:

rasa/studio/prompts.py

@@ -0,0 +1,223 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Text
+
+import structlog
+
+from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+from rasa.dialogue_understanding.generator.llm_based_command_generator import (
+    LLMBasedCommandGenerator,
+)
+from rasa.shared.constants import (
+    CONFIG_NAME_KEY,
+    CONFIG_PIPELINE_KEY,
+    CONFIG_POLICIES_KEY,
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+    DEFAULT_PROMPTS_PATH,
+    PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
+)
+from rasa.shared.utils.common import all_subclasses
+from rasa.shared.utils.llm import get_system_default_prompts
+from rasa.shared.utils.yaml import read_yaml, write_yaml
+from rasa.studio.data_handler import StudioDataHandler
+
+structlogger = structlog.get_logger()
+
+CONTEXTUAL_RESPONSE_REPHRASER_NAME = "contextual_response_rephraser"
+COMMAND_GENERATOR_NAME = "command_generator"
+ENTERPRISE_SEARCH_NAME = "enterprise_search"
+
+
+def handle_prompts(handler: StudioDataHandler, root: Path) -> None:
+    """Handle prompts for the assistant.
+
+    Args:
+        handler: The data handler to retrieve prompts from.
+        root: The root directory where the prompts should be saved.
+    """
+    prompts = handler.get_prompts()
+    if not prompts:
+        return
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    endpoints_path = root / DEFAULT_ENDPOINTS_PATH
+    config: Dict = read_yaml(config_path)
+    endpoints: Dict = read_yaml(endpoints_path)
+
+    system_prompts = get_system_default_prompts(config, endpoints)
+
+    _handle_contextual_response_rephraser(
+        root,
+        prompts.get(CONTEXTUAL_RESPONSE_REPHRASER_NAME),
+        system_prompts.contextual_response_rephraser,
+        endpoints,
+    )
+    _handle_command_generator(
+        root,
+        prompts.get(COMMAND_GENERATOR_NAME),
+        system_prompts.command_generator,
+        config,
+    )
+    _handle_enterprise_search(
+        root,
+        prompts.get(ENTERPRISE_SEARCH_NAME),
+        system_prompts.enterprise_search,
+        config,
+    )
+
+
+def _handle_contextual_response_rephraser(
+    root: Path,
+    prompt_content: Optional[Text],
+    system_prompt: Optional[Text],
+    endpoints: Dict,
+) -> None:
+    """Handles the contextual response rephraser prompt.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        prompt_content: The content of the contextual response rephraser prompt.
+        system_prompt: The system prompt for comparison.
+        endpoints: The endpoints configuration to update with the prompt path.
+    """
+    if not _is_custom_prompt(prompt_content, system_prompt):
+        return
+
+    prompt_path = _save_prompt_file(
+        root, f"{CONTEXTUAL_RESPONSE_REPHRASER_NAME}.jinja", prompt_content
+    )
+
+    endpoints["nlg"] = endpoints.get("nlg") or {}
+    endpoints["nlg"]["prompt"] = str(prompt_path)
+
+    endpoints_path = root / DEFAULT_ENDPOINTS_PATH
+    write_yaml(data=endpoints, target=endpoints_path, should_preserve_key_order=True)
+
+
+def _handle_command_generator(
+    root: Path,
+    prompt_content: Optional[Text],
+    system_prompt: Optional[Text],
+    config: Dict,
+) -> None:
+    """Handles the command generator prompt.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        prompt_content: The content of the command generator prompt.
+        system_prompt: The system prompt for comparison.
+        config: The configuration dictionary to update with the prompt path.
+    """
+    if not _is_custom_prompt(prompt_content, system_prompt):
+        return
+
+    prompt_path = _save_prompt_file(
+        root, f"{COMMAND_GENERATOR_NAME}.jinja", prompt_content
+    )
+
+    command_generator_names: List[str] = [
+        cls.__name__ for cls in all_subclasses(LLMBasedCommandGenerator)
+    ]
+    _add_prompt_to_config(
+        config=config,
+        section_key=CONFIG_PIPELINE_KEY,
+        component_names=command_generator_names,
+        prompt_key=PROMPT_TEMPLATE_CONFIG_KEY,
+        prompt_path=str(prompt_path),
+    )
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    write_yaml(data=config, target=config_path, should_preserve_key_order=True)
+
+
+def _handle_enterprise_search(
+    root: Path,
+    prompt_content: Optional[Text],
+    system_prompt: Optional[Text],
+    config: Dict,
+) -> None:
+    """Handles the enterprise search prompt.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        prompt_content: The content of the enterprise search prompt.
+        system_prompt: The system prompt for comparison.
+        config: The configuration dictionary to update with the prompt path.
+    """
+    if not _is_custom_prompt(prompt_content, system_prompt):
+        return
+
+    prompt_path = _save_prompt_file(
+        root, f"{ENTERPRISE_SEARCH_NAME}.jinja", prompt_content
+    )
+
+    _add_prompt_to_config(
+        config=config,
+        section_key=CONFIG_POLICIES_KEY,
+        component_names=[EnterpriseSearchPolicy.__name__],
+        prompt_key=PROMPT_CONFIG_KEY,
+        prompt_path=str(prompt_path),
+    )
+
+    config_path = root / DEFAULT_CONFIG_PATH
+    write_yaml(data=config, target=config_path, should_preserve_key_order=True)
+
+
+def _is_custom_prompt(
+    studio_prompt: Optional[Text], system_prompt: Optional[Text]
+) -> bool:
+    """Check if the prompt has been customized in Studio.
+
+    Args:
+        studio_prompt: The prompt content from the Studio.
+        system_prompt: The default system prompt content.
+    """
+    return bool(studio_prompt and studio_prompt != system_prompt)
+
+
+def _save_prompt_file(root: Path, filename: str, content: str) -> Path:
+    """Save a prompt file to the specified root directory.
+
+    Args:
+        root: The root directory where the prompt file will be saved.
+        filename: The name of the prompt file.
+        content: The content of the prompt.
+    """
+    prompts_dir = root / DEFAULT_PROMPTS_PATH
+    prompts_dir.mkdir(parents=True, exist_ok=True)
+
+    file_path = prompts_dir / filename
+    file_path.write_text(content, encoding="utf-8")
+
+    return file_path.relative_to(root)
+
+
+def _add_prompt_to_config(
+    *,
+    config: Dict,
+    section_key: str,
+    component_names: List[str],
+    prompt_key: str,
+    prompt_path: str,
+) -> None:
+    """Add a prompt path to the specified section of the configuration."""
+    matches = [
+        component
+        for component in config.get(section_key, [])
+        if component.get(CONFIG_NAME_KEY) in component_names
+    ]
+
+    if not matches:
+        return
+
+    # Update the first occurrence of the component.
+    matches[0][prompt_key] = prompt_path
+
+    if len(matches) > 1:
+        structlogger.warning(
+            "rasa.studio.prompts.add_prompt_to_config.multiple_components",
+            event_info=(
+                "Multiple components found in the configuration for the same prompt."
+            ),
+        )