rasa-pro 3.11.3__py3-none-any.whl → 3.11.3a1.dev1__py3-none-any.whl

rasa/e2e_test/utils/validation.py

@@ -6,6 +6,7 @@ import structlog
 
 import rasa.shared.utils.io
 from rasa.e2e_test.constants import SCHEMA_FILE_PATH
+from rasa.e2e_test.e2e_test_case import Fixture, Metadata
 from rasa.shared.utils.yaml import read_schema_file
 
 if TYPE_CHECKING:
@@ -27,8 +28,24 @@ def validate_path_to_test_cases(path: str) -> None:
         sys.exit(1)
 
 
-def validate_test_case(test_case_name: str, input_test_cases: List["TestCase"]) -> None:
-    """Validate that test case exists."""
+def validate_test_case(
+    test_case_name: str,
+    input_test_cases: List["TestCase"],
+    fixtures: Dict[str, Fixture],
+    metadata: Dict[str, Metadata],
+) -> None:
+    """
+    Validate the test case, its fixtures, and metadata.
+
+    Args:
+        test_case_name (str): The name of the test case to validate.
+        input_test_cases (List["TestCase"]): A list of test cases to validate.
+        fixtures (Dict[str, Fixture]): A dictionary of defined fixtures.
+        metadata (Dict[str, Metadata]): A dictionary of defined metadata.
+
+    Raises:
+        SystemExit: If the test case, fixtures, or metadata are not defined.
+    """
     if test_case_name and not input_test_cases:
         rasa.shared.utils.io.raise_warning(
             f"Test case does not exist: {test_case_name}. "
@@ -38,6 +55,87 @@ def validate_test_case(test_case_name: str, input_test_cases: List["TestCase"])
         )
         sys.exit(1)
 
+    all_good = True
+    for test_case in input_test_cases:
+        all_good_fixtures = validate_test_case_fixtures(test_case, fixtures)
+        all_good_metadata = validate_test_case_metadata(test_case, metadata)
+        all_good = all_good and all_good_fixtures and all_good_metadata
+
+    if not all_good:
+        sys.exit(1)
+
+
+def validate_test_case_fixtures(
+    test_case: "TestCase", fixtures: Dict[str, Fixture]
+) -> bool:
+    """Validates that the fixtures used in the test case are defined.
+
+    Args:
+        test_case (TestCase): The test case to validate.
+        fixtures (Dict[str, Fixture]): A dictionary of defined fixtures.
+
+    Returns:
+        True if all fixtures used in the test case are defined, False otherwise.
+
+    Raises:
+        Logs an error if a fixture used in the test case is not defined.
+    """
+    all_good = True
+    if not test_case.fixture_names:
+        return all_good
+
+    for fixture_name in test_case.fixture_names:
+        if fixture_name not in fixtures:
+            structlogger.error(
+                "validation.validate_test_case_fixtures",
+                event_info=(
+                    f"Fixture '{fixture_name}' referenced in the "
+                    f"test case '{test_case.name}' is not defined."
+                ),
+            )
+            all_good = False
+    return all_good
+
+
+def validate_test_case_metadata(
+    test_case: "TestCase", metadata: Dict[str, Metadata]
+) -> bool:
+    """
+    Validates that the metadata used in the test case and its steps are defined.
+
+    Args:
+        test_case (TestCase): The test case to validate.
+        metadata (Dict[str, Metadata]): A dictionary of defined metadata.
+
+    Returns:
+        True if all fixtures used in the test case are defined, False otherwise.
+
+    Raises:
+        Logs an error if metadata used in the test case or its steps is not defined.
+    """
+    all_good = True
+    if test_case.metadata_name and test_case.metadata_name not in metadata:
+        structlogger.error(
+            "validation.validate_test_case_metadata.test_case_metadata",
+            event_info=(
+                f"Metadata '{test_case.metadata_name}' referenced in "
+                f"the test case '{test_case.name}' is not defined."
+            ),
+        )
+        all_good = False
+
+    for step in test_case.steps:
+        if step.metadata_name and step.metadata_name not in metadata:
+            structlogger.error(
+                "validation.validate_test_case_metadata.step_metadata",
+                event_info=(
+                    f"Metadata '{step.metadata_name}' referenced in the "
+                    f"step of the test case '{test_case.name}' is not defined."
+                ),
+            )
+            all_good = False
+    return all_good
+
 
 def validate_model_path(model_path: Optional[str], parameter: str, default: str) -> str:
     """Validate the model path.

rasa/engine/recipes/default_recipe.py

@@ -1,65 +1,71 @@
 from __future__ import annotations
 
 import copy
+import dataclasses
 import enum
 import logging
 import math
 from enum import Enum
-from typing import Dict, Text, Any, Tuple, Type, Optional, List, Callable, Set, Union
-
-import dataclasses
+from typing import Any, Callable, Dict, List, Optional, Set, Text, Tuple, Type, Union
 
+import rasa.shared.constants
 from rasa.core.featurizers.precomputation import (
-    CoreFeaturizationInputConverter,
     CoreFeaturizationCollector,
+    CoreFeaturizationInputConverter,
 )
-from rasa.graph_components.providers.flows_provider import FlowsProvider
+from rasa.core.policies.ensemble import DefaultPolicyPredictionEnsemble
 from rasa.dialogue_understanding.processor.command_processor_component import (
     CommandProcessorComponent,
 )
-from rasa.shared.exceptions import FileNotFoundException
-from rasa.core.policies.ensemble import DefaultPolicyPredictionEnsemble
-
-from rasa.engine.graph import (
-    GraphSchema,
-    GraphComponent,
-    SchemaNode,
-    GraphModelConfiguration,
-)
 from rasa.engine.constants import (
+    PLACEHOLDER_ENDPOINTS,
     PLACEHOLDER_IMPORTER,
     PLACEHOLDER_MESSAGE,
     PLACEHOLDER_TRACKER,
-    PLACEHOLDER_ENDPOINTS,
+)
+from rasa.engine.graph import (
+    GraphComponent,
+    GraphModelConfiguration,
+    GraphSchema,
+    SchemaNode,
 )
 from rasa.engine.recipes.recipe import Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.graph_components.converters.nlu_message_converter import NLUMessageConverter
-from rasa.graph_components.providers.domain_provider import DomainProvider
-from rasa.graph_components.providers.forms_provider import FormsProvider
-from rasa.graph_components.providers.responses_provider import ResponsesProvider
 from rasa.graph_components.providers.domain_for_core_training_provider import (
     DomainForCoreTrainingProvider,
 )
+from rasa.graph_components.providers.domain_provider import DomainProvider
+from rasa.graph_components.providers.flows_provider import FlowsProvider
+from rasa.graph_components.providers.forms_provider import FormsProvider
 from rasa.graph_components.providers.nlu_training_data_provider import (
     NLUTrainingDataProvider,
 )
+from rasa.graph_components.providers.responses_provider import ResponsesProvider
 from rasa.graph_components.providers.rule_only_provider import RuleOnlyDataProvider
 from rasa.graph_components.providers.story_graph_provider import StoryGraphProvider
 from rasa.graph_components.providers.training_tracker_provider import (
     TrainingTrackerProvider,
 )
-import rasa.shared.constants
-from rasa.shared.exceptions import RasaException, InvalidConfigException
-from rasa.shared.constants import ASSISTANT_ID_KEY
+from rasa.shared.constants import (
+    ASSISTANT_ID_KEY,
+    CONFIG_LANGUAGE_KEY,
+    CONFIG_NAME_KEY,
+    CONFIG_PIPELINE_KEY,
+    CONFIG_POLICIES_KEY,
+)
 from rasa.shared.data import TrainingType
-from rasa.shared.utils.yaml import read_config_file
-
-from rasa.utils.tensorflow.constants import EPOCHS
+from rasa.shared.exceptions import (
+    FileNotFoundException,
+    InvalidConfigException,
+    RasaException,
+)
 from rasa.shared.utils.common import (
     class_from_module_path,
     transform_collection_to_sentence,
 )
+from rasa.shared.utils.yaml import read_config_file
+from rasa.utils.tensorflow.constants import EPOCHS
 
 logger = logging.getLogger(__name__)
 
@@ -67,13 +73,13 @@ logger = logging.getLogger(__name__)
 DEFAULT_PREDICT_KWARGS = dict(constructor_name="load", eager=True, is_target=False)
 
 COMMENTS_FOR_KEYS = {
-    "pipeline": (
+    CONFIG_PIPELINE_KEY: (
         f"# # No configuration for the NLU pipeline was provided. The following "
         f"default pipeline was used to train your model.\n"
         f"# # If you'd like to customize it, uncomment and adjust the pipeline.\n"
         f"# # See {rasa.shared.constants.DOCS_URL_PIPELINE} for more information.\n"
     ),
-    "policies": (
+    CONFIG_POLICIES_KEY: (
         f"# # No configuration for policies was provided. The following default "
         f"policies were used to train your model.\n"
         f"# # If you'd like to customize them, uncomment and adjust the policies.\n"
@@ -82,6 +88,10 @@ COMMENTS_FOR_KEYS = {
 }
 
 
+GRAPH_NODE_RUN_PREFIX = "run_"
+GRAPH_NODE_TRAIN_PREFIX = "train_"
+
+
 class DefaultV1RecipeRegisterException(RasaException):
     """If you register a class which is not of type `GraphComponent`."""
 
@@ -194,10 +204,12 @@ class DefaultV1Recipe(Recipe):
     ) -> GraphModelConfiguration:
         """Converts the default config to graphs (see interface for full docstring)."""
         self._use_core = (
-            bool(config.get("policies")) and not training_type == TrainingType.NLU
+            bool(config.get(CONFIG_POLICIES_KEY))
+            and not training_type == TrainingType.NLU
         )
         self._use_nlu = (
-            bool(config.get("pipeline")) and not training_type == TrainingType.CORE
+            bool(config.get(CONFIG_PIPELINE_KEY))
+            and not training_type == TrainingType.CORE
         )
 
         if not self._use_nlu and training_type == TrainingType.NLU:
@@ -232,9 +244,9 @@ class DefaultV1Recipe(Recipe):
             predict_schema=GraphSchema(predict_nodes),
             training_type=training_type,
             assistant_id=config.get(ASSISTANT_ID_KEY),
-            language=config.get("language"),
+            language=config.get(CONFIG_LANGUAGE_KEY),
             core_target=core_target,
-            nlu_target=f"run_{RegexMessageHandler.__name__}",
+            nlu_target=f"{GRAPH_NODE_RUN_PREFIX}{RegexMessageHandler.__name__}",
         )
 
     def _create_train_nodes(
@@ -317,7 +329,7 @@ class DefaultV1Recipe(Recipe):
             constructor_name="create",
             fn="provide",
             config={
-                "language": train_config.get("language"),
+                "language": train_config.get(CONFIG_LANGUAGE_KEY),
                 "persist": persist_nlu_data,
             },
             is_target=persist_nlu_data,
@@ -327,8 +339,8 @@ class DefaultV1Recipe(Recipe):
         last_run_node = "nlu_training_data_provider"
         preprocessors: List[Text] = []
 
-        for idx, config in enumerate(train_config["pipeline"]):
-            component_name = config.pop("name")
+        for idx, config in enumerate(train_config[CONFIG_PIPELINE_KEY]):
+            component_name = config.pop(CONFIG_NAME_KEY)
             component = self._from_registry(component_name)
             component_name = f"{component_name}{idx}"
 
@@ -451,7 +463,7 @@ class DefaultV1Recipe(Recipe):
         needs.update(self._get_model_provider_needs(train_nodes, component))
         needs["training_data"] = last_run_node
 
-        train_node_name = f"train_{component_name}"
+        train_node_name = f"{GRAPH_NODE_TRAIN_PREFIX}{component_name}"
         train_nodes[train_node_name] = SchemaNode(
             needs=needs,
             uses=component,
@@ -469,10 +481,10 @@ class DefaultV1Recipe(Recipe):
         component_config: Dict[Text, Any],
     ) -> Dict[Text, Any]:
         from rasa.nlu.classifiers.mitie_intent_classifier import MitieIntentClassifier
-        from rasa.nlu.extractors.mitie_entity_extractor import MitieEntityExtractor
         from rasa.nlu.classifiers.sklearn_intent_classifier import (
             SklearnIntentClassifier,
         )
+        from rasa.nlu.extractors.mitie_entity_extractor import MitieEntityExtractor
 
         cli_args_mapping: Dict[Type[GraphComponent], List[Text]] = {
             MitieIntentClassifier: ["num_threads"],
@@ -520,7 +532,7 @@ class DefaultV1Recipe(Recipe):
 
         needs["training_data"] = last_run_node
 
-        node_name = f"run_{component_name}"
+        node_name = f"{GRAPH_NODE_RUN_PREFIX}{component_name}"
         train_nodes[node_name] = SchemaNode(
             needs=needs,
             uses=component_class,
@@ -627,8 +639,8 @@ class DefaultV1Recipe(Recipe):
         )
 
         policy_with_end_to_end_support_used = False
-        for idx, config in enumerate(train_config["policies"]):
-            component_name = config.pop("name")
+        for idx, config in enumerate(train_config[CONFIG_POLICIES_KEY]):
+            component_name = config.pop(CONFIG_NAME_KEY)
             component = self._from_registry(component_name)
 
             extra_config_from_cli = self._extra_config_from_cli(
@@ -647,7 +659,7 @@ class DefaultV1Recipe(Recipe):
                 needs["precomputations"] = "end_to_end_features_provider"
             # during core training we use a stripped down version of the domain
             needs["domain"] = "domain_for_core_training_provider"
-            train_nodes[f"train_{component_name}{idx}"] = SchemaNode(
+            train_nodes[f"{GRAPH_NODE_TRAIN_PREFIX}{component_name}{idx}"] = SchemaNode(
                 needs=needs,
                 uses=component.clazz,
                 constructor_name="load" if self._is_finetuning else "create",
@@ -722,7 +734,9 @@ class DefaultV1Recipe(Recipe):
         if self._use_core:
             domain_needs["domain"] = "domain_provider"
 
-        regex_handler_node_name = f"run_{RegexMessageHandler.__name__}"
+        regex_handler_node_name = (
+            f"{GRAPH_NODE_RUN_PREFIX}{RegexMessageHandler.__name__}"
+        )
         predict_nodes[regex_handler_node_name] = SchemaNode(
             **DEFAULT_PREDICT_KWARGS,
             needs={"messages": last_run_nlu_node, **domain_needs},
@@ -762,8 +776,8 @@ class DefaultV1Recipe(Recipe):
             resource=Resource("domain_provider"),
         )
 
-        for idx, config in enumerate(predict_config["pipeline"]):
-            component_name = config.pop("name")
+        for idx, config in enumerate(predict_config[CONFIG_PIPELINE_KEY]):
+            component_name = config.pop(CONFIG_NAME_KEY)
             component = self._from_registry(component_name)
             component_name = f"{component_name}{idx}"
             if self.ComponentType.MODEL_LOADER in component.types:
@@ -830,10 +844,10 @@ class DefaultV1Recipe(Recipe):
         item_config: Dict[Text, Any],
         from_resource: bool = False,
     ) -> Text:
-        train_node_name = f"run_{node_name}"
+        train_node_name = f"{GRAPH_NODE_RUN_PREFIX}{node_name}"
         resource = None
         if from_resource:
-            train_node_name = f"train_{node_name}"
+            train_node_name = f"{GRAPH_NODE_TRAIN_PREFIX}{node_name}"
             resource = Resource(train_node_name)
 
         return self._add_nlu_predict_node(
@@ -852,7 +866,7 @@ class DefaultV1Recipe(Recipe):
         component_name: Text,
         last_run_node: Text,
     ) -> Text:
-        node_name = f"run_{component_name}"
+        node_name = f"{GRAPH_NODE_RUN_PREFIX}{component_name}"
 
         needs = self._get_needs_from_args(node.uses, "process")
         needs.update(self._get_model_provider_needs(predict_nodes, node.uses))
@@ -919,12 +933,12 @@ class DefaultV1Recipe(Recipe):
         rule_policy_resource = None
         policies: List[Text] = []
 
-        for idx, config in enumerate(predict_config["policies"]):
-            component_name = config.pop("name")
+        for idx, config in enumerate(predict_config[CONFIG_POLICIES_KEY]):
+            component_name = config.pop(CONFIG_NAME_KEY)
             component = self._from_registry(component_name)
 
-            train_node_name = f"train_{component_name}{idx}"
-            node_name = f"run_{component_name}{idx}"
+            train_node_name = f"{GRAPH_NODE_TRAIN_PREFIX}{component_name}{idx}"
+            node_name = f"{GRAPH_NODE_RUN_PREFIX}{component_name}{idx}"
 
             from rasa.core.policies.rule_policy import RulePolicy
 

rasa/engine/recipes/graph_recipe.py

@@ -1,16 +1,17 @@
 import logging
+from typing import Any, Dict, Text, Tuple
 
+from rasa.engine.graph import GraphModelConfiguration, GraphSchema
 from rasa.engine.recipes.recipe import Recipe
-from rasa.engine.graph import GraphModelConfiguration
-from rasa.shared.constants import DOCS_URL_GRAPH_RECIPE, ASSISTANT_ID_KEY
+from rasa.shared.constants import (
+    ASSISTANT_ID_KEY,
+    CONFIG_LANGUAGE_KEY,
+    DOCS_URL_GRAPH_RECIPE,
+)
 from rasa.shared.data import TrainingType
 from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.utils.common import mark_as_experimental_feature
 from rasa.shared.utils.io import raise_warning
-from rasa.engine.graph import GraphSchema
-
-from typing import Dict, Text, Any, Tuple
-
 
 logger = logging.getLogger(__name__)
 
@@ -72,7 +73,7 @@ class GraphV1Recipe(Recipe):
             predict_schema=GraphSchema.from_dict(config.get("predict_schema")),
             training_type=training_type,
             assistant_id=config.get(ASSISTANT_ID_KEY),
-            language=config.get("language"),
+            language=config.get(CONFIG_LANGUAGE_KEY),
             core_target=core_target,
             nlu_target=nlu_target,
         )

rasa/model_manager/runner_service.py

@@ -207,6 +207,7 @@ def start_bot_process(
         "--credentials",
         f"{bot_base_path}/credentials.yml",
         "--debug",
+        "--inspect",
         f"--port={port}",
         "--model",
         f"{bot_base_path}/models",

rasa/model_manager/socket_bridge.py

@@ -1,3 +1,4 @@
+import json
 from typing import Any, Dict, Optional
 
 from socketio import AsyncServer
@@ -9,12 +10,21 @@ from rasa.model_manager.studio_jwt_auth import (
     UserToServiceAuthenticationError,
     authenticate_user_to_service,
 )
+from dataclasses import dataclass
 
 structlogger = structlog.get_logger()
 
 
+@dataclass
+class SocketProxyClient:
+    """Store information about a running bot."""
+
+    user_id: str
+    socket: AsyncClient
+
+
 # A simple in-memory store for active chat connections to studio frontend
-socket_proxy_clients = {}
+socket_proxy_clients: Dict[str, SocketProxyClient] = {}
 
 
 async def socketio_websocket_traffic_wrapper(
@@ -31,7 +41,7 @@ async def socketio_websocket_traffic_wrapper(
         return False
 
     try:
-        authenticate_user_to_service(auth_token)
+        user_info = authenticate_user_to_service(auth_token)
         structlogger.debug("model_runner.user_authenticated_successfully", sid=sid)
     except UserToServiceAuthenticationError as error:
         structlogger.error(
@@ -60,7 +70,9 @@ async def socketio_websocket_traffic_wrapper(
         structlogger.debug(
             "model_runner.bot_connection_established", deployment_id=deployment_id
         )
-        socket_proxy_clients[sid] = client
+        socket_proxy_clients[sid] = SocketProxyClient(
+            user_id=user_info.get("sub", ""), socket=client
+        )
         return True
     else:
         structlogger.error(
@@ -87,12 +99,12 @@ def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession])
         """Disconnect the bot connection."""
         structlogger.debug("model_runner.bot_disconnect", sid=sid)
         if sid in socket_proxy_clients:
-            await socket_proxy_clients[sid].disconnect()
+            await socket_proxy_clients[sid].socket.disconnect()
             del socket_proxy_clients[sid]
 
     @sio.on("*")
     async def handle_message(event: str, sid: str, data: Dict[str, Any]) -> None:
-        """ "Bridge messages between user and bot.
+        """Bridge messages between user and bot.
 
         Both incoming user messages to the bot_url and
         bot responses sent back to the client need to
@@ -103,7 +115,12 @@ def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession])
             structlogger.error("model_runner.bot_not_connected", sid=sid)
             return
 
-        await client.emit(event, data)
+        if "metadata" in data:
+            data.metadata["x-forwarded-for"] = client.user_id
+        else:
+            data["metadata"] = {"x-forwarded-for": client.user_id}
+
+        await client.socket.emit(event, data)
 
 
 async def create_bridge_client(
@@ -111,7 +128,7 @@ async def create_bridge_client(
 ) -> AsyncClient:
     """Create a new socket bridge client.
 
-    Forwards messages comming from the bot to the user.
+    Forwards messages coming from the bot to the user.
     """
     client = AsyncClient()
 
@@ -129,6 +146,11 @@ async def create_bridge_client(
         structlogger.debug("model_runner.bot_message", deployment_id=deployment_id)
         await sio.emit("bot_message", data, room=sid)
 
+    @client.event  # type: ignore[misc]
+    async def tracker(data: Dict[str, Any]) -> None:
+        structlogger.debug("model_runner.tracker_message", deployment_id=deployment_id)
+        await sio.emit("tracker", json.loads(data), room=sid)
+
     @client.event  # type: ignore[misc]
     async def disconnect() -> None:
         structlogger.debug(

rasa/model_training.py

@@ -23,6 +23,7 @@ from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.engine.storage.storage import ModelStorage
 from rasa.engine.training.components import FingerprintStatus
 from rasa.engine.training.graph_trainer import GraphTrainer
+from rasa.shared.constants import CONFIG_RECIPE_KEY
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import SlotSet
 from rasa.shared.core.training_data.structures import StoryGraph
@@ -304,7 +305,7 @@ async def _train_graph(
     is_finetuning = model_to_finetune is not None
 
     config = file_importer.get_config()
-    recipe = Recipe.recipe_for_name(config.get("recipe"))
+    recipe = Recipe.recipe_for_name(config.get(CONFIG_RECIPE_KEY))
     config, _missing_keys, _configured_keys = recipe.auto_configure(
         file_importer.get_config_file_for_auto_config(),
         config,

rasa/server.py

@@ -62,11 +62,9 @@ from rasa.shared.constants import (
     DOCS_BASE_URL,
     DOCS_URL_TRAINING_DATA,
     TEST_STORIES_FILE_PREFIX,
-    DOCS_URL_FLOWS,
 )
 from rasa.shared.core.domain import Domain, InvalidDomain
 from rasa.shared.core.events import Event
-from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader
 from rasa.shared.core.trackers import (
     DialogueStateTracker,
     EventVerbosity,
@@ -74,7 +72,6 @@ from rasa.shared.core.trackers import (
 from rasa.shared.core.training_data.story_writer.yaml_story_writer import (
     YAMLStoryWriter,
 )
-from rasa.shared.exceptions import YamlException, RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.nlu.training_data.formats import RasaYAMLReader
 from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
@@ -1569,8 +1566,7 @@ def _nlu_training_payload_from_json(
     )
 
 
-def _validate_nlu_training_data_payload(yaml_text: str) -> None:
-    """Validate the NLU training data payload of the request body."""
+def _validate_yaml_training_payload(yaml_text: Text) -> None:
     try:
         RasaYAMLReader().validate(yaml_text)
     except Exception as e:
@@ -1582,38 +1578,6 @@ def _validate_nlu_training_data_payload(yaml_text: str) -> None:
         )
 
 
-def _validate_flows_payload(yaml_text: str) -> None:
-    """Validate the flows payload of the request body."""
-    try:
-        YAMLFlowsReader().read_from_string(yaml_text)
-    except (YamlException, RasaException) as exc:
-        # if the payload does not contain any flows, we can ignore the error
-        if (
-            hasattr(exc, "validation_errors")
-            and exc.validation_errors is not None
-            and any(
-                [
-                    "'flows' is a required property" in error.message
-                    for error in exc.validation_errors
-                ]
-            )
-        ):
-            return None
-
-        raise ErrorResponse(
-            HTTPStatus.BAD_REQUEST,
-            "BadRequest",
-            f"The request body does not contain valid YAML. Error: {exc}",
-            help_url=DOCS_URL_FLOWS,
-        )
-
-
-def _validate_yaml_training_payload(yaml_text: str) -> None:
-    """Validate the YAML training payload of the request body."""
-    _validate_nlu_training_data_payload(yaml_text)
-    _validate_flows_payload(yaml_text)
-
-
 def _extract_core_additional_arguments(request: Request) -> Dict[Text, Any]:
     return {
         "augmentation_factor": rasa.utils.endpoints.int_arg(request, "augmentation", 50)

rasa/shared/constants.py

@@ -19,7 +19,6 @@ DOCS_URL_GRAPH_COMPONENTS = DOCS_URL_CONCEPTS + "/components/custom-graph-compon
 DOCS_URL_GRAPH_RECIPE = DOCS_URL_CONCEPTS + "/components/graph-recipe"
 DOCS_URL_CATEGORICAL_SLOTS = DOCS_URL_CONCEPTS + "/domain#categorical-slot"
 DOCS_URL_DOMAIN = DOCS_URL_CONCEPTS + "/domain"
-DOCS_URL_FLOWS = DOCS_URL_CONCEPTS + "/flows"
 
 # Docs URLs for NLU-based assistants
 DOCS_URL_TRAINING_DATA = DOCS_URL_NLU_BASED + "/training-data-format"
@@ -102,16 +101,28 @@ ASSISTANT_ID_KEY = "assistant_id"
 ASSISTANT_ID_DEFAULT_VALUE = "placeholder_default"
 
 CONFIG_MANDATORY_COMMON_KEYS = [ASSISTANT_ID_KEY]
-CONFIG_AUTOCONFIGURABLE_KEYS_CORE = ["policies"]
-CONFIG_AUTOCONFIGURABLE_KEYS_NLU = ["pipeline"]
+CONFIG_NAME_KEY = "name"
+CONFIG_POLICIES_KEY = "policies"
+CONFIG_PIPELINE_KEY = "pipeline"
+CONFIG_LANGUAGE_KEY = "language"
+CONFIG_RECIPE_KEY = "recipe"
+CONFIG_LLM_KEY = "llm"
+CONFIG_MODEL_NAME_KEY = "model_name"
+CONFIG_TRAIN_SCHEMA = "train_schema"
+CONFIG_PREDICT_SCHEMA = "predict_schema"
+CONFIG_AUTOCONFIGURABLE_KEYS_CORE = [CONFIG_POLICIES_KEY]
+CONFIG_AUTOCONFIGURABLE_KEYS_NLU = [CONFIG_PIPELINE_KEY]
 CONFIG_AUTOCONFIGURABLE_KEYS = (
     CONFIG_AUTOCONFIGURABLE_KEYS_CORE + CONFIG_AUTOCONFIGURABLE_KEYS_NLU
 )
-CONFIG_KEYS_CORE = ["policies"] + CONFIG_MANDATORY_COMMON_KEYS
-CONFIG_KEYS_NLU = ["language", "pipeline"] + CONFIG_MANDATORY_COMMON_KEYS
+CONFIG_KEYS_CORE = [CONFIG_POLICIES_KEY] + CONFIG_MANDATORY_COMMON_KEYS
+CONFIG_KEYS_NLU = [
+    CONFIG_LANGUAGE_KEY,
+    CONFIG_PIPELINE_KEY,
+] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_KEYS = CONFIG_KEYS_CORE + CONFIG_KEYS_NLU
 CONFIG_MANDATORY_KEYS_CORE: List[Text] = [] + CONFIG_MANDATORY_COMMON_KEYS
-CONFIG_MANDATORY_KEYS_NLU = ["language"] + CONFIG_MANDATORY_COMMON_KEYS
+CONFIG_MANDATORY_KEYS_NLU = [CONFIG_LANGUAGE_KEY] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_MANDATORY_KEYS = CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU
 
 # Keys related to Forms (in the Domain)

rasa/shared/nlu/constants.py

@@ -2,6 +2,10 @@ TEXT = "text"
 TEXT_TOKENS = "text_tokens"
 INTENT = "intent"
 COMMANDS = "commands"
+PREDICTED_COMMANDS = "predicted_commands"
+PROMPTS = "prompts"
+KEY_USER_PROMPT = "user_prompt"
+KEY_SYSTEM_PROMPT = "system_prompt"
 LLM_COMMANDS = "llm_commands"  # needed for fine-tuning
 LLM_PROMPT = "llm_prompt"  # needed for fine-tuning
 FLOWS_FROM_SEMANTIC_SEARCH = "flows_from_semantic_search"