rasa-pro 3.12.0.dev11__py3-none-any.whl → 3.12.0.dev12__py3-none-any.whl

rasa/cli/inspect.py

@@ -9,10 +9,6 @@ from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
 from rasa.core import constants
-from rasa.engine.storage.local_model_storage import LocalModelStorage
-from rasa.exceptions import ModelNotFound
-from rasa.model import get_local_model
-from rasa.shared.utils.cli import print_error
 from rasa.utils.cli import remove_argument_from_parser
 
 
@@ -59,8 +55,6 @@ async def open_inspector_in_browser(server_url: Text, voice: bool = False) -> No
 def inspect(args: argparse.Namespace) -> None:
     """Inspect the bot using the most recent model."""
     import rasa.cli.run
-    from rasa.cli.utils import get_validated_path
-    from rasa.shared.constants import DEFAULT_MODELS_PATH
 
     async def after_start_hook_open_inspector(_: Sanic, __: AbstractEventLoop) -> None:
         """Hook to open the browser on server start."""
@@ -77,18 +71,5 @@ def inspect(args: argparse.Namespace) -> None:
     args.credentials = None
     args.server_listeners = [(after_start_hook_open_inspector, "after_server_start")]
 
-    model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
-
-    try:
-        model = get_local_model(model)
-    except ModelNotFound:
-        print_error(
-            "No model found. Train a model before running the "
-            "server using `rasa train`."
-        )
-        return
-
-    metadata = LocalModelStorage.metadata_from_archive(model)
-
-    telemetry.track_inspect_started(args.connector, metadata.assistant_id)
+    telemetry.track_inspect_started(args.connector)
     rasa.cli.run.run(args)

rasa/cli/shell.py

@@ -95,7 +95,7 @@ def shell_nlu(args: argparse.Namespace) -> None:
         )
         return
 
-    telemetry.track_shell_started("nlu", metadata.assistant_id)
+    telemetry.track_shell_started("nlu")
     rasa.nlu.run.run_cmdline(model)
 
 
@@ -129,12 +129,12 @@ def shell(args: argparse.Namespace) -> None:
     if metadata.training_type == TrainingType.NLU:
         import rasa.nlu.run
 
-        telemetry.track_shell_started("nlu", metadata.assistant_id)
+        telemetry.track_shell_started("nlu")
 
         rasa.nlu.run.run_cmdline(model)
     else:
         import rasa.cli.run
 
-        telemetry.track_shell_started("rasa", metadata.assistant_id)
+        telemetry.track_shell_started("rasa")
 
         rasa.cli.run.run(args)

rasa/core/actions/action.py

@@ -73,9 +73,9 @@ from rasa.shared.core.constants import (
     ACTION_VALIDATE_SLOT_MAPPINGS,
     DEFAULT_SLOT_NAMES,
     KNOWLEDGE_BASE_SLOT_NAMES,
+    MAPPING_TYPE,
     REQUESTED_SLOT,
     USER_INTENT_OUT_OF_SCOPE,
-    SetSlotExtractor,
     SlotMappingType,
 )
 from rasa.shared.core.domain import Domain
@@ -111,7 +111,6 @@ if TYPE_CHECKING:
     from rasa.core.channels.channel import OutputChannel
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.events import IntentPrediction
-    from rasa.shared.core.slot_mappings import SlotMapping
 
 logger = logging.getLogger(__name__)
 
@@ -119,10 +118,6 @@ logger = logging.getLogger(__name__)
 def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["Action"]:
     """List default actions."""
     from rasa.core.actions.action_clean_stack import ActionCleanStack
-    from rasa.core.actions.action_handle_digressions import (
-        ActionBlockDigressions,
-        ActionContinueDigression,
-    )
     from rasa.core.actions.action_hangup import ActionHangup
     from rasa.core.actions.action_repeat_bot_messages import ActionRepeatBotMessages
     from rasa.core.actions.action_run_slot_rejections import ActionRunSlotRejections
