rasa-pro 3.9.17__py3-none-any.whl → 3.10.3__py3-none-any.whl

rasa/core/policies/intentless_policy.py

@@ -8,13 +8,14 @@ import tiktoken
 from jinja2 import Template
 from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings
-from langchain.vectorstores import FAISS
+from langchain_community.vectorstores.faiss import FAISS
 
 import rasa.shared.utils.io
 from rasa import telemetry
 from rasa.core.constants import (
     CHAT_POLICY_PRIORITY,
     POLICY_PRIORITY,
+    UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.policies.policy import Policy, PolicyPrediction, SupportedData
 from rasa.dialogue_understanding.stack.frames import (
@@ -27,7 +28,17 @@ from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
-from rasa.shared.constants import REQUIRED_SLOTS_KEY
+from rasa.shared.constants import (
+    REQUIRED_SLOTS_KEY,
+    EMBEDDINGS_CONFIG_KEY,
+    LLM_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    PROMPT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    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 (
@@ -42,6 +53,10 @@ from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, RasaCoreException
 from rasa.shared.nlu.constants import PREDICTED_CONFIDENCE_KEY
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.providers.embedding._langchain_embedding_client_adapter import (
+    _LangchainEmbeddingClientAdapter,
+)
+from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
     AI,
@@ -55,6 +70,7 @@ from rasa.shared.utils.llm import (
     llm_factory,
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
+    try_instantiate_llm_client,
 )
 from rasa.utils.ml_utils import (
     extract_ai_response_examples,
@@ -68,7 +84,6 @@ from rasa.utils.log_utils import log_llm
 
 if TYPE_CHECKING:
     from rasa.core.featurizers.tracker_featurizers import TrackerFeaturizer
-    from langchain.llms.base import BaseLLM
 
 structlogger = structlog.get_logger()
 
@@ -87,18 +102,16 @@ MAX_NUMBER_OF_TOKENS_FOR_SAMPLES = 900
 # the config property name for the confidence of the nlu prediction
 NLU_ABSTENTION_THRESHOLD = "nlu_abstention_threshold"
 
-PROMPT = "prompt"
-
 DEFAULT_LLM_CONFIG = {
-    "_type": "openai",
-    "request_timeout": 5,
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME,
     "temperature": 0.0,
-    "model_name": DEFAULT_OPENAI_CHAT_MODEL_NAME,
     "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TIMEOUT_CONFIG_KEY: 5,
 }
 
 DEFAULT_EMBEDDINGS_CONFIG = {
-    "_type": "openai",
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
 }
 
@@ -106,8 +119,6 @@ DEFAULT_INTENTLESS_PROMPT_TEMPLATE = importlib.resources.open_text(
     "rasa.core.policies", "intentless_prompt_template.jinja2"
 ).name
 
-EMBEDDINGS_CONFIG_KEY = "embeddings"
-LLM_CONFIG_KEY = "llm"
 INTENTLESS_PROMPT_TEMPLATE_FILE_NAME = "intentless_policy_prompt.jinja2"
 
 
@@ -366,7 +377,7 @@ class IntentlessPolicy(Policy):
             NLU_ABSTENTION_THRESHOLD: 0.9,
             LLM_CONFIG_KEY: DEFAULT_LLM_CONFIG,
             EMBEDDINGS_CONFIG_KEY: DEFAULT_EMBEDDINGS_CONFIG,
-            PROMPT: DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
+            PROMPT_CONFIG_KEY: DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
         }
 
     @staticmethod
@@ -405,7 +416,7 @@ class IntentlessPolicy(Policy):
         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]
+            self.config[PROMPT_CONFIG_KEY]
         )
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
 
@@ -416,9 +427,10 @@ class IntentlessPolicy(Policy):
         Returns:
         The embedder.
         """
-        return embedder_factory(
+        client = embedder_factory(
             config.get(EMBEDDINGS_CONFIG_KEY), DEFAULT_EMBEDDINGS_CONFIG
         )
+        return _LangchainEmbeddingClientAdapter(client)
 
     def embeddings_property(self, prop: str) -> Optional[str]:
         """Returns the property of the embeddings config."""
@@ -458,6 +470,13 @@ class IntentlessPolicy(Policy):
             A policy must return its resource locator so that potential children nodes
             can load the policy from the resource.
         """
+        try_instantiate_llm_client(
+            self.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            "intentless_policy.train",
+            "IntentlessPolicy",
+        )
+
         responses = filter_responses(responses, forms, flows or FlowsList([]))
         telemetry.track_intentless_policy_train()
         response_texts = [r for r in extract_ai_response_examples(responses.data)]
@@ -500,11 +519,12 @@ class IntentlessPolicy(Policy):
 
         structlogger.info("intentless_policy.training.completed")
         telemetry.track_intentless_policy_train_completed(
-            embeddings_type=self.embeddings_property("_type"),
-            embeddings_model=self.embeddings_property("model")
-            or self.embeddings_property("model_name"),
-            llm_type=self.llm_property("_type"),
-            llm_model=self.llm_property("model") or self.llm_property("model_name"),
+            embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
+            embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
+            or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
+            llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
+            llm_model=self.llm_property(MODEL_CONFIG_KEY)
+            or self.llm_property(MODEL_NAME_CONFIG_KEY),
         )
 
         self.persist()
@@ -578,11 +598,12 @@ class IntentlessPolicy(Policy):
         )
 
         telemetry.track_intentless_policy_predict(
-            embeddings_type=self.embeddings_property("_type"),
-            embeddings_model=self.embeddings_property("model")
-            or self.embeddings_property("model_name"),
-            llm_type=self.llm_property("_type"),
-            llm_model=self.llm_property("model") or self.llm_property("model_name"),
+            embeddings_type=self.embeddings_property(PROVIDER_CONFIG_KEY),
+            embeddings_model=self.embeddings_property(MODEL_CONFIG_KEY)
+            or self.embeddings_property(MODEL_NAME_CONFIG_KEY),
+            llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
+            llm_model=self.llm_property(MODEL_CONFIG_KEY)
+            or self.llm_property(MODEL_NAME_CONFIG_KEY),
             score=score,
         )
 
@@ -595,7 +616,9 @@ class IntentlessPolicy(Policy):
         else:
             events = []
 
-        return self._prediction(result, events=events)
+        action_metadata = {UTTER_SOURCE_METADATA_KEY: self.__class__.__name__}
+
+        return self._prediction(result, events=events, action_metadata=action_metadata)
 
     async def generate_answer(
         self,
@@ -619,9 +642,10 @@ class IntentlessPolicy(Policy):
         )
         return await self._generate_llm_answer(llm, prompt)
 
-    async def _generate_llm_answer(self, llm: "BaseLLM", prompt: str) -> Optional[str]:
+    async def _generate_llm_answer(self, llm: LLMClient, prompt: str) -> Optional[str]:
         try:
-            return await llm.apredict(prompt)
+            llm_response = await llm.acompletion(prompt)
+            return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here
@@ -916,7 +940,7 @@ class IntentlessPolicy(Policy):
     def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint of the knowledge base for the graph."""
         prompt_template = get_prompt_template(
-            config.get("prompt"),
+            config.get(PROMPT_CONFIG_KEY),
             DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
         )
         return deep_container_fingerprint(prompt_template)

rasa/core/policies/ted_policy.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
-
 import logging
+
+from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from pathlib import Path
 from collections import defaultdict
 import contextlib
-from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
 import numpy as np
 import tensorflow as tf
+from typing import Any, List, Optional, Text, Dict, Tuple, Union, Type
 
-from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
@@ -49,22 +49,18 @@ from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.events import EntitiesAdded, Event
 from rasa.shared.core.domain import Domain
 from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.nlu.training_data.features import (
-    Features,
-    save_features,
-    load_features,
-)
+from rasa.shared.nlu.training_data.features import Features
 import rasa.shared.utils.io
 import rasa.utils.io
 from rasa.utils import train_utils
-from rasa.utils.tensorflow.feature_array import (
-    FeatureArray,
-    serialize_nested_feature_arrays,
-    deserialize_nested_feature_arrays,
-)
 from rasa.utils.tensorflow.models import RasaModel, TransformerRasaModel
 from rasa.utils.tensorflow import rasa_layers
-from rasa.utils.tensorflow.model_data import RasaModelData, FeatureSignature, Data
+from rasa.utils.tensorflow.model_data import (
+    RasaModelData,
+    FeatureSignature,
+    FeatureArray,
+    Data,
+)
 from rasa.utils.tensorflow.model_data_utils import convert_to_data_format
 from rasa.utils.tensorflow.constants import (
     LABEL,
@@ -965,32 +961,22 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted
         """
         model_filename = self._metadata_filename()
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.priority.json", self.priority
-        )
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.meta.json", self.config
+        rasa.utils.io.json_pickle(
+            model_path / f"{model_filename}.priority.pkl", self.priority
         )
