rasa-pro 3.14.0.dev4__py3-none-any.whl → 3.14.0.dev5__py3-none-any.whl

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 import structlog
 
@@ -11,29 +11,15 @@ from rasa.dialogue_understanding.commands.command_syntax_manager import (
     CommandSyntaxManager,
     CommandSyntaxVersion,
 )
-from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
-from rasa.dialogue_understanding.stack.frames.dialogue_stack_frame import (
-    DialogueStackFrame,
-)
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
-    AgentStackFrame,
-    AgentState,
     FlowStackFrameType,
     UserFlowStackFrame,
 )
-from rasa.dialogue_understanding.stack.frames.pattern_frame import PatternFlowStackFrame
 from rasa.dialogue_understanding.stack.utils import (
-    is_continue_interrupted_flow_active,
     top_user_flow_frame,
     user_flows_on_the_stack,
 )
-from rasa.shared.core.events import (
-    AgentInterrupted,
-    AgentResumed,
-    Event,
-    FlowInterrupted,
-    FlowResumed,
-)
+from rasa.shared.core.events import Event, FlowInterrupted
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 
@@ -85,7 +71,12 @@ class StartFlowCommand(Command):
         original_stack = original_tracker.stack
         applied_events: List[Event] = []
 
-        if self.flow not in all_flows.flow_ids:
+        if self.flow in user_flows_on_the_stack(stack):
+            structlogger.debug(
+                "start_flow_command.skip_command.already_started_flow", command=self
+            )
+            return []
+        elif self.flow not in all_flows.flow_ids:
             structlogger.debug(
                 "start_flow_command.skip_command.start_invalid_flow_id", command=self
             )
@@ -96,36 +87,9 @@ class StartFlowCommand(Command):
             original_user_frame.flow(all_flows) if original_user_frame else None
         )
 
-        # if the original top flow is the same as the flow to start, the flow is
-        # already active, do nothing
-        if original_top_flow is not None and original_top_flow.id == self.flow:
-            # in case continue_interrupted is not active, skip the already active start
-            # flow command
-            if not is_continue_interrupted_flow_active(stack):
-                return []
-
-            # if the continue interrupted flow is active, and the command generator
-            # 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)
-            return applied_events + tracker.create_stack_updated_events(stack)
-
-        # if the flow is already on the stack, resume it
-        if (
-            self.flow in user_flows_on_the_stack(stack)
-            and original_user_frame is not None
-        ):
-            # 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)
-            return self.resume_flow(tracker, stack, original_user_frame)
-
         frame_type = FlowStackFrameType.REGULAR
 
         if original_top_flow:
-            # if the original top flow is not the same as the flow to start,
-            # interrupt the current active flow
             frame_type = FlowStackFrameType.INTERRUPT
 
             if original_user_frame is not None:
@@ -135,24 +99,6 @@ class StartFlowCommand(Command):
                     )
                 )
 
-            # If there is an active agent frame, interrupt it
-            active_agent_stack_frame = stack.find_active_agent_frame()
-            if active_agent_stack_frame:
-                structlogger.debug(
-                    "start_flow_command.interrupt_agent",
-                    command=self,
-                    agent_id=active_agent_stack_frame.agent_id,
-                    frame_id=active_agent_stack_frame.frame_id,
-                    flow_id=active_agent_stack_frame.flow_id,
-                )
-                active_agent_stack_frame.state = AgentState.INTERRUPTED
-                applied_events.append(
-                    AgentInterrupted(
-                        active_agent_stack_frame.agent_id,
-                        active_agent_stack_frame.flow_id,
-                    )
-                )
-
         structlogger.debug("start_flow_command.start_flow", command=self)
         stack.push(UserFlowStackFrame(flow_id=self.flow, frame_type=frame_type))
         return applied_events + tracker.create_stack_updated_events(stack)
@@ -198,105 +144,3 @@ class StartFlowCommand(Command):
             CommandSyntaxManager.get_syntax_version(),
             mapper[CommandSyntaxManager.get_default_syntax_version()],
         )
-
-    def resume_flow(
-        self,
-        tracker: DialogueStateTracker,
-        stack: DialogueStack,
-        original_user_frame: UserFlowStackFrame,
-    ) -> List[Event]:
-        """Resumes a flow by reordering frames."""
-        applied_events: List[Event] = []
-
-        # Resume existing flow by reordering frames
-        frames_to_resume, user_frame_to_resume = self._collect_frames_to_resume(
-            stack, self.flow
-        )
-
-        # if the flow is not on the stack, do nothing
-        # this should not happen, but just in case
-        if user_frame_to_resume is None:
-            structlogger.error(
-                "start_flow_command.resume_flow.no_user_frame_to_resume",
-                command=self,
-            )
-            return []
-
-        # move the frames to the top of the stack, e.g. reorder the frames
-        # on the stack
-        stack.move_frames_to_top(frames_to_resume)
-        agent_stack_frame = next(
-            (frame for frame in frames_to_resume if isinstance(frame, AgentStackFrame)),
-            None,
-        )
-        if agent_stack_frame:
-            agent_id = agent_stack_frame.agent_id
-            applied_events.append(AgentResumed(agent_id, agent_stack_frame.flow_id))
-
-        # Create flow interruption and resumption events
-        applied_events.extend(
-            [
-                # the current active flow is interrupted
-                FlowInterrupted(
-                    original_user_frame.flow_id, original_user_frame.step_id
-                ),
-                # the flow, which was on the stack, is resumed
-                FlowResumed(user_frame_to_resume.flow_id, user_frame_to_resume.step_id),
-            ]
-        )
-
-        return applied_events + tracker.create_stack_updated_events(stack)
-
-    def _collect_frames_to_resume(
-        self, stack: DialogueStack, target_flow_id: str
-    ) -> Tuple[List[DialogueStackFrame], Optional[UserFlowStackFrame]]:
-        """Collect frames that need to be resumed for the target flow.
-
-        Args:
-            stack: The stack to collect frames from.
-            target_flow_id: The ID of the flow to resume.
-
-        Returns:
-            A tuple containing (frames_to_resume, frame_to_resume).
-        """
-        frames_to_resume: List[DialogueStackFrame] = []
-        frame_found = False
-        frame_to_resume = None
-
-        for frame in stack.frames:
-            if isinstance(frame, UserFlowStackFrame) and (
-                frame.frame_type == FlowStackFrameType.REGULAR
-                or frame.frame_type == FlowStackFrameType.INTERRUPT
-            ):
-                if frame.flow_id == target_flow_id:
-                    frames_to_resume.append(frame)
-                    frame_to_resume = frame
-                    frame_found = True
-                    continue
-                elif frame_found:
-                    break
-
-            if frame_found:
-                frames_to_resume.append(frame)
-
-        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."""
-    if not is_continue_interrupted_flow_active(stack):
-        return stack
-
-    # remove pattern_continue_interrupted from the stack
-    top_frame = stack.top()
-    while isinstance(top_frame, PatternFlowStackFrame):
-        # 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
-        # from being left on the stack when the flow is started
-        # which would prevent pattern_completed to be triggered
-        # once the user flow is completed.
-        stack.pop()
-        top_frame = stack.top()
-
-    return stack

rasa/dialogue_understanding/commands/utils.py

@@ -6,10 +6,7 @@ from rasa.dialogue_understanding.patterns.validate_slot import (
     ValidateSlotPatternFlowStackFrame,
 )
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
-from rasa.shared.core.events import (
-    Event,
-    SlotSet,
-)
+from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -106,8 +103,7 @@ def create_validate_frames_from_slot_set_events(
     Args:
         tracker: The dialogue state tracker.
         events: List of events to process.
-        validate_frames: List to collect validation frames.
-        should_break:  whether to break after the first non-SlotSet event.
+        should_break:  whether or not to break after the first non-SlotSet event.
             if True, break out of the event loop as soon as the first non-SlotSet
             event is encountered.
             if False, continue processing the events until the end.

rasa/dialogue_understanding/generator/command_parser.py

@@ -9,11 +9,9 @@ from rasa.dialogue_understanding.commands import (
     ChitChatAnswerCommand,
     ClarifyCommand,
     Command,
-    ContinueAgentCommand,
     HumanHandoffCommand,
     KnowledgeAnswerCommand,
     RepeatBotMessagesCommand,
-    RestartAgentCommand,
     SetSlotCommand,
     SkipQuestionCommand,
     StartFlowCommand,
@@ -36,8 +34,6 @@ DEFAULT_COMMANDS = [
     HumanHandoffCommand,
     ClarifyCommand,
     RepeatBotMessagesCommand,
-    ContinueAgentCommand,
-    RestartAgentCommand,
 ]
 
 

rasa/dialogue_understanding/generator/flow_retrieval.py

@@ -219,11 +219,6 @@ class FlowRetrieval(EmbeddingsHealthCheckMixin):
         if self.vector_store is not None:
             with self._model_storage.write_to(self._resource) as model_path:
                 self.vector_store.save_local(model_path)
-        else:
-            structlogger.warning(
-                "flow_retrieval.persist_vector_store.not_initialized",
-                event_info="Vector store is None, not persisted.",
-            )
 
     def _persist_config(self) -> None:
         with self._model_storage.write_to(self._resource) as path:
@@ -249,6 +244,16 @@ class FlowRetrieval(EmbeddingsHealthCheckMixin):
         )
 
         flows_to_embedd = flows.exclude_link_only_flows()
+
+        if not flows_to_embedd:
+            structlogger.debug(
+                "flow_retrieval.populate_vector_store.no_flows_to_embed",
+                event_info=(
+                    "No flows to embed in the vector store, skipping population."
+                ),
+            )
+            return
+
         embeddings = self._create_embedder(self.config)
         documents = self._generate_flow_documents(flows_to_embedd, domain)
         try:
@@ -420,10 +425,6 @@ class FlowRetrieval(EmbeddingsHealthCheckMixin):
             The top k documents with similarity scores.
         """
         if self.vector_store is None:
-            structlogger.error(
-                "flow_retrieval.query_vector_store.vector_store_not_configured",
-                event_info="Vector store is not configured",
-            )
             return []
         try:
             documents_with_scores = (

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -7,7 +7,6 @@ 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.dialogue_understanding.commands import (
     Command,
     SetSlotCommand,
@@ -32,7 +31,6 @@ from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.core.constants import SetSlotExtractor
 from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import AgentStarted
 from rasa.shared.core.flows import Flow, FlowsList, FlowStep
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
 from rasa.shared.core.slot_mappings import SlotFillingManager
@@ -227,7 +225,8 @@ class LLMBasedCommandGenerator(
 
     @lru_cache
     def compile_template(self, template: str) -> Template:
-        """Compile the prompt template and register custom filters.
+        """
+        Compile the prompt template and register custom filters.
 
         Compiling the template is an expensive operation,
         so we cache the result.
@@ -362,24 +361,20 @@ class LLMBasedCommandGenerator(
             )
 
     def prepare_flows_for_template(
-        self,
-        flows: FlowsList,
-        tracker: DialogueStateTracker,
-        add_agent_info: bool = False,
+        self, flows: FlowsList, tracker: DialogueStateTracker
     ) -> List[Dict[str, Any]]:
         """Format data on available flows for insertion into the prompt template.
 
         Args:
             flows: The flows available to the user.
             tracker: The tracker containing the current state of the conversation.
-            add_agent_info: Whether to add agent info to flows or not.
 
         Returns:
             The inputs for the prompt template.
         """
-        result: List[Dict[str, Any]] = []
+        result = []
         for flow in flows.user_flows:
-            slots_with_info: List[Dict[str, Any]] = [
+            slots_with_info = [
                 {
                     "name": q.collect,
                     "description": q.description,
@@ -388,46 +383,13 @@ class LLMBasedCommandGenerator(
                 for q in flow.get_collect_steps()
                 if self.is_extractable(q, tracker)
             ]
-
-            agent_info: List[Dict[str, Any]] = []
-            if add_agent_info:
-                # add information about agents that have been started for this flow
-                agent_events = [
-                    event
-                    for event in tracker.events
-                    if isinstance(event, AgentStarted) and event.flow_id == flow.id
-                ]
-                available_agents = [
-                    AvailableAgents.get_agent_config(event.agent_id)
-                    for event in agent_events
-                ]
-                if available_agents:
-                    agent_info = [
-                        {
-                            "name": available_agent.agent.name,
-                            "description": available_agent.agent.description,
-                        }
-                        for available_agent in available_agents
-                        if available_agent is not None
-                    ]
-
-            if agent_info:
-                result.append(
-                    {
-                        "name": flow.id,
-                        "description": flow.description,
-                        "slots": slots_with_info,
-                        "agent_info": agent_info,
-                    }
-                )
-            else:
-                result.append(
-                    {
-                        "name": flow.id,
-                        "description": flow.description,
-                        "slots": slots_with_info,
-                    }
-                )
+            result.append(
+                {
+                    "name": flow.id,
+                    "description": flow.description,
+                    "slots": slots_with_info,
+                }
+            )
         return result
 
     @staticmethod

rasa/dialogue_understanding/generator/llm_command_generator.py

@@ -1,7 +1,7 @@
 from typing import Any, Dict, List, Optional, Text, Union
 
 import structlog
-from deprecated import deprecated  # type: ignore[import-untyped]
+from deprecated import deprecated  # type: ignore[import]
 
 from rasa.dialogue_understanding.generator.single_step.single_step_llm_command_generator import (  # noqa: E501
     SingleStepLLMCommandGenerator,

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -2,7 +2,7 @@ import importlib.resources
 from typing import Any, Dict, List, Optional, Text, Tuple, Union
 
 import structlog
-from deprecated import deprecated  # type: ignore[import-untyped]
+from deprecated import deprecated  # type: ignore[import]
 from jinja2 import Template
 
 import rasa.shared.utils.io

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,
-        }