rasa-pro 3.13.0.dev20250612__py3-none-any.whl → 3.13.0.dev20250613__py3-none-any.whl

rasa/__main__.py

@@ -143,9 +143,6 @@ def main(raw_arguments: Optional[List[str]] = None) -> None:
             if not is_studio_command:
                 plugin_manager().hook.init_telemetry(endpoints_file=endpoints_file)
                 plugin_manager().hook.init_managers(endpoints_file=endpoints_file)
-                plugin_manager().hook.init_anonymization_pipeline(
-                    endpoints_file=endpoints_file
-                )
 
             cmdline_arguments.func(cmdline_arguments)
         elif hasattr(cmdline_arguments, "version"):

rasa/api.py

@@ -38,7 +38,7 @@ def run(
     """
     import rasa.core.run
     import rasa.shared.utils.common
-    from rasa.core.utils import AvailableEndpoints
+    from rasa.core.available_endpoints import AvailableEndpoints
     from rasa.shared.constants import DOCS_BASE_URL
     from rasa.shared.utils.cli import print_warning
 

rasa/cli/dialogue_understanding_test.py

@@ -16,9 +16,9 @@ from rasa.cli.arguments.default_arguments import (
     add_remote_storage_param,
 )
 from rasa.core.agent import Agent
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.exceptions import AgentNotReady
 from rasa.core.processor import MessageProcessor
-from rasa.core.utils import AvailableEndpoints
 from rasa.dialogue_understanding.commands import Command
 from rasa.dialogue_understanding.generator import LLMBasedCommandGenerator
 from rasa.dialogue_understanding.generator.command_parser import DEFAULT_COMMANDS

rasa/cli/e2e_test.py

@@ -18,8 +18,8 @@ from rasa.cli.arguments.default_arguments import (
     add_model_param,
     add_remote_storage_param,
 )
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.exceptions import AgentNotReady
-from rasa.core.utils import AvailableEndpoints
 from rasa.e2e_test.aggregate_test_stats_calculator import (
     AggregateTestStatsCalculator,
 )

rasa/cli/evaluate.py

@@ -6,10 +6,10 @@ import rasa.cli.arguments.evaluate as arguments
 import rasa.shared.utils.cli
 from rasa import telemetry
 from rasa.cli import SubParsersAction
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.evaluation.marker_base import Marker, OperatorMarker
 from rasa.core.evaluation.marker_tracker_loader import MarkerTrackerLoader
 from rasa.core.tracker_stores.tracker_store import TrackerStore
-from rasa.core.utils import AvailableEndpoints
 from rasa.shared.core.domain import Domain
 
 STATS_OVERALL_SUFFIX = "-overall.csv"

rasa/cli/export.py

@@ -16,10 +16,10 @@ from rasa.shared.constants import DOCS_URL_EVENT_BROKERS, DOCS_URL_TRACKER_STORE
 from rasa.shared.exceptions import RasaException
 
 if typing.TYPE_CHECKING:
+    from rasa.core.available_endpoints import AvailableEndpoints
     from rasa.core.brokers.broker import EventBroker
     from rasa.core.exporter import Exporter
     from rasa.core.tracker_stores.tracker_store import TrackerStore
-    from rasa.core.utils import AvailableEndpoints
 
 logger = logging.getLogger(__name__)
 

rasa/cli/llm_fine_tuning.py

@@ -20,8 +20,8 @@ from rasa.cli.e2e_test import (
     read_test_cases,
     validate_model_path,
 )
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.exceptions import AgentNotReady
-from rasa.core.utils import AvailableEndpoints
 from rasa.dialogue_understanding.generator.llm_based_command_generator import (
     LLMBasedCommandGenerator,
 )
@@ -208,10 +208,7 @@ def prepare_llm_fine_tuning_data(args: argparse.Namespace) -> None:
         sys.exit(0)
 
     flows = asyncio.run(e2e_test_runner.agent.processor.get_flows())
-    llm_command_generator_config = _get_llm_command_generator_config(e2e_test_runner)
-    llm_command_generator: Type[LLMBasedCommandGenerator] = _get_llm_command_generator(
-        e2e_test_runner
-    )
+    _validate_llm_command_generator_present(e2e_test_runner)
 
     # set up storage context
     storage_context = create_storage_context(StorageType.FILE, output_dir)
@@ -242,11 +239,11 @@ def prepare_llm_fine_tuning_data(args: argparse.Namespace) -> None:
             rephrase_config,
             args.num_rephrases,
             flows,
-            llm_command_generator,
-            llm_command_generator_config,
+            e2e_test_runner.agent,
             storage_context,
         )
     )
+
     statistics["num_passing_rephrased_user_messages"] = sum(
         [conversation.get_number_of_rephrases(True) for conversation in conversations]
     )
@@ -257,7 +254,11 @@ def prepare_llm_fine_tuning_data(args: argparse.Namespace) -> None:
 
     # 3. create fine-tuning dataset
     log_start_of_module("LLM Data Preparation")
-    llm_fine_tuning_data = convert_to_fine_tuning_data(conversations, storage_context)
+    llm_fine_tuning_data = asyncio.run(
+        convert_to_fine_tuning_data(
+            conversations, storage_context, e2e_test_runner.agent
+        )
+    )
     statistics["num_ft_data_points"] = len(llm_fine_tuning_data)
     log_end_of_module("LLM Data Preparation", statistics)
 
@@ -311,9 +312,9 @@ def _get_llm_command_generator_config(e2e_test_runner: E2ETestRunner) -> Dict[st
     sys.exit(1)
 
 
-def _get_llm_command_generator(
+def _validate_llm_command_generator_present(
     e2e_test_runner: E2ETestRunner,
-) -> Type[LLMBasedCommandGenerator]:
+) -> None:
     train_schema = e2e_test_runner.agent.processor.model_metadata.train_schema  # type: ignore
 
     for _, node in train_schema.nodes.items():
@@ -322,7 +323,7 @@ def _get_llm_command_generator(
         ) and not node.matches_type(
             MultiStepLLMCommandGenerator, include_subtypes=True
         ):
-            return cast(Type[LLMBasedCommandGenerator], node.uses)
+            return
 
     rasa.shared.utils.cli.print_error(
         "The provided model is not trained using 'SingleStepLLMCommandGenerator' or "

rasa/cli/project_templates/defaults.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import tempfile
+from typing import Any, Dict, List, Optional, Text
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from rasa.dialogue_understanding.patterns.domain_for_patterns import (
+    ContextField,
+    generate_domain_for_default_patterns,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.importers.importer import FlowSyncImporter, TrainingDataImporter
+from rasa.shared.utils.llm import SystemPrompts, get_system_default_prompts
+from rasa.shared.utils.yaml import read_yaml, write_yaml
+
+
+class Response(BaseModel):
+    text: str = Field(..., description="The human-readable response string.")
+    metadata: Optional[Dict[str, Any]] = Field(
+        None, description="Optional metadata used by Rasa at runtime."
+    )
+
+
+class Slot(BaseModel):
+    name: Text = Field(..., description="Name of the slot.")
+    type: Text = Field(..., description="Type of the slot.")
+    mappings: Optional[List[Dict[str, Any]]] = Field(
+        None, description="Mappings for the slot."
+    )
+    model_config = ConfigDict(extra="allow")
+
+
+class PatternFlow(BaseModel):
+    description: str = Field(..., description="Description of the flow.")
+    name: Text = Field(..., description="Name of the flow.")
+    steps: List[Any] = Field(..., description="List of steps in the flow.")
+    nlu_trigger: Optional[Any] = Field(None, description="NLU trigger for the flow.")
+    persisted_slots: Optional[List[Text]] = Field(None, description="Slots to persist.")
+
+
+class PatternDefaults(BaseModel):
+    """Content of `default_flows_for_patterns.yml` after it is loaded from disk."""
+
+    responses: Dict[Text, List[Response]] = Field(
+        default_factory=dict,
+        description="Response templates available out-of-the-box.",
+    )
+    slots: Dict[Text, Slot] = Field(
+        default_factory=dict, description="Slot definitions used by the default flows."
+    )
+    flows: Dict[Text, PatternFlow] = Field(
+        default_factory=dict, description="Default flows (conversation patterns)."
+    )
+
+
+class RasaDefaults(PatternDefaults):
+    """Full set of defaults that Rasa injects when a project is created."""
+
+    prompts: SystemPrompts = Field(..., description="Built-in system prompts.")
+    actions: List[Text] = Field(..., description="Default actions shipped by Rasa.")
+    intents: List[Text] = Field(..., description="Default intents shipped by Rasa.")
+    contexts: Dict[Text, ContextField] = Field(
+        ..., description="Context fields that can appear on the conversation stack."
+    )
+
+    class Config:
+        extra = "forbid"
+        validate_assignment = True
+
+
+def _get_domain_from_importer(config: Dict[Text, Any]) -> Domain:
+    """Get the domain from the TrainingDataImporter.
+
+    Args:
+        config: The config.yml file data.
+
+    Returns:
+        A Domain object .
+    """
+    with tempfile.NamedTemporaryFile("w+", suffix=".yml") as tmp:
+        write_yaml(config, tmp.name)
+        importer = TrainingDataImporter.load_from_config(
+            domain_path=FlowSyncImporter.default_pattern_path(),
+            config_path=tmp.name,
+        )
+        return importer.get_domain()
+
+
+def get_pattern_defaults(config: Dict[Text, Any]) -> PatternDefaults:
+    """Get the default flows, responses and slots for patterns.
+
+    Args:
+        config: The config.yml file data.
+
+    Returns:
+        A PatternDefaults object containing the defaults.
+    """
+    domain = _get_domain_from_importer(config)
+    domain_dict = domain.as_dict()
+
+    # Make sure all the slots are exported, including the builtin slots
+    domain_dict["slots"] = {slot.name: slot.to_dict() for slot in domain.slots}
+
+    return PatternDefaults(**domain_dict)
+
+
+def get_rasa_defaults(config_yaml: Text, endpoints_yaml: Text) -> RasaDefaults:
+    """Get the default values for a Rasa project.
+
+    Args:
+        config_yaml: The content of the config.yml file.
+        endpoints_yaml: The content of the endpoints.yml file.
+
+    Returns:
+        A RasaDefaults object containing the default values for the project.
+    """
+    config = read_yaml(config_yaml)
+    endpoints = read_yaml(endpoints_yaml)
+
+    prompts = get_system_default_prompts(config, endpoints)
+    pattern_domain = generate_domain_for_default_patterns()
+    pattern_defaults = get_pattern_defaults(config)
+
+    return RasaDefaults(
+        prompts=prompts,
+        actions=pattern_domain.actions,
+        intents=pattern_domain.intents,
+        contexts=pattern_domain.contexts,
+        responses=pattern_defaults.responses,
+        slots=pattern_defaults.slots,
+        flows=pattern_defaults.flows,
+    )

rasa/cli/run.py

@@ -109,7 +109,7 @@ def run(args: argparse.Namespace) -> None:
     # configured
 
     import rasa.model
-    from rasa.core.utils import AvailableEndpoints
+    from rasa.core.available_endpoints import AvailableEndpoints
 
     # start server if remote storage is configured
     if args.remote_storage is not None:

rasa/cli/studio/link.py

@@ -0,0 +1,53 @@
+import argparse
+from typing import List, Text
+
+from rasa.cli import SubParsersAction
+from rasa.cli.studio.upload import (
+    add_config_param,
+    add_data_param,
+    add_domain_param,
+    add_endpoint_param,
+)
+from rasa.shared.constants import (
+    DEFAULT_DOMAIN_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+from rasa.studio.link import handle_link
+
+
+def add_subparser(
+    subparsers: SubParsersAction,
+    parents: List[argparse.ArgumentParser],
+    domain: Text = DEFAULT_DOMAIN_PATH,
+) -> None:
+    """Register the `rasa studio link` command with the main CLI.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+        domain: Path to the assistant's domain file.
+    """
+    link_parser = subparsers.add_parser(
+        "link",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Link the current project to an existing Rasa Studio assistant.",
+    )
+
+    link_parser.add_argument(
+        "assistant_name",
+        nargs=1,
+        type=str,
+        help="Name of the assistant in Rasa Studio.",
+    )
+
+    add_domain_param(link_parser, domain)
+    add_data_param(link_parser)
+    add_config_param(link_parser)
+    add_endpoint_param(
+        link_parser,
+        "Configuration file for the model endpoints.",
+        default=DEFAULT_ENDPOINTS_PATH,
+    )
+    link_parser.set_defaults(func=handle_link)

rasa/cli/studio/pull.py

@@ -0,0 +1,78 @@
+import argparse
+from typing import List, Text
+
+from rasa.cli import SubParsersAction
+from rasa.cli.arguments.default_arguments import (
+    add_config_param,
+    add_endpoint_param,
+)
+from rasa.cli.studio.upload import add_data_param, add_domain_param
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_DOMAIN_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+from rasa.studio.pull import (
+    handle_pull,
+    handle_pull_config,
+    handle_pull_endpoints,
+)
+
+
+def add_subparser(
+    subparsers: SubParsersAction,
+    parents: List[argparse.ArgumentParser],
+    domain: Text = DEFAULT_DOMAIN_PATH,
+) -> None:
+    """Register `rasa studio pull` and its sub-commands.
+
+    Args:
+        subparsers: subparser we are going to attach to
+        parents: Parent parsers, needed to ensure tree structure in argparse
+        domain: Path to the assistant's domain file.
+    """
+    pull_parser = subparsers.add_parser(
+        "pull",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Pull assistant data from Rasa Studio.",
+    )
+    pull_subparsers = pull_parser.add_subparsers()
+
+    # Arguments for pulling configuration only
+    config_parser = pull_subparsers.add_parser(
+        "config",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Pull only the assistant configuration file.",
+    )
+    add_config_param(config_parser, default=DEFAULT_CONFIG_PATH)
+    config_parser.set_defaults(func=handle_pull_config)
+
+    # Arguments for pulling endpoints only
+    endpoints_parser = pull_subparsers.add_parser(
+        "endpoints",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Pull only the endpoints configuration file.",
+    )
+    add_endpoint_param(
+        endpoints_parser,
+        "Configuration file for the model endpoints.",
+        default=DEFAULT_ENDPOINTS_PATH,
+    )
+    endpoints_parser.set_defaults(func=handle_pull_endpoints)
+
+    # Arguments for pulling the whole assistant data
+    add_domain_param(pull_parser, domain)
+    add_data_param(pull_parser)
+    add_config_param(pull_parser, default=DEFAULT_CONFIG_PATH)
+    add_endpoint_param(
+        pull_parser,
+        "Configuration file for the model endpoints.",
+        default=DEFAULT_ENDPOINTS_PATH,
+    )
+    pull_parser.set_defaults(func=handle_pull)

rasa/cli/studio/push.py

@@ -0,0 +1,78 @@
+import argparse
+from typing import List, Text
+
+from rasa.cli import SubParsersAction
+from rasa.cli.studio.upload import (
+    add_config_param,
+    add_data_param,
+    add_domain_param,
+    add_endpoint_param,
+)
+from rasa.shared.constants import (
+    DEFAULT_DOMAIN_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+from rasa.studio.push import (
+    handle_push,
+    handle_push_config,
+    handle_push_endpoints,
+)
+
+
+def add_subparser(
+    subparsers: SubParsersAction,
+    parents: List[argparse.ArgumentParser],
+    domain: Text = DEFAULT_DOMAIN_PATH,
+) -> None:
+    """Register the `rasa studio push` command and its sub-commands.
+
+    Args:
+        subparsers: The subparsers to add the command to.
+        parents: Parent parsers, needed to ensure tree structure in argparse
+        domain: Path to the assistant's domain file.
+    """
+    push_parser = subparsers.add_parser(
+        "push",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Push assistant data to Rasa Studio.",
+    )
+    push_subparsers = push_parser.add_subparsers()
+
+    # Arguments for pushing configuration only
+    config_parser = push_subparsers.add_parser(
+        "config",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Push only the assistant configuration file.",
+    )
+    add_config_param(config_parser)
+    config_parser.set_defaults(func=handle_push_config)
+
+    # Arguments for pushing endpoints only
+    endpoints_parser = push_subparsers.add_parser(
+        "endpoints",
+        parents=parents,
+        conflict_handler="resolve",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        help="Push ONLY the endpoints configuration file.",
+    )
+    add_endpoint_param(
+        endpoints_parser,
+        "Configuration file for the model endpoints.",
+        default=DEFAULT_ENDPOINTS_PATH,
+    )
+    endpoints_parser.set_defaults(func=handle_push_endpoints)
+
+    # Arguments for pushing the whole assistant data
+    add_domain_param(push_parser, domain)
+    add_data_param(push_parser)
+    add_config_param(push_parser)
+    add_endpoint_param(
+        push_parser,
+        "Configuration file for the model endpoints.",
+        default=DEFAULT_ENDPOINTS_PATH,
+    )
+    push_parser.set_defaults(func=handle_push)

rasa/cli/studio/studio.py

@@ -5,10 +5,15 @@ from urllib.parse import ParseResult, urlparse
 import questionary
 
 import rasa.cli.studio.download
+import rasa.cli.studio.link
+import rasa.cli.studio.pull
+import rasa.cli.studio.push
 import rasa.cli.studio.train
 import rasa.cli.studio.upload
 import rasa.shared.utils.cli
 from rasa.cli import SubParsersAction
+from rasa.cli.utils import get_validated_path
+from rasa.shared.constants import DEFAULT_DOMAIN_PATH, DEFAULT_DOMAIN_PATHS
 from rasa.studio.auth import StudioAuth
 from rasa.studio.config import StudioConfig
 
@@ -33,6 +38,13 @@ def add_subparser(
     rasa.cli.studio.upload.add_subparser(studio_subparsers, parents)
     rasa.cli.studio.download.add_subparser(studio_subparsers, parents)
 
+    domain = get_validated_path(
+        DEFAULT_DOMAIN_PATH, "domain", DEFAULT_DOMAIN_PATHS, none_is_valid=True
+    )
+    rasa.cli.studio.link.add_subparser(studio_subparsers, parents, domain)
+    rasa.cli.studio.push.add_subparser(studio_subparsers, parents, domain)
+    rasa.cli.studio.pull.add_subparser(studio_subparsers, parents, domain)
+
     _add_config_subparser(studio_subparsers, parents)
     _add_login_subparser(studio_subparsers, parents)
 

rasa/cli/studio/upload.py

@@ -54,3 +54,11 @@ def set_upload_arguments(parser: argparse.ArgumentParser) -> None:
         type=str,
         help="Name of intents to upload to Rasa Studio",
     )
+
+    parser.add_argument(
+        "assistant_name",
+        default=None,
+        nargs="?",
+        type=str,
+        help="Name of the assistant on Rasa Studio",
+    )

rasa/cli/train.py

@@ -11,7 +11,7 @@ import rasa.cli.utils
 import rasa.core.utils
 import rasa.utils.common
 from rasa.cli import SubParsersAction
-from rasa.core import ContextualResponseRephraser
+from rasa.core.nlg.contextual_response_rephraser import ContextualResponseRephraser
 from rasa.core.nlg.generator import NaturalLanguageGenerator
 from rasa.core.train import do_compare_training
 from rasa.engine.validation import validate_api_type_config_key_usage

rasa/cli/utils.py

@@ -104,7 +104,7 @@ def get_validated_path(
                 parameter=parameter,
                 event_info=(f"Parameter '{parameter}' was not set. {shared_info}"),
             )
-        else:
+        elif current not in default_options:
             structlogger.warn(
                 "cli.get_validated_path.path_does_not_exists",
                 path=current,

rasa/cli/x.py

@@ -15,7 +15,7 @@ import rasa.utils.common
 import rasa.utils.io
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import x as arguments
-from rasa.core.utils import AvailableEndpoints
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.constants import (
     DEFAULT_CREDENTIALS_PATH,
     DEFAULT_ENDPOINTS_PATH,

rasa/constants.py

@@ -44,3 +44,5 @@ HTTP_STATUS_FORBIDDEN = 403
 HTTP_STATUS_NOT_FOUND = 404
 
 RASA_REMOTE_STORAGE_ENV_VAR_NAME = "RASA_REMOTE_STORAGE"
+
+RASA_DIR_NAME = ".rasa"

rasa/core/__init__.py

@@ -1,16 +0,0 @@
-import logging
-
-import rasa
-from rasa.core.nlg.contextual_response_rephraser import ContextualResponseRephraser
-from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
-from rasa.core.policies.intentless_policy import IntentlessPolicy
-
-logging.getLogger(__name__).addHandler(logging.NullHandler())
-
-__version__ = rasa.__version__
-
-__all__ = [
-    "EnterpriseSearchPolicy",
-    "IntentlessPolicy",
-    "ContextualResponseRephraser",
-]

rasa/core/actions/action.py

@@ -1152,7 +1152,11 @@ class ActionSendText(Action):
         fallback = {"text": ""}
         metadata_copy = copy.deepcopy(metadata) if metadata else {}
         message = metadata_copy.get("message", fallback)
-        return [create_bot_utterance(message, tracker.current_language)]
+
+        should_send_text = metadata_copy.get("should_send_text", True)
+        if should_send_text:
+            return [create_bot_utterance(message, tracker.current_language)]
+        return []
 
 
 class ActionExtractSlots(Action):

rasa/core/actions/action_repeat_bot_messages.py

@@ -25,7 +25,7 @@ class ActionRepeatBotMessages(Action):
         """Return the name of the action."""
         return ACTION_REPEAT_BOT_MESSAGES
 
-    def _get_last_bot_events(self, tracker: DialogueStateTracker) -> List[Event]:
+    def _get_last_bot_events(self, tracker: DialogueStateTracker) -> List[BotUttered]:
         """Get the last consecutive bot events before the most recent user message.
 
         This function scans the dialogue history in reverse to find the last sequence of
@@ -48,33 +48,21 @@ class ActionRepeatBotMessages(Action):
             The elif condition doesn't break when it sees User3 event.
             But it does at User2 event.
         """
-        # Skip action if we are in a collect information step whose
-        # default behavior is to repeat anyways
-        top_frame = tracker.stack.top(
-            lambda frame: isinstance(frame, RepeatBotMessagesPatternFlowStackFrame)
-            or isinstance(frame, UserSilencePatternFlowStackFrame)
-        )
-        if isinstance(top_frame, CollectInformationPatternFlowStackFrame):
-            return []
         # filter user and bot events
-        filtered = [
+        user_and_bot_events = [
             e for e in tracker.events if isinstance(e, (BotUttered, UserUttered))
         ]
-        bot_events: List[Event] = []
+        last_bot_events: List[BotUttered] = []
 
         # find the last BotUttered events
-        for e in reversed(filtered):
-            if isinstance(e, BotUttered):
-                # insert instead of append because the list is reversed
-                bot_events.insert(0, e)
-
-            # stop if a UserUttered event is found
-            # only if we have collected some bot events already
-            # this condition skips the first N UserUttered events
-            elif bot_events:
+        for e in reversed(user_and_bot_events):
+            # stop when seeing a user event after having seen bot events already
+            if isinstance(e, UserUttered) and len(last_bot_events) > 0:
                 break
+            elif isinstance(e, BotUttered):
+                last_bot_events.append(e)
 
-        return bot_events
+        return list(reversed(last_bot_events))
 
     async def run(
         self,
@@ -85,5 +73,13 @@ class ActionRepeatBotMessages(Action):
         metadata: Optional[Dict[str, Any]] = None,
     ) -> List[Event]:
         """Send the last bot messages to the channel again"""
-        bot_events = self._get_last_bot_events(tracker)
+        top_frame = tracker.stack.top(
+            lambda frame: isinstance(frame, RepeatBotMessagesPatternFlowStackFrame)
+            or isinstance(frame, UserSilencePatternFlowStackFrame)
+        )
+
+        bot_events: List[Event] = list(self._get_last_bot_events(tracker))
+        # drop the last bot event in a collect step as that part will be repeated anyway
+        if isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            bot_events = bot_events[:-1]
         return bot_events