rasa-pro 3.11.0__py3-none-any.whl → 3.11.0a1__py3-none-any.whl

rasa/shared/providers/llm/_base_litellm_client.py

@@ -1,7 +1,7 @@
-import logging
 from abc import abstractmethod
 from typing import Dict, List, Any, Union
 
+import logging
 import structlog
 from litellm import (
     completion,
@@ -9,7 +9,6 @@ from litellm import (
     validate_environment,
 )
 
-from rasa.shared.constants import API_BASE_CONFIG_KEY, API_KEY
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -19,7 +18,7 @@ from rasa.shared.providers._ssl_verification_utils import (
     ensure_ssl_certificates_for_litellm_openai_based_clients,
 )
 from rasa.shared.providers.llm.llm_response import LLMResponse, LLMUsage
-from rasa.shared.utils.io import suppress_logs, resolve_environment_variables
+from rasa.shared.utils.io import suppress_logs
 
 structlogger = structlog.get_logger()
 
@@ -30,7 +29,8 @@ logging.getLogger("LiteLLM").setLevel(logging.WARNING)
 
 
 class _BaseLiteLLMClient:
-    """An abstract base class for LiteLLM clients.
+    """
+    An abstract base class for LiteLLM clients.
 
     This class defines the interface and common functionality for all clients
     based on LiteLLM.
@@ -99,14 +99,11 @@ class _BaseLiteLLMClient:
             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,
-            api_key=self._litellm_extra_parameters.get(API_KEY),
-            api_base=self._litellm_extra_parameters.get(API_BASE_CONFIG_KEY),
-        )
+        validation_info = validate_environment(self._litellm_model_name)
         if missing_environment_variables := validation_info.get(
             _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY
         ):
@@ -121,65 +118,61 @@ class _BaseLiteLLMClient:
             )
             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)
+
     @suppress_logs(log_level=logging.WARNING)
     def completion(self, messages: Union[List[str], str]) -> LLMResponse:
-        """Synchronously generate completions for given list of messages.
+        """
+        Synchronously generate completions for given list of messages.
 
         Args:
             messages: List of messages or a single message to generate the
                 completion for.
-
         Returns:
             List of message completions.
-
         Raises:
             ProviderClientAPIException: If the API request fails.
         """
         try:
             formatted_messages = self._format_messages(messages)
-            arguments = resolve_environment_variables(self._completion_fn_args)
-            response = completion(messages=formatted_messages, **arguments)
+            response = completion(
+                messages=formatted_messages, **self._completion_fn_args
+            )
             return self._format_response(response)
         except Exception as e:
             raise ProviderClientAPIException(e)
 
     @suppress_logs(log_level=logging.WARNING)
     async def acompletion(self, messages: Union[List[str], str]) -> LLMResponse:
-        """Asynchronously generate completions for given list of messages.
+        """
+        Asynchronously generate completions for given list of messages.
 
         Args:
             messages: List of messages or a single message to generate the
                 completion for.
-
         Returns:
             List of message completions.
-
         Raises:
             ProviderClientAPIException: If the API request fails.
         """
         try:
             formatted_messages = self._format_messages(messages)
-            arguments = resolve_environment_variables(self._completion_fn_args)
-            response = await acompletion(messages=formatted_messages, **arguments)
+            response = await acompletion(
+                messages=formatted_messages, **self._completion_fn_args
+            )
             return self._format_response(response)
         except Exception as e:
-            message = ""
-            from rasa.shared.providers.llm.self_hosted_llm_client import (
-                SelfHostedLLMClient,
-            )
-
-            if isinstance(self, SelfHostedLLMClient):
-                message = (
-                    "If you are using 'provider=self-hosted' to call a hosted vllm "
-                    "server make sure your config is correctly setup. You should have "
-                    "the following mandatory keys in your config: "
-                    "provider=self-hosted; "
-                    "model='<your-vllm-model-name>'; "
-                    "api_base='your-hosted-vllm-serv'."
-                    "In case you are getting OpenAI connection errors, such as missing "
-                    "API key, your configuration is incorrect."
-                )
-            raise ProviderClientAPIException(e, message)
+            raise ProviderClientAPIException(e)
 
     def _format_messages(self, messages: Union[List[str], str]) -> List[Dict[str, str]]:
         """Formats messages (or a single message) to OpenAI format."""
@@ -221,35 +214,10 @@ class _BaseLiteLLMClient:
         )
         return formatted_response
 
-    def _format_text_completion_response(self, response: Any) -> LLMResponse:
-        """Parses the LiteLLM text completion response to Rasa format."""
-        formatted_response = LLMResponse(
-            id=response.id,
-            created=response.created,
-            choices=[choice.text for choice in response.choices],
-            model=response.model,
-        )
-        if (usage := response.usage) is not None:
-            prompt_tokens = (
-                num_tokens
-                if isinstance(num_tokens := usage.prompt_tokens, (int, float))
-                else 0
-            )
-            completion_tokens = (
-                num_tokens
-                if isinstance(num_tokens := usage.completion_tokens, (int, float))
-                else 0
-            )
-            formatted_response.usage = LLMUsage(prompt_tokens, completion_tokens)
-        structlogger.debug(
-            "base_litellm_client.formatted_response",
-            formatted_response=formatted_response.to_dict(),
-        )
-        return formatted_response
-
     @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

rasa/shared/providers/llm/azure_openai_llm_client.py

@@ -17,7 +17,6 @@ from rasa.shared.constants import (
     OPENAI_API_KEY_ENV_VAR,
     AZURE_API_TYPE_ENV_VAR,
     AZURE_OPENAI_PROVIDER,
-    API_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
 from rasa.shared.providers._configs.azure_openai_client_config import (
@@ -30,7 +29,8 @@ structlogger = structlog.get_logger()
 
 
 class AzureOpenAILLMClient(_BaseLiteLLMClient):
-    """A client for interfacing with Azure's OpenAI LLM deployments.
+    """
+    A client for interfacing with Azure's OpenAI LLM deployments.
 
     Parameters:
         deployment (str): The deployment name.
@@ -80,7 +80,11 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
             or os.getenv(OPENAI_API_VERSION_ENV_VAR)
         )
 
-        self._api_key_env_var = self._resolve_api_key_env_var()
+        # API key can be set through OPENAI_API_KEY too,
+        # because of the backward compatibility
+        self._api_key = os.getenv(AZURE_API_KEY_ENV_VAR) or os.getenv(
+            OPENAI_API_KEY_ENV_VAR
+        )
 
         # Not used by LiteLLM, here for backward compatibility
         self._api_type = (
@@ -113,6 +117,11 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
                 "env_var": AZURE_API_VERSION_ENV_VAR,
                 "deprecated_var": OPENAI_API_VERSION_ENV_VAR,
             },
+            "API Key": {
+                "current_value": self._api_key,
+                "env_var": AZURE_API_KEY_ENV_VAR,
+                "deprecated_var": OPENAI_API_KEY_ENV_VAR,
+            },
         }
 
         deprecation_warning_message = (
@@ -145,51 +154,10 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
                     )
                 raise_deprecation_warning(message=message)
 
-    def _resolve_api_key_env_var(self) -> str:
-        """Resolves the environment variable to use for the API key.
-
-        Returns:
-            str: The env variable in dollar syntax format to use for the API key.
-        """
-        if API_KEY in self._extra_parameters:
-            # API key is set to an env var in the config itself
-            # in case the model is defined in the endpoints.yml
-            return self._extra_parameters[API_KEY]
-
-        if os.getenv(AZURE_API_KEY_ENV_VAR) is not None:
-            return "${AZURE_API_KEY}"
-
-        if os.getenv(OPENAI_API_KEY_ENV_VAR) is not None:
-            # API key can be set through OPENAI_API_KEY too,
-            # because of the backward compatibility
-            raise_deprecation_warning(
-                message=(
-                    f"Usage of '{OPENAI_API_KEY_ENV_VAR}' environment variable "
-                    "for setting the API key for Azure OpenAI "
-                    "client is deprecated and will be removed "
-                    f"in 4.0.0. Please use '{AZURE_API_KEY_ENV_VAR}' "
-                    "environment variable."
-                )
-            )
-            return "${OPENAI_API_KEY}"
-
-        structlogger.error(
-            "azure_openai_llm_client.api_key_not_set",
-            event_info=(
-                "API key not set, it is required for API calls. "
-                f"Set it either via the environment variable"
-                f"'{AZURE_API_KEY_ENV_VAR}' or directly"
-                f"via the config key '{API_KEY}'."
-            ),
-        )
-        raise ProviderClientValidationError(
-            f"Missing required environment variable/config key '{API_KEY}' for "
-            f"API calls."
-        )
-
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "AzureOpenAILLMClient":
-        """Initializes the client from given configuration.
+        """
+        Initializes the client from given configuration.
 
         Args:
             config (Dict[str, Any]): Configuration.
