rasa-pro 3.14.0.dev1__py3-none-any.whl → 3.14.0.dev20250818__py3-none-any.whl

rasa/dialogue_understanding/generator/single_step/compact_llm_command_generator.py

@@ -45,30 +45,29 @@ DEFAULT_LLM_CONFIG = {
     TIMEOUT_CONFIG_KEY: 7,
 }
 
-# TODO: only load the agent prompt template in cases where agents are actually used
 MODEL_PROMPT_MAPPER = {
     f"{OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
-        "agent_command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+        "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
     ),
     f"{AZURE_OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
-        "agent_command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+        "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
     ),
     f"{AWS_BEDROCK_PROVIDER}/anthropic.{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}-v1:0": (
-        "agent_command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
+        "command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
     ),
     f"{ANTHROPIC_PROVIDER}/{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}": (
-        "agent_command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
+        "command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
     ),
 }
 
 # When model is not configured, then we use the default prompt template
 DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
-    "agent_command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+    "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
 )
 # When the configured model is not found in the model prompt mapper, then we use the
 # fallback prompt template
 FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
-    "agent_command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+    "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
 )
 
 

rasa/dialogue_understanding/generator/single_step/search_ready_llm_command_generator.py

@@ -44,26 +44,25 @@ DEFAULT_LLM_CONFIG = {
     TIMEOUT_CONFIG_KEY: 7,
 }
 
-# TODO: only load the agent prompt template in cases where agents are actually used
 DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
-    "agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
+    "command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
 )
 FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
-    "agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
+    "command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
 )
 MODEL_PROMPT_MAPPER = {
     f"{OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
-        "agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
+        "command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
     ),
     f"{AZURE_OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
-        "agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
+        "command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
     ),
     f"{AWS_BEDROCK_PROVIDER}/anthropic."
     f"{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}-v1:0": (
-        "agent_command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2"
+        "command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2"
     ),
     f"{ANTHROPIC_PROVIDER}/{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}": (
-        "agent_command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2"
+        "command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2"
     ),
 }
 

rasa/dialogue_understanding/generator/single_step/single_step_based_llm_command_generator.py

@@ -5,7 +5,6 @@ from typing import Any, Dict, List, Literal, Optional, Text
 import structlog
 
 import rasa.shared.utils.io
-from rasa.core.available_agents import AvailableAgents
 from rasa.dialogue_understanding.commands import (
     CannotHandleCommand,
     Command,
@@ -45,7 +44,6 @@ from rasa.shared.constants import (
     PROMPT_TEMPLATE_CONFIG_KEY,
     ROUTE_TO_CALM_SLOT,
 )
-from rasa.shared.core.events import AgentCompleted
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import ProviderClientAPIException
@@ -398,15 +396,13 @@ class SingleStepBasedLLMCommandGenerator(LLMBasedCommandGenerator, ABC):
             current_slot_allowed_values = allowed_values_for_slot(
                 tracker.slots.get(current_slot)
             )
-        current_conversation = tracker_as_readable_transcript(
-            tracker, highlight_agent_turns=True
-        )
+        current_conversation = tracker_as_readable_transcript(tracker)
         latest_user_message = sanitize_message_for_prompt(message.get(TEXT))
         current_conversation += f"\nUSER: {latest_user_message}"
 
         inputs = {
             "available_flows": self.prepare_flows_for_template(
-                startable_flows, tracker, add_agent_info=True
+                startable_flows, tracker
             ),
             "current_conversation": current_conversation,
             "flow_slots": flow_slots,
@@ -416,10 +412,6 @@ class SingleStepBasedLLMCommandGenerator(LLMBasedCommandGenerator, ABC):
             "current_slot_type": current_slot_type,
             "current_slot_allowed_values": current_slot_allowed_values,
             "user_message": latest_user_message,
-            "active_agent": self._get_active_agent(tracker, top_flow.id)
-            if top_flow
-            else None,
-            "completed_agents": self._get_completed_agents(tracker),
         }
 
         return self.compile_template(self.prompt_template).render(**inputs)
@@ -467,34 +459,3 @@ class SingleStepBasedLLMCommandGenerator(LLMBasedCommandGenerator, ABC):
     ) -> Optional[str]:
         """Get the prompt template from the config or the default prompt template."""
         pass
-
-    def _get_active_agent(
-        self, tracker: DialogueStateTracker, active_flow_id: str
-    ) -> Optional[Dict[str, Any]]:
-        agent_frame = tracker.stack.find_active_agent_stack_frame_for_flow(
-            active_flow_id
-        )
-        if agent_frame:
-            return self._get_agent_info(agent_frame.agent_id)
-        return None
-
-    def _get_completed_agents(
-        self, tracker: DialogueStateTracker
-    ) -> List[Dict[str, Any]]:
-        completed_agents: List[Dict[str, Any]] = []
-        for event in reversed(tracker.events):
-            if isinstance(event, AgentCompleted):
-                agent_info = self._get_agent_info(event.agent_id)
-                if agent_info:
-                    completed_agents.append(agent_info)
-        return completed_agents
-
-    def _get_agent_info(self, agent_id: str) -> Optional[Dict[str, Any]]:
-        agent_config = AvailableAgents.get_agent_config(agent_id)
-        if agent_config is None:
-            return None
-
-        return {
-            "name": agent_config.agent.name,
-            "description": agent_config.agent.description,
-        }

rasa/dialogue_understanding/patterns/continue_interrupted.py

@@ -1,31 +1,14 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict
 
-from rasa.core.actions.action import Action
-from rasa.core.channels import OutputChannel
-from rasa.core.nlg import NaturalLanguageGenerator
 from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
-from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.constants import (
-    ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE,
-    ACTION_CANCEL_INTERRUPTED_FLOW,
-    ACTION_CONTINUE_INTERRUPTED_FLOW,
-    ACTION_SET_INTERRUPTED_FLOWS,
-)
-from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import Event, SlotSet
-from rasa.shared.core.trackers import DialogueStateTracker
 
 FLOW_PATTERN_CONTINUE_INTERRUPTED = (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX + "continue_interrupted"
 )
-INTERRUPTED_FLOWS_SLOT = "interrupted_flows"
-INTERRUPTED_FLOW_TO_CONTINUE_SLOT = "interrupted_flow_to_continue"
-MULTIPLE_FLOWS_INTERRUPTED_SLOT = "multiple_flows_interrupted"
-CONFIRMATION_CONTINUE_INTERRUPTED_FLOW_SLOT = "confirmation_continue_interrupted_flow"
 
 
 @dataclass
@@ -66,148 +49,3 @@ class ContinueInterruptedPatternFlowStackFrame(PatternFlowStackFrame):
             and self.step_id == other.step_id
             and self.previous_flow_name == other.previous_flow_name
         )
-
-
-class ActionSetInterruptedFlows(Action):
-    def name(self) -> str:
-        return ACTION_SET_INTERRUPTED_FLOWS
-
-    async def run(
-        self,
-        output_channel: OutputChannel,
-        nlg: NaturalLanguageGenerator,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        metadata: Optional[Dict[Text, Any]] = None,
-    ) -> list[Event]:
-        interrupted_flows_set = set()
-        interrupted_user_flow_stack_frames = tracker.stack.get_all_user_flow_frames()
-
-        for frame in interrupted_user_flow_stack_frames:
-            interrupted_flows_set.add(frame.flow_id)
-
-        interrupted_flows = list(interrupted_flows_set)
-        multiple_flows_interrupted = len(interrupted_flows) > 1
-
-        return [
-            SlotSet(INTERRUPTED_FLOWS_SLOT, interrupted_flows),
-            SlotSet(MULTIPLE_FLOWS_INTERRUPTED_SLOT, multiple_flows_interrupted),
-        ]
-
-
-class ActionAskInterruptedFlowToContinue(Action):
-    def name(self) -> str:
-        return ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE
-
-    async def run(
-        self,
-        output_channel: OutputChannel,
-        nlg: NaturalLanguageGenerator,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        metadata: Optional[Dict[Text, Any]] = None,
-    ) -> List[Event]:
-        interrupted_flows = tracker.get_slot(INTERRUPTED_FLOWS_SLOT) or []
-
-        buttons = [
-            {
-                "title": flow_id,
-                "payload": f'/SetSlots{{"{INTERRUPTED_FLOW_TO_CONTINUE_SLOT}": '
-                f'"{flow_id}"}}',
-            }
-            for flow_id in interrupted_flows or []
-        ]
-        buttons.append(
-            {
-                "title": "None of them",
-                "payload": f'/SetSlots{{"{INTERRUPTED_FLOW_TO_CONTINUE_SLOT}": '
-                f'"none"}}',
-            }
-        )
-
-        await output_channel.send_text_with_buttons(
-            tracker.sender_id,
-            "You previously started several other tasks. "
-            "Would you like to resume any of them?",
-            buttons=buttons,
-        )
-
-        return []
-
-
-class ActionContinueInterruptedFlow(Action):
-    def name(self) -> str:
-        return ACTION_CONTINUE_INTERRUPTED_FLOW
-
-    async def run(
-        self,
-        output_channel: OutputChannel,
-        nlg: NaturalLanguageGenerator,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        metadata: Optional[Dict[Text, Any]] = None,
-    ) -> List[Event]:
-        from rasa.dialogue_understanding.commands import StartFlowCommand
-
-        # get all necessary slot values
-        multiple = tracker.get_slot(MULTIPLE_FLOWS_INTERRUPTED_SLOT)
-        selected_flow = tracker.get_slot(INTERRUPTED_FLOW_TO_CONTINUE_SLOT)
-        interrupted_flows = tracker.get_slot(INTERRUPTED_FLOWS_SLOT) or []
-
-        original_user_frame = top_user_flow_frame(tracker.stack)
-
-        # case of multiple interrupted flows, where the user selected a flow to continue
-        if multiple:
-            flow_id = selected_flow if selected_flow else None
-        # case of single interrupted flow, so there is only one flow to continue
-        else:
-            flow_id = interrupted_flows[0] if interrupted_flows else None
-
-        event_list = []
-        if flow_id:
-            # TODO: refactor to avoid creating a StartFlowCommand first
-            # resume the flow with the provided flow id
-            start_flow_command = StartFlowCommand(flow_id)
-            event_list = start_flow_command.resume_flow(
-                tracker, tracker.stack, original_user_frame
-            )
-        else:
-            await output_channel.send_text_message(
-                tracker.sender_id,
-                "You haven't selected a valid task to resume. "
-                "Please specify the task you would like to continue.",
-            )
-
-        return event_list
-
-
-class ActionCancelInterruptedFlow(Action):
-    def name(self) -> str:
-        return ACTION_CANCEL_INTERRUPTED_FLOW
-
-    async def run(
-        self,
-        output_channel: OutputChannel,
-        nlg: NaturalLanguageGenerator,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        metadata: Optional[Dict[Text, Any]] = None,
-    ) -> List[Event]:
-        from rasa.dialogue_understanding.commands import CancelFlowCommand
-
-        interrupted_flows = tracker.get_slot(INTERRUPTED_FLOWS_SLOT) or []
-
-        event_list = []
-        for flow_id in interrupted_flows:
-            # TODO: refactor to avoid creating a CancelFlowCommand first
-            cancel_flow_command = CancelFlowCommand()
-            event_list.extend(
-                cancel_flow_command.cancel_flow(tracker, tracker.stack, flow_id)
-            )
-
-        return event_list + [
-            SlotSet(INTERRUPTED_FLOWS_SLOT, None),
-            SlotSet(INTERRUPTED_FLOW_TO_CONTINUE_SLOT, None),
-            SlotSet(MULTIPLE_FLOWS_INTERRUPTED_SLOT, None),
-            SlotSet(CONFIRMATION_CONTINUE_INTERRUPTED_FLOW_SLOT, None),
-        ]

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -1,17 +1,6 @@
 version: "3.1"
 responses:
 
-  utter_ask_continue_interrupted_flow:
-    - text: "Would you like to continue with {{ context.previous_flow_name }}?"
-      metadata:
-        rephrase: True
-        template: jinja
-      buttons:
-        - title: "Yes"
-          payload: "/SetSlots(confirmation_continue_interrupted_flow=true)"
-        - title: "No"
-          payload: "/SetSlots(confirmation_continue_interrupted_flow=false)"
-
   utter_ask_rephrase:
     - text: I’m sorry I am unable to understand you, could you please rephrase?
 
@@ -64,6 +53,12 @@ responses:
         rephrase: True
         template: jinja
 
+  utter_flow_continue_interrupted:
+    - text: "Let's continue with {{ context.previous_flow_name }}."
+      metadata:
+        rephrase: True
+        template: jinja
+
   utter_free_chitchat_response:
     - text: "Sorry, I'm not able to answer that right now."
       metadata:
@@ -129,19 +124,6 @@ slots:
     type: float
     initial_value: 0.0
     max_value: 1000000
-  interrupted_flows:
-    type: list
-  multiple_flows_interrupted:
-    type: bool
-    initial_value: false
-  confirmation_continue_interrupted_flow:
-      type: bool
-      initial_value: null
-      mappings:
-        - type: controlled
-  interrupted_flow_to_continue:
-    type: text
-    initial_value: null
 
 flows:
   pattern_cancel_flow:
@@ -228,33 +210,7 @@ flows:
     description: Conversation repair flow for managing when users switch between different flows
     name: pattern continue interrupted
     steps:
-      - action: action_set_interrupted_flows
-      - noop: true
-        next:
-          - if: slots.multiple_flows_interrupted
-            then:
-              - collect: interrupted_flow_to_continue
-                description: "Fill this slot with the name of the flow the user wants to continue. If the user does not want to continue any of the interrupted flows, fill this slot with 'none'."
-                next:
-                  - if: slots.interrupted_flow_to_continue != "none"
-                    then:
-                      - action: action_continue_interrupted_flow
-                        next: END
-                  - else:
-                      - action: action_cancel_interrupted_flow
-                        next: END
-          - else:
-            - collect: confirmation_continue_interrupted_flow
-              description: "If the user wants to continue the interrupted flow, fill this slot with true. If the user does not want to continue the interrupted flow, fill this slot with false."
-              utter: utter_ask_continue_interrupted_flow
-              next:
-                - if: slots.confirmation_continue_interrupted_flow
-                  then:
-                    - action: action_continue_interrupted_flow
-                      next: END
-                - else:
-                    - action: action_cancel_interrupted_flow
-                      next: END
+      - action: utter_flow_continue_interrupted
 
   pattern_correction:
     description: Conversation repair flow for managing user input changes or error corrections

rasa/dialogue_understanding/stack/dialogue_stack.py

@@ -8,13 +8,6 @@ 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
 
@@ -98,42 +91,6 @@ 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.
 
@@ -152,7 +109,7 @@ class DialogueStack:
         """Returns the topmost frame from the stack.
 
         Args:
-            ignore: The ID of the flow to ignore. Picks the top most
+            ignore_frame: The ID of the flow to ignore. Picks the top most
                 frame that has a different flow ID.
 
         Returns:
@@ -179,8 +136,7 @@ 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)
@@ -221,80 +177,3 @@ 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
-
-    def get_all_user_flow_frames(
-        self, ignore_call_and_link_frames: bool = True
-    ) -> List[UserFlowStackFrame]:
-        """Get all user flow frames from the dialogue stack.
-
-        Args:
-            ignore_call_and_link_frames: Whether to ignore user frames of type `call`
-                and `link`. By default, these frames are ignored.
-
-        Returns:
-            A list of all user flow frames in the dialogue stack.
-        """
-        return [
-            frame
-            for frame in self.frames
-            if isinstance(frame, UserFlowStackFrame)
-            and (
-                not ignore_call_and_link_frames
-                or (
-                    frame.frame_type != FlowStackFrameType.CALL
-                    and frame.frame_type != FlowStackFrameType.LINK
-                )
-            )
-        ]

rasa/dialogue_understanding/stack/frames/flow_stack_frame.py

@@ -94,18 +94,6 @@ 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
@@ -183,48 +171,3 @@ 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

@@ -198,9 +198,8 @@ 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.
-
-    Collect steps that have to be asked before filling are not considered.
+    """Get all collect steps that are part of the current flow, without
+    considering the collect steps that has to be asked before filling.
 
     Args:
         dialogue_stack: The dialogue stack.