rasa-pro 3.11.0rc3__py3-none-any.whl → 3.11.2__py3-none-any.whl

rasa/engine/validation.py

@@ -16,6 +16,7 @@ from typing import (
     Union,
     TypeVar,
     List,
+    Literal,
 )
 
 import rasa.utils.common
@@ -52,7 +53,7 @@ from rasa.engine.graph import (
     GraphModelConfiguration,
 )
 from rasa.engine.storage.resource import Resource
-from rasa.engine.storage.storage import ModelStorage
+from rasa.engine.storage.storage import ModelStorage, ModelMetadata
 from rasa.engine.training.fingerprinting import Fingerprintable
 from rasa.shared.constants import (
     DOCS_URL_GRAPH_COMPONENTS,
@@ -72,7 +73,14 @@ from rasa.shared.constants import (
     ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE,
     ROUTING_STRATEGIES_NOT_REQUIRING_CACHE,
     REDIS_HOST_CONFIG_KEY,
+    AWS_ACCESS_KEY_ID_CONFIG_KEY,
+    AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
+    AWS_SESSION_TOKEN_CONFIG_KEY,
+    SENSITIVE_DATA,
     USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+    VALID_PROVIDERS_FOR_API_TYPE_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_RESET_ROUTING, ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import Domain
@@ -80,7 +88,6 @@ from rasa.shared.core.flows import FlowsList, Flow
 from rasa.shared.core.slots import Slot
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.utils.cli import print_error_and_exit
 
 TypeAnnotation = Union[TypeVar, Text, Type, Optional[AvailableEndpoints]]
 
@@ -896,26 +903,45 @@ def _validate_component_model_client_config(
         model_group_ids.append(component_config[key][MODEL_GROUP_CONFIG_KEY])
 
         if len(component_config[key]) > 1:
-            print_error_and_exit(
-                f"You specified a '{MODEL_GROUP_CONFIG_KEY}' for the '{key}' "
-                f"config key for the component "
-                f"'{component_name or component_config['name']}'. "
-                "No other parameters are allowed under the "
-                f"'{key}' key in that case. Please update your config."
+            structlogger.error(
+                "validation.validate_model_client_configuration_setup"
+                ".only_model_group_reference_key_is_allowed",
+                event_info=(
+                    f"You specified a '{MODEL_GROUP_CONFIG_KEY}' for the '{key}' "
+                    f"config key for the component "
+                    f"'{component_name or component_config['name']}'. "
+                    "No other parameters are allowed under the "
+                    f"'{key}' key in that case. Please update your config."
+                ),
+                component_name=component_name or component_config["name"],
+                component_client_config_key=key,
             )
+            sys.exit(1)
     else:
         model_group_syntax_used.append(False)
 
-        # check that api_key is not set in config
-        if API_KEY in component_config[key]:
-            print_error_and_exit(
-                f"You specified '{API_KEY}' in the config for "
-                f"'{component_name or component_config['name']}', which is not allowed."
-                " Set API keys through environment variables."
-            )
+        # check that any of the sensitive data keys is not set in config
+        for secret_key in SENSITIVE_DATA:
+            if secret_key in component_config[key]:
+                structlogger.error(
+                    "validation.validate_model_client_configuration_setup"
+                    ".secret_key_not_allowed_in_the_config",
+                    event_info=(
+                        f"You specified '{secret_key}' in the config for "
+                        f"'{component_name or component_config['name']}', "
+                        f"which is not allowed. "
+                        "Set secret keys through environment variables."
+                    ),
+                    component_name=component_name or component_config["name"],
+                    component_client_config_key=key,
+                    secret_key=secret_key,
+                )
+                sys.exit(1)
 
 
-def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
+def validate_model_client_configuration_setup_during_training_time(
+    config: Dict[str, Any],
+) -> None:
     """Validates the model client configuration setup.
 
     Checks the model configuration of the components in the pipeline.
@@ -924,6 +950,8 @@ def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
       the same time (either at component level itself or across different components)
     - the LLM/embeddings is/are defined using the new syntax, but no model
       group is defined or the referenced model group does not exist
+    - the LLM/embeddings provider is defined using 'api_type' key for providers other
+    than 'openai' or 'azure'
 
     Args:
         config: The config dictionary
@@ -940,22 +968,28 @@ def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
         if outer_key not in config or config[outer_key] is None:
             continue
 
-        for component in config[outer_key]:
+        for component_config in config[outer_key]:
             for key in [LLM_CONFIG_KEY, EMBEDDINGS_CONFIG_KEY]:
                 _validate_component_model_client_config(
-                    component, key, model_group_syntax_used, model_group_ids
+                    component_config, key, model_group_syntax_used, model_group_ids
                 )
+                validate_api_type_config_key_usage(component_config, key)
 
             # as flow retrieval is not a component itself, we need to
             # check it separately
-            if FLOW_RETRIEVAL_KEY in component:
-                if EMBEDDINGS_CONFIG_KEY in component[FLOW_RETRIEVAL_KEY]:
+            if FLOW_RETRIEVAL_KEY in component_config:
+                if EMBEDDINGS_CONFIG_KEY in component_config[FLOW_RETRIEVAL_KEY]:
                     _validate_component_model_client_config(
-                        component[FLOW_RETRIEVAL_KEY],
+                        component_config[FLOW_RETRIEVAL_KEY],
                         EMBEDDINGS_CONFIG_KEY,
                         model_group_syntax_used,
                         model_group_ids,
-                        component["name"] + "." + FLOW_RETRIEVAL_KEY,
+                        component_config["name"] + "." + FLOW_RETRIEVAL_KEY,
+                    )
+                    validate_api_type_config_key_usage(
+                        component_config[FLOW_RETRIEVAL_KEY],
+                        EMBEDDINGS_CONFIG_KEY,
+                        component_config["name"] + "." + FLOW_RETRIEVAL_KEY,
                     )
 
     # also include the ContextualResponseRephraser component
@@ -970,14 +1004,19 @@ def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
         )
 
     if not is_uniform_bool_list(model_group_syntax_used):
-        print_error_and_exit(
-            "Some of your components refer to an LLM using the "
-            f"'{MODEL_GROUP_CONFIG_KEY}' parameter, other components directly"
-            f" define the LLM under the '{LLM_CONFIG_KEY}' or the "
-            f"'{EMBEDDINGS_CONFIG_KEY}' key. You cannot use"
-            " both types of definitions. Please chose one syntax "
-            "and update your config."
+        structlogger.error(
+            "validation.validate_model_client_configuration_setup"
+            ".inconsistent_use_of_model_group_syntax",
+            event_info=(
+                "Some of your components refer to an LLM using the "
+                f"'{MODEL_GROUP_CONFIG_KEY}' parameter, other components directly"
+                f" define the LLM under the '{LLM_CONFIG_KEY}' or the "
+                f"'{EMBEDDINGS_CONFIG_KEY}' key. You cannot use"
+                " both types of definitions. Please chose one syntax "
+                "and update your config."
+            ),
         )
+        sys.exit(1)
 
     # Print a deprecation warning in case the old syntax is used.
     if len(model_group_syntax_used) > 0 and model_group_syntax_used[0] is False:
@@ -993,12 +1032,17 @@ def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
 
     endpoints = AvailableEndpoints.get_instance()
     if len(model_group_ids) > 0 and endpoints.model_groups is None:
-        print_error_and_exit(
-            "You are referring to (a) model group(s) in your "
-            "config.yml file, but no model group was defined in "
-            "the endpoints.yml file. Please define the model "
-            "group(s)."
+        structlogger.error(
+            "validation.validate_model_client_configuration_setup"
+            ".referencing_model_group_but_none_are_defined",
+            event_info=(
+                "You are referring to (a) model group(s) in your "
+                "config.yml file, but no model group was defined in "
+                "the endpoints.yml file. Please define the model "
+                "group(s)."
+            ),
         )
+        sys.exit(1)
 
     if endpoints.model_groups is None:
         return
@@ -1009,23 +1053,146 @@ def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
 
     for model_group_id in model_group_ids:
         if model_group_id not in existing_model_group_ids:
-            print_error_and_exit(
-                "One of your components is referring to the model group "
-                f"'{model_group_id}', but this model group does not exist in the "
-                f"endpoints.yml file. Please chose one of the existing "
-                f"model groups ({existing_model_group_ids}) or define "
-                f"the a model group for '{model_group_id}'."
+            structlogger.error(
+                "validation.validate_model_client_configuration_setup"
+                ".referencing_undefined_model_group",
+                event_info=(
+                    "One of your components is referring to the model group "
+                    f"'{model_group_id}', but this model group does not exist in the "
+                    f"endpoints.yml file. Please chose one of the existing "
+                    f"model groups ({existing_model_group_ids}) or define "
+                    f"the model group for '{model_group_id}'."
+                ),
+                referencing_model_group_id=model_group_id,
+                existing_model_group_ids=existing_model_group_ids,
             )
+            sys.exit(1)
+
+
+def _validate_component_model_client_config_has_references_to_endpoints(
+    component_config: Dict[Text, Any],
+    key: str,
+    component_name: Optional[Text] = None,
+) -> None:
+    """Validates that the specified client configuration references a valid model group
+    defined in the `endpoints.yml` file.
+
+    This function ensures that when the client configuration for a component uses the
+    `model_group` key, the referenced model group exists in the `endpoints.yml` file.
+    If the referenced model group is missing or invalid, an error is raised.
+
+    Args:
+        component_config: The configuration dictionary for the component being
+            validated.
+        key: 'llm' or 'embeddings'
+        component_name: Optional; the name of the component being validated, used for
+            error messages.
+
+    Raises:
+        SystemExit: If the referenced model group is missing or invalid.
+    """
+    if key not in component_config:
+        # no llm/embeddings configuration present
+        return
+
+    endpoints = AvailableEndpoints.get_instance()
+
+    if MODEL_GROUP_CONFIG_KEY in component_config[key]:
+        referencing_model_group_id = component_config[key][MODEL_GROUP_CONFIG_KEY]
+
+        if endpoints.model_groups is None:
+            structlogger.error(
+                "validation.validate_model_client_config_correctly_references_endpoints"
+                ".no_model_groups_defined",
+                event_info=(
+                    f"Your {component_name or component_config.get('name') or ''} "
+                    f"component's '{key}' configuration of the trained model "
+                    f"references the model group '{referencing_model_group_id}', "
+                    f"but NO MODEL GROUPS ARE DEFINED in the endpoints.yml file. "
+                    f"Please add a definition for the required model group in the "
+                    f"endpoints.yml file."
+                ),
+                component_name=component_name or component_config.get("name"),
+                model_group_id=referencing_model_group_id,
+                component_client_config_key=key,
+            )
+            sys.exit(1)
+
+        existing_model_group_ids = [
+            model_group[MODEL_GROUP_ID_CONFIG_KEY]
+            for model_group in endpoints.model_groups
+        ]
+
+        if referencing_model_group_id not in existing_model_group_ids:
+            structlogger.error(
+                "validation.validate_model_client_config_correctly_references_endpoints"
+                ".referenced_model_group_does_not_exist",
+                event_info=(
+                    f"Your {component_name or component_config.get('name') or ''} "
+                    f"component's '{key}' configuration of the trained model "
+                    f"references the model group '{referencing_model_group_id}', "
+                    f"but this model group DOES NOT EXIST in the endpoints.yml file. "
+                    f"The endpoints.yml defines the following model groups: "
+                    f"{existing_model_group_ids}. "
+                    f"Please add a definition for the required model group in the "
+                    f"endpoints.yml file."
+                ),
+                model_group_id=referencing_model_group_id,
+                existing_model_group_ids=existing_model_group_ids,
+                component_client_config_key=key,
+            )
+            sys.exit(1)
+
+
+def validate_model_client_configuration_setup_during_inference_time(
+    model_metadata: ModelMetadata,
+) -> None:
+    for (
+        component_node_name,
+        component_node,
+    ) in model_metadata.predict_schema.nodes.items():
+        for client_config_key in [EMBEDDINGS_CONFIG_KEY, LLM_CONFIG_KEY]:
+            if client_config_key not in component_node.config:
+                continue
+
+            _validate_component_model_client_config_has_references_to_endpoints(
+                component_config=component_node.config,
+                key=client_config_key,
+                component_name=component_node_name,
+            )
+
+            # as flow retrieval is not a component itself, we need to
+            # check it separately
+            if FLOW_RETRIEVAL_KEY in component_node.config:
+                if EMBEDDINGS_CONFIG_KEY in component_node.config[FLOW_RETRIEVAL_KEY]:
+                    _validate_component_model_client_config_has_references_to_endpoints(
+                        component_config=component_node.config[FLOW_RETRIEVAL_KEY],
+                        key=EMBEDDINGS_CONFIG_KEY,
+                        component_name=component_node_name + "." + FLOW_RETRIEVAL_KEY,
+                    )
+
+    # also include the ContextualResponseRephraser component
+    endpoints = AvailableEndpoints.get_instance()
+    if endpoints.nlg is not None:
+        _validate_component_model_client_config_has_references_to_endpoints(
+            component_config=endpoints.nlg.kwargs,
+            key=LLM_CONFIG_KEY,
+            component_name=ContextualResponseRephraser.__name__,
+        )
 
 
 def _validate_unique_model_group_ids(model_groups: List[Dict[str, Any]]) -> None:
     # Each model id must be unique within the model_groups
     model_ids = [model_group[MODEL_GROUP_ID_CONFIG_KEY] for model_group in model_groups]
     if len(model_ids) != len(set(model_ids)):
-        print_error_and_exit(
-            "Each model group id must be unique. Please make sure that "
-            "the model group ids are unique in your endpoints.yml file."
+        structlogger.error(
+            "validate_model_group_configuration_setup.non_unique_model_group_ids",
+            event_info=(
+                "Each model group id must be unique. Please make sure that "
+                "the model group ids are unique in your endpoints.yml file."
+            ),
         )
+        sys.exit(1)
 
 
 def _validate_model_group_with_multiple_models(
@@ -1037,13 +1204,18 @@ def _validate_model_group_with_multiple_models(
             len(model_group[MODELS_CONFIG_KEY]) > 1
             and ROUTER_CONFIG_KEY not in model_group
         ):
-            print_error_and_exit(
-                f"You defined multiple models for the model group "
-                f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}', but no router. "
-                f"If a model group contains "
-                f"multiple models, a router must be defined. Please define a router "
-                f"for the model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'."
+            structlogger.error(
+                "validate_model_group_configuration_setup.router_not_present",
+                event_info=(
+                    f"You defined multiple models for the model group "
+                    f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}', but no router. "
+                    "If a model group contains multiple models, a router must be "
+                    "defined. Please define a router for the model group "
+                    f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'."
+                ),
+                model_group_id=model_group[MODEL_GROUP_ID_CONFIG_KEY],
             )
+            sys.exit(1)
 
 
 def _validate_model_group_router_setting(
@@ -1056,28 +1228,49 @@ def _validate_model_group_router_setting(
 
         for model_config in model_group.get(MODELS_CONFIG_KEY, []):
             if USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY in model_config:
-                print_error_and_exit(
-                    f"You defined the '{USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY}' in "
-                    f"the model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'. This "
-                    f"key is not allowed in the model configuration as the router is "
-                    f"defined. Please remove this key from your model configuration "
-                    f"and update it in the '{ROUTER_CONFIG_KEY} configuration, as it "
-                    f"is a router level setting."
+                structlogger.error(
+                    "validation.validate_model_group_configuration_setup"
+                    f".{USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY}_set_incorrectly",
+                    event_info=(
+                        f"You defined the '{USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY}' "
+                        f"in the model group "
+                        f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'. This key is not "
+                        f"allowed in the model configuration as the router is defined. "
+                        f"Please remove this key from your model configuration and "
+                        f"update it in the '{ROUTER_CONFIG_KEY} configuration, as it "
+                        f"is a router level setting."
+                    ),
+                    model_group_id=model_group[MODEL_GROUP_ID_CONFIG_KEY],
                 )
+                sys.exit(1)
 
         router_config = model_group[ROUTER_CONFIG_KEY]
         if ROUTING_STRATEGY_CONFIG_KEY in router_config:
             routing_strategy = router_config.get(ROUTING_STRATEGY_CONFIG_KEY)
             if routing_strategy and routing_strategy not in VALID_ROUTING_STRATEGIES:
-                print_error_and_exit(
-                    f"The routing strategy '{routing_strategy}' you defined for the "
-                    f"model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' is not "
-                    f"valid. Valid routing strategies are categorized as follows:\n"
-                    f"- Strategies requiring Redis caching: "
-                    f"{', '.join(ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE)}\n"
-                    f"- Strategies not requiring caching: "
-                    f"{', '.join(ROUTING_STRATEGIES_NOT_REQUIRING_CACHE)}"
+                structlogger.error(
+                    "validation.validate_model_group_configuration_setup"
+                    ".invalid_routing_strategy",
+                    event_info=(
+                        f"The routing strategy '{routing_strategy}' you defined for "
+                        f"the model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' "
+                        f"is not valid. Valid routing strategies are categorized as "
+                        f"follows:\n"
+                        f"- Strategies requiring Redis caching: "
+                        f"{', '.join(ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE)}\n"
+                        f"- Strategies not requiring caching: "
+                        f"{', '.join(ROUTING_STRATEGIES_NOT_REQUIRING_CACHE)}"
+                    ),
+                    model_group_id=model_group[MODEL_GROUP_ID_CONFIG_KEY],
+                    invalid_routing_strategy=routing_strategy,
+                    supported_routing_strategies_requiring_redis_cache=(
+                        ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE
+                    ),
+                    supported_routing_strategies_not_requiring_redis_cache=(
+                        ROUTING_STRATEGIES_NOT_REQUIRING_CACHE
+                    ),
                 )
+                sys.exit(1)
             if (
                 routing_strategy in ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE
                 and REDIS_HOST_CONFIG_KEY not in router_config
@@ -1091,6 +1284,7 @@ def _validate_model_group_router_setting(
                         f"'{REDIS_HOST_CONFIG_KEY}' to the router configuration for "
                         f"the model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'."
                     ),
+                    model_group_id=model_group[MODEL_GROUP_ID_CONFIG_KEY],
                 )
 
 
@@ -1098,13 +1292,18 @@ def _validate_usage_of_environment_variables_in_model_group_config(
     model_groups: List[Dict[str, Any]],
 ) -> None:
     # Limit the use of ${env_var} in the model_groups config to the following variables:
-    # deployment, api_base, api_key, api_version, aws_region_name
+    # - deployment,
+    # - api_base, api_version and api_key,
+    # - aws_region_name, aws_access_key_id, aws_secret_access_key, and aws_session_token
     allowed_env_vars = {
         DEPLOYMENT_CONFIG_KEY,
         API_BASE_CONFIG_KEY,
         API_KEY,
         API_VERSION_CONFIG_KEY,
         AWS_REGION_NAME_CONFIG_KEY,
+        AWS_ACCESS_KEY_ID_CONFIG_KEY,
+        AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
+        AWS_SESSION_TOKEN_CONFIG_KEY,
     }
 
     for model_group in model_groups:
@@ -1112,39 +1311,62 @@ def _validate_usage_of_environment_variables_in_model_group_config(
             for key, value in model_config.items():
                 if isinstance(value, str):
                     if re.match(r"\${(\w+)}", value) and key not in allowed_env_vars:
-                        print_error_and_exit(
-                            f"You defined '{key}' as environment variable in model "
-                            f"group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}', "
-                            f"which is not allowed. "
-                            f"You can only use environment variables for the following "
-                            f"keys: {', '.join(allowed_env_vars)}. "
-                            f"Please update your config."
+                        structlogger.error(
+                            "validation.validate_model_group_configuration_setup"
+                            ".invalid_use_of_environment_variables",
+                            event_info=(
+                                f"You defined '{key}' as environment variable in model "
+                                f"group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}', "
+                                f"which is not allowed. "
+                                f"You can only use environment variables for the "
+                                f"following keys: {', '.join(allowed_env_vars)}. "
+                                f"Please update your config."
+                            ),
+                            model_group_id=model_group[MODEL_GROUP_ID_CONFIG_KEY],
+                            key=key,
+                            allowed_keys_for_env_vars=allowed_env_vars,
                         )
+                        sys.exit(1)
 
 
-def _validate_api_key_is_an_environment_variable(
+def _validate_sensitive_keys_are_an_environment_variables_for_model_groups(
     model_groups: List[Dict[str, Any]],
 ) -> None:
     # the api key can only be set as an environment variable
     for model_group in model_groups:
         for model_config in model_group[MODELS_CONFIG_KEY]:
             for key, value in model_config.items():
-                if key == API_KEY:
+                if key in SENSITIVE_DATA:
                     if isinstance(value, str):
                         if not re.match(r"\${(\w+)}", value):
-                            print_error_and_exit(
-                                f"You defined the '{API_KEY}' in model group "
-                                f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' as a "
-                                f"string. The '{API_KEY}' must be set as an environment"
-                                f" variable. Please update your config."
+                            structlogger.error(
+                                "validation.validate_model_group_configuration_setup"
+                                ".sensitive_key_string_value_must_be_set_as_env_var",
+                                event_info=(
+                                    f"You defined the '{key}' in model group "
+                                    f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' as a "
+                                    f"string. The '{key}' must be set as an "
+                                    f"environment variable. Please update your config."
+                                ),
+                                key=key,
+                                model_group_id=model_group[MODEL_GROUP_ID_CONFIG_KEY],
                             )
+                            sys.exit(1)
                     else:
-                        print_error_and_exit(
-                            f"You should define the '{API_KEY}' in model group "
-                            f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' using the "
-                            f"environment variable syntax - ${{ENV_VARIABLE_NAME}}. "
-                            f"Please update your config."
+                        structlogger.error(
+                            "validation.validate_model_group_configuration_setup"
+                            ".sensitive_key_must_be_set_as_env_var",
+                            event_info=(
+                                f"You should define the '{key}' in model group "
+                                f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' using the "
+                                f"environment variable syntax - "
+                                f"${{ENV_VARIABLE_NAME}}. "
+                                f"Please update your config."
+                            ),
+                            key=key,
+                            model_group_id=model_group[MODEL_GROUP_ID_CONFIG_KEY],
                         )
+                        sys.exit(1)
 
 
 def validate_model_group_configuration_setup() -> None:
@@ -1159,7 +1381,9 @@ def validate_model_group_configuration_setup() -> None:
     _validate_usage_of_environment_variables_in_model_group_config(
         endpoints.model_groups
     )
-    _validate_api_key_is_an_environment_variable(endpoints.model_groups)
+    _validate_sensitive_keys_are_an_environment_variables_for_model_groups(
+        endpoints.model_groups
+    )
     _validate_model_group_router_setting(endpoints.model_groups)
 
 
@@ -1189,3 +1413,39 @@ def validate_command_generator_setup(
 ) -> None:
     schema = model_configuration.predict_schema
     validate_command_generator_exclusivity(schema)
+
+
+def validate_api_type_config_key_usage(
+    component_config: Dict[str, Any],
+    key: Literal["llm", "embeddings"],
+    component_name: Optional[str] = None,
+) -> None:
+    """Validate the LLM/embeddings configuration of a component.
+
+    Validation fails, if
+    - the LLM/embeddings provider is defined using 'api_type' key for providers other
+    than 'openai' or 'azure'
+
+    Args:
+        component_config: The config of the component
+        key: either 'llm' or 'embeddings'
+        component_name: the name of the component
+    """
+    if component_config is None or key not in component_config:
+        return
+
+    if API_TYPE_CONFIG_KEY in component_config[key]:
+        api_type = component_config[key][API_TYPE_CONFIG_KEY]
+        if api_type not in VALID_PROVIDERS_FOR_API_TYPE_CONFIG_KEY:
+            structlogger.error(
+                "validation.component.api_type_config_key_invalid",
+                event_info=(
+                    f"You specified '{API_TYPE_CONFIG_KEY}: {api_type}' for "
+                    f"'{component_name or component_config['name']}', which is not "
+                    f"allowed. "
+                    f"The '{API_TYPE_CONFIG_KEY}' key can only be used for the "
+                    f"following providers: {VALID_PROVIDERS_FOR_API_TYPE_CONFIG_KEY}. "
+                    f"For other providers, please use the '{PROVIDER_CONFIG_KEY}' key."
+                ),
+            )
+            sys.exit(1)

rasa/model_manager/config.py

@@ -7,6 +7,8 @@ SERVER_BASE_WORKING_DIRECTORY = os.environ.get(
     "RASA_MODEL_SERVER_BASE_DIRECTORY", DEFAULT_SERVER_BASE_WORKING_DIRECTORY
 )
 
+SERVER_PORT = os.environ.get("RASA_MODEL_SERVER_PORT", 8000)
+
 SERVER_BASE_URL = os.environ.get("RASA_MODEL_SERVER_BASE_URL", None)
 
 # defaults to storing on the local hard drive
@@ -30,3 +32,9 @@ MAX_PARALLEL_BOT_RUNS = os.getenv(
 )
 
 DEFAULT_SERVER_PATH_PREFIX = "talk"
+
+DEFAULT_MIN_REQUIRED_DISCSPACE_MB = 1
+
+MIN_REQUIRED_DISCSPACE_MB = int(
+    os.getenv("MIN_REQUIRED_DISCSPACE_MB", DEFAULT_MIN_REQUIRED_DISCSPACE_MB)
+)