rasa-pro 3.10.9.dev1__py3-none-any.whl → 3.10.11__py3-none-any.whl

rasa/cli/arguments/train.py

@@ -3,12 +3,12 @@ from typing import Union
 
 from rasa.cli.arguments.default_arguments import (
     add_config_param,
-    add_stories_param,
-    add_nlu_data_param,
-    add_out_param,
     add_domain_param,
     add_endpoint_param,
+    add_nlu_data_param,
+    add_out_param,
     add_remote_storage_param,
+    add_stories_param,
 )
 from rasa.graph_components.providers.training_tracker_provider import (
     TrainingTrackerProvider,
@@ -40,6 +40,12 @@ def set_train_arguments(parser: argparse.ArgumentParser) -> None:
         parser, help_text="Configuration file for the connectors as a yml file."
     )
     add_remote_storage_param(parser)
+    parser.add_argument(
+        "--remote-bot-config-path",
+        help="Path to the bot configuration file in the remote storage.",
+        required=False,
+        type=str,
+    )
 
 
 def set_train_core_arguments(parser: argparse.ArgumentParser) -> None:

rasa/cli/train.py

@@ -1,18 +1,22 @@
 import argparse
 import asyncio
+import os
 import sys
 from pathlib import Path
 from typing import Dict, List, Optional, Text, Union
 
 import structlog
+from tarsafe import TarSafe
 
 import rasa.cli.arguments.train as train_arguments
 import rasa.cli.utils
 import rasa.core.utils
 import rasa.utils.common
+from rasa.api import train as train_all
 from rasa.cli import SubParsersAction
 from rasa.core.nlg.generator import NaturalLanguageGenerator
 from rasa.core.train import do_compare_training
+from rasa.nlu.persistor import get_persistor
 from rasa.shared.constants import (
     CONFIG_MANDATORY_KEYS,
     CONFIG_MANDATORY_KEYS_CORE,
@@ -20,6 +24,7 @@ from rasa.shared.constants import (
     DEFAULT_DATA_PATH,
     DEFAULT_DOMAIN_PATHS,
 )
+from rasa.shared.exceptions import RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
 
 structlogger = structlog.getLogger(__name__)
@@ -36,7 +41,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,
     )
@@ -83,6 +88,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 +130,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.api 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

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()

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.10.9.dev1"
+MINIMUM_COMPATIBLE_VERSION = "3.10.0rc1"
 
 GLOBAL_USER_CONFIG_PATH = os.path.expanduser("~/.config/rasa/global.yml")
 

rasa/core/featurizers/single_state_featurizer.py

@@ -1,8 +1,7 @@
 import logging
-from typing import List, Optional, Dict, Text, Set, Any
-
 import numpy as np
 import scipy.sparse
+from typing import List, Optional, Dict, Text, Set, Any
 
 from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
 from rasa.nlu.extractors.extractor import EntityTagSpec
@@ -361,26 +360,6 @@ class SingleStateFeaturizer:
             for action in domain.action_names_or_texts
         ]
 
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "action_texts": self.action_texts,
-            "entity_tag_specs": self.entity_tag_specs,
-            "feature_states": self._default_feature_states,
-        }
-
-    @classmethod
-    def create_from_dict(
-        cls, data: Dict[str, Any]
-    ) -> Optional["SingleStateFeaturizer"]:
-        if not data:
-            return None
-
-        featurizer = SingleStateFeaturizer()
-        featurizer.action_texts = data["action_texts"]
-        featurizer._default_feature_states = data["feature_states"]
-        featurizer.entity_tag_specs = data["entity_tag_specs"]
-        return featurizer
-
 
 class IntentTokenizerSingleStateFeaturizer(SingleStateFeaturizer):
     """A SingleStateFeaturizer for use with policies that predict intent labels."""

rasa/core/featurizers/tracker_featurizers.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
-
-import logging
-from abc import abstractmethod
-from collections import defaultdict
 from pathlib import Path
