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

rasa/core/policies/intentless_policy.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple
 
 import structlog
 import tiktoken
+from deprecated import deprecated  # type: ignore[import]
 from jinja2 import Template
 from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings
@@ -31,22 +32,20 @@ from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
     LLM_CONFIG_KEY,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
+    TEMPERATURE_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
-from rasa.shared.core.events import (
-    ActionExecuted,
-    BotUttered,
-    Event,
-    UserUttered,
-)
+from rasa.shared.core.events import ActionExecuted, BotUttered, Event, UserUttered
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.policies.utils import filter_responses_for_intentless_policy
@@ -58,18 +57,22 @@ from rasa.shared.providers.embedding._langchain_embedding_client_adapter import
     _LangchainEmbeddingClientAdapter,
 )
 from rasa.shared.providers.llm.llm_client import LLMClient
-from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
+from rasa.shared.utils.constants import (
+    LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+    LOG_COMPONENT_SOURCE_METHOD_INIT,
+)
 from rasa.shared.utils.health_check.embeddings_health_check_mixin import (
     EmbeddingsHealthCheckMixin,
 )
 from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
-from rasa.shared.utils.io import deep_container_fingerprint
+from rasa.shared.utils.io import deep_container_fingerprint, raise_deprecation_warning
 from rasa.shared.utils.llm import (
     AI,
     DEFAULT_OPENAI_CHAT_MODEL_NAME,
     DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
     DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     USER,
+    check_prompt_config_keys_and_warn_if_deprecated,
     combine_custom_and_default_config,
     embedder_factory,
     get_prompt_template,
@@ -111,19 +114,22 @@ NLU_ABSTENTION_THRESHOLD = "nlu_abstention_threshold"
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME,
-    "temperature": 0.0,
-    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TEMPERATURE_CONFIG_KEY: 0.0,
+    MAX_COMPLETION_TOKENS_CONFIG_KEY: DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
     TIMEOUT_CONFIG_KEY: 5,
 }
 
 DEFAULT_EMBEDDINGS_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
-    "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
 }
 
-DEFAULT_INTENTLESS_PROMPT_TEMPLATE = importlib.resources.open_text(
+DEFAULT_INTENTLESS_PROMPT_TEMPLATE_FILE_NAME = importlib.resources.open_text(
     "rasa.core.policies", "intentless_prompt_template.jinja2"
 ).name
+DEFAULT_INTENTLESS_PROMPT_TEMPLATE = importlib.resources.read_text(
+    "rasa.core.policies", "intentless_prompt_template.jinja2"
+)
 
 INTENTLESS_PROMPT_TEMPLATE_FILE_NAME = "intentless_policy_prompt.jinja2"
 INTENTLESS_CONFIG_FILE_NAME = "config.json"
@@ -323,6 +329,9 @@ def conversation_as_prompt(conversation: Conversation) -> str:
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.POLICY_WITH_END_TO_END_SUPPORT, is_trainable=True
 )