@@ -157,8 +152,6 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionResetRouting(),
         ActionHangup(),
         ActionRepeatBotMessages(),
-        ActionBlockDigressions(),
-        ActionContinueDigression(),
     ]
 
 
@@ -947,14 +940,7 @@ class RemoteAction(Action):
         )
 
         events = rasa.shared.core.events.deserialise_events(events_json)
-
-        processed_events = []
-        for event in events:
-            if isinstance(event, SlotSet) and event.filled_by is None:
-                event.filled_by = SetSlotExtractor.CUSTOM.value
-            processed_events.append(event)
-
-        return cast(List[Event], bot_messages) + processed_events
+        return cast(List[Event], bot_messages) + events
 
     def name(self) -> Text:
         return self._name
@@ -1222,7 +1208,7 @@ class ActionExtractSlots(Action):
 
     async def _execute_custom_action(
         self,
-        mapping: "SlotMapping",
+        mapping: Dict[Text, Any],
         executed_custom_actions: Set[Text],
         output_channel: "OutputChannel",
         nlg: "NaturalLanguageGenerator",
@@ -1230,7 +1216,7 @@ class ActionExtractSlots(Action):
         domain: "Domain",
         calm_custom_action_names: Optional[Set[str]] = None,
     ) -> Tuple[List[Event], Set[Text]]:
-        custom_action = mapping.run_action_every_turn
+        custom_action = mapping.get("action")
 
         if not custom_action or custom_action in executed_custom_actions:
             return [], executed_custom_actions
@@ -1331,9 +1317,10 @@ class ActionExtractSlots(Action):
                 slot_events.append(SlotSet(slot.name, slot_value))
 
             for mapping in slot.mappings:
-                should_fill_controlled_slot = mapping.type == SlotMappingType.CONTROLLED
+                mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
+                should_fill_custom_slot = mapping_type == SlotMappingType.CUSTOM
 
