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

rasa/shared/core/slots.py

@@ -273,10 +273,14 @@ 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/exceptions.py

@@ -163,6 +163,10 @@ class ProviderClientAPIException(RasaException):
         return s
 
 
+class LLMToolResponseDecodeError(ProviderClientAPIException):
+    """Raised when a JSON decoding error occurs in LLM tool response."""
+
+
 class ProviderClientValidationError(RasaException):
     """Raised for errors that occur during validation of the API client."""
 
@@ -173,3 +177,11 @@ class FinetuningDataPreparationException(RasaException):
 
 class AgentInitializationException(RasaException):
     """Raised when there is an error during the initialization of an agent."""
+
+
+class AgentAuthInitializationException(RasaException):
+    """Raised when there is an error during the initialization of agent auth client."""
+
+
+class AuthenticationError(RasaException):
+    """Raised when there is an authentication error."""

rasa/shared/importers/importer.py

@@ -207,6 +207,12 @@ 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/utils.py

@@ -1,9 +1,37 @@
-from typing import Iterable, List, Optional, Text
+from typing import Any, Dict, Iterable, List, Optional, Text
+
+from pydantic import BaseModel, Field
 
 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:
@@ -40,3 +68,51 @@ def flows_from_paths(files: List[Text], domain: Optional[Domain] = None) -> Flow
         )
     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/nlu/training_data/schemas/responses.yml

@@ -72,6 +72,9 @@ schema;responses:
               allowempty: True
           channel:
             type: "str"
+          allow_interruptions:
+            type: "bool"
+            required: False
           metadata:
             type: "any"
           condition:

rasa/shared/providers/_utils.py

@@ -1,87 +1,103 @@
 from typing import Any, Dict, Optional
 
+import boto3
 import structlog
