rasa-pro 3.12.0.dev13__py3-none-any.whl → 3.12.0rc1__py3-none-any.whl

rasa/anonymization/anonymization_rule_executor.py

@@ -4,20 +4,14 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Text, Union
 
 from faker import Faker
-from presidio_analyzer import AnalyzerEngine
-from presidio_analyzer.nlp_engine import (
-    SpacyNlpEngine,
-    StanzaNlpEngine,
-    TransformersNlpEngine,
-)
-from presidio_anonymizer import AnonymizerEngine
-from presidio_anonymizer.entities import OperatorConfig
 
 from rasa.shared.exceptions import RasaException
 from rasa.utils.singleton import Singleton
 
 if typing.TYPE_CHECKING:
+    from presidio_analyzer import AnalyzerEngine
     from presidio_analyzer.nlp_engine.nlp_engine import NlpEngine
+    from presidio_anonymizer.entities import OperatorConfig
 
 DEFAULT_PRESIDIO_LANG_CODE = "en"
 DEFAULT_PRESIDIO_MODEL_NAME = "en_core_web_lg"
@@ -61,8 +55,10 @@ class AnonymizationAnalyzer(metaclass=Singleton):
     @staticmethod
     def _get_analyzer_engine(
         anonymization_rule_list: AnonymizationRuleList,
-    ) -> AnalyzerEngine:
+    ) -> "AnalyzerEngine":
         """Returns an analyzer engine for all the anonymization rule lists."""
+        from presidio_analyzer import AnalyzerEngine
+
         try:
             nlp_engine = AnonymizationAnalyzer._build_presidio_nlp_engine(
                 anonymization_rule_list
@@ -84,6 +80,12 @@ class AnonymizationAnalyzer(metaclass=Singleton):
         anonymization_rule_list: AnonymizationRuleList,
     ) -> "NlpEngine":
         """Creates an instance of the Presidio nlp engine."""
+        from presidio_analyzer.nlp_engine import (
+            SpacyNlpEngine,
+            StanzaNlpEngine,
+            TransformersNlpEngine,
+        )
+
         if anonymization_rule_list.model_provider == "transformers":
             nlp_engine = TransformersNlpEngine(
                 models={
@@ -111,6 +113,8 @@ class AnonymizationRuleExecutor:
 
     def __init__(self, anonymization_rule_list: AnonymizationRuleList):
         """Initialize the anonymization rule executor."""
+        from presidio_anonymizer import AnonymizerEngine
+
         self.anonymization_rule_list = anonymization_rule_list
 
         is_valid_rule_list = self._validate_anonymization_rule_list(
@@ -243,8 +247,10 @@ class AnonymizationRuleExecutor:
 
         return func
 
-    def get_operators(self) -> Dict[Text, OperatorConfig]:
+    def get_operators(self) -> Dict[Text, "OperatorConfig"]:
         """Returns a dictionary of operators for the given anonymization rule list."""
+        from presidio_anonymizer.entities import OperatorConfig
+
         operators = {}
 
         for rule in self.anonymization_rule_list.rule_list:

rasa/cli/data.py

@@ -178,6 +178,22 @@ def _add_data_validate_parsers(
     )
     arguments.set_validator_arguments(flows_structure_parser)
 
+    translations_structure_parser = validate_subparsers.add_parser(
+        "translations",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        parents=parents,
+        help="Checks for inconsistencies of the flow and response translation.",
+    )
+    translations_structure_parser.set_defaults(
+        func=lambda args: rasa.cli.utils.validate_files(
+            args.fail_on_warnings,
+            args.max_history,
+            _build_training_data_importer(args),
+            translations_only=True,
+        )
+    )
+    arguments.set_validator_arguments(translations_structure_parser)
+
 
 def _build_training_data_importer(args: argparse.Namespace) -> "TrainingDataImporter":
     config = rasa.cli.utils.get_validated_path(

rasa/cli/project_templates/calm/config.yml

@@ -1,9 +1,9 @@
 recipe: default.v1
 language: en
 pipeline:
-  - name: SingleStepLLMCommandGenerator
+  - name: CompactLLMCommandGenerator
     llm:
-      model_group: openai-gpt-4
+      model_group: openai-gpt-4o
 
 policies:
   - name: FlowPolicy

rasa/cli/project_templates/calm/endpoints.yml

@@ -50,9 +50,9 @@ action_endpoint:
 #   type: rephrase
 
 model_groups:
-  - id: openai-gpt-4
+  - id: openai-gpt-4o
     models:
       - provider: openai
-        model: openai/gpt-4
+        model: gpt-4o-2024-11-20
         request_timeout: 7
         max_tokens: 256

rasa/cli/utils.py

@@ -248,6 +248,7 @@ def validate_files(
     importer: TrainingDataImporter,
     stories_only: bool = False,
     flows_only: bool = False,
+    translations_only: bool = False,
 ) -> None:
     """Validates either the story structure or the entire project.
 
@@ -257,6 +258,7 @@ def validate_files(
         importer: The `TrainingDataImporter` to use to load the training data.
         stories_only: If `True`, only the story structure is validated.
         flows_only: If `True`, only the flows are validated.
+        translations_only: If `True`, only the translations data is validated.
     """
     from rasa.validator import Validator
 
@@ -266,6 +268,8 @@ def validate_files(
         all_good = _validate_story_structure(validator, max_history, fail_on_warnings)
     elif flows_only:
         all_good = validator.verify_flows()
+    elif translations_only:
+        all_good = validator.verify_translations()
     else:
         if importer.get_domain().is_empty():
             structlogger.error(
@@ -280,6 +284,7 @@ def validate_files(
             validator, max_history, fail_on_warnings
         )
         valid_flows = validator.verify_flows()
+        valid_translations = validator.verify_translations(summary_mode=True)
         valid_CALM_slot_mappings = validator.validate_CALM_slot_mappings()
 
         all_good = (
@@ -287,6 +292,7 @@ def validate_files(
             and valid_nlu
             and valid_stories
             and valid_flows
+            and valid_translations
             and valid_CALM_slot_mappings
         )
 
@@ -309,6 +315,10 @@ def _validate_domain(validator: "Validator") -> bool:
     valid_slot_mappings = validator.verify_slot_mappings()
     valid_responses = validator.check_for_no_empty_parenthesis_in_responses()
     valid_buttons = validator.validate_button_payloads()
+    valid_slot_validation = validator.verify_slot_validation()
+    valid_conditional_responses = (
+        validator.validate_conditional_response_variation_predicates()
+    )
     return (
         valid_domain_validity
         and valid_actions_in_stories_rules
@@ -317,6 +327,8 @@ def _validate_domain(validator: "Validator") -> bool:
         and valid_slot_mappings
         and valid_responses
         and valid_buttons
+        and valid_slot_validation
+        and valid_conditional_responses
     )
 
 

rasa/core/actions/action.py

@@ -1,17 +1,7 @@
 import copy
 import logging
 from functools import lru_cache
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Text,
-    Tuple,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, cast
 
 from jsonschema import Draft202012Validator
 
@@ -29,11 +19,15 @@ from rasa.core.actions.e2e_stub_custom_action_executor import (
 from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
 from rasa.core.actions.http_custom_action_executor import HTTPCustomActionExecutor
 from rasa.core.constants import (
+    KEY_IS_CALM_SYSTEM,
+    KEY_IS_COEXISTENCE_ASSISTANT,
     UTTER_SOURCE_METADATA_KEY,
 )
+from rasa.core.nlg.translate import get_translated_buttons, get_translated_text
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.core.utils import add_bot_utterance_metadata
 from rasa.e2e_test.constants import KEY_STUB_CUSTOM_ACTIONS
+from rasa.engine.language import Language
 from rasa.nlu.constants import (
     RESPONSE_SELECTOR_DEFAULT_INTENT,
     RESPONSE_SELECTOR_PREDICTION_KEY,
@@ -70,13 +64,11 @@ from rasa.shared.core.constants import (
     ACTION_SEND_TEXT_NAME,
     ACTION_SESSION_START_NAME,
     ACTION_UNLIKELY_INTENT_NAME,
-    ACTION_VALIDATE_SLOT_MAPPINGS,
     DEFAULT_SLOT_NAMES,
     KNOWLEDGE_BASE_SLOT_NAMES,
     REQUESTED_SLOT,
     USER_INTENT_OUT_OF_SCOPE,
     SetSlotExtractor,
-    SlotMappingType,
 )
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import (
@@ -92,26 +84,23 @@ from rasa.shared.core.events import (
     UserUttered,
 )
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.constants import KEY_TRANSLATION
 from rasa.shared.core.slot_mappings import (
     SlotFillingManager,
     extract_slot_value,
 )
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
-from rasa.shared.nlu.constants import (
-    INTENT_NAME_KEY,
-    INTENT_RANKING_KEY,
-)
+from rasa.shared.nlu.constants import INTENT_NAME_KEY, INTENT_RANKING_KEY
 from rasa.shared.utils.io import raise_warning
 from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
-from rasa.utils.endpoints import ClientResponseError, EndpointConfig
+from rasa.utils.endpoints import EndpointConfig
 from rasa.utils.url_tools import UrlSchema, get_url_schema
 
 if TYPE_CHECKING:
     from rasa.core.channels.channel import OutputChannel
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.events import IntentPrediction
-    from rasa.shared.core.slot_mappings import SlotMapping
 
 logger = logging.getLogger(__name__)
 
@@ -268,25 +257,36 @@ def action_for_name_or_text(
     return RemoteAction(action_name_or_text, action_endpoint)
 
 
-def create_bot_utterance(message: Dict[Text, Any]) -> BotUttered:
-    """Create BotUttered event from message."""
-    bot_message = BotUttered(
-        text=message.pop(TEXT, None),
-        data={
-            ELEMENTS: message.pop(ELEMENTS, None),
-            QUICK_REPLIES: message.pop(QUICK_REPLIES, None),
-            BUTTONS: message.pop(BUTTONS, None),
-            # for legacy / compatibility reasons we need to set the image
-            # to be the attachment if there is no other attachment (the
-            # `.get` is intentional - no `pop` as we still need the image`
-            # property to set it in the following line)
-            ATTACHMENT: message.pop(ATTACHMENT, None) or message.get(IMAGE, None),
-            IMAGE: message.pop(IMAGE, None),
-            CUSTOM: message.pop(CUSTOM, None),
-        },
-        metadata=message,
+def create_bot_utterance(
+    message: Dict[Text, Any], language: Optional[Language] = None
+) -> BotUttered:
+    """Create BotUttered event from message with translation support."""
+    message_copy = copy.deepcopy(message)
+
+    text = get_translated_text(
+        text=message_copy.pop(TEXT, None),
+        translation=message_copy.pop(KEY_TRANSLATION, {}),
+        language=language,
+    )
+
+    buttons = get_translated_buttons(
+        buttons=message_copy.pop(BUTTONS, None), language=language
     )
-    return bot_message
+
+    data = {
+        ELEMENTS: message_copy.pop(ELEMENTS, None),
+        QUICK_REPLIES: message_copy.pop(QUICK_REPLIES, None),
+        BUTTONS: buttons,
+        # for legacy / compatibility reasons we need to set the image
+        # to be the attachment if there is no other attachment (the
+        # `.get` is intentional - no `pop` as we still need the image`
+        # property to set it in the following line)
+        ATTACHMENT: message_copy.pop(ATTACHMENT, None) or message_copy.get(IMAGE, None),
+        IMAGE: message_copy.pop(IMAGE, None),
+        CUSTOM: message_copy.pop(CUSTOM, None),
+    }
+
+    return BotUttered(text=text, data=data, metadata=message_copy)
 
 
 class Action:
@@ -399,7 +399,7 @@ class ActionBotResponse(Action):
         message = add_bot_utterance_metadata(
             message, self.utter_action, nlg, domain, tracker
         )
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
     def name(self) -> Text:
         """Returns action name."""
@@ -433,7 +433,7 @@ class ActionEndToEndResponse(Action):
     ) -> List[Event]:
         """Runs action (see parent class for full docstring)."""
         message = {"text": self.action_text}
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
     def event_for_successful_execution(
         self,
@@ -917,7 +917,7 @@ class RemoteAction(Action):
             # Avoid overwriting `draft` values with empty values
             response = {k: v for k, v in response.items() if v}
             draft.update(response)
-            bot_messages.append(create_bot_utterance(draft))
+            bot_messages.append(create_bot_utterance(draft, tracker.current_language))
 
         return bot_messages
 
@@ -1125,7 +1125,7 @@ class ActionDefaultAskAffirmation(Action):
             "utter_action": self.name(),
         }
 
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
 
 class ActionDefaultAskRephrase(ActionBotResponse):
@@ -1158,7 +1158,7 @@ class ActionSendText(Action):
         fallback = {"text": ""}
         metadata_copy = copy.deepcopy(metadata) if metadata else {}
         message = metadata_copy.get("message", fallback)
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
 
 class ActionExtractSlots(Action):
@@ -1179,113 +1179,6 @@ class ActionExtractSlots(Action):
         """Returns action_extract_slots name."""
         return ACTION_EXTRACT_SLOTS
 
-    async def _run_custom_action(
-        self,
-        custom_action: Text,
-        output_channel: "OutputChannel",
-        nlg: "NaturalLanguageGenerator",
-        tracker: "DialogueStateTracker",
-        domain: "Domain",
-    ) -> List[Event]:
-        slot_events: List[Event] = []
-        remote_action = RemoteAction(custom_action, self._action_endpoint)
-        disallowed_types = set()
-
-        try:
-            custom_events = await remote_action.run(
-                output_channel, nlg, tracker, domain
-            )
-            for event in custom_events:
-                if isinstance(event, SlotSet):
-                    slot_events.append(event)
-                elif isinstance(event, BotUttered):
-                    slot_events.append(event)
-                else:
-                    disallowed_types.add(event.type_name)
-        except (RasaException, ClientResponseError) as e:
-            logger.warning(
-                f"Failed to execute custom action '{custom_action}' "
-                f"as a result of error '{e!s}'. The default action "
-                f"'{self.name()}' failed to fill slots with custom "
-                f"mappings."
-            )
-
-        for type_name in disallowed_types:
-            logger.info(
-                f"Running custom action '{custom_action}' has resulted "
-                f"in an event of type '{type_name}'. This is "
-                f"disallowed and the tracker will not be "
-                f"updated with this event."
-            )
-
-        return slot_events
-
-    async def _execute_custom_action(
-        self,
-        mapping: "SlotMapping",
-        executed_custom_actions: Set[Text],
-        output_channel: "OutputChannel",
-        nlg: "NaturalLanguageGenerator",
-        tracker: "DialogueStateTracker",
-        domain: "Domain",
-        calm_custom_action_names: Optional[Set[str]] = None,
-    ) -> Tuple[List[Event], Set[Text]]:
-        custom_action = mapping.run_action_every_turn
-
-        if not custom_action or custom_action in executed_custom_actions:
-            return [], executed_custom_actions
-
-        if (
-            calm_custom_action_names is not None
-            and custom_action in calm_custom_action_names
-        ):
-            return [], executed_custom_actions
-
-        slot_events = await self._run_custom_action(
-            custom_action, output_channel, nlg, tracker, domain
-        )
-
-        executed_custom_actions.add(custom_action)
-
-        return slot_events, executed_custom_actions
-
-    async def _execute_validation_action(
-        self,
-        extraction_events: List[Event],
-        output_channel: "OutputChannel",
-        nlg: "NaturalLanguageGenerator",
-        tracker: "DialogueStateTracker",
-        domain: "Domain",
-    ) -> List[Event]:
-        slot_events: List[SlotSet] = [
-            event for event in extraction_events if isinstance(event, SlotSet)
-        ]
-
-        slot_candidates = "\n".join([e.key for e in slot_events])
-        logger.debug(f"Validating extracted slots: {slot_candidates}")
-
-        if ACTION_VALIDATE_SLOT_MAPPINGS not in domain.user_actions:
-            return cast(List[Event], slot_events)
-
-        _tracker = DialogueStateTracker.from_events(
-            tracker.sender_id,
-            tracker.events_after_latest_restart() + cast(List[Event], slot_events),
-            slots=domain.slots,
-        )
-        validate_events = await self._run_custom_action(
-            ACTION_VALIDATE_SLOT_MAPPINGS, output_channel, nlg, _tracker, domain
-        )
-        validated_slot_names = [
-            event.key for event in validate_events if isinstance(event, SlotSet)
-        ]
-
-        # If the custom action doesn't return a SlotSet event for an extracted slot
-        # candidate we assume that it was valid. The custom action has to return a
-        # SlotSet(slot_name, None) event to mark a Slot as invalid.
-        return validate_events + [
-            event for event in slot_events if event.key not in validated_slot_names
-        ]
-
     async def run(
         self,
         output_channel: "OutputChannel",
@@ -1296,59 +1189,59 @@ class ActionExtractSlots(Action):
     ) -> List[Event]:
         """Runs action. Please see parent class for the full docstring."""
         slot_events: List[Event] = []
-        executed_custom_actions: Set[Text] = set()
-
         user_slots = [
             slot
             for slot in domain.slots
             if slot.name not in DEFAULT_SLOT_NAMES | KNOWLEDGE_BASE_SLOT_NAMES
         ]
 
-        calm_slot_names = set()
-        calm_custom_action_names = None
-        flows = None
-
-        if metadata is not None:
-            flows = metadata.get("all_flows")
-
-        if flows is not None:
-            flows = FlowsList.from_json(flows)
-            calm_slot_names = flows.available_slot_names()
-            calm_custom_action_names = flows.available_custom_actions()
-
+        all_flows = metadata.get("all_flows") if metadata else None
+        flows = FlowsList.from_json(all_flows) if all_flows else None
+        calm_slot_names = flows.available_slot_names() if flows else set()
+        is_calm_system = metadata.get(KEY_IS_CALM_SYSTEM) if metadata else False
+        is_coexistence_bot = (
+            metadata.get(KEY_IS_COEXISTENCE_ASSISTANT) if metadata else False
+        )
         slot_filling_manager = SlotFillingManager(
-            domain, tracker, action_endpoint=self._action_endpoint
+            domain,
+            tracker,
+            action_endpoint=self._action_endpoint,
         )
 
         for slot in user_slots:
             # allows the action to set slots that are shared between
             # the NLU-based system and CALM system in a coexistence bot
-            if slot.name in calm_slot_names and not slot.shared_for_coexistence:
-                continue
-
-            slot_value, is_extracted = extract_slot_value(slot, slot_filling_manager)
-            if is_extracted:
-                slot_events.append(SlotSet(slot.name, slot_value))
-
-            for mapping in slot.mappings:
-                should_fill_controlled_slot = mapping.type == SlotMappingType.CONTROLLED
-
-                if should_fill_controlled_slot:
-                    (
-                        custom_evts,
-                        executed_custom_actions,
-                    ) = await self._execute_custom_action(
-                        mapping,
-                        executed_custom_actions,
-                        output_channel,
-                        nlg,
-                        tracker,
-                        domain,
-                        calm_custom_action_names,
+            if is_coexistence_bot:
+                should_fill_slot_in_coexistence = (
+                    slot_filling_manager.should_fill_slot_in_coexistence(
+                        is_calm_system=is_calm_system,
+                        slot=slot,
+                        calm_slot_names=calm_slot_names,
                     )
-                    slot_events.extend(custom_evts)
+                )
+                if not should_fill_slot_in_coexistence:
+                    continue
 
-        validated_events = await self._execute_validation_action(
-            slot_events, output_channel, nlg, tracker, domain
-        )
-        return validated_events
+            if not is_calm_system:
+                slot_value, is_extracted = extract_slot_value(
+                    slot, slot_filling_manager
+                )
+                if is_extracted:
+                    slot_events.append(SlotSet(slot.name, slot_value))
+
+            custom_events = await slot_filling_manager.run_action_at_every_turn(
+                slot,
+                output_channel,
+                nlg,
+            )
+            slot_events.extend(custom_events)
+
+        if not is_calm_system:
+            validated_events = await slot_filling_manager.execute_validation_action(
+                slot_events,
+                output_channel,
+                nlg,
+            )
+            return validated_events
+
+        return slot_events

rasa/core/actions/action_run_slot_rejections.py

@@ -9,14 +9,17 @@ from rasa.core.utils import add_bot_utterance_metadata
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
 )
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
+)
 from rasa.shared.core.constants import ACTION_RUN_SLOT_REJECTIONS_NAME
 from rasa.shared.core.events import Event, SlotSet
-from rasa.shared.core.flows.steps.collect import SlotRejection
 from rasa.shared.core.slots import (
     BooleanSlot,
     CategoricalSlot,
     FloatSlot,
     Slot,
+    SlotRejection,
 )
 
 if TYPE_CHECKING:
@@ -138,10 +141,19 @@ class ActionRunSlotRejections(Action):
         """Run the predicate checks."""
         utterance = None
         top_frame = tracker.stack.top()
-        if not isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+        if not isinstance(
+            top_frame,
+            (
+                CollectInformationPatternFlowStackFrame,
+                ValidateSlotPatternFlowStackFrame,
+            ),
+        ):
             return []
+        elif isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            slot_name = top_frame.collect
+        elif isinstance(top_frame, ValidateSlotPatternFlowStackFrame):
+            slot_name = top_frame.validate
 
-        slot_name = top_frame.collect
         slot_instance = tracker.slots.get(slot_name)
         if slot_instance and not slot_instance.has_been_set:
             # this is the first time the assistant asks for the slot value,
@@ -205,6 +217,6 @@ class ActionRunSlotRejections(Action):
             message = add_bot_utterance_metadata(
                 message, utterance, nlg, domain, tracker
             )
-            events.append(create_bot_utterance(message))
+            events.append(create_bot_utterance(message, tracker.current_language))
 
         return events

rasa/core/channels/__init__.py

@@ -34,6 +34,7 @@ from rasa.core.channels.voice_stream.twilio_media_streams import (
 )
 from rasa.core.channels.voice_stream.genesys import GenesysInputChannel
 from rasa.core.channels.studio_chat import StudioChatInput
+from rasa.core.channels.voice_stream.audiocodes import AudiocodesVoiceInputChannel
 
 input_channel_classes: List[Type[InputChannel]] = [
     CmdlineInput,
@@ -58,6 +59,7 @@ input_channel_classes: List[Type[InputChannel]] = [
     BrowserAudioInputChannel,
     GenesysInputChannel,
     StudioChatInput,
+    AudiocodesVoiceInputChannel,
 ]
 
 # Mapping from an input channel name to its class to allow name based lookup.

rasa/core/channels/studio_chat.py

@@ -18,6 +18,8 @@ from sanic import Sanic
 from rasa.core.channels.socketio import SocketBlueprint, SocketIOInput
 from rasa.hooks import hookimpl
 from rasa.plugin import plugin_manager
+from rasa.shared.core.constants import ACTION_LISTEN_NAME
+from rasa.shared.core.events import ActionExecuted
 from rasa.shared.core.trackers import EventVerbosity
 
 if TYPE_CHECKING:
@@ -43,6 +45,15 @@ def tracker_as_dump(tracker: "DialogueStateTracker") -> str:
     return json.dumps(state)
 
 
+def does_need_action_prediction(tracker: "DialogueStateTracker") -> bool:
+    """Check if the tracker needs an action prediction."""
+    return (
+        len(tracker.events) == 0
+        or not isinstance(tracker.events[-1], ActionExecuted)
+        or tracker.events[-1].action_name != ACTION_LISTEN_NAME
+    )
+
+
 class StudioTrackerUpdatePlugin:
     """Plugin for publishing tracker updates a socketio channel."""
 
@@ -169,6 +180,14 @@ class StudioChatInput(SocketIOInput):
             # will override an existing tracker with the same id!
             await self.agent.tracker_store.save(tracker)
 
+            processor = self.agent.processor
+            if processor and does_need_action_prediction(tracker):
+                output_channel = self.get_output_channel()
+
+                await processor._run_prediction_loop(output_channel, tracker)
+                await processor.run_anonymization_pipeline(tracker)
+                await self.agent.tracker_store.save(tracker)
+
         await self.on_tracker_updated(tracker)
 
     def blueprint(