rasa-pro 3.13.11__py3-none-any.whl → 3.14.0__py3-none-any.whl

rasa/dialogue_understanding/stack/dialogue_stack.py

@@ -8,6 +8,13 @@ from typing import Any, Callable, Dict, List, Optional
 import jsonpatch
 import structlog
 
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+
 if typing.TYPE_CHECKING:
     from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
 
@@ -91,6 +98,42 @@ class DialogueStack:
         """
         return self.frames.pop()
 
+    def move_frames_to_top(self, frames_to_move: List["DialogueStackFrame"]) -> None:
+        """Moves specified frames to top of stack while preserving their relative order.
+
+        Args:
+            frames_to_move: The frames to move to the top of the stack.
+        """
+        # Get frames that are not being moved
+        frames_to_keep = [frame for frame in self.frames if frame not in frames_to_move]
+
+        # Reorder: keep frames first, then moved frames
+        self.frames = frames_to_keep + frames_to_move
+
+        # set all frames to interrupt except for LINK and CALL
+        for frame in self.frames:
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type == FlowStackFrameType.LINK
+            ):
+                continue
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type == FlowStackFrameType.CALL
+            ):
+                continue
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type == FlowStackFrameType.REGULAR
+            ):
+                frame.frame_type = FlowStackFrameType.INTERRUPT
+
+        # set the first frame to regular
+        for frame in self.frames:
+            if isinstance(frame, UserFlowStackFrame):
+                frame.frame_type = FlowStackFrameType.REGULAR
+                return
+
     def current_context(self) -> Dict[str, Any]:
         """Returns the context of the topmost frame.
 