-from litellm import validate_environment
+from botocore.exceptions import BotoCoreError, ClientError
 
 from rasa.shared.constants import (
     API_BASE_CONFIG_KEY,
     API_VERSION_CONFIG_KEY,
     AWS_ACCESS_KEY_ID_CONFIG_KEY,
-    AWS_ACCESS_KEY_ID_ENV_VAR,
+    AWS_BEDROCK_PROVIDER,
     AWS_REGION_NAME_CONFIG_KEY,
-    AWS_REGION_NAME_ENV_VAR,
+    AWS_SAGEMAKER_CHAT_PROVIDER,
+    AWS_SAGEMAKER_PROVIDER,
     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.providers.embedding._base_litellm_embedding_client import (
-    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
-)
+from rasa.shared.utils.io import resolve_environment_variables
 
 structlogger = structlog.get_logger()
 
 
 def validate_aws_setup_for_litellm_clients(
-    litellm_model_name: str, litellm_call_kwargs: dict, source_log: str
+    litellm_model_name: str, litellm_call_kwargs: Dict, source_log: str, provider: str
 ) -> None:
-    """Validates the AWS setup for LiteLLM clients to ensure all required
-    environment variables or corresponding call kwargs are set.
+    """Validates the AWS setup for LiteLLM clients to ensure credentials 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.
     """
-
-    # 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,
-    }
-
-    # 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, []
+    # 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
     )
-    # 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
-    ]
 
-    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
+    # 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)
+
+        # 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()
+
+    except (ClientError, BotoCoreError) as exc:
         event_info = (
-            f"The following environment variables or configuration keys are "
-            f"missing: "
-            f"{', '.join(missing_environment_details)}. "
-            f"These settings are required for API calls."
+            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. "
         )
         structlogger.error(
-            f"{source_log}.validate_aws_environment_variables",
+            f"{source_log}.validate_aws_credentials_for_litellm_clients",
             event_info=event_info,
-            missing_environment_variables=missing_environment_variables,
+            exception=str(exc),
+            model_name=litellm_model_name,
         )
         raise ProviderClientValidationError(event_info)
 

rasa/shared/providers/embedding/default_litellm_embedding_client.py

@@ -37,6 +37,7 @@ 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,
@@ -121,6 +122,7 @@ class DefaultLiteLLMEmbeddingClient(_BaseLiteLLMEmbeddingClient):
                 self._litellm_model_name,
                 self._litellm_extra_parameters,
                 "default_litellm_embedding_client",
+                provider=self.provider,
             )
         else:
             super().validate_client_setup()

rasa/shared/providers/llm/_base_litellm_client.py

@@ -158,7 +158,7 @@ class _BaseLiteLLMClient:
             )
             return self._format_response(response)
         except Exception as e:
-            raise ProviderClientAPIException(e)
+            raise ProviderClientAPIException(e) from e
 
     @suppress_logs(log_level=logging.WARNING)
     async def acompletion(
@@ -209,7 +209,7 @@ class _BaseLiteLLMClient:
                     "In case you are getting OpenAI connection errors, such as missing "
                     "API key, your configuration is incorrect."
                 )
-            raise ProviderClientAPIException(e, message)
+            raise ProviderClientAPIException(e, message) from e
 
     def _get_formatted_messages(
         self, messages: Union[List[dict], List[str], str]

rasa/shared/providers/llm/default_litellm_llm_client.py

@@ -39,6 +39,7 @@ class DefaultLiteLLMClient(_BaseLiteLLMClient):
 
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> DefaultLiteLLMClient:
+        """Creates a DefaultLiteLLMClient instance from a configuration dictionary."""
         default_config = DefaultLiteLLMClientConfig.from_dict(config)
         return cls(
             model=default_config.model,
@@ -110,6 +111,7 @@ class DefaultLiteLLMClient(_BaseLiteLLMClient):
                 self._litellm_model_name,
                 self._litellm_extra_parameters,
                 "default_litellm_llm_client",
+                provider=self.provider,
             )
         else:
             super().validate_client_setup()

rasa/shared/providers/llm/llm_response.py

@@ -9,7 +9,7 @@ from litellm.utils import ChatCompletionMessageToolCall
 from pydantic import BaseModel
 
 from rasa.shared.constants import KEY_TOOL_CALLS
-from rasa.shared.exceptions import ProviderClientAPIException
+from rasa.shared.exceptions import LLMToolResponseDecodeError
 
 structlogger = structlog.get_logger()
 
@@ -75,13 +75,13 @@ class LLMToolCall(BaseModel):
                 tool_name=data.function.name,
                 tool_call=data.function.arguments,
             )
-            raise ProviderClientAPIException(
+            raise LLMToolResponseDecodeError(
                 original_exception=e,
                 message=(
-                    f"Invalid arguments for tool call `{data.function.name}`: "
+                    f"Invalid arguments for tool call - `{data.function.name}`: "
                     f"`{data.function.arguments}`"
                 ),
-            )
+            ) from e
 
         return cls(
             id=data.id,

rasa/shared/utils/common.py

@@ -17,6 +17,7 @@ from typing import (
     Optional,
     Sequence,
     Text,
+    Tuple,
     Type,
 )
 
@@ -102,9 +103,12 @@ def sort_list_of_dicts_by_first_key(dicts: List[Dict]) -> List[Dict]:
 
 def cached_method(f: Callable[..., Any]) -> Callable[..., Any]:
     """Caches method calls based on the call's `args` and `kwargs`.
+
     Works for `async` and `sync` methods. Don't apply this to functions.
+
     Args:
         f: The decorated method whose return value should be cached.
+
     Returns:
         The return value which the method gives for the first call with the given
         arguments.
@@ -358,6 +362,7 @@ def validate_environment(
     component_name: str,
 ) -> None:
     """Make sure all needed requirements for a component are met.
+
     Args:
          required_env_vars: List of environment variables that should be set
          required_packages: List of packages that should be installed
@@ -389,3 +394,22 @@ Sign up at: https://feedback.rasa.com
 {separator}
 """
     print_success(message)
+
+
+def conditional_import(module_name: str, class_name: str) -> Tuple[Any, bool]:
+    """Conditionally import a class, returning (class, is_available) tuple.
+
+    Args:
+        module_name: The module path to import from
+        class_name: The class name to import
+
+    Returns:
+        A tuple of (class, is_available) where class is the imported class
+        or None if import failed, and is_available is a boolean indicating
+        whether the import was successful.
+    """
+    try:
+        module = __import__(module_name, fromlist=[class_name])
+        return getattr(module, class_name), True
+    except ImportError:
+        return None, False

rasa/shared/utils/health_check/health_check.py

@@ -1,7 +1,10 @@
 import os
-from typing import Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 from rasa.exceptions import HealthCheckError
+
+if TYPE_CHECKING:
+    pass
 from rasa.shared.constants import (
     LLM_API_HEALTH_CHECK_DEFAULT_VALUE,
     LLM_API_HEALTH_CHECK_ENV_VAR,
@@ -63,6 +66,7 @@ def perform_llm_health_check(
     log_source_component: str,
 ) -> None:
     """Try to instantiate the LLM Client to validate the provided config.
+
     If the LLM_API_HEALTH_CHECK environment variable is true, perform a test call
     to the LLM API. If config contains multiple models, perform a test call for each
     model in the model group.
@@ -125,6 +129,7 @@ def perform_embeddings_health_check(
     log_source_component: str,
 ) -> None:
     """Try to instantiate the Embedder to validate the provided config.
+
     If the LLM_API_HEALTH_CHECK environment variable is true, perform a test call
     to the Embeddings API. If config contains multiple models, perform a test call for
     each model in the model group.
@@ -240,8 +245,7 @@ def send_test_embeddings_api_request(
 
 
 def is_api_health_check_enabled() -> bool:
-    """Determines whether the API health check is enabled based on an environment
-    variable.
+    """Determines whether the API health check is enabled.
 
     Returns:
         bool: True if the API health check is enabled, False otherwise.

rasa/shared/utils/llm.py

@@ -762,7 +762,7 @@ def get_prompt_template(
                 log_source_method=log_source_method,
             )
             return prompt_template
-    except (FileIOException, FileNotFoundException):
+    except (FileIOException, FileNotFoundException) as e:
         structlogger.warning(
             "utils.llm.get_prompt_template" ".failed_to_read_custom_prompt_template",
             event_info=(
@@ -770,6 +770,7 @@ def get_prompt_template(
             ),
             log_source_component=log_source_component,
             log_source_method=log_source_method,
+            error=str(e),
         )
     return default_prompt_template