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

rasa/cli/train.py

@@ -1,26 +1,34 @@
 import argparse
-import structlog
-import sys
 import asyncio
+import os
+import sys
 from pathlib import Path
 from typing import Dict, List, Optional, Text, Union
 
-from rasa.cli import SubParsersAction
-import rasa.cli.arguments.train as train_arguments
+import structlog
+from tarsafe import TarSafe
 
+import rasa.cli.arguments.train as train_arguments
 import rasa.cli.utils
 import rasa.core.utils
-from rasa.shared.importers.importer import TrainingDataImporter
 import rasa.utils.common
+from rasa.api import train as train_all
+from rasa.cli import SubParsersAction
+from rasa.core import ContextualResponseRephraser
 from rasa.core.nlg.generator import NaturalLanguageGenerator
 from rasa.core.train import do_compare_training
+from rasa.engine.validation import validate_api_type_config_key_usage
+from rasa.nlu.persistor import get_persistor
 from rasa.shared.constants import (
+    CONFIG_MANDATORY_KEYS,
     CONFIG_MANDATORY_KEYS_CORE,
     CONFIG_MANDATORY_KEYS_NLU,
-    CONFIG_MANDATORY_KEYS,
     DEFAULT_DATA_PATH,
     DEFAULT_DOMAIN_PATHS,
+    LLM_CONFIG_KEY,
 )
+from rasa.shared.exceptions import RasaException
+from rasa.shared.importers.importer import TrainingDataImporter
 
 structlogger = structlog.getLogger(__name__)
 
@@ -36,7 +44,7 @@ def add_subparser(
     """
     train_parser = subparsers.add_parser(
         "train",
-        help="Trains a Rasa model using your NLU data and stories.",
+        help="Trains a Rasa model using your CALM flows, NLU data and stories.",
         parents=parents,
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
@@ -70,6 +78,12 @@ def add_subparser(
 def _check_nlg_endpoint_validity(endpoint: Union[Path, str]) -> None:
     try:
         endpoints = rasa.core.utils.read_endpoints_from_path(endpoint)
+        if endpoints.nlg is not None:
+            validate_api_type_config_key_usage(
+                endpoints.nlg.kwargs,
+                LLM_CONFIG_KEY,
+                ContextualResponseRephraser.__name__,
+            )
         NaturalLanguageGenerator.create(endpoints.nlg)
     except Exception as e:
         structlogger.error(
@@ -83,6 +97,37 @@ def _check_nlg_endpoint_validity(endpoint: Union[Path, str]) -> None:
         sys.exit(1)
 
 
+def retrieve_and_unpack_bot_config_from_remote_storage(
+    args: argparse.Namespace,
+) -> None:
+    """Retrieve and unpack bot config from remote storage.
+
+    Bot config is retrieved from remote storage and unpacked
+    to the current working directory.
+    """
+    persistor = get_persistor(args.remote_storage)
+    if persistor is None:
+        raise RasaException(
+            f"Could not find a persistor for "
+            f"the storage type '{args.remote_storage}'."
+        )
+
+    current_working_directory = os.getcwd()
+
+    persistor.retrieve(args.remote_bot_config_path, current_working_directory)
+
+    remote_bot_config_tar_file_name = os.path.basename(args.remote_bot_config_path)
+
+    with TarSafe.open(remote_bot_config_tar_file_name, "r:gz") as tar:
+        tar.extractall(path=current_working_directory)
+
+    structlogger.debug(
+        "rasa.train.retrieve_and_unpack_bot_config.remove_downloaded_archive",
+        training_data_path=args.remote_bot_config_path,
+    )
+    os.remove(Path(current_working_directory).joinpath(remote_bot_config_tar_file_name))
+
+
 def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[Text]:
     """Trains a model.
 
@@ -94,7 +139,9 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
     Returns:
         Path to a trained model or `None` if training was not successful.
     """
-    from rasa import train as train_all
+    # retrieve and unpack bot_config from remote storage
+    if hasattr(args, "remote_bot_config_path") and args.remote_bot_config_path:
+        retrieve_and_unpack_bot_config_from_remote_storage(args)
 
     domain = rasa.cli.utils.get_validated_path(
         args.domain, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=True
@@ -137,6 +184,7 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
         nlu_additional_arguments=extract_nlu_additional_arguments(args),
         model_to_finetune=_model_for_finetuning(args),
         finetuning_epoch_fraction=args.epoch_fraction,
+        remote_storage=args.remote_storage,
     )
     if training_result.code != 0 and can_exit:
         sys.exit(training_result.code)

rasa/cli/utils.py

@@ -1,30 +1,32 @@
-import json
 import argparse
-import structlog
 import importlib
+import json
 import os
 import sys
 import time
 from pathlib import Path
 from types import FrameType
-from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Union, overload
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Union, overload
+
 import randomname
+import structlog
 
 import rasa.shared.utils.cli
 import rasa.shared.utils.io
-from rasa.shared.importers.importer import TrainingDataImporter
+from rasa import telemetry
 from rasa.shared.constants import (
     ASSISTANT_ID_DEFAULT_VALUE,
     ASSISTANT_ID_KEY,
     DEFAULT_CONFIG_PATH,
 )
-from rasa import telemetry
+from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.utils.yaml import read_config_file
 from rasa.utils.io import write_yaml
 
 if TYPE_CHECKING:
     from questionary import Question
     from typing_extensions import Literal
+
     from rasa.validator import Validator
 
 structlogger = structlog.get_logger()
@@ -462,3 +464,18 @@ def warn_if_rasa_plus_package_installed() -> None:
 def check_if_studio_command() -> bool:
     """Checks if the command is a Rasa Studio command."""
     return len(sys.argv) >= 2 and sys.argv[1] == "studio"
+
+
+def get_e2e_results_file_name(
+    results_output_path: Path,
+    result_type: str,
+) -> str:
+    """Returns the name of the e2e results file."""
+    if results_output_path.is_dir():
+        file_name = str(results_output_path) + f"/e2e_results_{result_type}.yml"
+    else:
+        parent = results_output_path.parent
+        stem = results_output_path.stem
+        file_name = str(parent) + f"/{stem}_{result_type}.yml"
+
+    return file_name

rasa/cli/x.py

@@ -179,7 +179,7 @@ def run_in_enterprise_connection_mode(args: argparse.Namespace) -> None:
     print_success("Starting a Rasa server in Rasa Enterprise connection mode... 🚀")
 
     credentials_path, endpoints_path = _get_credentials_and_endpoints_paths(args)
-    endpoints = AvailableEndpoints.read_endpoints(endpoints_path)
+    endpoints = AvailableEndpoints.get_instance(endpoints_path)
 
     _rasa_service(args, endpoints, None, credentials_path)
 

rasa/constants.py

@@ -18,7 +18,7 @@ CONFIG_TELEMETRY_ID = "rasa_user_id"
 CONFIG_TELEMETRY_ENABLED = "enabled"
 CONFIG_TELEMETRY_DATE = "date"
 
-MINIMUM_COMPATIBLE_VERSION = "3.9.16"
+MINIMUM_COMPATIBLE_VERSION = "3.10.12"
 
 GLOBAL_USER_CONFIG_PATH = os.path.expanduser("~/.config/rasa/global.yml")
 
@@ -27,6 +27,7 @@ ENV_LOG_LEVEL_LIBRARIES = "LOG_LEVEL_LIBRARIES"
 ENV_LOG_LEVEL_MATPLOTLIB = "LOG_LEVEL_MATPLOTLIB"
 ENV_LOG_LEVEL_RABBITMQ = "LOG_LEVEL_RABBITMQ"
 ENV_LOG_LEVEL_KAFKA = "LOG_LEVEL_KAFKA"
+ENV_LOG_LEVEL_MLFLOW = "LOG_LEVEL_MLFLOW"
 
 DEFAULT_SANIC_WORKERS = 1
 ENV_SANIC_WORKERS = "SANIC_WORKERS"
@@ -35,3 +36,8 @@ ENV_SANIC_BACKLOG = "SANIC_BACKLOG"
 ENV_GPU_CONFIG = "TF_GPU_MEMORY_ALLOC"
 ENV_CPU_INTER_OP_CONFIG = "TF_INTER_OP_PARALLELISM_THREADS"
 ENV_CPU_INTRA_OP_CONFIG = "TF_INTRA_OP_PARALLELISM_THREADS"
+
+MODEL_ARCHIVE_EXTENSION = "tar.gz"
+
+HTTP_STATUS_FORBIDDEN = 403
+HTTP_STATUS_NOT_FOUND = 404

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 {}