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

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -24,6 +24,7 @@ from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
     FLOW_RETRIEVAL_KEY,
+    DEFAULT_LLM_CONFIG,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
 from rasa.dialogue_understanding.generator.llm_based_command_generator import (
@@ -53,6 +54,7 @@ from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
     sanitize_message_for_prompt,
     allowed_values_for_slot,
+    try_instantiate_llm_client,
 )
 
 # multistep template keys
@@ -141,6 +143,12 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         prompts = cls._load_prompt_templates(model_storage, resource)
         # init base command generator
         command_generator = cls(config, model_storage, resource, prompts)
+        try_instantiate_llm_client(
+            command_generator.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "multi_step_llm_command_generator.load",
+            MultiStepLLMCommandGenerator.__name__,
+        )
         # load flow retrieval if enabled
         if command_generator.enabled_flow_retrieval:
             command_generator.flow_retrieval = cls.load_flow_retrival(
@@ -179,101 +187,29 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             return []
 
         try:
-            # retrieve relevant flows
-            filtered_flows = await self.filter_flows(message, flows, tracker)
-
-            # 1st step: Handle active flow
-            if tracker.has_active_user_flow:
-                commands_from_active_flow = (
-                    await self._predict_commands_for_active_flow(
-                        message,
-                        tracker,
-                        available_flows=filtered_flows,
-                        all_flows=flows,
-                    )
-                )
-            else:
-                commands_from_active_flow = []
-
-            # 2nd step: Check if we need to switch to another flow
-            contains_change_flow_command = any(
-                isinstance(command, ChangeFlowCommand)
-                for command in commands_from_active_flow
-            )
-            should_change_flows = (
-                not commands_from_active_flow or contains_change_flow_command
+            commands = await self._predict_commands_with_multi_step(
+                message, flows, tracker
             )
+            commands = self._clean_up_commands(commands)
+        except ProviderClientAPIException:
+            # if any step resulted in API exception, the command prediction cannot
+            # be completed, "predict" the ErrorCommand
+            commands = [ErrorCommand()]
 
-            if should_change_flows:
-                commands_for_handling_flows = (
-                    await self._predict_commands_for_handling_flows(
-                        message,
-                        tracker,
-                        available_flows=filtered_flows,
-                        all_flows=flows,
-                    )
-                )
-            else:
-                commands_for_handling_flows = []
-
-            if contains_change_flow_command:
-                commands_from_active_flow.pop(
-                    commands_from_active_flow.index(ChangeFlowCommand())
-                )
-
-            # 3rd step: Fill slots for started flows
-            newly_started_flows = FlowsList(
-                [
-                    flow
-                    for command in commands_for_handling_flows
-                    if (
-                        isinstance(command, StartFlowCommand)
-                        and (flow := filtered_flows.flow_by_id(command.flow))
-                        is not None
-                    )
-                ]
-            )
+        if not commands:
+            # if for any reason the final list of commands is empty,
+            # "predict" CannotHandle
+            commands = [CannotHandleCommand()]
 
-            commands_for_newly_started_flows = (
-                await self._predict_commands_for_newly_started_flows(
-                    message,
-                    tracker,
-                    newly_started_flows=newly_started_flows,
-                    all_flows=flows,
-                )
-            )
+        if tracker.has_coexistence_routing_slot:
+            # if coexistence feature is used, set the routing slot
+            commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True)]
 
-        # if any step resulted in API exception,
-        # the command prediction cannot be completed,
-        # raise ErrorCommand
-        except ProviderClientAPIException:
-            return [ErrorCommand()]
-
-        # concatenate predicted commands
-        commands = list(
-            set(
-                commands_from_active_flow
-                + commands_for_handling_flows
-                + commands_for_newly_started_flows
-            )
-        )
-        commands = self._clean_up_commands(commands)
         structlogger.debug(
-            "multi_step_llm_command_generator" ".predict_commands" ".finished",
+            "multi_step_llm_command_generator.predict_commands.finished",
             commands=commands,
         )
 
-        # if for any reason the final list of commands is empty,
-        # return CannotHandle
-        if not commands:
-            # if action_list is None, we couldn't get any response from the LLM
-            commands = [CannotHandleCommand()]
-        else:
-            # if the LLM command generator predicted valid commands and the
-            # coexistence feature is used, set the routing slot
-            if tracker.has_coexistence_routing_slot:
-                commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True)]
-
         return commands
 
     @classmethod
@@ -301,9 +237,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\(\)")
@@ -352,9 +288,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)
                 ]
@@ -365,6 +311,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
@@ -440,6 +393,97 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
                 file_path = path / file_name
                 rasa.shared.utils.io.write_text_file(template, file_path)
 
+    async def _predict_commands_with_multi_step(
+        self,
+        message: Message,
+        flows: FlowsList,
+        tracker: DialogueStateTracker,
+    ) -> List[Command]:
+        """Predict commands using the LLM.
+
+        Args:
+            message: The message from the user.
+            flows: The flows available to the user.
+            tracker: The tracker containing the current state of the conversation.
+
+        Returns:
+            The commands generated by the llm.
+
+        Raises:
+            ProviderClientAPIException: If API calls raised an error.
+        """
+        # retrieve relevant flows
+        filtered_flows = await self.filter_flows(message, flows, tracker)
+
+        # 1st step: Handle active flow
+        if tracker.has_active_user_flow:
+            commands_from_active_flow = await self._predict_commands_for_active_flow(
+                message,
+                tracker,
+                available_flows=filtered_flows,
+                all_flows=flows,
+            )
+        else:
+            commands_from_active_flow = []
+
+        # 2nd step: Check if we need to switch to another flow
+        contains_change_flow_command = any(
+            isinstance(command, ChangeFlowCommand)
+            for command in commands_from_active_flow
+        )
+        should_change_flows = (
+            not commands_from_active_flow or contains_change_flow_command
+        )
+
+        if should_change_flows:
+            commands_for_handling_flows = (
+                await self._predict_commands_for_handling_flows(
+                    message,
+                    tracker,
+                    available_flows=filtered_flows,
+                    all_flows=flows,
+                )
+            )
+        else:
+            commands_for_handling_flows = []
+
+        if contains_change_flow_command:
+            commands_from_active_flow.pop(
+                commands_from_active_flow.index(ChangeFlowCommand())
+            )
+
+        # 3rd step: Fill slots for started flows
+        newly_started_flows = FlowsList(
+            [
+                flow
+                for command in commands_for_handling_flows
+                if (
+                    isinstance(command, StartFlowCommand)
+                    and (flow := filtered_flows.flow_by_id(command.flow)) is not None
+                )
+            ]
+        )
+
+        commands_for_newly_started_flows = (
+            await self._predict_commands_for_newly_started_flows(
+                message,
+                tracker,
+                newly_started_flows=newly_started_flows,
+                all_flows=flows,
+            )
+        )
+
+        # concatenate predicted commands
+        commands = list(
+            set(
+                commands_from_active_flow
+                + commands_for_handling_flows
+                + commands_for_newly_started_flows
+            )
+        )
+
+        return commands
+
     async def _predict_commands_for_active_flow(
         self,
         message: Message,

rasa/dialogue_understanding/generator/nlu_command_adapter.py

@@ -2,13 +2,15 @@ from typing import Dict, Text, Any, Optional, List
 
 import structlog
 
-
 from rasa.dialogue_understanding.commands import (
     Command,
     StartFlowCommand,
     SetSlotCommand,
 )
 from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
+from rasa.dialogue_understanding.commands.utils import (
+    triggerable_pattern_to_command_class,
+)
 from rasa.dialogue_understanding.generator import CommandGenerator
 from rasa.engine.graph import GraphComponent, ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
@@ -17,6 +19,7 @@ from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.constants import ROUTE_TO_CALM_SLOT
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows.flows_list import FlowsList
+from rasa.shared.core.flows.steps import CollectInformationFlowStep
 from rasa.shared.core.slot_mappings import (
     SlotFillingManager,
     extract_slot_value,
@@ -25,6 +28,7 @@ from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import ENTITIES, INTENT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.utils.log_utils import log_llm
 
 structlogger = structlog.get_logger()
 
@@ -126,13 +130,22 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
             clean_up_commands,
         )
 
-        structlogger.info("nlu_command_adapter.cleaning_commands", commands=commands)
+        log_llm(
+            logger=structlogger,
+            log_module="NLUCommandAdapter",
+            log_event="nlu_command_adapter.predict_commands.finished",
+            commands=commands,
+        )
+
         if commands:
             commands = clean_up_commands(
                 commands, tracker, flows, self._execution_context
             )
-            structlogger.info(
-                "nlu_command_adapter.clean_commands", clean_commands=commands
+            log_llm(
+                logger=structlogger,
+                log_module="NLUCommandAdapter",
+                log_event="nlu_command_adapter.clean_commands",
+                commands=commands,
             )
 
         return commands
@@ -162,7 +175,12 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
 
         for flow in flows:
             if flow.nlu_triggers and flow.nlu_triggers.is_triggered(message):
-                commands.append(StartFlowCommand(flow.id))
+                if flow.is_rasa_default_flow:
+                    pattern_command = triggerable_pattern_to_command_class.get(flow.id)
+                    if pattern_command:
+                        commands.append(pattern_command())
+                else:
+                    commands.append(StartFlowCommand(flow.id))
 
         # there should be just one flow that can be triggered by the predicted intent
         # this is checked when loading the flows
@@ -180,7 +198,12 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
         set_slot_commands = _issue_set_slot_commands(message, tracker, flows, domain)
         commands.extend(set_slot_commands)
 
-        structlogger.info("nlu_command_adapter.predict_commands", commands=commands)
+        log_llm(
+            logger=structlogger,
+            log_module="NLUCommandAdapter",
+            log_event="nlu_command_adapter.predict_commands",
+            commands=commands,
+        )
 
         return commands
 
@@ -195,7 +218,24 @@ def _issue_set_slot_commands(
     commands: List[Command] = []
     domain = domain if domain else Domain.empty()
     slot_filling_manager = SlotFillingManager(domain, tracker, message)
-    available_slot_names = flows.available_slot_names()
+
+    # only use slots that don't have ask_before_filling set to True
+    available_slot_names = flows.available_slot_names(ask_before_filling=False)
+
+    # check if the current step is a CollectInformationFlowStep
+    # in case it has ask_before_filling set to True, we need to add the
+    # slot to the available_slot_names
+    if tracker.active_flow:
+        flow = flows.flow_by_id(tracker.active_flow)
+        step_id = tracker.current_step_id
+        if flow is not None:
+            current_step = flow.step_by_id(step_id)
+            if (
+                current_step
+                and isinstance(current_step, CollectInformationFlowStep)
+                and current_step.ask_before_filling
+            ):
+                available_slot_names.add(current_step.collect)
 
     for _, slot in tracker.slots.items():
         # if a slot is not collected in available flows,

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -1,8 +1,9 @@
 import importlib.resources
 import re
-import structlog
 from typing import Dict, Any, List, Optional, Text
 
+import structlog
+
 import rasa.shared.utils.io
 from rasa.dialogue_understanding.commands import (
     Command,
@@ -16,33 +17,39 @@ from rasa.dialogue_understanding.commands import (
     ClarifyCommand,
     CannotHandleCommand,
 )
-from rasa.dialogue_understanding.generator.llm_based_command_generator import (
-    LLMBasedCommandGenerator,
-)
 from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
     FLOW_RETRIEVAL_KEY,
+    DEFAULT_LLM_CONFIG,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import (
     FlowRetrieval,
 )
+from rasa.dialogue_understanding.generator.llm_based_command_generator import (
+    LLMBasedCommandGenerator,
+)
 from rasa.dialogue_understanding.stack.utils import top_flow_frame
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
-from rasa.shared.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.constants import (
+    ROUTE_TO_CALM_SLOT,
+    PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
+)
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.nlu.constants import TEXT
-from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.exceptions import ProviderClientAPIException
+from rasa.shared.nlu.constants import TEXT, LLM_COMMANDS, LLM_PROMPT
+from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
     get_prompt_template,
     tracker_as_readable_transcript,
     sanitize_message_for_prompt,
+    try_instantiate_llm_client,
 )
 from rasa.utils.log_utils import log_llm
 
@@ -82,7 +89,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         )
 
         # Set the prompt template
-        if config.get("prompt"):
+        if config.get(PROMPT_CONFIG_KEY):
             structlogger.warning(
                 "single_step_llm_command_generator.init",
                 event_info=(
@@ -91,7 +98,11 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
                     "Please use the config parameter 'prompt_template' instead. "
                 ),
             )
-        config_prompt = config.get("prompt") or config.get("prompt_template") or None
+        config_prompt = (
+            config.get(PROMPT_CONFIG_KEY)
+            or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            or None
+        )
         self.prompt_template = prompt_template or get_prompt_template(
             config_prompt,
             DEFAULT_COMMAND_PROMPT_TEMPLATE,
@@ -104,8 +115,8 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
     def get_default_config() -> Dict[str, Any]:
         """The component's default config (see parent class for full docstring)."""
         return {
-            "prompt": None,  # Legacy
-            "prompt_template": None,
+            PROMPT_CONFIG_KEY: None,  # Legacy
+            PROMPT_TEMPLATE_CONFIG_KEY: None,
             USER_INPUT_CONFIG_KEY: None,
             LLM_CONFIG_KEY: None,
             FLOW_RETRIEVAL_KEY: FlowRetrieval.get_default_config(),
@@ -127,6 +138,12 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         )
         # init base command generator
         command_generator = cls(config, model_storage, resource, prompt_template)
+        try_instantiate_llm_client(
+            command_generator.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "single_step_llm_command_generator.load",
+            SingleStepLLMCommandGenerator.__name__,
+        )
         # load flow retrieval if enabled
         if command_generator.enabled_flow_retrieval:
             command_generator.flow_retrieval = cls.load_flow_retrival(
@@ -167,11 +184,57 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             # cannot do anything if there are no flows or no tracker
             return []
 
-        # retrieve flows
         try:
-            filtered_flows = await self.filter_flows(message, flows, tracker)
+            commands = await self._predict_commands(message, flows, tracker)
         except ProviderClientAPIException:
-            return [ErrorCommand()]
+            # if command predictions resulted in API exception
+            # "predict" the ErrorCommand
+            commands = [ErrorCommand()]
+
+        if not commands:
+            # no commands are parsed or there's an invalid command
+            structlogger.warning(
+                "single_step_llm_command_generator.predict_commands",
+                message="No commands were predicted as the LLM response could "
+                "not be parsed or the LLM responded with an invalid command."
+                "Returning a CannotHandleCommand instead.",
+            )
+            commands = [CannotHandleCommand()]
+
+        if tracker.has_coexistence_routing_slot:
+            # if coexistence feature is used, set the routing slot
+            commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True)]
+
+        log_llm(
+            logger=structlogger,
+            log_module="SingleStepLLMCommandGenerator",
+            log_event="llm_command_generator.predict_commands.finished",
+            commands=commands,
+        )
+
+        return commands
+
+    async def _predict_commands(
+        self,
+        message: Message,
+        flows: FlowsList,
+        tracker: Optional[DialogueStateTracker] = None,
+    ) -> List[Command]:
+        """Predict commands using the LLM.
+
+        Args:
+            message: The message from the user.
+            flows: The flows available to the user.
+            tracker: The tracker containing the current state of the conversation.
+
+        Returns:
+            The commands generated by the llm.
+
+        Raises:
+            ProviderClientAPIException: If API calls raised an error.
+        """
+        # retrieve flows
+        filtered_flows = await self.filter_flows(message, flows, tracker)
 
         flow_prompt = self.render_template(message, tracker, filtered_flows, flows)
         log_llm(
@@ -181,14 +244,11 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             prompt=flow_prompt,
         )
 
-        try:
-            action_list = await self.invoke_llm(flow_prompt)
-            # The check for 'None' maintains compatibility with older versions
-            # of LLMCommandGenerator. In previous implementations, 'invoke_llm'
-            # might return 'None' to indicate a failure to generate actions.
-            if action_list is None:
-                return [ErrorCommand()]
-        except ProviderClientAPIException:
+        action_list = await self.invoke_llm(flow_prompt)
+        # The check for 'None' maintains compatibility with older versions
+        # of LLMCommandGenerator. In previous implementations, 'invoke_llm'
+        # might return 'None' to indicate a failure to generate actions.
+        if action_list is None:
             return [ErrorCommand()]
 
         log_llm(
@@ -200,23 +260,26 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
 
         commands = self.parse_commands(action_list, tracker, flows)
 
-        if not commands:
-            # no commands are parsed or there's an invalid command
-            commands = [CannotHandleCommand()]
-        else:
-            # if the LLM command generator predicted valid commands and the
-            # coexistence feature is used, set the routing slot
-            if tracker.has_coexistence_routing_slot:
-                commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True)]
+        self._update_message_parse_data_for_fine_tuning(message, commands, flow_prompt)
 
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.finished",
-            commands=commands,
-        )
         return commands
 
+    @staticmethod
+    def _update_message_parse_data_for_fine_tuning(
+        message: Message, commands: List[Command], prompt: str
+    ) -> None:
+        from rasa.llm_fine_tuning.annotation_module import preparing_fine_tuning_data
+
+        if preparing_fine_tuning_data:
+            # Add commands and prompt to the message object in order to create
+            # prompt -> commands pairs for fine-tuning
+            message.set(
+                LLM_COMMANDS,
+                [command.as_dict() for command in commands],
+                add_to_output=True,
+            )
+            message.set(LLM_PROMPT, prompt, add_to_output=True)
+
     @classmethod
     def parse_commands(
         cls, actions: Optional[str], tracker: DialogueStateTracker, flows: FlowsList
@@ -236,14 +299,16 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
 
         commands: List[Command] = []
 
-        slot_set_re = re.compile(r"""SetSlot\(([a-zA-Z_][a-zA-Z0-9_-]*?), ?(.*)\)""")
-        start_flow_re = re.compile(r"StartFlow\(([a-zA-Z0-9_-]+?)\)")
+        slot_set_re = re.compile(
+            r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
+        )
+        start_flow_re = re.compile(r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)")
         cancel_flow_re = re.compile(r"CancelFlow\(\)")
         chitchat_re = re.compile(r"ChitChat\(\)")
         skip_question_re = re.compile(r"SkipQuestion\(\)")
         knowledge_re = re.compile(r"SearchAndReply\(\)")
         humand_handoff_re = re.compile(r"HumanHandoff\(\)")
-        clarify_re = re.compile(r"Clarify\(([a-zA-Z0-9_, ]+)\)")
+        clarify_re = re.compile(r"Clarify\(([\"\'a-zA-Z0-9_, ]+)\)")
 
         for action in actions.strip().splitlines():
             if match := slot_set_re.search(action):
@@ -272,20 +337,41 @@ class SingleStepLLMCommandGenerator(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 if flow in flows.user_flow_ids
+                    flow for flow in cleaned_options if flow in flows.user_flow_ids
                 ]
                 if len(set(valid_options)) == 1:
                     commands.extend(cls.start_flow_by_name(valid_options[0], flows))
                 elif len(valid_options) > 1:
                     commands.append(ClarifyCommand(valid_options))
 
+        if not commands:
+            structlogger.debug(
+                "single_step_llm_command_generator.parse_commands",
+                message="No commands were parsed from the LLM actions.",
+                actions=actions,
+            )
+
         return commands
 
     @classmethod
     def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint of the knowledge base for the graph."""
-        config_prompt = config.get("prompt") or config.get("prompt_template") or None
+        config_prompt = (
+            config.get(PROMPT_CONFIG_KEY)
+            or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            or None
+        )
         prompt_template = get_prompt_template(
             config_prompt,
             DEFAULT_COMMAND_PROMPT_TEMPLATE,