+@deprecated(
+    reason=("The IntentlessPolicy is deprecated and will be removed in Rasa `4.0.0`.")
+)
 class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
     """Policy which uses a language model to generate the next action.
 
@@ -344,9 +353,7 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             # ensures that the policy will not override a deterministic policy
             # which utilizes the nlu predictions confidence (e.g. Memoization).
             NLU_ABSTENTION_THRESHOLD: 0.9,
-            LLM_CONFIG_KEY: DEFAULT_LLM_CONFIG,
-            EMBEDDINGS_CONFIG_KEY: DEFAULT_EMBEDDINGS_CONFIG,
-            PROMPT_CONFIG_KEY: DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
+            PROMPT_TEMPLATE_CONFIG_KEY: None,  # TODO: remove in Rasa 4.0.0
         }
 
     @staticmethod
@@ -378,27 +385,68 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         prompt_template: Optional[Text] = None,
     ) -> None:
         """Constructs a new Policy object."""
+        raise_deprecation_warning(
+            message=("Support for `IntentlessPolicy` will be removed in Rasa `4.0.0`.")
+        )
         super().__init__(config, model_storage, resource, execution_context, featurizer)
 
         # Resolve LLM config
-        self.config[LLM_CONFIG_KEY] = resolve_model_client_config(
-            self.config.get(LLM_CONFIG_KEY), IntentlessPolicy.__name__
+        self.config[LLM_CONFIG_KEY] = combine_custom_and_default_config(
+            resolve_model_client_config(
+                self.config.get(LLM_CONFIG_KEY), IntentlessPolicy.__name__
+            ),
+            DEFAULT_LLM_CONFIG,
         )
 
         # Resolve embeddings config
-        self.config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
-            self.config.get(EMBEDDINGS_CONFIG_KEY), IntentlessPolicy.__name__
+        self.config[EMBEDDINGS_CONFIG_KEY] = combine_custom_and_default_config(
+            resolve_model_client_config(
+                self.config.get(EMBEDDINGS_CONFIG_KEY), IntentlessPolicy.__name__
+            ),
+            DEFAULT_EMBEDDINGS_CONFIG,
         )
 
         self.nlu_abstention_threshold: float = self.config[NLU_ABSTENTION_THRESHOLD]
         self.response_index = responses_docsearch
         self.conversation_samples_index = samples_docsearch
         self.embedder = self._create_plain_embedder(config)
-        self.prompt_template = prompt_template or rasa.shared.utils.io.read_file(
-            self.config[PROMPT_CONFIG_KEY]
+
+        # Warn if the prompt config key is used to set the prompt template
+        check_prompt_config_keys_and_warn_if_deprecated(config, "intentless_policy")
+
+        self.prompt_template = prompt_template or self._resolve_prompt_template(
+            config, LOG_COMPONENT_SOURCE_METHOD_INIT
         )
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
 
+    @classmethod
+    def _resolve_prompt_template(
+        cls: Any,
+        config: dict,
+        log_source_method: str,
+    ) -> str:
+        """Resolves the prompt template from the config.
+
+        Args:
+            config: The config to resolve the prompt template from.
+            log_source_method: The method from which the prompt template is resolved.
+
+        Returns:
+            The resolved prompt template.
+        """
+        # Prefer prompt template over prompt config key.
+        prompt_template_file = (
+            config.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            or config.get(PROMPT_CONFIG_KEY)
+            or DEFAULT_INTENTLESS_PROMPT_TEMPLATE_FILE_NAME
+        )
+        return get_prompt_template(
+            prompt_template_file,
+            DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
+            log_source_component=IntentlessPolicy.__name__,
+            log_source_method=log_source_method,
+        )
+
     @classmethod
     def _create_plain_embedder(cls, config: Dict[Text, Any]) -> Embeddings:
         """Creates an embedder that uses the OpenAI API.
@@ -937,11 +985,8 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
     @classmethod
     def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint of intentless policy for the graph."""
-        prompt_template = get_prompt_template(
-            config.get(PROMPT_CONFIG_KEY),
-            DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
-            log_source_component=IntentlessPolicy.__name__,
-            log_source_method=LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+        prompt_template = cls._resolve_prompt_template(
+            config, LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
         )
 
         llm_config = resolve_model_client_config(

rasa/core/processor.py

@@ -34,6 +34,9 @@ from rasa.dialogue_understanding.commands import (
     CannotHandleCommand,
     Command,
     NoopCommand,
+    RestartCommand,
+    SessionEndCommand,
+    SessionStartCommand,
     SetSlotCommand,
 )
 from rasa.dialogue_understanding.commands.utils import (
@@ -72,8 +75,8 @@ from rasa.shared.core.constants import (
     ACTION_SESSION_START_NAME,
     FOLLOWUP_ACTION,
     SESSION_START_METADATA_SLOT,
+    SILENCE_TIMEOUT_SLOT,
     SLOT_CONSECUTIVE_SILENCE_TIMEOUTS,
-    SLOT_SILENCE_TIMEOUT,
     USER_INTENT_RESTART,
     USER_INTENT_SILENCE_TIMEOUT,
     SetSlotExtractor,
@@ -109,7 +112,8 @@ from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
 
 if TYPE_CHECKING:
-    from rasa.core.utils import AvailableEndpoints
+    from rasa.core.available_endpoints import AvailableEndpoints
+    from rasa.privacy.privacy_manager import BackgroundPrivacyManager
 
 logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
@@ -135,6 +139,7 @@ class MessageProcessor:
         on_circuit_break: Optional[LambdaType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional["AvailableEndpoints"] = None,
+        privacy_manager: Optional["BackgroundPrivacyManager"] = None,
     ) -> None:
         """Initializes a `MessageProcessor`."""
         self.nlg = generator
@@ -164,6 +169,9 @@ class MessageProcessor:
         self.model_path = Path(model_path)
         self.domain = self.model_metadata.domain
         self.http_interpreter = http_interpreter
+        self.privacy_manager = privacy_manager
+        if self.privacy_manager is not None:
+            self.privacy_manager.validate_sensitive_slots_in_domain(self.domain)
 
     @staticmethod
     def _load_model(
@@ -213,15 +221,30 @@ class MessageProcessor:
 
         await self._run_prediction_loop(message.output_channel, tracker)
 
-        await self.run_anonymization_pipeline(tracker)
-
         await self.save_tracker(tracker)
 
+        self.trigger_anonymization(tracker)
+
         if isinstance(message.output_channel, CollectingOutputChannel):
             return message.output_channel.messages
 
         return None
 
+    def trigger_anonymization(self, tracker: DialogueStateTracker) -> None:
+        if self.privacy_manager is None:
+            structlogger.debug(
+                "processor.trigger_anonymization.skipping.pii_management_not_enabled",
+            )
+            return None
+
+        structlogger.info(
+            "rasa.core.processor.trigger_anonymization",
+            sender_id=tracker.sender_id,
+            event_info="Triggering anonymization for publishing anonymized "
+            "events to the event broker.",
+        )
+        return self.privacy_manager.run(tracker)
+
     async def run_action_extract_slots(
         self,
         output_channel: OutputChannel,
@@ -262,26 +285,6 @@ class MessageProcessor:
 
         return tracker
 
-    async def run_anonymization_pipeline(self, tracker: DialogueStateTracker) -> None:
-        """Run the anonymization pipeline on the new tracker events.
-
-        Args:
-            tracker: A tracker representing a conversation state.
-        """
-        anonymization_pipeline = plugin_manager().hook.get_anonymization_pipeline()
-        if anonymization_pipeline is None:
-            return None
-
-        old_tracker = await self.tracker_store.retrieve(tracker.sender_id)
-        new_events = rasa.shared.core.trackers.TrackerEventDiffEngine.event_difference(
-            old_tracker, tracker
-        )
-
-        for event in new_events:
-            body = {"sender_id": tracker.sender_id}
-            body.update(event.as_dict())
-            anonymization_pipeline.run(body)
-
     async def predict_next_for_sender_id(
         self, sender_id: Text
     ) -> Optional[Dict[Text, Any]]:
@@ -819,28 +822,8 @@ class MessageProcessor:
         )
 
         self._check_for_unseen_features(parse_data)
-        # resetting timeouts variables whenever something that is not a timeout occurs
-        if (
-            parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
-            != USER_INTENT_SILENCE_TIMEOUT
-            and tracker
-        ):
-            if (
-                SLOT_CONSECUTIVE_SILENCE_TIMEOUTS in tracker.slots
-                and tracker.slots[SLOT_CONSECUTIVE_SILENCE_TIMEOUTS].value != 0.0
-            ):
-                tracker.update(SlotSet(SLOT_CONSECUTIVE_SILENCE_TIMEOUTS, 0.0))
-            if (
-                SLOT_SILENCE_TIMEOUT in tracker.slots
-                and tracker.slots[SLOT_SILENCE_TIMEOUT].value
-                != tracker.slots[SLOT_SILENCE_TIMEOUT].initial_value
-            ):
-                tracker.update(
-                    SlotSet(
-                        SLOT_SILENCE_TIMEOUT,
-                        tracker.slots[SLOT_SILENCE_TIMEOUT].initial_value,
-                    )
-                )
+
+        self._initialise_consecutive_silence_timeout_slots(parse_data, tracker)
 
         return parse_data
 
@@ -880,19 +863,61 @@ class MessageProcessor:
                 tracker.has_coexistence_routing_slot
                 and tracker.get_slot(ROUTE_TO_CALM_SLOT) is None
             ):
-                # if we are currently not routing to either CALM or dm1
-                # we make a sticky routing to CALM if there are any commands
-                # from the trigger intent parsing
-                # or a sticky routing to dm1 if there are no commands
+                # If we are currently not routing to either CALM or DM1:
+                # - Sticky route to CALM if there are any commands
+                #   from the trigger intent parsing
+                # - Sticky route to DM1 if there are no commands present
+                route_to_calm_slot_value = self._determine_route_to_calm_slot_value(
+                    nlu_adapted_commands
+                )
                 commands += [
                     SetSlotCommand(
-                        ROUTE_TO_CALM_SLOT, len(nlu_adapted_commands) > 0
+                        ROUTE_TO_CALM_SLOT, route_to_calm_slot_value
                     ).as_dict()
                 ]
 
         parse_data[COMMANDS] = commands
         return parse_data
 
+    def _determine_route_to_calm_slot_value(
+        self, nlu_adapted_commands: List[Dict[str, Any]]
+    ) -> Optional[bool]:
+        """Determines what value should be assigned to `ROUTE_TO_CALM_SLOT`.
+
+        Returns:
+            - True: If any command other than:
+                - SessionStartCommand
+                - SessionEndCommand
+                - RestartCommand
+              is present.
+            - None: If only ignored system commands are present.
+            - False If no commands at all.
+        """
+        system_commands_to_ignore = [
+            SessionStartCommand.command(),
+            SessionEndCommand.command(),
+            RestartCommand.command(),
+        ]
+
+        # Exclude the system commands, as it doesn't originate from the user's
+        # input intent and shouldn't influence the decision for setting
+        # ROUTE_TO_CALM_SLOT.
+        intent_triggered_commands = [
+            command
+            for command in nlu_adapted_commands
+            if command.get("command") not in system_commands_to_ignore
+        ]
+
+        if len(intent_triggered_commands) > 0:
+            # There are commands other than system commands present - route to CALM
+            return True
+        elif len(nlu_adapted_commands) > 0:
+            # Only system command is present — defer routing decision
+            return None
+        else:
+            # No commands at all — route to DM1
+            return False
+
     def _update_full_retrieval_intent(self, parse_data: Dict[Text, Any]) -> None:
         """Update the parse data with the full retrieval intent.
 
@@ -1577,3 +1602,31 @@ class MessageProcessor:
         )
 
         return tracker, validate_frames
+
+    @staticmethod
+    def _initialise_consecutive_silence_timeout_slots(
+        parse_data: Dict[str, Any],
+        tracker: DialogueStateTracker,
+    ) -> None:
+        # resetting timeouts variables whenever something that is not a timeout occurs
+        if (
+            parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
+            != USER_INTENT_SILENCE_TIMEOUT
+            and tracker
+        ):
+            if (
+                SLOT_CONSECUTIVE_SILENCE_TIMEOUTS in tracker.slots
+                and tracker.slots[SLOT_CONSECUTIVE_SILENCE_TIMEOUTS].value != 0.0
+            ):
+                tracker.update(SlotSet(SLOT_CONSECUTIVE_SILENCE_TIMEOUTS, 0.0))
+            if (
+                SILENCE_TIMEOUT_SLOT in tracker.slots
+                and tracker.slots[SILENCE_TIMEOUT_SLOT].value
+                != tracker.slots[SILENCE_TIMEOUT_SLOT].initial_value
+            ):
+                tracker.update(
+                    SlotSet(
+                        SILENCE_TIMEOUT_SLOT,
+                        tracker.slots[SILENCE_TIMEOUT_SLOT].initial_value,
+                    )
+                )

rasa/core/run.py

@@ -30,12 +30,11 @@ from rasa import server, telemetry
 from rasa.constants import ENV_SANIC_BACKLOG
 from rasa.core import agent, channels, constants
 from rasa.core.agent import Agent
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
 from rasa.core.channels.development_inspector import DevelopmentInspectProxy
 from rasa.core.persistor import StorageType
