rasa-pro 3.14.0rc2__py3-none-any.whl → 3.14.0rc4__py3-none-any.whl

rasa/cli/project_templates/basic/tests/e2e_test_cases/without_stub/general/patterns.yml

@@ -0,0 +1,32 @@
+test_cases:
+- test_case: test pattern session start
+  steps:
+    - user: "/session_start"
+      assertions:
+        - flow_started: "pattern_session_start"
+        - bot_uttered:
+            utter_name: "utter_welcome"
+#
+- test_case: test basic conversation flow
+  steps:
+    - user: "hello"
+      assertions:
+        - flow_started: "hello"
+        - bot_uttered:
+            utter_name: "utter_hello"
+    - user: "what can you help me with?"
+      assertions:
+        - flow_started: "help"
+        - bot_uttered:
+            utter_name: "utter_what_can_you_do"
+    - user: "show me faqs"
+      assertions:
+        - flow_started: "show_faqs"
+        - bot_uttered:
+            utter_name: "utter_top_faqs"
+    - user: "goodbye"
+      assertions:
+        - flow_started: "goodbye_flow"
+        - bot_uttered:
+            utter_name: "utter_goodbye"
+        - flow_started: "leave_feedback"

rasa/cli/project_templates/basic/tests/e2e_test_cases/without_stub/general/show_faqs.yml

@@ -0,0 +1,8 @@
+test_cases:
+  - test_case: show faqs
+    steps:
+    - user: "show me the faqs"
+      assertions:
+        - flow_started: "show_faqs"
+        - bot_uttered:
+            utter_name: "utter_top_faqs"

rasa/cli/project_templates/telco/data/network/flow_solve_internet_issue.yml

@@ -69,5 +69,5 @@ flows:
               #when it is False this means this flow will only be run if it is called by another flow, not the user.
     description: run diagnostics to check the internet speed for the user
     steps:
-      - action: utter_communicate_run_diagnosticss
-      - action: actions_run_speed_test
+      - action: utter_communicate_run_diagnostics
+      - action: actions_run_speed_test

rasa/cli/project_templates/telco/domain/network/solve_internet_issue.yml

@@ -14,7 +14,7 @@ responses:
     - text: |
         I see.
         Let me try to identify the root cause of the issue you are facing.
-  utter_communicate_run_diagnosticss:
+  utter_communicate_run_diagnostics:
     - text: |
         I will run a network diagnostics for you 🛜
         Wait a moment please...
@@ -72,4 +72,3 @@ responses:
 actions:
   - actions_run_speed_test
   - action_sleep_few_sec
-

rasa/cli/project_templates/telco/tests/e2e_test_cases/with_stub/network/solve_internet_not_slow.yml

@@ -0,0 +1,33 @@
+stub_custom_actions:
+  actions_run_speed_test:
+    events:
+      - event: slot
+        name: network_speed
+        value: 150.0
+    responses:
+      - text: "Thank you for waiting... ✅ "
+  action_sleep_few_sec:
+    events: []
+    responses: []
+
+test_cases:
+  - test_case: Solving Internet issue not slow
+    steps:
+      - user: "Hey, my internet is very slow. What's going on?"
+        assertions:
+          - flow_started: "fix_internet_slow"
+          - bot_uttered:
+              utter_name: "utter_acknowledge_issue"
+          - action_executed: action_sleep_few_sec
+          - flow_started: "run_diagnostics"
+          - bot_uttered:
+              utter_name: "utter_speed_network_not_issue"
+          - action_executed: "actions_run_speed_test"
+          - bot_uttered:
+              utter_name: "utter_propose_other_solutions"
+          - action_executed: "action_sleep_few_sec"
+          - bot_uttered:
+              utter_name: "utter_ask_more_help_needed"
+      - user: "/SetSlots(more_help_needed=True)"
+        assertions:
+          - flow_started: "human_handoff"

rasa/cli/project_templates/telco/tests/e2e_test_cases/with_stub/network/solve_internet_slow.yml

@@ -0,0 +1,47 @@
+stub_custom_actions:
+  actions_run_speed_test:
+    events:
+      - event: slot
+        name: network_speed
+        value: 50.0
+    responses:
+      - text: "Thank you for waiting... ✅ "
+  action_sleep_few_sec:
+    events: []
+    responses: []
+
+test_cases:
+  - test_case: Solving Internet slow issue
+    steps:
+      - user: "Hey, my internet is very slow. What's going on?"
+        assertions:
+          - flow_started: "fix_internet_slow"
+          - bot_uttered:
+              utter_name: "utter_acknowledge_issue"
+          - action_executed: action_sleep_few_sec
+          - flow_started: "run_diagnostics"
+          - bot_uttered:
+              utter_name: "utter_communicate_run_diagnostics"
+          - action_executed: "actions_run_speed_test"
+          - bot_uttered:
+              utter_name: "utter_acknowledge_speed_test_not_good"
+          - action_executed: "action_sleep_few_sec"
+          - bot_uttered:
+              utter_name: "utter_propose_reboot_router_solution"
+          - action_executed: "action_sleep_few_sec"
+          - flow_started: "reboot_router"
+          - bot_uttered:
+              utter_name: "utter_explain_reboot_router"
+          - bot_uttered:
+              utter_name: "utter_ask_reboot_router"
+              buttons:
+                - title: "Done"
+                  payload: "/SetSlots(reboot_router=True)"
+                - title: "Facing a problem"
+                  payload: "/SetSlots(reboot_router=False)"
+      - user: "/SetSlots(reboot_router=False)"
+        assertions:
+          - slot_was_set:
+              - name: "reboot_router"
+                value: False
+          - flow_started: "human_handoff"

rasa/cli/project_templates/telco/tests/e2e_test_cases/without_stub/general/hello.yml

@@ -0,0 +1,8 @@
+test_cases:
+  - test_case: hello
+    steps:
+    - user: "hello"
+      assertions:
+        - flow_started: "hello"
+        - bot_uttered:
+            utter_name: "utter_hello"

rasa/cli/run.py