@@ -244,17 +212,23 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
 
     @property
     def model(self) -> Optional[str]:
-        """Returns the name of the model deployed on Azure."""
+        """
+        Returns the name of the model deployed on Azure.
+        """
         return self._model
 
     @property
     def api_base(self) -> Optional[str]:
-        """Returns the API base URL for the Azure OpenAI llm client."""
+        """
+        Returns the API base URL for the Azure OpenAI llm client.
+        """
         return self._api_base
 
     @property
     def api_version(self) -> Optional[str]:
-        """Returns the API version for the Azure OpenAI llm client."""
+        """
+        Returns the API version for the Azure OpenAI llm client.
+        """
         return self._api_version
 
     @property
@@ -287,7 +261,7 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
             {
                 "api_base": self.api_base,
                 "api_version": self.api_version,
-                "api_key": self._api_key_env_var,
+                "api_key": self._api_key,
             }
         )
         return fn_args
@@ -331,6 +305,11 @@ class AzureOpenAILLMClient(_BaseLiteLLMClient):
                 "env_var": None,
                 "config_key": DEPLOYMENT_CONFIG_KEY,
             },
+            "API Key": {
+                "current_value": self._api_key,
+                "env_var": AZURE_API_KEY_ENV_VAR,
+                "config_key": None,
+            },
         }
 
         missing_settings = [

rasa/shared/providers/llm/default_litellm_llm_client.py

@@ -1,13 +1,8 @@
 from typing import Dict, Any
 
-from rasa.shared.constants import (
-    AWS_BEDROCK_PROVIDER,
-    AWS_SAGEMAKER_PROVIDER,
-)
 from rasa.shared.providers._configs.default_litellm_client_config import (
     DefaultLiteLLMClientConfig,
 )
-from rasa.shared.providers._utils import validate_aws_setup_for_litellm_clients
 from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
 
 
@@ -87,22 +82,3 @@ class DefaultLiteLLMClient(_BaseLiteLLMClient):
         to the client provider and deployed model.
         """
         return self._extra_parameters
-
-    def validate_client_setup(self) -> None:
-        # TODO: Temporarily change the environment variable validation for AWS setup
-        #       (Bedrock and SageMaker) until resolved by either:
-        #       1. An update from the LiteLLM package addressing the issue.
-        #       2. The implementation of a Bedrock client on our end.
-        #       ---
-        #       This fix ensures a consistent user experience for Bedrock (and
-        #       SageMaker) in Rasa by allowing AWS secrets to be provided as extra
-        #       parameters without triggering validation errors due to missing AWS
-        #       environment variables.
-        if self.provider.lower() in [AWS_BEDROCK_PROVIDER, AWS_SAGEMAKER_PROVIDER]:
-            validate_aws_setup_for_litellm_clients(
-                self._litellm_model_name,
-                self._litellm_extra_parameters,
-                "default_litellm_llm_client",
-            )
-        else:
-            super().validate_client_setup()

rasa/shared/providers/llm/self_hosted_llm_client.py

@@ -4,20 +4,15 @@ from litellm import (
     atext_completion,
 )
 import logging
-import os
 import structlog
 
-from rasa.shared.constants import (
-    SELF_HOSTED_VLLM_PREFIX,
-    SELF_HOSTED_VLLM_API_KEY_ENV_VAR,
-    API_KEY,
-)
+from rasa.shared.constants import OPENAI_PROVIDER
 from rasa.shared.providers._configs.self_hosted_llm_client_config import (
     SelfHostedLLMClientConfig,
 )
 from rasa.shared.exceptions import ProviderClientAPIException
 from rasa.shared.providers.llm._base_litellm_client import _BaseLiteLLMClient
-from rasa.shared.providers.llm.llm_response import LLMResponse
+from rasa.shared.providers.llm.llm_response import LLMResponse, LLMUsage
 from rasa.shared.utils.io import suppress_logs
 
 structlogger = structlog.get_logger()
@@ -62,8 +57,6 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
         self._api_version = api_version
         self._use_chat_completions_endpoint = use_chat_completions_endpoint
         self._extra_parameters = kwargs or {}
-        if self._extra_parameters.get(API_KEY) is None:
-            self._apply_dummy_api_key_if_missing()
 
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "SelfHostedLLMClient":
@@ -162,10 +155,10 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
         """Returns the value of LiteLLM's model parameter to be used in
         completion/acompletion in LiteLLM format:
 
-        <hosted_vllm>/<model or deployment name>
+        <openai>/<model or deployment name>
         """
-        if self.model and f"{SELF_HOSTED_VLLM_PREFIX}/" not in self.model:
-            return f"{SELF_HOSTED_VLLM_PREFIX}/{self.model}"
+        if self.model and f"{OPENAI_PROVIDER}/" not in self.model:
+            return f"{OPENAI_PROVIDER}/{self.model}"
         return self.model
 
     @property
@@ -261,9 +254,28 @@ class SelfHostedLLMClient(_BaseLiteLLMClient):
             return super().completion(messages)
         return self._text_completion(messages)
 
-    @staticmethod
-    def _apply_dummy_api_key_if_missing() -> None:
-        if not os.getenv(SELF_HOSTED_VLLM_API_KEY_ENV_VAR):
-            os.environ[SELF_HOSTED_VLLM_API_KEY_ENV_VAR] = (
-                "dummy_self_hosted_llm_api_key"
+    def _format_text_completion_response(self, response: Any) -> LLMResponse:
+        """Parses the LiteLLM text completion response to Rasa format."""
+        formatted_response = LLMResponse(
+            id=response.id,
+            created=response.created,
+            choices=[choice.text for choice in response.choices],
+            model=response.model,
+        )
+        if (usage := response.usage) is not None:
+            prompt_tokens = (
+                num_tokens
+                if isinstance(num_tokens := usage.prompt_tokens, (int, float))
+                else 0
             )
+            completion_tokens = (
+                num_tokens
+                if isinstance(num_tokens := usage.completion_tokens, (int, float))
+                else 0
+            )
+            formatted_response.usage = LLMUsage(prompt_tokens, completion_tokens)
+        structlogger.debug(
+            "base_litellm_client.formatted_response",
+            formatted_response=formatted_response.to_dict(),
+        )
+        return formatted_response

rasa/shared/providers/mappings.py

@@ -5,8 +5,6 @@ from rasa.shared.constants import (
     HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER,
     OPENAI_PROVIDER,
     SELF_HOSTED_PROVIDER,
-    RASA_PROVIDER,
-    SELF_HOSTED_VLLM_PREFIX,
 )
 from rasa.shared.providers.embedding.azure_openai_embedding_client import (
     AzureOpenAIEmbeddingClient,
@@ -26,7 +24,6 @@ from rasa.shared.providers.llm.default_litellm_llm_client import DefaultLiteLLMC
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.providers.llm.openai_llm_client import OpenAILLMClient
 from rasa.shared.providers.llm.self_hosted_llm_client import SelfHostedLLMClient
-from rasa.shared.providers.llm.rasa_llm_client import RasaLLMClient
 from rasa.shared.providers._configs.azure_openai_client_config import (
     AzureOpenAIClientConfig,
 )
@@ -40,15 +37,12 @@ from rasa.shared.providers._configs.openai_client_config import OpenAIClientConf
 from rasa.shared.providers._configs.self_hosted_llm_client_config import (
     SelfHostedLLMClientConfig,
 )
-from rasa.shared.providers._configs.rasa_llm_client_config import RasaLLMClientConfig
-
 from rasa.shared.providers._configs.client_config import ClientConfig
 
 _provider_to_llm_client_mapping: Dict[str, Type[LLMClient]] = {
     OPENAI_PROVIDER: OpenAILLMClient,
     AZURE_OPENAI_PROVIDER: AzureOpenAILLMClient,
     SELF_HOSTED_PROVIDER: SelfHostedLLMClient,
-    RASA_PROVIDER: RasaLLMClient,
 }
 
 _provider_to_embedding_client_mapping: Dict[str, Type[EmbeddingClient]] = {
@@ -62,15 +56,6 @@ _provider_to_client_config_class_mapping: Dict[str, Type] = {
     AZURE_OPENAI_PROVIDER: AzureOpenAIClientConfig,
     HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER: HuggingFaceLocalEmbeddingClientConfig,
     SELF_HOSTED_PROVIDER: SelfHostedLLMClientConfig,
-    RASA_PROVIDER: RasaLLMClientConfig,
-}
-
-
-_provider_to_prefix_mapping: Dict[str, str] = {
-    # Specify the provider name as the key and its corresponding prefix as the value
-    # for providers where the prefix differs from the provider name.
-    SELF_HOSTED_PROVIDER: SELF_HOSTED_VLLM_PREFIX,
-    RASA_PROVIDER: OPENAI_PROVIDER,
 }
 
 
@@ -88,7 +73,3 @@ def get_client_config_class_from_provider(provider: str) -> Type[ClientConfig]:
     return _provider_to_client_config_class_mapping.get(
         provider, DefaultLiteLLMClientConfig
     )
-
-
-def get_prefix_from_provider(provider: str) -> str:
-    return _provider_to_prefix_mapping.get(provider, provider)

rasa/shared/utils/common.py

@@ -3,16 +3,14 @@ import functools
 import importlib
 import inspect
 import logging
-import os
 import pkgutil
 import sys
 from types import ModuleType
-from typing import Sequence, Text, Dict, Optional, Any, List, Callable, Collection, Type
+from typing import Text, Dict, Optional, Any, List, Callable, Collection, Type
 
 import rasa.shared.utils.io
-from rasa.exceptions import MissingDependencyException
 from rasa.shared.constants import DOCS_URL_MIGRATION_GUIDE
-from rasa.shared.exceptions import ProviderClientValidationError, RasaException
+from rasa.shared.exceptions import RasaException
 
 logger = logging.getLogger(__name__)
 
@@ -192,14 +190,6 @@ def mark_as_experimental_feature(feature_name: Text) -> None:
     )
 
 
-def mark_as_beta_feature(feature_name: Text) -> None:
-    """Warns users that they are using a beta feature."""
-    logger.warning(
-        f"🔬 Beta Feature: {feature_name} is in beta. It may have unexpected "
-        "behaviour and might be changed in the future."
-    )
-
-
 def arguments_of(func: Callable) -> List[Text]:
     """Return the parameters of the function `func` as a list of names."""
     import inspect
@@ -297,28 +287,3 @@ def warn_and_exit_if_module_path_contains_rasa_plus(
             docs=DOCS_URL_MIGRATION_GUIDE,
         )
         sys.exit(1)
-
-
-def validate_environment(
-    required_env_vars: Sequence[str],
-    required_packages: Sequence[str],
-    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
-         component_name: component name that needs the requirements
-    """
-    for e in required_env_vars:
-        if not os.environ.get(e):
-            raise ProviderClientValidationError(
-                f"Missing environment variable for {component_name}: {e}"
-            )
-    for p in required_packages:
-        try:
-            importlib.import_module(p)
-        except ImportError:
-            raise MissingDependencyException(
-                f"Missing package for {component_name}: {p}"
-            )

rasa/shared/utils/io.py

@@ -1,19 +1,18 @@
+from collections import OrderedDict
+from functools import wraps
+from hashlib import md5
 import asyncio
 import errno
 import glob
 import json
 import logging
 import os
-import random
-import string
 import sys
-import warnings
-from collections import OrderedDict
-from functools import wraps
-from hashlib import md5
 from pathlib import Path
 from typing import Any, cast, Callable, Dict, List, Optional, Text, Type, TypeVar, Union
-
+import warnings
+import random
+import string
 import portalocker
 
 from rasa.shared.constants import (
@@ -476,24 +475,3 @@ def suppress_logs(log_level: int = logging.WARNING) -> Callable[[F], F]:
             return cast(F, sync_wrapper)
 
     return decorator
-
-
-def resolve_environment_variables(
-    value: Union[str, List[Any], Dict[str, Any]],
-) -> Union[str, List[Any], Dict[str, Any]]:
-    """Resolve environment variables in a string, list, or dictionary.
-
-    Args:
-        value: The value to resolve environment variables in.
-
-    Returns:
-        The value with environment variables resolved.
-    """
-    if isinstance(value, str):
-        return os.path.expandvars(value)
-    elif isinstance(value, list):
-        return [resolve_environment_variables(item) for item in value]
-    elif isinstance(value, dict):
-        return {key: resolve_environment_variables(val) for key, val in value.items()}
-    else:
-        return value