rasa-pro 3.9.18__py3-none-any.whl → 3.10.3__py3-none-any.whl

rasa/core/actions/action.py

@@ -1,14 +1,15 @@
 import copy
 import logging
+from functools import lru_cache
 from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
     List,
-    Text,
     Optional,
-    Dict,
-    Any,
-    TYPE_CHECKING,
-    Tuple,
     Set,
+    Text,
+    Tuple,
     cast,
 )
 
@@ -16,59 +17,68 @@ import rasa.core
 import rasa.shared.utils.io
 from rasa.core.actions.custom_action_executor import (
     CustomActionExecutor,
-    RetryCustomActionExecutor,
     NoEndpointCustomActionExecutor,
+    RetryCustomActionExecutor,
+)
+from rasa.core.actions.direct_custom_actions_executor import DirectCustomActionExecutor
+from rasa.core.actions.e2e_stub_custom_action_executor import (
+    E2EStubCustomActionExecutor,
 )
 from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
 from rasa.core.actions.http_custom_action_executor import HTTPCustomActionExecutor
+from rasa.core.constants import (
+    UTTER_SOURCE_METADATA_KEY,
+)
 from rasa.core.policies.policy import PolicyPrediction
+from rasa.core.utils import add_bot_utterance_metadata
+from rasa.e2e_test.constants import KEY_STUB_CUSTOM_ACTIONS
 from rasa.nlu.constants import (
     RESPONSE_SELECTOR_DEFAULT_INTENT,
-    RESPONSE_SELECTOR_PROPERTY_NAME,
     RESPONSE_SELECTOR_PREDICTION_KEY,
+    RESPONSE_SELECTOR_PROPERTY_NAME,
     RESPONSE_SELECTOR_UTTER_ACTION_KEY,
 )
 from rasa.shared.constants import (
-    DOCS_BASE_URL,
     DEFAULT_NLU_FALLBACK_INTENT_NAME,
+    DOCS_BASE_URL,
+    FLOW_PREFIX,
     ROUTE_TO_CALM_SLOT,
     UTTER_PREFIX,
-    FLOW_PREFIX,
 )
 from rasa.shared.core.constants import (
-    ACTION_RESET_ROUTING,
-    USER_INTENT_OUT_OF_SCOPE,
+    ACTION_BACK_NAME,
+    ACTION_DEACTIVATE_LOOP_NAME,
+    ACTION_DEFAULT_ASK_AFFIRMATION_NAME,
+    ACTION_DEFAULT_ASK_REPHRASE_NAME,
+    ACTION_DEFAULT_FALLBACK_NAME,
+    ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
+    ACTION_RESET_ROUTING,
     ACTION_RESTART_NAME,
+    ACTION_REVERT_FALLBACK_EVENTS_NAME,
     ACTION_SEND_TEXT_NAME,
     ACTION_SESSION_START_NAME,
-    ACTION_DEFAULT_FALLBACK_NAME,
-    ACTION_DEACTIVATE_LOOP_NAME,
-    ACTION_REVERT_FALLBACK_EVENTS_NAME,
-    ACTION_DEFAULT_ASK_AFFIRMATION_NAME,
-    ACTION_DEFAULT_ASK_REPHRASE_NAME,
     ACTION_UNLIKELY_INTENT_NAME,
-    ACTION_BACK_NAME,
-    REQUESTED_SLOT,
-    ACTION_EXTRACT_SLOTS,
-    DEFAULT_SLOT_NAMES,
     ACTION_VALIDATE_SLOT_MAPPINGS,
+    DEFAULT_SLOT_NAMES,
+    KNOWLEDGE_BASE_SLOT_NAMES,
     MAPPING_TYPE,
+    REQUESTED_SLOT,
+    USER_INTENT_OUT_OF_SCOPE,
     SlotMappingType,
-    KNOWLEDGE_BASE_SLOT_NAMES,
 )
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import (
-    RoutingSessionEnded,
-    UserUtteranceReverted,
-    UserUttered,
     ActionExecuted,
-    Event,
-    BotUttered,
-    SlotSet,
     ActiveLoop,
+    BotUttered,
+    Event,
     Restarted,
+    RoutingSessionEnded,
     SessionStarted,
+    SlotSet,
+    UserUtteranceReverted,
+    UserUttered,
 )
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.slot_mappings import (
@@ -81,28 +91,30 @@ from rasa.shared.nlu.constants import (
     INTENT_NAME_KEY,
     INTENT_RANKING_KEY,
 )
+from rasa.shared.utils.io import raise_warning
 from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
-from rasa.utils.endpoints import EndpointConfig, ClientResponseError
-from rasa.utils.url_tools import get_url_schema, UrlSchema
+from rasa.utils.endpoints import ClientResponseError, EndpointConfig
+from rasa.utils.url_tools import UrlSchema, get_url_schema
 
 if TYPE_CHECKING:
-    from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.core.channels.channel import OutputChannel
+    from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.events import IntentPrediction
 
+
 logger = logging.getLogger(__name__)
 
 
 def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["Action"]:
     """List default actions."""
-    from rasa.core.actions.two_stage_fallback import TwoStageFallbackAction
-    from rasa.dialogue_understanding.patterns.correction import ActionCorrectFlowSlot
-    from rasa.dialogue_understanding.patterns.cancel import ActionCancelFlow
-    from rasa.dialogue_understanding.patterns.clarify import ActionClarifyFlows
+    from rasa.core.actions.action_clean_stack import ActionCleanStack
     from rasa.core.actions.action_run_slot_rejections import ActionRunSlotRejections
     from rasa.core.actions.action_trigger_chitchat import ActionTriggerChitchat
     from rasa.core.actions.action_trigger_search import ActionTriggerSearch
-    from rasa.core.actions.action_clean_stack import ActionCleanStack
+    from rasa.core.actions.two_stage_fallback import TwoStageFallbackAction
+    from rasa.dialogue_understanding.patterns.cancel import ActionCancelFlow
+    from rasa.dialogue_understanding.patterns.clarify import ActionClarifyFlows
+    from rasa.dialogue_understanding.patterns.correction import ActionCorrectFlowSlot
 
     return [
         ActionListen(),
@@ -130,7 +142,9 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
 
 
 def action_for_index(
-    index: int, domain: Domain, action_endpoint: Optional[EndpointConfig]
+    index: int,
+    domain: Domain,
+    action_endpoint: Optional[EndpointConfig],
 ) -> "Action":
     """Get an action based on its index in the list of available actions.
 
@@ -153,7 +167,9 @@ def action_for_index(
         )
 
     return action_for_name_or_text(
-        domain.action_names_or_texts[index], domain, action_endpoint
+        domain.action_names_or_texts[index],
+        domain,
+        action_endpoint,
     )
 
 
@@ -177,7 +193,9 @@ def is_retrieval_action(action_name: Text, retrieval_intents: List[Text]) -> boo
 
 
 def action_for_name_or_text(
-    action_name_or_text: Text, domain: Domain, action_endpoint: Optional[EndpointConfig]
+    action_name_or_text: Text,
+    domain: Domain,
+    action_endpoint: Optional[EndpointConfig],
 ) -> "Action":
     """Retrieves an action by its name or by its text in case it's an end-to-end action.
 
@@ -347,8 +365,11 @@ class ActionBotResponse(Action):
                     )
                 )
             return []
