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

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -1,14 +1,18 @@
 from abc import ABC, abstractmethod
 from functools import lru_cache
-from typing import Any, Dict, List, Optional, Text, Tuple, Union
+from typing import Any, Dict, List, Optional, Set, Text, Tuple, Union
 
 import structlog
 from jinja2 import Template
 
+import rasa.dialogue_understanding.generator.utils
 import rasa.shared.utils.io
 from rasa.dialogue_understanding.commands import (
     Command,
+    SetSlotCommand,
+    StartFlowCommand,
 )
+from rasa.dialogue_understanding.constants import KEY_MINIMIZE_NUM_CALLS
 from rasa.dialogue_understanding.generator import CommandGenerator
 from rasa.dialogue_understanding.generator.constants import (
     DEFAULT_LLM_CONFIG,
@@ -18,13 +22,16 @@ from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
+from rasa.dialogue_understanding.stack.utils import top_flow_frame
 from rasa.engine.graph import ExecutionContext, GraphComponent
 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.core.constants import SetSlotExtractor
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import Flow, FlowsList, FlowStep
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.slot_mappings import SlotFillingManager
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, ProviderClientAPIException
 from rasa.shared.nlu.constants import FLOWS_IN_PROMPT
@@ -304,11 +311,20 @@ class LLMBasedCommandGenerator(
         return filtered_flows
 
     @measure_llm_latency
-    async def invoke_llm(self, prompt: Text) -> Optional[LLMResponse]:
+    async def invoke_llm(
+        self, prompt: Union[List[dict], List[str], str]
+    ) -> Optional[LLMResponse]:
         """Use LLM to generate a response.
 
         Args:
-            prompt: The prompt to send to the LLM.
+            prompt: The prompt can be,
+                - a list of preformatted messages. Each message should be a dictionary
+                    with the following keys:
+                    - content: The message content.
+                    - role: The role of the message (e.g. user or system).
+                - a list of messages. Each message is a string and will be formatted
+                    as a user message.
+                - a single message as a string which will be formatted as user message.
 
         Returns:
             An LLMResponse object.
@@ -357,8 +373,7 @@ class LLMBasedCommandGenerator(
                     "slots": slots_with_info,
                 }
             )
-
-        return sorted(result, key=lambda x: x["name"])
+        return result
 
     @staticmethod
     def is_extractable(
@@ -454,3 +469,153 @@ class LLMBasedCommandGenerator(
             if isinstance(current_step, CollectInformationFlowStep)
             else (None, None)
         )
+
+    @staticmethod
+    def _prior_commands_contain_start_flow(prior_commands: List[Command]) -> bool:
+        return any(isinstance(command, StartFlowCommand) for command in prior_commands)
+
+    @staticmethod
+    def _prior_commands_contain_set_slot_for_active_collect_step(
+        prior_commands: List[Command],
+        flows: FlowsList,
+        tracker: DialogueStateTracker,
+    ) -> bool:
+        latest_user_frame = top_flow_frame(tracker.stack, ignore_call_frames=False)
+
+        if latest_user_frame is None:
+            return False
+
+        active_flow = latest_user_frame.flow(flows)
+        active_step = active_flow.step_by_id(latest_user_frame.step_id)
+
+        if not isinstance(active_step, CollectInformationFlowStep):
+            return False
+
+        return any(
+            command.name == active_step.collect
+            for command in prior_commands
+            if isinstance(command, SetSlotCommand)
+        )
+
+    def _should_skip_llm_call(
+        self,
+        prior_commands: List[Command],
+        flows: FlowsList,
+        tracker: DialogueStateTracker,
+    ) -> bool:
+        """Skip invoking the LLM.
+
+        This returns True if the bot builder sets the property
+        KEY_MINIMIZE_NUM_CALLS to True and the prior commands
+        either contain a StartFlowCommand or a SetSlot command
+        for the current collect step.
+        """
+        return self.config.get(KEY_MINIMIZE_NUM_CALLS, False) and (
+            self._prior_commands_contain_start_flow(prior_commands)
+            or self._prior_commands_contain_set_slot_for_active_collect_step(
+                prior_commands, flows, tracker
+            )
+        )
+
+    @staticmethod
+    def _check_commands_against_slot_mappings(
+        commands: List[Command],
+        tracker: DialogueStateTracker,
+        domain: Optional[Domain] = None,
+    ) -> List[Command]:
+        """Check if the LLM-issued slot commands are fillable.
+
+        The LLM-issued slot commands are fillable if the slot
+        mappings are satisfied (in particular the mapping conditions).
+        """
+        if not domain:
+            return commands
+
+        llm_fillable_slots = [
+            tracker.slots.get(command.name)
+            for command in commands
+            if isinstance(command, SetSlotCommand)
+            and command.extractor == SetSlotExtractor.LLM.value
+            and tracker.slots.get(command.name) is not None
+        ]
+
+        if not llm_fillable_slots:
+            return commands
+
+        slot_filling_manager = SlotFillingManager(domain, tracker)
+        slots_to_be_removed = []
+
+        structlogger.debug(
+            "command_processor.check_commands_against_slot_mappings.active_flow",
+            active_flow=tracker.active_flow,
+        )
+
+        for slot in llm_fillable_slots:
+            should_fill_slot = False
+            for mapping in slot.mappings:  # type: ignore[union-attr]
+                should_fill_slot = slot_filling_manager.should_fill_slot(
+                    slot.name,  # type: ignore[union-attr]
+                    mapping,
+                )
+
+                if should_fill_slot:
+                    break
+
+            if not should_fill_slot:
+                structlogger.debug(
+                    "command_processor.check_commands_against_slot_mappings.slot_not_fillable",
+                    slot_name=slot.name,  # type: ignore[union-attr]
+                )
+                slots_to_be_removed.append(slot.name)  # type: ignore[union-attr]
+
+        if not slots_to_be_removed:
+            return commands
+
+        filtered_commands = [
+            command
+            for command in commands
+            if not (
+                isinstance(command, SetSlotCommand)
+                and command.name in slots_to_be_removed
+            )
+        ]
+
+        return filtered_commands
+
+    def _check_start_flow_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        prior_start_flow_names: Set[str],
+        current_start_flow_names: Set[str],
+    ) -> List[Command]:
+        """Prioritize the prior commands over the LLM-issued commands."""
+        different_flow_names = current_start_flow_names.difference(
+            prior_start_flow_names
+        )
+
+        if not different_flow_names:
+            return prior_commands + commands
+
+        # discard the flow names that are different to prior start flow commands
+        filtered_commands = [
+            command
+            for command in commands
+            if not isinstance(command, StartFlowCommand)
+            or command.flow not in different_flow_names
+        ]
+        return prior_commands + filtered_commands
+
+    def _filter_slot_commands(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        overlapping_slot_names: Set[str],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Prioritize prior commands over LLM ones in the case of same slot."""
+        filtered_commands = (
+            rasa.dialogue_understanding.generator.utils.filter_slot_commands(
+                commands, overlapping_slot_names
+            )
+        )
+        return prior_commands, filtered_commands

rasa/dialogue_understanding/generator/llm_command_generator.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional, Text
+from typing import Any, Dict, List, Optional, Text, Union
 
 import structlog
 from deprecated import deprecated  # type: ignore[import]
@@ -25,7 +25,7 @@ structlogger = structlog.get_logger()
 @deprecated(
     reason=(
         "The LLMCommandGenerator is deprecated and will be removed in Rasa 4.0.0. "
-        "Please use use SingleStepLLMCommandGenerator instead."
+        "Please use SingleStepLLMCommandGenerator instead."
     )
 )
 class LLMCommandGenerator(SingleStepLLMCommandGenerator):
@@ -54,7 +54,9 @@ class LLMCommandGenerator(SingleStepLLMCommandGenerator):
             **kwargs,
         )
 
-    async def invoke_llm(self, prompt: Text) -> Optional[LLMResponse]:
+    async def invoke_llm(
+        self, prompt: Union[List[dict], List[str], str]
+    ) -> Optional[LLMResponse]:
         try:
             return await super().invoke_llm(prompt)
         except ProviderClientAPIException:

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -2,6 +2,7 @@ import importlib.resources
 from typing import Any, Dict, List, Optional, Text, Tuple, Union
 
 import structlog
+from deprecated import deprecated  # type: ignore[import]
 from jinja2 import Template
 
 import rasa.shared.utils.io
@@ -51,7 +52,7 @@ from rasa.shared.exceptions import ProviderClientAPIException
 from rasa.shared.nlu.constants import TEXT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
-from rasa.shared.utils.io import deep_container_fingerprint
+from rasa.shared.utils.io import deep_container_fingerprint, raise_deprecation_warning
 from rasa.shared.utils.llm import (
     allowed_values_for_slot,
     get_prompt_template,
@@ -100,6 +101,12 @@ structlogger = structlog.get_logger()
     ],
     is_trainable=True,
 )
+@deprecated(
+    reason=(
+        "The MultiStepLLMCommandGenerator is deprecated and will be removed in "
+        "Rasa `4.0.0`."
+    )
+)
 class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
     """An multi step command generator using LLM."""
 
@@ -111,6 +118,14 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         prompt_templates: Optional[Dict[Text, Optional[Text]]] = None,
         **kwargs: Any,
     ) -> None:
+        raise_deprecation_warning(
+            message=(
+                "Support for `MultiStepLLMCommandGenerator` will be removed in Rasa "
+                "`4.0.0`. Please modify your assistant's configuration to use other "
+                "LLM command generators like the `SingleStepLLMCommandGenerator`."
+            )
+        )
+
         super().__init__(
             config, model_storage, resource, prompt_templates=prompt_templates, **kwargs
         )
@@ -120,7 +135,6 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             FILL_SLOTS_KEY: None,
         }
         self._init_prompt_templates(prompt_templates)
-
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
 
     ### Implementations of LLMBasedCommandGenerator parent
@@ -190,9 +204,14 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         Returns:
             The commands generated by the llm.
         """
+        prior_commands = self._get_prior_commands(message)
+
         if tracker is None or flows.is_empty():
             # cannot do anything if there are no flows or no tracker
-            return []
+            return prior_commands
+
+        if self._should_skip_llm_call(prior_commands, flows, tracker):
+            return prior_commands
 
         try:
             commands = await self._predict_commands_with_multi_step(
@@ -221,7 +240,10 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             commands=commands,
         )
 
-        return commands
+        domain = kwargs.get("domain")
+        commands = self._check_commands_against_slot_mappings(commands, tracker, domain)
+
+        return self._check_commands_overlap(prior_commands, commands)
 
     @classmethod
     def parse_commands(

rasa/dialogue_understanding/generator/nlu_command_adapter.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict, List, Optional, Set, Text, Tuple
 
 import structlog
 
+import rasa.dialogue_understanding.generator.utils
 from rasa.dialogue_understanding.commands import (
     Command,
     SetSlotCommand,
@@ -98,9 +99,11 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
         Returns:
             The commands triggered by NLU.
         """
+        prior_commands = self._get_prior_commands(message)
+
         if tracker is None or flows.is_empty():
             # cannot do anything if there are no flows or no tracker
-            return []
+            return prior_commands
 
         domain = kwargs.get("domain", None)
         commands = self.convert_nlu_to_commands(message, tracker, flows, domain)
@@ -146,7 +149,7 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
                 commands=commands,
             )
 
-        return commands
+        return self._check_commands_overlap(prior_commands, commands)
 
     @staticmethod
     def convert_nlu_to_commands(
@@ -208,6 +211,44 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
         )
         return commands
 
+    def _check_start_flow_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        prior_start_flow_names: Set[str],
+        current_start_flow_names: Set[str],
+    ) -> List[Command]:
+        """Prioritize the current NLU commands over the prior commands."""
+        different_flow_names = prior_start_flow_names.difference(
+            current_start_flow_names
+        )
+
+        if not different_flow_names:
+            return prior_commands + commands
+
+        filtered_commands = [
+            command
+            for command in prior_commands
+            if not isinstance(command, StartFlowCommand)
+            or command.flow not in different_flow_names
+        ]
+
+        return filtered_commands + commands
+
+    def _filter_slot_commands(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        overlapping_slot_names: Set[str],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Prioritize NLU commands over prior_commands in the case of same slot."""
+        filtered_prior_commands = (
+            rasa.dialogue_understanding.generator.utils.filter_slot_commands(
+                prior_commands, overlapping_slot_names
+            )
+        )
+        return filtered_prior_commands, commands
+
 
 def _issue_set_slot_commands(
     message: Message,

rasa/dialogue_understanding/generator/prompt_templates/command_prompt_template.jinja2

@@ -0,0 +1,60 @@
+Your task is to analyze the current conversation context and generate a list of actions to start new business processes that we call flows, to extract slots, or respond to small talk and knowledge requests.
+
+These are the flows that can be started, with their description and slots:
+{% for flow in available_flows %}
+{{ flow.name }}: {{ flow.description }}
+    {% for slot in flow.slots -%}
+    slot: {{ slot.name }}{% if slot.description %} ({{ slot.description }}){% endif %}{% if slot.allowed_values %}, allowed values: {{ slot.allowed_values }}{% endif %}
+    {% endfor %}
+{%- endfor %}
+
+===
+Here is what happened previously in the conversation:
+{{ current_conversation }}
+
+===
+{% if current_flow != None %}
+You are currently in the flow "{{ current_flow }}".
+You have just asked the user for the slot "{{ current_slot }}"{% if current_slot_description %} ({{ current_slot_description }}){% endif %}.
+
+{% if flow_slots|length > 0 %}
+Here are the slots of the currently active flow:
+{% for slot in flow_slots -%}
+- name: {{ slot.name }}, value: {{ slot.value }}, type: {{ slot.type }}, description: {{ slot.description}}{% if slot.allowed_values %}, allowed values: {{ slot.allowed_values }}{% endif %}
+{% endfor %}
+{% endif %}
+{% else %}
+You are currently not in any flow and so there are no active slots.
+This means you can only set a slot if you first start a flow that requires that slot.
+{% endif %}
+If you start a flow, first start the flow and then optionally fill that flow's slots with information the user provided in their message.
+
+The user just said """{{ user_message }}""".
+
+===
+Based on this information generate a list of actions you want to take. Your job is to start flows and to fill slots where appropriate. Any logic of what happens afterwards is handled by the flow engine. These are your available actions:
+* Slot setting, described by "SetSlot(slot_name, slot_value)". An example would be "SetSlot(recipient, Freddy)"
+* Starting another flow, described by "StartFlow(flow_name)". An example would be "StartFlow(transfer_money)"
+* Cancelling the current flow, described by "CancelFlow()"
+* Clarifying which flow should be started. An example would be Clarify(list_contacts, add_contact, remove_contact) if the user just wrote "contacts" and there are multiple potential candidates. It also works with a single flow name to confirm you understood correctly, as in Clarify(transfer_money).
+* Intercepting and handle user messages with the intent to bypass the current step in the flow, described by "SkipQuestion()". Examples of user skip phrases are: "Go to the next question", "Ask me something else".
+* Responding to knowledge-oriented user messages, described by "SearchAndReply()"
+* Responding to a casual, non-task-oriented user message, described by "ChitChat()".
+* Handing off to a human, in case the user seems frustrated or explicitly asks to speak to one, described by "HumanHandoff()".
+{% if is_repeat_command_enabled %}
+* Repeat the last bot messages, described by "RepeatLastBotMessages()". This is useful when the user asks to repeat the last bot messages.
+{% endif %}
+
+===
+Write out the actions you want to take, one per line, in the order they should take place.
+Do not fill slots with abstract values or placeholders.
+Only use information provided by the user.
+Only start a flow if it's completely clear what the user wants. Imagine you were a person reading this message. If it's not 100% clear, clarify the next step.
+Don't be overly confident. Take a conservative approach and clarify before proceeding.
+If the user asks for two things which seem contradictory, clarify before starting a flow.
+If it's not clear whether the user wants to skip the step or to cancel the flow, cancel the flow.
+Strictly adhere to the provided action types listed above.
+Focus on the last message and take it one step at a time.
+Use the previous conversation steps only to aid understanding.
+
+Your action list:

rasa/dialogue_understanding/generator/prompt_templates/command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2

@@ -0,0 +1,77 @@
+Your task is to analyze the current conversation context and generate a list of actions to start new business processes that we call flows, to extract slots, or respond to small talk and knowledge requests.
+
+## Available Actions:
+* `start flow flow_name`: Starting a flow. For example, `start flow transfer_money` or `start flow list_contacts`
+* `set slot slot_name slot_value`: Slot setting. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values
+* `cancel flow`: Cancelling the current flow
+* `disambiguate flows flow_name1 flow_name2 ... flow_name_n`: Disambiguate which flow should be started when user input is ambiguous by listing the potential flows as options. For example, `disambiguate flows list_contacts add_contact remove_contact ...` if the user just wrote "contacts".
+* `provide info`: Responding to the user's questions by supplying relevant information, such as answering FAQs or explaining services
+* `offtopic reply`: Responding to casual or social user messages that are unrelated to any flows, engaging in friendly conversation and addressing off-topic remarks.
+* `hand over`: Handing over to a human, in case the user seems frustrated or explicitly asks to speak to one
+
+
+## General Tips
+* Do not fill slots with abstract values or placeholders.
+* Only use information provided by the user.
+* Use clarification in ambiguous cases.
+* Multiple flows can be started. If a user wants to digress into a second flow, you do not need to cancel the current flow.
+* Strictly adhere to the provided action format.
+* For categorical slots try to match the user message with potential slot values. Use "other" if you cannot match it
+* Focus on the last message and take it one step at a time.
+* Use the previous conversation steps only to aid understanding.
+
+
+## Available Flows:
+Use the following structured date:
+```xml
+<flows>
+    {% for flow in available_flows %}<flow>
+        <name>{{ flow.name }}</name>
+        <description>{{ flow.description }}</description>
+        <slots>{% for slot in flow.slots %}
+            <slot>
+                <name>{{ slot.name }}</name>
+                <description>{{ slot.description }}</description>
+                <allowed_values>{{ slot.allowed_values }}</allowed_values>
+            </slot>{% endfor %}
+        </slots>
+    </flow>
+    {% endfor %}
+</flows>
+```
+
+## Current State
+{% if current_flow != None %}
+Use the following structured date:
+```xml
+<current_state>
+    <active_flow>{{ current_flow }}</active_flow>
+    <current_step>
+        <requested_slot>{{ current_slot }}</requested_slot>
+        <requested_slot_description>{{ current_slot_description }}</requested_slot_description>
+    </current_step>
+    <slots>
+        {% for slot in flow_slots %}<slot>
+            <name>{{ slot.name }}</name>
+            <value>{{ slot.value }}</value>
+            <type>{{ slot.type }}</type>
+            <description>{{ slot.description }}</description>{% if slot.allowed_values %}
+            <allowed_values>{{ slot.allowed_values }}</allowed_values>{% endif %}
+        </slot>
+        {% endfor %}
+    </slots>
+</current_state>
+```
+{% else %}
+You are currently not inside any flow.
+{% endif %}
+
+
+## Conversation History
+{{ current_conversation }}
+
+
+## Task
+Create an action list with one action per line in response to the users last message: """{{ user_message }}""".
+
+Your action list:

rasa/dialogue_understanding/generator/prompt_templates/command_prompt_v2_default.jinja2

@@ -0,0 +1,68 @@
+## Task Description
+Your task is to analyze the current conversation context and generate a list of actions to start new business processes that we call flows, to extract slots, or respond to small talk and knowledge requests.
+
+--
+
+## Available Actions:
+* `start flow flow_name`: Starting a flow. For example, `start flow transfer_money` or `start flow list_contacts`
+* `set slot slot_name slot_value`: Slot setting. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values
+* `cancel flow`: Cancelling the current flow
+* `disambiguate flows flow_name1 flow_name2 ... flow_name_n`: Disambiguate which flow should be started when user input is ambiguous by listing the potential flows as options. For example, `disambiguate flows list_contacts add_contact remove_contact ...` if the user just wrote "contacts".
+* `provide info`: Responding to the user's questions by supplying relevant information, such as answering FAQs or explaining services
+* `offtopic reply`: Responding to casual or social user messages that are unrelated to any flows, engaging in friendly conversation and addressing off-topic remarks.
+* `hand over`: Handing over to a human, in case the user seems frustrated or explicitly asks to speak to one
+
+--
+
+## General Tips
+* Do not fill slots with abstract values or placeholders.
+* Only use information provided by the user.
+* Use clarification in ambiguous cases.
+* Multiple flows can be started. If a user wants to digress into a second flow, you do not need to cancel the current flow.
+* Strictly adhere to the provided action format.
+* For categorical slots try to match the user message with potential slot values. Use "other" if you cannot match it
+* Focus on the last message and take it one step at a time.
+* Use the previous conversation steps only to aid understanding.
+
+--
+
+## Available Flows and Slots
+{% for flow in available_flows %}
+* `{{ flow.name }}`: {{ flow.description }}
+    {% for slot in flow.slots -%}
+    * `{{ slot.name }}`{% if slot.description %} ({{ slot.description }}){% endif %}{% if slot.allowed_values %}, allowed values: `{{ slot.allowed_values }}`{% endif %}
+    {% endfor %}
+{%- endfor %}
+
+--
+
+## Current State
+{% if current_flow != None %}
+You are currently in the flow `{{ current_flow }}`.
+You have just asked the user for the slot `{{ current_slot }}`{% if current_slot_description %} ({{ current_slot_description }}){% endif %}.
+
+{% if flow_slots|length > 0 %}
+Here are the slots of the flow `{{ current_flow }}`:
+{% for slot in flow_slots -%}
+* `{{ slot.name }}`
+   - value: "{{ slot.value }}"
+   - type: {{ slot.type }}
+   - description: {{ slot.description}}
+{% if slot.allowed_values %}   - allowed values: {{ slot.allowed_values }}{% endif %}
+{% endfor %}
+{% endif %}
+{% else %}
+You are currently not inside any flow.
+{% endif %}
+
+---
+
+## Conversation History
+{{ current_conversation }}
+
+---
+
+## Task
+Create an action list with one action per line in response to the users last message: """{{ user_message }}""".
+
+Your action list:

rasa/dialogue_understanding/generator/{single_step/command_prompt_template.jinja2 → prompt_templates/command_prompt_v2_gpt_4o_2024_11_20_template.jinja2}

@@ -7,7 +7,7 @@ Your task is to analyze the current conversation context and generate a list of
 * `start flow flow_name`: Starting a flow. For example, `start flow transfer_money` or `start flow list_contacts`
 * `set slot slot_name slot_value`: Slot setting. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values
 * `cancel flow`: Cancelling the current flow
-* `disambiguate flows flow_name1 flow_name2 ... flow_name_n`: Disambiguate which flow should be started when user input is ambiguous by listing the potential flows as options. For example, `clarify flows list_contacts add_contact remove_contact ...` if the user just wrote "contacts".
+* `disambiguate flows flow_name1 flow_name2 ... flow_name_n`: Disambiguate which flow should be started when user input is ambiguous by listing the potential flows as options. For example, `disambiguate flows list_contacts add_contact remove_contact ...` if the user just wrote "contacts".
 * `provide info`: Responding to the user's questions by supplying relevant information, such as answering FAQs or explaining services
 * `offtopic reply`: Responding to casual or social user messages that are unrelated to any flows, engaging in friendly conversation and addressing off-topic remarks.
 * `hand over`: Handing over to a human, in case the user seems frustrated or explicitly asks to speak to one