rasa-pro 3.14.0.dev5__py3-none-any.whl → 3.14.0.dev6__py3-none-any.whl

rasa/shared/core/flows/validation.py

@@ -6,6 +6,8 @@ from collections import defaultdict
 from dataclasses import dataclass
 from typing import List, Optional, Set, Text
 
+from jinja2 import Template
+
 from rasa.shared.constants import (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX,
     RASA_PATTERN_CHITCHAT,
@@ -35,6 +37,7 @@ from rasa.shared.core.flows.utils import (
 from rasa.shared.exceptions import RasaException
 
 if typing.TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
     from rasa.shared.core.flows.flows_list import FlowsList
 
 FLOW_ID_REGEX = r"""^[a-zA-Z0-9_][a-zA-Z0-9_-]*?$"""
@@ -107,6 +110,26 @@ class DuplicatedStepIdException(RasaException):
         )
 
 
+class InvalidExitIfConditionException(RasaException):
+    """Raised when an exit_if condition is invalid."""
+
+    def __init__(self, step_id: str, flow_id: str, condition: str, reason: str) -> None:
+        """Initializes the exception."""
+        self.step_id = step_id
+        self.flow_id = flow_id
+        self.condition = condition
+        self.reason = reason
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return (
+            f"Invalid exit_if condition '{self.condition}' in step '{self.step_id}' "
+            f"of flow '{self.flow_id}': {self.reason}. "
+            f"Please ensure that exit_if conditions contain at least one slot "
+            f"reference and use only defined slots with valid predicates."
+        )
+
+
 class DuplicatedFlowIdException(RasaException):
     """Raised when a flow is using the same id as another flow."""
 
@@ -261,7 +284,7 @@ class NoLinkAllowedInCalledFlowException(RasaException):
         )
 
 
-class UnresolvedFlowException(RasaException):
+class UnresolvedLinkFlowException(RasaException):
     """Raised when a flow is called or linked from another flow but doesn't exist."""
 
     def __init__(self, flow_id: str, calling_flow_id: str, step_id: str) -> None:
@@ -273,13 +296,37 @@ class UnresolvedFlowException(RasaException):
     def __str__(self) -> str:
         """Return a string representation of the exception."""
         return (
-            f"Flow '{self.flow_id}' is called or linked from flow "
+            f"Flow '{self.flow_id}' is linked from flow "
             f"'{self.calling_flow_id}' in step '{self.step_id}', "
             f"but it doesn't exist. "
             f"Please make sure that a flow with id '{self.flow_id}' exists."
         )
 
 
+class UnresolvedCallStepException(RasaException):
+    """Valid call step should have a reference to an existing flow or agent.
+    Raised when it does not.
+    """
+
+    def __init__(
+        self, call_step_argument: str, calling_flow_id: str, step_id: str
+    ) -> None:
+        """Initializes the exception."""
+        self.call_step_argument = call_step_argument
+        self.calling_flow_id = calling_flow_id
+        self.step_id = step_id
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return (
+            f"The call step '{self.step_id}' in flow '{self.calling_flow_id}' "
+            f"is invalid: there is no flow or agent with the "
+            f"id '{self.call_step_argument}'. "
+            f"Please make sure that the call step argument is a valid flow id "
+            f"or an agent id."
+        )
+
+
 class UnresolvedFlowStepIdException(RasaException):
     """Raised when a flow step is referenced, but its id can not be resolved."""
 
@@ -562,15 +609,88 @@ def validate_link_in_call_restriction(flows: "FlowsList") -> None:
                 raise NoLinkAllowedInCalledFlowException(step.id, flow.id, step.call)
 
 
-def validate_called_flows_exists(flows: "FlowsList") -> None:
-    """Validates that all called flows exist."""
+def validate_call_steps(flows: "FlowsList") -> None:
+    """Validates that all called flows/agents exist and additional properties
+    are valid.
+    """
     for flow in flows.underlying_flows:
         for step in flow.steps:
             if not isinstance(step, CallFlowStep):
                 continue
 