+from collections import defaultdict
+from abc import abstractmethod
+import jsonpickle
+import logging
+
+from tqdm import tqdm
 from typing import (
     Tuple,
     List,
@@ -16,30 +18,25 @@ from typing import (
     Set,
     DefaultDict,
     cast,
-    Type,
-    Callable,
-    ClassVar,
 )
-
 import numpy as np
-from tqdm import tqdm
 
+from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
+from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
+from rasa.core.exceptions import InvalidTrackerFeaturizerUsageError
 import rasa.shared.core.trackers
 import rasa.shared.utils.io
-from rasa.core.exceptions import InvalidTrackerFeaturizerUsageError
-from rasa.core.featurizers.precomputation import MessageContainerForCoreFeaturization
-from rasa.core.featurizers.single_state_featurizer import SingleStateFeaturizer
+from rasa.shared.nlu.constants import TEXT, INTENT, ENTITIES, ACTION_NAME
+from rasa.shared.nlu.training_data.features import Features
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.core.domain import State, Domain
+from rasa.shared.core.events import Event, ActionExecuted, UserUttered
 from rasa.shared.core.constants import (
     USER,
     ACTION_UNLIKELY_INTENT_NAME,
     PREVIOUS_ACTION,
 )
-from rasa.shared.core.domain import State, Domain
-from rasa.shared.core.events import Event, ActionExecuted, UserUttered
-from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
-from rasa.shared.nlu.constants import TEXT, INTENT, ENTITIES, ACTION_NAME
-from rasa.shared.nlu.training_data.features import Features
 from rasa.utils.tensorflow.constants import LABEL_PAD_ID
 from rasa.utils.tensorflow.model_data import ragged_array_to_ndarray
 
@@ -67,10 +64,6 @@ class InvalidStory(RasaException):
 class TrackerFeaturizer:
     """Base class for actual tracker featurizers."""
 
-    # Class registry to store all subclasses
-    _registry: ClassVar[Dict[str, Type["TrackerFeaturizer"]]] = {}
-    _featurizer_type: str = "TrackerFeaturizer"
-
     def __init__(
         self, state_featurizer: Optional[SingleStateFeaturizer] = None
     ) -> None:
@@ -81,36 +74,6 @@ class TrackerFeaturizer:
         """
         self.state_featurizer = state_featurizer
 
-    @classmethod
-    def register(cls, featurizer_type: str) -> Callable:
-        """Decorator to register featurizer subclasses."""
-
-        def wrapper(subclass: Type["TrackerFeaturizer"]) -> Type["TrackerFeaturizer"]:
-            cls._registry[featurizer_type] = subclass
-            # Store the type identifier in the class for serialization
-            subclass._featurizer_type = featurizer_type
-            return subclass
-
-        return wrapper
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> "TrackerFeaturizer":
-        """Create featurizer instance from dictionary."""
-        featurizer_type = data.pop("type")
-
-        if featurizer_type not in cls._registry:
-            raise ValueError(f"Unknown featurizer type: {featurizer_type}")
-
-        # Get the correct subclass and instantiate it
-        subclass = cls._registry[featurizer_type]
-        return subclass.create_from_dict(data)
-
-    @classmethod
-    @abstractmethod
-    def create_from_dict(cls, data: Dict[str, Any]) -> "TrackerFeaturizer":
-        """Each subclass must implement its own creation from dict method."""
-        pass
-
     @staticmethod
     def _create_states(
         tracker: DialogueStateTracker,
@@ -502,7 +465,9 @@ class TrackerFeaturizer:
             self.state_featurizer.entity_tag_specs = []
 
         # noinspection PyTypeChecker
-        rasa.shared.utils.io.dump_obj_as_json_to_file(featurizer_file, self.to_dict())
+        rasa.shared.utils.io.write_text_file(
+            str(jsonpickle.encode(self)), featurizer_file
+        )
 
     @staticmethod
     def load(path: Union[Text, Path]) -> Optional[TrackerFeaturizer]:
@@ -516,17 +481,7 @@ class TrackerFeaturizer:
         """
         featurizer_file = Path(path) / FEATURIZER_FILE
         if featurizer_file.is_file():
-            data = rasa.shared.utils.io.read_json_file(featurizer_file)
-
-            if "type" not in data:
-                logger.error(
-                    f"Couldn't load featurizer for policy. "
-                    f"File '{featurizer_file}' does not contain all "
-                    f"necessary information. 'type' is missing."
-                )
-                return None
-
-            return TrackerFeaturizer.from_dict(data)
+            return jsonpickle.decode(rasa.shared.utils.io.read_file(featurizer_file))
 
         logger.error(
             f"Couldn't load featurizer for policy. "
@@ -553,16 +508,7 @@ class TrackerFeaturizer:
             )
         ]
 
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "type": self.__class__._featurizer_type,
-            "state_featurizer": (
-                self.state_featurizer.to_dict() if self.state_featurizer else None
-            ),
-        }
-
 
