rasa-pro 3.13.0rc2__tar.gz → 3.13.0rc3__tar.gz

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.13.0rc2
+Version: 3.13.0rc3
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.13.0rc2"
+version = "3.13.0rc3"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -374,6 +374,7 @@ convention = "google"
 
 
 
+
 [tool.poetry.group.dev.dependencies]
 ruff = ">=0.3.5,<0.4.0"
 docker = "~7.1.0"

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/rasa/core/channels/voice_stream/audiocodes.py

@@ -104,10 +104,10 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
 
     def __init__(
         self,
-        token: Optional[Text],
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        token: Optional[Text] = None,
     ):
         mark_as_beta_feature("Audiocodes (audiocodes_stream) Channel")
         super().__init__(

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/rasa/core/policies/enterprise_search_policy.py

@@ -4,7 +4,7 @@ import importlib.resources
 import json
 import os.path
 import re
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple
 
 import dotenv
 import structlog
@@ -139,6 +139,8 @@ DEFAULT_ENTERPRISE_SEARCH_PROMPT_WITH_RELEVANCY_CHECK_AND_CITATION_TEMPLATE = (
 
 _ENTERPRISE_SEARCH_ANSWER_NOT_RELEVANT_PATTERN = re.compile(r"\[NO_RAG_ANSWER\]")
 
+_ENTERPRISE_SEARCH_CITATION_PATTERN = re.compile(r"\[([^\]]+)\]")
+
 
 class VectorStoreConnectionError(RasaException):
     """Exception raised for errors in connecting to the vector store."""
@@ -944,10 +946,18 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
     @staticmethod
     def post_process_citations(llm_answer: str) -> str:
-        """Post-process the LLM answer.
-
-         Re-writes the bracketed numbers to start from 1 and
-         re-arranges the sources to follow the enumeration order.
+        """Post-processes the LLM answer to correctly number and sort citations and
+        sources.
+
+        - Handles both single `[1]` and grouped `[1, 3]` citations.
+        - Rewrites the numbers in square brackets in the answer text to start from 1
+        and be sorted within each group.
+        - Reorders the sources according to the order of their first appearance
+        in the text.
+        - Removes citations from the text that point to sources missing from
+        the source list.
+        - Keeps sources that are not cited in the text, placing them at the end
+        of the list.
 
         Args:
             llm_answer: The LLM answer.
@@ -961,77 +971,160 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
         # Split llm_answer into answer and citations
         try:
-            answer, citations = llm_answer.rsplit("Sources:", 1)
+            answer_part, sources_part = llm_answer.rsplit("Sources:", 1)
         except ValueError:
-            # if there is no "Sources:" in the llm_answer
-            return llm_answer
-
-        # Find all source references in the answer
-        pattern = r"\[\s*(\d+(?:\s*,\s*\d+)*)\s*\]"
-        matches = re.findall(pattern, answer)
-        old_source_indices = [
-            int(num.strip()) for match in matches for num in match.split(",")
-        ]
+            # if there is no "Sources:" separator, return the original llm_answer
+            return llm_answer.strip()
 
-        # Map old source references to the correct enumeration
-        renumber_mapping = {num: idx + 1 for idx, num in enumerate(old_source_indices)}
-
-        # remove whitespace from original source citations in answer
-        for match in matches:
-            answer = answer.replace(f"[{match}]", f"[{match.replace(' ', '')}]")
-
-        new_answer = []
-        for word in answer.split():
-            matches = re.findall(pattern, word)
-            if matches:
-                for match in matches:
-                    if "," in match:
-                        old_indices = [
-                            int(num.strip()) for num in match.split(",") if num
-                        ]
-                        new_indices = [
-                            renumber_mapping[old_index]
-                            for old_index in old_indices
-                            if old_index in renumber_mapping
-                        ]
-                        if not new_indices:
-                            continue
-
-                        word = word.replace(
-                            match, f"{', '.join(map(str, new_indices))}"
-                        )
-                    else:
-                        old_index = int(match.strip("[].,:;?!"))
-                        new_index = renumber_mapping.get(old_index)
-                        if not new_index:
-                            continue
+        # Parse the sources block to extract valid sources and other lines
+        valid_sources, other_source_lines = EnterpriseSearchPolicy._parse_sources_block(
+            sources_part
+        )
+
+        # Find all unique, valid citations in the answer text in their order
+        # of appearance
+        cited_order = EnterpriseSearchPolicy._get_cited_order(
+            answer_part, valid_sources
+        )
+
+        # Create a mapping from the old source numbers to the new, sequential numbers.
+        # For example, if the citation order in the text was [3, 1, 2], this map
+        # becomes {3: 1, 1: 2, 2: 3}. This allows for a quick lookup when rewriting
+        # the citations
+        renumbering_map = {
+            old_num: new_num + 1 for new_num, old_num in enumerate(cited_order)
+        }
 
-                        word = word.replace(str(old_index), str(new_index))
-            new_answer.append(word)
+        # Rewrite the citations in the answer text based on the renumbering map
+        processed_answer = EnterpriseSearchPolicy._rewrite_answer_citations(
+            answer_part, renumbering_map
+        )
+
+        # Build the new list of sources
+        new_sources_list = EnterpriseSearchPolicy._build_final_sources_list(
+            cited_order,
+            renumbering_map,
+            valid_sources,
+            other_source_lines,
+        )
+
+        if len(new_sources_list) > 0:
+            processed_answer += "\nSources:\n" + "\n".join(new_sources_list)
+
+        return processed_answer
+
+    @staticmethod
+    def _parse_sources_block(sources_part: str) -> Tuple[Dict[int, str], List[str]]:
+        """Parses the sources block from the LLM response.
+        Returns a tuple containing:
+        - A dictionary of valid sources matching the "[1] ..." format,
+        where the key is the source number
+        - A list of other source lines that do not match the specified format
+        """
+        valid_sources: Dict[int, str] = {}
+        other_source_lines: List[str] = []
+        source_line_pattern = re.compile(r"^\s*\[(\d+)\](.*)")
 
-        # join the words
-        joined_answer = " ".join(new_answer)
-        joined_answer += "\nSources:\n"
+        source_lines = sources_part.strip().split("\n")
 
-        new_sources: List[str] = []
+        for line in source_lines:
+            line = line.strip()
+            if not line:
+                continue
 
-        for line in citations.split("\n"):
-            pattern = r"(?<=\[)\d+"
-            match = re.search(pattern, line)
+            match = source_line_pattern.match(line)
             if match:
-                old_index = int(match.group(0))
-                new_index = renumber_mapping[old_index]
-                # replace only the first occurrence of the old index
-                line = line.replace(f"[{old_index}]", f"[{new_index}]", 1)
+                num = int(match.group(1))
+                valid_sources[num] = line
+            else:
+                other_source_lines.append(line)
+
+        return valid_sources, other_source_lines
+
+    @staticmethod
+    def _get_cited_order(
+        answer_part: str, available_sources: Dict[int, str]
+    ) -> List[int]:
+        """Find all unique, valid citations in the answer text in their order
+        # of appearance
+        """
+        cited_order: List[int] = []
+        seen_indices = set()
+
+        for match in _ENTERPRISE_SEARCH_CITATION_PATTERN.finditer(answer_part):
+            content = match.group(1)
+            indices_str = [s.strip() for s in content.split(",")]
+            for index_str in indices_str:
+                if index_str.isdigit():
+                    index = int(index_str)
+                    if index in available_sources and index not in seen_indices:
+                        cited_order.append(index)
+                        seen_indices.add(index)
+
+        return cited_order
+
+    @staticmethod
+    def _rewrite_answer_citations(
+        answer_part: str, renumber_map: Dict[int, int]
+    ) -> str:
+        """Rewrites the citations in the answer text based on the renumbering map."""
+
+        def replacer(match: re.Match) -> str:
+            content = match.group(1)
+            old_indices_str = [s.strip() for s in content.split(",")]
+            new_indices = [
+                renumber_map[int(s)]
+                for s in old_indices_str
+                if s.isdigit() and int(s) in renumber_map
+            ]
+            if not new_indices:
+                return ""
+
+            return f"[{', '.join(map(str, sorted(list(set(new_indices)))))}]"
+
+        processed_answer = _ENTERPRISE_SEARCH_CITATION_PATTERN.sub(
+            replacer, answer_part
+        )
+
+        # Clean up formatting after replacements
+        processed_answer = re.sub(r"\s+([,.?])", r"\1", processed_answer)
+        processed_answer = processed_answer.replace("[]", " ")
+        processed_answer = re.sub(r"\s+", " ", processed_answer)
+        processed_answer = processed_answer.strip()
+
+        return processed_answer
+
+    @staticmethod
+    def _build_final_sources_list(
+        cited_order: List[int],
+        renumbering_map: Dict[int, int],
+        valid_sources: Dict[int, str],
+        other_source_lines: List[str],
+    ) -> List[str]:
+        """Builds the final list of sources based on the cited order and
+        renumbering map.
+        """
+        new_sources_list: List[str] = []
+
+        # First, add the sorted, used sources
+        for old_num in cited_order:
+            new_num = renumbering_map[old_num]
+            source_line = valid_sources[old_num]
+            new_sources_list.append(
+                source_line.replace(f"[{old_num}]", f"[{new_num}]", 1)
+            )
 
-                # insert the line into the new_index position
-                new_sources.insert(new_index - 1, line)
-            elif line.strip():
-                new_sources.append(line)
+        # Then, add the unused but validly numbered sources
+        used_source_nums = set(cited_order)
+        # Sort by number to ensure a consistent order for uncited sources
+        for num, line in sorted(valid_sources.items()):
+            if num not in used_source_nums:
+                new_sources_list.append(line)
 
-        joined_sources = "\n".join(new_sources)
+        # Finally, add any other source lines
+        new_sources_list.extend(other_source_lines)
 
-        return joined_answer + joined_sources
+        return new_sources_list
 
     @classmethod
     def _perform_health_checks(

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/rasa/core/policies/enterprise_search_prompt_with_relevancy_check_and_citation_template.jinja2

@@ -1,8 +1,11 @@
-Based on the provided documents and the recent conversation context, answer the following question.
+{% if check_relevancy %}Based on the provided documents and the recent conversation context, answer the following question.
 Before responding, ensure the answer is directly supported by the documents or context.
 Do not make assumptions or infer beyond the given information.
 Only answer if you are more than 80% confident that the response is fully supported.
 If the answer cannot be determined, respond with: [NO_RAG_ANSWER]
+{% else %}Given the following information, please provide an answer based on the provided documents and the context of the recent conversation.
+If the answer is not known or cannot be determined from the provided documents or context, please state that you do not know to the user.
+{% endif %}
 
 ### Relevant Documents
 Use the following documents to answer the question:

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/rasa/core/policies/flows/flow_executor.py

@@ -41,6 +41,7 @@ from rasa.dialogue_understanding.patterns.internal_error import (
     InternalErrorPatternFlowStackFrame,
 )
 from rasa.dialogue_understanding.patterns.search import SearchPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.user_silence import FLOW_PATTERN_USER_SILENCE
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames import (
     BaseFlowStackFrame,
@@ -590,9 +591,9 @@ def run_step(
         initial_events.append(FlowStarted(flow.id, metadata=stack.current_context()))
 
     # FLow does not start with collect step or we are not in collect information pattern
-    if _first_step_is_not_collect(
-        step, previous_step_id
-    ) and not _in_collect_information_pattern(flow):
+    if _first_step_is_not_collect(step, previous_step_id) and not (
+        _in_collect_information_pattern(flow) or _in_pattern_user_silence(flow)
+    ):
         _append_global_silence_timeout_event(initial_events, tracker)
 
     if isinstance(step, CollectInformationFlowStep):
@@ -650,6 +651,11 @@ def _in_collect_information_pattern(flow: Flow) -> bool:
     return flow.id == FLOW_PATTERN_COLLECT_INFORMATION
 
 
+def _in_pattern_user_silence(flow: Flow) -> bool:
+    """Check if the current flow is a user silence pattern."""
+    return flow.id == FLOW_PATTERN_USER_SILENCE
+
+
 def _run_end_step(
     flow: Flow,
     flows: FlowsList,

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/rasa/core/tracker_stores/redis_tracker_store.py

@@ -88,17 +88,21 @@ class RedisTrackerStore(TrackerStore, SerializedTrackerAsText):
         if not timeout and self.record_exp:
             timeout = self.record_exp
 
-        stored = self.red.get(self.key_prefix + tracker.sender_id)
+        # if the sender_id starts with the key prefix, we remove it
+        # this is used to avoid storing the prefix twice
+        sender_id = tracker.sender_id
+        if sender_id.startswith(self.key_prefix):
+            sender_id = sender_id[len(self.key_prefix) :]
+
+        stored = self.red.get(self.key_prefix + sender_id)
 
         if stored is not None:
-            prior_tracker = self.deserialise_tracker(tracker.sender_id, stored)
+            prior_tracker = self.deserialise_tracker(sender_id, stored)
 
             tracker = self._merge_trackers(prior_tracker, tracker)
 
         serialised_tracker = self.serialise_tracker(tracker)
-        self.red.set(
-            self.key_prefix + tracker.sender_id, serialised_tracker, ex=timeout
-        )
+        self.red.set(self.key_prefix + sender_id, serialised_tracker, ex=timeout)
 
     async def delete(self, sender_id: Text) -> None:
         """Delete tracker for the given sender_id.
@@ -113,6 +117,9 @@ class RedisTrackerStore(TrackerStore, SerializedTrackerAsText):
             )
             return None
 
+        if sender_id.startswith(self.key_prefix):
+            sender_id = sender_id[len(self.key_prefix) :]
+
         self.red.delete(self.key_prefix + sender_id)
         structlogger.info(
             "redis_tracker_store.delete.deleted_tracker",
@@ -156,6 +163,9 @@ class RedisTrackerStore(TrackerStore, SerializedTrackerAsText):
             sender_id: Conversation ID to fetch the tracker for.
             fetch_all_sessions: Whether to fetch all sessions or only the last one.
         """
+        if sender_id.startswith(self.key_prefix):
+            sender_id = sender_id[len(self.key_prefix) :]
+
         stored = self.red.get(self.key_prefix + sender_id)
         if stored is None:
             structlogger.debug(

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -139,7 +139,8 @@ flows:
     steps:
       - noop: true
         next:
-          # Chitchat fallback
+          # Fallback for ChitChat command when IntentlessPolicy isn't set, but
+          # pattern_chitchat invokes action_trigger_chitchat
           - if: context.reason is "cannot_handle_chitchat"
             then:
               - action: utter_cannot_handle
@@ -164,7 +165,9 @@ flows:
     description: Conversation repair flow for off-topic interactions that won't disrupt the main conversation
     name: pattern chitchat
     steps:
-      - action: action_trigger_chitchat
+      - action: utter_cannot_handle
+      # To enable free-form response use:
+      # - action: utter_free_chitchat_response
 
   pattern_clarification:
     description: Conversation repair flow for handling ambiguous requests that could match multiple flows

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/rasa/dialogue_understanding/processor/command_processor.py

@@ -64,12 +64,6 @@ from rasa.shared.nlu.constants import COMMANDS
 
 structlogger = structlog.get_logger()
 
-CANNOT_HANDLE_REASON = (
-    "A command generator attempted to set a slot "
-    "with a value extracted by an extractor "
-    "that is incompatible with the slot mapping type."
-)
-
 
 def contains_command(commands: List[Command], typ: Type[Command]) -> bool:
     """Check if a list of commands contains a command of a given type.
@@ -587,6 +581,11 @@ def clean_up_slot_command(
             "command_processor.clean_up_slot_command.skip_command_slot_not_in_domain",
             command=command,
         )
+        resulting_commands.append(
+            CannotHandleCommand(
+                reason="The slot predicted by the LLM is not defined in the domain."
+            )
+        )
         return resulting_commands
 
     if not should_slot_be_set(slot, command, resulting_commands):
@@ -605,7 +604,10 @@ def clean_up_slot_command(
             for command in resulting_commands
         )
 
-        cannot_handle = CannotHandleCommand(reason=CANNOT_HANDLE_REASON)
+        cannot_handle = CannotHandleCommand(
+            reason="A command generator attempted to set a slot with a value extracted "
+            "by an extractor that is incompatible with the slot mapping type."
+        )
         if not slot_command_exists_already and cannot_handle not in resulting_commands:
             resulting_commands.append(cannot_handle)
 

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/rasa/llm_fine_tuning/annotation_module.py

@@ -9,8 +9,8 @@ from rasa.e2e_test.e2e_test_case import ActualStepOutput, TestCase, TestStep, Te
 from rasa.e2e_test.e2e_test_runner import TEST_TURNS_TYPE, E2ETestRunner
 from rasa.llm_fine_tuning.conversations import Conversation, ConversationStep
 from rasa.llm_fine_tuning.storage import StorageContext
-from rasa.shared.core.constants import USER
-from rasa.shared.core.events import UserUttered
+from rasa.shared.core.constants import BOT, USER
+from rasa.shared.core.events import BotUttered, UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FinetuningDataPreparationException
 from rasa.shared.nlu.constants import LLM_COMMANDS, LLM_PROMPT
@@ -83,16 +83,18 @@ def generate_conversation(
         Conversation.
     """
     steps = []
-    tracker_event_indices = [
-        i for i, event in enumerate(tracker.events) if isinstance(event, UserUttered)
-    ]
-
-    if len(test_case.steps) != len(tracker_event_indices):
-        raise FinetuningDataPreparationException(
-            "Number of test case steps and tracker events do not match."
-        )
 
     if assertions_used:
+        tracker_event_indices = [
+            i
+            for i, event in enumerate(tracker.events)
+            if isinstance(event, UserUttered)
+        ]
+        if len(test_case.steps) != len(tracker_event_indices):
+            raise FinetuningDataPreparationException(
+                "Number of test case steps and tracker events do not match."
+            )
+
         # we only have user steps, extract the bot response from the bot uttered
         # events of the test turn
         for i, (original_step, tracker_event_index) in enumerate(
@@ -110,8 +112,30 @@ def generate_conversation(
             )
             steps.extend(_create_bot_test_steps(test_turns[i]))
     else:
+        tracker_event_indices = [
+            i
+            for i, event in enumerate(tracker.events)
+            if isinstance(event, UserUttered) or isinstance(event, BotUttered)
+        ]
+
+        # Generally, we expect one or more bot response(s) for each user utterance
+        # in the test case, so that we can evaluate the actual bot response.
+        # If the test case ends with one or more user utterance(s) instead,
+        # we should thus trim those from the test case steps.
+        # This only applies to test cases that have at least one bot utterance;
+        # otherwise, all test case steps would be removed.
+        has_bot_utterance = any(step.actor == BOT for step in test_case.steps)
+        i = len(test_case.steps)
+        if has_bot_utterance:
+            while i > 0 and test_case.steps[i - 1].actor == USER:
+                i -= 1
+        test_case_steps = test_case.steps[:i]
+
+        # If the number of test case steps and tracker events differ,
+        # using zip ensures we only process pairs that exist in both lists.
+        # Prevents index errors and ensures we don't process unmatched steps or events.
         for i, (original_step, tracker_event_index) in enumerate(
-            zip(test_case.steps, tracker_event_indices)
+            zip(test_case_steps, tracker_event_indices)
         ):
             if original_step.actor == USER:
                 previous_turn = _get_previous_actual_step_output(test_turns, i)
@@ -127,6 +151,14 @@ def generate_conversation(
             else:
                 steps.append(original_step)
 
+        # the tracker should only include events up to the last bot utterance
+        # so that the resulting transcript ends with the last bot utterance too
+        # only applies to test cases that have at least one bot utterance
+        if has_bot_utterance and test_case.steps and test_case.steps[-1].actor == USER:
+            event_to_go_to = tracker_event_indices[len(test_case_steps)] - 1
+            timestamp = tracker.events[event_to_go_to].timestamp
+            tracker = tracker.travel_back_in_time(timestamp)
+
     # Some messages in an e2e test case could be mapped to commands via
     # 'NLUCommandAdapter', e.g. the message will not be annotated with a prompt and
     # commands pair. Only convert steps that have a prompt and commands present into a

{rasa_pro-3.13.0rc2 → rasa_pro-3.13.0rc3}/rasa/privacy/privacy_filter.py

@@ -2,6 +2,7 @@ import copy
 import datetime
 import json
 import os
+from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 import structlog
@@ -60,8 +61,17 @@ class PrivacyFilter:
     def _load_gliner_model() -> Optional[Any]:
         """Load the GLiNER model for PII detection."""
         local_model_path = os.getenv(GLINER_MODEL_PATH_ENV_VAR_NAME)
-        cache_dir = os.getenv(HUGGINGFACE_CACHE_DIR_ENV_VAR_NAME)
-        model_path = local_model_path or DEFAULT_PII_MODEL
+        cache_dir_env_value = os.getenv(HUGGINGFACE_CACHE_DIR_ENV_VAR_NAME)
+        cache_dir = Path(cache_dir_env_value).resolve() if cache_dir_env_value else None
+        model_path = (
+            Path(local_model_path).resolve() if local_model_path else DEFAULT_PII_MODEL
+        )
+        local_files_only = isinstance(model_path, Path) and model_path.exists()
+
+        structlogger.debug(
+            "rasa.privacy.privacy_filter.loading_gliner_model",
+            local_files_only=local_files_only,
+        )
 
         try:
             from gliner import GLiNER
@@ -69,6 +79,7 @@ class PrivacyFilter:
             return GLiNER.from_pretrained(
                 model_path,
                 cache_dir=cache_dir,
+                local_files_only=local_files_only,
             )
         except ImportError:
             structlogger.warning(
@@ -193,7 +204,9 @@ class PrivacyFilter:
 
         for key, slot in anonymized_slots.items():
             original_slot_value = key.split(":", 1)[1]
-            anonymized_text = user_event.text.replace(original_slot_value, slot.value)
+            anonymized_text = self._smart_replace(
+                user_event.text, original_slot_value, slot.value
+            )
             user_event.text = anonymized_text
 
             anonymized_parse_data[TEXT_KEY] = anonymized_text
@@ -232,7 +245,9 @@ class PrivacyFilter:
 
         for key, slot in anonymized_slots.items():
             original_slot_value = key.split(":", 1)[1]
-            anonymized_text = bot_event.text.replace(original_slot_value, slot.value)
+            anonymized_text = self._smart_replace(
+                bot_event.text, original_slot_value, slot.value
+            )
             bot_event.text = anonymized_text
 
         bot_event.text = self._anonymize_edge_cases(bot_event.text, anonymized_slots)
@@ -338,3 +353,41 @@ class PrivacyFilter:
             text = text.replace(entity_value, self._mask(entity[ENTITY_LABEL_KEY]))
 
         return text
+
+    @staticmethod
+    def _smart_replace(text: str, original_value: str, replacement: str) -> str:
+        """Replace original_value with replacement in text.
+
+        This method performs a string replacement in the text,
+        with special handling for floats.
+        If original_value is a float string like "24.0",
+        also tries replacing the integer version "24".
+
+        Args:
+            text (str): The text to perform replacements on
+            original_value (str): The value to replace
+            replacement (str): The replacement value
+
+        Returns:
+            str: The text with replacements applied
+        """
+        # First try the original replacement
+        result = text.replace(original_value, replacement)
+        if text != result:
+            return result
+
+        # If replacement didn't happen and it's a float,
+        # try replacing the integer version
+        if "." in original_value:
+            try:
+                float_val = float(original_value)
+                if float_val.is_integer():
+                    int_version = str(int(float_val))
+                    result = result.replace(int_version, replacement)
+            except ValueError:
+                structlogger.warning(
+                    "rasa.privacy.privacy_filter.smart_replace_float_error",
+                    event_info="Unable to anonymize float value.",
+                )
+
+        return result