rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/shared/providers/_configs/model_group_config.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import List, Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    API_BASE_CONFIG_KEY,
+    API_KEY,
+    API_TYPE_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    EXTRA_PARAMETERS_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    MODEL_GROUPS_CONFIG_KEY,
+    MODELS_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+)
+from rasa.shared.providers._configs._lite_llm_config.lite_llm_config_adapter import (
+    to_lite_llm_config,
+)
+from rasa.shared.providers.mappings import get_client_config_class_from_provider
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class ModelConfig:
+    """Parses the model config.
+
+    Raises:
+        ValueError: If the provider config key is missing in the config.
+    """
+
+    provider: str
+    model: Optional[str] = None
+    deployment: Optional[str] = None
+    api_base: Optional[str] = None
+    api_key: Optional[str] = None
+    api_version: Optional[str] = None
+    extra_parameters: dict = field(default_factory=dict)
+    # Retained for backward compatibility with older configurations,
+    # but intentionally not included in extra_parameters
+    api_type: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, config: dict) -> ModelConfig:
+        """Initializes a dataclass from the passed config. The provider config param is
+        used to determine the client config class to use. The client config class takes
+        care of resolving config aliases and throwing deprecation warnings.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            ModelConfig
+        """
+        from rasa.shared.utils.llm import get_provider_from_config
+
+        # Get the provider from config, this also inferring the provider from
+        # deprecated configurations
+        provider = get_provider_from_config(config)
+
+        # Retrieve the client configuration class for the specified provider.
+        client_config_clazz = get_client_config_class_from_provider(provider)
+
+        # Try to instantiate the config object in order to resolve deprecated
+        # aliases and throw deprecation warnings.
+        client_config_obj = client_config_clazz.from_dict(config)
+
+        # Convert back to dictionary and instantiate the ModelConfig object.
+        client_config = client_config_obj.to_dict()
+
+        # Check for provider after resolving all aliases
+        if PROVIDER_CONFIG_KEY not in client_config:
+            raise ValueError(
+                f"Missing required key '{PROVIDER_CONFIG_KEY}' in "
+                f"'{MODELS_CONFIG_KEY}' config."
+            )
+
+        return ModelConfig(
+            provider=client_config.pop(PROVIDER_CONFIG_KEY, None),
+            model=client_config.pop(MODEL_CONFIG_KEY, None),
+            deployment=client_config.pop(DEPLOYMENT_CONFIG_KEY, None),
+            api_type=client_config.pop(API_TYPE_CONFIG_KEY, None),
+            api_base=client_config.pop(API_BASE_CONFIG_KEY, None),
+            api_key=client_config.pop(API_KEY, None),
+            api_version=client_config.pop(API_VERSION_CONFIG_KEY, None),
+            extra_parameters=client_config,
+        )
+
+    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_KEY, None)
+        d.update(self.extra_parameters)
+
+        # Remove keys with None values
+        return {key: value for key, value in d.items() if value is not None}
+
+
+@dataclass
+class ModelGroupConfig:
+    """Parses the models config. The models config is a list of model configs.
+
+    Raises:
+        ValueError: If the model group ID is None or if the models list is empty.
+    """
+
+    model_group_id: str
+    models: List[ModelConfig]
+
+    def __post_init__(self) -> None:
+        if self.model_group_id is None:
+            message = "Model group ID cannot be set to None."
+            structlogger.error(
+                "model_group_config.validation_error",
+                message=message,
+                model_group_id=self.model_group_id,
+            )
+            raise ValueError(message)
+        if not self.models:
+            message = "Models cannot be empty."
+            structlogger.error(
+                "model_group_config.validation_error",
+                message=message,
+                model_group_id=self.model_group_id,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> ModelGroupConfig:
+        """Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            ModelGroupConfig
+        """
+        if MODELS_CONFIG_KEY not in config:
+            raise ValueError(
+                f"Missing required key '{MODELS_CONFIG_KEY}' in "
+                f"'{MODEL_GROUPS_CONFIG_KEY}' config."
+            )
+
+        models_config = [
+            ModelConfig.from_dict(model_config)
+            for model_config in config[MODELS_CONFIG_KEY]
+        ]
+
+        return cls(
+            model_group_id=config.get(MODEL_GROUP_ID_CONFIG_KEY),
+            models=models_config,
+        )
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = {
+            MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
+            MODELS_CONFIG_KEY: [model.to_dict() for model in self.models],
+        }
+        return d

rasa/shared/providers/_configs/openai_client_config.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    API_BASE_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+    OPENAI_API_BASE_CONFIG_KEY,
+    OPENAI_API_TYPE,
+    OPENAI_API_TYPE_CONFIG_KEY,
+    OPENAI_API_VERSION_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    PROVIDER_CONFIG_KEY,
+    RASA_TYPE_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+    STREAM_CONFIG_KEY,
+    TIMEOUT_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 = [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,75 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    API_BASE_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    RASA_PROVIDER,
+)
+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,178 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    API_BASE_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+    OPENAI_API_BASE_CONFIG_KEY,
+    OPENAI_API_TYPE_CONFIG_KEY,
+    OPENAI_API_VERSION_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    PROVIDER_CONFIG_KEY,
+    RASA_TYPE_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+    SELF_HOSTED_PROVIDER,
+    STREAM_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+    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