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

rasa/core/policies/flows/mcp_tool_executor.py

@@ -1,277 +0,0 @@
-import json
-import operator
-from functools import reduce
-from typing import Any, Dict, List, Optional
-
-import structlog
-from mcp.types import CallToolResult
-
-from rasa.core.available_endpoints import AvailableEndpoints
-from rasa.core.policies.flows.flow_step_result import (
-    ContinueFlowWithNextStep,
-    FlowStepResult,
-)
-from rasa.dialogue_understanding.patterns.internal_error import (
-    InternalErrorPatternFlowStackFrame,
-)
-from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
-from rasa.shared.core.events import Event, SlotSet
-from rasa.shared.core.flows.steps import CallFlowStep
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.utils.mcp.server_connection import MCPServerConnection
-from rasa.utils.common import ensure_jsonified_iterable
-
-structlogger = structlog.get_logger()
-
-CONFIG_RESULT_KEY = "result_key"
-CONFIG_SLOT = "slot"
-
-
-async def call_mcp_tool(
-    initial_events: List[Event],
-    stack: DialogueStack,
-    step: CallFlowStep,
-    tracker: DialogueStateTracker,
-) -> FlowStepResult:
-    """Run an MCP tool call step."""
-    structlogger.debug(
-        "flow.step.call_mcp_tool",
-        tool_id=step.call,
-        mcp_server=step.mcp_server,
-        mapping=step.mapping,
-        step_id=step.id,
-        flow_id=step.flow_id,
-    )
-
-    try:
-        return await _execute_mcp_tool_call(initial_events, stack, step, tracker)
-    except Exception as e:
-        return _handle_mcp_tool_error(
-            stack,
-            initial_events,
-            error_message=f"Failed to execute MCP tool call: {e}.",
-            tool_name=step.call,
-            mcp_server=step.mcp_server,
-        )
-
-
-async def _execute_mcp_tool_call(
-    initial_events: List[Event],
-    stack: DialogueStack,
-    step: CallFlowStep,
-    tracker: DialogueStateTracker,
-) -> FlowStepResult:
-    """Execute the MCP tool call with proper error handling."""
-    mcp_server_connection = None
-    try:
-        # Connect to the MCP server
-        mcp_server_connection = await _connect_to_mcp_server(step.mcp_server)
-
-        if not mcp_server_connection:
-            return _handle_mcp_tool_error(
-                stack,
-                initial_events,
-                f"Cannot connect to MCP server '{step.mcp_server}'.",
-                tool_name=step.call,
-                mcp_server=step.mcp_server,
-            )
-
-        # Validate tool availability
-        if not await _is_tool_available(mcp_server_connection, step.call):
-            return _handle_mcp_tool_error(
-                stack,
-                initial_events,
-                f"Tool '{step.call}' is not available on MCP server "
-                f"'{step.mcp_server}'.",
-                tool_name=step.call,
-                mcp_server=step.mcp_server,
-            )
-
-        # This should not happen, but we need to check for type checking to pass
-        if not step.mapping:
-            return _handle_mcp_tool_error(
-                stack,
-                initial_events,
-                f"No mapping found for tool '{step.call}'.",
-                tool_name=step.call,
-                mcp_server=step.mcp_server,
-            )
-
-        # Prepare arguments for the tool call
-        arguments = _prepare_tool_arguments(step.mapping["input"], tracker)
-
-        # Call the tool with parameters
-        mcp_server = await mcp_server_connection.ensure_active_session()
-        result = await mcp_server.call_tool(step.call, arguments)
-
-        # Handle tool execution result
-        if result is None or result.isError:
-            return _handle_mcp_tool_error(
-                stack,
-                initial_events,
-                f"Tool '{step.call}' execution failed: {result.content}.",
-                tool_name=step.call,
-                mcp_server=step.mcp_server,
-            )
-        elif not result.content:
-            structlogger.warning(
-                "call_mcp_tool.empty_tool_result",
-                tool_name=step.call,
-                mcp_server=step.mcp_server,
-            )
-        else:
-            structlogger.debug(
-                "call_mcp_tool.tool_execution_success",
-                tool_name=step.call,
-                mcp_server=step.mcp_server,
-                result_content=result.content,
-                result_structured_content=result.structuredContent,
-            )
-
-            # Process successful result
-            if set_slot_event := _process_tool_result(result, step.mapping["output"]):
-                initial_events.extend(set_slot_event)
-            else:
-                return _handle_mcp_tool_error(
-                    stack,
-                    initial_events,
-                    f"Failed to process tool result for '{step.call}'.",
-                    tool_name=step.call,
-                    mcp_server=step.mcp_server,
-                )
-
-        return ContinueFlowWithNextStep(events=initial_events)
-
-    finally:
-        # Always clean up the connection to prevent resource leaks
-        if mcp_server_connection:
-            try:
-                await mcp_server_connection.close()
-            except Exception as e:
-                structlogger.warning(
-                    "call_mcp_tool.connection_cleanup_failed",
-                    tool_name=step.call,
-                    mcp_server=step.mcp_server,
-                    error=str(e),
-                )
-
-
-async def _is_tool_available(
-    mcp_server_connection: MCPServerConnection, tool_name: str
-) -> bool:
-    """Check if the specified tool is available on the MCP server."""
-    try:
-        # Get the active session from the connection
-        mcp_server = await mcp_server_connection.ensure_active_session()
-        available_tools = await mcp_server.list_tools()
-        tool_names = [tool.name for tool in available_tools.tools]
-        return tool_name in tool_names
-    except Exception as e:
-        structlogger.warning(
-            "call_mcp_tool.tool_availability_check_failed",
-            tool_name=tool_name,
-            error=str(e),
-        )
-        return False
-
-
-async def _connect_to_mcp_server(
-    mcp_server_name: Optional[str],
-) -> Optional[MCPServerConnection]:
-    """Connect to the MCP server."""
-    if not mcp_server_name:
-        return None
-
-    # get the MCP server config from the available endpoints
-    endpoints = AvailableEndpoints.get_instance()
-    mcp_servers = endpoints.mcp_servers
-    if not mcp_servers:
-        return None
-
-    mcp_server_configs = [
-        mcp_server for mcp_server in mcp_servers if mcp_server.name == mcp_server_name
-    ]
-    if not mcp_server_configs or len(mcp_server_configs) != 1:
-        return None
-
-    mcp_server_config = mcp_server_configs[0]
-    mcp_server_connection = MCPServerConnection(
-        mcp_server_config.name, mcp_server_config.url, mcp_server_config.type
-    )
-
-    # Ensure the connection is established and return the connection object
-    await mcp_server_connection.ensure_active_session()
-    return mcp_server_connection
-
-
-def _prepare_tool_arguments(
-    input_mapping: List[Dict[str, str]], tracker: DialogueStateTracker
-) -> Dict[str, Any]:
-    """Prepare arguments for the tool call from slot values."""
-    arguments = {}
-    for argument in input_mapping:
-        slot_value = tracker.get_slot(argument["slot"])
-        arguments[argument["param"]] = slot_value
-    return arguments
-
-
-def _jsonify_slot_value(value: Any) -> str | int | float | bool | None:
-    """Prepare value for SlotSet: iterables -> JSON string, primitives -> as-is"""
-    if isinstance(value, (list, dict)) and len(value):
-        return json.dumps(ensure_jsonified_iterable(value))
-    return value
-
-
-def _process_tool_result(
-    result: CallToolResult,
-    output_mapping: List[Dict[str, str]],
-) -> Optional[List[SlotSet]]:
-    """Create a SetSlot event for the tool result."""
-    try:
-        _result_as_dict = {"result": result.model_dump()}
-        slots = []
-        for mapping in output_mapping:
-            try:
-                # Use reduce to navigate through nested keys in the result
-                slot_value = reduce(
-                    operator.getitem,
-                    mapping[CONFIG_RESULT_KEY].split("."),
-                    _result_as_dict,
-                )
-                slots.append(
-                    SlotSet(mapping[CONFIG_SLOT], _jsonify_slot_value(slot_value))
-                )
-            except (KeyError, TypeError):
-                structlogger.error(
-                    "call_mcp_tool.result_key_not_found_in_tool_result",
-                    slot=mapping[CONFIG_SLOT],
-                    result_key=mapping[CONFIG_RESULT_KEY],
-                    result=_result_as_dict,
-                )
-                return None
-        return slots
-    except Exception as e:
-        structlogger.error(
-            "call_mcp_tool.result_processing_failed",
-            error=str(e),
-            result=result,
-        )
-        return None
-
-
-def _handle_mcp_tool_error(
-    stack: DialogueStack,
-    events: List[Event],
-    error_message: str,
-    tool_name: str,
-    mcp_server: Optional[str],
-) -> FlowStepResult:
-    """Handle MCP tool errors consistently."""
-    structlogger.error(
-        "call_mcp_tool.error",
-        error_message=error_message,
-        tool_name=tool_name,
-        mcp_server=mcp_server,
-    )
-    stack.push(InternalErrorPatternFlowStackFrame())
-    return ContinueFlowWithNextStep(events=events)