-        message["utter_action"] = self.utter_action
 
+        message.update(metadata or {})
+        message = add_bot_utterance_metadata(
+            message, self.utter_action, nlg, domain, tracker
+        )
         return [create_bot_utterance(message)]
 
     def name(self) -> Text:
@@ -702,12 +723,15 @@ class ActionDeactivateLoop(Action):
 
 class RemoteAction(Action):
     def __init__(
-        self, name: Text, action_endpoint: Optional[EndpointConfig] = None
+        self,
+        name: Text,
+        action_endpoint: Optional[EndpointConfig] = None,
     ) -> None:
         self._name = name
         self.action_endpoint = action_endpoint
         self.executor = self._create_executor()
 
+    @lru_cache(maxsize=1)
     def _create_executor(self) -> CustomActionExecutor:
         """Creates an executor based on the action endpoint configuration.
 
@@ -717,10 +741,22 @@ class RemoteAction(Action):
         Raises:
             RasaException: If no valid action endpoint is configured.
         """
-
         if not self.action_endpoint:
             return NoEndpointCustomActionExecutor(self.name())
 
+        if self.action_endpoint.kwargs.get(KEY_STUB_CUSTOM_ACTIONS):
+            return E2EStubCustomActionExecutor(self.name(), self.action_endpoint)
+
+        if self.action_endpoint.url and self.action_endpoint.actions_module:
+            raise_warning(
+                "Both 'actions_module' and 'url' are defined. "
+                "As they are mutually exclusive and 'actions_module' "
+                "is prioritized, actions will be executed by the assistant."
+            )
+
+        if self.action_endpoint and self.action_endpoint.actions_module:
+            return DirectCustomActionExecutor(self.name(), self.action_endpoint)
+
         url_schema = get_url_schema(self.action_endpoint.url)
 
         if url_schema == UrlSchema.GRPC:
@@ -760,8 +796,7 @@ class RemoteAction(Action):
         return schema
 
     def _validate_action_result(self, result: Dict[Text, Any]) -> bool:
-        from jsonschema import validate
-        from jsonschema import ValidationError
+        from jsonschema import ValidationError, validate
 
         try:
             validate(result, self.action_response_format_spec())
@@ -781,20 +816,25 @@ class RemoteAction(Action):
         output_channel: "OutputChannel",
         nlg: "NaturalLanguageGenerator",
         tracker: "DialogueStateTracker",
+        **kwargs: Any,
     ) -> List[BotUttered]:
         """Use the responses generated by the action endpoint and utter them."""
         bot_messages = []
+        domain: Domain = kwargs.get("domain", None)
+        action_name: str = kwargs.get("action_name", None)
         for response in responses:
             generated_response = response.pop("response", None)
-            if generated_response:
+            if generated_response is not None:
                 draft = await nlg.generate(
                     generated_response, tracker, output_channel.name(), **response
                 )
                 if not draft:
                     continue
-                draft["utter_action"] = generated_response
+                draft = add_bot_utterance_metadata(
+                    draft, generated_response, nlg, domain, tracker
+                )
             else:
-                draft = {}
+                draft = {UTTER_SOURCE_METADATA_KEY: action_name}
 
             buttons = response.pop("buttons", []) or []
             if buttons:
@@ -817,13 +857,21 @@ class RemoteAction(Action):
         metadata: Optional[Dict[Text, Any]] = None,
     ) -> List[Event]:
         """Runs action. Please see parent class for the full docstring."""
-        response = await self.executor.run(tracker=tracker, domain=domain)
+        response = await self.executor.run(
+            domain=domain,
+            tracker=tracker,
+        )
         self._validate_action_result(response)
 
         events_json = response.get("events", [])
         responses = response.get("responses", [])
         bot_messages = await self._utter_responses(
-            responses, output_channel, nlg, tracker
+            responses,
+            output_channel,
+            nlg,
+            tracker,
+            domain=domain,
+            action_name=self.name(),
         )
 
         events = rasa.shared.core.events.deserialise_events(events_json)
@@ -1029,7 +1077,8 @@ class ActionSendText(Action):
     ) -> List[Event]:
         """Runs action. Please see parent class for the full docstring."""
         fallback = {"text": ""}
-        message = metadata.get("message", fallback) if metadata else fallback
+        metadata_copy = copy.deepcopy(metadata) if metadata else {}
+        message = metadata_copy.get("message", fallback)
         return [create_bot_utterance(message)]
 
 

rasa/core/actions/action_run_slot_rejections.py

@@ -5,6 +5,7 @@ from jinja2 import Template
 from pypred import Predicate
 
 from rasa.core.actions.action import Action, create_bot_utterance
+from rasa.core.utils import add_bot_utterance_metadata
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
 )
@@ -201,7 +202,9 @@ class ActionRunSlotRejections(Action):
                 utterance=utterance,
             )
         else:
-            message["utter_action"] = utterance
+            message = add_bot_utterance_metadata(
+                message, utterance, nlg, domain, tracker
+            )
             events.append(create_bot_utterance(message))
 
         return events

rasa/core/actions/custom_action_executor.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import abc
 import logging
 from typing import TYPE_CHECKING, Any, Dict, Text
@@ -36,7 +38,7 @@ class CustomActionExecutor(abc.ABC):
         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.
+            include_domain: If True, the domain is included in the request.
 
         Returns:
             The response from the execution of the custom action.
@@ -71,8 +73,7 @@ class NoEndpointCustomActionExecutor(CustomActionExecutor):
         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.
+            include_domain: If True, the domain is included in the request.
 
         Returns:
             The response from the execution of the custom action.
@@ -123,7 +124,7 @@ class CustomActionRequestWriter:
         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.
+            include_domain: If True, the domain is included in the request.
 
         Returns:
             A JSON payload to be sent to the action server.
@@ -173,14 +174,16 @@ class RetryCustomActionExecutor(CustomActionExecutor):
         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
