rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc2__py3-none-any.whl

rasa/shared/providers/_configs/litellm_router_client_config.py

@@ -0,0 +1,200 @@
+import copy
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+import structlog
+from rasa.shared.constants import (
+    ROUTER_CONFIG_KEY,
+    MODELS_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    LITELLM_PARAMS_KEY,
+    PROVIDER_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_LIST_KEY,
+)
+from rasa.shared.providers._configs.model_group_config import (
+    ModelGroupConfig,
+    ModelConfig,
+)
+from rasa.shared.providers.mappings import get_prefix_from_provider
+from rasa.shared.utils.llm import DEPLOYMENT_CENTRIC_PROVIDERS
+
+
+structlogger = structlog.get_logger()
+
+_LITELLM_UNSUPPORTED_KEYS = [
+    PROVIDER_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    API_TYPE_CONFIG_KEY,
+]
+
+
+@dataclass
+class LiteLLMRouterClientConfig:
+    """Parses configuration for a LiteLLM Router client. The configuration is expected
+    to be in the following format:
+
+    {
+        "id": "model_group_id",
+        "models": [
+            {
+                "provider": "provider_name",
+                "model": "model_name",
+                "api_base": "api_base",
+                "api_key": "api_key",
+                "api_version": "api_version",
+            },
+            {
+                "provider": "provider_name",
+                "model": "model_name",
+            },
+        "router": {}
+    }
+
+    This configuration is converted into the LiteLLM required format:
+
+    {
+        "id": "model_group_id",
+        "model_list": [
+            {
+                "model_name": "model_group_id",
+                "litellm_params": {
+                    "model": "provider_name/model_name",
+                    "api_base": "api_base",
+                    "api_key": "api_key",
+                    "api_version": "api_version",
+                },
+            },
+            {
+                "model_name": "model_group_id",
+                "litellm_params": {
+                    "model": "provider_name/model_name",
+                },
+            },
+        ],
+        "router": {},
+    }
+
+    Raises:
+        ValueError: If the configuration is missing required keys.
+    """
+
+    _model_group_config: ModelGroupConfig
+    router: Dict[str, Any]
+    extra_parameters: dict = field(default_factory=dict)
+
+    @property
+    def model_group_id(self) -> str:
+        return self._model_group_config.model_group_id
+
+    @property
+    def models(self) -> List[ModelConfig]:
+        return self._model_group_config.models
+
+    @property
+    def litellm_model_list(self) -> List[Dict[str, Any]]:
+        return self._convert_models_to_litellm_model_list()
+
+    def __post_init__(self) -> None:
+        if not self.router:
+            message = "Router cannot be empty."
+            structlogger.error(
+                "litellm_router_client_config.validation_error",
+                message=message,
+                model_group_id=self._model_group_config.model_group_id,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "LiteLLMRouterClientConfig":
+        """Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            LiteLLMRouterClientConfig
+        """
+
+        model_group_config = ModelGroupConfig.from_dict(config)
+
+        # Copy config to avoid mutating the original
+        config_copy = copy.deepcopy(config)
+        # Pop the keys used by ModelGroupConfig
+        config_copy.pop(MODEL_GROUP_ID_CONFIG_KEY, None)
+        config_copy.pop(MODELS_CONFIG_KEY, None)
+        # Get the router settings
+        router_settings = config_copy.pop(ROUTER_CONFIG_KEY, None)
+        # The rest is considered as extra parameters
+        extra_parameters = config_copy
+
+        this = LiteLLMRouterClientConfig(
+            _model_group_config=model_group_config,
+            router=router_settings,
+            extra_parameters=extra_parameters,
+        )
+        return this
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = self._model_group_config.to_dict()
+        d[ROUTER_CONFIG_KEY] = self.router
+        if self.extra_parameters:
+            d.update(self.extra_parameters)
+        return d
+
+    def to_litellm_dict(self) -> dict:
+        litellm_model_list = self._convert_models_to_litellm_model_list()
+        d = {
+            **self.extra_parameters,
+            MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
+            MODEL_LIST_KEY: litellm_model_list,
+            ROUTER_CONFIG_KEY: self.router,
+        }
+        return d
+
+    def _convert_models_to_litellm_model_list(self) -> List[Dict[str, Any]]:
+        litellm_model_list = []
+
+        for model_config_object in self.models:
+            # Convert the model config to a dict representation
+            litellm_model_config = model_config_object.to_dict()
+
+            provider = litellm_model_config[PROVIDER_CONFIG_KEY]
+
+            # Get the litellm prefixing for the provider
+            prefix = get_prefix_from_provider(provider)
+
+            # Determine whether to use model or deployment key based on the provider.
+            litellm_model_name_without_prefix = (
+                litellm_model_config[DEPLOYMENT_CONFIG_KEY]
+                if provider in DEPLOYMENT_CENTRIC_PROVIDERS
+                else litellm_model_config[MODEL_CONFIG_KEY]
+            )
+
+            # Set 'model' to a provider prefixed model name e.g. openai/gpt-4
+            litellm_model_config[MODEL_CONFIG_KEY] = (
+                f"{prefix}/{litellm_model_name_without_prefix}"
+            )
+
+            # Remove parameters that are None and not supported by LiteLLM.
+            litellm_model_config = {
+                key: value
+                for key, value in litellm_model_config.items()
+                if key not in _LITELLM_UNSUPPORTED_KEYS and value is not None
+            }
+
+            litellm_model_list_item = {
+                MODEL_NAME_CONFIG_KEY: self.model_group_id,
+                LITELLM_PARAMS_KEY: litellm_model_config,
+            }
+
+            litellm_model_list.append(litellm_model_list_item)
+
+        return litellm_model_list

rasa/shared/providers/_configs/model_group_config.py

@@ -0,0 +1,167 @@
+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,
+    PROVIDER_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    MODELS_CONFIG_KEY,
+    MODEL_GROUPS_CONFIG_KEY,
+    EXTRA_PARAMETERS_KEY,
+)
+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