-            if flows.flow_by_id(step.call) is None:
-                raise UnresolvedFlowException(step.call, flow.id, step.id)
+            _is_step_calling_agent = step.is_calling_agent()
+            if (
+                not _is_step_calling_agent
+                and flows.flow_by_id(step.call) is None
+                and not step.is_calling_mcp_tool()
+            ):
+                raise UnresolvedCallStepException(step.call, flow.id, step.id)
+
+            if step.exit_if and not _is_step_calling_agent:
+                # exit_if is only allowed for call steps that call an agent
+                raise RasaException(
+                    f"Call step '{step.id}' in flow '{flow.id}' has an 'exit_if' "
+                    f"condition, but it is not calling an agent. "
+                    f"'exit_if' is only allowed for call steps that call an agent."
+                )
+
+
+def validate_exit_if_conditions(
+    flows: "FlowsList", domain: Optional["Domain"] = None
+) -> None:
+    """Validates that exit_if conditions are valid.
+
+    This function validates:
+    - Each condition contains at least one slot reference
+    - Only defined slots are used within the conditions
+    - The predicates are valid
+
+    Args:
+        flows: The flows to validate.
+        domain: The domain with slot definitions. If None, slot validation is skipped.
+
+    Raises:
+        InvalidExitIfConditionException: If any exit_if condition is invalid.
+    """
+    for flow in flows.underlying_flows:
+        for step in flow.steps:
+            if not isinstance(step, CallFlowStep) or not step.exit_if:
+                continue
+
+            for condition in step.exit_if:
+                if not isinstance(condition, str):
+                    raise InvalidExitIfConditionException(
+                        step.id, flow.id, str(condition), "Condition must be a string"
+                    )
+
+                # Check if condition contains at least one slot reference
+                slot_references = re.findall(r"\bslots\.\w+", condition)
+                if not slot_references:
+                    raise InvalidExitIfConditionException(
+                        step.id,
+                        flow.id,
+                        condition,
+                        "Condition must contain at least one slot reference "
+                        "(e.g., 'slots.slot_name')",
+                    )
+
+                # Validate slot names if domain is provided
+                if domain:
+                    domain_slots = {slot.name: slot for slot in domain.slots}
+                    for slot_ref in slot_references:
+                        slot_name = slot_ref.split(".")[1]
+                        if slot_name not in domain_slots:
+                            raise InvalidExitIfConditionException(
+                                step.id,
+                                flow.id,
+                                condition,
+                                f"Slot '{slot_name}' is not defined in the domain",
+                            )
+
+                        # Validate predicate syntax using pypred
+                        _validate_predicate_syntax_with_pypred(
+                            step.id, flow.id, condition
+                        )
 
 
 def validate_linked_flows_exists(flows: "FlowsList") -> None:
@@ -594,7 +714,7 @@ def validate_linked_flows_exists(flows: "FlowsList") -> None:
                     flow.is_rasa_default_flow and step.link == RASA_PATTERN_CHITCHAT
                 )
             ):
-                raise UnresolvedFlowException(step.link, flow.id, step.id)
+                raise UnresolvedLinkFlowException(step.link, flow.id, step.id)
 
 
 def validate_patterns_are_not_called_or_linked(flows: "FlowsList") -> None:
@@ -751,3 +871,53 @@ def validate_slot_persistence_configuration(flow: Flow) -> None:
         result = _is_persist_slots_valid(persist_slots, flow_slots)
         if not result.is_valid:
             raise InvalidPersistSlotsException(flow_id, result.invalid_slots)
+
+
+def _validate_predicate_syntax_with_pypred(
+    step_id: str, flow_id: str, condition: str
+) -> None:
+    """Validates predicate syntax using pypred.
+
+    This function validates that the exit_if condition has valid predicate syntax.
+    Pypred catches syntax errors like double operators, invalid expressions, etc.
+
+    Args:
+        step_id: The ID of the step containing the condition.
+        flow_id: The ID of the flow containing the step.
+        condition: The exit_if condition string.
+
+    Raises:
+        InvalidExitIfConditionException: If pypred detects syntax errors.
+    """
+    try:
+        from pypred import Predicate
+
+        # Create a simple test context for syntax validation.
+        # This context works with all slot types since it's only used for:
+        # 1. Template rendering: Basic structure for Jinja2 template rendering
+        # 2. Syntax validation: Pypred validates predicate syntax
+        #    without actual slot values
+        test_context = {"slots": {"test_slot": "test_value"}}
+        rendered_template = Template(condition).render(test_context)
+
+        # Let pypred validate the predicate syntax
+        predicate = Predicate(rendered_template)
+        if not predicate.is_valid():
+            raise InvalidExitIfConditionException(
+                step_id,
+                flow_id,
+                condition,
+                "Invalid predicate syntax",
+            )
+
+    except ImportError:
+        # pypred not available, skip validation
+        pass
+    except Exception as e:
+        # Re-raise pypred errors as predicate syntax errors
+        raise InvalidExitIfConditionException(
+            step_id,
+            flow_id,
+            condition,
+            f"Invalid predicate syntax: {e}",
+        )

