rasa-pro 3.14.0.dev7__py3-none-any.whl → 3.14.0.dev9__py3-none-any.whl

rasa/model_training.py

@@ -201,6 +201,20 @@ async def train(
             config, domain, training_files, core_additional_arguments
         )
 
+    # Check TensorFlow availability and warn if not available
+    import importlib.util
+
+    if importlib.util.find_spec("tensorflow") is None:
+        structlogger.warning(
+            "model_training.train.tensorflow_not_available",
+            event_info=(
+                "TensorFlow is not installed. Components requiring TensorFlow "
+                "(DIETClassifier, TEDPolicy, UnexpecTEDIntentPolicy, ResponseSelector, "
+                "ConveRTFeaturizer, LanguageModelFeaturizer) "
+                "will not be available."
+            ),
+        )
+
     stories = file_importer.get_stories()
     flows = file_importer.get_flows()
     nlu_data = file_importer.get_nlu_data()

rasa/nlu/classifiers/diet_classifier.py

@@ -1070,12 +1070,14 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
 
         with self._model_storage.write_to(self._resource) as model_path:
             file_name = self.__class__.__name__
-            tf_model_file = model_path / f"{file_name}.tf_model"
+            tf_model_file = model_path / f"{file_name}.weights.h5"
 
             rasa.shared.utils.io.create_directory_for_file(tf_model_file)
 
             if self.component_config[CHECKPOINT_MODEL] and self.tmp_checkpoint_dir:
-                self.model.load_weights(self.tmp_checkpoint_dir / "checkpoint.tf_model")
+                self.model.load_weights(
+                    self.tmp_checkpoint_dir / "checkpoint.weights.h5"
+                )
                 # Save an empty file to flag that this model has been
                 # produced using checkpointing
                 checkpoint_marker = model_path / f"{file_name}.from_checkpoint.pkl"
@@ -1247,7 +1249,7 @@ class DIETClassifier(GraphComponent, IntentClassifier, EntityExtractorMixin):
         finetune_mode: bool = False,
     ) -> "RasaModel":
         file_name = cls.__name__
-        tf_model_file = model_path / f"{file_name}.tf_model"
+        tf_model_file = model_path / f"{file_name}.weights.h5"
 
         label_key = LABEL_KEY if config[INTENT_CLASSIFICATION] else None
         label_sub_key = LABEL_SUB_KEY if config[INTENT_CLASSIFICATION] else None
@@ -1527,7 +1529,7 @@ class DIET(TransformerRasaModel):
         # convert to bag-of-words by summing along the sequence dimension
         x = tf.reduce_sum(x, axis=1)
 
-        return self._tf_layers[f"ffnn.{name}"](x, self._training)
+        return self._tf_layers[f"ffnn.{name}"](x, training=self._training)
 
     def _create_all_labels(self) -> Tuple[tf.Tensor, tf.Tensor]:
         all_label_ids = self.tf_label_data[LABEL_KEY][LABEL_SUB_KEY][0]
@@ -1536,9 +1538,23 @@ class DIET(TransformerRasaModel):
             self.tf_label_data, LABEL
         )
 
+        # Check if SENTENCE features exist, if not use None
+        # This is needed for compatibility with tensorFlow=2.19.1, which
+        # has a transitive dependency on keras=3.11.3, which introduces
+        # stricter data validation
+        sentence_features = None
+        if SENTENCE in self.tf_label_data[LABEL]:
+            sentence_features = self.tf_label_data[LABEL][SENTENCE]
+
+        # Handle missing SEQUENCE features for Keras 3+ compatibility,
+        # which introduces stricter data validation
+        sequence_features = None
+        if SEQUENCE in self.tf_label_data[LABEL]:
+            sequence_features = self.tf_label_data[LABEL][SEQUENCE]
+
         x = self._create_bow(
-            self.tf_label_data[LABEL][SEQUENCE],
-            self.tf_label_data[LABEL][SENTENCE],
+            sequence_features,
+            sentence_features,
             sequence_feature_lengths,
             self.label_name,
         )

rasa/nlu/classifiers/logistic_regression_classifier.py

@@ -21,6 +21,21 @@ from rasa.utils.tensorflow.constants import RANKING_LENGTH
 structlogger = structlog.get_logger()
 
 
+def _check_skops_dependency() -> None:
+    """Check if skops is available and raise error if not."""
+    import importlib.util
+
+    if importlib.util.find_spec("skops") is None:
+        from rasa.exceptions import MissingDependencyException
+
+        raise MissingDependencyException(
+            "The LogisticRegressionClassifier requires the 'skops' package "
+            "to save and load trained models. "
+            "To install it, run: `pip install rasa[skops]` or `pip install skops`. "
+            "If using poetry, run `poetry install --extras skops`. "
+        )
+
+
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.INTENT_CLASSIFIER, is_trainable=True
 )