@@ -19,8 +19,8 @@ from rasa.shared.constants import (
     REQUEST_TIMEOUT_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
-    OPENAI_PROVIDER,
     OPENAI_API_TYPE,
+    OPENAI_PROVIDER,
 )
 from rasa.shared.providers._configs.utils import (
     resolve_aliases,

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

@@ -23,6 +23,7 @@ from rasa.shared.constants import (
     SELF_HOSTED_PROVIDER,
     USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
 )
+
 from rasa.shared.providers._configs.utils import (
     raise_deprecation_warnings,
     resolve_aliases,

rasa/shared/providers/_configs/utils.py

@@ -99,3 +99,19 @@ def validate_forbidden_keys(config: dict, forbidden_keys: list) -> None:
             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/embedding/_base_litellm_embedding_client.py

@@ -1,10 +1,12 @@
+import logging
 from abc import abstractmethod
 from typing import Any, Dict, List
 
 import litellm
-import logging
 import structlog
 from litellm import aembedding, embedding, validate_environment
+
+from rasa.shared.constants import API_BASE_CONFIG_KEY, API_KEY
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -17,7 +19,7 @@ from rasa.shared.providers.embedding.embedding_response import (
     EmbeddingResponse,
     EmbeddingUsage,
 )
-from rasa.shared.utils.io import suppress_logs
+from rasa.shared.utils.io import suppress_logs, resolve_environment_variables
 
 structlogger = structlog.get_logger()
 
@@ -25,8 +27,7 @@ _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY = "missing_keys"
 
 
 class _BaseLiteLLMEmbeddingClient:
-    """
-    An abstract base class for LiteLLM embedding clients.
+    """An abstract base class for LiteLLM embedding clients.
 
     This class defines the interface and common functionality for all clients
     based on LiteLLM.
@@ -81,11 +82,14 @@ class _BaseLiteLLMEmbeddingClient:
             ProviderClientValidationError if validation fails.
         """
         self._validate_environment_variables()
-        self._validate_api_key_not_in_config()
 
     def _validate_environment_variables(self) -> None:
         """Validate that the required environment variables are set."""
-        validation_info = validate_environment(self._litellm_model_name)
+        validation_info = validate_environment(
+            self._litellm_model_name,
+            api_key=self._litellm_extra_parameters.get(API_KEY),
+            api_base=self._litellm_extra_parameters.get(API_BASE_CONFIG_KEY),
+        )
         if missing_environment_variables := validation_info.get(
             _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY
         ):
@@ -100,21 +104,8 @@ class _BaseLiteLLMEmbeddingClient:
             )
             raise ProviderClientValidationError(event_info)
 
-    def _validate_api_key_not_in_config(self) -> None:
-        if "api_key" in self._litellm_extra_parameters:
-            event_info = (
-                "API Key is set through `api_key` extra parameter."
-                "Set API keys through environment variables."
-            )
-            structlogger.error(
-                "base_litellm_client.validate_api_key_not_in_config",
-                event_info=event_info,
-            )
-            raise ProviderClientValidationError(event_info)
-
     def validate_documents(self, documents: List[str]) -> None:
-        """
-        Validates a list of documents to ensure they are suitable for embedding.
+        """Validates a list of documents to ensure they are suitable for embedding.
 
         Args:
             documents: List of documents to be validated.
@@ -130,8 +121,7 @@ class _BaseLiteLLMEmbeddingClient:
 
     @suppress_logs(log_level=logging.WARNING)
     def embed(self, documents: List[str]) -> EmbeddingResponse:
-        """
-        Embeds a list of documents synchronously.
+        """Embeds a list of documents synchronously.
 
         Args:
             documents: List of documents to be embedded.
@@ -144,7 +134,8 @@ class _BaseLiteLLMEmbeddingClient:
         """
         self.validate_documents(documents)
         try:
-            response = embedding(input=documents, **self._embedding_fn_args)
+            arguments = resolve_environment_variables(self._embedding_fn_args)
+            response = embedding(input=documents, **arguments)
             return self._format_response(response)
         except Exception as e:
             raise ProviderClientAPIException(
@@ -153,8 +144,7 @@ class _BaseLiteLLMEmbeddingClient:
 
     @suppress_logs(log_level=logging.WARNING)
     async def aembed(self, documents: List[str]) -> EmbeddingResponse:
-        """
-        Embeds a list of documents asynchronously.
+        """Embeds a list of documents asynchronously.
 
         Args:
             documents: List of documents to be embedded.
@@ -167,7 +157,8 @@ class _BaseLiteLLMEmbeddingClient:
         """
         self.validate_documents(documents)
         try:
-            response = await aembedding(input=documents, **self._embedding_fn_args)
+            arguments = resolve_environment_variables(self._embedding_fn_args)
+            response = await aembedding(input=documents, **arguments)
             return self._format_response(response)
         except Exception as e:
             raise ProviderClientAPIException(
@@ -182,7 +173,6 @@ class _BaseLiteLLMEmbeddingClient:
         Raises:
             ValueError: If any response data is None.
         """
-
         # If data is not available (None), raise a ValueError
         if response.data is None:
             message = (
@@ -239,8 +229,7 @@ class _BaseLiteLLMEmbeddingClient:
 
     @staticmethod
     def _ensure_certificates() -> None:
-        """
-        Configures SSL certificates for LiteLLM. This method is invoked during
+        """Configures SSL certificates for LiteLLM. This method is invoked during
         client initialization.
 
         LiteLLM may utilize `openai` clients or other providers that require