rasa-pro 3.13.0.dev1__py3-none-any.whl → 3.13.0.dev2__py3-none-any.whl

rasa/core/policies/enterprise_search_policy.py

@@ -1,12 +1,10 @@
 import importlib.resources
-import json
 import re
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text
 
 import dotenv
 import structlog
 from jinja2 import Template
-from pydantic import ValidationError
 
 import rasa.shared.utils.io
 from rasa.core.constants import (
@@ -16,12 +14,9 @@ from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.information_retrieval import (
-    InformationRetrieval,
-    InformationRetrievalException,
     SearchResult,
-    create_from_endpoint_config,
+    SearchResultList,
 )
-from rasa.core.information_retrieval.faiss import FAISS_Store
 from rasa.core.policies.policy import Policy, PolicyPrediction
 from rasa.core.utils import AvailableEndpoints
 from rasa.dialogue_understanding.generator.constants import (
@@ -38,6 +33,10 @@ from rasa.dialogue_understanding.stack.frames import (
     PatternFlowStackFrame,
     SearchStackFrame,
 )
+from rasa.document_retrieval.constants import (
+    POST_PROCESSED_DOCUMENTS_KEY,
+    SEARCH_QUERY_KEY,
+)
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
@@ -45,10 +44,7 @@ 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 (
-    EMBEDDINGS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
-    MODEL_GROUP_ID_CONFIG_KEY,
-    MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
@@ -60,10 +56,10 @@ from rasa.shared.core.constants import (
     DEFAULT_SLOT_NAMES,
 )
 from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import BotUttered, Event, UserUttered
+from rasa.shared.core.events import Event
 from rasa.shared.core.generator import TrackerWithCachedStates
-from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
-from rasa.shared.exceptions import FileIOException, RasaException
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import FileIOException
 from rasa.shared.nlu.constants import (
     KEY_COMPONENT_NAME,
     KEY_LLM_RESPONSE_METADATA,
@@ -72,12 +68,8 @@ from rasa.shared.nlu.constants import (
     PROMPTS,
 )
 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.providers.llm.llm_response import LLMResponse, measure_llm_latency
-from rasa.shared.utils.cli import print_error_and_exit
 from rasa.shared.utils.health_check.embeddings_health_check_mixin import (
     EmbeddingsHealthCheckMixin,
 )
@@ -85,23 +77,13 @@ from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheck
 from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_CHAT_MODEL_NAME,
-    DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
-    embedder_factory,
     get_prompt_template,
     llm_factory,
     resolve_model_client_config,
-    sanitize_message_for_prompt,
     tracker_as_readable_transcript,
 )
-from rasa.telemetry import (
-    track_enterprise_search_policy_predict,
-    track_enterprise_search_policy_train_completed,
-    track_enterprise_search_policy_train_started,
-)
 
 if TYPE_CHECKING:
-    from langchain.schema.embeddings import Embeddings
-
     from rasa.core.featurizers.tracker_featurizers import TrackerFeaturizer
 
 from rasa.utils.log_utils import log_llm
@@ -110,22 +92,11 @@ logger = structlog.get_logger()
 
 dotenv.load_dotenv("./.env")
 
-SOURCE_PROPERTY = "source"
-VECTOR_STORE_TYPE_PROPERTY = "type"
-VECTOR_STORE_PROPERTY = "vector_store"
-VECTOR_STORE_THRESHOLD_PROPERTY = "threshold"
 TRACE_TOKENS_PROPERTY = "trace_prompt_tokens"
 CITATION_ENABLED_PROPERTY = "citation_enabled"
 USE_LLM_PROPERTY = "use_generative_llm"
 MAX_MESSAGES_IN_QUERY_KEY = "max_messages_in_query"
 
-DEFAULT_VECTOR_STORE_TYPE = "faiss"
-DEFAULT_VECTOR_STORE_THRESHOLD = 0.0
-DEFAULT_VECTOR_STORE = {
-    VECTOR_STORE_TYPE_PROPERTY: DEFAULT_VECTOR_STORE_TYPE,
-    SOURCE_PROPERTY: "./docs",
-    VECTOR_STORE_THRESHOLD_PROPERTY: DEFAULT_VECTOR_STORE_THRESHOLD,
-}
 
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
@@ -136,11 +107,6 @@ DEFAULT_LLM_CONFIG = {
     "max_retries": 1,
 }
 
-DEFAULT_EMBEDDINGS_CONFIG = {
-    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
-    "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
-}
-
 ENTERPRISE_SEARCH_PROMPT_FILE_NAME = "enterprise_search_policy_prompt.jinja2"
 ENTERPRISE_SEARCH_CONFIG_FILE_NAME = "config.json"
 
@@ -156,14 +122,6 @@ DEFAULT_ENTERPRISE_SEARCH_PROMPT_WITH_CITATION_TEMPLATE = importlib.resources.re
 )
 
 
-class VectorStoreConnectionError(RasaException):
-    """Exception raised for errors in connecting to the vector store."""
-
-
-class VectorStoreConfigurationError(RasaException):
-    """Exception raised for errors in vector store configuration."""
-
-
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.POLICY_WITH_END_TO_END_SUPPORT, is_trainable=True
 )
@@ -197,7 +155,6 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         """Returns the default config of the policy."""
         return {
             POLICY_PRIORITY: SEARCH_POLICY_PRIORITY,
-            VECTOR_STORE_PROPERTY: DEFAULT_VECTOR_STORE,
         }
 
     def __init__(
@@ -206,7 +163,6 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         model_storage: ModelStorage,
         resource: Resource,
         execution_context: ExecutionContext,
-        vector_store: Optional[InformationRetrieval] = None,
         featurizer: Optional["TrackerFeaturizer"] = None,
         prompt_template: Optional[Text] = None,
     ) -> None:
@@ -217,21 +173,6 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         self.config[LLM_CONFIG_KEY] = resolve_model_client_config(
             self.config.get(LLM_CONFIG_KEY), EnterpriseSearchPolicy.__name__
         )
-        # Resolve embeddings config
-        self.config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
-            self.config.get(EMBEDDINGS_CONFIG_KEY), EnterpriseSearchPolicy.__name__
-        )
-
-        # Vector store object and configuration
-        self.vector_store = vector_store
-        self.vector_store_config = self.config.get(
-            VECTOR_STORE_PROPERTY, DEFAULT_VECTOR_STORE
-        )
-
-        # Embeddings configuration for encoding the search query
-        self.embeddings_config = (
-            self.config[EMBEDDINGS_CONFIG_KEY] or DEFAULT_EMBEDDINGS_CONFIG
-        )
 
         # LLM Configuration for response generation
         self.llm_config = self.config[LLM_CONFIG_KEY] or DEFAULT_LLM_CONFIG
@@ -239,9 +180,6 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         # Maximum number of turns to include in the prompt
         self.max_history = self.config.get(POLICY_MAX_HISTORY)
 
-        # Maximum number of messages to include in the search query
-        self.max_messages_in_query = self.config.get(MAX_MESSAGES_IN_QUERY_KEY, 2)
-
         # boolean to enable/disable tracing of prompt tokens
         self.trace_prompt_tokens = self.config.get(TRACE_TOKENS_PROPERTY, False)
 
@@ -263,25 +201,6 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         if self.citation_enabled:
             self.prompt_template = self.citation_prompt_template
 
-    @classmethod
-    def _create_plain_embedder(cls, config: Dict[Text, Any]) -> "Embeddings":
-        """Creates an embedder based on the given configuration.
-
-        Returns:
-        The embedder.
-        """
-        # Copy the config so original config is not modified
-        config = config.copy()
-        # Resolve config and instantiate the embedding client
-        config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
-            config.get(EMBEDDINGS_CONFIG_KEY), EnterpriseSearchPolicy.__name__
-        )
-        client = embedder_factory(
-            config.get(EMBEDDINGS_CONFIG_KEY), DEFAULT_EMBEDDINGS_CONFIG
-        )
-        # Wrap the embedding client in the adapter
-        return _LangchainEmbeddingClientAdapter(client)
-
     @classmethod
     def _add_prompt_and_llm_response_to_latest_message(
         cls,
@@ -346,53 +265,24 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         # Perform health checks for both LLM and embeddings client configs
         self._perform_health_checks(self.config, "enterprise_search_policy.train")
 
-        store_type = self.vector_store_config.get(VECTOR_STORE_TYPE_PROPERTY)
-
-        # telemetry call to track training start
-        track_enterprise_search_policy_train_started()
-
-        # validate embedding configuration
-        try:
-            embeddings = self._create_plain_embedder(self.config)
-        except (ValidationError, Exception) as e:
-            logger.error(
-                "enterprise_search_policy.train.embedder_instantiation_failed",
-                message="Unable to instantiate the embedding client.",
-                error=e,
-            )
-            print_error_and_exit(
-                "Unable to create embedder. Please make sure you specified the "
-                f"required environment variables. Error: {e}"
-            )
+        # # telemetry call to track training start
+        # track_enterprise_search_policy_train_started()
+        # # telemetry call to track training completion
+        # track_enterprise_search_policy_train_completed(
+        #     vector_store_type=store_type,
+        #     embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
+        #     embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
+        #     or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
+        #     embeddings_model_group_id=self.embeddings_config.get(
+        #         MODEL_GROUP_ID_CONFIG_KEY
+        #     ),
+        #     llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
+        #     llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
+        #     or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
+        #     llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
+        #     citation_enabled=self.citation_enabled,
+        # )
 
-        if store_type == DEFAULT_VECTOR_STORE_TYPE:
-            logger.info("enterprise_search_policy.train.faiss")
-            with self._model_storage.write_to(self._resource) as path:
-                self.vector_store = FAISS_Store(
-                    docs_folder=self.vector_store_config.get(SOURCE_PROPERTY),
-                    embeddings=embeddings,
-                    index_path=path,
-                    create_index=True,
-                    use_llm=self.use_llm,
-                )
-        else:
-            logger.info("enterprise_search_policy.train.custom", store_type=store_type)
-
-        # telemetry call to track training completion
-        track_enterprise_search_policy_train_completed(
-            vector_store_type=store_type,
-            embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
-            embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
-            or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
-            embeddings_model_group_id=self.embeddings_config.get(
-                MODEL_GROUP_ID_CONFIG_KEY
-            ),
-            llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
-            llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
-            or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
-            citation_enabled=self.citation_enabled,
-        )
         self.persist()
         return self._resource
 
@@ -429,60 +319,6 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                 )
         return template_slots
 