rasa/dialogue_understanding/commands/continue_agent_command.py

@@ -1,91 +0,0 @@
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-from typing import Any, Dict, List
-
-import structlog
-
-from rasa.dialogue_understanding.commands.command import Command
-from rasa.dialogue_understanding.commands.command_syntax_manager import (
-    CommandSyntaxManager,
-    CommandSyntaxVersion,
-)
-from rasa.shared.core.events import Event
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.trackers import DialogueStateTracker
-
-structlogger = structlog.get_logger()
-
-
-@dataclass
-class ContinueAgentCommand(Command):
-    """A command to continue the currently active agent's execution."""
-
-    @classmethod
-    def command(cls) -> str:
-        """Returns the command type."""
-        return "continue agent"
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> ContinueAgentCommand:
-        """Converts the dictionary to a command.
-
-        Returns:
-            The converted dictionary.
-        """
-        return ContinueAgentCommand()
-
-    def run_command_on_tracker(
-        self,
-        tracker: DialogueStateTracker,
-        all_flows: FlowsList,
-        original_tracker: DialogueStateTracker,
-    ) -> List[Event]:
-        """Runs the command on the tracker.
-
-        Args:
-            tracker: The tracker to run the command on.
-            all_flows: All flows in the assistant.
-            original_tracker: The tracker before any command was executed.
-
-        Returns:
-            The events to apply to the tracker.
-        """
-        # do nothing
-        return []
-
-    def __hash__(self) -> int:
-        return hash(self.command())
-
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, ContinueAgentCommand)
-
-    def to_dsl(self) -> str:
-        """Converts the command to a DSL string."""
-        mapper = {
-            CommandSyntaxVersion.v1: "ContinueAgent()",
-            CommandSyntaxVersion.v2: "continue agent",
-            CommandSyntaxVersion.v3: "continue agent",
-        }
-        return mapper.get(
-            CommandSyntaxManager.get_syntax_version(),
-            mapper[CommandSyntaxManager.get_default_syntax_version()],
-        )
-
-    @classmethod
-    def from_dsl(cls, match: re.Match, **kwargs: Any) -> ContinueAgentCommand:
-        """Converts a DSL string to a command."""
-        return ContinueAgentCommand()
-
-    @staticmethod
-    def regex_pattern() -> str:
-        mapper = {
-            CommandSyntaxVersion.v1: r"ContinueAgent\(\)",
-            CommandSyntaxVersion.v2: r"""^[\s\W\d]*continue agent['"`]*$""",
-            CommandSyntaxVersion.v3: r"""^[\s\W\d]*continue agent['"`]*$""",
-        }
-        return mapper.get(
-            CommandSyntaxManager.get_syntax_version(),
-            mapper[CommandSyntaxManager.get_default_syntax_version()],
-        )

rasa/dialogue_understanding/commands/restart_agent_command.py

@@ -1,162 +0,0 @@
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
-
-from rasa.dialogue_understanding.commands.command import Command
-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.flow_stack_frame import (
-    AgentStackFrame,
-    AgentState,
-)
-from rasa.shared.core.events import AgentStarted, Event
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.flows.steps import CallFlowStep
-from rasa.shared.core.trackers import DialogueStateTracker
-
-
-@dataclass
-class RestartAgentCommand(Command):
-    """A command to restart an agentic loop within a flow."""
-
-    agent_id: str
-
-    @classmethod
-    def command(cls) -> str:
-        """Returns the command type."""
-        return "restart agent"
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> RestartAgentCommand:
-        """Converts the dictionary to a command.
-
-        Returns:
-            The converted dictionary.
-        """
-        try:
-            return RestartAgentCommand(agent_id=data["agent_id"])
-        except KeyError as e:
-            raise ValueError(
-                f"Missing parameter '{e}' while parsing RestartAgentCommand."
-            ) from e
-
-    def run_command_on_tracker(
-        self,
-        tracker: DialogueStateTracker,
-        all_flows: FlowsList,
-        original_tracker: DialogueStateTracker,
-    ) -> List[Event]:
-        """Runs the command on the tracker.
-
-        Args:
-            tracker: The tracker to run the command on.
-            all_flows: All flows in the assistant.
-            original_tracker: The tracker before any command was executed.
-
-        Returns:
-            The events to apply to the tracker.
-        """
-        stack = tracker.stack
-
-        # get the agent flow
-        agent_flow_id = self._get_agent_flow(original_tracker)
-
-        # create a new agent stack frame to restart the agent
-        restart_agent_frame = self.create_restart_agent_stack_frame(
-            all_flows, agent_flow_id
-        )
-
-        # if the stack contains an agent stack frame with status
-        # "waiting for input" update the status to "interrupted"
-        self.update_agent_stack_frames_on_stack(stack)
-
-        # push the stack frame on the top of the stack
-        stack.push(restart_agent_frame)
-        return tracker.create_stack_updated_events(stack)
-
-    def __hash__(self) -> int:
-        return hash(self.command())
-
-    def __eq__(self, other: object) -> bool:
-        return isinstance(other, RestartAgentCommand)
-
-    def to_dsl(self) -> str:
-        """Converts the command to a DSL string."""
-        mapper = {
-            CommandSyntaxVersion.v1: f"RestartAgent({self.agent_id})",
-            CommandSyntaxVersion.v2: f"restart agent {self.agent_id}",
-            CommandSyntaxVersion.v3: f"restart agent {self.agent_id}",
-        }
-        return mapper.get(
-            CommandSyntaxManager.get_syntax_version(),
-            mapper[CommandSyntaxManager.get_default_syntax_version()],
-        )
-
-    @classmethod
-    def from_dsl(cls, match: re.Match, **kwargs: Any) -> RestartAgentCommand:
-        """Converts a DSL string to a command."""
-        return RestartAgentCommand(agent_id=str(match.group(1).strip()))
-
-    @staticmethod
-    def regex_pattern() -> str:
-        mapper = {
-            CommandSyntaxVersion.v1: r"RestartAgent\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)",
-            CommandSyntaxVersion.v2: (
-                r"""^[\s\W\d]*restart agent ['"`]?([a-zA-Z0-9_-]+)['"`]*"""
-            ),
-            CommandSyntaxVersion.v3: (
-                r"""^[\s\W\d]*restart agent ['"`]?([a-zA-Z0-9_-]+)['"`]*"""
-            ),
-        }
-        return mapper.get(
-            CommandSyntaxManager.get_syntax_version(),
-            mapper[CommandSyntaxManager.get_default_syntax_version()],
-        )
-
-    def create_restart_agent_stack_frame(
-        self, all_flows: FlowsList, agent_flow_id: str
-    ) -> AgentStackFrame:
-        # get the agent flow
-        agent_flow = all_flows.flow_by_id(agent_flow_id)
-        if not agent_flow:
-            raise ValueError(f"Agent flow {agent_flow_id} not found")
-
-        # find the call flow step for the agent
-        # set the state to "waiting for input" so that the agent can process
-        # the latest user message
-        for step in agent_flow.steps:
-            if isinstance(step, CallFlowStep) and step.call == self.agent_id:
-                return AgentStackFrame(
-                    frame_id=f"restart_agent_{self.agent_id}",
-                    flow_id=agent_flow_id,
-                    step_id=step.id,
-                    agent_id=self.agent_id,
-                    state=AgentState.WAITING_FOR_INPUT,
-                )
-
-        raise ValueError(f"Call step in agent flow {agent_flow_id} not found")
-
-    def update_agent_stack_frames_on_stack(self, stack: DialogueStack) -> None:
-        for frame in stack.frames:
-            if (
-                isinstance(frame, AgentStackFrame)
-                and frame.state == AgentState.WAITING_FOR_INPUT
-            ):
-                frame.state = AgentState.INTERRUPTED
-
-    def _get_agent_flow(self, tracker: DialogueStateTracker) -> Optional[str]:
-        # find events associated with the agent
-        agent_started_events = [
-            event
-            for event in tracker.events
-            if type(event) == AgentStarted and event.agent_id == self.agent_id
-        ]
-        # take the last one if the agent was started multiple times
-        if agent_started_events:
-            return agent_started_events[-1].flow_id
-        return None

rasa/dialogue_understanding/generator/prompt_templates/agent_command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2

@@ -1,61 +0,0 @@
-## 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/dialogue_understanding/generator/prompt_templates/agent_command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2

@@ -1,81 +0,0 @@
-## 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: