rasa-pro 3.12.0.dev1__py3-none-any.whl

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 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 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,145 @@
+import json
+import logging
+from typing import Any, Dict, Optional, TYPE_CHECKING
+
+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.core.domain import Domain
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import RasaException
+from rasa.utils.common import get_bool_env_variable
+
+if TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+from rasa.utils.endpoints import ClientResponseError, EndpointConfig
+
+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: Optional["Domain"] = None,
+        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 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.
+        """
+        from rasa.core.actions.action import RemoteActionJSONValidator
+
+        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 = {}
+
+            RemoteActionJSONValidator.validate(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

@@ -0,0 +1,114 @@
+from abc import ABC
+from typing import Any, Dict, List, TYPE_CHECKING, Optional, Text
+
+from rasa.core.actions.action import Action
+from rasa.shared.core.events import Event, ActiveLoop
+
+if TYPE_CHECKING:
+    from rasa.core.channels import OutputChannel
+    from rasa.shared.core.domain import Domain
+    from rasa.core.nlg import NaturalLanguageGenerator
+    from rasa.shared.core.trackers import DialogueStateTracker
+
+
+class LoopAction(Action, ABC):
+    async def run(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        events: List[Event] = []
+
+        if not await self.is_activated(output_channel, nlg, tracker, domain):
+            events += await self._activate_loop(
+                output_channel,
+                nlg,
+                tracker,
+                domain,
+                metadata,
+            )
+
+        if not await self.is_done(output_channel, nlg, tracker, domain, events):
+            events += await self.do(output_channel, nlg, tracker, domain, events)
+
+        if await self.is_done(output_channel, nlg, tracker, domain, events):
+            events += self._default_deactivation_events()
+            events += await self.deactivate(
+                output_channel, nlg, tracker, domain, events
+            )
+
+        return events
+
+    async def is_activated(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+    ) -> bool:
+        return tracker.active_loop_name == self.name()
+
+    # default implementation checks if form active
+    def _default_activation_events(self) -> List[Event]:
+        return [ActiveLoop(self.name())]
+
+    async def activate(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        # can be overwritten
+        return []
+
+    async def do(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        events_so_far: List[Event],
+    ) -> List[Event]:
+        raise NotImplementedError()
+
+    async def is_done(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        events_so_far: List[Event],
+    ) -> bool:
+        raise NotImplementedError()
+
+    def _default_deactivation_events(self) -> List[Event]:
+        return [ActiveLoop(None)]
+
+    async def deactivate(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        events_so_far: List[Event],
+    ) -> List[Event]:
+        # can be overwritten
+        return []
+
+    async def _activate_loop(
+        self,
+        output_channel: "OutputChannel",
+        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)
+
+        return events

rasa/core/actions/two_stage_fallback.py

@@ -0,0 +1,186 @@
+import copy
+import time
+from typing import List, Text, Optional
+
+from rasa.core.actions import action
+from rasa.core.actions.loops import LoopAction
+from rasa.core.channels import OutputChannel
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import (
+    Event,
+    UserUtteranceReverted,
+    ActionExecuted,
+    UserUttered,
+    ActiveLoop,
+)
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
+from rasa.shared.constants import DEFAULT_NLU_FALLBACK_INTENT_NAME
+from rasa.shared.core.constants import (
+    USER_INTENT_OUT_OF_SCOPE,
+    ACTION_LISTEN_NAME,
+    ACTION_DEFAULT_FALLBACK_NAME,
+    ACTION_DEFAULT_ASK_AFFIRMATION_NAME,
+    ACTION_DEFAULT_ASK_REPHRASE_NAME,
+    ACTION_TWO_STAGE_FALLBACK_NAME,
+)
+from rasa.shared.nlu.constants import INTENT, PREDICTED_CONFIDENCE_KEY
+from rasa.utils.endpoints import EndpointConfig
+
+
+class TwoStageFallbackAction(LoopAction):
+    def __init__(self, action_endpoint: Optional[EndpointConfig] = None) -> None:
+        self._action_endpoint = action_endpoint
+
+    def name(self) -> Text:
+        return ACTION_TWO_STAGE_FALLBACK_NAME
+
+    async def do(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        events_so_far: List[Event],
+    ) -> List[Event]:
+        if _user_should_affirm(tracker, events_so_far):
+            return await self._ask_affirm(output_channel, nlg, tracker, domain)
+
+        return await self._ask_rephrase(output_channel, nlg, tracker, domain)
+
+    async def _ask_affirm(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+    ) -> List[Event]:
+        affirm_action = action.action_for_name_or_text(
+            ACTION_DEFAULT_ASK_AFFIRMATION_NAME, domain, self._action_endpoint
+        )
+
+        return await affirm_action.run(output_channel, nlg, tracker, domain)
+
+    async def _ask_rephrase(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+    ) -> List[Event]:
+        rephrase = action.action_for_name_or_text(
+            ACTION_DEFAULT_ASK_REPHRASE_NAME, domain, self._action_endpoint
+        )
+
+        return await rephrase.run(output_channel, nlg, tracker, domain)
+
+    async def is_done(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        events_so_far: List[Event],
+    ) -> bool:
+        _user_clarified = _last_intent_name(tracker) not in [
+            DEFAULT_NLU_FALLBACK_INTENT_NAME,
+            USER_INTENT_OUT_OF_SCOPE,
+        ]
+        return (
+            _user_clarified
+            or _two_fallbacks_in_a_row(tracker)
+            or _second_affirmation_failed(tracker)
+        )
+
+    async def deactivate(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        events_so_far: List[Event],
+    ) -> List[Event]:
+        if _two_fallbacks_in_a_row(tracker) or _second_affirmation_failed(tracker):
+            return await self._give_up(output_channel, nlg, tracker, domain)
+
+        # revert fallback events
+        reverted_event: List[Event] = [UserUtteranceReverted()]
+        return reverted_event + _message_clarification(tracker)
+
+    async def _give_up(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+    ) -> List[Event]:
+        fallback = action.action_for_name_or_text(
+            ACTION_DEFAULT_FALLBACK_NAME, domain, self._action_endpoint
+        )
+
+        return await fallback.run(output_channel, nlg, tracker, domain)
+
+
+def _last_intent_name(tracker: DialogueStateTracker) -> Optional[Text]:
+    last_message = tracker.latest_message
+    if not last_message:
+        return None
+
+    return last_message.intent_name
+
+
+def _two_fallbacks_in_a_row(tracker: DialogueStateTracker) -> bool:
+    return _last_n_intent_names(tracker, 2) == [
+        DEFAULT_NLU_FALLBACK_INTENT_NAME,
+        DEFAULT_NLU_FALLBACK_INTENT_NAME,
+    ]
+
+
+def _last_n_intent_names(
+    tracker: DialogueStateTracker, number_of_last_intent_names: int
+) -> List[Optional[Text]]:
+    intent_names: List[Optional[Text]] = []
+    for i in range(number_of_last_intent_names):
+        message = tracker.get_last_event_for(
+            (UserUttered, UserUtteranceReverted),
+            skip=i,
+            event_verbosity=EventVerbosity.AFTER_RESTART,
+        )
+        if isinstance(message, UserUttered):
+            intent_names.append(message.intent.get("name"))
+
+    return intent_names
+
+
+def _user_should_affirm(
+    tracker: DialogueStateTracker, events_so_far: List[Event]
+) -> bool:
+    fallback_was_just_activated = any(
+        isinstance(event, ActiveLoop) for event in events_so_far
+    )
+    if fallback_was_just_activated:
+        return True
+
+    return _last_intent_name(tracker) == DEFAULT_NLU_FALLBACK_INTENT_NAME
+
+
+def _second_affirmation_failed(tracker: DialogueStateTracker) -> bool:
+    return _last_n_intent_names(tracker, 3) == [
+        USER_INTENT_OUT_OF_SCOPE,
+        DEFAULT_NLU_FALLBACK_INTENT_NAME,
+        USER_INTENT_OUT_OF_SCOPE,
+    ]
+
+
+def _message_clarification(tracker: DialogueStateTracker) -> List[Event]:
+    latest_message = tracker.latest_message
+    if not latest_message:
+        raise TypeError(
+            "Cannot issue message clarification because "
+            "latest message is not on tracker."
+        )
+
+    clarification = copy.deepcopy(latest_message)
+    clarification.parse_data[INTENT][PREDICTED_CONFIDENCE_KEY] = 1.0  # type: ignore[literal-required]
+    clarification.timestamp = time.time()
+    return [ActionExecuted(ACTION_LISTEN_NAME), clarification]