-from rasa.core.utils import AvailableEndpoints
-from rasa.plugin import plugin_manager
 from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.yaml import read_config_file
 from rasa.utils import licensing
@@ -45,7 +44,7 @@ logger = logging.getLogger()  # get the root logger
 
 def create_http_input_channels(
     channel: Optional[Text], credentials_file: Optional[Text]
-) -> List["InputChannel"]:
+) -> List[InputChannel]:
     """Instantiate the chosen input channel."""
     if credentials_file:
         all_credentials = read_config_file(credentials_file)
@@ -59,22 +58,45 @@ def create_http_input_channels(
                 "To connect to all given channels, omit the '--connector' "
                 "argument.".format(channel)
             )
-        return [_create_single_channel(channel, all_credentials.get(channel))]
+        return [
+            _create_single_channel(
+                channel,
+                all_credentials.get(channel),
+            )
+        ]
     else:
         return [_create_single_channel(c, k) for c, k in all_credentials.items()]
 
 
-def _create_single_channel(channel: Text, credentials: Dict[Text, Any]) -> Any:
+def _create_single_channel(
+    channel: Text,
+    credentials: Optional[Dict[Text, Any]],
+) -> Any:
+    """Create a single input channel based on the channel name and credentials.
+
+    Args:
+        channel: The name of the input channel to create.
+        credentials: The credentials for the input channel.
+
+    Returns:
+        An instance of the input channel class.
+
+    Raises:
+        RasaException: If the channel class cannot be found or instantiated.
+    """
     from rasa.core.channels import BUILTIN_CHANNELS
 
     if channel in BUILTIN_CHANNELS:
-        return BUILTIN_CHANNELS[channel].from_credentials(credentials)
+        channel_class = BUILTIN_CHANNELS[channel]
+
+        return channel_class.from_credentials(credentials)
     else:
         # try to load channel based on class name
         try:
             input_channel_class = rasa.shared.utils.common.class_from_module_path(
                 channel
             )
+
             return input_channel_class.from_credentials(credentials)
         except (AttributeError, ImportError):
             raise RasaException(
@@ -108,7 +130,7 @@ def _is_apple_silicon_system() -> bool:
 
 
 def configure_app(
-    input_channels: Optional[List["InputChannel"]] = None,
+    input_channels: Optional[List[InputChannel]] = None,
     cors: Optional[Union[Text, List[Text], None]] = None,
     auth_token: Optional[Text] = None,
     enable_api: bool = True,
@@ -190,10 +212,6 @@ def configure_app(
             logger.info("Killing Sanic server now.")
             running_app.stop()  # kill the sanic server
 
-    @app.after_server_stop
-    async def after_server_stop(running_app: Sanic) -> None:
-        plugin_manager().hook.after_server_stop()
-
     if server_listeners:
         for listener, event in server_listeners:
             app.register_listener(listener, event)
@@ -346,3 +364,7 @@ async def close_resources(app: Sanic, _: AbstractEventLoop) -> None:
     event_broker = current_agent.tracker_store.event_broker
     if event_broker:
         await event_broker.close()
+
+    privacy_manager = current_agent.privacy_manager
+    if privacy_manager:
+        privacy_manager.stop()

rasa/core/tracker_stores/tracker_store.py

@@ -671,7 +671,7 @@ def _create_from_endpoint_config(
 
     structlogger.debug(
         "tracker_store.create_tracker_store_from_endpoint_config",
-        eventi_info=f"Connected to {tracker_store.__class__.__name__}.",
+        event_info=f"Connected to {tracker_store.__class__.__name__}.",
     )
 
     return tracker_store

rasa/core/training/interactive.py

@@ -47,8 +47,8 @@ import rasa.shared.utils.io
 import rasa.utils.io as io_utils
 from rasa import telemetry
 from rasa.core import run, utils
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.constants import DEFAULT_SERVER_FORMAT, DEFAULT_SERVER_PORT
-from rasa.core.utils import AvailableEndpoints
 from rasa.shared.constants import (
     DEFAULT_SENDER_ID,
     DOCS_URL_NLU_BASED_POLICIES,