rasa-pro 3.9.17__py3-none-any.whl → 3.10.3__py3-none-any.whl

rasa/shared/providers/_configs/default_litellm_client_config.py

@@ -0,0 +1,130 @@
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict
+
+import structlog
+
+from rasa.shared.constants import (
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.utils import (
+    validate_required_keys,
+    validate_forbidden_keys,
+    resolve_aliases,
+    raise_deprecation_warnings,
+)
+import rasa.shared.utils.cli
+
+structlogger = structlog.get_logger()
+
+
+DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
+    # Timeout aliases
+    REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+}
+
+REQUIRED_KEYS = [MODEL_CONFIG_KEY, PROVIDER_CONFIG_KEY]
+
+FORBIDDEN_KEYS = [
+    STREAM_CONFIG_KEY,
+    N_REPHRASES_CONFIG_KEY,
+]
+
+
+@dataclass
+class DefaultLiteLLMClientConfig:
+    """Parses configuration for default 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
+    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(
+                "default_litellm_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(
+                "default_litellm_client_config.validation_error",
+                message=message,
+                provider=self.provider,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "DefaultLiteLLMClientConfig":
+        """
+        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)
+        # Raise error for using `model_name` instead instead of `model`
+        cls.check_and_error_for_model_name_in_config(config)
+        # 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 = DefaultLiteLLMClientConfig(
+            # Required parameters
+            model=config.pop(MODEL_CONFIG_KEY),
+            provider=config.pop(PROVIDER_CONFIG_KEY),
+            # 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)
+
+    @staticmethod
+    def check_and_error_for_model_name_in_config(config: Dict[str, Any]) -> None:
+        """Check for usage of deprecated model_name and raise an error if found."""
+        if config.get(MODEL_NAME_CONFIG_KEY) and not config.get(MODEL_CONFIG_KEY):
+            event_info = (
+                f"Unsupported parameter - {MODEL_NAME_CONFIG_KEY} is set. Please use "
+                f"{MODEL_CONFIG_KEY} instead."
+            )
+            structlogger.error(
+                "default_litellm_client_config.unsupported_parameter_in_config",
+                event_info=event_info,
+                config=config,
+            )
+            rasa.shared.utils.cli.print_error_and_exit(event_info)

rasa/shared/providers/_configs/huggingface_local_embedding_client_config.py

