rasa-pro 3.12.4__py3-none-any.whl → 3.13.0.dev1__py3-none-any.whl

rasa/cli/scaffold.py

@@ -64,7 +64,7 @@ def add_subparser(
         "--template",
         type=ProjectTemplateName,
         choices=list(ProjectTemplateName),
-        default=ProjectTemplateName.DEFAULT,
+        default=ProjectTemplateName.CALM,
         help="Select the template to use for the project.",
     )
     scaffold_parser.set_defaults(func=run)

rasa/core/actions/action.py

@@ -23,9 +23,11 @@ from rasa.core.constants import (
     KEY_IS_COEXISTENCE_ASSISTANT,
     UTTER_SOURCE_METADATA_KEY,
 )
+from rasa.core.nlg.translate import get_translated_buttons, get_translated_text
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.core.utils import add_bot_utterance_metadata
 from rasa.e2e_test.constants import KEY_STUB_CUSTOM_ACTIONS
+from rasa.engine.language import Language
 from rasa.nlu.constants import (
     RESPONSE_SELECTOR_DEFAULT_INTENT,
     RESPONSE_SELECTOR_PREDICTION_KEY,
@@ -82,6 +84,7 @@ from rasa.shared.core.events import (
     UserUttered,
 )
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.constants import KEY_TRANSLATION
 from rasa.shared.core.slot_mappings import (
     SlotFillingManager,
     extract_slot_value,
@@ -254,25 +257,36 @@ def action_for_name_or_text(
     return RemoteAction(action_name_or_text, action_endpoint)
 
 
-def create_bot_utterance(message: Dict[Text, Any]) -> BotUttered:
-    """Create BotUttered event from message."""
-    bot_message = BotUttered(
-        text=message.pop(TEXT, None),
-        data={
-            ELEMENTS: message.pop(ELEMENTS, None),
-            QUICK_REPLIES: message.pop(QUICK_REPLIES, None),
-            BUTTONS: message.pop(BUTTONS, None),
-            # for legacy / compatibility reasons we need to set the image
-            # to be the attachment if there is no other attachment (the
-            # `.get` is intentional - no `pop` as we still need the image`
-            # property to set it in the following line)
-            ATTACHMENT: message.pop(ATTACHMENT, None) or message.get(IMAGE, None),
-            IMAGE: message.pop(IMAGE, None),
-            CUSTOM: message.pop(CUSTOM, None),
-        },
-        metadata=message,
+def create_bot_utterance(
+    message: Dict[Text, Any], language: Optional[Language] = None
+) -> BotUttered:
+    """Create BotUttered event from message with translation support."""
+    message_copy = copy.deepcopy(message)
+
+    text = get_translated_text(
+        text=message_copy.pop(TEXT, None),
+        translation=message_copy.pop(KEY_TRANSLATION, {}),
+        language=language,
+    )
+
+    buttons = get_translated_buttons(
+        buttons=message_copy.pop(BUTTONS, None), language=language
     )
-    return bot_message
+
+    data = {
+        ELEMENTS: message_copy.pop(ELEMENTS, None),
+        QUICK_REPLIES: message_copy.pop(QUICK_REPLIES, None),
+        BUTTONS: buttons,
+        # for legacy / compatibility reasons we need to set the image
+        # to be the attachment if there is no other attachment (the
+        # `.get` is intentional - no `pop` as we still need the image`
+        # property to set it in the following line)
+        ATTACHMENT: message_copy.pop(ATTACHMENT, None) or message_copy.get(IMAGE, None),
+        IMAGE: message_copy.pop(IMAGE, None),
+        CUSTOM: message_copy.pop(CUSTOM, None),
+    }
+
+    return BotUttered(text=text, data=data, metadata=message_copy)
 
 
 class Action:
@@ -385,7 +399,7 @@ class ActionBotResponse(Action):
         message = add_bot_utterance_metadata(
             message, self.utter_action, nlg, domain, tracker
         )
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
     def name(self) -> Text:
         """Returns action name."""
@@ -419,7 +433,7 @@ class ActionEndToEndResponse(Action):
     ) -> List[Event]:
         """Runs action (see parent class for full docstring)."""
         message = {"text": self.action_text}
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
     def event_for_successful_execution(
         self,
@@ -885,10 +899,7 @@ class RemoteAction(Action):
             generated_response = response.pop("response", None)
             if generated_response is not None:
                 draft = await nlg.generate(
-                    generated_response,
-                    tracker,
-                    output_channel.name(),
-                    **response,
+                    generated_response, tracker, output_channel.name(), **response
                 )
                 if not draft:
                     continue
@@ -906,7 +917,7 @@ class RemoteAction(Action):
             # Avoid overwriting `draft` values with empty values
             response = {k: v for k, v in response.items() if v}
             draft.update(response)
-            bot_messages.append(create_bot_utterance(draft))
+            bot_messages.append(create_bot_utterance(draft, tracker.current_language))
 
         return bot_messages
 
@@ -1063,7 +1074,6 @@ def _revert_rephrasing_events() -> List[Event]:
     ]
 
 
-# TODO: this should be removed, e.g. it uses a hardcoded message and no translation
 class ActionDefaultAskAffirmation(Action):
     """Default implementation which asks the user to affirm his intent.
 
@@ -1115,7 +1125,7 @@ class ActionDefaultAskAffirmation(Action):
             "utter_action": self.name(),
         }
 
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
 
 class ActionDefaultAskRephrase(ActionBotResponse):
@@ -1148,7 +1158,7 @@ class ActionSendText(Action):
         fallback = {"text": ""}
         metadata_copy = copy.deepcopy(metadata) if metadata else {}
         message = metadata_copy.get("message", fallback)
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
 
 class ActionExtractSlots(Action):

rasa/core/actions/action_run_slot_rejections.py

@@ -217,6 +217,6 @@ class ActionRunSlotRejections(Action):
             message = add_bot_utterance_metadata(
                 message, utterance, nlg, domain, tracker
             )
-            events.append(create_bot_utterance(message))
+            events.append(create_bot_utterance(message, tracker.current_language))
 
         return events

rasa/core/channels/studio_chat.py

@@ -120,13 +120,6 @@ class StudioChatInput(SocketIOInput):
 
         self._register_tracker_update_hook()
 
-    async def emit(self, event: str, data: Dict, room: str) -> None:
-        """Emits an event to the websocket."""
-        if not self.sio:
-            structlogger.error("studio_chat.emit.sio_not_initialized")
-            return
-        await self.sio.emit(event, data, room=room)
-
     def _register_tracker_update_hook(self) -> None:
         plugin_manager().register(StudioTrackerUpdatePlugin(self))
 
@@ -136,7 +129,10 @@ class StudioChatInput(SocketIOInput):
 
     async def publish_tracker_update(self, sender_id: str, tracker_dump: Dict) -> None:
         """Publishes a tracker update notification to the websocket."""
-        await self.emit("tracker", tracker_dump, room=sender_id)
+        if not self.sio:
+            structlogger.error("studio_chat.on_tracker_updated.sio_not_initialized")
+            return
+        await self.sio.emit("tracker", tracker_dump, room=sender_id)
 
     async def on_message_proxy(
         self,
@@ -176,45 +172,22 @@ class StudioChatInput(SocketIOInput):
             structlogger.error("studio_chat.sio.domain_not_initialized")
             return None
 
-        tracker: Optional[DialogueStateTracker] = None
-
         async with self.agent.lock_store.lock(data["sender_id"]):
-            try:
-                tracker = DialogueStateTracker.from_dict(
-                    data["sender_id"], data["events"], domain.slots
-                )
+            tracker = DialogueStateTracker.from_dict(
+                data["sender_id"], data["events"], domain.slots
+            )
+
+            # will override an existing tracker with the same id!
+            await self.agent.tracker_store.save(tracker)
 
-                # will override an existing tracker with the same id!
+            processor = self.agent.processor
+            if processor and does_need_action_prediction(tracker):
+                output_channel = self.get_output_channel()
+
+                await processor._run_prediction_loop(output_channel, tracker)
+                await processor.run_anonymization_pipeline(tracker)
                 await self.agent.tracker_store.save(tracker)
 
-                processor = self.agent.processor
-                if processor and does_need_action_prediction(tracker):
-                    output_channel = self.get_output_channel()
-
-                    await processor._run_prediction_loop(output_channel, tracker)
-                    await processor.run_anonymization_pipeline(tracker)
-                    await self.agent.tracker_store.save(tracker)
-            except Exception as e:
-                structlogger.error(
-                    "studio_chat.sio.handle_tracker_update.error",
-                    error=e,
-                    sender_id=data["sender_id"],
-                )
-                await self.emit(
-                    "error",
-                    {
-                        "message": "An error occurred while updating the conversation.",
-                        "error": str(e),
-                        "exception": str(type(e).__name__),
-                    },
-                    room=sid,
-                )
-        if not tracker:
-            # in case the tracker couldn't be updated, we retrieve the prior
-            # version and use that to populate the update
-            tracker = await self.agent.tracker_store.get_or_create_tracker(
-                data["sender_id"]
-            )
         await self.on_tracker_updated(tracker)
 
     def blueprint(

rasa/core/information_retrieval/faiss.py

@@ -31,10 +31,12 @@ class FAISS_Store(InformationRetrieval):
         index_path: str,
         docs_folder: Optional[str],
         create_index: Optional[bool] = False,
+        use_llm: bool = False,
     ):
         """Initializes the FAISS Store."""
         self.chunk_size = 1000
         self.chunk_overlap = 20
+        self.use_llm = use_llm
 
         path = Path(index_path) / "documents_faiss"
         if create_index:
@@ -71,6 +73,57 @@ class FAISS_Store(InformationRetrieval):
 
         return loader.load()
 
+    def _format_faqs(self, docs: List["Document"]) -> List["Document"]:
+        """Splits each loaded file into individual FAQs.
+
+        Args:
+            docs: Documents representing whole files containing FAQs.
+
+        Returns:
+            List of Document objects, each containing a separate FAQ.
+
+        Examples:
+            An example of a file containing FAQs:
+
+            Q: Who is Finley?
+            A: Finley is your smart assistant for the FinX App. You can add him to your
+               favorite messenger and tell him what you need help with.
+
+            Q: How does Finley work?
+            A: Finley is powered by the latest chatbot technology leveraging a unique
+               interplay of large language models and secure logic.
+
+        More details in documentation: https://rasa.com/docs/reference/config/policies/extractive-search/
+        """
+        structured_faqs = []
+        from langchain.schema import Document
+
+        for doc in docs:
+            faq_chunks = doc.page_content.strip().split("\n\n")
+
+            for chunk in faq_chunks:
+                lines = chunk.strip().split("\n")
+                if len(lines) < 2:
+                    continue  # Skip if something unexpected
+
+                question_line = lines[0].strip()
+                answer_line = lines[1].strip()
+
+                question = question_line.replace("Q: ", "").strip()
+                answer = answer_line.replace("A: ", "").strip()
+
+                doc_obj = Document(
+                    page_content=question,
+                    metadata={
+                        "title": question.lower().replace(" ", "_")[:-1],
+                        "type": "faq",
+                        "answer": answer,
+                    },
+                )
+
+                structured_faqs.append(doc_obj)
+        return structured_faqs
+
     def _create_document_index(
         self, docs_folder: Optional[str], embedding: "Embeddings"
     ) -> FAISS:
@@ -87,12 +140,15 @@ class FAISS_Store(InformationRetrieval):
             raise ValueError("parameter `docs_folder` needs to be specified")
 
         docs = self.load_documents(docs_folder)
-        splitter = RecursiveCharacterTextSplitter(
-            chunk_size=self.chunk_size,
-            chunk_overlap=self.chunk_overlap,
-            length_function=len,
-        )
-        doc_chunks = splitter.split_documents(docs)
+        if self.use_llm:
+            splitter = RecursiveCharacterTextSplitter(
+                chunk_size=self.chunk_size,
+                chunk_overlap=self.chunk_overlap,
+                length_function=len,
+            )
+            doc_chunks = splitter.split_documents(docs)
+        else:
+            doc_chunks = self._format_faqs(docs)
 
         logger.info(
             "information_retrieval.faiss_store._create_document_index",

rasa/core/nlg/contextual_response_rephraser.py

@@ -200,10 +200,8 @@ class ContextualResponseRephraser(
 
     @measure_llm_latency
     async def _generate_llm_response(self, prompt: str) -> Optional[LLMResponse]:
-        """Use LLM to generate a response.
-
-        Returns an LLMResponse object containing both the generated text
-        (choices) and metadata.
+        """Use LLM to generate a response, returning an LLMResponse object
+        containing both the generated text (choices) and metadata.
 
         Args:
             prompt: The prompt to send to the LLM.
@@ -369,9 +367,12 @@ class ContextualResponseRephraser(
         Returns:
             The generated response.
         """
-        templated_response = await super().generate(
+        filled_slots = tracker.current_slot_values()
+        stack_context = tracker.stack.current_context()
+        templated_response = self.generate_from_slots(
             utter_action=utter_action,
-            tracker=tracker,
+            filled_slots=filled_slots,
+            stack_context=stack_context,
             output_channel=output_channel,
             **kwargs,
         )

rasa/core/nlg/generator.py

@@ -6,8 +6,6 @@ from pypred import Predicate
 
 import rasa.shared.utils.common
 import rasa.shared.utils.io
-from rasa.core.nlg.translate import has_translation
-from rasa.engine.language import Language
 from rasa.shared.constants import CHANNEL, RESPONSE_CONDITION
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -133,23 +131,11 @@ class ResponseVariationFilter:
 
         return True
 
-    def _filter_by_language(
-        self, responses: List[Dict[Text, Any]], language: Optional[Language] = None
-    ) -> List[Dict[Text, Any]]:
-        if not language:
-            return responses
-
-        if filtered := [r for r in responses if has_translation(r, language)]:
-            return filtered
-        # if no translation is found, return the original response variations
-        return responses
-
     def responses_for_utter_action(
         self,
         utter_action: Text,
         output_channel: Text,
         filled_slots: Dict[Text, Any],
-        language: Optional[Language] = None,
     ) -> List[Dict[Text, Any]]:
         """Returns array of responses that fit the channel, action and condition."""
         # filter responses without a condition
@@ -190,16 +176,16 @@ class ResponseVariationFilter:
         )
 
         if conditional_channel:
-            return self._filter_by_language(conditional_channel, language)
+            return conditional_channel
 
         if default_channel:
-            return self._filter_by_language(default_channel, language)
+            return default_channel
 
         if conditional_no_channel:
-            return self._filter_by_language(conditional_no_channel, language)
+            return conditional_no_channel
 
         if default_no_channel:
-            return self._filter_by_language(default_no_channel, language)
+            return default_no_channel
 
         # if there is no response variation selected,
         # return the internal error response to prevent
@@ -212,9 +198,7 @@ class ResponseVariationFilter:
             f"a default variation and that all the conditions are valid. "
             f"Returning the internal error response.",
         )
-        return self._filter_by_language(
-            self.responses.get("utter_internal_error_rasa", []), language
-        )
+        return self.responses.get("utter_internal_error_rasa", [])
 
     def get_response_variation_id(
         self,

rasa/core/nlg/response.py

@@ -5,11 +5,8 @@ from typing import Any, Dict, List, Optional, Text
 from rasa.core.constants import DEFAULT_TEMPLATE_ENGINE, TEMPLATE_ENGINE_CONFIG_KEY
 from rasa.core.nlg import interpolator
 from rasa.core.nlg.generator import NaturalLanguageGenerator, ResponseVariationFilter
-from rasa.core.nlg.translate import get_translated_buttons, get_translated_text
-from rasa.engine.language import Language
-from rasa.shared.constants import BUTTONS, RESPONSE_CONDITION, TEXT
+from rasa.shared.constants import RESPONSE_CONDITION
 from rasa.shared.core.domain import RESPONSE_KEYS_TO_INTERPOLATE
-from rasa.shared.core.flows.constants import KEY_TRANSLATION
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import METADATA
 
@@ -33,11 +30,7 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
 
     # noinspection PyUnusedLocal
     def _random_response_for(
-        self,
-        utter_action: Text,
-        output_channel: Text,
-        filled_slots: Dict[Text, Any],
-        language: Optional[Language] = None,
+        self, utter_action: Text, output_channel: Text, filled_slots: Dict[Text, Any]
     ) -> Optional[Dict[Text, Any]]:
         """Select random response for the utter action from available ones.
 
@@ -49,7 +42,7 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
         if utter_action in self.responses:
             response_filter = ResponseVariationFilter(self.responses)
             suitable_responses = response_filter.responses_for_utter_action(
-                utter_action, output_channel, filled_slots, language
+                utter_action, output_channel, filled_slots
             )
 
             if suitable_responses:
@@ -82,36 +75,9 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
         """Generate a response for the requested utter action."""
         filled_slots = tracker.current_slot_values()
         stack_context = tracker.stack.current_context()
-        response = self.generate_from_slots(
-            utter_action,
-            filled_slots,
-            stack_context,
-            output_channel,
-            tracker.current_language,
-            **kwargs,
+        return self.generate_from_slots(
+            utter_action, filled_slots, stack_context, output_channel, **kwargs
         )
-        if response is not None:
-            return self.translate_response(response, tracker.current_language)
-        return None
-
-    def translate_response(
-        self, response: Dict[Text, Any], language: Optional[Language] = None
-    ) -> Dict[Text, Any]:
-        message_copy = copy.deepcopy(response)
-
-        text = get_translated_text(
-            text=message_copy.pop(TEXT, None),
-            translation=message_copy.pop(KEY_TRANSLATION, {}),
-            language=language,
-        )
-
-        buttons = get_translated_buttons(
-            buttons=message_copy.pop(BUTTONS, None), language=language
-        )
-        message_copy[TEXT] = text
-        if buttons:
-            message_copy[BUTTONS] = buttons
-        return message_copy
 
     def generate_from_slots(
         self,
@@ -119,15 +85,12 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
         filled_slots: Dict[Text, Any],
         stack_context: Dict[Text, Any],
         output_channel: Text,
-        language: Optional[Language] = None,
         **kwargs: Any,
     ) -> Optional[Dict[Text, Any]]:
         """Generate a response for the requested utter action."""
         # Fetching a random response for the passed utter action
         r = copy.deepcopy(
-            self._random_response_for(
-                utter_action, output_channel, filled_slots, language
-            )
+            self._random_response_for(utter_action, output_channel, filled_slots)
         )
         # Filling the slots in the response with placeholders and returning the response
         if r is not None:

rasa/core/nlg/translate.py

@@ -23,14 +23,6 @@ def get_translated_text(
     return translation.get(language_code, text)
 
 
-def has_translation(
-    message: Dict[Text, Any], language: Optional[Language] = None
-) -> bool:
-    """Check if the message has a translation for the given language."""
-    language_code = language.code if language else None
-    return language_code in message.get(KEY_TRANSLATION, {})
-
-
 def get_translated_buttons(
     buttons: Optional[List[Dict[Text, Any]]], language: Optional[Language] = None
 ) -> Optional[List[Dict[Text, Any]]]:

rasa/core/policies/enterprise_search_policy.py

@@ -373,6 +373,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                     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)

rasa/core/policies/intentless_policy.py

@@ -1,7 +1,7 @@
 import importlib.resources
 import math
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Text, Tuple
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple
 
 import structlog
 import tiktoken
@@ -18,7 +18,6 @@ from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.policies.policy import Policy, PolicyPrediction, SupportedData
-from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.stack.frames import (
     ChitChatStackFrame,
     DialogueStackFrame,
@@ -38,10 +37,9 @@ from rasa.shared.constants import (
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
-    REQUIRED_SLOTS_KEY,
     TIMEOUT_CONFIG_KEY,
 )
-from rasa.shared.core.constants import ACTION_LISTEN_NAME, ACTION_TRIGGER_CHITCHAT
+from rasa.shared.core.constants import ACTION_LISTEN_NAME
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.core.events import (
     ActionExecuted,
@@ -51,6 +49,7 @@ from rasa.shared.core.events import (
 )
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.generator import TrackerWithCachedStates
+from rasa.shared.core.policies.utils import filter_responses_for_intentless_policy
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, RasaCoreException
 from rasa.shared.nlu.constants import PREDICTED_CONFIDENCE_KEY
@@ -146,59 +145,6 @@ class Conversation:
     interactions: List[Interaction] = field(default_factory=list)
 
 
-def collect_form_responses(forms: Forms) -> Set[Text]:
-    """Collect responses that belong the requested slots in forms.
-
-    Args:
-        forms: the forms from the domain
-    Returns:
-        all utterances used in forms
-    """
-    form_responses = set()
-    for _, form_info in forms.data.items():
-        for required_slot in form_info.get(REQUIRED_SLOTS_KEY, []):
-            form_responses.add(f"utter_ask_{required_slot}")
-    return form_responses
-
-
-def filter_responses(responses: Responses, forms: Forms, flows: FlowsList) -> Responses:
-    """Filters out responses that are unwanted for the intentless policy.
-
-    This includes utterances used in flows and forms.
-
-    Args:
-        responses: the responses from the domain
-        forms: the forms from the domain
-        flows: all flows
-    Returns:
-        The remaining, relevant responses for the intentless policy.
-    """
-    form_responses = collect_form_responses(forms)
-    flow_responses = flows.utterances
-    combined_responses = form_responses | flow_responses
-    filtered_responses = {
-        name: variants
-        for name, variants in responses.data.items()
-        if name not in combined_responses
-    }
-
-    pattern_chitchat = flows.flow_by_id(FLOW_PATTERN_CHITCHAT)
-
-    # The following condition is highly unlikely, but mypy requires the case
-    # of pattern_chitchat == None to be addressed
-    if not pattern_chitchat:
-        return Responses(data=filtered_responses)
-
-    # if action_trigger_chitchat, filter out "utter_free_chitchat_response"
-    has_action_trigger_chitchat = pattern_chitchat.has_action_step(
-        ACTION_TRIGGER_CHITCHAT
-    )
-    if has_action_trigger_chitchat:
-        filtered_responses.pop("utter_free_chitchat_response", None)
-
-    return Responses(data=filtered_responses)
-
-
 def action_from_response(
     text: Optional[str], responses: Dict[Text, List[Dict[Text, Any]]]
 ) -> Optional[str]:
@@ -512,7 +458,9 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         # Perform health checks of both LLM and embeddings client configs
         self._perform_health_checks(self.config, "intentless_policy.train")
 
-        responses = filter_responses(responses, forms, flows or FlowsList([]))
+        responses = filter_responses_for_intentless_policy(
+            responses, forms, flows or FlowsList([])
+        )
         telemetry.track_intentless_policy_train()
         response_texts = [r for r in extract_ai_response_examples(responses.data)]
 
@@ -947,7 +895,6 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         **kwargs: Any,
     ) -> "IntentlessPolicy":
         """Loads a trained policy (see parent class for full docstring)."""
-
         # Perform health checks of both LLM and embeddings client configs
         cls._perform_health_checks(config, "intentless_policy.load")
 

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -65,7 +65,7 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
         """Converts the command to a DSL string."""
         mapper = {
             CommandSyntaxVersion.v1: "SearchAndReply()",
-            CommandSyntaxVersion.v2: "provide info",
+            CommandSyntaxVersion.v2: "search and reply",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),
@@ -81,7 +81,7 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"SearchAndReply\(\)",
-            CommandSyntaxVersion.v2: r"""^[\s\W\d]*provide info['"`]*$""",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*search and reply['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),