@@ -109,7 +152,7 @@ class DialogueStack:
         """Returns the topmost frame from the stack.
 
         Args:
-            ignore_frame: The ID of the flow to ignore. Picks the top most
+            ignore: The ID of the flow to ignore. Picks the top most
                 frame that has a different flow ID.
 
         Returns:
@@ -136,7 +179,8 @@ class DialogueStack:
             patch_dump: The patch to apply to the stack.
 
         Returns:
-            The updated stack."""
+        The updated stack.
+        """
         patch = jsonpatch.JsonPatch.from_string(patch_dump)
         dialogue_stack_dump = patch.apply(self.as_dict())
         return DialogueStack.from_dict(dialogue_stack_dump)
@@ -177,3 +221,55 @@ class DialogueStack:
         if patch:
             return patch.to_string()
         return None
+
+    def _find_agent_frame_by_predicate(
+        self, predicate: Callable[[AgentStackFrame], bool]
+    ) -> List[AgentStackFrame]:
+        stack_frames: List[AgentStackFrame] = []
+        for stack_frame in reversed(self.frames):
+            if isinstance(stack_frame, AgentStackFrame) and predicate(stack_frame):
+                stack_frames.append(stack_frame)
+        return stack_frames
+
+    def find_active_agent_frame(self) -> Optional[AgentStackFrame]:
+        stack_frames = self._find_agent_frame_by_predicate(
+            lambda frame: frame.state == AgentState.WAITING_FOR_INPUT
+        )
+        if stack_frames:
+            return stack_frames[0]
+        return None
+
+    def find_agent_stack_frame_by_agent(
+        self, agent_id: str
+    ) -> Optional[AgentStackFrame]:
+        """Get the agent stack frame for a specific agent ID.
+
+        May also include the agent stack frame in the INTERRUPTED state.
+        """
+        stack_frames = self._find_agent_frame_by_predicate(
+            lambda frame: frame.agent_id == agent_id
+        )
+        if stack_frames:
+            return stack_frames[0]
+        return None
+
+    def find_active_agent_stack_frame_for_flow(
+        self, flow_id: str
+    ) -> Optional[AgentStackFrame]:
+        """Get the agent stack frame of a specific flow."""
+        stack_frames = self._find_agent_frame_by_predicate(
+            lambda frame: frame.flow_id == flow_id
+        )
+        for stack_frame in stack_frames:
+            if stack_frame.state == AgentState.WAITING_FOR_INPUT:
+                return stack_frame
+        return None
+
+    def get_active_agent_id(self) -> Optional[typing.Text]:
+        agent_frame = self.find_active_agent_frame()
+        if agent_frame:
+            return agent_frame.agent_id
+        return None
+
+    def agent_is_active(self) -> bool:
+        return self.find_active_agent_frame() is not None

rasa/dialogue_understanding/stack/frames/flow_stack_frame.py

@@ -94,6 +94,18 @@ class InvalidFlowStepIdException(Exception):
         super().__init__(f"Invalid flow step ID '{step_id}' for flow '{flow_id}'.")
 
 
+class InvalidAgentState(RasaException):
+    """Raised if the agent state is invalid."""
+
+    def __init__(self, invalid_state: str) -> None:
+        """Creates a `InvalidAgentState`.
+
+        Args:
+            invalid_state: The invalid agent state.
+        """
+        super().__init__(f"Invalid agent state '{invalid_state}'.")
+
+
 @dataclass
 class BaseFlowStackFrame(DialogueStackFrame):
     flow_id: str = ""  # needed to avoid "default arg before non-default" error
@@ -171,3 +183,48 @@ class UserFlowStackFrame(BaseFlowStackFrame):
             step_id=data["step_id"],
             frame_type=FlowStackFrameType.from_str(data.get("frame_type")),
         )
+
+
+class AgentState(str, Enum):
+    INTERRUPTED = "interrupted"
+    WAITING_FOR_INPUT = "waiting_for_input"
+
+    @staticmethod
+    def from_str(state: Optional[str]) -> AgentState:
+        if state == AgentState.WAITING_FOR_INPUT.value:
+            return AgentState.WAITING_FOR_INPUT
+        elif state == AgentState.INTERRUPTED.value:
+            return AgentState.INTERRUPTED
+        else:
+            raise InvalidAgentState(state)
+
+
+@dataclass
+class AgentStackFrame(BaseFlowStackFrame):
+    agent_id: str = ""
+    state: AgentState = AgentState.WAITING_FOR_INPUT
+    metadata: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return "agent"
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> AgentStackFrame:
+        """Creates a `AgentStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `AgentStackFrame` from.
+
+        Returns:
+            The created `AgentStackFrame`.
+        """
+        return AgentStackFrame(
+            frame_id=data["frame_id"],
+            flow_id=data["flow_id"],
+            step_id=data["step_id"],
+            agent_id=data["agent_id"],
+            state=AgentState.from_str(data["state"]),
+            metadata=data.get("metadata"),
+        )

rasa/dialogue_understanding/stack/utils.py

@@ -17,6 +17,9 @@ from rasa.shared.core.flows.steps.constants import END_STEP
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
 
 if typing.TYPE_CHECKING:
+    from rasa.dialogue_understanding.patterns.continue_interrupted import (
+        ContinueInterruptedPatternFlowStackFrame,
+    )
     from rasa.shared.core.trackers import DialogueStateTracker
 
 
@@ -171,10 +174,40 @@ def user_flows_on_the_stack(dialogue_stack: DialogueStack) -> Set[str]:
     All user flows that are currently on the stack.
     """
     return {
-        f.flow_id for f in dialogue_stack.frames if isinstance(f, UserFlowStackFrame)
+        frame.flow_id
+        for frame in user_frames_on_the_stack(
+            dialogue_stack, ignore_call_and_link_frames=False
+        )
     }
 
 
+def user_frames_on_the_stack(
+    dialogue_stack: DialogueStack, ignore_call_and_link_frames: bool = True
+) -> List[UserFlowStackFrame]:
+    """Get all user frames that are currently on the stack.
+
+    Args:
+        dialogue_stack: The dialogue stack.
+        ignore_call_and_link_frames: Whether to ignore user frames of type `call`
+            and `link`. By default, these frames are ignored.
+
+    Returns:
+    All user frames that are currently on the stack.
+    """
+    return [
+        frame
+        for frame in dialogue_stack.frames
+        if isinstance(frame, UserFlowStackFrame)
+        and (
+            not ignore_call_and_link_frames
+            or (
+                frame.frame_type != FlowStackFrameType.CALL
+                and frame.frame_type != FlowStackFrameType.LINK
+            )
+        )
+    ]
+
+
 def end_top_user_flow(stack: DialogueStack) -> DialogueStack:
     """Ends all frames on top of the stack including the topmost user frame.
 
@@ -198,8 +231,9 @@ def end_top_user_flow(stack: DialogueStack) -> DialogueStack:
 def get_collect_steps_excluding_ask_before_filling_for_active_flow(
     dialogue_stack: DialogueStack, all_flows: FlowsList
 ) -> Set[str]:
-    """Get all collect steps that are part of the current flow, without
-    considering the collect steps that has to be asked before filling.
+    """Get all collect steps that are part of the current flow.
+
+    Collect steps that have to be asked before filling are not considered.
 
     Args:
         dialogue_stack: The dialogue stack.
@@ -230,3 +264,23 @@ def get_collect_steps_excluding_ask_before_filling_for_active_flow(
         for step in active_flow.get_collect_steps()
         if not step.ask_before_filling
     )
+
+
+def is_continue_interrupted_flow_active(stack: DialogueStack) -> bool:
+    """Check if the continue interrupted flow is active."""
+    return get_active_continue_interrupted_pattern_frame(stack) is not None
+
+
+def get_active_continue_interrupted_pattern_frame(
+    stack: DialogueStack,
+) -> Optional["ContinueInterruptedPatternFlowStackFrame"]:
+    from rasa.dialogue_understanding.patterns.continue_interrupted import (
+        ContinueInterruptedPatternFlowStackFrame,
+    )
+
+    for frame in reversed(stack.frames):
+        if isinstance(frame, ContinueInterruptedPatternFlowStackFrame):
+            return frame
+        if isinstance(frame, UserFlowStackFrame):
+            return None
+    return None

rasa/dialogue_understanding/utils.py

@@ -1,9 +1,9 @@
+import typing
 from contextlib import contextmanager
 from typing import Any, Dict, Generator, List, Optional, Text
 
 import structlog
 
-from rasa.dialogue_understanding.commands import Command, NoopCommand, SetSlotCommand
 from rasa.dialogue_understanding.constants import (
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME,
 )
@@ -23,6 +23,9 @@ from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
 from rasa.utils.common import get_bool_env_variable
 
+if typing.TYPE_CHECKING:
+    from rasa.dialogue_understanding.commands import Command
+
 record_commands_and_prompts = get_bool_env_variable(
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME, False
 )
@@ -41,7 +44,7 @@ def set_record_commands_and_prompts() -> Generator:
 
 
 def add_commands_to_message_parse_data(
-    message: Message, component_name: str, commands: List[Command]
+    message: Message, component_name: str, commands: List["Command"]
 ) -> None:
     """Add commands to the message parse data.
 
@@ -144,6 +147,11 @@ def _handle_via_nlu_in_coexistence(
     tracker: Optional[DialogueStateTracker], message: Message
 ) -> bool:
     """Check if the message should be handled by the NLU subsystem in coexistence mode."""  # noqa: E501
+    from rasa.dialogue_understanding.commands import (
+        NoopCommand,
+        SetSlotCommand,
+    )
+
     if not tracker:
         return False
 
@@ -156,8 +164,7 @@ def _handle_via_nlu_in_coexistence(
             "utils.handle_via_nlu_in_coexistence"
             ".tracker_missing_route_session_to_calm_slot",
             event_info=(
-                f"Tracker doesn't have the '{ROUTE_TO_CALM_SLOT}' slot."
-                f"Routing to CALM."
+                f"Tracker doesn't have the '{ROUTE_TO_CALM_SLOT}' slot.Routing to CALM."
             ),
             route_session_to_calm=commands,
         )
@@ -218,3 +225,16 @@ def _handle_via_nlu_in_coexistence(
         commands=commands,
     )
     return False
+
+
+def assemble_options_string(names: List[str], conjunction: str = "and") -> str:
+    """Concatenate options to a human-readable string."""
+    option_message = ""
+    for i, name in enumerate(names):
+        if i == 0:
+            option_message += name
+        elif i == len(names) - 1:
+            option_message += f" {conjunction} {name}"
+        else:
+            option_message += f", {name}"
+    return option_message

rasa/dialogue_understanding_test/du_test_runner.py

@@ -1,12 +1,14 @@
 import asyncio
 import time
-from typing import Any, Dict, List, Optional, Text
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
 
 import structlog
 from tqdm import tqdm
 
-from rasa.core.available_endpoints import AvailableEndpoints
 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
@@ -52,10 +54,11 @@ class DialogueUnderstandingTestRunner:
 
     def __init__(
         self,
-        model_path: Optional[Text] = None,
+        model_path: Optional[str] = None,
         model_server: Optional[EndpointConfig] = None,
         remote_storage: Optional[StorageType] = None,
         endpoints: Optional[AvailableEndpoints] = None,
+        sub_agents_path: Optional[Union[Path, str]] = None,
     ) -> None:
         """Initializes the Dialogue Understanding test suite runner.
 
@@ -68,6 +71,7 @@ class DialogueUnderstandingTestRunner:
         import rasa.core.agent
 
         self._check_action_server(endpoints)
+        sub_agents = Configuration.get_instance().available_agents
 
         self.agent = asyncio.run(
             rasa.core.agent.load_agent(
@@ -75,6 +79,7 @@ class DialogueUnderstandingTestRunner:
                 model_server=model_server,
                 remote_storage=remote_storage,
                 endpoints=endpoints,
+                sub_agents=sub_agents,
             )
         )
         if not self.agent.is_ready():

rasa/e2e_test/e2e_test_runner.py

@@ -13,8 +13,9 @@ import structlog
 from tqdm import tqdm
 
 import rasa.shared.utils.io
-from rasa.core.available_endpoints import AvailableEndpoints
 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
@@ -65,6 +66,7 @@ class E2ETestRunner:
         model_server: Optional[EndpointConfig] = None,
         remote_storage: Optional[StorageType] = None,
         endpoints: Optional[AvailableEndpoints] = None,
+        sub_agents_path: Optional[Text] = None,
         **kwargs: Any,
     ) -> None:
         """Initializes the E2E test suite runner.
@@ -94,12 +96,15 @@ class E2ETestRunner:
         if endpoints and not are_custom_actions_stubbed:
             self._action_server_is_reachable(endpoints)
 
+        sub_agents = Configuration.get_instance().available_agents
+
         self.agent = asyncio.run(
             rasa.core.agent.load_agent(
                 model_path=model_path,
                 model_server=model_server,
                 remote_storage=remote_storage,
                 endpoints=endpoints,
+                sub_agents=sub_agents,
             )
         )
 
@@ -742,7 +747,7 @@ class E2ETestRunner:
             test_result = test_turns[index]
             if index in failure_points:
                 diff_test_text, diff_actual_text = cls._handle_fail_diff(
-                    test_result,  # type: ignore[arg-type]
+                    test_result,
                     latest_response,
                     cls._select_bot_utter_turns(test_turns, index),
                 )  # test_result can only be TestStep in failure_points
@@ -806,7 +811,12 @@ class E2ETestRunner:
         """
         # This will only be used when the TestCase is not started
         # with a user step
-        latest_response: ActualStepOutput = test_turns[-1]  # type: ignore[assignment]
+        latest_response_event = test_turns[-1]
+        if not isinstance(latest_response_event, ActualStepOutput):
+            raise ValueError(
+                f"Expected ActualStepOutput, got {type(latest_response_event)}"
+            )
+        latest_response: ActualStepOutput = latest_response_event
         failures = []
         match = None
         for position in range(last_user_step_position, len(test_turns) - 1):

rasa/engine/caching.py

@@ -5,7 +5,7 @@ import logging
 import shutil
 from datetime import datetime
 from pathlib import Path
-from typing import Any, List, Optional, Text, Tuple
+from typing import Any, List, Optional, Text, Tuple, Union
 
 import sqlalchemy as sa
 import sqlalchemy.orm
@@ -294,7 +294,7 @@ class LocalTrainingCache(TrainingCache):
 
     def _cache_output_to_disk(
         self, output: Cacheable, model_storage: ModelStorage
-    ) -> Tuple[Optional[Text], Optional[Text]]:
+    ) -> Tuple[Optional[Union[Path, Text]], Optional[Text]]:
         tempdir_name = rasa.utils.common.get_temp_dir_name()
 
         # Use `TempDirectoryPath` instead of `tempfile.TemporaryDirectory` as this

rasa/engine/constants.py

@@ -1,7 +1,7 @@
 from typing import List, Optional
 
-from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels import UserMessage
+from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.importers.importer import TrainingDataImporter
 

rasa/engine/graph.py

@@ -69,6 +69,7 @@ class SchemaNode:
 
     def matches_type(self, node_type: Type, include_subtypes: bool = True) -> bool:
         """Checks if schema node's 'uses' is of specified node type.
+
         By default, it also checks for subtypes of the specified node type.
         """
         return (self.uses is node_type) or (
@@ -171,6 +172,7 @@ class GraphSchema:
 
     def has_node(self, node_type: Type, include_subtypes: bool = True) -> bool:
         """Checks if the graph schema contains a node of the specified node type.
+
         By default, it also checks for subtypes of the specified node type.
         """
         for node in self.nodes.values():
@@ -181,7 +183,7 @@ class GraphSchema:
     def count_nodes_of_a_given_type(
         self, node_type: Type, include_subtypes: bool = True
     ) -> int:
-        """Counts the number of the nodes of specified class"""
+        """Counts the number of the nodes of specified class."""
         counter = 0
         for node in self.nodes.values():
             if (node.uses is node_type) or (
@@ -353,6 +355,7 @@ class ExecutionContext:
 
     def has_node(self, node_type: Type, include_subtypes: bool = True) -> bool:
         """Checks if the graph node of the given type is present in the graph schema.
+
         By default, it also checks for subtypes of the specified node type.
         """
         return self.graph_schema.has_node(node_type, include_subtypes)
@@ -555,6 +558,7 @@ class GraphNode:
                 structlogger.error(
                     "graph.node.error_running_component",
                     node_name=self._node_name,
+                    error=str(e),
                 )
                 raise
 

rasa/engine/loader.py

@@ -1,6 +1,8 @@
 from pathlib import Path
 from typing import Tuple, Type
 
+import structlog
+
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.runner.interface import GraphRunner
 from rasa.engine.storage.storage import ModelMetadata, ModelStorage
@@ -9,6 +11,8 @@ from rasa.engine.validation import (
     validate_model_group_configuration_setup,
 )
 
+structlogger = structlog.get_logger()
+
 
 def load_predict_graph_runner(
     storage_path: Path,
@@ -30,6 +34,10 @@ def load_predict_graph_runner(
     model_storage, model_metadata = model_storage_class.from_model_archive(
         storage_path=storage_path, model_archive_path=model_archive_path
     )
+    structlogger.debug(
+        "engine.loader.load_predict_graph_runner.success",
+        model_id=model_metadata.model_id,
+    )
 
     # Components using LLMs or embeddings can reference model groups defined in
     # the endpoints.yml file for their client configurations. To ensure they will work
@@ -38,6 +46,10 @@ def load_predict_graph_runner(
     validate_model_group_configuration_setup()
     validate_model_client_configuration_setup_during_inference_time(model_metadata)
 
+    structlogger.debug(
+        "engine.loader.config.validation.success",
+        model_id=model_metadata.model_id,
+    )
     runner = graph_runner_class.create(
         graph_schema=model_metadata.predict_schema,
         model_storage=model_storage,