-@TrackerFeaturizer.register("FullDialogueTrackerFeaturizer")
 class FullDialogueTrackerFeaturizer(TrackerFeaturizer):
     """Creates full dialogue training data for time distributed architectures.
 
@@ -700,20 +646,7 @@ class FullDialogueTrackerFeaturizer(TrackerFeaturizer):
 
         return trackers_as_states
 
-    def to_dict(self) -> Dict[str, Any]:
-        return super().to_dict()
 
-    @classmethod
-    def create_from_dict(cls, data: Dict[str, Any]) -> "FullDialogueTrackerFeaturizer":
-        state_featurizer = SingleStateFeaturizer.create_from_dict(
-            data["state_featurizer"]
-        )
-        return cls(
-            state_featurizer,
-        )
-
-
-@TrackerFeaturizer.register("MaxHistoryTrackerFeaturizer")
 class MaxHistoryTrackerFeaturizer(TrackerFeaturizer):
     """Truncates the tracker history into `max_history` long sequences.
 
@@ -951,25 +884,7 @@ class MaxHistoryTrackerFeaturizer(TrackerFeaturizer):
 
         return trackers_as_states
 
-    def to_dict(self) -> Dict[str, Any]:
-        data = super().to_dict()
-        data.update(
-            {
-                "remove_duplicates": self.remove_duplicates,
-                "max_history": self.max_history,
-            }
-        )
-        return data
-
-    @classmethod
-    def create_from_dict(cls, data: Dict[str, Any]) -> "MaxHistoryTrackerFeaturizer":
-        state_featurizer = SingleStateFeaturizer.create_from_dict(
-            data["state_featurizer"]
-        )
-        return cls(state_featurizer, data["max_history"], data["remove_duplicates"])
 
-
-@TrackerFeaturizer.register("IntentMaxHistoryTrackerFeaturizer")
 class IntentMaxHistoryTrackerFeaturizer(MaxHistoryTrackerFeaturizer):
     """Truncates the tracker history into `max_history` long sequences.
 
@@ -1244,18 +1159,6 @@ class IntentMaxHistoryTrackerFeaturizer(MaxHistoryTrackerFeaturizer):
 
         return trackers_as_states
 
-    def to_dict(self) -> Dict[str, Any]:
-        return super().to_dict()
-
-    @classmethod
-    def create_from_dict(
-        cls, data: Dict[str, Any]
-    ) -> "IntentMaxHistoryTrackerFeaturizer":
-        state_featurizer = SingleStateFeaturizer.create_from_dict(
-            data["state_featurizer"]
-        )
-        return cls(state_featurizer, data["max_history"], data["remove_duplicates"])
-
 
 def _is_prev_action_unlikely_intent_in_state(state: State) -> bool:
     prev_action_name = state.get(PREVIOUS_ACTION, {}).get(ACTION_NAME)

rasa/core/policies/ted_policy.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
-
 import logging
+
+from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from pathlib import Path
 from collections import defaultdict
 import contextlib
-from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
 import numpy as np
 import tensorflow as tf
+from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
-from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
@@ -49,22 +49,18 @@ from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.events import EntitiesAdded, Event
 from rasa.shared.core.domain import Domain
 from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.nlu.training_data.features import (
-    Features,
-    save_features,
-    load_features,
-)
+from rasa.shared.nlu.training_data.features import Features
 import rasa.shared.utils.io
 import rasa.utils.io
 from rasa.utils import train_utils
-from rasa.utils.tensorflow.feature_array import (
-    FeatureArray,
-    serialize_nested_feature_arrays,
-    deserialize_nested_feature_arrays,
-)
 from rasa.utils.tensorflow.models import RasaModel, TransformerRasaModel
 from rasa.utils.tensorflow import rasa_layers
-from rasa.utils.tensorflow.model_data import RasaModelData, FeatureSignature, Data
+from rasa.utils.tensorflow.model_data import (
+    RasaModelData,
+    FeatureSignature,
+    FeatureArray,
+    Data,
+)
 from rasa.utils.tensorflow.model_data_utils import convert_to_data_format
 from rasa.utils.tensorflow.constants import (
     LABEL,
@@ -965,32 +961,22 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted
         """
         model_filename = self._metadata_filename()
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.priority.json", self.priority
-        )
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.meta.json", self.config
+        rasa.utils.io.json_pickle(
+            model_path / f"{model_filename}.priority.pkl", self.priority
         )
