rasa-pro 3.10.16__py3-none-any.whl → 3.11.0a1__py3-none-any.whl

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

@@ -101,9 +101,6 @@ logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
 MAX_NUMBER_OF_PREDICTIONS = int(os.environ.get("MAX_NUMBER_OF_PREDICTIONS", "10"))
-MAX_NUMBER_OF_PREDICTIONS_CALM = int(
-    os.environ.get("MAX_NUMBER_OF_PREDICTIONS_CALM", "1000")
-)
 
 
 class MessageProcessor:
@@ -117,7 +114,6 @@ class MessageProcessor:
         generator: NaturalLanguageGenerator,
         action_endpoint: Optional[EndpointConfig] = None,
         max_number_of_predictions: int = MAX_NUMBER_OF_PREDICTIONS,
-        max_number_of_predictions_calm: int = MAX_NUMBER_OF_PREDICTIONS_CALM,
         on_circuit_break: Optional[LambdaType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional["AvailableEndpoints"] = None,
@@ -126,6 +122,7 @@ class MessageProcessor:
         self.nlg = generator
         self.tracker_store = tracker_store
         self.lock_store = lock_store
+        self.max_number_of_predictions = max_number_of_predictions
         self.on_circuit_break = on_circuit_break
         self.action_endpoint = action_endpoint
         self.model_filename, self.model_metadata, self.graph_runner = self._load_model(
@@ -133,10 +130,6 @@ class MessageProcessor:
         )
         self.endpoints = endpoints
 
-        self.max_number_of_predictions = max_number_of_predictions
-        self.max_number_of_predictions_calm = max_number_of_predictions_calm
-        self.is_calm_assistant = self._is_calm_assistant()
-
         if self.model_metadata.assistant_id is None:
             rasa.shared.utils.io.raise_warning(
                 f"The model metadata does not contain a value for the "
@@ -979,15 +972,11 @@ class MessageProcessor:
     ) -> int:
         """Select the action limit based on the tracker state.
 
-        This function determines the maximum number of predictions that should be
-        made during a dialogue conversation. Typically, the number of predictions
-        is limited to the number of actions executed so far in the conversation.
-        However, in certain states (e.g., when the user is correcting the
-        conversation flow), more predictions may be allowed as the system traverses
-        through a long dialogue flow.
-
-        Additionally, if the `ROUTE_TO_CALM_SLOT` is present in the tracker slots,
-        the action limit is adjusted to a separate limit for CALM-based flows.
+        Usually, we want to limit the number of predictions to the number of actions
+        that have been executed in the conversation so far. However, if the
+        conversation is currently in a state where the user is correcting the flow
+        we want to allow for more predictions to be made as we might be traversing
+        through a long flow.
 
         Args:
             tracker: instance of DialogueStateTracker.
@@ -995,18 +984,6 @@ class MessageProcessor:
         Returns:
         The maximum number of predictions to make.
         """
-        # Check if it is a CALM assistant and if so, that the `ROUTE_TO_CALM_SLOT`
-        # is either not present or set to `True`.
-        # If it does, use the specific prediction limit for CALM assistants.
-        # Otherwise, use the default prediction limit.
-        if self.is_calm_assistant and (
-            not tracker.has_coexistence_routing_slot
-            or tracker.get_slot(ROUTE_TO_CALM_SLOT)
-        ):
-            max_number_of_predictions = self.max_number_of_predictions_calm
-        else:
-            max_number_of_predictions = self.max_number_of_predictions
-
         reversed_events = list(tracker.events)[::-1]
         is_conversation_in_flow_correction = False
         for e in reversed_events:
@@ -1021,10 +998,8 @@ class MessageProcessor:
             # allow for more predictions to be made as we might be traversing through
             # a long flow. We multiply the number of predictions by 10 to allow for
             # more predictions to be made - the factor is a best guess.
-            return max_number_of_predictions * 5
-
-        # Return the default
-        return max_number_of_predictions
+            return self.max_number_of_predictions * 5
+        return self.max_number_of_predictions
 
     def is_action_limit_reached(
         self, tracker: DialogueStateTracker, should_predict_another_action: bool
@@ -1254,13 +1229,11 @@ class MessageProcessor:
             tracker.update(events[0])
             return self.should_predict_another_action(action.name())
         except Exception:
-            structlogger.exception(
-                "rasa.core.processor.run_action.exception",
-                event_info=f"Encountered an exception while "
-                f"running action '{action.name()}'."
-                f"Bot will continue, but the actions events are lost. "
-                f"Please check the logs of your action server for "
-                f"more information.",
+            logger.exception(
+                f"Encountered an exception while running action '{action.name()}'."
+                "Bot will continue, but the actions events are lost. "
+                "Please check the logs of your action server for "
+                "more information."
             )
             events = []
 
@@ -1414,27 +1387,3 @@ class MessageProcessor:
         ]
 
         return len(filtered_commands) > 0
-
-    def _is_calm_assistant(self) -> bool:
-        """Inspects the nodes of the graph schema to determine whether
-        any node is associated with the `FlowPolicy`, which is indicative of a
-        CALM assistant setup.
-
-        Returns:
-            bool: True if any node in the graph schema uses `FlowPolicy`.
-        """
-        # Get the graph schema's nodes from the graph runner.
-        nodes: dict[str, Any] = self.graph_runner._graph_schema.nodes  # type: ignore[attr-defined]
-
-        flow_policy_class_path = "rasa.core.policies.flow_policy.FlowPolicy"
-        # Iterate over the nodes and check if any node uses `FlowPolicy`.
-        for node_name, schema_node in nodes.items():
-            if (
-                schema_node.uses is not None
-                and f"{schema_node.uses.__module__}.{schema_node.uses.__name__}"
-                == flow_policy_class_path
-            ):
-                return True
-
-        # Return False if no node is found using `FlowPolicy`.
-        return False

rasa/core/run.py

@@ -19,6 +19,7 @@ from typing import (
 
 from sanic import Sanic
 from sanic.worker.loader import AppLoader
+from rasa.core.channels.development_inspector import DevelopmentInspectProxy
 
 import rasa.core.utils
 import rasa.shared.utils.common
@@ -32,8 +33,8 @@ from rasa.core import agent, channels, constants
 from rasa.core.agent import Agent
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
+from rasa.core.persistor import StorageType
 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
@@ -224,6 +225,7 @@ def serve_application(
     syslog_protocol: Optional[Text] = None,
     request_timeout: Optional[int] = None,
     server_listeners: Optional[List[Tuple[Callable, Text]]] = None,
+    inspect: Optional[bool] = False,
 ) -> None:
     """Run the API entrypoint."""
     if not channel and not credentials:
@@ -231,6 +233,13 @@ def serve_application(
 
     input_channels = create_http_input_channels(channel, credentials)
 
+    if inspect:
+        logger.info("Starting development inspector.")
+        input_channels = [DevelopmentInspectProxy(ic) for ic in input_channels]
+
+        # the inspector needs the api to retrieve slots and flows
+        enable_api = True
+
     app = configure_app(
         input_channels,
         cors,
@@ -311,6 +320,7 @@ async def load_agent_on_start(
         endpoints=endpoints,
         loop=loop,
     )
+
     logger.info("Rasa server is up and running.")
     return app.ctx.agent
 

rasa/core/secrets_manager/constants.py

@@ -23,6 +23,7 @@ VAULT_TRANSIT_MOUNT_POINT_ENV_NAME = "VAULT_TRANSIT_MOUNT_POINT"
 VAULT_NAMESPACE_ENV_NAME = "VAULT_NAMESPACE"
 VAULT_DEFAULT_RASA_SECRETS_PATH = "rasa-secrets"
 VAULT_SECRET_MANAGER_NAME = "vault"
+VAULT_MOUNT_POINT_ENV_NAME = "VAULT_MOUNT_POINT"
 
 
 VAULT_ENDPOINT_URL_LABEL = "url"
@@ -30,3 +31,6 @@ VAULT_ENDPOINT_TOKEN_LABEL = "token"
 VAULT_ENDPOINT_SECRETS_PATH_LABEL = "secrets_path"
 VAULT_ENDPOINT_TRANSIT_MOUNT_POINT_LABEL = "transit_mount_point"
 VAULT_ENDPOINT_NAMESPACE_LABEL = "namespace"
+VAULT_ENDPOINT_MOUNT_POINT_LABEL = "mount_point"
+
+VAULT_MOUNT_POINT_DEFAULT_VALUE = "secret"

rasa/core/secrets_manager/factory.py

@@ -7,9 +7,11 @@ from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
 from rasa.core.secrets_manager.constants import (
     SECRET_MANAGER_ENV_NAME,
     VAULT_DEFAULT_RASA_SECRETS_PATH,
+    VAULT_ENDPOINT_MOUNT_POINT_LABEL,
     VAULT_ENDPOINT_NAMESPACE_LABEL,
     VAULT_ENDPOINT_SECRETS_PATH_LABEL,
     VAULT_ENDPOINT_TRANSIT_MOUNT_POINT_LABEL,
+    VAULT_MOUNT_POINT_ENV_NAME,
     VAULT_NAMESPACE_ENV_NAME,
     VAULT_RASA_SECRETS_PATH_ENV_NAME,
     VAULT_SECRET_MANAGER_NAME,
@@ -48,6 +50,7 @@ def create(config: SecretManagerConfig) -> Optional[SecretsManager]:
             transit_mount_point=vault_config.transit_mount_point,
             secrets_path=vault_config.secrets_path,
             namespace=vault_config.namespace,
+            mount_point=vault_config.mount_point,
         )
 
     return secret_manager
@@ -79,6 +82,7 @@ def read_vault_endpoint_config(
         )
         secrets_path = endpoint_config.kwargs.get(VAULT_ENDPOINT_SECRETS_PATH_LABEL)
         namespace = endpoint_config.kwargs.get(VAULT_ENDPOINT_NAMESPACE_LABEL)
+        mount_point = endpoint_config.kwargs.get(VAULT_ENDPOINT_MOUNT_POINT_LABEL)
 
         return VaultSecretManagerNonStrictConfig(
             url=url,
@@ -86,6 +90,7 @@ def read_vault_endpoint_config(
             transit_mount_point=transit_mount_point,
             secrets_path=secrets_path or VAULT_DEFAULT_RASA_SECRETS_PATH,
             namespace=namespace,
+            mount_point=mount_point,
         )
 
     return None
@@ -102,6 +107,7 @@ def read_vault_env_vars() -> VaultSecretManagerNonStrictConfig:
     transit_mount_point = os.getenv(VAULT_TRANSIT_MOUNT_POINT_ENV_NAME)
     secrets_path = os.getenv(VAULT_RASA_SECRETS_PATH_ENV_NAME)
     namespace = os.getenv(VAULT_NAMESPACE_ENV_NAME)
+    mount_point = os.getenv(VAULT_MOUNT_POINT_ENV_NAME)
 
     return VaultSecretManagerNonStrictConfig(
         url=url,
@@ -109,6 +115,7 @@ def read_vault_env_vars() -> VaultSecretManagerNonStrictConfig:
         transit_mount_point=transit_mount_point,
         secrets_path=secrets_path,
         namespace=namespace,
+        mount_point=mount_point,
     )
 
 
@@ -149,6 +156,7 @@ def read_vault_config(
         f"{VAULT_RASA_SECRETS_PATH_ENV_NAME} = {env_config.secrets_path}, "
         f"{VAULT_TRANSIT_MOUNT_POINT_ENV_NAME} = {env_config.transit_mount_point}. "
         f"{VAULT_NAMESPACE_ENV_NAME} = {env_config.namespace}. "
+        f"{VAULT_MOUNT_POINT_ENV_NAME} = {env_config.mount_point}. "
     )
 
 

rasa/core/secrets_manager/vault.py

@@ -15,6 +15,7 @@ from rasa.utils.endpoints import EndpointConfig
 from rasa.core.secrets_manager.constants import (
     TRACKER_STORE_ENDPOINT_TYPE,
     TRANSIT_KEY_FOR_ENCRYPTION_LABEL,
+    VAULT_MOUNT_POINT_DEFAULT_VALUE,
     VAULT_SECRET_MANAGER_NAME,
 )
 from rasa.core.secrets_manager.endpoints import (
@@ -181,6 +182,7 @@ class VaultSecretsManager(SecretsManager):
         secrets_path: Text,
         transit_mount_point: Optional[Text] = None,
         namespace: Optional[Text] = None,
+        mount_point: Optional[Text] = None,
     ):
         """Initialise the VaultSecretsManager.
 
@@ -190,11 +192,13 @@ class VaultSecretsManager(SecretsManager):
             secrets_path: The path to the secrets in the vault server.
             transit_mount_point: The mount point of the transit engine.
             namespace: The namespace in which secrets reside in.
+            mount_point: The mount point of the kv engine.
         """
         self.host = host
         self.transit_mount_point = transit_mount_point
         self.token = token
         self.secrets_path = secrets_path
+        self.mount_point = mount_point or VAULT_MOUNT_POINT_DEFAULT_VALUE
         self.namespace = namespace
 
         # Create client
@@ -236,7 +240,7 @@ class VaultSecretsManager(SecretsManager):
         """
         logger.info(f"Loading secrets from vault server at {self.host}.")
         read_response = self.client.secrets.kv.read_secret_version(
-            mount_point="secret", path=self.secrets_path
+            mount_point=self.mount_point, path=self.secrets_path
         )
 
         secrets = read_response["data"]["data"]
@@ -455,6 +459,7 @@ class VaultSecretManagerConfig(SecretManagerConfig):
         secrets_path: Text,
         transit_mount_point: Text = "transit",
         namespace: Optional[Text] = None,
+        mount_point: Optional[Text] = None,
     ) -> None:
         """Initialise the VaultSecretManagerConfig.
 
@@ -471,6 +476,7 @@ class VaultSecretManagerConfig(SecretManagerConfig):
         self.secrets_path = secrets_path
         self.transit_mount_point = transit_mount_point
         self.namespace = namespace
+        self.mount_point = mount_point
 
 
 @dataclass
@@ -486,6 +492,7 @@ class VaultSecretManagerNonStrictConfig:
     secrets_path: Optional[Text]
     transit_mount_point: Optional[Text]
     namespace: Optional[Text] = None
+    mount_point: Optional[Text] = None
 
     def is_empty(self) -> bool:
         """Check if all the values are empty."""
@@ -495,6 +502,7 @@ class VaultSecretManagerNonStrictConfig:
             and (self.secrets_path is None or self.secrets_path == "")
             and (self.transit_mount_point is None or self.transit_mount_point == "")
             and (self.namespace is None or self.namespace == "")
+            and (self.mount_point is None or self.mount_point == "")
         )
 
     def is_valid(self) -> bool:
@@ -516,6 +524,7 @@ class VaultSecretManagerNonStrictConfig:
             and self.secrets_path != ""
             and self._is_optional_value_valid(self.transit_mount_point)
             and self._is_optional_value_valid(self.namespace)
+            and self._is_optional_value_valid(self.mount_point)
         )
 
     @staticmethod
@@ -547,6 +556,7 @@ class VaultSecretManagerNonStrictConfig:
             secrets_path=self.secrets_path or other.secrets_path,
             transit_mount_point=self.transit_mount_point or other.transit_mount_point,
             namespace=self.namespace or other.namespace,
+            mount_point=self.mount_point or other.mount_point,
         )
 
 

rasa/core/training/interactive.py

@@ -1688,7 +1688,7 @@ def run_interactive_learning(
         p = None
 
     app = run.configure_app(port=port, conversation_id="default", enable_api=True)
-    endpoints = AvailableEndpoints.get_instance(server_args.get("endpoints"))
+    endpoints = AvailableEndpoints.read_endpoints(server_args.get("endpoints"))
 
     # before_server_start handlers make sure the agent is loaded before the
     # interactive learning IO starts

rasa/core/utils.py

@@ -171,8 +171,6 @@ def is_limit_reached(num_messages: int, limit: Optional[int]) -> bool:
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
-    _instance = None
-
     @classmethod
     def read_endpoints(cls, endpoint_file: Text) -> "AvailableEndpoints":
         """Read the different endpoints from a yaml file."""
@@ -219,14 +217,6 @@ class AvailableEndpoints:
         self.event_broker = event_broker
         self.vector_store = vector_store
 
-    @classmethod
-    def get_instance(cls, endpoint_file: Optional[Text] = None) -> "AvailableEndpoints":
-        """Get the singleton instance of AvailableEndpoints."""
-        # Ensure that the instance is initialized only once.
-        if cls._instance is None:
-            cls._instance = cls.read_endpoints(endpoint_file)
-        return cls._instance
-
 
 def read_endpoints_from_path(
     endpoints_path: Optional[Union[Path, Text]] = None,
@@ -244,7 +234,7 @@ def read_endpoints_from_path(
     endpoints_config_path = cli_utils.get_validated_path(
         endpoints_path, "endpoints", DEFAULT_ENDPOINTS_PATH, True
     )
-    return AvailableEndpoints.get_instance(endpoints_config_path)
+    return AvailableEndpoints.read_endpoints(endpoints_config_path)
 
 
 def _lock_store_is_multi_worker_compatible(

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+import os
 from typing import Any, Dict, List, Optional
 
 import structlog
@@ -21,6 +22,7 @@ from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.constants import (
+    LLM_API_HEALTH_CHECK_ENV_VAR,
     ROUTE_TO_CALM_SLOT,
     PROMPT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
@@ -36,6 +38,7 @@ from rasa.shared.nlu.training_data.training_data import TrainingData
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_CHAT_MODEL_NAME,
     get_prompt_template,
+    llm_api_health_check,
     llm_factory,
     try_instantiate_llm_client,
 )
@@ -130,12 +133,16 @@ class LLMBasedRouter(GraphComponent):
     def train(self, training_data: TrainingData) -> Resource:
         """Train the intent classifier on a data set."""
         # Validate llm configuration
-        try_instantiate_llm_client(
+        llm_client = try_instantiate_llm_client(
             self.config.get(LLM_CONFIG_KEY),
             DEFAULT_LLM_CONFIG,
             "llm_based_router.train",
-            "LLMBasedRouter",
+            LLMBasedRouter.__name__,
         )
+        if os.getenv(LLM_API_HEALTH_CHECK_ENV_VAR, "true").lower() == "true":
+            llm_api_health_check(
+                llm_client, "llm_based_router.train", LLMBasedRouter.__name__
+            )
 
         self.persist()
         return self._resource
@@ -161,14 +168,7 @@ class LLMBasedRouter(GraphComponent):
                 "llm_based_router.load.failed", error=e, resource=resource.name
             )
 
-        router = cls(config, model_storage, resource, prompt_template=prompt_template)
-        try_instantiate_llm_client(
-            router.config.get(LLM_CONFIG_KEY),
-            DEFAULT_LLM_CONFIG,
-            "llm_based_router.load",
-            LLMBasedRouter.__name__,
-        )
-        return router
+        return cls(config, model_storage, resource, prompt_template=prompt_template)
 
     @classmethod
     def create(

rasa/dialogue_understanding/commands/__init__.py

@@ -32,6 +32,7 @@ from rasa.dialogue_understanding.commands.change_flow_command import ChangeFlowC
 from rasa.dialogue_understanding.commands.session_start_command import (
     SessionStartCommand,
 )
+from rasa.dialogue_understanding.commands.session_end_command import SessionEndCommand
 
 __all__ = [
     "Command",
@@ -51,5 +52,6 @@ __all__ = [
     "NoopCommand",
     "ChangeFlowCommand",
     "SessionStartCommand",
+    "SessionEndCommand",
     "RestartCommand",
 ]