rasa/shared/core/flows/yaml_flows_io.py

@@ -127,7 +127,7 @@ class YAMLFlowsReader:
             If a schema does not have a `schema_name` set, we will use the
             `type` instead as a fallback.
             """
-            return schema.get("schema_name", schema.get("type"))
+            return str(schema.get("schema_name", schema.get("type") or "unknown"))
 
         def schema_names(schemas: List[Dict[str, Any]]) -> List[str]:
             """Get the names of the schemas.
@@ -262,9 +262,12 @@ class YamlFlowsWriter:
         Returns:
             The dumped YAML.
         """
-        return dump_obj_as_yaml_to_string(
-            {KEY_FLOWS: get_flows_as_json(flows, should_clean_json)}
-        )
+        dump = {}
+        for flow in flows:
+            dumped_flow = get_flow_as_json(flow, should_clean_json)
+            del dumped_flow["id"]
+            dump[flow.id] = dumped_flow
+        return dump_obj_as_yaml_to_string({KEY_FLOWS: dump})
 
     @staticmethod
     def dump(
@@ -415,24 +418,13 @@ def process_yaml_content(yaml_content: Dict[str, Any]) -> Dict[str, Any]:
 
     # Under the "flows" key certain keys cannot have metadata
     _process_keys_recursively(
-        yaml_content["flows"], ["nlu_trigger", "set_slots", "metadata"]
+        yaml_content["flows"],
+        ["nlu_trigger", "set_slots", "metadata", "mapping", "exit_if"],
     )
 
     return yaml_content
 
 
-def get_flows_as_json(
-    flows: FlowsList, should_clean_json: bool = False
-) -> Dict[str, Any]:
-    """Get the flows as a JSON dictionary."""
-    dump = {}
-    for flow in flows:
-        dumped_flow = get_flow_as_json(flow, should_clean_json)
-        del dumped_flow["id"]
-        dump[flow.id] = dumped_flow
-    return dump
-
-
 def get_flow_as_json(flow: Flow, should_clean_json: bool = False) -> Dict[str, Any]:
     """Clean the Flow JSON by removing default values and empty fields.
 

rasa/shared/core/slots.py

@@ -68,9 +68,9 @@ class SlotRejection:
 
 
 class SlotValidation(BaseModel):
-    rejections: List[SlotRejection] = Field(alias=REJECTIONS)
+    rejections: List[SlotRejection] = Field(alias=REJECTIONS)  # type: ignore[literal-required]
     """how the slot value is validated using predicate evaluation."""
-    refill_utter: str = Field(alias=REFILL_UTTER)
+    refill_utter: str = Field(alias=REFILL_UTTER)  # type: ignore[literal-required]
     """The utterance that the assistant uses to ask for the slot."""
 
     @staticmethod
@@ -273,14 +273,10 @@ class Slot(ABC):
         try:
             return rasa.shared.utils.common.class_from_module_path(type_name)
         except (ImportError, AttributeError):
-            known_types = [
-                cls.type_name for cls in rasa.shared.utils.common.all_subclasses(Slot)
-            ]
             raise InvalidSlotTypeException(
                 f"Failed to find slot type, '{type_name}' is neither a known type nor "
                 f"user-defined. If you are creating your own slot type, make "
                 f"sure its module path is correct. "
-                f"Known types: {', '.join(known_types)} "
                 f"You can find all build in types at {DOCS_URL_SLOTS}"
             )
 

rasa/shared/core/trackers.py

@@ -849,7 +849,7 @@ class DialogueStateTracker:
         action_names_to_exclude: Optional[List[Text]] = None,
         skip: int = 0,
         event_verbosity: EventVerbosity = EventVerbosity.APPLIED,
-    ) -> Optional["EventTypeAlias"]:
+    ) -> Optional[Event]:
         """Gets the last event of a given type which was actually applied.
 
         Args:
@@ -889,9 +889,12 @@ class DialogueStateTracker:
         Returns:
             `True` if last executed action had name `name`, otherwise `False`.
         """
-        last: Optional[ActionExecuted] = self.get_last_event_for(
+        last_event = self.get_last_event_for(
             ActionExecuted, action_names_to_exclude=[ACTION_LISTEN_NAME], skip=skip
         )
+        last: Optional[ActionExecuted] = (
+            last_event if isinstance(last_event, ActionExecuted) else None
+        )
         return last is not None and last.action_name == name
 
     ###

rasa/shared/exceptions.py

@@ -169,3 +169,7 @@ class ProviderClientValidationError(RasaException):
 
 class FinetuningDataPreparationException(RasaException):
     """Raised when there is an error in data preparation for fine-tuning."""
+
+
+class AgentInitializationException(RasaException):
+    """Raised when there is an error during the initialization of an agent."""

rasa/shared/importers/importer.py

@@ -207,12 +207,6 @@ class TrainingDataImporter(ABC):
                 )
             ]
 
-        return TrainingDataImporter.wrap_in_builtins(importers)
-
-    @staticmethod
-    def wrap_in_builtins(
-        importers: List["TrainingDataImporter"],
-    ) -> "TrainingDataImporter":
         return LanguageImporter(
             E2EImporter(
                 FlowSyncImporter(ResponsesSyncImporter(CombinedDataImporter(importers)))

rasa/shared/importers/rasa.py

@@ -74,7 +74,7 @@ class RasaFileImporter(TrainingDataImporter):
     @cached_method
     def get_flows(self) -> FlowsList:
         """Retrieves training stories / rules (see parent class for full docstring)."""
-        return utils.flows_from_paths(self._flow_files)
+        return utils.flows_from_paths(self._flow_files, self.get_domain())
 
     @cached_method
     def get_conversation_tests(self) -> StoryGraph:

rasa/shared/importers/utils.py

@@ -1,37 +1,9 @@
-from typing import Any, Dict, Iterable, List, Optional, Text
-
-from pydantic import BaseModel, Field
+from typing import Iterable, List, Optional, Text
 
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.flows.yaml_flows_io import KEY_FLOWS, get_flows_as_json
 from rasa.shared.core.training_data.structures import StoryGraph
-from rasa.shared.importers.importer import TrainingDataImporter
-from rasa.shared.nlu.training_data.formats.rasa_yaml import RasaYAMLWriter
 from rasa.shared.nlu.training_data.training_data import TrainingData
-from rasa.utils.json_utils import extract_values
-
-
-class CALMUserData(BaseModel):
-    """All pieces that will be uploaded to Rasa Studio."""
-
-    flows: Dict[str, Any] = Field(default_factory=dict)
-    domain: Dict[str, Any] = Field(default_factory=dict)
-    config: Dict[str, Any] = Field(default_factory=dict)
-    endpoints: Dict[str, Any] = Field(default_factory=dict)
-    nlu: Dict[str, Any] = Field(default_factory=dict)
-
-
-DOMAIN_KEYS = [
-    "version",
-    "actions",
-    "responses",
-    "slots",
-    "intents",
-    "entities",
-    "forms",
-    "session_config",
-]
 
 
 def training_data_from_paths(paths: Iterable[Text], language: Text) -> TrainingData:
@@ -51,8 +23,14 @@ def story_graph_from_paths(
     return StoryGraph(story_steps)
 
 
-def flows_from_paths(files: List[Text]) -> FlowsList:
-    """Returns the flows from paths."""
+def flows_from_paths(files: List[Text], domain: Optional[Domain] = None) -> FlowsList:
+    """Returns the flows from paths.
+
+    Args:
+        files: List of flow file paths to load.
+        domain: Optional domain for validation. If provided, exit_if conditions
+               will be validated against defined slots.
+    """
     from rasa.shared.core.flows.yaml_flows_io import YAMLFlowsReader
 
     flows = FlowsList(underlying_flows=[])
@@ -60,53 +38,5 @@ def flows_from_paths(files: List[Text]) -> FlowsList:
         flows = flows.merge(
             YAMLFlowsReader.read_from_file(file), ignore_duplicates=False
         )
-    flows.validate()
+    flows.validate(domain)
     return flows
-
-
-def extract_calm_import_parts_from_importer(
-    importer: TrainingDataImporter,
-    config: Optional[Dict[str, Any]] = None,
-    endpoints: Optional[Dict[str, Any]] = None,
-) -> CALMUserData:
-    """Extracts CALMUserData from a TrainingDataImporter.
-
-    Args:
-        importer: The training data importer
-        data_paths: The path(s) to the training data for flows
-        config: Optional config dict, if not provided will use importer.get_config()
-        endpoints: Optional endpoints dict, defaults to empty dict
-
-    Returns:
-        CALMUserData containing flows, domain, config, endpoints, and nlu data
-    """
-    # Extract config
-    if config is None:
-        config = importer.get_config()
-
-    # Extract domain
-    domain_from_files = importer.get_user_domain().as_dict()
-    domain = extract_values(domain_from_files, DOMAIN_KEYS)
-
-    # Extract flows
-    flows = importer.get_user_flows()
-    flows_dict = {KEY_FLOWS: get_flows_as_json(flows)}
-
-    # Extract NLU data
-    nlu_data = importer.get_nlu_data()
-    nlu_examples = nlu_data.filter_training_examples(
-        lambda ex: ex.get("intent") in nlu_data.intents
-    )
-    nlu_dict = RasaYAMLWriter().training_data_to_dict(nlu_examples)
-
-    # Use provided endpoints or default to empty dict
-    if endpoints is None:
-        endpoints = {}
-
-    return CALMUserData(
-        flows=flows_dict or {},
-        domain=domain or {},
-        config=config or {},
-        endpoints=endpoints or {},
-        nlu=nlu_dict or {},
-    )

rasa/shared/providers/_utils.py

@@ -1,103 +1,87 @@
 from typing import Any, Dict, Optional
 
-import boto3
 import structlog
-from botocore.exceptions import BotoCoreError, ClientError
+from litellm import validate_environment
 
 from rasa.shared.constants import (
     API_BASE_CONFIG_KEY,
     API_VERSION_CONFIG_KEY,
     AWS_ACCESS_KEY_ID_CONFIG_KEY,
-    AWS_BEDROCK_PROVIDER,
+    AWS_ACCESS_KEY_ID_ENV_VAR,
     AWS_REGION_NAME_CONFIG_KEY,
-    AWS_SAGEMAKER_CHAT_PROVIDER,
-    AWS_SAGEMAKER_PROVIDER,
+    AWS_REGION_NAME_ENV_VAR,
     AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
+    AWS_SECRET_ACCESS_KEY_ENV_VAR,
     AWS_SESSION_TOKEN_CONFIG_KEY,
+    AWS_SESSION_TOKEN_ENV_VAR,
     AZURE_API_BASE_ENV_VAR,
     AZURE_API_VERSION_ENV_VAR,
     DEPLOYMENT_CONFIG_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
-from rasa.shared.utils.io import resolve_environment_variables
+from rasa.shared.providers.embedding._base_litellm_embedding_client import (
+    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
+)
 
 structlogger = structlog.get_logger()
 
 
 def validate_aws_setup_for_litellm_clients(
-    litellm_model_name: str, litellm_call_kwargs: Dict, source_log: str, provider: str
+    litellm_model_name: str, litellm_call_kwargs: dict, source_log: str
 ) -> None:
-    """Validates the AWS setup for LiteLLM clients to ensure credentials are set.
+    """Validates the AWS setup for LiteLLM clients to ensure all required
+    environment variables or corresponding call kwargs are set.
 
     Args:
         litellm_model_name (str): The name of the LiteLLM model being validated.
         litellm_call_kwargs (dict): Additional keyword arguments passed to the client,
             which may include configuration values for AWS credentials.
         source_log (str): The source log identifier for structured logging.
-        provider (str): The provider for which the validation is being performed.
 
     Raises:
         ProviderClientValidationError: If any required AWS environment variable
             or corresponding configuration key is missing.
     """
-    # expand environment variables if referenced in the config
-    resolved_litellm_call_kwargs: Dict = resolve_environment_variables(
-        litellm_call_kwargs
-    )  # type: ignore[assignment]
-
-    # boto3 only accepts bedrock and sagemaker as valid clients
-    # therefore we need to convert the provider name if it is defined
-    # as sagemaker_chat
-    provider = (
-        AWS_SAGEMAKER_PROVIDER if provider == AWS_SAGEMAKER_CHAT_PROVIDER else provider
-    )
-
-    # if the AWS credentials are defined in the endpoints yaml model config,
-    # either as referenced secret env vars or direct values, we need to pass them
-    # to the boto3 client to ensure that the client can connect to the AWS service.
-    additional_kwargs: Dict[str, Any] = {}
-    if AWS_ACCESS_KEY_ID_CONFIG_KEY in resolved_litellm_call_kwargs:
-        additional_kwargs[AWS_ACCESS_KEY_ID_CONFIG_KEY] = resolved_litellm_call_kwargs[
-            AWS_ACCESS_KEY_ID_CONFIG_KEY
-        ]
-    if AWS_SECRET_ACCESS_KEY_CONFIG_KEY in resolved_litellm_call_kwargs:
-        additional_kwargs[AWS_SECRET_ACCESS_KEY_CONFIG_KEY] = (
-            resolved_litellm_call_kwargs[AWS_SECRET_ACCESS_KEY_CONFIG_KEY]
-        )
-    if AWS_SESSION_TOKEN_CONFIG_KEY in resolved_litellm_call_kwargs:
-        additional_kwargs[AWS_SESSION_TOKEN_CONFIG_KEY] = resolved_litellm_call_kwargs[
-            AWS_SESSION_TOKEN_CONFIG_KEY
-        ]
-    if AWS_REGION_NAME_CONFIG_KEY in resolved_litellm_call_kwargs:
-        additional_kwargs["region_name"] = resolved_litellm_call_kwargs[
-            AWS_REGION_NAME_CONFIG_KEY
-        ]
 
-    try:
-        # We are using the boto3 client because it can discover the AWS credentials
-        # from the environment variables, credentials file, or IAM roles.
-        # This is necessary to ensure that the client can connect to the AWS service.
-        aws_client = boto3.client(provider, **additional_kwargs)
+    # Mapping of environment variable names to their corresponding config keys
+    envs_to_args = {
+        AWS_ACCESS_KEY_ID_ENV_VAR: AWS_ACCESS_KEY_ID_CONFIG_KEY,
+        AWS_SECRET_ACCESS_KEY_ENV_VAR: AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
+        AWS_REGION_NAME_ENV_VAR: AWS_REGION_NAME_CONFIG_KEY,
+        AWS_SESSION_TOKEN_ENV_VAR: AWS_SESSION_TOKEN_CONFIG_KEY,
+    }
 
-        # Using different method calls available to different AWS clients
-        # to test the connection
-        if provider == AWS_SAGEMAKER_PROVIDER:
-            aws_client.list_models()
-        elif provider == AWS_BEDROCK_PROVIDER:
-            aws_client.get_model_invocation_logging_configuration()
+    # Validate the environment setup for the model
+    validation_info = validate_environment(litellm_model_name)
+    missing_environment_variables = validation_info.get(
+        _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY, []
+    )
+    # Filter out missing environment variables that have been set trough arguments
+    # in extra parameters
+    missing_environment_variables = [
+        missing_env_var
+        for missing_env_var in missing_environment_variables
+        if litellm_call_kwargs.get(envs_to_args.get(missing_env_var)) is None
+    ]
 
-    except (ClientError, BotoCoreError) as exc:
+    if missing_environment_variables:
+        missing_environment_details = [
+            (
+                f"'{missing_env_var}' environment variable or "
+                f"'{envs_to_args.get(missing_env_var)}' config key"
+            )
+            for missing_env_var in missing_environment_variables
+        ]
         event_info = (
-            f"Failed to validate AWS setup for LiteLLM clients: {exc}. "
-            f"Ensure that you are using one of the available authentication methods:"
-            f"credentials file, environment variables, or IAM roles. "
-            f"Also, ensure that the AWS region is set correctly. "
+            f"The following environment variables or configuration keys are "
+            f"missing: "
+            f"{', '.join(missing_environment_details)}. "
+            f"These settings are required for API calls."
         )
         structlogger.error(
-            f"{source_log}.validate_aws_credentials_for_litellm_clients",
+            f"{source_log}.validate_aws_environment_variables",
             event_info=event_info,
-            exception=str(exc),
-            model_name=litellm_model_name,
+            missing_environment_variables=missing_environment_variables,
         )
         raise ProviderClientValidationError(event_info)
 

rasa/shared/providers/embedding/default_litellm_embedding_client.py

@@ -37,7 +37,6 @@ class DefaultLiteLLMEmbeddingClient(_BaseLiteLLMEmbeddingClient):
 
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "DefaultLiteLLMEmbeddingClient":
-        """Creates a DefaultLiteLLMEmbeddingClient instance from a config dict."""
         default_config = DefaultLiteLLMClientConfig.from_dict(config)
         return cls(
             model=default_config.model,
@@ -122,7 +121,6 @@ class DefaultLiteLLMEmbeddingClient(_BaseLiteLLMEmbeddingClient):
                 self._litellm_model_name,
                 self._litellm_extra_parameters,
                 "default_litellm_embedding_client",
-                provider=self.provider,
             )
         else:
             super().validate_client_setup()