rasa-pro 3.14.0.dev20250922__py3-none-any.whl → 3.14.0rc2__py3-none-any.whl

rasa/nlu/extractors/mitie_entity_extractor.py

@@ -4,6 +4,9 @@ import logging
 import typing
 from typing import Any, Dict, List, Optional, Text, Type
 
+# importing mitie at module level to ensure error is raised if mitie is not installed
+import mitie
+
 import rasa.shared.utils.io
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe

rasa/nlu/extractors/spacy_entity_extractor.py

@@ -1,6 +1,9 @@
 import typing
 from typing import Any, Dict, List, Text, Type
 
+# importing spacy at module level to ensure error is raised if spacy is not installed
+import spacy  # noqa: F401
+
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource

rasa/nlu/featurizers/dense_featurizer/convert_featurizer.py

@@ -28,6 +28,7 @@ from rasa.nlu.tokenizers.tokenizer import Token, Tokenizer
 from rasa.shared.nlu.constants import ACTION_TEXT, TEXT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.io import raise_deprecation_warning
 
 logger = logging.getLogger(__name__)
 
@@ -101,6 +102,9 @@ class ConveRTFeaturizer(DenseFeaturizer, GraphComponent):
             name: An identifier for this featurizer.
             config: The configuration.
         """
+        raise_deprecation_warning(
+            "ConveRTFeaturizer is deprecated and will be removed in a future version."
+        )
         super().__init__(name=name, config=config)
 
         model_url = self._config["model_url"]

rasa/nlu/featurizers/dense_featurizer/lm_featurizer.py

@@ -23,6 +23,7 @@ from rasa.nlu.tokenizers.tokenizer import Token, Tokenizer
 from rasa.shared.nlu.constants import ACTION_TEXT, TEXT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils import train_utils
 from rasa.utils.tensorflow.model_data import ragged_array_to_ndarray
 
@@ -61,6 +62,10 @@ class LanguageModelFeaturizer(DenseFeaturizer, GraphComponent):
         self, config: Dict[Text, Any], execution_context: ExecutionContext
     ) -> None:
         """Initializes the featurizer with the model in the config."""
+        raise_deprecation_warning(
+            "LanguageModelFeaturizer is deprecated and "
+            "will be removed in a future version."
+        )
         super(LanguageModelFeaturizer, self).__init__(
             execution_context.node_name, config
         )

rasa/nlu/featurizers/dense_featurizer/mitie_featurizer.py

@@ -4,6 +4,8 @@ import logging
 import typing
 from typing import Any, Dict, List, Text, Tuple, Type
 
+# importing mitie at module level to ensure error is raised if mitie is not installed
+import mitie
 import numpy as np
 
 from rasa.engine.graph import ExecutionContext, GraphComponent

rasa/nlu/featurizers/dense_featurizer/spacy_featurizer.py

@@ -4,6 +4,9 @@ from typing import Any, Dict, List, Text, Type
 
 import numpy as np
 
+# importing spacy at module level to ensure error is raised if spacy is not installed
+import spacy  # noqa: F401
+
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource

rasa/nlu/featurizers/sparse_featurizer/count_vectors_featurizer.py

@@ -21,12 +21,14 @@ from rasa.nlu.constants import (
 )
 from rasa.nlu.featurizers.sparse_featurizer.sparse_featurizer import SparseFeaturizer
 from rasa.nlu.tokenizers.tokenizer import Tokenizer
-from rasa.nlu.utils.spacy_utils import SpacyModel
 from rasa.shared.constants import DOCS_URL_COMPONENTS
 from rasa.shared.exceptions import FileIOException, RasaException
 from rasa.shared.nlu.constants import ACTION_NAME, INTENT, INTENT_RESPONSE_KEY, TEXT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.common import conditional_import
+
+SpacyModel, _ = conditional_import("rasa.nlu.utils.spacy_utils", "SpacyModel")
 
 BUFFER_SLOTS_PREFIX = "buf_"
 
@@ -603,7 +605,7 @@ class CountVectorsFeaturizer(SparseFeaturizer, GraphComponent):
             return [], []
 
     def train(
-        self, training_data: TrainingData, model: Optional[SpacyModel] = None
+        self, training_data: TrainingData, model: Optional[Any] = None
     ) -> Resource:
         """Trains the featurizer.
 

rasa/nlu/featurizers/sparse_featurizer/lexical_syntactic_featurizer.py

@@ -18,6 +18,10 @@ from typing import (
 import numpy as np
 import scipy.sparse
 
+# importing spacy at module level to ensure error is raised if spacy is not installed
+# spacy is needed when importing from rasa.nlu.tokenizers.spacy_tokenizer
+import spacy  # noqa: F401
+
 import rasa.shared.utils.io
 import rasa.utils.io
 from rasa.engine.graph import ExecutionContext, GraphComponent

rasa/nlu/selectors/response_selector.py

@@ -45,6 +45,7 @@ from rasa.shared.nlu.constants import (
 from rasa.shared.nlu.training_data import util
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.io import raise_deprecation_warning
 from rasa.utils.tensorflow import rasa_layers
 from rasa.utils.tensorflow.constants import (
     AUTO,
@@ -295,6 +296,9 @@ class ResponseSelector(DIETClassifier):
                 otherwise initializes it with random weights.
             sparse_feature_sizes: Sizes of the sparse features the model was trained on.
         """
+        raise_deprecation_warning(
+            "ResponseSelector is deprecated and will be removed in a future version."
+        )
         component_config = config
 
         # the following properties cannot be adapted for the ResponseSelector
@@ -963,8 +967,12 @@ class DIET2DIET(DIET):
 
         predictions = {
             DIAGNOSTIC_DATA: {
-                "attention_weights": attention_weights,
-                "text_transformed": text_transformed,
+                "attention_weights": attention_weights.numpy()
+                if hasattr(attention_weights, "numpy")
+                else attention_weights,
+                "text_transformed": text_transformed.numpy()
+                if hasattr(text_transformed, "numpy")
+                else text_transformed,
             }
         }
 

rasa/nlu/tokenizers/jieba_tokenizer.py

@@ -6,6 +6,9 @@ import os
 import shutil
 from typing import Any, Dict, List, Optional, Text
 
+# importing jieba at module level to ensure error is raised if jieba is not installed
+import jieba
+
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
@@ -81,8 +84,6 @@ class JiebaTokenizer(Tokenizer):
         be found in the documentation of jieba.
         https://github.com/fxsjy/jieba#load-dictionary
         """
-        import jieba
-
         jieba_userdicts = glob.glob(f"{path}/*")
         for jieba_userdict in jieba_userdicts:
             logger.info(f"Loading Jieba User Dictionary at {jieba_userdict}")
@@ -95,8 +96,6 @@ class JiebaTokenizer(Tokenizer):
 
     def tokenize(self, message: Message, attribute: Text) -> List[Token]:
         """Tokenizes the text of the provided attribute of the incoming message."""
-        import jieba
-
         text = message.get(attribute)
 
         tokenized = jieba.tokenize(text)

rasa/nlu/tokenizers/mitie_tokenizer.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Text
 
+# importing mitie at module level to ensure error is raised if mitie is not installed
+import mitie
+
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
@@ -49,8 +52,6 @@ class MitieTokenizer(Tokenizer):
 
     def tokenize(self, message: Message, attribute: Text) -> List[Token]:
         """Tokenizes the text of the provided attribute of the incoming message."""
-        import mitie
-
         text = message.get(attribute)
 
         encoded_sentence = text.encode(DEFAULT_ENCODING)

rasa/nlu/tokenizers/spacy_tokenizer.py

@@ -1,6 +1,9 @@
 import typing
 from typing import Any, Dict, List, Optional, Text, Type
 
+# importing spacy at module level to ensure error is raised if spacy is not installed
+import spacy
+
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.nlu.constants import SPACY_DOCS
 from rasa.nlu.tokenizers.tokenizer import Token, Tokenizer
@@ -64,8 +67,6 @@ class SpacyTokenizer(Tokenizer):
 
     @staticmethod
     def _tag_of_token(token: Any) -> Text:
-        import spacy
-
         if spacy.about.__version__ > "2" and token._.has("tag"):
             return token._.get("tag")
         else:

rasa/nlu/utils/mitie_utils.py

@@ -4,6 +4,9 @@ import typing
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Text
 
+# importing mitie at module level to ensure error is raised if mitie is not installed
+import mitie
+
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource

rasa/nlu/utils/spacy_utils.py

@@ -5,6 +5,9 @@ import logging
 import typing
 from typing import Any, Dict, List, Optional, Text, Tuple
 
+# importing spacy at module level to ensure error is raised if spacy is not installed
+import spacy
+
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
@@ -76,8 +79,6 @@ class SpacyNLP(GraphComponent):
     @staticmethod
     def load_model(spacy_model_name: Text) -> SpacyModel:
         """Try loading the model, catching the OSError if missing."""
-        import spacy
-
         if not spacy_model_name:
             raise InvalidModelError(
                 f"Missing model configuration for `SpacyNLP` in `config.yml`.\n"

rasa/plugin.py

@@ -37,7 +37,7 @@ def init_hooks(manager: pluggy.PluginManager) -> None:
     manager.register(hooks)
 
 
-@hookspec  # type: ignore[misc]
+@hookspec
 def refine_cli(
     subparsers: SubParsersAction,
     parent_parsers: List[argparse.ArgumentParser],
@@ -45,22 +45,22 @@ def refine_cli(
     """Customizable hook for adding CLI commands."""
 
 
-@hookspec  # type: ignore[misc]
+@hookspec
 def configure_commandline(cmdline_arguments: argparse.Namespace) -> Optional[Text]:
     """Hook specification for configuring plugin CLI."""
 
 
-@hookspec  # type: ignore[misc]
+@hookspec
 def init_telemetry(endpoints_file: Optional[Text]) -> None:
     """Hook specification for initialising plugin telemetry."""
 
 
-@hookspec  # type: ignore[misc]
+@hookspec
 def init_managers(endpoints_file: Optional[Text]) -> None:
     """Hook specification for initialising managers."""
 
 
-@hookspec(firstresult=True)  # type: ignore[misc]
+@hookspec(firstresult=True)
 def create_tracker_store(  # type: ignore[empty-body]
     endpoint_config: Union["TrackerStore", "EndpointConfig"],
     domain: "Domain",
@@ -69,7 +69,7 @@ def create_tracker_store(  # type: ignore[empty-body]
     """Hook specification for wrapping with AuthRetryTrackerStore."""
 
 
-@hookspec  # type: ignore[misc]
+@hookspec
 def after_server_stop() -> None:
     """Hook specification for stopping the server.
 
@@ -78,11 +78,11 @@ def after_server_stop() -> None:
     """
 
 
-@hookspec  # type: ignore[misc]
+@hookspec
 def after_new_user_message(tracker: "DialogueStateTracker") -> None:
     """Hook specification for after a new user message is received."""
 
 
-@hookspec  # type: ignore[misc]
+@hookspec
 def after_action_executed(tracker: "DialogueStateTracker") -> None:
     """Hook specification for after an action is executed."""

rasa/privacy/privacy_manager.py

@@ -30,8 +30,8 @@ from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
 if TYPE_CHECKING:
     from asyncio import AbstractEventLoop
 
-    from rasa.core.available_endpoints import AvailableEndpoints
     from rasa.core.brokers.broker import EventBroker
+    from rasa.core.config.available_endpoints import AvailableEndpoints
     from rasa.shared.core.domain import Domain
 
 
@@ -264,10 +264,19 @@ class BackgroundPrivacyManager:
             )
             return None
 
-        latest_user_message = tracker.get_last_event_for(
+        latest_user_message_event = tracker.get_last_event_for(
             UserUttered, event_verbosity=EventVerbosity.ALL
         )
-        if latest_user_message is None or not latest_user_message.text:
+        if latest_user_message_event is None or not isinstance(
+            latest_user_message_event, UserUttered
+        ):
+            structlogger.debug(
+                "rasa.privacy_manager.no_user_message.skipping_processing",
+            )
+            return None
+
+        latest_user_message: UserUttered = latest_user_message_event
+        if not latest_user_message.text:
             structlogger.debug(
                 "rasa.privacy_manager.no_user_message.skipping_processing",
             )

rasa/server.py

@@ -44,12 +44,13 @@ import rasa.utils.endpoints
 import rasa.utils.io
 from rasa.constants import MINIMUM_COMPATIBLE_VERSION
 from rasa.core.agent import Agent
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.available_agents import AvailableAgents
 from rasa.core.channels.channel import (
     CollectingOutputChannel,
     OutputChannel,
     UserMessage,
 )
+from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.core.constants import DEFAULT_RESPONSE_TIMEOUT
 from rasa.core.persistor import parse_remote_storage
 from rasa.core.test import test
@@ -243,7 +244,7 @@ def requires_auth(
         @wraps(f)
         async def decorated(
             request: Request, *args: Any, **kwargs: Any
-        ) -> response.HTTPResponse:
+        ) -> Union[response.HTTPResponse, Coroutine[Any, Any, response.HTTPResponse]]:
             provided = request.args.get("token", None)
 
             # noinspection PyProtectedMember
@@ -676,7 +677,9 @@ def inject_temp_dir(f: Callable[..., Coroutine]) -> Callable:
     """
 
     @wraps(f)
-    async def decorated_function(*args: Any, **kwargs: Any) -> HTTPResponse:
+    async def decorated_function(
+        *args: Any, **kwargs: Any
+    ) -> Union[HTTPResponse, Coroutine[Any, Any, HTTPResponse]]:
         with TempDirectoryPath(get_temp_dir_name()) as directory:
             # Decorated request handles need to have a parameter `temporary_directory`
             return await f(*args, temporary_directory=Path(directory), **kwargs)
@@ -693,6 +696,7 @@ def create_app(
     jwt_private_key: Optional[Text] = None,
     jwt_method: Text = "HS256",
     endpoints: Optional[AvailableEndpoints] = None,
+    sub_agents: Optional[AvailableAgents] = None,
     is_inspector_enabled: bool = False,
 ) -> Sanic:
     """Class representing a Rasa HTTP server."""
@@ -728,6 +732,7 @@ def create_app(
             user_id="username",
         )
 
+    app.ctx.sub_agents = sub_agents
     app.ctx.agent = agent
     # Initialize shared object of type unsigned int for tracking
     # the number of active training processes
@@ -1463,6 +1468,13 @@ def create_app(
         flows = await processor.get_flows()
         return response.json(flows.as_json_list())
 
+    @app.get("/sub-agents")
+    @requires_auth(app, auth_token)
+    async def get_sub_agents(request: Request) -> HTTPResponse:
+        """Get all the sub-agents currently stored by the agent."""
+        sub_agents = app.ctx.sub_agents
+        return response.json(sub_agents.as_json_list())
+
     @app.get("/domain")
     @requires_auth(app, auth_token)
     @ensure_loaded_agent(app)

rasa/shared/agents/auth/agent_auth_factory.py

@@ -0,0 +1,105 @@
+"""Factory for creating authentication strategy instances based on the strategy type."""
+
+from typing import Any, ClassVar, Dict, Optional, Type
+
+import structlog
+
+from rasa.shared.agents.auth.auth_strategy import (
+    AgentAuthStrategy,
+    APIKeyAuthStrategy,
+    BearerTokenAuthStrategy,
+    OAuth2AuthStrategy,
+)
+from rasa.shared.agents.auth.constants import CONFIG_MODULE_KEY
+from rasa.shared.agents.auth.types import AgentAuthType
+from rasa.shared.utils.common import class_from_module_path
+
+structlogger = structlog.get_logger()
+
+
+class AgentAuthFactory:
+    """Factory for creating authentication strategy instances based on the
+    authentication strategy type.
+    """
+
+    _auth_strategies: ClassVar[Dict[AgentAuthType, Type[AgentAuthStrategy]]] = {
+        AgentAuthType.API_KEY: APIKeyAuthStrategy,
+        AgentAuthType.OAUTH2: OAuth2AuthStrategy,
+        AgentAuthType.BEARER_TOKEN: BearerTokenAuthStrategy,
+    }
+
+    @classmethod
+    def create_client(
+        cls, auth_type: AgentAuthType, config: Optional[Dict[str, Any]] = None
+    ) -> AgentAuthStrategy:
+        """Create an authentication strategy instance based on the strategy type.
+
+        Args:
+            auth_type: The type of the authentication strategy.
+            config: The configuration dictionary for the authentication.
+
+        Returns:
+            An instance of the authentication strategy.
+        """
+        config = config or {}
+
+        # If the auth type is custom, we need to create it from the module
+        if auth_type == AgentAuthType.CUSTOM:
+            auth_strategy_class: Type[AgentAuthStrategy] = class_from_module_path(
+                config[CONFIG_MODULE_KEY]
+            )
+            if not cls._is_valid_custom_auth_strategy(auth_strategy_class):
+                raise ValueError(
+                    f"Authentication strategy class `{auth_strategy_class}` must "
+                    f"subclass the "
+                    f"`{cls.get_agent_auth_strategy_base_class().__name__}` class."
+                )
+            structlogger.debug(
+                "agent_auth_factory.create_client.custom_auth_strategy",
+                event_info=f"Initializing `{auth_strategy_class.__name__}`",
+                auth_type=auth_type.value,
+                auth_strategy_class=auth_strategy_class.__name__,
+            )
+            return auth_strategy_class.from_config(config)
+
+        # Get the strategy class for the specified type
+        auth_strategy_class = cls._get_auth_strategy_class(auth_type)
+        if auth_strategy_class is None:
+            raise ValueError(
+                f"Unsupported strategy type: {auth_type}. "
+                f"Supported types: {cls.get_supported_auth_strategy_types()}"
+            )
+        # Create instance based on strategy type
+        return auth_strategy_class.from_config(config)
+
+    @classmethod
+    def get_supported_auth_strategy_types(cls) -> list[AgentAuthType]:
+        """Get all supported authentication strategy types."""
+        return list(cls._auth_strategies.keys())
+
+    @classmethod
+    def _get_auth_strategy_class(
+        cls, auth_type: AgentAuthType
+    ) -> Type[AgentAuthStrategy]:
+        """Get the class that implements the authentication strategy."""
+        if not cls.is_auth_strategy_supported(auth_type):
+            raise ValueError(
+                f"Unsupported authentication strategy type: {auth_type}. "
+                f"Supported types: {cls.get_supported_auth_strategy_types()}"
+            )
+        return cls._auth_strategies[auth_type]
+
+    @classmethod
+    def is_auth_strategy_supported(cls, auth_type: AgentAuthType) -> bool:
+        """Check if the authentication strategy type is supported."""
+        return auth_type in cls._auth_strategies
+
+    @classmethod
+    def _is_valid_custom_auth_strategy(cls, strategy_class: Any) -> bool:
+        """Check if the authentication strategy class is valid."""
+        return issubclass(strategy_class, cls.get_agent_auth_strategy_base_class())
+
+    @staticmethod
+    def get_agent_auth_strategy_base_class() -> Type[AgentAuthStrategy]:
+        """Get the agent authentication strategy base class."""
+        return AgentAuthStrategy

rasa/shared/agents/auth/agent_auth_manager.py

@@ -0,0 +1,92 @@
+"""High-level authentication management with strategy abstraction."""
+
+from typing import Any, Dict, Optional
+
+import structlog
+
+from rasa.shared.agents.auth.agent_auth_factory import AgentAuthFactory
+from rasa.shared.agents.auth.auth_strategy import AgentAuthStrategy
+from rasa.shared.agents.auth.constants import (
+    CONFIG_API_KEY_KEY,
+    CONFIG_MODULE_KEY,
+    CONFIG_OAUTH_KEY,
+    CONFIG_TOKEN_KEY,
+)
+from rasa.shared.agents.auth.types import AgentAuthType
+from rasa.shared.exceptions import AgentAuthInitializationException
+
+structlogger = structlog.get_logger()
+
+
+class AgentAuthManager:
+    """High-level authentication management with strategy abstraction."""
+
+    def __init__(self, auth_strategy: Optional[AgentAuthStrategy] = None):
+        """Initialize a new authentication manager instance."""
+        self._auth_strategy: Optional[AgentAuthStrategy] = auth_strategy
+
+    def get_auth(self) -> AgentAuthStrategy:
+        """Retrieve the authentication instance.
+
+        Returns:
+            The authentication instance.
+
+        Raises:
+            ValueError: If no authentication is connected.
+        """
+        if self._auth_strategy is None:
+            raise ValueError("No authentication instance available")
+        return self._auth_strategy
+
+    @staticmethod
+    def detect_auth_type(config: Dict[str, Any]) -> AgentAuthType:
+        if CONFIG_MODULE_KEY in config:
+            return AgentAuthType.CUSTOM
+        if CONFIG_API_KEY_KEY in config:
+            return AgentAuthType.API_KEY
+        if CONFIG_TOKEN_KEY in config:
+            return AgentAuthType.BEARER_TOKEN
+        if CONFIG_OAUTH_KEY in config:
+            return AgentAuthType.OAUTH2
+        raise ValueError(
+            "Invalid authentication type. Supported types: "
+            + ", ".join([auth_type.value for auth_type in AgentAuthType])
+        )
+
+    @classmethod
+    def load_auth(
+        cls, config: Optional[Dict[str, Any]]
+    ) -> Optional["AgentAuthManager"]:
+        """Connect to authentication using specified strategy type and persist
+        the auth instance to the manager in a ready-to-use state.
+
+        Args:
+            config: The configuration dictionary for the authentication.
+
+        Raises:
+            AgentAuthInitializationException: If the authentication connection fails.
+        """
+        if not config:
+            return None
+        try:
+            auth_type = AgentAuthManager.detect_auth_type(config)
+
+            # Create the auth client
+            client = AgentAuthFactory.create_client(auth_type, config)
+
+            structlogger.debug(
+                "agent_auth_manager.load_auth.success",
+                auth_type=auth_type.value,
+                event_info=(
+                    f"Loaded authentication client successfully for `{auth_type.value}`"
+                ),
+            )
+            return cls(client)
+        except Exception as e:
+            event_info = "Failed to load authentication client"
+            structlogger.error(
+                "agent_auth_manager.load_auth.failed_to_load",
+                event_info=event_info,
+                config=config,
+            )
+            raise AgentAuthInitializationException(e) from e

rasa/shared/agents/auth/auth_strategy/__init__.py

@@ -0,0 +1,19 @@
+"""Authentication strategy implementations."""
+
+from rasa.shared.agents.auth.auth_strategy.agent_auth_strategy import AgentAuthStrategy
+from rasa.shared.agents.auth.auth_strategy.api_key_auth_strategy import (
+    APIKeyAuthStrategy,
+)
+from rasa.shared.agents.auth.auth_strategy.bearer_token_auth_strategy import (
+    BearerTokenAuthStrategy,
+)
+from rasa.shared.agents.auth.auth_strategy.oauth2_auth_strategy import (
+    OAuth2AuthStrategy,
+)
+
+__all__ = [
+    "AgentAuthStrategy",
+    "APIKeyAuthStrategy",
+    "OAuth2AuthStrategy",
+    "BearerTokenAuthStrategy",
+]