@@ -151,6 +166,7 @@ class LogisticRegressionClassifier(IntentClassifier, GraphComponent):
         execution_context: ExecutionContext,
     ) -> "LogisticRegressionClassifier":
         """Creates a new untrained component (see parent class for full docstring)."""
+        _check_skops_dependency()
         return cls(config, execution_context.node_name, model_storage, resource)
 
     def process(self, messages: List[Message]) -> List[Message]:
@@ -183,6 +199,7 @@ class LogisticRegressionClassifier(IntentClassifier, GraphComponent):
 
     def persist(self) -> None:
         """Persist this model into the passed directory."""
+        _check_skops_dependency()
         import skops.io as sio
 
         with self._model_storage.write_to(self._resource) as model_dir:
@@ -203,6 +220,7 @@ class LogisticRegressionClassifier(IntentClassifier, GraphComponent):
         **kwargs: Any,
     ) -> "LogisticRegressionClassifier":
         """Loads trained component (see parent class for full docstring)."""
+        _check_skops_dependency()
         import skops.io as sio
 
         try:

rasa/nlu/extractors/extractor.py

@@ -2,8 +2,7 @@ import abc
 from typing import Any, Dict, List, NamedTuple, Optional, Text, Tuple
 
 import rasa.shared.utils.io
-
-# import rasa.utils.train_utils
+import rasa.utils.train_utils
 from rasa.nlu.constants import (
     ENTITY_ATTRIBUTE_CONFIDENCE_GROUP,
     ENTITY_ATTRIBUTE_CONFIDENCE_ROLE,

rasa/shared/agents/auth/agent_auth_factory.py

@@ -0,0 +1,74 @@
+"""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.types import AgentAuthType
+
+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 {}
+
+        # 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

rasa/shared/agents/auth/agent_auth_manager.py

@@ -0,0 +1,86 @@
+"""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_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_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: Dict[str, Any]) -> "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.
+        """
+        config = config or {}
+        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)

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",
+]

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

@@ -0,0 +1,52 @@
+from abc import ABC, abstractmethod
+from typing import Any, AsyncGenerator, Dict
+
+import httpx
+
+from rasa.shared.agents.auth.types import AgentAuthType
+from rasa.shared.utils.io import resolve_environment_variables
+
+
+class AgentAuthStrategy(ABC, httpx.Auth):
+    """Base class for authentication strategies."""
+
+    @classmethod
+    @abstractmethod
+    def from_config(cls, config: Dict[str, Any]) -> "AgentAuthStrategy":
+        """Create an authentication strategy instance from a config dictionary."""
+        ...
+
+    @property
+    @abstractmethod
+    def auth_type(self) -> AgentAuthType:
+        """Return the type of the authentication strategy."""
+        ...
+
+    @abstractmethod
+    async def get_headers(self) -> Dict[str, str]:
+        """Get authentication headers for requests.
+
+        Returns:
+            Dictionary containing authentication headers.
+        """
+        ...
+
+    async def async_auth_flow(
+        self, request: httpx.Request
+    ) -> AsyncGenerator[httpx.Request, httpx.Response]:
+        """Get authentication headers for requests.
+
+        Returns:
+            Async generator of requests with authentication headers.
+        """
+        # Get authentication headers.
+        auth_headers = await self.get_headers()
+
+        # Resolve environment variables in authentication headers.
+        resolved_auth_headers = resolve_environment_variables(auth_headers)
+
+        # Update request headers with resolved authentication headers.
+        request.headers.update(resolved_auth_headers)
+
+        # Yield request with resolved authentication headers.
+        yield request

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

@@ -0,0 +1,42 @@
+"""API Key authentication strategy implementation."""
+
+from typing import Any, Dict
+
+from rasa.shared.agents.auth.auth_strategy import AgentAuthStrategy
+from rasa.shared.agents.auth.constants import (
+    CONFIG_API_KEY_KEY,
+    CONFIG_HEADER_FORMAT_KEY,
+    CONFIG_HEADER_NAME_KEY,
+)
+from rasa.shared.agents.auth.types import AgentAuthType
+
+
+class APIKeyAuthStrategy(AgentAuthStrategy):
+    """API Key authentication strategy implementation."""
+
+    def __init__(
+        self,
+        api_key: str,
+        header_name: str = "Authorization",
+        header_format: str = "Bearer {key}",
+    ):
+        self.api_key = api_key
+        self.header_name = header_name
+        self.header_format = header_format
+
+    @classmethod
+    def from_config(cls, config: Dict[str, Any]) -> "APIKeyAuthStrategy":
+        api_key = config.get(CONFIG_API_KEY_KEY)
+        header_name = config.get(CONFIG_HEADER_NAME_KEY, "Authorization")
+        header_format = config.get(CONFIG_HEADER_FORMAT_KEY, "Bearer {key}")
+        if not api_key:
+            raise ValueError("API key is required for API KEY authentication")
+        return APIKeyAuthStrategy(api_key, header_name, header_format)
+
+    @property
+    def auth_type(self) -> AgentAuthType:
+        return AgentAuthType.API_KEY
+
+    async def get_headers(self) -> Dict[str, str]:
+        """Return API key authentication headers."""
+        return {self.header_name: self.header_format.format(key=self.api_key)}

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

@@ -0,0 +1,28 @@
+"""Bearer Token authentication strategy implementation."""
+
+from typing import Any, Dict
+
+from rasa.shared.agents.auth.auth_strategy import AgentAuthStrategy
+from rasa.shared.agents.auth.constants import CONFIG_TOKEN_KEY
+from rasa.shared.agents.auth.types import AgentAuthType
+
+
+class BearerTokenAuthStrategy(AgentAuthStrategy):
+    """Bearer Token authentication strategy implementation."""
+
+    def __init__(self, token: str):
+        self._token = token
+
+    @classmethod
+    def from_config(cls, config: Dict[str, Any]) -> "BearerTokenAuthStrategy":
+        token = config.get(CONFIG_TOKEN_KEY)
+        if not token:
+            raise ValueError("Access token is required for Bearer Token authentication")
+        return BearerTokenAuthStrategy(token)
+
+    @property
+    def auth_type(self) -> AgentAuthType:
+        return AgentAuthType.BEARER_TOKEN
+
+    async def get_headers(self) -> Dict[str, str]:
+        return {"Authorization": f"Bearer {self._token}"}

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

@@ -0,0 +1,159 @@
+"""OAuth2 authentication strategy client credentials flow implementation."""
+
+import asyncio
+import time
+from typing import Any, AsyncGenerator, Dict, Optional
+
+import httpx
+
+from rasa.shared.agents.auth.auth_strategy import AgentAuthStrategy
+from rasa.shared.agents.auth.constants import (
+    CONFIG_CLIENT_ID_KEY,
+    CONFIG_CLIENT_SECRET_KEY,
+    CONFIG_SCOPE_KEY,
+    CONFIG_TIMEOUT_KEY,
+    CONFIG_TOKEN_URL_KEY,
+)
+from rasa.shared.agents.auth.types import AgentAuthType
+from rasa.shared.utils.io import resolve_environment_variables
+
+KEY_ACCESS_TOKEN = "access_token"
+KEY_CLIENT_CREDENTIALS = "client_credentials"
+KEY_EXPIRES_IN = "expires_in"
+
+
+class OAuth2AuthStrategy(AgentAuthStrategy):
+    """Client Credentials Flow authentication strategy."""
+
+    DEFAULT_ACCESS_TOKEN_TIMEOUT = 5
+    DEFAULT_ACCESS_TOKEN_EXPIRES_IN_SECONDS = 3600
+    DEFAULT_BUFFER_TIME_SECONDS = 10
+
+    def __init__(
+        self,
+        token_url: str,
+        client_id: str,
+        client_secret: str,
+        scope: str,
+        timeout: Optional[int] = None,
+    ):
+        self.token_url = token_url
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.scope = scope
+        self.timeout = timeout or self.DEFAULT_ACCESS_TOKEN_TIMEOUT
+
+        # Only client credentials flow is supported for server to server communication.
+        self._grant_type = KEY_CLIENT_CREDENTIALS
+
+        # Initialize defaults.
+        self._access_token: Optional[str] = None
+        self._expires_at: Optional[float] = None
+
+        # Initialize lock for concurrent access to the refresh the access token.
+        self._refresh_lock = asyncio.Lock()
+
+    @classmethod
+    def from_config(cls, config: Dict[str, Any]) -> "OAuth2AuthStrategy":
+        """Create OAuth2AuthStrategy from configuration dictionary."""
+        token_url = config.get(CONFIG_TOKEN_URL_KEY)
+        client_id = config.get(CONFIG_CLIENT_ID_KEY)
+        client_secret = config.get(CONFIG_CLIENT_SECRET_KEY)
+        scope = config.get(CONFIG_SCOPE_KEY)
+        timeout = config.get(CONFIG_TIMEOUT_KEY) or cls.DEFAULT_ACCESS_TOKEN_TIMEOUT
+
+        if not token_url:
+            raise ValueError("Token URL is required for OAuth2 authentication")
+        if not client_id:
+            raise ValueError("Client ID is required for OAuth2 authentication")
+        if not client_secret:
+            raise ValueError("Client secret is required for OAuth2 authentication")
+        if not scope:
+            raise ValueError("Scope is required for OAuth2 authentication")
+
+        return cls(
+            token_url=token_url,
+            client_id=client_id,
+            client_secret=client_secret,
+            scope=scope,
+            timeout=timeout,
+        )
+
+    @property
+    def auth_type(self) -> AgentAuthType:
+        return AgentAuthType.OAUTH2
+
+    async def get_headers(self) -> Dict[str, str]:
+        """Return OAuth2 authentication headers."""
+        # Acquire lock to prevent concurrent access to the refresh the access token.
+        async with self._refresh_lock:
+            # Refresh if missing or expired
+            if not self._access_token or self._is_expired():
+                await self._refresh_access_token()
+            if not self._access_token:
+                raise ValueError("Failed to obtain access token")
+        return {"Authorization": f"Bearer {self._access_token}"}
+
+    def _is_expired(self) -> bool:
+        """Check if access token is expired."""
+        # Adding a buffer time to the expiration time to avoid race conditions.
+        return (
+            not self._expires_at
+            or self._expires_at <= time.time() + self.DEFAULT_BUFFER_TIME_SECONDS
+        )
+
+    async def _refresh_access_token(self) -> None:
+        """Fetch a new access token using client credentials flow."""
+        # Prepare data and headers
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        data = {
+            "grant_type": self._grant_type,
+            "client_id": self.client_id,
+            "client_secret": self.client_secret,
+            "scope": self.scope,
+        }
+
+        # Resolve environment variables in data.
+        resolved_data = resolve_environment_variables(data)
+
+        # Fetch access token
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                resp = await client.post(
+                    self.token_url, data=resolved_data, headers=headers
+                )
+                resp.raise_for_status()
+                token_data = resp.json()
+        except httpx.HTTPStatusError as e:
+            raise ValueError(
+                f"OAuth2 token request failed with status {e.response.status_code}: "
+                f"{e.response.text}"
+            ) from e
+        except httpx.RequestError as e:
+            raise ValueError(f"OAuth2 token request failed: {e}") from e
+        except Exception as e:
+            raise ValueError(
+                f"Unexpected error during OAuth2 token request: {e}"
+            ) from e
+
+        # Validate token data
+        if KEY_ACCESS_TOKEN not in token_data:
+            raise ValueError(f"No {KEY_ACCESS_TOKEN} in OAuth2 response")
+
+        # Set access token and expires at
+        self._access_token = token_data[KEY_ACCESS_TOKEN]
+        self._expires_at = time.time() + token_data.get(
+            KEY_EXPIRES_IN, self.DEFAULT_ACCESS_TOKEN_EXPIRES_IN_SECONDS
+        )
+
+    async def async_auth_flow(
+        self, request: httpx.Request
+    ) -> AsyncGenerator[httpx.Request, httpx.Response]:
+        """Inject Authorization header into outgoing requests.
+
+        Returns:
+            Async generator of requests with Authorization header.
+        """
+        auth_headers = await self.get_headers()
+        request.headers.update(auth_headers)
+        yield request

rasa/shared/agents/auth/constants.py

@@ -0,0 +1,11 @@
+CONFIG_API_KEY_KEY = "api_key"
+CONFIG_TOKEN_KEY = "token"
+CONFIG_OAUTH_KEY = "oauth"
+CONFIG_HEADER_NAME_KEY = "header_name"
+CONFIG_HEADER_FORMAT_KEY = "header_format"
+CONFIG_CLIENT_ID_KEY = "client_id"
+CONFIG_CLIENT_SECRET_KEY = "client_secret"
+CONFIG_TOKEN_URL_KEY = "token_url"
+CONFIG_SCOPE_KEY = "scope"
+CONFIG_GRANT_TYPE_KEY = "grant_type"
+CONFIG_TIMEOUT_KEY = "timeout"

rasa/shared/agents/auth/types.py

@@ -0,0 +1,11 @@
+"""Fundamental types for authentication protocols."""
+
+from enum import Enum
+
+
+class AgentAuthType(Enum):
+    """An Enum class that represents the supported authentication protocol types."""
+
+    API_KEY = "api_key"
+    OAUTH2 = "oauth2"
+    BEARER_TOKEN = "bearer_token"

rasa/shared/core/constants.py

@@ -61,6 +61,7 @@ ACTION_CANCEL_INTERRUPTED_FLOWS = "action_cancel_interrupted_flows"
 
 ACTION_METADATA_EXECUTION_SUCCESS = "execution_success"
 ACTION_METADATA_EXECUTION_ERROR_MESSAGE = "execution_error_message"
+ACTION_METADATA_EXECUTION_TIME = "execution_times"
 
 ACTION_METADATA_MESSAGE_KEY = "message"
 ACTION_METADATA_TEXT_KEY = "text"