-        # save data example
-        serialize_nested_feature_arrays(
-            self.data_example,
-            str(model_path / f"{model_filename}.data_example.st"),
-            str(model_path / f"{model_filename}.data_example_metadata.json"),
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.meta.pkl", self.config
         )
-        # save label data
-        serialize_nested_feature_arrays(
-            dict(self._label_data.data) if self._label_data is not None else {},
-            str(model_path / f"{model_filename}.label_data.st"),
-            str(model_path / f"{model_filename}.label_data_metadata.json"),
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.data_example.pkl", self.data_example
         )
-        # save fake features
-        metadata = save_features(
-            self.fake_features, str(model_path / f"{model_filename}.fake_features.st")
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.fake_features.pkl", self.fake_features
         )
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.fake_features_metadata.json", metadata
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.label_data.pkl",
+            dict(self._label_data.data) if self._label_data is not None else {},
         )
-
         entity_tag_specs = (
             [tag_spec._asdict() for tag_spec in self._entity_tag_specs]
             if self._entity_tag_specs
@@ -1008,29 +994,18 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted.
         """
         tf_model_file = model_path / f"{cls._metadata_filename()}.tf_model"
-
-        # load data example
-        loaded_data = deserialize_nested_feature_arrays(
-            str(model_path / f"{cls._metadata_filename()}.data_example.st"),
-            str(model_path / f"{cls._metadata_filename()}.data_example_metadata.json"),
+        loaded_data = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.data_example.pkl"
         )
-        # load label data
-        loaded_label_data = deserialize_nested_feature_arrays(
-            str(model_path / f"{cls._metadata_filename()}.label_data.st"),
-            str(model_path / f"{cls._metadata_filename()}.label_data_metadata.json"),
+        label_data = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.label_data.pkl"
         )
-        label_data = RasaModelData(data=loaded_label_data)
-
-        # load fake features
-        metadata = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.fake_features_metadata.json"
+        fake_features = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.fake_features.pkl"
         )
-        fake_features = load_features(
-            str(model_path / f"{cls._metadata_filename()}.fake_features.st"), metadata
-        )
-
-        priority = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.priority.json"
+        label_data = RasaModelData(data=label_data)
+        priority = rasa.utils.io.json_unpickle(
+            model_path / f"{cls._metadata_filename()}.priority.pkl"
         )
         entity_tag_specs = rasa.shared.utils.io.read_json_file(
             model_path / f"{cls._metadata_filename()}.entity_tag_specs.json"
@@ -1048,8 +1023,8 @@ class TEDPolicy(Policy):
             )
             for tag_spec in entity_tag_specs
         ]
-        model_config = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.meta.json"
+        model_config = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.meta.pkl"
         )
 
         return {
@@ -1095,7 +1070,7 @@ class TEDPolicy(Policy):
     ) -> TEDPolicy:
         featurizer = TrackerFeaturizer.load(model_path)
 
-        if not (model_path / f"{cls._metadata_filename()}.data_example.st").is_file():
+        if not (model_path / f"{cls._metadata_filename()}.data_example.pkl").is_file():
             return cls(
                 config,
                 model_storage,

rasa/core/policies/unexpected_intent_policy.py

@@ -5,7 +5,6 @@ from typing import Any, List, Optional, Text, Dict, Type, Union
 
 import numpy as np
 import tensorflow as tf
-
 import rasa.utils.common
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
@@ -17,7 +16,6 @@ from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.constants import SLOTS, ACTIVE_LOOP, ACTION_UNLIKELY_INTENT_NAME
 from rasa.shared.core.events import UserUttered, ActionExecuted
-import rasa.shared.utils.io
 from rasa.shared.nlu.constants import (
     INTENT,
     TEXT,
@@ -105,6 +103,8 @@ from rasa.utils.tensorflow.constants import (
 )
 from rasa.utils.tensorflow import layers
 from rasa.utils.tensorflow.model_data import RasaModelData, FeatureArray, Data
+
+import rasa.utils.io as io_utils
 from rasa.core.exceptions import RasaCoreException
 from rasa.shared.utils import common
 
@@ -881,12 +881,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted
         """
         super().persist_model_utilities(model_path)
-
-        from safetensors.numpy import save_file
-
-        save_file(
-            {str(k): np.array(v) for k, v in self.label_quantiles.items()},
-            model_path / f"{self._metadata_filename()}.label_quantiles.st",
+        io_utils.pickle_dump(
+            model_path / f"{self._metadata_filename()}.label_quantiles.pkl",
+            self.label_quantiles,
         )
 
     @classmethod
@@ -897,14 +894,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted.
         """
         model_utilties = super()._load_model_utilities(model_path)
-
-        from safetensors.numpy import load_file
-
-        loaded_label_quantiles = load_file(
-            model_path / f"{cls._metadata_filename()}.label_quantiles.st"
+        label_quantiles = io_utils.pickle_load(
+            model_path / f"{cls._metadata_filename()}.label_quantiles.pkl"
         )
-        label_quantiles = {int(k): list(v) for k, v in loaded_label_quantiles.items()}
-
         model_utilties.update({"label_quantiles": label_quantiles})
         return model_utilties
 

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -229,9 +229,9 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         commands: List[Command] = []
 
         slot_set_re = re.compile(
-            r"""SetSlot\((\"?[a-zA-Z_][a-zA-Z0-9_-]*?\"?), ?(.*)\)"""
+            r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
         )
-        start_flow_re = re.compile(r"StartFlow\(([a-zA-Z0-9_-]+?)\)")
+        start_flow_re = re.compile(r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)")
         change_flow_re = re.compile(r"ChangeFlow\(\)")
         cancel_flow_re = re.compile(r"CancelFlow\(\)")
         chitchat_re = re.compile(r"ChitChat\(\)")
@@ -280,9 +280,19 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
                 commands.append(HumanHandoffCommand())
             elif match := clarify_re.search(action):
                 options = sorted([opt.strip() for opt in match.group(1).split(",")])
+                # Remove surrounding quotes if present
+                cleaned_options = []
+                for flow in options:
+                    if (flow.startswith('"') and flow.endswith('"')) or (
+                        flow.startswith("'") and flow.endswith("'")
+                    ):
+                        cleaned_options.append(flow[1:-1])
+                    else:
+                        cleaned_options.append(flow)
+                # check if flow is valid
                 valid_options = [
                     flow
-                    for flow in options
+                    for flow in cleaned_options
                     if flow in flows.user_flow_ids
                     and flow not in user_flows_on_the_stack(tracker.stack)
                 ]
@@ -293,6 +303,13 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             elif change_flow_re.search(action):
                 commands.append(ChangeFlowCommand())
 
+        if not commands:
+            structlogger.debug(
+                "multi_step_llm_command_generator.parse_commands",
+                message="No commands were parsed from the LLM actions.",
+                actions=actions,
+            )
+
         return commands
 
     ### Helper methods