-    def _connect_vector_store_or_raise(
-        self, endpoints: Optional[AvailableEndpoints]
-    ) -> None:
-        """Connects to the vector store or raises an exception.
-
-        Raise exceptions for the following cases:
-        - The configuration is not specified
-        - Unable to connect to the vector store
-
-        Args:
-            endpoints: Endpoints configuration.
-        """
-        config = endpoints.vector_store if endpoints else None
-        store_type = self.vector_store_config.get(VECTOR_STORE_TYPE_PROPERTY)
-        if config is None and store_type != DEFAULT_VECTOR_STORE_TYPE:
-            logger.error(
-                "enterprise_search_policy._connect_vector_store_or_raise.no_config"
-            )
-            raise VectorStoreConfigurationError(
-                """No vector store specified. Please specify a vector
-                store in the endpoints configuration"""
-            )
-        try:
-            self.vector_store.connect(config)  # type: ignore
-        except Exception as e:
-            logger.error(
-                "enterprise_search_policy._connect_vector_store_or_raise.connect_error",
-                error=e,
-                config=config,
-            )
-            raise VectorStoreConnectionError(
-                f"Unable to connect to the vector store. Error: {e}"
-            )
-
-    def _prepare_search_query(self, tracker: DialogueStateTracker, history: int) -> str:
-        """Prepares the search query.
-        The search query is the last N messages in the conversation history.
-
-        Args:
-            tracker: The tracker containing the conversation history up to now.
-            history: The number of messages to include in the search query.
-
-        Returns:
-            The search query.
-        """
-        transcript = []
-        for event in tracker.applied_events():
-            if isinstance(event, UserUttered) or isinstance(event, BotUttered):
-                transcript.append(sanitize_message_for_prompt(event.text))
-
-        search_query = " ".join(transcript[-history:][::-1])
-        logger.debug("search_query", search_query=search_query)
-        return search_query
-
     async def predict_action_probabilities(  # type: ignore[override]
         self,
         tracker: DialogueStateTracker,
@@ -506,44 +342,34 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
              The prediction.
         """
         logger_key = "enterprise_search_policy.predict_action_probabilities"
-        vector_search_threshold = self.vector_store_config.get(
-            VECTOR_STORE_THRESHOLD_PROPERTY, DEFAULT_VECTOR_STORE_THRESHOLD
-        )
-        llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
+
         if not self.supports_current_stack_frame(
             tracker, False, False
         ) or self.should_abstain_in_coexistence(tracker, True):
             return self._prediction(self._default_predictions(domain))
 
-        if not self.vector_store:
-            logger.error(f"{logger_key}.no_vector_store")
-            return self._create_prediction_internal_error(domain, tracker)
-
-        try:
-            self._connect_vector_store_or_raise(endpoints)
-        except (VectorStoreConfigurationError, VectorStoreConnectionError) as e:
-            logger.error(f"{logger_key}.connection_error", error=e)
-            return self._create_prediction_internal_error(domain, tracker)
+        # retrieve documents from the latest message
+        # document retrieval happened earlier in the pipeline
+        if tracker.latest_message is None or tracker.latest_message.parse_data is None:
+            logger.info(f"{logger_key}.no_documents")
+            return self._create_prediction_cannot_handle(domain, tracker)
 
-        search_query = self._prepare_search_query(
-            tracker, int(self.max_messages_in_query)
+        documents_data = tracker.latest_message.parse_data.get(
+            POST_PROCESSED_DOCUMENTS_KEY
         )
-        tracker_state = tracker.current_state(EventVerbosity.AFTER_RESTART)
 
-        try:
-            documents = await self.vector_store.search(
-                query=search_query,
-                tracker_state=tracker_state,
-                threshold=vector_search_threshold,
-            )
-        except InformationRetrievalException as e:
-            logger.error(f"{logger_key}.search_error", error=e)
-            return self._create_prediction_internal_error(domain, tracker)
+        if not documents_data:
+            logger.info(f"{logger_key}.no_documents")
+            return self._create_prediction_cannot_handle(domain, tracker)
+
+        documents = SearchResultList.from_dict(documents_data)
 
         if not documents.results:
             logger.info(f"{logger_key}.no_documents")
             return self._create_prediction_cannot_handle(domain, tracker)
 
+        llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
+
         if self.use_llm:
             prompt = self._render_prompt(tracker, documents.results)
             llm_response = await self._generate_llm_answer(llm, prompt)
@@ -588,25 +414,29 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                     result.text for result in documents.results
                 ],
                 UTTER_SOURCE_METADATA_KEY: self.__class__.__name__,
-                SEARCH_QUERY_METADATA_KEY: search_query,
+                SEARCH_QUERY_METADATA_KEY: tracker.latest_message.parse_data.get(
+                    SEARCH_QUERY_KEY
+                ),
             }
         }
 
-        # telemetry call to track policy prediction
-        track_enterprise_search_policy_predict(
-            vector_store_type=self.vector_store_config.get(VECTOR_STORE_TYPE_PROPERTY),
-            embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
-            embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
-            or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
-            embeddings_model_group_id=self.embeddings_config.get(
-                MODEL_GROUP_ID_CONFIG_KEY
-            ),
-            llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
-            llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
-            or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
-            llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
-            citation_enabled=self.citation_enabled,
-        )
+        # # telemetry call to track policy prediction
+        # track_enterprise_search_policy_predict(
+        #     vector_store_type=self.vector_store_config.get(
+        #     VECTOR_STORE_TYPE_PROPERTY),
+        #     embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
+        #     embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
+        #     or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
+        #     embeddings_model_group_id=self.embeddings_config.get(
+        #         MODEL_GROUP_ID_CONFIG_KEY
+        #     ),
+        #     llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
+        #     llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
+        #     or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
+        #     llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
+        #     citation_enabled=self.citation_enabled,
+        # )
+
         return self._create_prediction(
             domain=domain, tracker=tracker, action_metadata=action_metadata
         )
@@ -774,73 +604,19 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                 "enterprise_search_policy.load.failed", error=e, resource=resource.name
             )
 
-        store_type = config.get(VECTOR_STORE_PROPERTY, {}).get(
-            VECTOR_STORE_TYPE_PROPERTY
-        )
-
-        embeddings = cls._create_plain_embedder(config)
-
         logger.info("enterprise_search_policy.load", config=config)
-        if store_type == DEFAULT_VECTOR_STORE_TYPE:
-            # if a vector store is not specified,
-            # default to using FAISS with the index stored in the model
-            # TODO figure out a way to get path without context manager
-            with model_storage.read_from(resource) as path:
-                vector_store = FAISS_Store(
-                    embeddings=embeddings,
-                    index_path=path,
-                    docs_folder=None,
-                    create_index=False,
-                )
-        else:
-            vector_store = create_from_endpoint_config(
-                config_type=store_type,
-                embeddings=embeddings,
-            )  # type: ignore
 
         return cls(
             config,
             model_storage,
             resource,
             execution_context,
-            vector_store=vector_store,
             prompt_template=prompt_template,
         )
 
-    @classmethod
-    def _get_local_knowledge_data(cls, config: Dict[str, Any]) -> Optional[List[str]]:
-        """This is required only for local knowledge base types.
-
-        e.g. FAISS, to ensure that the graph component is retrained when the knowledge
-        base is updated.
-        """
-        merged_config = {**cls.get_default_config(), **config}
-
-        store_type = merged_config.get(VECTOR_STORE_PROPERTY, {}).get(
-            VECTOR_STORE_TYPE_PROPERTY
-        )
-        if store_type != DEFAULT_VECTOR_STORE_TYPE:
-            return None
-
-        source = merged_config.get(VECTOR_STORE_PROPERTY, {}).get(SOURCE_PROPERTY)
-        if not source:
-            return None
-
-        docs = FAISS_Store.load_documents(source)
-
-        if len(docs) == 0:
-            return None
-
-        docs_as_strings = [
-            json.dumps(doc.dict(), ensure_ascii=False, sort_keys=True) for doc in docs
-        ]
-        return sorted(docs_as_strings)
-
     @classmethod
     def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint of enterprise search policy for the graph."""
-        local_knowledge_data = cls._get_local_knowledge_data(config)
-
         prompt_template = get_prompt_template(
             config.get(PROMPT_CONFIG_KEY),
             DEFAULT_ENTERPRISE_SEARCH_PROMPT_TEMPLATE,
@@ -849,12 +625,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         llm_config = resolve_model_client_config(
             config.get(LLM_CONFIG_KEY), EnterpriseSearchPolicy.__name__
         )
-        embedding_config = resolve_model_client_config(
-            config.get(EMBEDDINGS_CONFIG_KEY), EnterpriseSearchPolicy.__name__
-        )
-        return deep_container_fingerprint(
-            [prompt_template, local_knowledge_data, llm_config, embedding_config]
-        )
+        return deep_container_fingerprint([prompt_template, llm_config])
 
     @staticmethod
     def post_process_citations(llm_answer: str) -> str:
@@ -959,14 +730,3 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             log_source_method,
             EnterpriseSearchPolicy.__name__,
         )
-
-        # Perform health check of the embeddings client config
-        embeddings_config = resolve_model_client_config(
-            config.get(EMBEDDINGS_CONFIG_KEY, {})
-        )
-        cls.perform_embeddings_health_check(
-            embeddings_config,
-            DEFAULT_EMBEDDINGS_CONFIG,
-            log_source_method,
-            EnterpriseSearchPolicy.__name__,
-        )

rasa/core/policies/flows/flow_executor.py

@@ -23,7 +23,6 @@ from rasa.core.policies.flows.flow_step_result import (
 )
 from rasa.dialogue_understanding.commands import CancelFlowCommand
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
-from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
 )
@@ -51,7 +50,6 @@ from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
 )
 from rasa.dialogue_understanding.stack.utils import (
     top_user_flow_frame,
-    user_flows_on_the_stack,
 )
 from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
 from rasa.shared.core.constants import (
@@ -280,33 +278,6 @@ def trigger_pattern_continue_interrupted(
     return events
 
 
-def trigger_pattern_clarification(
-    current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
-) -> None:
-    """Trigger the pattern to clarify which topic to continue if needed."""
-    if not isinstance(current_frame, UserFlowStackFrame):
-        return None
-
-    if current_frame.frame_type in [
-        FlowStackFrameType.CALL,
-        FlowStackFrameType.INTERRUPT,
-    ]:
-        # we want to return to the flow that called
-        # the current flow or the flow that was interrupted
-        # by the current flow
-        return None
-
-    pending_flows = [
-        flows.flow_by_id(frame.flow_id)
-        for frame in stack.frames
-        if isinstance(frame, UserFlowStackFrame)
-        and frame.flow_id != current_frame.flow_id
-    ]
-
-    flow_names = [flow.readable_name() for flow in pending_flows if flow is not None]
-    stack.push(ClarifyPatternFlowStackFrame(names=flow_names))
-
-
 def trigger_pattern_completed(
     current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
 ) -> None:
@@ -675,15 +646,9 @@ def _run_end_step(
     structlogger.debug("flow.step.run.flow_end")
     current_frame = stack.pop()
     trigger_pattern_completed(current_frame, stack, flows)
-    resumed_events = []
-    if len(user_flows_on_the_stack(stack)) > 1:
-        # if there are more user flows on the stack,
-        # we need to trigger the pattern clarify
-        trigger_pattern_clarification(current_frame, stack, flows)
-    else:
-        resumed_events = trigger_pattern_continue_interrupted(
-            current_frame, stack, flows, tracker
-        )
+    resumed_events = trigger_pattern_continue_interrupted(
+        current_frame, stack, flows, tracker
+    )
     reset_events: List[Event] = reset_scoped_slots(current_frame, flow, tracker)
     return ContinueFlowWithNextStep(
         events=initial_events + reset_events + resumed_events, has_flow_ended=True

rasa/core/processor.py

@@ -76,6 +76,7 @@ from rasa.shared.core.constants import (
     SLOT_SILENCE_TIMEOUT,
     USER_INTENT_RESTART,
     USER_INTENT_SILENCE_TIMEOUT,
+    SetSlotExtractor,
 )
 from rasa.shared.core.events import (
     ActionExecuted,
@@ -766,13 +767,26 @@ class MessageProcessor:
         if self.http_interpreter:
             parse_data = await self.http_interpreter.parse(message)
         else:
-            regex_reader = create_regex_pattern_reader(message, self.domain)
-
             processed_message = Message({TEXT: message.text})
-            if regex_reader:
-                processed_message = regex_reader.unpack_regex_message(
-                    message=processed_message, domain=self.domain
+
+            all_flows = await self.get_flows()
+            should_force_slot_command, slot_name = (
+                rasa.core.utils.should_force_slot_filling(tracker, all_flows)
+            )
+
+            if should_force_slot_command:
+                command = SetSlotCommand(
+                    name=slot_name,
+                    value=message.text,
+                    extractor=SetSlotExtractor.COMMAND_PAYLOAD_READER.value,
                 )
+                processed_message.set(COMMANDS, [command.as_dict()], add_to_output=True)
+            else:
+                regex_reader = create_regex_pattern_reader(message, self.domain)
+                if regex_reader:
+                    processed_message = regex_reader.unpack_regex_message(
+                        message=processed_message, domain=self.domain
+                    )
 
             # Invalid use of slash syntax, sanitize the message before passing
             # it to the graph
@@ -1009,7 +1023,14 @@ class MessageProcessor:
 
     @staticmethod
     def _should_handle_message(tracker: DialogueStateTracker) -> bool:
-        return not tracker.is_paused() or (
+        return not tracker.is_paused() or MessageProcessor._last_user_intent_is_restart(
+            tracker
+        )
+
+    @staticmethod
+    def _last_user_intent_is_restart(tracker: DialogueStateTracker) -> bool:
+        """Check if the last user intent is a restart intent."""
+        return (
             tracker.latest_message is not None
             and tracker.latest_message.intent.get(INTENT_NAME_KEY)
             == USER_INTENT_RESTART