rasa-pro 3.12.0rc1__py3-none-any.whl → 3.12.0rc3__py3-none-any.whl

rasa/core/channels/voice_stream/voice_channel.py

@@ -17,6 +17,7 @@ from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
     UserIsSpeaking,
+    UserSilence,
 )
 from rasa.core.channels.voice_stream.asr.azure import AzureASR
 from rasa.core.channels.voice_stream.asr.deepgram import DeepgramASR
@@ -120,13 +121,14 @@ class VoiceOutputChannel(OutputChannel):
         voice_websocket: Websocket,
         tts_engine: TTSEngine,
         tts_cache: TTSCache,
+        min_buffer_size: int = 0,
     ):
         super().__init__()
         self.voice_websocket = voice_websocket
         self.tts_engine = tts_engine
         self.tts_cache = tts_cache
-
         self.latest_message_id: Optional[str] = None
+        self.min_buffer_size = min_buffer_size
 
     def rasa_audio_bytes_to_channel_bytes(
         self, rasa_audio_bytes: RasaAudioBytes
@@ -186,6 +188,7 @@ class VoiceOutputChannel(OutputChannel):
         cached_audio_bytes = self.tts_cache.get(text)
         collected_audio_bytes = RasaAudioBytes(b"")
         seconds_marker = -1
+        last_sent_offset = 0
 
         # Send start marker before first chunk
         try:
@@ -205,17 +208,37 @@ class VoiceOutputChannel(OutputChannel):
                 audio_stream = self.chunk_audio(generate_silence())
 
         async for audio_bytes in audio_stream:
-            try:
-                await self.send_audio_bytes(recipient_id, audio_bytes)
-                full_seconds_of_audio = len(collected_audio_bytes) // HERTZ
-                if full_seconds_of_audio > seconds_marker:
-                    await self.send_intermediate_marker(recipient_id)
-                    seconds_marker = full_seconds_of_audio
+            collected_audio_bytes = RasaAudioBytes(collected_audio_bytes + audio_bytes)
 
+            # Check if we have enough new bytes to send
+            current_buffer_size = len(collected_audio_bytes) - last_sent_offset
+            should_send = current_buffer_size >= self.min_buffer_size
+
+            if should_send:
+                try:
+                    # Send only the new bytes since last send
+                    new_bytes = RasaAudioBytes(collected_audio_bytes[last_sent_offset:])
+                    await self.send_audio_bytes(recipient_id, new_bytes)
+                    last_sent_offset = len(collected_audio_bytes)
+
+                    full_seconds_of_audio = len(collected_audio_bytes) // HERTZ
+                    if full_seconds_of_audio > seconds_marker:
+                        await self.send_intermediate_marker(recipient_id)
+                        seconds_marker = full_seconds_of_audio
+
+                except (WebsocketClosed, ServerError):
+                    # ignore sending error, and keep collecting and caching audio bytes
+                    call_state.connection_failed = True  # type: ignore[attr-defined]
+
+        # Send any remaining audio not yet sent
+        remaining_bytes = len(collected_audio_bytes) - last_sent_offset
+        if remaining_bytes > 0:
+            try:
+                new_bytes = RasaAudioBytes(collected_audio_bytes[last_sent_offset:])
+                await self.send_audio_bytes(recipient_id, new_bytes)
             except (WebsocketClosed, ServerError):
-                # ignore sending error, and keep collecting and caching audio bytes
+                # ignore sending error
                 call_state.connection_failed = True  # type: ignore[attr-defined]
-            collected_audio_bytes = RasaAudioBytes(collected_audio_bytes + audio_bytes)
 
         try:
             await self.send_end_marker(recipient_id)
@@ -265,13 +288,7 @@ class VoiceInputChannel(InputChannel):
         self.monitor_silence = monitor_silence
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
 
-    async def handle_silence_timeout(
-        self,
-        voice_websocket: Websocket,
-        on_new_message: Callable[[UserMessage], Awaitable[Any]],
-        tts_engine: TTSEngine,
-        call_parameters: CallParameters,
-    ) -> None:
+    async def monitor_silence_timeout(self, asr_event_queue: asyncio.Queue) -> None:
         timeout = call_state.silence_timeout
         if not timeout:
             return
@@ -279,16 +296,8 @@ class VoiceInputChannel(InputChannel):
             return
         logger.debug("voice_channel.silence_timeout_watch_started", timeout=timeout)
         await asyncio.sleep(timeout)
+        await asr_event_queue.put(UserSilence())
         logger.debug("voice_channel.silence_timeout_tripped")
-        output_channel = self.create_output_channel(voice_websocket, tts_engine)
-        message = UserMessage(
-            "/silence_timeout",
-            output_channel,
-            call_parameters.stream_id,
-            input_channel=self.name(),
-            metadata=asdict(call_parameters),
-        )
-        await on_new_message(message)
 
     @staticmethod
     def _cancel_silence_timeout_watcher() -> None:
@@ -350,6 +359,7 @@ class VoiceInputChannel(InputChannel):
         _call_state.set(CallState())
         asr_engine = asr_engine_from_config(self.asr_config)
         tts_engine = tts_engine_from_config(self.tts_config)
+        asr_event_queue: asyncio.Queue = asyncio.Queue()
         await asr_engine.connect()
 
         call_parameters = await self.collect_call_parameters(channel_websocket)
@@ -376,12 +386,7 @@ class VoiceInputChannel(InputChannel):
                     self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
                         asyncio.create_task(
-                            self.handle_silence_timeout(
-                                channel_websocket,
-                                on_new_message,
-                                tts_engine,
-                                call_parameters,
-                            )
+                            self.monitor_silence_timeout(asr_event_queue)
                         )
                     )
                 if isinstance(channel_action, NewAudioAction):
@@ -390,8 +395,13 @@ class VoiceInputChannel(InputChannel):
                     # end stream event came from the other side
                     break
 
-        async def consume_asr_events() -> None:
+        async def receive_asr_events() -> None:
             async for event in asr_engine.stream_asr_events():
+                await asr_event_queue.put(event)
+
+        async def handle_asr_events() -> None:
+            while True:
+                event = await asr_event_queue.get()
                 await self.handle_asr_event(
                     event,
                     channel_websocket,
@@ -400,16 +410,18 @@ class VoiceInputChannel(InputChannel):
                     call_parameters,
                 )
 
-        audio_forwarding_task = asyncio.create_task(consume_audio_bytes())
-        asr_event_task = asyncio.create_task(consume_asr_events())
+        tasks = [
+            asyncio.create_task(consume_audio_bytes()),
+            asyncio.create_task(receive_asr_events()),
+            asyncio.create_task(handle_asr_events()),
+        ]
         await asyncio.wait(
-            [audio_forwarding_task, asr_event_task],
+            tasks,
             return_when=asyncio.FIRST_COMPLETED,
         )
-        if not audio_forwarding_task.done():
-            audio_forwarding_task.cancel()
-        if not asr_event_task.done():
-            asr_event_task.cancel()
+        for task in tasks:
+            if not task.done():
+                task.cancel()
         await tts_engine.close_connection()
         await asr_engine.close_connection()
         await channel_websocket.close()
@@ -447,3 +459,13 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserIsSpeaking):
             self._cancel_silence_timeout_watcher()
             call_state.is_user_speaking = True  # type: ignore[attr-defined]
+        elif isinstance(e, UserSilence):
+            output_channel = self.create_output_channel(voice_websocket, tts_engine)
+            message = UserMessage(
+                "/silence_timeout",
+                output_channel,
+                call_parameters.stream_id,
+                input_channel=self.name(),
+                metadata=asdict(call_parameters),
+            )
+            await on_new_message(message)

rasa/core/policies/flows/flow_executor.py

@@ -287,8 +287,13 @@ def trigger_pattern_clarification(
     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
+    if current_frame.frame_type in [
+        FlowStackFrameType.CALL,
+        FlowStackFrameType.INTERRUPT,
+    ]:
+        # we want to return to the flow that called
+        # the current flow or the flow that was interrupted
+        # by the current flow
         return None
 
     pending_flows = [

rasa/core/processor.py

@@ -1553,7 +1553,6 @@ class MessageProcessor:
             tracker,
             prior_tracker_events,
             should_break=True,
-            update_corrected_slots=True,
         )
 
         return tracker, validate_frames

rasa/core/tracker_store.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import contextlib
 import itertools
 import json
-import logging
 import os
 from inspect import isawaitable, iscoroutinefunction
 from time import sleep
@@ -24,6 +23,7 @@ from typing import (
 )
 
 import sqlalchemy as sa
+import structlog
 from boto3.dynamodb.conditions import Key
 from pymongo.collection import Collection
 
@@ -31,6 +31,7 @@ import rasa.shared.utils.cli
 import rasa.shared.utils.common
 import rasa.shared.utils.io
 import rasa.utils.json_utils
+from rasa.constants import DEFAULT_SANIC_WORKERS, ENV_SANIC_WORKERS
 from rasa.core.brokers.broker import EventBroker
 from rasa.core.constants import (
     POSTGRESQL_MAX_OVERFLOW,
@@ -59,7 +60,7 @@ if TYPE_CHECKING:
     from sqlalchemy.engine.url import URL
     from sqlalchemy.orm import Query, Session
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger(__name__)
 
 # default values of PostgreSQL pool size and max overflow
 POSTGRESQL_DEFAULT_MAX_OVERFLOW = 100
@@ -315,7 +316,10 @@ class TrackerStore:
     async def stream_events(self, tracker: DialogueStateTracker) -> None:
         """Streams events to a message broker."""
         if self.event_broker is None:
-            logger.debug("No event broker configured. Skipping streaming events.")
+            structlogger.debug(
+                "tracker_store.stream_events.no_broker_configured",
+                event_info="No event broker configured. Skipping streaming events.",
+            )
             return None
 
         old_tracker = await self.retrieve(tracker.sender_id)
@@ -437,13 +441,22 @@ class InMemoryTrackerStore(TrackerStore, SerializedTrackerAsText):
             fetch_all_sessions: Whether to fetch all sessions or only the last one.
         """
         if sender_id not in self.store:
-            logger.debug(f"Could not find tracker for conversation ID '{sender_id}'.")
+            structlogger.debug(
+                "in_memory_tracker_store.retrieve.no_tracker_for_sender_id",
+                event_info=f"Could not find tracker for conversation ID '{sender_id}'.",
+            )
             return None
 
         tracker = self.deserialise_tracker(sender_id, self.store[sender_id])
 
         if not tracker:
-            logger.debug(f"Could not find tracker for conversation ID '{sender_id}'.")
+            structlogger.debug(
+                "in_memory_tracker_store.retrieve.failed_to_deserialize_tracker",
+                event_info=(
+                    f"Could not deserialize tracker "
+                    f"for conversation ID '{sender_id}'.",
+                ),
+            )
             return None
 
         if fetch_all_sessions:
@@ -499,7 +512,10 @@ class RedisTrackerStore(TrackerStore, SerializedTrackerAsText):
 
         self.key_prefix = DEFAULT_REDIS_TRACKER_STORE_KEY_PREFIX
         if key_prefix:
-            logger.debug(f"Setting non-default redis key prefix: '{key_prefix}'.")
+            structlogger.debug(
+                "redis_tracker_store.init.custom_key_prefix",
+                event_info=f"Setting non-default redis key prefix: '{key_prefix}'.",
+            )
             self._set_key_prefix(key_prefix)
 
         super().__init__(domain, event_broker, **kwargs)
@@ -508,9 +524,13 @@ class RedisTrackerStore(TrackerStore, SerializedTrackerAsText):
         if isinstance(key_prefix, str) and key_prefix.isalnum():
             self.key_prefix = key_prefix + ":" + DEFAULT_REDIS_TRACKER_STORE_KEY_PREFIX
         else:
-            logger.warning(
-                f"Omitting provided non-alphanumeric redis key prefix: '{key_prefix}'. "
-                f"Using default '{self.key_prefix}' instead."
+            structlogger.warning(
+                "redis_tracker_store.init.invalid_key_prefix",
+                event_info=(
+                    f"Omitting provided non-alphanumeric "
+                    f"redis key prefix: '{key_prefix}'. "
+                    f"Using default '{self.key_prefix}' instead."
+                ),
             )
 
     def _get_key_prefix(self) -> Text:
@@ -576,7 +596,10 @@ class RedisTrackerStore(TrackerStore, SerializedTrackerAsText):
         """
         stored = self.red.get(self.key_prefix + sender_id)
         if stored is None:
-            logger.debug(f"Could not find tracker for conversation ID '{sender_id}'.")
+            structlogger.debug(
+                "redis_tracker_store.retrieve.no_tracker_for_sender_id",
+                event_info=f"Could not find tracker for conversation ID '{sender_id}'.",
+            )
             return None
 
         tracker = self.deserialise_tracker(sender_id, stored)
@@ -674,6 +697,31 @@ class DynamoTrackerStore(TrackerStore, SerializedTrackerAsDict):
         try:
             self.client.describe_table(TableName=table_name)
         except self.client.exceptions.ResourceNotFoundException:
+            sanic_workers_count = int(
+                os.environ.get(ENV_SANIC_WORKERS, DEFAULT_SANIC_WORKERS)
+            )
+
+            if sanic_workers_count > 1:
+                structlogger.error(
+                    "dynamo_tracker_store.table_creation_not_supported_in_multi_worker_mode",
+                    event_info=(
+                        "DynamoDB table creation is not "
+                        "supported in multi-worker mode. "
+                        "Table should already exist.",
+                    ),
+                )
+                raise RasaException(
+                    "DynamoDB table creation is not supported in "
+                    "case of multiple sanic workers. To create the table either "
+                    "run Rasa with a single worker or create the table manually."
+                    "Here are the defaults which can be used to "
+                    "create the table manually: "
+                    f"Table name: {table_name}, Primary key: sender_id, "
+                    f"key type `HASH`, attribute type `S` (String), "
+                    "Provisioned throughput: Read capacity units: 5, "
+                    "Write capacity units: 5"
+                )
+
             table = dynamo.create_table(
                 TableName=self.table_name,
                 KeySchema=[{"AttributeName": "sender_id", "KeyType": "HASH"}],
@@ -1001,7 +1049,10 @@ def create_engine_kwargs(url: Union[Text, "URL"]) -> Dict[Text, Any]:
     schema_name = os.environ.get(POSTGRESQL_SCHEMA)
 
     if schema_name:
-        logger.debug(f"Using PostgreSQL schema '{schema_name}'.")
+        structlogger.debug(
+            "postgresql_tracker_store.schema_name",
+            event_inf=f"Using PostgreSQL schema '{schema_name}'.",
+        )
         kwargs["connect_args"] = {"options": f"-csearch_path={schema_name}"}
 
     # pool_size and max_overflow can be set to control the number of
@@ -1114,7 +1165,10 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
 
         self.engine = sa.create_engine(engine_url, **create_engine_kwargs(engine_url))
 
-        logger.debug(f"Attempting to connect to database via '{self.engine.url!r}'.")
+        structlogger.debug(
+            "sql_tracker_store.connect_to_sql_database",
+            event_info=f"Attempting to connect to database via '{self.engine.url!r}'.",
+        )
 
         # Database might take a while to come up
         while True:
@@ -1133,7 +1187,11 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
                     # Several Rasa services started in parallel may attempt to
                     # create tables at the same time. That is okay so long as
                     # the first services finishes the table creation.
-                    logger.error(f"Could not create tables: {e}")
+                    structlogger.error(
+                        "sql_tracker_store.create_tables_failed",
+                        event_info="Could not create tables",
+                        exec_info=e,
+                    )
 
                 self.sessionmaker = sa.orm.session.sessionmaker(bind=self.engine)
                 break
@@ -1141,10 +1199,17 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
                 sqlalchemy.exc.OperationalError,
                 sqlalchemy.exc.IntegrityError,
             ) as error:
-                logger.warning(error)
+                structlogger.warning(
+                    "sql_tracker_store.initialisation_error",
+                    event_info="Failed to establish a connection to the SQL database. ",
+                    exc_info=error,
+                )
                 sleep(5)
 
-        logger.debug(f"Connection to SQL database '{db}' successful.")
+        structlogger.debug(
+            "sql_tracker_store.connected_to_sql_database",
+            event_info=f"Connection to SQL database '{db}' successful.",
+        )
 
         super().__init__(domain, event_broker, **kwargs)
 
@@ -1212,7 +1277,7 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
         """Creates database `db` and updates engine accordingly."""
         from sqlalchemy import create_engine
 
-        if not self.engine.dialect.name == "postgresql":
+        if self.engine.dialect.name != "postgresql":
             rasa.shared.utils.io.raise_warning(
                 "The parameter 'login_db' can only be used with a postgres database."
             )
@@ -1252,7 +1317,11 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
                     sqlalchemy.exc.ProgrammingError,
                     sqlalchemy.exc.IntegrityError,
                 ) as e:
-                    logger.error(f"Could not create database '{database_name}': {e}")
+                    structlogger.error(
+                        "sql_tracker_store.create_database_failed",
+                        event_info=f"Could not create database '{database_name}'",
+                        exec_info=e,
+                    )
 
     @contextlib.contextmanager
     def session_scope(self) -> Generator["Session", None, None]:
@@ -1316,15 +1385,21 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
             events = [json.loads(event.data) for event in serialised_events]
 
             if self.domain and len(events) > 0:
-                logger.debug(f"Recreating tracker from sender id '{sender_id}'")
+                structlogger.debug(
+                    "sql_tracker_store.recreating_tracker",
+                    event_info=f"Recreating tracker from sender id '{sender_id}'",
+                )
                 return DialogueStateTracker.from_dict(
                     sender_id, events, self.domain.slots
                 )
             else:
-                logger.debug(
-                    f"Can't retrieve tracker matching "
-                    f"sender id '{sender_id}' from SQL storage. "
-                    f"Returning `None` instead."
+                structlogger.debug(
+                    "sql_tracker_store._retrieve.no_tracker_for_sender_id",
+                    event_info=(
+                        f"Can't retrieve tracker matching "
+                        f"sender id '{sender_id}' from SQL storage. "
+                        f"Returning `None` instead.",
+                    ),
                 )
                 return None
 
@@ -1401,7 +1476,12 @@ class SQLTrackerStore(TrackerStore, SerializedTrackerAsText):
                 )
             session.commit()
 
-        logger.debug(f"Tracker with sender_id '{tracker.sender_id}' stored to database")
+        structlogger.debug(
+            "sql_tracker_store.save_tracker",
+            event_info=(
+                f"Tracker with sender_id " f"'{tracker.sender_id}' stored to database",
+            ),
+        )
 
     def _additional_events(
         self, session: "Session", tracker: DialogueStateTracker
@@ -1469,11 +1549,14 @@ class FailSafeTrackerStore(TrackerStore):
         if self._on_tracker_store_error:
             self._on_tracker_store_error(error)
         else:
-            logger.error(
-                f"Error happened when trying to save conversation tracker to "
-                f"'{self._tracker_store.__class__.__name__}'. Falling back to use "
-                f"the '{InMemoryTrackerStore.__name__}'. Please "
-                f"investigate the following error: {error}."
+            structlogger.error(
+                "fail_safe_tracker_store.tracker_store_error",
+                event_info=(
+                    f"Error happened when trying to save conversation tracker to "
+                    f"'{self._tracker_store.__class__.__name__}'. Falling back to use "
+                    f"the '{InMemoryTrackerStore.__name__}'. Please "
+                    f"investigate the following error: {error}."
+                ),
             )
 
     async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
@@ -1525,11 +1608,14 @@ class FailSafeTrackerStore(TrackerStore):
         if self._on_tracker_store_error:
             self._on_tracker_store_error(error)
         else:
-            logger.error(
-                f"Error happened when trying to retrieve conversation tracker from "
-                f"'{self._tracker_store.__class__.__name__}'. Falling back to use "
-                f"the '{InMemoryTrackerStore.__name__}'. Please "
-                f"investigate the following error: {error}."
+            structlogger.error(
+                "fail_safe_tracker_store.tracker_store_retrieve_error",
+                event_info=(
+                    f"Error happened when trying to retrieve conversation tracker from "
+                    f"'{self._tracker_store.__class__.__name__}'. Falling back to use "
+                    f"the '{InMemoryTrackerStore.__name__}'."
+                ),
+                exec_info=error,
             )
 
 
@@ -1574,7 +1660,10 @@ def _create_from_endpoint_config(
             domain, endpoint_config, event_broker
         )
 
-    logger.debug(f"Connected to {tracker_store.__class__.__name__}.")
+    structlogger.debug(
+        "tracker_store.create_tracker_store_from_endpoint_config",
+        eventi_info=f"Connected to {tracker_store.__class__.__name__}.",
+    )
 
     return tracker_store
 

rasa/dialogue_understanding/commands/can_not_handle_command.py

@@ -99,7 +99,7 @@ class CannotHandleCommand(Command):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"CannotHandle\(\)",
-            CommandSyntaxVersion.v2: r"^[^\w]*cannot handle$",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*cannot handle['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -166,7 +166,7 @@ class CancelFlowCommand(Command):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"CancelFlow\(\)",
-            CommandSyntaxVersion.v2: r"^[^\w]*cancel flow$",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*cancel flow['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),

rasa/dialogue_understanding/commands/change_flow_command.py

@@ -70,7 +70,7 @@ class ChangeFlowCommand(Command):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"ChangeFlow\(\)",
-            CommandSyntaxVersion.v2: r"^[^\w]*change$",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*change['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -81,7 +81,7 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"ChitChat\(\)",
-            CommandSyntaxVersion.v2: r"^[^\w]*offtopic reply$",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*offtopic reply['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),

rasa/dialogue_understanding/commands/clarify_command.py

@@ -119,7 +119,7 @@ class ClarifyCommand(Command):
         mapper = {
             CommandSyntaxVersion.v1: r"Clarify\(([\"\'a-zA-Z0-9_, ]*)\)",
             CommandSyntaxVersion.v2: (
-                r"^[^\w]*disambiguate flows ([\"\'a-zA-Z0-9_, ]*)$"
+                r"""^[\s\W\d]*disambiguate flows (["'a-zA-Z0-9_, ]*)['"`]*$"""
             ),
         }
         return mapper.get(

rasa/dialogue_understanding/commands/command_syntax_manager.py

@@ -30,7 +30,7 @@ class CommandSyntaxManager:
         syntax version remains consistent throughout the lifetime of the generator.
         """
         if cls._version:
-            structlogger.warn(
+            structlogger.debug(
                 "command_syntax_manager.syntax_version_already_set",
                 event_info=(
                     f"The command syntax version has already been set. Overwriting "

rasa/dialogue_understanding/commands/handle_digressions_command.py

@@ -14,7 +14,6 @@ from rasa.dialogue_understanding.patterns.handle_digressions import (
 )
 from rasa.dialogue_understanding.stack.utils import (
     top_flow_frame,
-    user_flows_on_the_stack,
 )
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
@@ -71,12 +70,7 @@ class HandleDigressionsCommand(Command):
         stack = tracker.stack
         original_stack = original_tracker.stack
 
-        if self.flow in user_flows_on_the_stack(stack):
-            structlogger.debug(
-                "command_executor.skip_command.already_started_flow", command=self
-            )
-            return []
-        elif self.flow not in all_flows.flow_ids:
+        if self.flow not in all_flows.flow_ids:
             structlogger.debug(
                 "command_executor.push_cannot_handle.start_invalid_flow_id",
                 command=self,

rasa/dialogue_understanding/commands/human_handoff_command.py

@@ -88,7 +88,7 @@ class HumanHandoffCommand(Command):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"HumanHandoff\(\)",
-            CommandSyntaxVersion.v2: r"^[^\w]*hand over$",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*hand over['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -81,7 +81,7 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"SearchAndReply\(\)",
-            CommandSyntaxVersion.v2: r"^[^\w]*provide info$",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*provide info['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),

rasa/dialogue_understanding/commands/repeat_bot_messages_command.py

@@ -82,7 +82,7 @@ class RepeatBotMessagesCommand(Command):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"RepeatLastBotMessages\(\)",
-            CommandSyntaxVersion.v2: r"^[^\w]*repeat message$",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*repeat message['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),

rasa/dialogue_understanding/commands/set_slot_command.py

@@ -126,6 +126,7 @@ class SetSlotCommand(Command):
         if (
             self.name not in slots_of_active_flow
             and self.name != ROUTE_TO_CALM_SLOT
+            and not slot.is_builtin
             and self.extractor
             in {
                 SetSlotExtractor.LLM.value,
@@ -189,7 +190,7 @@ class SetSlotCommand(Command):
                 r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
             ),
             CommandSyntaxVersion.v2: (
-                r"""^[^\w]*set slot ['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]? ['"]?(.+?)['"]?$"""  # noqa: E501
+                r"""^[\s\W\d]*set slot ['"`]?([a-zA-Z_][a-zA-Z0-9_-]*)['"`]? ['"`]?(.+?)['"`]*$"""  # noqa: E501
             ),
         }
         return mapper.get(

rasa/dialogue_understanding/commands/skip_question_command.py

@@ -97,7 +97,7 @@ class SkipQuestionCommand(Command):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"SkipQuestion\(\)",
-            CommandSyntaxVersion.v2: r"^[^\w]*skip question$",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*skip question['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),