rasa-pro 3.11.3__py3-none-any.whl

rasa/shared/providers/_configs/openai_client_config.py

@@ -0,0 +1,175 @@
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    OPENAI_API_BASE_CONFIG_KEY,
+    API_BASE_CONFIG_KEY,
+    OPENAI_API_TYPE_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+    OPENAI_API_VERSION_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
+    RASA_TYPE_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY,
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    OPENAI_API_TYPE,
+    OPENAI_PROVIDER,
+)
+from rasa.shared.providers._configs.utils import (
+    resolve_aliases,
+    validate_required_keys,
+    raise_deprecation_warnings,
+    validate_forbidden_keys,
+)
+
+structlogger = structlog.get_logger()
+
+
+DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
+    # Model name aliases
+    MODEL_NAME_CONFIG_KEY: MODEL_CONFIG_KEY,
+    # Provider aliases
+    RASA_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    # API type aliases
+    OPENAI_API_TYPE_CONFIG_KEY: API_TYPE_CONFIG_KEY,
+    # API base aliases
+    OPENAI_API_BASE_CONFIG_KEY: API_BASE_CONFIG_KEY,
+    # API version aliases
+    OPENAI_API_VERSION_CONFIG_KEY: API_VERSION_CONFIG_KEY,
+    # Timeout aliases
+    REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+}
+
+REQUIRED_KEYS = [MODEL_CONFIG_KEY]
+
+FORBIDDEN_KEYS = [
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+]
+
+
+@dataclass
+class OpenAIClientConfig:
+    """Parses configuration for Azure OpenAI client, resolves aliases and
+    raises deprecation warnings.
+
+    Raises:
+        ValueError: Raised in cases of invalid configuration:
+            - If any of the required configuration keys are missing.
+            - If `api_type` has a value different from `openai`.
+    """
+
+    model: str
+    api_base: Optional[str]
+    api_version: Optional[str]
+
+    # API Type is not actually used by LiteLLM backend, but we define
+    # it here for backward compatibility.
+    api_type: str = OPENAI_API_TYPE
+
+    # Provider is not used by LiteLLM backend, but we define
+    # it here since it's used as switch between different
+    # clients
+    provider: str = OPENAI_PROVIDER
+
+    extra_parameters: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        # In case of OpenAI hosting, it doesn't make sense
+        # for API type to be anything else that 'openai'
+        if self.api_type != OPENAI_API_TYPE:
+            message = f"API type must be set to '{OPENAI_API_TYPE}'."
+            structlogger.error(
+                "openai_client_config.validation_error",
+                message=message,
+                api_type=self.api_type,
+            )
+            raise ValueError(message)
+        if self.provider != OPENAI_PROVIDER:
+            message = f"Provider must be set to '{OPENAI_PROVIDER}'."
+            structlogger.error(
+                "openai_client_config.validation_error",
+                message=message,
+                provider=self.provider,
+            )
+            raise ValueError(message)
+        if self.model is None:
+            message = "Model cannot be set to None."
+            structlogger.error(
+                "openai_client_config.validation_error",
+                message=message,
+                model=self.model,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "OpenAIClientConfig":
+        """
+        Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            AzureOpenAIClientConfig
+        """
+        # Check for deprecated keys
+        raise_deprecation_warnings(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+        # Resolve any potential aliases
+        config = cls.resolve_config_aliases(config)
+        # Validate that the required keys are present
+        validate_required_keys(config, REQUIRED_KEYS)
+        # Validate that the forbidden keys are not present
+        validate_forbidden_keys(config, FORBIDDEN_KEYS)
+        this = OpenAIClientConfig(
+            # Required parameters
+            model=config.pop(MODEL_CONFIG_KEY),
+            # Pop the 'provider' key. Currently, it's *optional* because of
+            # backward compatibility with older versions.
+            provider=config.pop(PROVIDER_CONFIG_KEY, OPENAI_PROVIDER),
+            # Optional parameters
+            api_base=config.pop(API_BASE_CONFIG_KEY, None),
+            api_version=config.pop(API_VERSION_CONFIG_KEY, None),
+            api_type=config.pop(API_TYPE_CONFIG_KEY, OPENAI_API_TYPE),
+            # The rest of parameters (e.g. model parameters) are considered
+            # as extra parameters (this also includes timeout).
+            extra_parameters=config,
+        )
+        return this
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = asdict(self)
+        # Extra parameters should also be on the top level
+        d.pop("extra_parameters", None)
+        d.update(self.extra_parameters)
+        return d
+
+    @staticmethod
+    def resolve_config_aliases(config: Dict[str, Any]) -> Dict[str, Any]:
+        return resolve_aliases(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+
+
+def is_openai_config(config: dict) -> bool:
+    """Check whether the configuration is meant to configure
+    an OpenAI client.
+    """
+    # Process the config to handle all the aliases
+    config = OpenAIClientConfig.resolve_config_aliases(config)
+
+    # Case: Configuration contains `provider: openai`
+    if config.get(PROVIDER_CONFIG_KEY) == OPENAI_PROVIDER:
+        return True
+
+    return False

rasa/shared/providers/_configs/rasa_llm_client_config.py

@@ -0,0 +1,73 @@
+from dataclasses import asdict, dataclass, field
+from typing import Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    MODEL_CONFIG_KEY,
+    RASA_PROVIDER,
+    PROVIDER_CONFIG_KEY,
+    API_BASE_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.utils import (
+    validate_required_keys,
+)
+
+REQUIRED_KEYS = [MODEL_CONFIG_KEY, PROVIDER_CONFIG_KEY, API_BASE_CONFIG_KEY]
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class RasaLLMClientConfig:
+    """Parses configuration for a Rasa Hosted LiteLLM client,
+    checks required keys present.
+
+    Raises:
+        ValueError: Raised in cases of invalid configuration:
+            - If any of the required configuration keys are missing.
+    """
+
+    model: Optional[str]
+    api_base: Optional[str]
+    # Provider is not used by LiteLLM backend, but we define it here since it's
+    # used as switch between different clients.
+    provider: str = RASA_PROVIDER
+
+    extra_parameters: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "RasaLLMClientConfig":
+        """
+        Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Raised in cases of invalid configuration:
+                - If any of the required configuration keys are missing.
+                - If `api_type` has a value different from `azure`.
+
+        Returns:
+            RasaLLMClientConfig
+        """
+        # Validate that required keys are set
+        validate_required_keys(config, REQUIRED_KEYS)
+
+        extra_parameters = {k: v for k, v in config.items() if k not in REQUIRED_KEYS}
+
+        return cls(
+            model=config.get(MODEL_CONFIG_KEY),
+            api_base=config.get(API_BASE_CONFIG_KEY),
+            provider=config.get(PROVIDER_CONFIG_KEY, RASA_PROVIDER),
+            extra_parameters=extra_parameters,
+        )
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = asdict(self)
+        # Extra parameters should also be on the top level
+        d.pop("extra_parameters", None)
+        d.update(self.extra_parameters)
+        return d

rasa/shared/providers/_configs/self_hosted_llm_client_config.py

@@ -0,0 +1,177 @@
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    OPENAI_API_BASE_CONFIG_KEY,
+    API_BASE_CONFIG_KEY,
+    OPENAI_API_TYPE_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+    OPENAI_API_VERSION_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
+    RASA_TYPE_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY,
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    SELF_HOSTED_PROVIDER,
+    USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
+)
+
+from rasa.shared.providers._configs.utils import (
+    raise_deprecation_warnings,
+    resolve_aliases,
+    validate_forbidden_keys,
+    validate_required_keys,
+)
+
+structlogger = structlog.get_logger()
+
+
+DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
+    # Model name aliases
+    MODEL_NAME_CONFIG_KEY: MODEL_CONFIG_KEY,
+    # Provider aliases
+    RASA_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    # API type aliases
+    OPENAI_API_TYPE_CONFIG_KEY: API_TYPE_CONFIG_KEY,
+    # API base aliases
+    OPENAI_API_BASE_CONFIG_KEY: API_BASE_CONFIG_KEY,
+    # API version aliases
+    OPENAI_API_VERSION_CONFIG_KEY: API_VERSION_CONFIG_KEY,
+    # Timeout aliases
+    REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+}
+
+REQUIRED_KEYS = [API_BASE_CONFIG_KEY, MODEL_CONFIG_KEY, PROVIDER_CONFIG_KEY]
+
+FORBIDDEN_KEYS = [
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+]
+
+
+@dataclass
+class SelfHostedLLMClientConfig:
+    """Parses configuration for Self Hosted LiteLLM client, resolves aliases and
+    raises deprecation warnings.
+
+    Raises:
+        ValueError: Raised in cases of invalid configuration:
+            - If any of the required configuration keys are missing.
+    """
+
+    model: str
+    provider: str
+    api_base: str
+    api_version: Optional[str] = None
+    api_type: Optional[str] = OPENAI_PROVIDER
+    use_chat_completions_endpoint: Optional[bool] = True
+    extra_parameters: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.model is None:
+            message = "Model cannot be set to None."
+            structlogger.error(
+                "self_hosted_llm_client_config.validation_error",
+                message=message,
+                model=self.model,
+            )
+            raise ValueError(message)
+        if self.provider is None:
+            message = "Provider cannot be set to None."
+            structlogger.error(
+                "self_hosted_llm_client_config.validation_error",
+                message=message,
+                provider=self.provider,
+            )
+            raise ValueError(message)
+        if self.api_base is None:
+            message = "API base cannot be set to None."
+            structlogger.error(
+                "self_hosted_llm_client_config.validation_error",
+                message=message,
+                provider=self.provider,
+            )
+            raise ValueError(message)
+        if self.api_type != OPENAI_PROVIDER:
+            message = (
+                f"Currently supports only {OPENAI_PROVIDER} endpoints. "
+                f"API type must be set to '{OPENAI_PROVIDER}'."
+            )
+            structlogger.error(
+                "self_hosted_llm_client_config.validation_error",
+                message=message,
+                api_type=self.api_type,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "SelfHostedLLMClientConfig":
+        """
+        Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            DefaultLiteLLMClientConfig
+        """
+        # Check for deprecated keys
+        raise_deprecation_warnings(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+        # Resolve any potential aliases
+        config = cls.resolve_config_aliases(config)
+        # Validate that the required keys are present
+        validate_required_keys(config, REQUIRED_KEYS)
+        # Validate that the forbidden keys are not present
+        validate_forbidden_keys(config, FORBIDDEN_KEYS)
+        this = SelfHostedLLMClientConfig(
+            # Required parameters
+            model=config.pop(MODEL_CONFIG_KEY),
+            provider=config.pop(PROVIDER_CONFIG_KEY),
+            api_base=config.pop(API_BASE_CONFIG_KEY),
+            # Optional parameters
+            api_type=config.pop(API_TYPE_CONFIG_KEY, OPENAI_PROVIDER),
+            api_version=config.pop(API_VERSION_CONFIG_KEY, None),
+            use_chat_completions_endpoint=config.pop(
+                USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY, True
+            ),
+            # The rest of parameters (e.g. model parameters) are considered
+            # as extra parameters
+            extra_parameters=config,
+        )
+        return this
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = asdict(self)
+        # Extra parameters should also be on the top level
+        d.pop("extra_parameters", None)
+        d.update(self.extra_parameters)
+        return d
+
+    @staticmethod
+    def resolve_config_aliases(config: Dict[str, Any]) -> Dict[str, Any]:
+        return resolve_aliases(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+
+
+def is_self_hosted_config(config: dict) -> bool:
+    """Check whether the configuration is meant to configure an self-hosted client."""
+    # Process the config to handle all the aliases
+    config = SelfHostedLLMClientConfig.resolve_config_aliases(config)
+
+    # Case: Configuration contains `provider: self-hosted`
+    if config.get(PROVIDER_CONFIG_KEY) == SELF_HOSTED_PROVIDER:
+        return True
+
+    return False

rasa/shared/providers/_configs/utils.py

@@ -0,0 +1,117 @@
+import structlog
+from rasa.shared.utils.io import raise_deprecation_warning
+
+structlogger = structlog.get_logger()
+
+
+def resolve_aliases(config: dict, deprecated_alias_mapping: dict) -> dict:
+    """
+    Resolve aliases in the configuration to standard keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        deprecated_alias_mapping: Dictionary mapping aliases to
+            their standard keys.
+
+    Returns:
+        New dictionary containing the processed configuration.
+    """
+    config = config.copy()
+
+    for alias, standard_key in deprecated_alias_mapping.items():
+        # We check for the alias instead of the standard key because our goal is to
+        # update the standard key when the alias is found. Since the standard key is
+        # always included in the default component configurations, we overwrite it
+        # with the alias value if the alias exists.
+        if alias in config:
+            config[standard_key] = config.pop(alias)
+
+    return config
+
+
+def raise_deprecation_warnings(config: dict, deprecated_alias_mapping: dict) -> None:
+    """
+    Raises warnings for deprecated keys in the configuration.
+
+    Args:
+        config: Dictionary containing the configuration.
+        deprecated_alias_mapping: Dictionary mapping deprecated keys to
+            their standard keys.
+
+    Raises:
+        DeprecationWarning: If any deprecated key is found in the config.
+    """
+    for alias, standard_key in deprecated_alias_mapping.items():
+        if alias in config:
+            raise_deprecation_warning(
+                message=(
+                    f"'{alias}' is deprecated and will be removed in "
+                    f"4.0.0. Use '{standard_key}' instead."
+                )
+            )
+
+
+def validate_required_keys(config: dict, required_keys: list) -> None:
+    """
+    Validates that the passed config contains all the required keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        required_keys: List of keys that must be present in the config.
+
+    Raises:
+        ValueError: If any required key is missing.
+    """
+    missing_keys = [key for key in required_keys if key not in config]
+    if missing_keys:
+        message = f"Missing required keys '{missing_keys}' for configuration."
+        structlogger.error(
+            "validate_required_keys",
+            message=message,
+            missing_keys=missing_keys,
+            config=config,
+        )
+        raise ValueError(message)
+
+
+def validate_forbidden_keys(config: dict, forbidden_keys: list) -> None:
+    """
+    Validates that the passed config doesn't contain any forbidden keys.
+
+    Args:
+        config: Dictionary containing the configuration.
+        forbidden_keys: List of keys that are forbidden in the config.
+
+    Raises:
+        ValueError: If any forbidden key is present.
+    """
+    forbidden_keys_in_config = set(config.keys()).intersection(set(forbidden_keys))
+
+    if forbidden_keys_in_config:
+        message = (
+            f"Forbidden keys '{forbidden_keys_in_config}' present "
+            f"in the configuration."
+        )
+        structlogger.error(
+            "validate_forbidden_keys",
+            message=message,
+            forbidden_keys=forbidden_keys_in_config,
+            config=config,
+        )
+        raise ValueError(message)
+
+
+def get_provider_prefixed_model_name(provider: str, model: str) -> str:
+    """
+    Returns the model name with the provider prefixed.
+
+    Args:
+        provider: The provider of the model.
+        model: The model name.
+
+    Returns:
+        The model name with the provider prefixed.
+    """
+    if model and f"{provider}/" not in model:
+        return f"{provider}/{model}"
+    return model

rasa/shared/providers/_ssl_verification_utils.py

@@ -0,0 +1,124 @@
+import os
+from typing import Optional, Union
+
+import httpx
+import litellm
+from rasa.shared.constants import (
+    RASA_CA_BUNDLE_ENV_VAR,
+    REQUESTS_CA_BUNDLE_ENV_VAR,
+    RASA_SSL_CERTIFICATE_ENV_VAR,
+    LITELLM_SSL_VERIFY_ENV_VAR,
+    LITELLM_SSL_CERTIFICATE_ENV_VAR,
+)
+
+import structlog
+
+from rasa.shared.utils.io import raise_deprecation_warning
+
+structlogger = structlog.get_logger()
+
+
+def ensure_ssl_certificates_for_litellm_non_openai_based_clients() -> None:
+    """
+    Ensure SSL certificates configuration for LiteLLM based on environment
+    variables for clients that are not utilizing OpenAI's clients from
+    `openai` library.
+    """
+    ssl_verify = _get_ssl_verify()
+    ssl_certificate = _get_ssl_cert()
+
+    structlogger.debug(
+        "ensure_ssl_certificates_for_litellm_non_openai_based_clients",
+        ssl_verify=ssl_verify,
+        ssl_certificate=ssl_certificate,
+    )
+
+    if ssl_verify is not None:
+        litellm.ssl_verify = ssl_verify
+    if ssl_certificate is not None:
+        litellm.ssl_certificate = ssl_certificate
+
+
+def ensure_ssl_certificates_for_litellm_openai_based_clients() -> None:
+    """
+    Ensure SSL certificates configuration for LiteLLM based on environment
+    variables for clients that are utilizing OpenAI's clients from
+    `openai` library.
+
+    The ssl configuration is ensured by setting `litellm.client_session` and
+    `litellm.aclient_session` if not previously set.
+    """
+    client_args = {}
+
+    ssl_verify = _get_ssl_verify()
+    ssl_certificate = _get_ssl_cert()
+
+    structlogger.debug(
+        "ensure_ssl_certificates_for_litellm_openai_based_clients",
+        ssl_verify=ssl_verify,
+        ssl_certificate=ssl_certificate,
+    )
+
+    if ssl_verify is not None:
+        client_args["verify"] = ssl_verify
+    if ssl_certificate is not None:
+        client_args["cert"] = ssl_certificate
+
+    if client_args and not isinstance(litellm.aclient_session, httpx.AsyncClient):
+        litellm.aclient_session = httpx.AsyncClient(**client_args)
+    if client_args and not isinstance(litellm.client_session, httpx.Client):
+        litellm.client_session = httpx.Client(**client_args)
+
+
+def _get_ssl_verify() -> Optional[Union[bool, str]]:
+    """
+    Environment variable priority (ssl verify):
+    1. `RASA_CA_BUNDLE`: Preferred for SSL verification.
+    2. `REQUESTS_CA_BUNDLE`: Deprecated; use `RASA_CA_BUNDLE_ENV_VAR` instead.
+    3. `SSL_VERIFY`: Fallback for SSL verification.
+
+    Returns:
+        Path to a self-signed SSL certificate or None if no SSL certificate is found.
+    """
+    if os.environ.get(REQUESTS_CA_BUNDLE_ENV_VAR) and os.environ.get(
+        RASA_CA_BUNDLE_ENV_VAR
+    ):
+        raise_deprecation_warning(
+            "Both REQUESTS_CA_BUNDLE and RASA_CA_BUNDLE environment variables are set. "
+            "RASA_CA_BUNDLE will be used as the SSL verification path.\n"
+            "Support of the REQUESTS_CA_BUNDLE environment variable is deprecated and "
+            "will be removed in Rasa Pro 4.0.0. Please set the RASA_CA_BUNDLE "
+            "environment variable instead."
+        )
+    elif os.environ.get(REQUESTS_CA_BUNDLE_ENV_VAR):
+        raise_deprecation_warning(
+            "Support of the REQUESTS_CA_BUNDLE environment variable is deprecated and "
+            "will be removed in Rasa Pro 4.0.0. Please set the RASA_CA_BUNDLE "
+            "environment variable instead."
+        )
+
+    return (
+        os.environ.get(RASA_CA_BUNDLE_ENV_VAR)
+        # Deprecated
+        or os.environ.get(REQUESTS_CA_BUNDLE_ENV_VAR)
+        # From LiteLLM, use as a fallback
+        or os.environ.get(LITELLM_SSL_VERIFY_ENV_VAR)
+        or None
+    )
+
+
+def _get_ssl_cert() -> Optional[str]:
+    """
+    Environment variable priority (ssl certificate):
+    1. `RASA_SSL_CERTIFICATE`: Preferred for client certificate.
+    2. `SSL_CERTIFICATE`: Fallback for client certificate.
+
+    Returns:
+        Path to a SSL certificate or None if no SSL certificate is found.
+    """
+    return (
+        os.environ.get(RASA_SSL_CERTIFICATE_ENV_VAR)
+        # From LiteLLM, use as a fallback
+        or os.environ.get(LITELLM_SSL_CERTIFICATE_ENV_VAR)
+        or None
+    )