@@ -0,0 +1,234 @@
+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,
+    RASA_TYPE_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY,
+    HUGGINGFACE_MULTIPROCESS_CONFIG_KEY,
+    HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY,
+    HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY,
+    HUGGINGFACE_MODEL_KWARGS_CONFIG_KEY,
+    HUGGINGFACE_ENCODE_KWARGS_CONFIG_KEY,
+    HUGGINGFACE_LOCAL_EMBEDDING_CACHING_FOLDER,
+    PROVIDER_CONFIG_KEY,
+    HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
+    TIMEOUT_CONFIG_KEY,
+    REQUEST_TIMEOUT_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.utils import (
+    resolve_aliases,
+    raise_deprecation_warnings,
+    validate_required_keys,
+)
+from rasa.shared.utils.io import raise_deprecation_warning
+
+structlogger = structlog.get_logger()
+
+DEPRECATED_HUGGINGFACE_TYPE = "huggingface"
+
+DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING = {
+    # Provider aliases
+    RASA_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    LANGCHAIN_TYPE_CONFIG_KEY: PROVIDER_CONFIG_KEY,
+    # Model name aliases
+    MODEL_NAME_CONFIG_KEY: MODEL_CONFIG_KEY,
+    # Timeout aliases
+    REQUEST_TIMEOUT_CONFIG_KEY: TIMEOUT_CONFIG_KEY,
+}
+
+REQUIRED_KEYS = [MODEL_CONFIG_KEY, PROVIDER_CONFIG_KEY]
+
+
+@dataclass
+class HuggingFaceLocalEmbeddingClientConfig:
+    """Parses configuration for HuggingFace local embeddings 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 `huggingface_local` or
+              `huggingface` (deprecated).
+    """
+
+    model: str
+
+    multi_process: Optional[bool]
+    cache_folder: Optional[str]
+    show_progress: Optional[bool]
+
+    # Provider is not actually used by sentence-transformers, but we define
+    # it here because it's used as a switch denominator for HuggingFace
+    # local embedding client.
+    provider: str = HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER
+
+    model_kwargs: dict = field(default_factory=dict)
+    encode_kwargs: dict = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if self.provider != HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER:
+            message = (
+                f"API type must be set to '{HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER}'."
+            )
+            structlogger.error(
+                "huggingface_local_embeddings_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(
+                "huggingface_local_embeddings_client_config.validation_error",
+                message=message,
+                model=self.model,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "HuggingFaceLocalEmbeddingClientConfig":
+        """
+        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 usage of deprecated switching key and value:
+        # 1. type: huggingface
+        # 2. _type: huggingface
+        _raise_deprecation_warning_for_huggingface_deprecated_switch_value(config)
+        # Check for other deprecated keys
+        raise_deprecation_warnings(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+        # Resolve any potential aliases
+        config = cls.resolve_config_aliases(config)
+        # Validate that required keys are set
+        validate_required_keys(config, REQUIRED_KEYS)
+        this = HuggingFaceLocalEmbeddingClientConfig(
+            # Required parameters
+            model=config.pop(MODEL_CONFIG_KEY),
+            provider=config.pop(PROVIDER_CONFIG_KEY),
+            # Optional
+            multi_process=config.pop(HUGGINGFACE_MULTIPROCESS_CONFIG_KEY, False),
+            cache_folder=config.pop(
+                HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY,
+                str(HUGGINGFACE_LOCAL_EMBEDDING_CACHING_FOLDER),
+            ),
+            show_progress=config.pop(HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY, False),
+            model_kwargs=config.pop(HUGGINGFACE_MODEL_KWARGS_CONFIG_KEY, {}),
+            encode_kwargs=config.pop(HUGGINGFACE_ENCODE_KWARGS_CONFIG_KEY, {}),
+        )
+        return this
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        return asdict(self)
+
+    @staticmethod
+    def resolve_config_aliases(config: Dict[str, Any]) -> Dict[str, Any]:
+        config = _resolve_huggingface_deprecated_switch_value(config)
+        return resolve_aliases(config, DEPRECATED_ALIASES_TO_STANDARD_KEY_MAPPING)
+
+
+def is_huggingface_local_config(config: dict) -> bool:
+    """Check whether the configuration is meant to configure
+    a local HuggingFace embedding client.
+    """
+    # Hugging face special deprecated cases:
+    # 1. type: huggingface
+    # 2. _type: huggingface
+    # If the deprecated setting is detected resolve both alias key and key
+    # value. This would mean that the configurations above will be
+    # transformed to:
+    # provider: huggingface_local
+    config = HuggingFaceLocalEmbeddingClientConfig.resolve_config_aliases(config)
+
+    # Case: Configuration contains `provider: huggingface_local`
+    if config.get(PROVIDER_CONFIG_KEY) in [
+        HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
+    ]:
+        return True
+
+    return False
+
+
+def _raise_deprecation_warning_for_huggingface_deprecated_switch_value(
+    config: dict,
+) -> None:
+    deprecated_switch_keys = [RASA_TYPE_CONFIG_KEY, LANGCHAIN_TYPE_CONFIG_KEY]
+    deprecation_message = (
+        f"Configuration "
+        f"`{{deprecated_switch_key}}: {DEPRECATED_HUGGINGFACE_TYPE}` "
+        f"is deprecated and will be removed in 4.0.0. "
+        f"Please use "
+        f"`{PROVIDER_CONFIG_KEY}: {HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER}` "
+        f"instead."
+    )
+    for deprecated_switch_key in deprecated_switch_keys:
+        if (
+            deprecated_switch_key in config
+            and config[deprecated_switch_key] == DEPRECATED_HUGGINGFACE_TYPE
+        ):
+            raise_deprecation_warning(
+                message=deprecation_message.format(
+                    deprecated_switch_key=deprecated_switch_key
+                )
+            )
+
+
+def _resolve_huggingface_deprecated_switch_value(config: dict) -> dict:
+    """
+    Resolve use of deprecated switching mechanism for HuggingFace local
+    embedding client.
+
+    The following settings (key + value) are deprecated:
+    1. `type: huggingface`
+    2. `_type: huggingface`
+    in favor of `provider: huggingface_local`.
+
+
+    Args:
+        config: given config
+
+    Returns:
+        New config with resolved switch mechanism
+
+    """
+    config = config.copy()
+
+    deprecated_switch_keys = [RASA_TYPE_CONFIG_KEY, LANGCHAIN_TYPE_CONFIG_KEY]
+    debug_message = (
+        f"Switching "
+        f"`{{deprecated_switch_key}}: {DEPRECATED_HUGGINGFACE_TYPE}` "
+        f"to `{PROVIDER_CONFIG_KEY}: {HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER}`."
+    )
+
+    for deprecated_switch_key in deprecated_switch_keys:
+        if (
+            deprecated_switch_key in config
+            and config[deprecated_switch_key] == DEPRECATED_HUGGINGFACE_TYPE
+        ):
+            # Update configuration with new switch mechanism
+            config[PROVIDER_CONFIG_KEY] = HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER
+            # Pop the deprecated key used
+            config.pop(deprecated_switch_key, None)
+
+            structlogger.debug(
+                "HuggingFaceLocalEmbeddingClientConfig"
+                "._resolve_huggingface_deprecated_switch_value",
+                message=debug_message.format(
+                    deprecated_switch_key=deprecated_switch_key
+                ),
+                new_config=config,
+            )
+
+    return config

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_PROVIDER,
+    OPENAI_API_TYPE,
+)
+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/self_hosted_llm_client_config.py

@@ -0,0 +1,171 @@
+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,
+)
+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
+    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),
+            # 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