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

rasa/core/nlg/contextual_response_rephraser.py

@@ -7,10 +7,6 @@ from rasa import telemetry
 from rasa.core.nlg.response import TemplatedNaturalLanguageGenerator
 from rasa.core.nlg.summarize import summarize_conversation
 from rasa.shared.constants import (
-    LANGFUSE_CUSTOM_METADATA_DICT,
-    LANGFUSE_METADATA_SESSION_ID,
-    LANGFUSE_METADATA_USER_ID,
-    LANGFUSE_TAGS,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
@@ -43,7 +39,6 @@ from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
 )
 from rasa.utils.endpoints import EndpointConfig
-from rasa.utils.licensing import get_human_readable_licence_owner
 from rasa.utils.log_utils import log_llm
 
 structlogger = structlog.get_logger()
@@ -135,7 +130,6 @@ class ContextualResponseRephraser(
             "contextual_response_rephraser.init",
             ContextualResponseRephraser.__name__,
         )
-        self.user_id = get_human_readable_licence_owner()
 
     @classmethod
     def _add_prompt_and_llm_metadata_to_response(
@@ -205,31 +199,20 @@ class ContextualResponseRephraser(
         return None
 
     @measure_llm_latency
-    async def _generate_llm_response(
-        self, prompt: str, sender_id: str
-    ) -> Optional[LLMResponse]:
-        """Use LLM to generate a response.
-
-        Returns an LLMResponse object containing both the generated text
-        (choices) and metadata.
+    async def _generate_llm_response(self, prompt: str) -> Optional[LLMResponse]:
+        """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.
-            sender_id: sender_id from the tracker.
 
         Returns:
             An LLMResponse object if successful, otherwise None.
         """
         llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
-        metadata = {
-            LANGFUSE_METADATA_USER_ID: self.user_id,
-            LANGFUSE_METADATA_SESSION_ID: sender_id,
-            LANGFUSE_CUSTOM_METADATA_DICT: {"component": self.__class__.__name__},
-            LANGFUSE_TAGS: [self.__class__.__name__],
-        }
 
         try:
-            return await llm.acompletion(prompt, metadata)
+            return await llm.acompletion(prompt)
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here
@@ -273,9 +256,7 @@ class ContextualResponseRephraser(
         The history for the prompt.
         """
         llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
-        return await summarize_conversation(
-            tracker, llm, max_turns=5, user_id=self.user_id, sender_id=tracker.sender_id
-        )
+        return await summarize_conversation(tracker, llm, max_turns=5)
 
     async def rephrase(
         self,
@@ -332,7 +313,7 @@ class ContextualResponseRephraser(
             or self.llm_property(MODEL_NAME_CONFIG_KEY),
             llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
         )
-        llm_response = await self._generate_llm_response(prompt, tracker.sender_id)
+        llm_response = await self._generate_llm_response(prompt)
         llm_response = LLMResponse.ensure_llm_response(llm_response)
 
         response = self._add_prompt_and_llm_metadata_to_response(
@@ -386,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/summarize.py

@@ -4,12 +4,6 @@ import structlog
 from jinja2 import Template
 
 from rasa.core.tracker_store import DialogueStateTracker
-from rasa.shared.constants import (
-    LANGFUSE_CUSTOM_METADATA_DICT,
-    LANGFUSE_METADATA_SESSION_ID,
-    LANGFUSE_METADATA_USER_ID,
-    LANGFUSE_TAGS,
-)
 from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
@@ -52,8 +46,6 @@ async def summarize_conversation(
     tracker: DialogueStateTracker,
     llm: LLMClient,
     max_turns: Optional[int] = MAX_TURNS_DEFAULT,
-    user_id: Optional[str] = None,
-    sender_id: Optional[str] = None,
 ) -> str:
     """Summarizes the dialogue using the LLM.
 
@@ -66,14 +58,8 @@ async def summarize_conversation(
         The summary of the dialogue.
     """
     prompt = _create_summarization_prompt(tracker, max_turns)
-    metadata = {
-        LANGFUSE_METADATA_USER_ID: user_id or "unknown",
-        LANGFUSE_METADATA_SESSION_ID: sender_id or "",
-        LANGFUSE_CUSTOM_METADATA_DICT: {"component": "summarize_conversation"},
-        LANGFUSE_TAGS: ["summarize_conversation"],
-    }
     try:
-        llm_response = await llm.acompletion(prompt, metadata)
+        llm_response = await llm.acompletion(prompt)
         summarization = llm_response.choices[0].strip()
         structlogger.debug(
             "summarization.success", summarization=summarization, prompt=prompt

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]]]: