rasa-pro 3.14.0.dev5__py3-none-any.whl → 3.14.0.dev6__py3-none-any.whl

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import structlog
 
@@ -11,15 +11,29 @@ from rasa.dialogue_understanding.commands.command_syntax_manager import (
     CommandSyntaxManager,
     CommandSyntaxVersion,
 )
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.dialogue_understanding.stack.frames.dialogue_stack_frame import (
+    DialogueStackFrame,
+)
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
     FlowStackFrameType,
     UserFlowStackFrame,
 )
+from rasa.dialogue_understanding.stack.frames.pattern_frame import PatternFlowStackFrame
 from rasa.dialogue_understanding.stack.utils import (
+    is_continue_interrupted_flow_active,
     top_user_flow_frame,
     user_flows_on_the_stack,
 )
-from rasa.shared.core.events import Event, FlowInterrupted
+from rasa.shared.core.events import (
+    AgentInterrupted,
+    AgentResumed,
+    Event,
+    FlowInterrupted,
+    FlowResumed,
+)
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 
@@ -71,12 +85,7 @@ class StartFlowCommand(Command):
         original_stack = original_tracker.stack
         applied_events: List[Event] = []
 
-        if self.flow in user_flows_on_the_stack(stack):
-            structlogger.debug(
-                "start_flow_command.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(
                 "start_flow_command.skip_command.start_invalid_flow_id", command=self
             )
@@ -87,9 +96,36 @@ class StartFlowCommand(Command):
             original_user_frame.flow(all_flows) if original_user_frame else None
         )
 
+        # if the original top flow is the same as the flow to start, the flow is
+        # already active, do nothing
+        if original_top_flow is not None and original_top_flow.id == self.flow:
+            # in case continue_interrupted is not active, skip the already active start
+            # flow command
+            if not is_continue_interrupted_flow_active(stack):
+                return []
+
+            # if the continue interrupted flow is active, and the command generator
+            # predicted a start flow command for the flow which is on top of the stack,
+            # we just need to remove the pattern_continue_interrupted frame(s) from the
+            # stack
+            stack = _remove_pattern_continue_interrupted_frames(stack)
+            return applied_events + tracker.create_stack_updated_events(stack)
+
+        # if the flow is already on the stack, resume it
+        if (
+            self.flow in user_flows_on_the_stack(stack)
+            and original_user_frame is not None
+        ):
+            # if pattern_continue_interrupted is active, we need to remove it
+            # from the stack before resuming the flow
+            stack = _remove_pattern_continue_interrupted_frames(stack)
+            return self.resume_flow(tracker, stack, original_user_frame)
+
         frame_type = FlowStackFrameType.REGULAR
 
         if original_top_flow:
+            # if the original top flow is not the same as the flow to start,
+            # interrupt the current active flow
             frame_type = FlowStackFrameType.INTERRUPT
 
             if original_user_frame is not None:
@@ -99,6 +135,24 @@ class StartFlowCommand(Command):
                     )
                 )
 
+            # If there is an active agent frame, interrupt it
+            active_agent_stack_frame = stack.find_active_agent_frame()
+            if active_agent_stack_frame:
+                structlogger.debug(
+                    "start_flow_command.interrupt_agent",
+                    command=self,
+                    agent_id=active_agent_stack_frame.agent_id,
+                    frame_id=active_agent_stack_frame.frame_id,
+                    flow_id=active_agent_stack_frame.flow_id,
+                )
+                active_agent_stack_frame.state = AgentState.INTERRUPTED
+                applied_events.append(
+                    AgentInterrupted(
+                        active_agent_stack_frame.agent_id,
+                        active_agent_stack_frame.flow_id,
+                    )
+                )
+
         structlogger.debug("start_flow_command.start_flow", command=self)
         stack.push(UserFlowStackFrame(flow_id=self.flow, frame_type=frame_type))
         return applied_events + tracker.create_stack_updated_events(stack)
@@ -144,3 +198,105 @@ class StartFlowCommand(Command):
             CommandSyntaxManager.get_syntax_version(),
             mapper[CommandSyntaxManager.get_default_syntax_version()],
         )
+
+    def resume_flow(
+        self,
+        tracker: DialogueStateTracker,
+        stack: DialogueStack,
+        original_user_frame: UserFlowStackFrame,
+    ) -> List[Event]:
+        """Resumes a flow by reordering frames."""
+        applied_events: List[Event] = []
+
+        # Resume existing flow by reordering frames
+        frames_to_resume, user_frame_to_resume = self._collect_frames_to_resume(
+            stack, self.flow
+        )
+
+        # if the flow is not on the stack, do nothing
+        # this should not happen, but just in case
+        if user_frame_to_resume is None:
+            structlogger.error(
+                "start_flow_command.resume_flow.no_user_frame_to_resume",
+                command=self,
+            )
+            return []
+
+        # move the frames to the top of the stack, e.g. reorder the frames
+        # on the stack
+        stack.move_frames_to_top(frames_to_resume)
+        agent_stack_frame = next(
+            (frame for frame in frames_to_resume if isinstance(frame, AgentStackFrame)),
+            None,
+        )
+        if agent_stack_frame:
+            agent_id = agent_stack_frame.agent_id
+            applied_events.append(AgentResumed(agent_id, agent_stack_frame.flow_id))
+
+        # Create flow interruption and resumption events
+        applied_events.extend(
+            [
+                # the current active flow is interrupted
+                FlowInterrupted(
+                    original_user_frame.flow_id, original_user_frame.step_id
+                ),
+                # the flow, which was on the stack, is resumed
+                FlowResumed(user_frame_to_resume.flow_id, user_frame_to_resume.step_id),
+            ]
+        )
+
+        return applied_events + tracker.create_stack_updated_events(stack)
+
+    def _collect_frames_to_resume(
+        self, stack: DialogueStack, target_flow_id: str
+    ) -> Tuple[List[DialogueStackFrame], Optional[UserFlowStackFrame]]:
+        """Collect frames that need to be resumed for the target flow.
+
+        Args:
+            stack: The stack to collect frames from.
+            target_flow_id: The ID of the flow to resume.
+
+        Returns:
+            A tuple containing (frames_to_resume, frame_to_resume).
+        """
+        frames_to_resume: List[DialogueStackFrame] = []
+        frame_found = False
+        frame_to_resume = None
+
+        for frame in stack.frames:
+            if isinstance(frame, UserFlowStackFrame) and (
+                frame.frame_type == FlowStackFrameType.REGULAR
+                or frame.frame_type == FlowStackFrameType.INTERRUPT
+            ):
+                if frame.flow_id == target_flow_id:
+                    frames_to_resume.append(frame)
+                    frame_to_resume = frame
+                    frame_found = True
+                    continue
+                elif frame_found:
+                    break
+
+            if frame_found:
+                frames_to_resume.append(frame)
+
+        return list(frames_to_resume), frame_to_resume
+
+
+def _remove_pattern_continue_interrupted_frames(stack: DialogueStack) -> DialogueStack:
+    """Remove pattern_continue_interrupted frames from the stack."""
+    if not is_continue_interrupted_flow_active(stack):
+        return stack
+
+    # remove pattern_continue_interrupted from the stack
+    top_frame = stack.top()
+    while isinstance(top_frame, PatternFlowStackFrame):
+        # If the top frame is a pattern frame, we need to remove it
+        # before continuing with the active user flow frame.
+        # This prevents the pattern frame
+        # from being left on the stack when the flow is started
+        # which would prevent pattern_completed to be triggered
+        # once the user flow is completed.
+        stack.pop()
+        top_frame = stack.top()
+
+    return stack

rasa/dialogue_understanding/commands/utils.py

@@ -6,7 +6,10 @@ from rasa.dialogue_understanding.patterns.validate_slot import (
     ValidateSlotPatternFlowStackFrame,
 )
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
-from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.events import (
+    Event,
+    SlotSet,
+)
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -103,7 +106,8 @@ def create_validate_frames_from_slot_set_events(
     Args:
         tracker: The dialogue state tracker.
         events: List of events to process.
-        should_break:  whether or not to break after the first non-SlotSet event.
+        validate_frames: List to collect validation frames.
+        should_break:  whether to break after the first non-SlotSet event.
             if True, break out of the event loop as soon as the first non-SlotSet
             event is encountered.
             if False, continue processing the events until the end.

rasa/dialogue_understanding/generator/command_parser.py

@@ -9,9 +9,11 @@ from rasa.dialogue_understanding.commands import (
     ChitChatAnswerCommand,
     ClarifyCommand,
     Command,
+    ContinueAgentCommand,
     HumanHandoffCommand,
     KnowledgeAnswerCommand,
     RepeatBotMessagesCommand,
+    RestartAgentCommand,
     SetSlotCommand,
     SkipQuestionCommand,
     StartFlowCommand,
@@ -34,6 +36,8 @@ DEFAULT_COMMANDS = [
     HumanHandoffCommand,
     ClarifyCommand,
     RepeatBotMessagesCommand,
+    ContinueAgentCommand,
+    RestartAgentCommand,
 ]
 
 

rasa/dialogue_understanding/generator/flow_retrieval.py

@@ -219,6 +219,11 @@ class FlowRetrieval(EmbeddingsHealthCheckMixin):
         if self.vector_store is not None:
             with self._model_storage.write_to(self._resource) as model_path:
                 self.vector_store.save_local(model_path)
+        else:
+            structlogger.warning(
+                "flow_retrieval.persist_vector_store.not_initialized",
+                event_info="Vector store is None, not persisted.",
+            )
 
     def _persist_config(self) -> None:
         with self._model_storage.write_to(self._resource) as path:
@@ -244,16 +249,6 @@ class FlowRetrieval(EmbeddingsHealthCheckMixin):
         )
 
         flows_to_embedd = flows.exclude_link_only_flows()
-
-        if not flows_to_embedd:
-            structlogger.debug(
-                "flow_retrieval.populate_vector_store.no_flows_to_embed",
-                event_info=(
-                    "No flows to embed in the vector store, skipping population."
-                ),
-            )
-            return
-
         embeddings = self._create_embedder(self.config)
         documents = self._generate_flow_documents(flows_to_embedd, domain)
         try:
@@ -425,6 +420,10 @@ class FlowRetrieval(EmbeddingsHealthCheckMixin):
             The top k documents with similarity scores.
         """
         if self.vector_store is None:
+            structlogger.error(
+                "flow_retrieval.query_vector_store.vector_store_not_configured",
+                event_info="Vector store is not configured",
+            )
             return []
         try:
             documents_with_scores = (

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -7,6 +7,7 @@ from jinja2 import Environment, Template, select_autoescape
 
 import rasa.dialogue_understanding.generator.utils
 import rasa.shared.utils.io
+from rasa.core.available_agents import AvailableAgents
 from rasa.dialogue_understanding.commands import (
     Command,
     SetSlotCommand,
@@ -31,6 +32,7 @@ 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.events import AgentStarted
 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
@@ -225,8 +227,7 @@ class LLMBasedCommandGenerator(
 
     @lru_cache
     def compile_template(self, template: str) -> Template:
-        """
-        Compile the prompt template and register custom filters.
+        """Compile the prompt template and register custom filters.
 
         Compiling the template is an expensive operation,
         so we cache the result.
@@ -361,20 +362,24 @@ class LLMBasedCommandGenerator(
             )
 
     def prepare_flows_for_template(
-        self, flows: FlowsList, tracker: DialogueStateTracker
+        self,
+        flows: FlowsList,
+        tracker: DialogueStateTracker,
+        add_agent_info: bool = False,
     ) -> List[Dict[str, Any]]:
         """Format data on available flows for insertion into the prompt template.
 
         Args:
             flows: The flows available to the user.
             tracker: The tracker containing the current state of the conversation.
+            add_agent_info: Whether to add agent info to flows or not.
 
         Returns:
             The inputs for the prompt template.
         """
-        result = []
+        result: List[Dict[str, Any]] = []
         for flow in flows.user_flows:
-            slots_with_info = [
+            slots_with_info: List[Dict[str, Any]] = [
                 {
                     "name": q.collect,
                     "description": q.description,
@@ -383,13 +388,46 @@ class LLMBasedCommandGenerator(
                 for q in flow.get_collect_steps()
                 if self.is_extractable(q, tracker)
             ]
-            result.append(
-                {
-                    "name": flow.id,
-                    "description": flow.description,
-                    "slots": slots_with_info,
-                }
-            )
+
+            agent_info: List[Dict[str, Any]] = []
+            if add_agent_info:
+                # add information about agents that have been started for this flow
+                agent_events = [
+                    event
+                    for event in tracker.events
+                    if isinstance(event, AgentStarted) and event.flow_id == flow.id
+                ]
+                available_agents = [
+                    AvailableAgents.get_agent_config(event.agent_id)
+                    for event in agent_events
+                ]
+                if available_agents:
+                    agent_info = [
+                        {
+                            "name": available_agent.agent.name,
+                            "description": available_agent.agent.description,
+                        }
+                        for available_agent in available_agents
+                        if available_agent is not None
+                    ]
+
+            if agent_info:
+                result.append(
+                    {
+                        "name": flow.id,
+                        "description": flow.description,
+                        "slots": slots_with_info,
+                        "agent_info": agent_info,
+                    }
+                )
+            else:
+                result.append(
+                    {
+                        "name": flow.id,
+                        "description": flow.description,
+                        "slots": slots_with_info,
+                    }
+                )
         return result
 
     @staticmethod

rasa/dialogue_understanding/generator/llm_command_generator.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, List, Optional, Text, Union
 
 import structlog
-from deprecated import deprecated  # type: ignore[import]
+from deprecated import deprecated  # type: ignore[import-untyped]
 
 from rasa.dialogue_understanding.generator.single_step.single_step_llm_command_generator import (  # noqa: E501
     SingleStepLLMCommandGenerator,

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -2,7 +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 deprecated import deprecated  # type: ignore[import-untyped]
 from jinja2 import Template
 
 import rasa.shared.utils.io

rasa/dialogue_understanding/generator/prompt_templates/agent_command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2

@@ -0,0 +1,61 @@
+## 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.
+* `repeat message`: Repeating the last bot message.
+{% if active_agent %} * `continue agent`: Continue the currently active agent {{ active_agent.name }}.{% endif %}
+{% if completed_agents %}* `restart agent agent_name`: Restart the agent with the given name, in case the user wants to change some answer to a previous question asked by the agent. For example, `restart agent car_research_agent` if the user chnaged his mind about the car he wants to buy.{% endif %}
+
+--
+
+## General Tips
+* Do not fill slots with abstract values or placeholders.
+* For categorical slots try to match the user message with allowed slot values. Use "other" if you cannot match it.
+* Set the boolean slots based on the user response. Map positive responses to `True`, and negative to `False`.
+* Always refer to the slot description to determine what information should be extracted and how it should be formatted.
+* For text slots, extract values exactly as provided by the user unless the slot description specifies otherwise. Preserve formatting and avoid rewording, truncation, or making assumptions.
+* 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.
+* Do not cancel the flow unless the user explicitly requests it.
+* Strictly adhere to the provided action format.
+* 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
+Use the following structured data:
+```json
+{"flows":[{% for flow in available_flows %}{"name":"{{ flow.name }}","description":{{ flow.description | to_json_escaped_string }}{% if flow.agent_info %},"sub-agents":[{% for agent in flow.agent_info %}{"name":"{{ agent.name }}","description":{{ agent.description | to_json_escaped_string }}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}{% if flow.slots %},"slots":[{% for slot in flow.slots %}{"name":"{{ slot.name }}"{% if slot.description %},"description":{{ slot.description | to_json_escaped_string }}{% endif %}{% if slot.allowed_values %},"allowed_values":{{ slot.allowed_values }}{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]}
+```
+
+--
+
+## Current State
+{% if current_flow != None %}Use the following structured data:
+```json
+{"active_flow": "{{ current_flow }}","current_step": {"requested_slot": "{{ current_slot }}","requested_slot_description": {{ current_slot_description | to_json_escaped_string }}},"slots": [{% for slot in flow_slots %}{"name": "{{ slot.name }}","value": "{{ slot.value }}","type": "{{ slot.type }}"{{ "," if slot.description or slot.allowed_values else "" }}{% if slot.description %}"description": {{ slot.description | to_json_escaped_string }}{{ "," if slot.allowed_values else "" }}{% endif %}{% if slot.allowed_values %}"allowed_values": "{{ slot.allowed_values }}"{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% if active_agent or completed_agents %},{% endif %}{% if active_agent %}"active_agent": {"name": "{{ active_agent.name }}","description": "{{ active_agent.description }}"}{% if completed_agents %},{% endif %}{% endif %}{% if completed_agents %}"completed_agents": [{% for agent in completed_agents %}{"name": "{{ agent.name }}","description": "{{ agent.description }}"}{% if not loop.last %},{% 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 user's last message: """{{ user_message }}""".
+
+Your action list:

rasa/{cli/project_templates/telco/prompts/command-generator.jinja2 → dialogue_understanding/generator/prompt_templates/agent_command_prompt_v2_gpt_4o_2024_11_20_template.jinja2}

@@ -6,7 +6,7 @@ Your task is to analyze the current conversation context and generate a list of
 ## Available Flows and Slots
 Use the following structured data:
 ```json
-{"flows":[{% for flow in available_flows %}{"name":"{{ flow.name }}","description":"{{ flow.description }}"{% if flow.slots %},"slots":[{% for slot in flow.slots %}{"name":"{{ slot.name }}"{% if slot.description %},"description":"{{ slot.description }}"{% endif %}{% if slot.allowed_values %},"allowed_values":{{ slot.allowed_values }}{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]}
+{"flows":[{% for flow in available_flows %}{"name":"{{ flow.name }}","description":{{ flow.description | to_json_escaped_string }}{% if flow.agent_info %},"sub-agents":[{% for agent in flow.agent_info %}{"name":"{{ agent.name }}","description":{{ agent.description | to_json_escaped_string }}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}{% if flow.slots %},"slots":[{% for slot in flow.slots %}{"name":"{{ slot.name }}"{% if slot.description %},"description":{{ slot.description | to_json_escaped_string }}{% endif %}{% if slot.allowed_values %},"allowed_values":{{ slot.allowed_values }}{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]}
 ```
 
 ---
@@ -19,6 +19,9 @@ Use the following structured data:
 * `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.
+* `repeat message`: Repeating the last bot message.
+{% if active_agent %} * `continue agent`: Continue the currently active agent {{ active_agent.name }}.{% endif %}
+{% if completed_agents %}* `restart agent agent_name`: Restart the agent with the given name, in case the user wants to change some answer to a previous question asked by the agent. For example, `restart agent car_research_agent` if the user chnaged his mind about the car he wants to buy.{% endif %}
 
 ---
 
@@ -38,9 +41,10 @@ Use the following structured data:
 ---
 
 ## Current State
-{% if current_flow != None %}Use the following structured data:
+{% if current_flow != None %}
+Use the following structured data:
 ```json
-{"active_flow":"{{ current_flow }}","current_step":{"requested_slot":"{{ current_slot }}","requested_slot_description":"{{ current_slot_description }}"},"slots":[{% for slot in flow_slots %}{"name":"{{ slot.name }}","value":"{{ slot.value }}","type":"{{ slot.type }}"{% if slot.description %},"description":"{{ slot.description }}"{% endif %}{% if slot.allowed_values %},"allowed_values":"{{ slot.allowed_values }}"{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]}
+{"active_flow": "{{ current_flow }}","current_step": {"requested_slot": "{{ current_slot }}","requested_slot_description": {{ current_slot_description | to_json_escaped_string }}},"slots": [{% for slot in flow_slots %}{"name": "{{ slot.name }}","value": "{{ slot.value }}","type": "{{ slot.type }}"{{ "," if slot.description or slot.allowed_values else "" }}{% if slot.description %}"description": {{ slot.description | to_json_escaped_string }}{{ "," if slot.allowed_values else "" }}{% endif %}{% if slot.allowed_values %}"allowed_values": "{{ slot.allowed_values }}"{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% if active_agent or completed_agents %},{% endif %}{% if active_agent %}"active_agent": {"name": "{{ active_agent.name }}","description": "{{ active_agent.description }}"}{% if completed_agents %},{% endif %}{% endif %}{% if completed_agents %}"completed_agents": [{% for agent in completed_agents %}{"name": "{{ agent.name }}","description": "{{ agent.description }}"}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}
 ```{% else %}
 You are currently not inside any flow.{% endif %}
 

rasa/dialogue_understanding/generator/prompt_templates/agent_command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2

@@ -0,0 +1,81 @@
+## 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 off-topic and knowledge requests.
+
+---
+
+## Available Actions:
+* `start flow flow_name`: Start a flow. For example, `start flow transfer_money` or `start flow list_contacts`.
+* `set slot slot_name slot_value`: Set a slot for the active flow. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values.
+* `disambiguate flows flow_name1 flow_name2 ... flow_name_n`: When a message could refer to multiple flows, list the possible flows as options to clarify. Example: `disambiguate flows list_contacts add_contact remove_contact`.
+* `search and reply`: Provide a response from the knowledge base to address the user's inquiry when no flows fit, including domain knowledge, FAQs, and all off-topic or social messages.
+* `cancel flow`: Cancel the current flow if the user requests it.
+* `repeat message`: Repeat the last bot message.
+{% if active_agent %} * `continue agent`: Continue the currently active agent {{ active_agent.name }}.{% endif %}
+{% if completed_agents %}* `restart agent agent_name`: Restart the agent with the given name, in case the user wants to change some answer to a previous question asked by the agent. For example, `restart agent car_research_agent` if the user chnaged his mind about the car he wants to buy.{% endif %}
+
+---
+
+## General Instructions
+### Start Flow
+* Only start a flow if the user's message is clear and fully addressed by that flow's description and purpose.
+* Pay close attention to exact wording and scope in the flow description — do not assume or “stretch” the intended use of a flow.
+### Set Slot
+* Do not fill slots with abstract values or placeholders.
+* For categorical slots, try to match the user message with allowed slot values. Use "other" if you cannot match it.
+* Set the boolean slots based on the user's response. Map positive responses to `True`, and negative to `False`.
+* Extract text slot values exactly as provided by the user. Avoid assumptions, format changes, or partial extractions.
+### Disambiguate Flows
+* Use `disambiguate flows` when the user's message matches multiple flows and you cannot decide which flow is most appropriate.
+* If the user message is short and not precise enough to start a flow or `search and reply`, disambiguate.
+* If a single flow is a strong/plausible fit, prefer starting that flow directly.
+* If a user's message unambiguously and distinctly matches multiple flows, start all relevant flows at once (rather than disambiguating).
+### Search and Reply
+* Only start `search and reply` if the user intent is clear.
+* Flow Priority: If you are unsure between starting a flow or `search and reply`, always prioritize starting a flow.
+### Cancel Flow
+* Do not cancel any flow unless the user explicitly requests it.
+* Multiple flows can be started without cancelling the previous, if the user wants to pursue multiple processes.
+### General Tips
+* Only use information provided by the user.
+* Strictly adhere to the provided action format.
+* Focus on the last message and take it one step at a time.
+* Use the previous conversation steps only to aid understanding.
+
+---
+
+## Decision Rule Table
+| Condition                                             | Action             |
+|-------------------------------------------------------|--------------------|
+| Flow perfectly matches user's message                 | start flow         |
+| Multiple flows are equally strong, relevant matches   | disambiguate flows |
+| User's message is unclear or imprecise                | disambiguate flows |
+| No flow fits at all, but knowledge base may help      | search and reply   |
+
+---
+
+## Available Flows and Slots
+Use the following structured data:
+```json
+{"flows":[{% for flow in available_flows %}{"name":"{{ flow.name }}","description":{{ flow.description | to_json_escaped_string }}{% if flow.agent_info %},"sub-agents":[{% for agent in flow.agent_info %}{"name":"{{ agent.name }}","description":{{ agent.description | to_json_escaped_string }}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}{% if flow.slots %},"slots":[{% for slot in flow.slots %}{"name":"{{ slot.name }}"{% if slot.description %},"description":{{ slot.description | to_json_escaped_string }}{% endif %}{% if slot.allowed_values %},"allowed_values":{{ slot.allowed_values }}{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]}
+```
+
+---
+
+## Current State
+{% if current_flow != None %}Use the following structured data:
+```json
+{"active_flow": "{{ current_flow }}","current_step": {"requested_slot": "{{ current_slot }}","requested_slot_description": {{ current_slot_description | to_json_escaped_string }}},"slots": [{% for slot in flow_slots %}{"name": "{{ slot.name }}","value": "{{ slot.value }}","type": "{{ slot.type }}"{{ "," if slot.description or slot.allowed_values else "" }}{% if slot.description %}"description": {{ slot.description | to_json_escaped_string }}{{ "," if slot.allowed_values else "" }}{% endif %}{% if slot.allowed_values %}"allowed_values": "{{ slot.allowed_values }}"{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% if active_agent or completed_agents %},{% endif %}{% if active_agent %}"active_agent": {"name": "{{ active_agent.name }}","description": "{{ active_agent.description }}"}{% if completed_agents %},{% endif %}{% endif %}{% if completed_agents %}"completed_agents": [{% for agent in completed_agents %}{"name": "{{ agent.name }}","description": "{{ agent.description }}"}{% if not loop.last %},{% 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 user's last message: """{{ user_message }}""".
+
+Your action list: