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

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

@@ -0,0 +1,41 @@
+test_cases:
+  - test_case: human handoff happy path
+    steps:
+    - user: "I would like to speak with a human"
+      assertions:
+        - flow_started: "human_handoff"
+        - bot_uttered:
+            utter_name: "utter_ask_confirm_human_handoff"
+            buttons:
+              - payload: "/SetSlots(confirm_human_handoff=Yes)"
+                title: "Yes"
+              - payload: "/SetSlots(confirm_human_handoff=No)"
+                title: "No"
+    - user: "/SetSlots(confirm_human_handoff=Yes)"
+      assertions:
+        - slot_was_set:
+            - name: "confirm_human_handoff"
+              value: "Yes"
+        - bot_uttered:
+            utter_name: "utter_transferring_to_human"
+        - action_executed: action_human_handoff
+# ====================================================>
+  - test_case: human handoff unhappy path
+    steps:
+    - user: "I would like to speak with a human"
+      assertions:
+        - flow_started: "human_handoff"
+        - bot_uttered:
+            utter_name: "utter_ask_confirm_human_handoff"
+            buttons:
+              - payload: "/SetSlots(confirm_human_handoff=Yes)"
+                title: "Yes"
+              - payload: "/SetSlots(confirm_human_handoff=No)"
+                title: "No"
+    - user: "/SetSlots(confirm_human_handoff=No)"
+      assertions:
+        - slot_was_set:
+            - name: "confirm_human_handoff"
+              value: "No"
+        - bot_uttered:
+            utter_name: "utter_human_handoff_cancelled"

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
@@ -194,8 +195,12 @@ def validate_files(
             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

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/brokers/kafka.py

@@ -12,6 +12,7 @@ import structlog
 
 import rasa.shared.utils.common
 from rasa.core.brokers.broker import EventBroker
+from rasa.core.constants import KAFKA_SERVICE_NAME
 from rasa.core.exceptions import KafkaProducerInitializationError
 from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
     IAMCredentialsProviderInput,
@@ -99,7 +100,10 @@ class KafkaEventBroker(EventBroker):
         self.queue_size = kwargs.get("queue_size")
         self.ssl_check_hostname = "https" if ssl_check_hostname else None
         self.iam_credentials_provider = create_iam_credentials_provider(
-            IAMCredentialsProviderInput(service_name=SupportedServiceType.EVENT_BROKER)
+            IAMCredentialsProviderInput(
+                service_type=SupportedServiceType.EVENT_BROKER,
+                service_name=KAFKA_SERVICE_NAME,
+            )
         )
 
         # PII management attributes

rasa/core/concurrent_lock_store.py

@@ -6,6 +6,9 @@ from typing import Deque, Optional, Text
 import structlog
 from pydantic import ValidationError
 
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    SupportedServiceType,
+)
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
     DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
@@ -108,6 +111,7 @@ class ConcurrentRedisLockStore(LockStore):
             redis_config = RedisConfig(
                 host=host,
                 port=port,
+                service_type=SupportedServiceType.LOCK_STORE,
                 db=db,
                 username=username,
                 password=password,
@@ -150,32 +154,45 @@ class ConcurrentRedisLockStore(LockStore):
                 ),
             )
 
-    def _get_keys_by_pattern(self, pattern: Text) -> list:
-        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
-        if self.deployment_mode == DeploymentMode.CLUSTER.value:
-            # In cluster mode, use SCAN to get keys more reliably
-            keys = []
-            cursor = 0
-
-            while True:
-                try:
-                    cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
-                    keys.extend(batch_keys)
+    def _scan_cluster_keys(self, pattern: Text) -> list:
+        """Scan keys in cluster mode with proper cursor handling."""
+        keys = []
+        cursor = 0
+
+        while True:
+            try:
+                cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
+                keys.extend(batch_keys)
+
+                if isinstance(cursor, dict):
+                    # cursor is a dict mapping each node to its scan position. e.g
+                    # {'127.0.0.1:7000': 0, '127.0.0.1:7001': 5, '127.0.0.1:7002': 0}
+                    # A cursor value of 0 means that node has finished scanning
+                    # When all nodes show 0, the entire cluster scan is complete
+                    if all(v == 0 for v in cursor.values()):
+                        break
+                else:
+                    # if scan is complete
                     if cursor == 0:
                         break
-                except Exception as e:
-                    structlogger.warning(
-                        "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
-                        event_info=f"SCAN interrupted in cluster mode: {e}. "
-                        f"Returning {len(keys)} keys found so far.",
-                    )
-                    break
-        else:
-            # Standard and sentinel modes use KEYS
-            keys = self.red.keys(pattern)
+
+            except Exception as e:
+                structlogger.warning(
+                    "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
+                    event_info=f"SCAN interrupted in cluster mode: {e}. "
+                    f"Returning {len(keys)} keys found so far.",
+                )
+                break
 
         return keys
 
+    def _get_keys_by_pattern(self, pattern: Text) -> list:
+        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
+        if self.deployment_mode == DeploymentMode.CLUSTER.value:
+            return self._scan_cluster_keys(pattern)
+        else:
+            return self.red.keys(pattern)
+
     def issue_ticket(
         self, conversation_id: Text, lock_lifetime: float = LOCK_LIFETIME
     ) -> int:

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")