Template name in bot uttered event (RasaHQ#5836)

* Added template name when creating BotUttered inside ActionUtterTemplate

Signed-off-by: Vinicius Lima <[email protected]>

* Adapted tests to recieve template name inside BotUttered metadata

Signed-off-by: Vinicius Lima <[email protected]>

* Added template name to all actions that generate BotUttered event

Signed-off-by: Vinicius Lima <[email protected]>

* renamed remaining references of domain templates to responses

* fixed tests

* renamed key to template_name

* fixed tests

* Update 4745.feature.rst

Co-authored-by: Vinicius Lima <[email protected]>

Author: tmbo

changelog/4745.feature.rst

@@ -0,0 +1,4 @@
+Added template name to the metadata of bot utterance events.
+
+``BotUttered`` event contains a ``template_name`` property in its metadata for any
+new bot message.

docs/core/domains.rst

@@ -202,8 +202,8 @@ can be sent like so:
 Channel-Specific Responses
 --------------------------
 
-For each response, you can have multiple **response templates** (see :ref:`variations`).
-If you have certain response templates that you would like sent only to specific
+For each response, you can have multiple **response variations** (see :ref:`variations`).
+If you have certain response variations that you would like sent only to specific
 channels, you can specify this with the ``channel:`` key. The value should match
 the name defined in the ``name()`` method of the channel's ``OutputChannel``
 class. Channel-specific responses are especially useful if creating custom
@@ -228,10 +228,10 @@ output payloads that will only work in certain channels.
         payload: '/inform{"game": "fortnite"}'
 
 Each time your bot looks for responses, it will first check to see if there
-are any channel-specific response templates for the connected channel. If there are, it
-will choose **only** from these response templates. If no channel-specific response templates are
-found, it will choose from any response templates that do not have a defined ``channel``.
-Therefore, it is good practice to always have at least one response template for each
+are any channel-specific response variations for the connected channel. If there are, it
+will choose **only** from these response variations. If no channel-specific response variations are
+found, it will choose from any response variations that do not have a defined ``channel``.
+Therefore, it is good practice to always have at least one response variation for each
 response that has no ``channel`` specified so that your bot can respond in all
 environments, including in the shell and in interactive learning.
 
@@ -284,7 +284,7 @@ Variations
 ----------
 
 If you want to randomly vary the response sent to the user, you can list
-multiple **response templates** and Rasa will randomly pick one of them, e.g.:
+multiple **response variations** and Rasa will randomly pick one of them, e.g.:
 
 .. code-block:: yaml
 

docs/core/retrieval-actions.rst

@@ -97,7 +97,7 @@ Next, include response texts for all retrieval intents in a **separate** trainin
 The retrieval model is trained separately as part of the NLU training pipeline to select the correct response.
 One important thing to remember is that the retrieval model uses the text of the response messages
 to select the correct one. If you change the text of these responses, you have to retrain your retrieval model!
-This is a key difference to the response templates in your domain file.
+This is a key difference to the responses defined in your domain file.
 
 .. note::
     The file containing response texts must exist as a separate file inside the training data directory passed

docs/dialogue-elements/dialogue-elements.rst

@@ -16,7 +16,7 @@ issues and new features.
 
 - highest level: user goals
 - middle level: dialogue elements
-- lowest level: intents, entities, actions, slots, and templates.
+- lowest level: intents, entities, actions, slots, and responses.
 
 
 

docs/user-guide/rasa-tutorial.rst

@@ -187,16 +187,16 @@ So what do the different parts mean?
 +---------------+-------------------------------------------------------------+
 | ``actions``   | things your assistant can do and say                        |
 +---------------+-------------------------------------------------------------+
-| ``templates`` | template strings for the things your assistant can say      |
+| ``responses`` | responses for the things your assistant can say             |
 +---------------+-------------------------------------------------------------+
 
 
 **How does this fit together?**
 Rasa Core's job is to choose the right action to execute at each step
 of the conversation. In this case, our actions simply send a message to the user.
 These simple utterance actions are the ``actions`` in the domain that start
-with ``utter_``. The assistant will respond with a message based on a template
-from the ``templates`` section. See :ref:`custom-actions`
+with ``utter_``. The assistant will respond with a message based on a response
+from the ``responses`` section. See :ref:`custom-actions`
 to build actions that do more than just send a message.
 
 

rasa/core/actions/action.py

@@ -225,11 +225,12 @@ async def run(
             return []
 
         logger.debug(f"Picking response from selector of type {query_key}")
+        selected = response_selector_properties[query_key]
         message = {
-            "text": response_selector_properties[query_key][
-                OPEN_UTTERANCE_PREDICTION_KEY
-            ]["name"]
+            "text": selected[OPEN_UTTERANCE_PREDICTION_KEY]["name"],
+            "template_name": selected["full_retrieval_intent"],
         }
+
         return [create_bot_utterance(message)]
 
     def name(self) -> Text:
@@ -262,10 +263,11 @@ async def run(
         if message is None:
             if not self.silent_fail:
                 logger.error(
-                    "Couldn't create message for template '{}'."
+                    "Couldn't create message for response '{}'."
                     "".format(self.template_name)
                 )
             return []
+        message["template_name"] = self.template_name
 
         return [create_bot_utterance(message)]
 
@@ -292,7 +294,7 @@ async def run(
         tracker: "DialogueStateTracker",
         domain: "Domain",
     ) -> List[Event]:
-        # only utter the template if it is available
+        # only utter the response if it is available
         evts = await super().run(output_channel, nlg, tracker, domain)
 
         return evts + [UserUtteranceReverted(), UserUtteranceReverted()]
@@ -320,7 +322,7 @@ async def run(
 class ActionRestart(ActionUtterTemplate):
     """Resets the tracker to its initial state.
 
-    Utters the restart template if available."""
+    Utters the restart response if available."""
 
     def name(self) -> Text:
         return ACTION_RESTART_NAME
@@ -337,7 +339,7 @@ async def run(
     ) -> List[Event]:
         from rasa.core.events import Restarted
 
-        # only utter the template if it is available
+        # only utter the response if it is available
         evts = await super().run(output_channel, nlg, tracker, domain)
 
         return evts + [Restarted()]
@@ -405,7 +407,7 @@ async def run(
     ) -> List[Event]:
         from rasa.core.events import UserUtteranceReverted
 
-        # only utter the template if it is available
+        # only utter the response if it is available
         evts = await super().run(output_channel, nlg, tracker, domain)
 
         return evts + [UserUtteranceReverted()]
@@ -505,6 +507,7 @@ async def _utter_responses(
                 )
                 if not draft:
                     continue
+                draft["template_name"] = template
             else:
                 draft = {}
 
@@ -719,6 +722,7 @@ async def run(
                 {"title": "Yes", "payload": f"/{intent_to_affirm}"},
                 {"title": "No", "payload": f"/{USER_INTENT_OUT_OF_SCOPE}"},
             ],
+            "template_name": self.name(),
         }
 
         return [create_bot_utterance(message)]

rasa/core/domain.py

@@ -368,29 +368,29 @@ def collect_templates(
             validated_variations = []
             if template_variations is None:
                 raise InvalidDomain(
-                    "Utterance '{}' does not have any defined templates.".format(
+                    "Response '{}' does not have any defined variations.".format(
                         template_key
                     )
                 )
 
             for t in template_variations:
 
-                # templates should be a dict with options
+                # responses should be a dict with options
                 if isinstance(t, str):
                     raise_warning(
-                        f"Templates should not be strings anymore. "
-                        f"Utterance template '{template_key}' should contain "
+                        f"Responses should not be strings anymore. "
+                        f"Response '{template_key}' should contain "
                         f"either a '- text: ' or a '- custom: ' "
-                        f"attribute to be a proper template.",
+                        f"attribute to be a proper response.",
                         FutureWarning,
-                        docs=DOCS_URL_DOMAINS + "#utterance-templates",
+                        docs=DOCS_URL_DOMAINS + "#responses",
                     )
                     validated_variations.append({"text": t})
                 elif "text" not in t and "custom" not in t:
                     raise InvalidDomain(
-                        f"Utter template '{template_key}' needs to contain either "
+                        f"Response '{template_key}' needs to contain either "
                         f"'- text: ' or '- custom: ' attribute to be a proper "
-                        f"template."
+                        f"response."
                     )
                 else:
                     validated_variations.append(t)
@@ -1062,11 +1062,11 @@ def check_missing_templates(self) -> None:
         if missing_templates:
             for template in missing_templates:
                 raise_warning(
-                    f"Utterance '{template}' is listed as an "
-                    f"action in the domain file, but there is "
-                    f"no matching utterance template. Please "
+                    f"Action '{template}' is listed as a "
+                    f"response action in the domain file, but there is "
+                    f"no matching response defined. Please "
                     f"check your domain.",
-                    docs=DOCS_URL_DOMAINS + "#utterance-templates",
+                    docs=DOCS_URL_DOMAINS + "#responses",
                 )
 
     def is_empty(self) -> bool:

rasa/core/training/interactive.py

@@ -200,9 +200,9 @@ async def send_action(
             if action_name in NEW_TEMPLATES:
                 warning_questions = questionary.confirm(
                     f"WARNING: You have created a new action: '{action_name}', "
-                    f"with matching template: '{[*NEW_TEMPLATES[action_name]][0]}'. "
+                    f"with matching response: '{[*NEW_TEMPLATES[action_name]][0]}'. "
                     f"This action will not return its message in this session, "
-                    f"but the new utterance will be saved to your domain file "
+                    f"but the new response will be saved to your domain file "
                     f"when you exit and save this session. "
                     f"You do not need to do anything further."
                 )
@@ -358,10 +358,8 @@ async def _request_free_text_utterance(
 ) -> Text:
 
     question = questionary.text(
-        message=(
-            f"Please type the message for your new utterance template '{action}':"
-        ),
-        validate=io_utils.not_empty_validator("Please enter a template message"),
+        message=(f"Please type the message for your new bot response '{action}':"),
+        validate=io_utils.not_empty_validator("Please enter a response"),
     )
     return await _ask_questions(question, conversation_id, endpoint)
 

rasa/model.py

@@ -88,7 +88,7 @@ def __init__(
         Args:
             nlu: `True` if the NLU model should be retrained.
             core: `True` if the Core model should be retrained.
-            nlg: `True` if the templates in the domain should be updated.
+            nlg: `True` if the responses in the domain should be updated.
             force_training: `True` if a training of all parts is forced.
         """
         self.nlu = nlu
@@ -107,7 +107,7 @@ def should_retrain_core(self) -> bool:
         return self.force_training or self.core
 
     def should_retrain_nlg(self) -> bool:
-        """Check if the templates have to be updated."""
+        """Check if the responses have to be updated."""
 
         return self.should_retrain_core() or self.nlg
 
@@ -286,7 +286,7 @@ async def model_fingerprint(file_importer: "TrainingDataImporter") -> Fingerprin
     nlu_data = await file_importer.get_nlu_data()
 
     domain_dict = domain.as_dict()
-    templates = domain_dict.pop("responses")
+    responses = domain_dict.pop("responses")
     domain_without_nlg = Domain.from_dict(domain_dict)
 
     return {
@@ -300,7 +300,7 @@ async def model_fingerprint(file_importer: "TrainingDataImporter") -> Fingerprin
             config, include_keys=CONFIG_MANDATORY_KEYS_NLU
         ),
         FINGERPRINT_DOMAIN_WITHOUT_NLG_KEY: hash(domain_without_nlg),
-        FINGERPRINT_NLG_KEY: get_dict_hash(templates),
+        FINGERPRINT_NLG_KEY: get_dict_hash(responses),
         FINGERPRINT_NLU_DATA_KEY: hash(nlu_data),
         FINGERPRINT_STORIES_KEY: hash(stories),
         FINGERPRINT_TRAINED_AT_KEY: time.time(),