+            include_domain: If True, the domain 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
+                tracker,
+                domain,
+                include_domain=include_domain,
             )
         except DomainNotFound:
             return await self._custom_action_executor.run(

rasa/core/actions/direct_custom_actions_executor.py

@@ -0,0 +1,80 @@
+from importlib.util import find_spec
+from typing import (
+    Any,
+    Dict,
+    Text,
+)
+
+import structlog
+from rasa_sdk.executor import ActionExecutor
+
+import rasa
+from rasa.core.actions.custom_action_executor import (
+    CustomActionExecutor,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
+
+structlogger = structlog.get_logger(__name__)
+
+
+class DirectCustomActionExecutor(CustomActionExecutor):
+    def __init__(self, action_name: str, action_endpoint: EndpointConfig):
+        """Initializes the direct custom action executor.
+
+        Args:
+            action_name: Name of the custom action.
+            action_endpoint: The endpoint to execute custom actions.
+        """
+        self.action_name = action_name
+        self.action_endpoint = action_endpoint
+        self.action_executor = ActionExecutor()
+
+    def register_actions_from_a_module(self) -> None:
+        module_name = self.action_endpoint.actions_module
+        if not find_spec(module_name):
+            raise RasaException(
+                f"You've provided the custom actions module '{module_name}' "
+                f"to run directly by the rasa server, however this module does "
+                f"not exist. Please check for typos in your `endpoints.yml` file."
+            )
+
+        self.action_executor.register_package(module_name)
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        """Executes the custom action directly.
+
+        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:
+            The response from the execution of the custom action.
+        """
+        structlogger.debug(
+            "action.direct_custom_action_executor.run",
+            action_name=self.action_name,
+        )
+        self.register_actions_from_a_module()
+
+        tracker_state = tracker.current_state(EventVerbosity.ALL)
+        action_call = {
+            "next_action": self.action_name,
+            "sender_id": tracker.sender_id,
+            "tracker": tracker_state,
+            "version": rasa.__version__,
+        }
+
+        if domain:
+            action_call["domain"] = domain.as_dict()
+
+        result = await self.action_executor.run(action_call)
+        return result.model_dump() if result else {}

rasa/core/actions/e2e_stub_custom_action_executor.py

@@ -0,0 +1,68 @@
+import typing
+from typing import (
+    Any,
+    Dict,
+    Text,
+)
+
+import structlog
+
+from rasa.core.actions.custom_action_executor import (
+    CustomActionExecutor,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import EndpointConfig
+
+if typing.TYPE_CHECKING:
+    from rasa.e2e_test.stub_custom_action import StubCustomAction
+
+structlogger = structlog.get_logger(__name__)
+
+
+class E2EStubCustomActionExecutor(CustomActionExecutor):
+    def __init__(
+        self,
+        action_name: str,
+        action_endpoint: EndpointConfig,
+    ):
+        """Initializes the e2e stub custom action executor.
+
+        Args:
+            action_name: Name of the custom action.
+            action_endpoint: The endpoint to execute custom actions.
+        """
+        self.action_name = action_name
+        self.action_endpoint = action_endpoint
+        self.stub_custom_action = self.get_stub_custom_action()
+
+    def get_stub_custom_action(self) -> "StubCustomAction":
+        from rasa.e2e_test.stub_custom_action import get_stub_custom_action
+
+        stub_custom_action = get_stub_custom_action(
+            self.action_endpoint, self.action_name
+        )
+
+        if stub_custom_action:
+            return stub_custom_action
+
+        # TODO Update message below with reference to the docs
+        raise RasaException(
+            f"You are using custom action stubs, however action `{self.action_name}` "
+            f"has not been stubbed. Note that you cannot stub some custom actions "
+            f"while running an action server instance, you must stub all custom "
+            f"actions called by the tests in the provided test path."
+        )
+
+    async def run(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> Dict[Text, Any]:
+        structlogger.debug(
+            "action.e2e_stub_custom_action_executor.run",
+            action_name=self.action_name,
+        )
+        return self.stub_custom_action.as_dict()

rasa/core/actions/grpc_custom_action_executor.py

@@ -97,7 +97,7 @@ class GRPCCustomActionExecutor(CustomActionExecutor):
         Args:
             tracker: Tracker for the current conversation.
             domain: Domain of the assistant.
-            include_domain: If True, the domain information is included in the request.
+            include_domain: If True, the domain is included in the request.
 
         Returns:
             Response from the action server.
@@ -184,7 +184,7 @@ class GRPCCustomActionExecutor(CustomActionExecutor):
         Args:
             tracker: Tracker for the current conversation.
             domain: Domain of the assistant.
-            include_domain: If True, the domain information is included in the request.
+            include_domain: If True, the domain is included in the request.
 
         Returns:
             gRPC payload for the action server.

rasa/core/actions/http_custom_action_executor.py

@@ -1,6 +1,6 @@
 import json
 import logging
-from typing import TYPE_CHECKING, Any, Dict
+from typing import Any, Dict, Optional, TYPE_CHECKING
 
 import aiohttp
 
@@ -14,14 +14,16 @@ from rasa.core.constants import (
     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
-from rasa.utils.endpoints import ClientResponseError, EndpointConfig
 
 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__)
 
@@ -48,7 +50,7 @@ class HTTPCustomActionExecutor(CustomActionExecutor):
     async def run(
         self,
         tracker: "DialogueStateTracker",
-        domain: "Domain",
+        domain: Optional["Domain"] = None,
         include_domain: bool = False,
     ) -> Dict[str, Any]:
         """Execute the custom action using an HTTP POST request.
@@ -56,8 +58,7 @@ class HTTPCustomActionExecutor(CustomActionExecutor):
         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.
+            include_domain: If True, the domain is included in the request.
 
         Returns:
             A dictionary containing the response from the custom action endpoint.