rasa-pro 3.8.18__py3-none-any.whl → 3.9.14__py3-none-any.whl

rasa/core/actions/custom_action_executor.py

@@ -0,0 +1,188 @@
+import abc
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Text
+
+import rasa
+from rasa.core.actions.action_exceptions import DomainNotFound
+from rasa.core.actions.constants import DEFAULT_SELECTIVE_DOMAIN, SELECTIVE_DOMAIN
+from rasa.shared.constants import DOCS_BASE_URL
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
+
+if TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+
+logger = logging.getLogger(__name__)
+
+
+class CustomActionExecutor(abc.ABC):
+    """Interface for custom action executors.
+
+    Provides an abstraction layer for executing custom actions
+    regardless of the communication protocol.
+    """
+
+    @abc.abstractmethod
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        """Executes the custom action.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain information is included in the request.
+
+        Returns:
+            The response from the execution of the custom action.
+        """
+        pass
+
+
+class NoEndpointCustomActionExecutor(CustomActionExecutor):
+    """Implementation of a custom action executor when endpoint is not set.
+
+    Used to handle the case where no endpoint is configured.
+
+    Raises RasaException when executed.
+    """
+
+    def __init__(self, action_name: str) -> None:
+        """Initializes the custom action executor.
+
+        Args:
+            action_name: The name of the custom action.
+        """
+        self.action_name = action_name
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        """Executes the custom action.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain information
+                            is included in the request.
+
+        Returns:
+            The response from the execution of the custom action.
+        """
+        raise RasaException(
+            f"Failed to execute custom action '{self.action_name}' "
+            f"because no endpoint is configured to run this "
+            f"custom action. Please take a look at "
+            f"the docs and set an endpoint configuration via the "
+            f"--endpoints flag. "
+            f"{DOCS_BASE_URL}/custom-actions"
+        )
+
+
+class CustomActionRequestWriter:
+    """Writes the request payload for a custom action."""
+
+    def __init__(self, action_name: str, action_endpoint: EndpointConfig) -> None:
+        """Initializes the request writer.
+
+        Args:
+            action_name: The name of the custom action.
+            action_endpoint: The endpoint configuration for the action server.
+        """
+        self.action_name = action_name
+        self.action_endpoint = action_endpoint
+
+    def _is_selective_domain_enabled(self) -> bool:
+        """Check if selective domain handling is enabled.
+
+        Returns:
+            True if selective domain handling is enabled, otherwise False.
+        """
+        if self.action_endpoint is None:
+            return False
+        return bool(
+            self.action_endpoint.kwargs.get(SELECTIVE_DOMAIN, DEFAULT_SELECTIVE_DOMAIN)
+        )
+
+    def create(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[str, Any]:
+        """Create the JSON payload for the action server request.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain information is included in the request.
+
+        Returns:
+            A JSON payload to be sent to the action server.
+        """
+        from rasa.shared.core.trackers import EventVerbosity
+
+        tracker_state = tracker.current_state(EventVerbosity.ALL)
+
+        result = {
+            "next_action": self.action_name,
+            "sender_id": tracker.sender_id,
+            "tracker": tracker_state,
+            "version": rasa.__version__,
+        }
+
+        if include_domain and (
+            not self._is_selective_domain_enabled()
+            or domain.does_custom_action_explicitly_need_domain(self.action_name)
+        ):
+            result["domain"] = domain.as_dict()
+
+        result["domain_digest"] = domain.fingerprint()
+
+        return result
+
+
+class RetryCustomActionExecutor(CustomActionExecutor):
+    """Retries the execution of a custom action."""
+
+    def __init__(self, custom_action_executor: CustomActionExecutor) -> None:
+        self._custom_action_executor = custom_action_executor
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        """Runs the wrapped custom action executor.
+
+        First request to the action server is made with/without the domain
+        as specified by the `include_domain` parameter.
+
+        If the action server responds with a `DomainNotFound` error, by running the
+        custom action executor again with the domain information.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain information is included in the request
+
+        Returns:
+            The response from the execution of the custom action.
+        """
+        try:
+            return await self._custom_action_executor.run(
+                tracker, domain, include_domain=include_domain
+            )
+        except DomainNotFound:
+            return await self._custom_action_executor.run(
+                tracker, domain, include_domain=True
+            )

rasa/core/actions/forms.py

@@ -11,7 +11,8 @@ from rasa.core.channels import OutputChannel
 from rasa.shared.core.domain import Domain, KEY_SLOTS
 from rasa.shared.core.constants import SlotMappingType, SLOT_MAPPINGS, MAPPING_TYPE
 
-from rasa.core.actions.action import ActionExecutionRejection, RemoteAction
+from rasa.core.actions.action import RemoteAction
+from rasa.core.actions.action_exceptions import ActionExecutionRejection
 from rasa.shared.core.constants import (
     ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
@@ -293,7 +294,8 @@ class FormAction(LoopAction):
             + [SlotSet(REQUESTED_SLOT, self.get_slot_to_fill(current_tracker))]
             # Insert form execution event so that it's clearly distinguishable which
             # events were newly added.
-            + [ActionExecuted(self.name())] + additional_events,
+            + [ActionExecuted(self.name())]
+            + additional_events,
             slots=domain.slots,
         )
 
@@ -565,6 +567,7 @@ class FormAction(LoopAction):
         nlg: "NaturalLanguageGenerator",
         tracker: "DialogueStateTracker",
         domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
     ) -> List[Event]:
         """Activate form if the form is called for the first time.
 
@@ -596,7 +599,7 @@ class FormAction(LoopAction):
         )
 
         extraction_events = await action_extract_slots.run(
-            output_channel, nlg, tracker, domain
+            output_channel, nlg, tracker, domain, metadata
         )
 
         events_as_str = "\n".join(str(e) for e in extraction_events)
@@ -712,9 +715,7 @@ class FormAction(LoopAction):
                 if isinstance(event, ActiveLoop)
             ),
             None,
-        ) == ActiveLoop(
-            None
-        )
+        ) == ActiveLoop(None)
 
     async def deactivate(self, *args: Any, **kwargs: Any) -> List[Event]:
         """Deactivates form."""
@@ -727,11 +728,14 @@ class FormAction(LoopAction):
         nlg: "NaturalLanguageGenerator",
         tracker: "DialogueStateTracker",
         domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
     ) -> List[Event]:
         events = self._default_activation_events()
 
         temp_tracker = tracker.copy()
         temp_tracker.update_with_events(events)
-        events += await self.activate(output_channel, nlg, temp_tracker, domain)
+        events += await self.activate(
+            output_channel, nlg, temp_tracker, domain, metadata
+        )
 
         return events

rasa/core/actions/grpc_custom_action_executor.py

@@ -0,0 +1,251 @@
+import json
+from typing import TYPE_CHECKING, Any, Dict, List, Tuple
+from urllib.parse import urlparse
+
+import grpc
+import structlog
+from google.protobuf.json_format import MessageToDict, Parse, ParseDict
+from rasa_sdk.grpc_errors import ResourceNotFound, ResourceNotFoundType
+from rasa_sdk.grpc_py import action_webhook_pb2, action_webhook_pb2_grpc
+
+from rasa.core.actions.action_exceptions import DomainNotFound
+from rasa.core.actions.constants import SSL_CLIENT_CERT_FIELD, SSL_CLIENT_KEY_FIELD
+from rasa.core.actions.custom_action_executor import (
+    CustomActionExecutor,
+    CustomActionRequestWriter,
+)
+from rasa.shared.exceptions import RasaException
+from rasa.shared.utils.io import file_as_bytes
+from rasa.utils.endpoints import EndpointConfig
+
+if TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger(__name__)
+
+
+class GRPCCustomActionExecutor(CustomActionExecutor):
+    """gRPC-based implementation of the CustomActionExecutor.
+
+    Executes custom actions by making gRPC requests to the action endpoint.
+    """
+
+    def __init__(
+        self,
+        action_name: str,
+        action_endpoint: EndpointConfig,
+    ) -> None:
+        """Initializes the gRPC custom action executor.
+
+        Args:
+            action_name: Name of the custom action.
+            action_endpoint: Endpoint configuration of the custom action.
+        """
+        self.action_name = action_name
+        self.request_writer = CustomActionRequestWriter(action_name, action_endpoint)
+        self.action_endpoint = action_endpoint
+
+        parsed_url = urlparse(self.action_endpoint.url)
+        self.request_url = parsed_url.netloc
+
+        self.cert_ca = (
+            file_as_bytes(self.action_endpoint.cafile)
+            if self.action_endpoint.cafile
+            else None
+        )
+
+        self.client_cert = None
+        self.client_key = None
+
+        client_cert_file = self.action_endpoint.kwargs.get(SSL_CLIENT_CERT_FIELD)
+        client_key_file = self.action_endpoint.kwargs.get(SSL_CLIENT_KEY_FIELD)
+        if client_cert_file and client_key_file:
+            self.client_cert = file_as_bytes(client_cert_file)
+            self.client_key = file_as_bytes(client_key_file)
+        elif client_key_file and not client_cert_file:
+            structlogger.error(
+                f"rasa.core.actions.grpc_custom_action_executor.{SSL_CLIENT_CERT_FIELD}_missing",
+                event_info=(
+                    f"Client key file '{SSL_CLIENT_KEY_FIELD}' is provided but "
+                    f"client certificate file '{SSL_CLIENT_CERT_FIELD}' "
+                    f"is not provided in the endpoint configuration. "
+                    f"Both fields are required for client TLS authentication."
+                    f"Continuing without client TLS authentication."
+                ),
+            )
+        elif client_cert_file and not client_key_file:
+            structlogger.error(
+                f"rasa.core.actions.grpc_custom_action_executor.{SSL_CLIENT_KEY_FIELD}_missing",
+                event_info=(
+                    f"Client certificate file '{SSL_CLIENT_CERT_FIELD}' "
+                    f" is provided but client key file '{SSL_CLIENT_KEY_FIELD}'"
+                    f" is not provided in the endpoint configuration. "
+                    f"Both fields are required for client TLS authentication."
+                    f"Continuing without client TLS authentication."
+                ),
+            )
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[str, Any]:
+        """Execute the custom action using a gRPC request.
+
+        Args:
+            tracker: Tracker for the current conversation.
+            domain: Domain of the assistant.
+            include_domain: If True, the domain information is included in the request.
+
+        Returns:
+            Response from the action server.
+        """
+
+        request = self._create_payload(
+            tracker=tracker, domain=domain, include_domain=include_domain
+        )
+
+        return self._request(request)
+
+    def _request(
+        self,
+        request: action_webhook_pb2.WebhookRequest,
+    ) -> Dict[str, Any]:
+        """Perform a single gRPC request to the action server.
+
+        Args:
+            request: gRPC Request to be sent to the action server.
+
+        Returns:
+            Response from the action server.
+        """
+
+        client = self._create_grpc_client()
+        metadata = self._build_metadata()
+        try:
+            response = client.Webhook(request, metadata=metadata)
+            return MessageToDict(response)
+        except grpc.RpcError as rpc_error:
+            if not isinstance(rpc_error, grpc.Call):
+                raise RasaException(
+                    f"Failed to execute custom action '{self.action_name}'. "
+                    f"Unknown error occurred while calling the "
+                    f"action server over gRPC protocol."
+                )
+
+            status_code = rpc_error.code()
+            details = rpc_error.details()
+            if status_code is not grpc.StatusCode.NOT_FOUND:
+                raise RasaException(
+                    f"Failed to execute custom action '{self.action_name}'. "
+                    f"Error: {details}"
+                )
+
+            resource_not_found_error = ResourceNotFound.model_validate_json(details)
+            if (
+                resource_not_found_error
+                and resource_not_found_error.resource_type
+                == ResourceNotFoundType.DOMAIN
+            ):
+                structlogger.error(
+                    "rasa.core.actions.grpc_custom_action_executor.domain_not_found",
+                    event_info=(
+                        f"Failed to execute custom action '{self.action_endpoint}'. "
+                        f"Could not find domain. {resource_not_found_error.message}"
+                    ),
+                )
+                raise DomainNotFound()
+            raise RasaException(
+                f"Failed to execute custom action '{self.action_name}'. "
+                f"Error: {details}"
+            )
+
+    def _build_metadata(self) -> List[Tuple[str, Any]]:
+        """Build metadata for the gRPC request.
+
+        Returns:
+            Metadata for the gRPC request.
+        """
+        metadata = []
+        for key, value in self.action_endpoint.headers.items():
+            metadata.append((key, value))
+        return metadata
+
+    def _create_payload(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> action_webhook_pb2.WebhookRequest:
+        """Create the gRPC payload for the action server.
+
+        Args:
+            tracker: Tracker for the current conversation.
+            domain: Domain of the assistant.
+            include_domain: If True, the domain information is included in the request.
+
+        Returns:
+            gRPC payload for the action server.
+        """
+        json_body = self.request_writer.create(
+            tracker=tracker, domain=domain, include_domain=include_domain
+        )
+
+        request_proto = action_webhook_pb2.WebhookRequest()
+
+        try:
+            return ParseDict(
+                js_dict=json_body, message=request_proto, ignore_unknown_fields=True
+            )
+        except Exception:
+            structlogger.warning(
+                (
+                    "rasa.core.actions.grpc_custom_action_executor."
+                    "create_grpc_payload_from_dict_failed"
+                ),
+                event_info=(
+                    "Failed to create gRPC payload from Python dictionary. "
+                    "Falling back to create payload from JSON intermediary."
+                ),
+            )
+            json_text = json.dumps(json_body)
+            return Parse(
+                text=json_text, message=request_proto, ignore_unknown_fields=True
+            )
+
+    def _create_grpc_client(
+        self,
+    ) -> action_webhook_pb2_grpc.ActionServiceStub:
+        """Create a gRPC client for the action server.
+
+        Returns:
+            gRPC client for the action server.
+        """
+        channel = self._create_channel()
+        return action_webhook_pb2_grpc.ActionServiceStub(channel)
+
+    def _create_channel(
+        self,
+    ) -> grpc.Channel:
+        """Create a gRPC channel for the action server.
+
+        Returns:
+            gRPC channel for the action server.
+        """
+
+        compression = grpc.Compression.Gzip
+
+        if self.cert_ca:
+            credentials = grpc.ssl_channel_credentials(
+                root_certificates=self.cert_ca,
+                private_key=self.client_key,
+                certificate_chain=self.client_cert,
+            )
+            return grpc.secure_channel(
+                target=self.request_url,
+                credentials=credentials,
+                compression=compression,
+            )
+        return grpc.insecure_channel(target=self.request_url, compression=compression)

rasa/core/actions/http_custom_action_executor.py

@@ -0,0 +1,140 @@
+import json
+import logging
+from typing import TYPE_CHECKING, Any, Dict
+
+import aiohttp
+
+from rasa.core.actions.action_exceptions import ActionExecutionRejection, DomainNotFound
+from rasa.core.actions.custom_action_executor import (
+    CustomActionExecutor,
+    CustomActionRequestWriter,
+)
+from rasa.core.constants import (
+    COMPRESS_ACTION_SERVER_REQUEST_ENV_NAME,
+    DEFAULT_COMPRESS_ACTION_SERVER_REQUEST,
+    DEFAULT_REQUEST_TIMEOUT,
+)
+from rasa.shared.exceptions import RasaException
+from rasa.utils.common import get_bool_env_variable
+from rasa.utils.endpoints import ClientResponseError, EndpointConfig
+
+if TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+
+logger = logging.getLogger(__name__)
+
+
+class HTTPCustomActionExecutor(CustomActionExecutor):
+    """HTTP-based implementation of the CustomActionExecutor.
+
+    Executes custom actions by making HTTP POST requests to the action endpoint.
+    """
+
+    def __init__(
+        self,
+        action_name: str,
+        action_endpoint: EndpointConfig,
+    ) -> None:
+        self.action_name = action_name
+        self.action_endpoint = action_endpoint
+        self.request_writer = CustomActionRequestWriter(action_name, action_endpoint)
+        self.should_compress = get_bool_env_variable(
+            COMPRESS_ACTION_SERVER_REQUEST_ENV_NAME,
+            DEFAULT_COMPRESS_ACTION_SERVER_REQUEST,
+        )
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[str, Any]:
+        """Execute the custom action using an HTTP POST request.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If `True`, the domain information
+                            is included in the request.
+
+        Returns:
+            A dictionary containing the response from the custom action endpoint.
+
+        Raises:
+            RasaException: If an error occurs while making the HTTP request.
+        """
+        try:
+            logger.debug(
+                "Calling action endpoint to run action '{}'.".format(self.action_name)
+            )
+
+            json_body = self.request_writer.create(
+                tracker=tracker, domain=domain, include_domain=include_domain
+            )
+
+            response = await self._perform_request_with_retries(json_body)
+
+            if response is None:
+                response = {}
+
+            return response
+
+        except ClientResponseError as e:
+            if e.status == 400:
+                response_data = json.loads(e.text)
+                exception = ActionExecutionRejection(
+                    response_data["action_name"], response_data.get("error")
+                )
+                logger.error(exception.message)
+                raise exception
+            else:
+                raise RasaException(
+                    f"Failed to execute custom action '{self.action_name}'"
+                ) from e
+
+        except aiohttp.ClientConnectionError as e:
+            logger.error(
+                f"Failed to run custom action '{self.action_name}'. Couldn't connect "
+                f"to the server at '{self.action_endpoint.url}'. "
+                f"Is the server running? "
+                f"Error: {e}"
+            )
+            raise RasaException(
+                f"Failed to execute custom action '{self.action_name}'. "
+                f"Couldn't connect to the server at '{self.action_endpoint.url}."
+            )
+
+        except aiohttp.ClientError as e:
+            # not all errors have a status attribute, but
+            # helpful to log if they got it
+
+            # noinspection PyUnresolvedReferences
+            status = getattr(e, "status", None)
+            raise RasaException(
+                "Failed to run custom action '{}'. Action server "
+                "responded with a non 200 status code of {}. "
+                "Make sure your action server properly runs actions "
+                "and returns a 200 once the action is executed. "
+                "Error: {}".format(self.action_name, status, e)
+            )
+
+    async def _perform_request_with_retries(
+        self,
+        json_body: Dict[str, Any],
+    ) -> Any:
+        """Attempts to perform the request with retries if necessary."""
+        assert self.action_endpoint is not None
+        try:
+            return await self.action_endpoint.request(
+                json=json_body,
+                method="post",
+                timeout=DEFAULT_REQUEST_TIMEOUT,
+                compress=self.should_compress,
+            )
+        except ClientResponseError as e:
+            # Repeat the request because Domain was not in the payload
+            if e.status == 449:
+                raise DomainNotFound()
+            raise e

rasa/core/actions/loops.py

@@ -28,6 +28,7 @@ class LoopAction(Action, ABC):
                 nlg,
                 tracker,
                 domain,
+                metadata,
             )
 
         if not await self.is_done(output_channel, nlg, tracker, domain, events):
@@ -60,6 +61,7 @@ class LoopAction(Action, ABC):
         nlg: "NaturalLanguageGenerator",
         tracker: "DialogueStateTracker",
         domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
     ) -> List[Event]:
         # can be overwritten
         return []
@@ -104,6 +106,7 @@ class LoopAction(Action, ABC):
         nlg: "NaturalLanguageGenerator",
         tracker: "DialogueStateTracker",
         domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
     ) -> List[Event]:
         events = self._default_activation_events()
         events += await self.activate(output_channel, nlg, tracker, domain)

rasa/core/actions/two_stage_fallback.py

@@ -181,6 +181,6 @@ def _message_clarification(tracker: DialogueStateTracker) -> List[Event]:
         )
 
     clarification = copy.deepcopy(latest_message)
-    clarification.parse_data[INTENT][PREDICTED_CONFIDENCE_KEY] = 1.0  # type: ignore[literal-required]  # noqa E501
+    clarification.parse_data[INTENT][PREDICTED_CONFIDENCE_KEY] = 1.0  # type: ignore[literal-required]
     clarification.timestamp = time.time()
     return [ActionExecuted(ACTION_LISTEN_NAME), clarification]