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

rasa/dialogue_understanding/generator/prompt_templates/agent_command_prompt_v3_gpt_4o_2024_11_20_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 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 %}]}
-```
-
----
-
-## 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 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   |
-
----
-
-## 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/shared/agents/utils.py

@@ -1,35 +0,0 @@
-from typing import Optional
-
-from rasa.agents.core.types import AgentIdentifier, ProtocolType
-from rasa.core.available_agents import AgentConfig, ProtocolConfig
-from rasa.shared.core.flows.steps import CallFlowStep
-
-
-def make_agent_identifier(
-    agent_name: str, protocol_type: ProtocolType
-) -> AgentIdentifier:
-    """Make an agent identifier."""
-    return AgentIdentifier(agent_name, protocol_type)
-
-
-def get_protocol_type(
-    step: CallFlowStep, agent_config: Optional[AgentConfig]
-) -> ProtocolType:
-    """Get the protocol type for an agent.
-
-    Args:
-        step: The step that is calling the agent.
-        agent_config: The agent configuration.
-
-    Returns:
-        The protocol type for the agent.
-    """
-    if step.exit_if:
-        protocol_type = ProtocolType.MCP_TASK
-    else:
-        protocol_type = (
-            ProtocolType.A2A
-            if agent_config and agent_config.agent.protocol == ProtocolConfig.A2A
-            else ProtocolType.MCP_OPEN
-        )
-    return protocol_type

rasa/shared/utils/mcp/server_connection.py

@@ -1,157 +0,0 @@
-"""MCP server connection utilities."""
-
-import asyncio
-from contextlib import AsyncExitStack
-from typing import Any, Dict, Optional
-
-import structlog
-from mcp import ClientSession
-from mcp.client.streamable_http import streamablehttp_client
-
-structlogger = structlog.get_logger()
-
-
-class MCPServerConnection:
-    """
-    Manages connection to an MCP server.
-
-    This class handles the lifecycle of connections to MCP servers,
-    including connection establishment, session management, and cleanup.
-    """
-
-    def __init__(self, server_name: str, server_url: str, server_type: str):
-        """
-        Initialize the MCP server connection.
-
-        Args:
-            server_name: Server name to identify the server
-            server_url: Server URL
-            server_type: Server type (currently only 'http' is supported)
-        """
-        self.server_name = server_name
-        self.server_url = server_url
-        self.server_type = server_type
-        self.session: Optional[ClientSession] = None
-        self.exit_stack: Optional[AsyncExitStack] = None
-
-    @classmethod
-    def from_config(cls, server_config: Dict[str, Any]) -> "MCPServerConnection":
-        """Initialize the MCP server connection from a configuration dictionary."""
-        return cls(
-            server_config["name"],
-            server_config["url"],
-            server_config.get("type", "http"),
-        )
-
-    async def connect(self) -> None:
-        """Establish connection to the MCP server.
-
-        Raises:
-            ValueError: If the server type is not supported.
-            ConnectionError: If connection fails.
-        """
-        if self.server_type != "http":
-            raise ValueError(f"Unsupported server type: {self.server_type}")
-
-        # Create a new exit stack for this connection to avoid task boundary issues
-        self.exit_stack = AsyncExitStack()
-
-        try:
-            read_stream, write_stream, _ = await self.exit_stack.enter_async_context(
-                streamablehttp_client(self.server_url)
-            )
-            self.session = await self.exit_stack.enter_async_context(
-                ClientSession(read_stream, write_stream)
-            )
-            await self.session.initialize()
-        except asyncio.CancelledError as e:
-            event_info = f"Connection to MCP server {self.server_name} was cancelled."
-            structlogger.error(
-                "mcp_server_connection.connect.connection_cancelled",
-                event_info=event_info,
-                server_name=self.server_name,
-                server_url=self.server_url,
-            )
-            # Clean up on cancellation
-            await self._cleanup()
-            raise ConnectionError(e)
-
-        except Exception as e:
-            event_info = f"Failed to connect to MCP server {self.server_name}: {e}"
-            structlogger.error(
-                "mcp_server_connection.connect.connection_failed",
-                event_info=event_info,
-                server_name=self.server_name,
-                server_url=self.server_url,
-            )
-            # Clean up on error
-            await self._cleanup()
-            raise ConnectionError(e)
-
-    async def ensure_active_session(self) -> ClientSession:
-        """
-        Ensure an active session is available.
-
-        If no session exists or the current session is inactive,
-        a new connection will be established.
-
-        Returns:
-            Active ClientSession instance.
-        """
-        if self.session is None:
-            await self.connect()
-            structlogger.info(
-                "mcp_server_connection.ensure_active_session.no_session",
-                server_name=self.server_name,
-                server_url=self.server_url,
-                event_info=(
-                    "No session found, connecting to the server "
-                    f"`{self.server_name}` @ `{self.server_url}`"
-                ),
-            )
-        if self.session:
-            try:
-                await self.session.send_ping()
-            except Exception as e:
-                structlogger.error(
-                    "mcp_server_connection.ensure_active_session.ping_failed",
-                    error=str(e),
-                    server_name=self.server_name,
-                    server_url=self.server_url,
-                    event_info=(
-                        "Ping failed, trying to reconnect to the server "
-                        f"`{self.server_name}` @ `{self.server_url}`"
-                    ),
-                )
-                await self.connect()
-                structlogger.info(
-                    "mcp_server_connection.ensure_active_session.reconnected",
-                    server_name=self.server_name,
-                    server_url=self.server_url,
-                    event_info=(
-                        "Reconnected to the server "
-                        f"`{self.server_name}` @ `{self.server_url}`"
-                    ),
-                )
-        assert self.session is not None  # Ensures type for mypy
-        return self.session
-
-    async def close(self) -> None:
-        """Close the connection and clean up resources."""
-        await self._cleanup()
-
-    async def _cleanup(self) -> None:
-        """Internal cleanup method to safely close resources."""
-        if self.exit_stack:
-            try:
-                await self.exit_stack.aclose()
-            except Exception as e:
-                # Log cleanup errors but don't raise them
-                structlogger.warning(
-                    "mcp_server_connection.cleanup.failed",
-                    server_name=self.server_name,
-                    error=str(e),
-                )
-            finally:
-                self.exit_stack = None
-                self.session = None