rasa-pro 3.14.0a20__py3-none-any.whl → 3.14.0a23__py3-none-any.whl

rasa/core/run.py

@@ -30,34 +30,35 @@ from rasa import server, telemetry
 from rasa.constants import ENV_SANIC_BACKLOG
 from rasa.core import agent, channels, constants
 from rasa.core.agent import Agent
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.available_agents import AvailableAgents
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
 from rasa.core.channels.development_inspector import DevelopmentInspectProxy
+from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.credentials import CredentialsConfig
 from rasa.core.persistor import StorageType
 from rasa.shared.exceptions import RasaException
-from rasa.shared.utils.yaml import read_config_file
 from rasa.utils import licensing
 
 logger = logging.getLogger()  # get the root logger
 
 
 def create_input_channels(
-    channel: Optional[Text], credentials_file: Optional[Text]
+    channel: Optional[Text], credentials_config: Optional[CredentialsConfig]
 ) -> List[InputChannel]:
     """Instantiate the chosen input channel.
 
     Args:
         channel (optional): The name of the specific input channel to create.
-        credentials_file: Path to the credentials file containing channel credentials.
+        credentials_config: CredentialsConfig object containing channel credentials.
 
     Returns:
         A list of instantiated input channels. If a specific channel is provided,
         it returns a list with that single channel. If no channel is specified,
         it returns a list of all channels defined in the credentials file.
     """
-    if credentials_file:
-        all_credentials = read_config_file(credentials_file)
+    if credentials_config:
+        all_credentials = credentials_config.channels
     else:
         all_credentials = {}
     if channel:
@@ -96,10 +97,32 @@ def _create_single_channel(
     """
     from rasa.core.channels import BUILTIN_CHANNELS
 
+    # Channels that have optional dependencies
+    channels_with_optional_deps = {
+        "facebook": "fbmessenger",
+        "slack": "slack-sdk",
+        "telegram": "aiogram",
+        "twilio": "twilio",
+        "twilio_voice": "twilio",
+        "twilio_media_streams": "twilio",
+        "webexteams": "webexteamssdk",
+        "vier_cvg": "cvg_sdk",
+    }
+
     if channel in BUILTIN_CHANNELS:
         channel_class = BUILTIN_CHANNELS[channel]
 
         return channel_class.from_credentials(credentials)
+    elif channel in channels_with_optional_deps:
+        # Channel is known but not available due to missing dependency
+        dependency = channels_with_optional_deps[channel]
+        raise RasaException(
+            f"Channel '{channel}' is not available "
+            f"due to missing '{dependency}' dependency. "
+            f"Please install the required extra by running: "
+            f"pip install 'rasa-pro[channels]' OR "
+            f"poetry add 'rasa-pro[channels]'"
+        )
     else:
         # try to load channel based on class name
         try:
@@ -151,6 +174,7 @@ def configure_app(
     route: Optional[Text] = "/webhooks/",
     port: int = constants.DEFAULT_SERVER_PORT,
     endpoints: Optional[AvailableEndpoints] = None,
+    sub_agents: Optional[AvailableAgents] = None,
     log_file: Optional[Text] = None,
     conversation_id: Optional[Text] = uuid.uuid4().hex,
     use_syslog: bool = False,
@@ -179,6 +203,7 @@ def configure_app(
                 jwt_private_key=jwt_private_key,
                 jwt_method=jwt_method,
                 endpoints=endpoints,
+                sub_agents=sub_agents,
                 is_inspector_enabled=is_inspector_enabled,
             )
         )
@@ -234,7 +259,7 @@ def serve_application(
     channel: Optional[Text] = None,
     interface: Optional[Text] = constants.DEFAULT_SERVER_INTERFACE,
     port: int = constants.DEFAULT_SERVER_PORT,
-    credentials: Optional[Text] = None,
+    credentials: Optional[CredentialsConfig] = None,
     cors: Optional[Union[Text, List[Text]]] = None,
     auth_token: Optional[Text] = None,
     enable_api: bool = True,
@@ -243,6 +268,7 @@ def serve_application(
     jwt_private_key: Optional[Text] = None,
     jwt_method: Optional[Text] = None,
     endpoints: Optional[AvailableEndpoints] = None,
+    sub_agents: Optional[AvailableAgents] = None,
     remote_storage: Optional[StorageType] = None,
     log_file: Optional[Text] = None,
     ssl_certificate: Optional[Text] = None,
@@ -283,6 +309,7 @@ def serve_application(
         jwt_method,
         port=port,
         endpoints=endpoints,
+        sub_agents=sub_agents,
         log_file=log_file,
         conversation_id=conversation_id,
         use_syslog=use_syslog,
@@ -302,7 +329,7 @@ def serve_application(
     logger.info(f"Starting Rasa server on {protocol}://{interface}:{port}")
 
     app.register_listener(
-        partial(load_agent_on_start, model_path, endpoints, remote_storage),
+        partial(load_agent_on_start, model_path, endpoints, remote_storage, sub_agents),
         "before_server_start",
     )
 
@@ -340,6 +367,7 @@ async def load_agent_on_start(
     model_path: Text,
     endpoints: AvailableEndpoints,
     remote_storage: Optional[StorageType],
+    sub_agents: Optional[AvailableAgents],
     app: Sanic,
     loop: AbstractEventLoop,
 ) -> Agent:
@@ -352,6 +380,7 @@ async def load_agent_on_start(
         model_path=model_path,
         remote_storage=remote_storage,
         endpoints=endpoints,
+        sub_agents=sub_agents,
         loop=loop,
     )
 

rasa/core/test.py

@@ -1281,6 +1281,10 @@ async def compare_models_in_dir(
         for k, v in number_correct_in_run.items():
             number_correct[k].append(v)
 
+    logger.info("current working directory: " + os.getcwd())
+    logger.info(
+        f"Writing model comparison results to '{os.path.join(output, RESULTS_FILE)}'"
+    )
     rasa.shared.utils.io.dump_obj_as_json_to_file(
         os.path.join(output, RESULTS_FILE), number_correct
     )

rasa/core/tracker_stores/sql_tracker_store.py

@@ -236,7 +236,7 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
             )
         )
         if iam_credentials_provider is not None:
-            credentials = iam_credentials_provider.get_credentials()
+            credentials = iam_credentials_provider.get_temporary_credentials()
             if credentials.auth_token:
                 password = credentials.auth_token
                 structlogger.debug(

rasa/core/tracker_stores/tracker_store.py

@@ -542,7 +542,7 @@ class FailSafeTrackerStore(TrackerStore):
         return self._tracker_store.domain
 
     @domain.setter
-    def domain(self, domain: Domain) -> None:
+    def domain(self, domain: Optional[Domain]) -> None:
         self._tracker_store.domain = domain
 
         if self._fallback_tracker_store:
@@ -805,9 +805,7 @@ class AwaitableTrackerStore(TrackerStore):
     async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
         """Wrapper to call `retrieve` method of primary tracker store."""
         result = self._tracker_store.retrieve(sender_id)
-        return (
-            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
-        )
+        return await result if isawaitable(result) else result
 
     async def keys(self) -> Iterable[Text]:
         """Wrapper to call `keys` method of primary tracker store."""
@@ -834,6 +832,4 @@ class AwaitableTrackerStore(TrackerStore):
     ) -> Optional[DialogueStateTracker]:
         """Wrapper to call `retrieve_full_tracker` method of primary tracker store."""
         result = self._tracker_store.retrieve_full_tracker(conversation_id)
-        return (
-            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
-        )
+        return await result if isawaitable(result) else result

rasa/core/train.py

@@ -46,7 +46,7 @@ async def train_comparison_models(
                     output=str(Path(output_path, f"run_{r +1}")),
                     fixed_model_name=config_name + PERCENTAGE_KEY + str(percentage),
                     additional_arguments={
-                        **additional_arguments,
+                        **(additional_arguments or {}),
                         "exclusion_percentage": percentage,
                     },
                 )

rasa/core/training/interactive.py

@@ -47,7 +47,7 @@ import rasa.shared.utils.io
 import rasa.utils.io as io_utils
 from rasa import telemetry
 from rasa.core import run, utils
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.config.configuration import Configuration
 from rasa.core.constants import DEFAULT_SERVER_FORMAT, DEFAULT_SERVER_PORT
 from rasa.shared.constants import (
     DEFAULT_SENDER_ID,
@@ -91,7 +91,7 @@ from rasa.shared.core.training_data.visualization import (
 )
 from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.importers.rasa import TrainingDataImporter
-from rasa.shared.nlu.constants import INTENT_NAME_KEY, TEXT
+from rasa.shared.nlu.constants import ENTITIES, INTENT, INTENT_NAME_KEY, TEXT
 
 # noinspection PyProtectedMember
 from rasa.shared.nlu.training_data import loading
@@ -789,7 +789,7 @@ def _collect_messages(events: List[Dict[Text, Any]]) -> List[Message]:
             data = event.get("parse_data", {})
             rasa_nlu_training_data_utils.remove_untrainable_entities_from(data)
             msg = Message.build(
-                data["text"], data["intent"][INTENT_NAME_KEY], data["entities"]
+                data[TEXT], data[INTENT][INTENT_NAME_KEY], data[ENTITIES]
             )
             messages.append(msg)
         elif event.get("event") == UserUtteranceReverted.type_name and messages:
@@ -901,13 +901,13 @@ def _get_nlu_target_format(export_path: Text) -> Text:
 
 def _entities_from_messages(messages: List[Message]) -> List[Text]:
     """Return all entities that occur in at least one of the messages."""
-    return list({e["entity"] for m in messages for e in m.data.get("entities", [])})
+    return list({e["entity"] for m in messages for e in m.data.get(ENTITIES, [])})
 
 
 def _intents_from_messages(messages: List[Message]) -> Set[Text]:
     """Return all intents that occur in at least one of the messages."""
     # set of distinct intents
-    distinct_intents = {m.data["intent"] for m in messages if "intent" in m.data}
+    distinct_intents = {m.data[INTENT] for m in messages if INTENT in m.data}
 
     return distinct_intents
 
@@ -1191,11 +1191,11 @@ def _as_md_message(parse_data: Dict[Text, Any]) -> Text:
     """Display the parse data of a message in markdown format."""
     from rasa.shared.nlu.training_data.formats.readerwriter import TrainingDataWriter
 
-    if parse_data.get("text", "").startswith(INTENT_MESSAGE_PREFIX):
-        return parse_data["text"]
+    if parse_data.get(TEXT, "").startswith(INTENT_MESSAGE_PREFIX):
+        return parse_data[TEXT]
 
-    if not parse_data.get("entities"):
-        parse_data["entities"] = []
+    if not parse_data.get(ENTITIES):
+        parse_data[ENTITIES] = []
 
     return TrainingDataWriter.generate_message(parse_data)
 
@@ -1207,7 +1207,7 @@ def _validate_user_regex(latest_message: Dict[Text, Any], intents: List[Text]) -
     `/greet`. Return `True` if the intent is a known one.
     """
     parse_data = latest_message.get("parse_data", {})
-    intent = parse_data.get("intent", {}).get(INTENT_NAME_KEY)
+    intent = parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
 
     if intent in intents:
         return True
@@ -1224,8 +1224,8 @@ async def _validate_user_text(
     """
     parse_data = latest_message.get("parse_data", {})
     text = _as_md_message(parse_data)
-    intent = parse_data.get("intent", {}).get(INTENT_NAME_KEY)
-    entities = parse_data.get("entities", [])
+    intent = parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
+    entities = parse_data.get(ENTITIES, [])
     if entities:
         message = (
             f"Is the intent '{intent}' correct for '{text}' and are "
@@ -1276,9 +1276,9 @@ async def _validate_nlu(
 
         entities = await _correct_entities(latest_message, endpoint, conversation_id)
         corrected_nlu = {
-            "intent": corrected_intent,
-            "entities": entities,
-            "text": latest_message.get("text"),
+            INTENT: corrected_intent,
+            ENTITIES: entities,
+            TEXT: latest_message.get("text"),
         }
 
         await _correct_wrong_nlu(corrected_nlu, events, endpoint, conversation_id)
@@ -1315,9 +1315,9 @@ def _merge_annotated_and_original_entities(
     # overwrite entities which have already been
     # annotated in the original annotation to preserve
     # additional entity parser information
-    entities = parse_annotated.get("entities", [])[:]
+    entities = parse_annotated.get(ENTITIES, [])[:]
     for i, entity in enumerate(entities):
-        for original_entity in parse_original.get("entities", []):
+        for original_entity in parse_original.get(ENTITIES, []):
             if _is_same_entity_annotation(entity, original_entity):
                 entities[i] = original_entity
                 break
@@ -1687,7 +1687,9 @@ def run_interactive_learning(
         p = None
 
     app = run.configure_app(port=port, conversation_id="default", enable_api=True)
-    endpoints = AvailableEndpoints.get_instance(server_args.get("endpoints"))
+    endpoints = Configuration.initialise_endpoints(
+        endpoints_path=server_args.get("endpoints")
+    ).endpoints
 
     # before_server_start handlers make sure the agent is loaded before the
     # interactive learning IO starts

rasa/core/training/story_conflict.py

@@ -14,7 +14,7 @@ from rasa.shared.core.constants import (
 from rasa.shared.core.domain import Domain, State
 from rasa.shared.core.events import ActionExecuted, Event
 from rasa.shared.core.generator import TrackerWithCachedStates
-from rasa.shared.nlu.constants import TEXT
+from rasa.shared.nlu.constants import INTENT, TEXT
 from rasa.shared.nlu.training_data.message import Message
 
 logger = logging.getLogger(__name__)
@@ -362,12 +362,12 @@ def _get_previous_event(
         previous_event_type = "bot utterance"
         previous_event_name = state[PREVIOUS_ACTION]["action_text"]
     elif USER in state.keys():
-        if "intent" in state[USER]:
+        if INTENT in state[USER]:
             previous_event_type = "intent"
-            previous_event_name = state[USER]["intent"]
-        elif "text" in state[USER]:
+            previous_event_name = state[USER][INTENT]
+        elif TEXT in state[USER]:
             previous_event_type = "user utterance"
-            previous_event_name = state[USER]["text"]
+            previous_event_name = state[USER][TEXT]
 
     if not isinstance(previous_event_name, (str, type(None))):
         # While the Substate type doesn't restrict the value of `action_text` /

rasa/core/utils.py

@@ -1,17 +1,16 @@
 import logging
 import os
+import re
 from pathlib import Path
 from socket import SOCK_DGRAM, SOCK_STREAM
-from typing import TYPE_CHECKING, Any, Dict, Optional, Set, Text, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Text, Tuple, Union
 
 import numpy as np
 import structlog
 from sanic import Sanic
 
-import rasa.cli.utils as cli_utils
 import rasa.shared.utils.io
 from rasa.constants import DEFAULT_SANIC_WORKERS, ENV_SANIC_WORKERS
-from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.constants import (
     ACTIVE_FLOW_METADATA_KEY,
     DOMAIN_GROUND_TRUTH_METADATA_KEY,
@@ -19,7 +18,7 @@ from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.lock_store import InMemoryLockStore, LockStore, RedisLockStore
-from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH, TCP_PROTOCOL
+from rasa.shared.constants import TCP_PROTOCOL
 from rasa.shared.core.constants import (
     SlotMappingType,
 )
@@ -37,25 +36,6 @@ if TYPE_CHECKING:
 structlogger = structlog.get_logger()
 
 
-def read_endpoints_from_path(
-    endpoints_path: Optional[Union[Path, str]] = None,
-) -> AvailableEndpoints:
-    """Get `AvailableEndpoints` object from specified path.
-
-    Args:
-        endpoints_path: Path of the endpoints file to be read. If `None` the
-            default path for that file is used (`endpoints.yml`).
-
-    Returns:
-        `AvailableEndpoints` object read from endpoints file.
-
-    """
-    endpoints_config_path = cli_utils.get_validated_path(
-        endpoints_path, "endpoints", DEFAULT_ENDPOINTS_PATH, True
-    )
-    return AvailableEndpoints.get_instance(endpoints_config_path)
-
-
 def configure_file_logging(
     logger_obj: logging.Logger,
     log_file: Optional[Text],
@@ -359,3 +339,22 @@ def should_force_slot_filling(
             return True, slot_name
 
     return False, None
+
+
+def get_slot_names_from_exit_conditions(exit_conditions: List[str]) -> List[str]:
+    """Extract slot names from exit conditions.
+
+    Args:
+        exit_conditions: The exit conditions to extract slot names from.
+
+    Returns:
+        A list of slot names.
+    """
+    # Find all unique names matching "slots.<name>"
+    return list(
+        {
+            name
+            for condition in exit_conditions
+            for name in re.findall(r"\bslots\.(\w+)", condition)
+        }
+    )

rasa/dialogue_understanding/commands/__init__.py

@@ -8,6 +8,9 @@ from rasa.dialogue_understanding.commands.chit_chat_answer_command import (
 )
 from rasa.dialogue_understanding.commands.clarify_command import ClarifyCommand
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.continue_agent_command import (
+    ContinueAgentCommand,
+)
 from rasa.dialogue_understanding.commands.correct_slots_command import (
     CorrectedSlot,
     CorrectSlotsCommand,
@@ -29,6 +32,9 @@ from rasa.dialogue_understanding.commands.noop_command import NoopCommand
 from rasa.dialogue_understanding.commands.repeat_bot_messages_command import (
     RepeatBotMessagesCommand,
 )
+from rasa.dialogue_understanding.commands.restart_agent_command import (
+    RestartAgentCommand,
+)
 from rasa.dialogue_understanding.commands.restart_command import RestartCommand
 from rasa.dialogue_understanding.commands.session_end_command import SessionEndCommand
 from rasa.dialogue_understanding.commands.session_start_command import (
@@ -62,4 +68,6 @@ __all__ = [
     "SessionEndCommand",
     "RepeatBotMessagesCommand",
     "RestartCommand",
+    "ContinueAgentCommand",
+    "RestartAgentCommand",
 ]

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -6,6 +6,9 @@ from typing import Any, Dict, List
 
 import structlog
 
+from rasa.core.policies.flows.agent_executor import (
+    remove_agent_stack_frame,
+)
 from rasa.dialogue_understanding.commands.command import Command
 from rasa.dialogue_understanding.commands.command_syntax_manager import (
     CommandSyntaxManager,
@@ -18,7 +21,7 @@ from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     UserFlowStackFrame,
 )
 from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
-from rasa.shared.core.events import Event, FlowCancelled
+from rasa.shared.core.events import AgentCancelled, Event, FlowCancelled
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 
@@ -48,8 +51,7 @@ class CancelFlowCommand(Command):
         """Selects the frames that were canceled.
 
         Args:
-            dialogue_stack: The dialogue stack.
-            current_flow: The current flow.
+            stack: The dialogue stack.
 
         Returns:
         The frames that were canceled.
@@ -71,8 +73,7 @@ class CancelFlowCommand(Command):
             # we should never get here as we should always find the user flow
             # that was canceled.
             raise ValueError(
-                f"Could not find a user flow frame to cancel. "
-                f"Current stack: {stack}."
+                f"Could not find a user flow frame to cancel. Current stack: {stack}."
             )
 
     def run_command_on_tracker(
@@ -106,6 +107,19 @@ class CancelFlowCommand(Command):
             )
             return []
 
+        if agent_frame := original_tracker.stack.find_active_agent_stack_frame_for_flow(
+            current_flow.id
+        ):
+            structlogger.debug(
+                "cancel_command.remove_agent_stack_frame",
+                command=self,
+                frame=agent_frame,
+            )
+            remove_agent_stack_frame(stack, agent_frame.agent_id)
+            applied_events.append(
+                AgentCancelled(agent_id=agent_frame.agent_id, flow_id=current_flow.id)
+            )
+
         # we pass in the original dialogue stack (before any of the currently
         # predicted commands were applied) to make sure we don't cancel any
         # frames that were added by the currently predicted commands.

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -12,7 +12,11 @@ from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
 from rasa.dialogue_understanding.patterns.chitchat import ChitchatPatternFlowStackFrame
-from rasa.shared.core.events import Event
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+)
+from rasa.shared.core.events import AgentInterrupted, Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 
@@ -52,8 +56,23 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
             The events to apply to the tracker.
         """
         stack = tracker.stack
+
+        applied_events: List[Event] = []
+
+        # if the top stack frame is an agent stack frame, we need to
+        # update the state to INTERRUPTED and add an AgentInterrupted event
+        if top_stack_frame := stack.top():
+            if isinstance(top_stack_frame, AgentStackFrame):
+                applied_events.append(
+                    AgentInterrupted(
+                        top_stack_frame.agent_id,
+                        top_stack_frame.flow_id,
+                    )
+                )
+                top_stack_frame.state = AgentState.INTERRUPTED
+
         stack.push(ChitchatPatternFlowStackFrame())
-        return tracker.create_stack_updated_events(stack)
+        return applied_events + tracker.create_stack_updated_events(stack)
 
     def __hash__(self) -> int:
         return hash(self.command())

rasa/dialogue_understanding/commands/clarify_command.py

@@ -13,7 +13,11 @@ from rasa.dialogue_understanding.commands.command_syntax_manager import (
 )
 from rasa.dialogue_understanding.commands.utils import extract_cleaned_options
 from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
-from rasa.shared.core.events import Event
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+)
+from rasa.shared.core.events import AgentInterrupted, Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 
@@ -85,8 +89,22 @@ class ClarifyCommand(Command):
             if flow is not None
         ]
 
+        applied_events: List[Event] = []
+
+        # if the top stack frame is an agent stack frame, we need to
+        # update the state to INTERRUPTED and add an AgentInterrupted event
+        if top_stack_frame := stack.top():
+            if isinstance(top_stack_frame, AgentStackFrame):
+                applied_events.append(
+                    AgentInterrupted(
+                        top_stack_frame.agent_id,
+                        top_stack_frame.flow_id,
+                    )
+                )
+                top_stack_frame.state = AgentState.INTERRUPTED
+
         stack.push(ClarifyPatternFlowStackFrame(names=names))
-        return tracker.create_stack_updated_events(stack)
+        return applied_events + tracker.create_stack_updated_events(stack)
 
     def __hash__(self) -> int:
         return hash(tuple(self.options))

rasa/dialogue_understanding/commands/continue_agent_command.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+
+from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class ContinueAgentCommand(Command):
+    """A command to continue the currently active agent's execution."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "continue agent"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ContinueAgentCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return ContinueAgentCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        # do nothing
+        return []
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, ContinueAgentCommand)
+
+    def to_dsl(self) -> str:
+        """Converts the command to a DSL string."""
+        mapper = {
+            CommandSyntaxVersion.v1: "ContinueAgent()",
+            CommandSyntaxVersion.v2: "continue agent",
+            CommandSyntaxVersion.v3: "continue agent",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
+
+    @classmethod
+    def from_dsl(cls, match: re.Match, **kwargs: Any) -> ContinueAgentCommand:
+        """Converts a DSL string to a command."""
+        return ContinueAgentCommand()
+
+    @staticmethod
+    def regex_pattern() -> str:
+        mapper = {
+            CommandSyntaxVersion.v1: r"ContinueAgent\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*continue agent['"`]*$""",
+            CommandSyntaxVersion.v3: r"""^[\s\W\d]*continue agent['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )