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

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

@@ -94,12 +94,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.

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -104,7 +104,10 @@ class StartFlowCommand(Command):
             # 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)
+            stack, flow_completed_events = remove_pattern_continue_interrupted_frames(
+                stack
+            )
+            applied_events.extend(flow_completed_events)
             return applied_events + tracker.create_stack_updated_events(stack)
 
         # if the flow is already on the stack, resume it
@@ -114,7 +117,10 @@ class StartFlowCommand(Command):
         ):
             # 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)
+            stack, flow_completed_events = remove_pattern_continue_interrupted_frames(
+                stack
+            )
+            applied_events.extend(flow_completed_events)
             applied_events.extend(resume_flow(self.flow, tracker, stack))
             # the current active flow is interrupted
             applied_events.append(
@@ -128,7 +134,8 @@ class StartFlowCommand(Command):
 
         # remove the pattern_continue_interrupted frames from the stack
         # if it is currently active but the user digressed from the pattern
-        stack = remove_pattern_continue_interrupted_frames(stack)
+        stack, flow_completed_events = remove_pattern_continue_interrupted_frames(stack)
+        applied_events.extend(flow_completed_events)
 
         if original_top_flow:
             # if the original top flow is not the same as the flow to start,

rasa/dialogue_understanding/commands/utils.py

@@ -19,6 +19,7 @@ from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
 from rasa.shared.core.events import (
     AgentResumed,
     Event,
+    FlowCompleted,
     FlowResumed,
     SlotSet,
 )
@@ -250,18 +251,28 @@ def collect_frames_to_resume(
     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."""
+def remove_pattern_continue_interrupted_frames(
+    stack: DialogueStack,
+) -> Tuple[DialogueStack, List[FlowCompleted]]:
+    """Remove pattern_continue_interrupted frames from the stack and return events.
+
+    Returns:
+        A tuple containing (updated_stack, flow_completed_events)
+    """
     from rasa.dialogue_understanding.stack.utils import (
         is_continue_interrupted_flow_active,
     )
 
     if not is_continue_interrupted_flow_active(stack):
-        return stack
+        return stack, []
 
+    events = []
     # remove pattern_continue_interrupted from the stack
     top_frame = stack.top()
     while isinstance(top_frame, PatternFlowStackFrame):
+        # Create FlowCompleted event for the pattern frame being removed
+        events.append(FlowCompleted(top_frame.flow_id, top_frame.step_id))
+
         # 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
@@ -271,4 +282,4 @@ def remove_pattern_continue_interrupted_frames(stack: DialogueStack) -> Dialogue
         stack.pop()
         top_frame = stack.top()
 
-    return stack
+    return stack, events

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -7,7 +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.core.config.configuration import Configuration
 from rasa.dialogue_understanding.commands import (
     Command,
     SetSlotCommand,
@@ -398,7 +398,9 @@ class LLMBasedCommandGenerator(
                     if isinstance(event, AgentStarted) and event.flow_id == flow.id
                 ]
                 available_agents = [
-                    AvailableAgents.get_agent_config(event.agent_id)
+                    Configuration.get_instance().available_agents.get_agent_config(
+                        event.agent_id
+                    )
                     for event in agent_events
                 ]
                 if available_agents:

rasa/dialogue_understanding/generator/single_step/compact_llm_command_generator.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, Literal, Optional, Text
 
 import structlog
 
-from rasa.core.available_agents import AvailableAgents
+from rasa.core.config.configuration import Configuration
 from rasa.dialogue_understanding.commands.command_syntax_manager import (
     CommandSyntaxVersion,
 )
@@ -125,7 +125,7 @@ class CompactLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
         """Get the default prompt template file name for the command generator."""
         return (
             AGENT_DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME
-            if AvailableAgents.has_agents()
+            if Configuration.get_instance().available_agents.has_agents()
             else DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME
         )
 
@@ -134,7 +134,7 @@ class CompactLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
         """Get the fallback prompt template file name for the command generator."""
         return (
             AGENT_FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME
-            if AvailableAgents.has_agents()
+            if Configuration.get_instance().available_agents.has_agents()
             else FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME
         )
 
@@ -143,7 +143,7 @@ class CompactLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
         """Get the model prompt mapper for the command generator."""
         return (
             AGENT_MODEL_PROMPT_MAPPER
-            if AvailableAgents.has_agents()
+            if Configuration.get_instance().available_agents.has_agents()
             else MODEL_PROMPT_MAPPER
         )
 

rasa/dialogue_understanding/generator/single_step/search_ready_llm_command_generator.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, Literal, Optional, Text
 
 import structlog
 
-from rasa.core.available_agents import AvailableAgents
+from rasa.core.config.configuration import Configuration
 from rasa.dialogue_understanding.commands.command_syntax_manager import (
     CommandSyntaxVersion,
 )
@@ -127,7 +127,7 @@ class SearchReadyLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
         """Get the default prompt template file name for the command generator."""
         return (
             AGENT_DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME
-            if AvailableAgents.has_agents()
+            if Configuration.get_instance().available_agents.has_agents()
             else DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME
         )
 
@@ -136,7 +136,7 @@ class SearchReadyLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
         """Get the fallback prompt template file name for the command generator."""
         return (
             AGENT_FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME
-            if AvailableAgents.has_agents()
+            if Configuration.get_instance().available_agents.has_agents()
             else FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME
         )
 
@@ -145,7 +145,7 @@ class SearchReadyLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
         """Get the model prompt mapper for the command generator."""
         return (
             AGENT_MODEL_PROMPT_MAPPER
-            if AvailableAgents.has_agents()
+            if Configuration.get_instance().available_agents.has_agents()
             else MODEL_PROMPT_MAPPER
         )
 

rasa/dialogue_understanding/generator/single_step/single_step_based_llm_command_generator.py

@@ -9,7 +9,7 @@ from rasa.agents.utils import (
     get_active_agent_info,
     get_completed_agents_info,
 )
-from rasa.core.available_agents import AvailableAgents
+from rasa.core.config.configuration import Configuration
 from rasa.dialogue_understanding.commands import (
     CannotHandleCommand,
     Command,
@@ -403,7 +403,7 @@ class SingleStepBasedLLMCommandGenerator(LLMBasedCommandGenerator, ABC):
             current_slot_allowed_values = allowed_values_for_slot(
                 tracker.slots.get(current_slot)
             )
-        has_agents = AvailableAgents.has_agents()
+        has_agents = Configuration.get_instance().available_agents.has_agents()
         current_conversation = tracker_as_readable_transcript(
             tracker, highlight_agent_turns=has_agents
         )

rasa/dialogue_understanding_test/du_test_runner.py

@@ -6,9 +6,9 @@ from typing import Any, Dict, List, Optional, Union
 import structlog
 from tqdm import tqdm
 
-from rasa.core.available_agents import AvailableAgents
 from rasa.core.channels import CollectingOutputChannel, UserMessage
 from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.configuration import Configuration
 from rasa.core.exceptions import AgentNotReady
 from rasa.core.persistor import StorageType
 from rasa.dialogue_understanding.commands import Command
@@ -71,7 +71,7 @@ class DialogueUnderstandingTestRunner:
         import rasa.core.agent
 
         self._check_action_server(endpoints)
-        sub_agents = AvailableAgents.get_instance(sub_agents_path)
+        sub_agents = Configuration.get_instance().available_agents
 
         self.agent = asyncio.run(
             rasa.core.agent.load_agent(

rasa/e2e_test/e2e_test_runner.py

@@ -13,9 +13,9 @@ import structlog
 from tqdm import tqdm
 
 import rasa.shared.utils.io
-from rasa.core.available_agents import AvailableAgents
 from rasa.core.channels import CollectingOutputChannel, UserMessage
 from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.configuration import Configuration
 from rasa.core.constants import ACTIVE_FLOW_METADATA_KEY, STEP_ID_METADATA_KEY
 from rasa.core.exceptions import AgentNotReady
 from rasa.core.persistor import StorageType
@@ -96,7 +96,7 @@ class E2ETestRunner:
         if endpoints and not are_custom_actions_stubbed:
             self._action_server_is_reachable(endpoints)
 
-        sub_agents = AvailableAgents.get_instance(sub_agents_path)
+        sub_agents = Configuration.get_instance().available_agents
 
         self.agent = asyncio.run(
             rasa.core.agent.load_agent(