-        # save data example
-        serialize_nested_feature_arrays(
-            self.data_example,
-            str(model_path / f"{model_filename}.data_example.st"),
-            str(model_path / f"{model_filename}.data_example_metadata.json"),
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.meta.pkl", self.config
         )
-        # save label data
-        serialize_nested_feature_arrays(
-            dict(self._label_data.data) if self._label_data is not None else {},
-            str(model_path / f"{model_filename}.label_data.st"),
-            str(model_path / f"{model_filename}.label_data_metadata.json"),
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.data_example.pkl", self.data_example
         )
-        # save fake features
-        metadata = save_features(
-            self.fake_features, str(model_path / f"{model_filename}.fake_features.st")
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.fake_features.pkl", self.fake_features
         )
-        rasa.shared.utils.io.dump_obj_as_json_to_file(
-            model_path / f"{model_filename}.fake_features_metadata.json", metadata
+        rasa.utils.io.pickle_dump(
+            model_path / f"{model_filename}.label_data.pkl",
+            dict(self._label_data.data) if self._label_data is not None else {},
         )
-
         entity_tag_specs = (
             [tag_spec._asdict() for tag_spec in self._entity_tag_specs]
             if self._entity_tag_specs
@@ -1008,29 +994,18 @@ class TEDPolicy(Policy):
             model_path: Path where model is to be persisted.
         """
         tf_model_file = model_path / f"{cls._metadata_filename()}.tf_model"
-
-        # load data example
-        loaded_data = deserialize_nested_feature_arrays(
-            str(model_path / f"{cls._metadata_filename()}.data_example.st"),
-            str(model_path / f"{cls._metadata_filename()}.data_example_metadata.json"),
+        loaded_data = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.data_example.pkl"
         )
-        # load label data
-        loaded_label_data = deserialize_nested_feature_arrays(
-            str(model_path / f"{cls._metadata_filename()}.label_data.st"),
-            str(model_path / f"{cls._metadata_filename()}.label_data_metadata.json"),
+        label_data = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.label_data.pkl"
         )
-        label_data = RasaModelData(data=loaded_label_data)
-
-        # load fake features
-        metadata = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.fake_features_metadata.json"
+        fake_features = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.fake_features.pkl"
         )
-        fake_features = load_features(
-            str(model_path / f"{cls._metadata_filename()}.fake_features.st"), metadata
-        )
-
-        priority = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.priority.json"
+        label_data = RasaModelData(data=label_data)
+        priority = rasa.utils.io.json_unpickle(
+            model_path / f"{cls._metadata_filename()}.priority.pkl"
         )
         entity_tag_specs = rasa.shared.utils.io.read_json_file(
             model_path / f"{cls._metadata_filename()}.entity_tag_specs.json"
@@ -1048,8 +1023,8 @@ class TEDPolicy(Policy):
             )
             for tag_spec in entity_tag_specs
         ]
-        model_config = rasa.shared.utils.io.read_json_file(
-            model_path / f"{cls._metadata_filename()}.meta.json"
+        model_config = rasa.utils.io.pickle_load(
+            model_path / f"{cls._metadata_filename()}.meta.pkl"
         )
 
         return {
@@ -1095,7 +1070,7 @@ class TEDPolicy(Policy):
     ) -> TEDPolicy:
         featurizer = TrackerFeaturizer.load(model_path)
 
-        if not (model_path / f"{cls._metadata_filename()}.data_example.st").is_file():
+        if not (model_path / f"{cls._metadata_filename()}.data_example.pkl").is_file():
             return cls(
                 config,
                 model_storage,

rasa/core/policies/unexpected_intent_policy.py

@@ -5,7 +5,6 @@ from typing import Any, List, Optional, Text, Dict, Type, Union
 
 import numpy as np
 import tensorflow as tf
-
 import rasa.utils.common
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
@@ -17,7 +16,6 @@ from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.constants import SLOTS, ACTIVE_LOOP, ACTION_UNLIKELY_INTENT_NAME
 from rasa.shared.core.events import UserUttered, ActionExecuted
-import rasa.shared.utils.io
 from rasa.shared.nlu.constants import (
     INTENT,
     TEXT,
@@ -105,6 +103,8 @@ from rasa.utils.tensorflow.constants import (
 )
 from rasa.utils.tensorflow import layers
 from rasa.utils.tensorflow.model_data import RasaModelData, FeatureArray, Data
+
+import rasa.utils.io as io_utils
 from rasa.core.exceptions import RasaCoreException
 from rasa.shared.utils import common
 
@@ -881,12 +881,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted
         """
         super().persist_model_utilities(model_path)
-
-        from safetensors.numpy import save_file
-
-        save_file(
-            {str(k): np.array(v) for k, v in self.label_quantiles.items()},
-            model_path / f"{self._metadata_filename()}.label_quantiles.st",
+        io_utils.pickle_dump(
+            model_path / f"{self._metadata_filename()}.label_quantiles.pkl",
+            self.label_quantiles,
         )
 
     @classmethod
@@ -897,14 +894,9 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
             model_path: Path where model is to be persisted.
         """
         model_utilties = super()._load_model_utilities(model_path)
-
-        from safetensors.numpy import load_file
-
-        loaded_label_quantiles = load_file(
-            model_path / f"{cls._metadata_filename()}.label_quantiles.st"
+        label_quantiles = io_utils.pickle_load(
+            model_path / f"{cls._metadata_filename()}.label_quantiles.pkl"
         )
-        label_quantiles = {int(k): list(v) for k, v in loaded_label_quantiles.items()}
-
         model_utilties.update({"label_quantiles": label_quantiles})
         return model_utilties
 

rasa/core/processor.py

@@ -3,12 +3,12 @@ import copy
 import logging
 import structlog
 import os
+import re
 from pathlib import Path
 import tarfile
 import time
 from types import LambdaType
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Tuple, Union
-
 from rasa.core.actions.action_exceptions import ActionExecutionRejection
 from rasa.core.actions.forms import FormAction
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
@@ -751,20 +751,17 @@ class MessageProcessor:
                     message=processed_message, domain=self.domain
                 )
 
-            # Invalid use of slash syntax
+            # Invalid use of slash syntax, sanitize the message before passing
+            # it to the graph
             if (
                 processed_message.starts_with_slash_syntax()
                 and not processed_message.has_intent()
                 and not processed_message.has_commands()
             ):
-                parse_data = self._parse_invalid_use_of_slash_syntax(
-                    processed_message, tracker, only_output_properties
-                )
+                message = self._sanitize_message(message)
 
             # Intent or commands are not explicitly present. Pass message to graph.
-            elif not (
-                processed_message.has_intent() or processed_message.has_commands()
-            ):
+            if not (processed_message.has_intent() or processed_message.has_commands()):
                 parse_data = await self._parse_message_with_graph(
                     message, tracker, only_output_properties
                 )
@@ -788,44 +785,16 @@ class MessageProcessor:
 
         return parse_data
 
-    def _parse_invalid_use_of_slash_syntax(
-        self,
-        message: Message,
-        tracker: Optional[DialogueStateTracker] = None,
-        only_output_properties: bool = True,
-    ) -> Dict[Text, Any]:
-        structlogger.warning(
-            "processor.message.parse.invalid_use_of_slash_syntax",
-            event_info=(
-                "Message starts with '/', but no intents or commands are"
-                "passed. Returning CannotHandleCommand() as a fallback."
-            ),
-            message=message.get(TEXT),
-        )
-        parse_data: Dict[Text, Any] = {
-            TEXT: "",
-            INTENT: {INTENT_NAME_KEY: None, PREDICTED_CONFIDENCE_KEY: 0.0},
-            ENTITIES: [],
-        }
-        parse_data.update(
-            message.as_dict(only_output_properties=only_output_properties)
-        )
-        commands = parse_data.get(COMMANDS, [])
-        commands += [
-            CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT).as_dict()
-        ]
-
-        if (
-            tracker is not None
-            and 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
-            commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True).as_dict()]
-
-        parse_data[COMMANDS] = commands
-        return parse_data
+    def _sanitize_message(self, message: UserMessage) -> UserMessage:
+        """Sanitize user message by removing prepended slashes before the
+        actual content.
+        """
+        # Regex pattern to match leading slashes and any whitespace before
+        # actual content
+        pattern = r"^[/\s]+"
+        # Remove the matched pattern from the beginning of the message
+        message.text = re.sub(pattern, "", message.text).strip()
+        return message
 
     async def _parse_message_with_commands_and_intents(
         self,

rasa/core/run.py

@@ -9,12 +9,12 @@ from functools import partial
 from typing import (
     Any,
     Callable,
+    Dict,
     List,
     Optional,
     Text,
     Tuple,
     Union,
-    Dict,
 )
 
 from sanic import Sanic
@@ -24,7 +24,6 @@ import rasa.core.utils
 import rasa.shared.utils.common
 import rasa.shared.utils.io
 import rasa.utils
-from rasa.utils import licensing
 import rasa.utils.common
 import rasa.utils.io
 from rasa import server, telemetry
@@ -34,9 +33,11 @@ from rasa.core.agent import Agent
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
 from rasa.core.utils import AvailableEndpoints
+from rasa.nlu.persistor import StorageType
 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
 
 logger = logging.getLogger()  # get the root logger
 
@@ -210,7 +211,7 @@ def serve_application(
     jwt_private_key: Optional[Text] = None,
     jwt_method: Optional[Text] = None,
     endpoints: Optional[AvailableEndpoints] = None,
-    remote_storage: Optional[Text] = None,
+    remote_storage: Optional[StorageType] = None,
     log_file: Optional[Text] = None,
     ssl_certificate: Optional[Text] = None,
     ssl_keyfile: Optional[Text] = None,
@@ -295,7 +296,7 @@ def serve_application(
 async def load_agent_on_start(
     model_path: Text,
     endpoints: AvailableEndpoints,
-    remote_storage: Optional[Text],
+    remote_storage: Optional[StorageType],
     app: Sanic,
     loop: AbstractEventLoop,
 ) -> Agent:

rasa/core/tracker_store.py

@@ -26,10 +26,10 @@ from typing import (
 from boto3.dynamodb.conditions import Key
 from pymongo.collection import Collection
 
-import rasa.core.utils as core_utils
 import rasa.shared.utils.cli
 import rasa.shared.utils.common
 import rasa.shared.utils.io
+import rasa.utils.json_utils
 from rasa.plugin import plugin_manager
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
 from rasa.core.brokers.broker import EventBroker
@@ -705,7 +705,7 @@ class DynamoTrackerStore(TrackerStore, SerializedTrackerAsDict):
 
         DynamoDB cannot store `float`s, so we'll convert them to `Decimal`s.
         """
-        return core_utils.replace_floats_with_decimals(
+        return rasa.utils.json_utils.replace_floats_with_decimals(
             SerializedTrackerAsDict.serialise_tracker(tracker)
         )
 
@@ -747,12 +747,16 @@ class DynamoTrackerStore(TrackerStore, SerializedTrackerAsDict):
             events_with_floats = []
             for dialogue in dialogues:
                 if dialogue.get("events"):
-                    events = core_utils.replace_decimals_with_floats(dialogue["events"])
+                    events = rasa.utils.json_utils.replace_decimals_with_floats(
+                        dialogue["events"]
+                    )
                     events_with_floats += events
         else:
             events = dialogues[0].get("events", [])
             # `float`s are stored as `Decimal` objects - we need to convert them back
-            events_with_floats = core_utils.replace_decimals_with_floats(events)
+            events_with_floats = rasa.utils.json_utils.replace_decimals_with_floats(
+                events
+            )
 
         if self.domain is None:
             slots = []