-                if should_fill_controlled_slot:
+                if should_fill_custom_slot:
                     (
                         custom_evts,
                         executed_custom_actions,

rasa/core/actions/forms.py

@@ -2,7 +2,7 @@ import copy
 import itertools
 import json
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Text, Union
+from typing import Any, Dict, List, Optional, Set, Text, Union
 
 import structlog
 
@@ -16,7 +16,7 @@ from rasa.shared.constants import UTTER_PREFIX
 from rasa.shared.core.constants import (
     ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
-    KEY_MAPPING_TYPE,
+    MAPPING_TYPE,
     REQUESTED_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
@@ -35,9 +35,6 @@ from rasa.shared.core.slots import ListSlot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig
 
-if TYPE_CHECKING:
-    from rasa.shared.core.slot_mappings import SlotMapping
-
 logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
@@ -161,9 +158,7 @@ class FormAction(LoopAction):
         domain_slots = domain.as_dict().get(KEY_SLOTS, {})
         for slot in domain.required_slots_for_form(self.name()):
             for slot_mapping in domain_slots.get(slot, {}).get(SLOT_MAPPINGS, []):
-                if slot_mapping.get(KEY_MAPPING_TYPE) == str(
-                    SlotMappingType.FROM_ENTITY
-                ):
+                if slot_mapping.get(MAPPING_TYPE) == str(SlotMappingType.FROM_ENTITY):
                     mapping_as_string = json.dumps(slot_mapping, sort_keys=True)
                     if mapping_as_string in unique_entity_slot_mappings:
                         unique_entity_slot_mappings.remove(mapping_as_string)
@@ -174,7 +169,7 @@ class FormAction(LoopAction):
         return unique_entity_slot_mappings
 
     def entity_mapping_is_unique(
-        self, slot_mapping: "SlotMapping", domain: Domain
+        self, slot_mapping: Dict[Text, Any], domain: Domain
     ) -> bool:
         """Verifies if the from_entity mapping is unique."""
         if not self._have_unique_entity_mappings_been_initialized:
@@ -182,7 +177,7 @@ class FormAction(LoopAction):
             self._unique_entity_mappings = self._create_unique_entity_mappings(domain)
             self._have_unique_entity_mappings_been_initialized = True
 
-        mapping_as_string = json.dumps(slot_mapping.as_dict(), sort_keys=True)
+        mapping_as_string = json.dumps(slot_mapping, sort_keys=True)
         return mapping_as_string in self._unique_entity_mappings
 
     @staticmethod

rasa/core/channels/__init__.py

@@ -32,7 +32,6 @@ from rasa.core.channels.vier_cvg import CVGInput
 from rasa.core.channels.voice_stream.twilio_media_streams import (
     TwilioMediaStreamsInputChannel,
 )
-from rasa.core.channels.voice_stream.genesys import GenesysInputChannel
 from rasa.core.channels.studio_chat import StudioChatInput
 
 input_channel_classes: List[Type[InputChannel]] = [
@@ -56,7 +55,6 @@ input_channel_classes: List[Type[InputChannel]] = [
     JambonzVoiceReadyInput,
     TwilioMediaStreamsInputChannel,
     BrowserAudioInputChannel,
-    GenesysInputChannel,
     StudioChatInput,
 ]
 

rasa/core/channels/voice_ready/audiocodes.py

@@ -1,11 +1,9 @@
-import asyncio
 import copy
 import json
 import uuid
-from collections import defaultdict
 from dataclasses import asdict
 from datetime import datetime, timedelta, timezone
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Set, Text, Union
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Text, Union
 
 import structlog
 from jsonschema import ValidationError, validate
@@ -225,16 +223,6 @@ class AudiocodesInput(InputChannel):
         self.scheduler_job = None
         self.keep_alive = keep_alive
         self.keep_alive_expiration_factor = keep_alive_expiration_factor
-        self.background_tasks: Dict[Text, Set[asyncio.Task]] = defaultdict(set)
-
-    def _create_task(self, conversation_id: Text, coro: Awaitable[Any]) -> asyncio.Task:
-        """Create and track an asyncio task for a conversation."""
-        task: asyncio.Task = asyncio.create_task(coro)
-        self.background_tasks[conversation_id].add(task)
-        task.add_done_callback(
-            lambda t: self.background_tasks[conversation_id].discard(t)
-        )
-        return task
 
     async def _set_scheduler_job(self) -> None:
         if self.scheduler_job:
@@ -263,20 +251,11 @@ class AudiocodesInput(InputChannel):
         )
         now = datetime.now(timezone.utc)
         delta = timedelta(seconds=self.keep_alive * self.keep_alive_expiration_factor)
-
-        # clean up conversations
-        inactive = [
-            conv_id
-            for conv_id, conv in self.conversations.items()
-            if not conv.is_active_conversation(now, delta)
-        ]
-
-        # cancel tasks and remove conversations
-        for conv_id in inactive:
-            for task in self.background_tasks[conv_id]:
-                task.cancel()
-            self.background_tasks.pop(conv_id, None)
-            self.conversations.pop(conv_id, None)
+        self.conversations = {
+            k: v
+            for k, v in self.conversations.items()
+            if v.is_active_conversation(now, delta)
+        }
 
     def handle_start_conversation(self, body: Dict[Text, Any]) -> Dict[Text, Any]:
         conversation_id = body["conversation"]
@@ -368,29 +347,31 @@ class AudiocodesInput(InputChannel):
             structlogger.debug("audiocodes.on_activities", conversation=conversation_id)
             conversation = self._get_conversation(request.token, conversation_id)
             if conversation is None:
-                structlogger.warning(
-                    "audiocodes.on_activities.no_conversation", request=request.json
-                )
                 return response.json({})
             elif conversation.ws:
                 ac_output: Union[WebsocketOutput, AudiocodesOutput] = WebsocketOutput(
                     conversation.ws, conversation_id
                 )
-                response_json = {}
+                await conversation.handle_activities(
+                    request.json,
+                    output_channel=ac_output,
+                    on_new_message=on_new_message,
+                )
+                return response.json({})
             else:
                 # handle non websocket case where messages get returned in json
                 ac_output = AudiocodesOutput()
-                response_json = {
-                    "conversation": conversation_id,
-                    "activities": ac_output.messages,
-                }
-
-            # start a background task to handle activities
-            self._create_task(
-                conversation_id,
-                conversation.handle_activities(request.json, ac_output, on_new_message),
-            )
-            return response.json(response_json)
+                await conversation.handle_activities(
+                    request.json,
+                    output_channel=ac_output,
+                    on_new_message=on_new_message,
+                )
+                return response.json(
+                    {
+                        "conversation": conversation_id,
+                        "activities": ac_output.messages,
+                    }
+                )
 
         @ac_webhook.route(
             "/conversation/<conversation_id>/disconnect", methods=["POST"]

rasa/core/channels/voice_stream/browser_audio.py

@@ -65,7 +65,6 @@ class BrowserAudioInputChannel(VoiceInputChannel):
     def map_input_message(
         self,
         message: Any,
-        ws: Websocket,
     ) -> VoiceChannelAction:
         data = json.loads(message)
         if "audio" in data:

rasa/core/channels/voice_stream/call_state.py

@@ -1,6 +1,6 @@
 import asyncio
 from contextvars import ContextVar
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import Optional
 
 from werkzeug.local import LocalProxy
@@ -19,12 +19,6 @@ class CallState:
     should_hangup: bool = False
     connection_failed: bool = False
 
-    # Genesys requires the server and client each maintain a
-    # monotonically increasing message sequence number.
-    client_sequence_number: int = 0
-    server_sequence_number: int = 0
-    audio_buffer: bytearray = field(default_factory=bytearray)
-
 
 _call_state: ContextVar[CallState] = ContextVar("call_state")
 call_state = LocalProxy(_call_state)

rasa/core/channels/voice_stream/tts/azure.py

@@ -81,8 +81,7 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
     @staticmethod
     def create_request_body(text: str, conf: AzureTTSConfig) -> str:
         return f"""
-        <speak version='1.0' xml:lang='{conf.language}' xmlns:mstts='http://www.w3.org/2001/mstts'
-                xmlns='http://www.w3.org/2001/10/synthesis'>
+        <speak version='1.0' xml:lang='{conf.language}'>
             <voice xml:lang='{conf.language}' name='{conf.voice}'>
                 {text}
             </voice>

rasa/core/channels/voice_stream/tts/cartesia.py

@@ -1,5 +1,3 @@
-import base64
-import json
 import os
 from dataclasses import dataclass
 from typing import AsyncIterator, Dict, Optional
@@ -41,7 +39,7 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
     @staticmethod
     def get_tts_endpoint() -> str:
         """Create the endpoint string for cartesia."""
-        return "https://api.cartesia.ai/tts/sse"
+        return "https://api.cartesia.ai/tts/bytes"
 
     @staticmethod
     def get_request_body(text: str, config: CartesiaTTSConfig) -> Dict:
@@ -87,19 +85,8 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
                 url, headers=headers, json=payload, chunked=True
             ) as response:
                 if 200 <= response.status < 300:
-                    async for chunk in response.content:
-                        # we are looking for chunks in the response that look like
-                        # b"data: {..., data: <base64 encoded audio bytes> ...}"
-                        # and extract the audio bytes from that
-                        if chunk.startswith(b"data: "):
-                            json_bytes = chunk[5:-1]
-                            json_data = json.loads(json_bytes.decode())
-                            if "data" in json_data:
-                                base64_encoded_bytes = json_data["data"]
-                                channel_bytes = base64.b64decode(base64_encoded_bytes)
-                                yield self.engine_bytes_to_rasa_audio_bytes(
-                                    channel_bytes
-                                )
+                    async for data in response.content.iter_chunked(1024):
+                        yield self.engine_bytes_to_rasa_audio_bytes(data)
                     return
                 else:
                     structlogger.error(

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -98,7 +98,6 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
     def map_input_message(
         self,
         message: Any,
-        ws: Websocket,
     ) -> VoiceChannelAction:
         data = json.loads(message)
         if data["event"] == "media":
@@ -143,7 +142,7 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
-        """Defines a Sanic blueprint for the voice input channel."""
+        """Defines a Sanic bluelogger.debug."""
         blueprint = Blueprint("twilio_media_streams", __name__)
 
         @blueprint.route("/", methods=["GET"])

rasa/core/channels/voice_stream/voice_channel.py

@@ -315,7 +315,6 @@ class VoiceInputChannel(InputChannel):
     def map_input_message(
         self,
         message: Any,
-        ws: Websocket,
     ) -> VoiceChannelAction:
         """Map a channel input message to a voice channel action."""
         raise NotImplementedError
@@ -341,7 +340,7 @@ class VoiceInputChannel(InputChannel):
         async def consume_audio_bytes() -> None:
             async for message in channel_websocket:
                 is_bot_speaking_before = call_state.is_bot_speaking
-                channel_action = self.map_input_message(message, channel_websocket)
+                channel_action = self.map_input_message(message)
                 is_bot_speaking_after = call_state.is_bot_speaking
 
                 if not is_bot_speaking_before and is_bot_speaking_after:

rasa/core/migrate.py

@@ -14,7 +14,7 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTIVE_LOOP,
-    KEY_MAPPING_TYPE,
+    MAPPING_TYPE,
     REQUESTED_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
@@ -43,7 +43,7 @@ def _create_back_up(domain_file: Path, backup_location: Path) -> Dict[Text, Any]
 def _get_updated_mapping_condition(
     condition: Dict[Text, Text], mapping: Dict[Text, Any], slot_name: Text
 ) -> Dict[Text, Text]:
-    if mapping.get(KEY_MAPPING_TYPE) not in [
+    if mapping.get(MAPPING_TYPE) not in [
         str(SlotMappingType.FROM_ENTITY),
         str(SlotMappingType.FROM_TRIGGER_INTENT),
     ]:

rasa/core/policies/flows/flow_executor.py

@@ -23,7 +23,6 @@ from rasa.core.policies.flows.flow_step_result import (
 )
 from rasa.dialogue_understanding.commands import CancelFlowCommand
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
-from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
 )
@@ -51,12 +50,9 @@ from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
 )
 from rasa.dialogue_understanding.stack.utils import (
     top_user_flow_frame,
-    user_flows_on_the_stack,
 )
 from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
-from rasa.shared.core.constants import (
-    ACTION_LISTEN_NAME,
-)
+from rasa.shared.core.constants import ACTION_LISTEN_NAME, SlotMappingType
 from rasa.shared.core.events import (
     Event,
     FlowCompleted,
@@ -276,28 +272,6 @@ def trigger_pattern_continue_interrupted(
     return events
 
 
-def trigger_pattern_clarification(
-    current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
-) -> None:
-    """Trigger the pattern to clarify which topic to continue if needed."""
-    if not isinstance(current_frame, UserFlowStackFrame):
-        return None
-
-    if current_frame.frame_type == FlowStackFrameType.CALL:
-        # we want to return to the flow that called the current flow
-        return None
-
-    pending_flows = [
-        flows.flow_by_id(frame.flow_id)
-        for frame in stack.frames
-        if isinstance(frame, UserFlowStackFrame)
-        and frame.flow_id != current_frame.flow_id
-    ]
-
-    flow_names = [flow.readable_name() for flow in pending_flows if flow is not None]
-    stack.push(ClarifyPatternFlowStackFrame(names=flow_names))
-
-
 def trigger_pattern_completed(
     current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
 ) -> None:
@@ -566,6 +540,38 @@ def cancel_flow_and_push_internal_error(stack: DialogueStack, flow_name: str) ->
     stack.push(InternalErrorPatternFlowStackFrame())
 
 
+def validate_custom_slot_mappings(
+    step: CollectInformationFlowStep,
+    stack: DialogueStack,
+    tracker: DialogueStateTracker,
+    available_actions: List[str],
+    flow_name: str,
+) -> bool:
+    """Validate a slot with custom mappings.
+
+    If invalid, trigger pattern_internal_error and return False.
+    """
+    slot = tracker.slots.get(step.collect, None)
+    slot_mappings = slot.mappings if slot else []
+    for mapping in slot_mappings:
+        if (
+            mapping.get("type") == SlotMappingType.CUSTOM.value
+            and mapping.get("action") is None
+        ):
+            # this is a slot that must be filled by a custom action
+            # check if collect_action exists
+            if step.collect_action not in available_actions:
+                structlogger.error(
+                    "flow.step.run.collect_action_not_found_for_custom_slot_mapping",
+                    action=step.collect_action,
+                    collect=step.collect,
+                )
+                cancel_flow_and_push_internal_error(stack, flow_name)
+                return False
+
+    return True
+
+
 def attach_stack_metadata_to_events(
     step_id: str,
     flow_id: str,
@@ -663,15 +669,7 @@ def _run_end_step(
     structlogger.debug("flow.step.run.flow_end")
     current_frame = stack.pop()
     trigger_pattern_completed(current_frame, stack, flows)
-    resumed_events = []
-    if len(user_flows_on_the_stack(stack)) > 1:
-        # if there are more user flows on the stack,
-        # we need to trigger the pattern clarify
-        trigger_pattern_clarification(current_frame, stack, flows)
-    else:
-        resumed_events = trigger_pattern_continue_interrupted(
-            current_frame, stack, flows
-        )
+    resumed_events = trigger_pattern_continue_interrupted(current_frame, stack, flows)
     reset_events: List[Event] = reset_scoped_slots(current_frame, flow, tracker)
     return ContinueFlowWithNextStep(
         events=initial_events + reset_events + resumed_events, has_flow_ended=True
@@ -762,6 +760,14 @@ def _run_collect_information_step(
         # if we return any other FlowStepResult, the assistant will stay silent
         # instead of triggering the internal error pattern
         return ContinueFlowWithNextStep(events=initial_events)
+    is_mapping_valid = validate_custom_slot_mappings(
+        step, stack, tracker, available_actions, flow_name
+    )
+
+    if not is_mapping_valid:
+        # if we return any other FlowStepResult, the assistant will stay silent
+        # instead of triggering the internal error pattern
+        return ContinueFlowWithNextStep(events=initial_events)
 
     structlogger.debug("flow.step.run.collect")
     trigger_pattern_ask_collect_information(

rasa/core/run.py

@@ -283,10 +283,9 @@ def serve_application(
         endpoints.lock_store if endpoints else None
     )
 
-    if not inspect:
-        telemetry.track_server_start(
-            input_channels, endpoints, model_path, number_of_workers, enable_api
-        )
+    telemetry.track_server_start(
+        input_channels, endpoints, model_path, number_of_workers, enable_api
+    )
 
     rasa.utils.common.update_sanic_log_level(
         log_file, use_syslog, syslog_address, syslog_port, syslog_protocol

rasa/dialogue_understanding/commands/can_not_handle_command.py

@@ -74,7 +74,7 @@ class CannotHandleCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "CannotHandle()"
+        return "cannot handle"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> CannotHandleCommand:
@@ -86,4 +86,4 @@ class CannotHandleCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"CannotHandle\(\)"
+        return r"^cannot handle$"