rasa-pro 3.12.21__py3-none-any.whl → 3.13.0__py3-none-any.whl

rasa/shared/utils/llm.py

@@ -1,9 +1,12 @@
+from __future__ import annotations
+
 import importlib.resources
 import json
 import logging
 from copy import deepcopy
 from datetime import datetime
 from functools import wraps
+from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -20,15 +23,27 @@ 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.utils import AvailableEndpoints
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.constants import (
+    CONFIG_NAME_KEY,
+    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,
@@ -63,6 +78,7 @@ from rasa.shared.providers.mappings import (
     get_embedding_client_from_provider,
     get_llm_client_from_provider,
 )
+from rasa.shared.utils.common import all_subclasses
 from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_INIT
 
 if TYPE_CHECKING:
@@ -76,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-4o-2024-11-20"
 
-DEFAULT_OPENAI_CHAT_MODEL_NAME = "gpt-3.5-turbo"
+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
 
@@ -110,6 +128,18 @@ _CombineConfigs_F = TypeVar(
 )
 
 
+class SystemPrompts(BaseModel):
+    command_generator: str = Field(
+        ..., description="Prompt used by the LLM command generator."
+    )
+    enterprise_search: str = Field(
+        ..., description="Prompt for standard enterprise search requests."
+    )
+    contextual_response_rephraser: str = Field(
+        ..., description="Prompt used for re-phrasing assistant responses."
+    )
+
+
 def _compute_hash_for_cache_from_configs(
     config_x: Dict[str, Any], config_y: Dict[str, Any]
 ) -> int:
@@ -553,7 +583,7 @@ def embedder_factory(
     ```
     {
        "provider": "openai",
-       "model": "text-embedding-3-small",
+       "model": "text-embedding-3-large",
        "timeout": 10,
        "num_retries": 3,
     }
@@ -566,7 +596,7 @@ def embedder_factory(
         "models": [
             {
                 "provider": "openai",
-                "model": "test-embedding-3-small",
+                "model": "test-embedding-3-large",
                 "api_key": "test"
             },
         ],
@@ -821,7 +851,9 @@ def allowed_values_for_slot(slot: Slot) -> Union[str, None]:
 
 
 def resolve_model_client_config(
-    model_config: Optional[Dict[str, Any]], component_name: Optional[str] = None
+    model_config: Optional[Dict[str, Any]],
+    component_name: Optional[str] = None,
+    model_groups: Optional[List[Dict[str, Any]]] = None,
 ) -> Optional[Dict[str, Any]]:
     """Resolve the model group in the model config.
 
@@ -835,6 +867,7 @@ def resolve_model_client_config(
         model_config: The model config to be resolved.
         component_name: The name of the component.
         component_name: The method of the component.
+        model_groups: Model groups from endpoints.yml.
 
     Returns:
         The resolved llm config.
@@ -861,7 +894,12 @@ def resolve_model_client_config(
 
     model_group_id = model_config.get(MODEL_GROUP_CONFIG_KEY)
 
-    endpoints = AvailableEndpoints.get_instance()
+    # If `model_groups` is provided, use it to initialise `AvailableEndpoints`,
+    # since `get_instance()` reads from the local endpoints file instead.
+    if model_groups:
+        endpoints = AvailableEndpoints(model_groups=model_groups)
+    else:
+        endpoints = AvailableEndpoints.get_instance()
     if endpoints.model_groups is None:
         _raise_invalid_config_exception(
             reason=(
@@ -919,3 +957,202 @@ async def create_tracker_for_user_step(
 
     # store the tracker with the unique sender id
     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]]:
+    """Get the llm command generator config from config.yml.
+
+    Args:
+        config: The config.yml file data.
+
+    Returns:
+        The llm command generator config.
+    """
+    from rasa.dialogue_understanding.generator import LLMBasedCommandGenerator
+
+    # Collect all LLM based Command Generator class names.
+    command_generator_subclasses = all_subclasses(LLMBasedCommandGenerator)
+    command_generator_class_names = [
+        command_generator.__name__ for command_generator in command_generator_subclasses
+    ]
+
+    # Read the LLM config of the Command Generator from the config.yml file.
+    pipelines = config.get(CONFIG_PIPELINE_KEY, [])
+    for pipeline in pipelines:
+        if pipeline.get(CONFIG_NAME_KEY) in command_generator_class_names:
+            return pipeline.get(LLM_CONFIG_KEY)
+
+    return None
+
+
+def _get_command_generator_prompt(
+    config: Dict[Text, Any], endpoints: Dict[Text, Any]
+) -> Text:
+    """Get the command generator prompt based on the config."""
+    from rasa.dialogue_understanding.generator.single_step.compact_llm_command_generator import (  # noqa: E501
+        DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+        FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME,
+        MODEL_PROMPT_MAPPER,
+    )
+
+    model_config = _get_llm_command_generator_config(config)
+    llm_config = resolve_model_client_config(
+        model_config=model_config,
+        model_groups=endpoints.get(MODEL_GROUPS_CONFIG_KEY),
+    )
+    return get_default_prompt_template_based_on_model(
+        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,
+    )
+
+
+def _get_enterprise_search_prompt(config: Dict[Text, Any]) -> Text:
+    """Get the enterprise search prompt based on the config."""
+    from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+
+    def get_enterprise_search_config() -> Dict[Text, Any]:
+        policies = config.get(CONFIG_POLICIES_KEY, [])
+        for policy in policies:
+            if policy.get(CONFIG_NAME_KEY) == EnterpriseSearchPolicy.__name__:
+                return policy
+
+        return {}
+
+    enterprise_search_config = get_enterprise_search_config()
+    return EnterpriseSearchPolicy.get_system_default_prompt_based_on_config(
+        enterprise_search_config
+    )
+
+
+def get_system_default_prompts(
+    config: Dict[Text, Any], endpoints: Dict[Text, Any]
+) -> SystemPrompts:
+    """Returns the system default prompts for the component.
+
+    Args:
+        config: The config.yml file data.
+        endpoints: The endpoints.yml file data.
+
+    Returns:
+        SystemPrompts: A Pydantic model containing all default prompts.
+    """
+    from rasa.core.nlg.contextual_response_rephraser import (
+        DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
+    )
+
+    return SystemPrompts(
+        command_generator=_get_command_generator_prompt(config, endpoints),
+        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/shared/utils/yaml.py

@@ -21,6 +21,7 @@ from ruamel.yaml import YAML, RoundTripRepresenter, YAMLError
 from ruamel.yaml.comments import CommentedMap, CommentedSeq
 from ruamel.yaml.constructor import BaseConstructor, DuplicateKeyError, ScalarNode
 from ruamel.yaml.loader import SafeLoader
+from ruamel.yaml.scalarstring import LiteralScalarString
 
 from rasa.shared.constants import (
     ASSERTIONS_SCHEMA_EXTENSIONS_FILE,
@@ -794,6 +795,25 @@ def write_yaml(
         should_preserve_key_order: Whether to force preserve key order in `data`.
         transform: A function to transform the data before writing it to the file.
     """
+
+    def multiline_str_representer(self: Any, value: str) -> Any:
+        """Dump multi-line strings as readable YAML block scalars where possible."""
+        if "\n" in value:
+            # First line after the newline decides: paragraph vs. snippet
+            first_line = value.split("\n", 1)[1]
+
+            # If the first line after the newline is not indented, treat the value
+            # as plain text. Indented text is likely pre-formatted YAML/JSON/etc.
+            if not first_line.startswith((" ", "\t")):
+                return self.represent_scalar(
+                    "tag:yaml.org,2002:str",
+                    LiteralScalarString(value),
+                    style="|",
+                )
+
+        # Fallback: keep default YAML scalar style (plain/quoted)
+        return self.represent_scalar("tag:yaml.org,2002:str", value)
+
     _enable_ordered_dict_yaml_dumping()
 
     if should_preserve_key_order:
@@ -808,6 +828,7 @@ def write_yaml(
         type(None),
         lambda self, _: self.represent_scalar("tag:yaml.org,2002:null", "null"),
     )
+    dumper.representer.add_representer(str, multiline_str_representer)
 
     if isinstance(target, StringIO):
         dumper.dump(data, target, transform=transform)
@@ -1025,6 +1046,17 @@ def validate_yaml_with_jsonschema(
     except (YAMLError, DuplicateKeyError) as e:
         raise YamlSyntaxException(underlying_yaml_exception=e)
 
+    validate_data_with_jsonschema(source_data, schema_content, humanize_error)
+
+
+def validate_data_with_jsonschema(
+    source_data: Any,
+    schema_content: Any,
+    humanize_error: Callable[
+        [jsonschema.ValidationError], str
+    ] = default_error_humanizer,
+) -> None:
+    """Validate Python object against the provided jsonschema content."""
     try:
         jsonschema.validate(source_data, schema_content)
     except jsonschema.ValidationError as error:

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.")
@@ -320,14 +341,14 @@ def create_new_flows_from_diff(
 
 
 def import_data_from_studio(
-    handler: StudioDataHandler, domain_path: Path, data_paths: List[Path]
+    handler: StudioDataHandler, domain_path: Path, data_path: Path
 ) -> Tuple[TrainingDataImporter, TrainingDataImporter]:
     """Construct TrainingDataImporter from Studio data and original data.
 
     Args:
         handler (StudioDataHandler): handler with data from studio
         domain_path (Path): Path to a domain file
-        data_paths (List[Path]): List of paths to training data files
+        data_path (List[Path]): List of paths to training data files
 
     Returns:
         Tuple[TrainingDataImporter, TrainingDataImporter]:
@@ -335,7 +356,7 @@ def import_data_from_studio(
     """
     tmp_dir = get_temp_dir_name()
     data_original = TrainingDataImporter.load_from_dict(
-        domain_path=domain_path, training_data_paths=data_paths
+        domain_path=str(domain_path), training_data_paths=[str(data_path)]
     )
 
     data_paths = []