@@ -88,7 +88,7 @@ def run(args: argparse.Namespace) -> None:
     """
     Configuration.initialise_endpoints(
         args.endpoints,
-    ).initialise_credentials(
+    ).initialise_sub_agents(args.sub_agents).initialise_credentials(
         args.credentials,
     )
 
@@ -108,7 +108,6 @@ def run(args: argparse.Namespace) -> None:
     # configured
 
     import rasa.model
-    from rasa.core.available_agents import AvailableAgents
 
     # start server if remote storage is configured
     if args.remote_storage is not None:
@@ -122,9 +121,6 @@ def run(args: argparse.Namespace) -> None:
         rasa_run(**vars(args))
         return
 
-    # load sub-agents
-    AvailableAgents.get_instance(args.sub_agents)
-
     # start server if local model found
     args.model = _validate_model_path(args.model, "model", DEFAULT_MODELS_PATH)
     local_model_set = True

rasa/cli/shell.py

@@ -115,6 +115,7 @@ def shell(args: argparse.Namespace) -> None:
     # it can be used safely throughout the codebase with
     # `Configuration.get_instance().endpoints`
     Configuration.initialise_endpoints(endpoints_path=Path(args.endpoints))
+    Configuration.initialise_sub_agents(args.sub_agents)
     model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
 
     try:

rasa/cli/train.py

@@ -128,6 +128,7 @@ def run_training(args: argparse.Namespace, can_exit: bool = False) -> Optional[T
     # Validates and loads endpoints with proper endpoint file location
     # TODO(Radovan): this should be probably be done in Configuration
     _check_nlg_endpoint_validity(args.endpoints)
+    Configuration.initialise_sub_agents(args.sub_agents)
 
     training_files = [
         get_validated_path(f, "data", DEFAULT_DATA_PATH, none_is_valid=True)

rasa/cli/validation/bot_config.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Optional
 import structlog
 
 from rasa import telemetry
+from rasa.core.constants import DEFAULT_SUB_AGENTS
 from rasa.exceptions import ValidationError
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.utils.common import display_research_study_prompt
@@ -188,20 +189,26 @@ def validate_files(
             validator, max_history, fail_on_warnings
         )
         valid_flows = validator.verify_flows()
+        valid_prompt_templates = validator.verify_prompt_templates()
         if validator.config:
             valid_translations = validator.verify_translations(summary_mode=True)
         else:
             valid_translations = True
         valid_CALM_slot_mappings = validator.validate_CALM_slot_mappings()
 
-        # Validate sub-agents if specified
-        valid_sub_agents = _validate_sub_agents(sub_agents) if sub_agents else True
+        # Validate sub-agents
+        sub_agents_path = sub_agents or DEFAULT_SUB_AGENTS
+        valid_sub_agents = _validate_sub_agents(sub_agents_path)
+
+        if valid_sub_agents:
+            valid_sub_agents = validator.validate_agent_flow_conflicts(sub_agents_path)
 
         all_good = (
             valid_domain
             and valid_nlu
             and valid_stories
             and valid_flows
+            and valid_prompt_templates
             and valid_translations
             and valid_CALM_slot_mappings
             and valid_sub_agents

rasa/core/available_agents.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel, Field, model_validator
 from ruamel import yaml as yaml
 
 from rasa.exceptions import ValidationError
-from rasa.utils.singleton import Singleton
+from rasa.shared.utils.yaml import read_config_file
 
 DEFAULT_AGENTS_CONFIG_FOLDER = "sub_agents"
 
@@ -89,48 +89,68 @@ class AgentConfig(BaseModel):
     connections: Optional[AgentConnections] = None
 
 
-class AvailableAgents(metaclass=Singleton):
+class AvailableAgents:
     """Collection of configured agents."""
 
-    _instance = None
-
     def __init__(self, agents: Optional[Dict[str, AgentConfig]] = None) -> None:
         """Create an `AvailableAgents` object."""
-        self.agents = agents or {}
+        self.agents: Dict[str, AgentConfig] = agents or {}
 
     @classmethod
-    def _read_agent_folder(cls, agent_folder: str) -> AvailableAgents:
+    def read_from_folder(cls, sub_agents_folder: str) -> AvailableAgents:
         """Read the different agents from the given folder."""
         agents: Dict[str, AgentConfig] = {}
 
-        if not os.path.isdir(agent_folder):
-            if agent_folder != DEFAULT_AGENTS_CONFIG_FOLDER:
+        if not os.path.isdir(sub_agents_folder):
+            if sub_agents_folder != DEFAULT_AGENTS_CONFIG_FOLDER:
                 # User explicitly specified a folder, it should exist
-                structlogger.error(
-                    f"The specified agents config folder '{agent_folder}' does not "
-                    f"exist or is not a directory."
-                )
-                raise ValueError(
-                    f"The specified agents config folder '{agent_folder}' does not "
-                    f"exist or is not a directory."
+                raise ValidationError(
+                    code="agent.sub_agents_folder_not_found",
+                    event_info=f"The specified agents config folder "
+                    f"'{sub_agents_folder}' does not exist or is not a "
+                    f"directory.",
+                    details={"folder": sub_agents_folder},
                 )
             else:
                 # We are using the default folder, it may not be created yet
                 # Init with an empty agents in this case
                 structlogger.info(
-                    f"Default agents config folder '{agent_folder}' does not exist. "
-                    f"Agent configurations won't be loaded."
+                    f"Default agents config folder '{sub_agents_folder}' does not "
+                    f"exist. Agent configurations won't be loaded."
                 )
                 return cls(agents)
 
         # First, load all agent configs into a temporary list for validation
         agent_configs: List[AgentConfig] = []
-        for agent_name in os.listdir(agent_folder):
-            config_path = os.path.join(agent_folder, agent_name, "config.yml")
+        for agent_name in os.listdir(sub_agents_folder):
+            agent_folder = os.path.join(sub_agents_folder, agent_name)
+            if not os.path.isdir(agent_folder):
+                raise ValidationError(
+                    code="agent.invalid_directory_structure",
+                    event_info=f"Invalid structure: '{agent_folder}' is not a folder. "
+                    f"Each agent must be stored in its own folder inside "
+                    f"'{sub_agents_folder}'. Expected structure: "
+                    f"{sub_agents_folder}/<agent_name>/config.yml",
+                    details={
+                        "agent_name": agent_name,
+                        "sub_agents_folder": sub_agents_folder,
+                    },
+                )
+            config_path = os.path.join(agent_folder, "config.yml")
             if not os.path.isfile(config_path):
-                continue
+                raise ValidationError(
+                    code="agent.missing_config_file",
+                    event_info=f"Missing config file for agent '{agent_name}'. "
+                    f"Expected file: '{config_path}'. "
+                    f"Each agent folder must contain a 'config.yml' file.",
+                    details={
+                        "agent_name": agent_name,
+                        "expected_config_file": config_path,
+                        "sub_agents_folder": sub_agents_folder,
+                    },
+                )
             try:
-                agent_config = cls._read_agent_config(config_path)
+                agent_config = cls._read_agent_config_file(config_path)
                 if not isinstance(agent_config, AgentConfig):
                     raise ValueError(f"Invalid agent config type for {agent_name}")
                 agent_configs.append(agent_config)
@@ -140,7 +160,7 @@ class AvailableAgents(metaclass=Singleton):
                     event_info=f"Failed to load agent '{agent_name}': {e}",
                     details={
                         "agent_name": agent_name,
-                        "agent_folder": agent_folder,
+                        "sub_agents_folder": sub_agents_folder,
                         "error": str(e),
                     },
                 )
@@ -153,27 +173,23 @@ class AvailableAgents(metaclass=Singleton):
         for agent_config in agent_configs:
             agents[agent_config.agent.name] = agent_config
 
+        structlogger.info(f"Loaded agent configs: {[k for k in agents.keys()]}")
         return cls(agents)
 
     @staticmethod
-    def _read_agent_config(config_path: str) -> AgentConfig:
-        """Read the agent config from a yaml file into Pydantic models.
+    def from_dict(data: Dict[str, Any]) -> AgentConfig:
+        """Parse the agent config from raw data into Pydantic models.
 
         Args:
-            config_path: Path to the config file.
+            data: Raw data from the config file as a dictionary.
 
         Returns:
-            The parsed AgentConfig.
+            The parsed AgentConfig as a Pydantic model.
 
         Raises:
-            yaml.YAMLError: If the YAML file is invalid.
             ValueError: If the data structure is invalid for Pydantic models.
         """
-        with open(config_path, "r") as f:
-            data = yaml.safe_load(f)
-
-        # Create the agent config (this will trigger Pydantic validation)
-        agent_config = AgentConfig(
+        return AgentConfig(
             agent=AgentInfo(**data.get("agent", {})),
             configuration=AgentConfiguration(**data.get("configuration", {}))
             if data.get("configuration")
@@ -183,24 +199,22 @@ class AvailableAgents(metaclass=Singleton):
             else None,
         )
 
-        return agent_config
-
     @classmethod
-    def get_instance(
-        cls, agent_folder: Optional[str] = DEFAULT_AGENTS_CONFIG_FOLDER
-    ) -> AvailableAgents:
-        """Get the singleton instance of `AvailableAgents`."""
-        if cls._instance is None:
-            cls._instance = cls._read_agent_folder(agent_folder)
+    def _read_agent_config_file(cls, config_path: str) -> AgentConfig:
+        """Read the agent config from a yaml file into Pydantic models.
 
-        return cls._instance
+        Args:
+            config_path: Path to the config file.
 
-    @classmethod
-    def reset_instance(cls) -> None:
-        cls._instance = None
-        # Also clear the metaclass singleton instances
-        if hasattr(type(cls), "_instances"):
-            type(cls)._instances.clear()
+        Returns:
+            The parsed AgentConfig.
+
+        Raises:
+            yaml.YAMLError: If the YAML file is invalid.
+            ValidationError: If the data structure is invalid for Pydantic models.
+        """
+        data = read_config_file(config_path)
+        return cls.from_dict(data)
 
     def as_json_list(self) -> List[Dict[str, Any]]:
         """Convert the available agents to a JSON-serializable list."""
@@ -218,12 +232,8 @@ class AvailableAgents(metaclass=Singleton):
             for agent_name, agent_config in self.agents.items()
         ]
 
-    @classmethod
-    def get_agent_config(cls, agent_id: str) -> Optional[AgentConfig]:
-        instance = cls.get_instance()
-        return instance.agents.get(agent_id)
+    def get_agent_config(self, agent_id: str) -> Optional[AgentConfig]:
+        return self.agents.get(agent_id)
 
-    @classmethod
-    def has_agents(cls) -> bool:
-        instance = cls.get_instance()
-        return len(instance.agents) > 0
+    def has_agents(self) -> bool:
+        return len(self.agents) > 0

rasa/core/config/available_endpoints.py

@@ -7,6 +7,7 @@ from typing import Any, Dict, List, Optional, Union
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from rasa.core.constants import MCP_SERVERS_KEY
+from rasa.shared.agents.auth.utils import validate_secrets_in_params
 from rasa.shared.core.constants import (
     GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE,
     GLOBAL_SILENCE_TIMEOUT_KEY,
@@ -77,6 +78,11 @@ class MCPServerConfig(BaseModel):
         # validate that name and url are not empty
         if not self.name or not self.url:
             raise ValueError("Name and URL cannot be empty")
+        # validate secrets in additional_params
+        if self.additional_params:
+            validate_secrets_in_params(
+                self.additional_params, f"MCP server - '{self.name}'"
+            )
         return self
 
     @model_validator(mode="before")
@@ -94,12 +100,9 @@ class MCPServerConfig(BaseModel):
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
-    _instance = None
-
     @classmethod
     def read_endpoints(cls, endpoint_file: Path) -> AvailableEndpoints:
         """Read the different endpoints from a yaml file."""
-
         nlg = read_endpoint_config(endpoint_file, endpoint_type="nlg")
         nlu = read_endpoint_config(endpoint_file, endpoint_type="nlu")
         action = read_endpoint_config(endpoint_file, endpoint_type="action_endpoint")

rasa/core/config/configuration.py

@@ -7,6 +7,7 @@ from typing import Literal, Optional
 import structlog
 
 from rasa.cli.validation.config_path_validation import get_validated_path
+from rasa.core.available_agents import DEFAULT_AGENTS_CONFIG_FOLDER, AvailableAgents
 from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.core.config.credentials import CredentialsConfig
 from rasa.core.config.message_procesing_config import MessageProcessingConfig
@@ -146,10 +147,12 @@ class Configuration:
     def __init__(
         self,
         endpoints: AvailableEndpoints,
+        available_agents: AvailableAgents,
         credentials: Optional[CredentialsConfig] = None,
         message_processing_config: Optional[MessageProcessingConfig] = None,
     ):
         self.credentials = credentials
+        self.available_agents = available_agents
         self.endpoints = endpoints
         self.message_processing_config = message_processing_config
 
@@ -159,6 +162,7 @@ class Configuration:
             cls._instance = Configuration(
                 credentials=None,
                 endpoints=AvailableEndpoints(),
+                available_agents=AvailableAgents(),
                 message_processing_config=None,
             )
         return cls._instance
@@ -177,7 +181,10 @@ class Configuration:
         )
         if cls._instance is None:
             cls._instance = Configuration(
-                endpoints=endpoints, credentials=None, message_processing_config=None
+                endpoints=endpoints,
+                available_agents=AvailableAgents(),
+                credentials=None,
+                message_processing_config=None,
             )
         else:
             cls._instance.endpoints = endpoints
@@ -189,6 +196,7 @@ class Configuration:
         if cls._instance is None:
             cls._instance = Configuration(
                 endpoints=AvailableEndpoints(),
+                available_agents=AvailableAgents(),
                 credentials=None,
                 message_processing_config=None,
             )
@@ -217,6 +225,7 @@ class Configuration:
                 message_processing_config=message_processing_config,
                 credentials=None,
                 endpoints=AvailableEndpoints(),
+                available_agents=AvailableAgents(),
             )
         else:
             cls._instance.message_processing_config = message_processing_config
@@ -240,12 +249,37 @@ class Configuration:
             cls._instance = Configuration(
                 credentials=credentials,
                 endpoints=AvailableEndpoints(),
+                available_agents=AvailableAgents(),
                 message_processing_config=None,
             )
         else:
             cls._instance.credentials = credentials
         return cls._instance
 
+    @classmethod
+    def initialise_sub_agents(cls, sub_agents_path: Optional[Path]) -> Configuration:
+        sub_agents_folder = (
+            str(sub_agents_path)
+            if sub_agents_path is not None
+            else DEFAULT_AGENTS_CONFIG_FOLDER
+        )
+        logger.debug(
+            "configuration.initialise_sub_agents.start",
+            sub_agents_folder=sub_agents_folder,
+        )
+        available_agents = AvailableAgents.read_from_folder(sub_agents_folder)
+
+        if cls._instance is None:
+            cls._instance = Configuration(
+                endpoints=AvailableEndpoints(),
+                available_agents=available_agents,
+                credentials=None,
+                message_processing_config=None,
+            )
+        else:
+            cls._instance.available_agents = available_agents
+        return cls._instance
+
     @classmethod
     def get_instance(cls) -> Configuration:
         if cls._instance is None:
@@ -254,6 +288,7 @@ class Configuration:
                 "Call appropriate 'initialise' methods to "
                 "load the config when Rasa Pro starts: "
                 "initialise_endpoints(), "
+                "initialise_sub_agents(), "
                 "initialise_credentials(), "
                 "initialise_message_processing()"
             )

rasa/core/policies/flows/agent_executor.py

@@ -16,7 +16,7 @@ from rasa.agents.constants import (
 from rasa.agents.core.types import AgentStatus, ProtocolType
 from rasa.agents.schemas import AgentInput, AgentOutput
 from rasa.agents.schemas.agent_input import AgentInputSlot
-from rasa.core.available_agents import AvailableAgents
+from rasa.core.config.configuration import Configuration
 from rasa.core.policies.flows.flow_step_result import (
     ContinueFlowWithNextStep,
     FlowActionPrediction,
@@ -47,12 +47,13 @@ from rasa.shared.core.events import (
     AgentStarted,
     Event,
     SlotSet,
+    deserialise_events,
 )
 from rasa.shared.core.flows.steps import (
     CallFlowStep,
 )
 from rasa.shared.core.slots import CategoricalSlot, Slot
-from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
 from rasa.shared.utils.llm import tracker_as_readable_transcript
 
 structlogger = structlog.get_logger()
@@ -61,8 +62,9 @@ MAX_AGENT_RETRIES = 3
 
 
 def remove_agent_stack_frame(stack: DialogueStack, agent_id: str) -> None:
-    """Finishes the agentic loop by popping the agent stack frame from the
-    provided `stack`. The `tracker.stack` is NOT modified.
+    """Finishes the agentic loop by popping the agent stack frame from provided `stack`.
+
+    The `tracker.stack` is NOT modified.
     """
     agent_stack_frame = stack.find_agent_stack_frame_by_agent(agent_id)
     if not agent_stack_frame:
@@ -136,7 +138,9 @@ async def run_agent(
     final_events.append(AgentStarted(step.call, step.flow_id))
 
     # send the input to the agent and wait for a response
-    protocol_type = get_protocol_type(step, AvailableAgents.get_agent_config(step.call))
+    protocol_type = get_protocol_type(
+        step, Configuration.get_instance().available_agents.get_agent_config(step.call)
+    )
     output: AgentOutput = await _call_agent_with_retry(
         agent_name=step.call,
         protocol_type=protocol_type,
@@ -471,8 +475,9 @@ def _create_action_prediction(
 def _create_agent_request_user_input_prediction(
     message: Optional[str], events: Optional[List[Event]]
 ) -> FlowActionPrediction:
-    """Create a prediction for requesting user input from the agent
-    and waiting for it.
+    """Create a prediction for requesting user input from the agent and waiting for it.
+
+    This function creates a prediction that will pause the flow and wait for user input.
     """
     return _create_action_prediction(
         ACTION_AGENT_REQUEST_USER_INPUT_NAME, message, events
@@ -529,7 +534,9 @@ def _prepare_agent_input(
             tracker.current_slot_values(), slots, step.exit_if
         ),
         conversation_history=tracker_as_readable_transcript(tracker),
-        events=tracker.current_state().get("events") or [],
+        events=deserialise_events(
+            tracker.current_state(EventVerbosity.ALL).get("events") or []
+        ),
         metadata=agent_input_metadata,
     )
 
@@ -550,6 +557,7 @@ def _prepare_slots_for_agent(
     Args:
         slot_values: The full slot dictionary from the tracker.
         slot_definitions: The slot definitions from the domain.
+        exit_if: Optional list of exit conditions that determine which slots to keep.
 
     Returns:
         A list of slots containing the name, current value, type, and allowed values.