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

rasa/__init__.py

@@ -5,11 +5,5 @@ from rasa import version
 # define the version before the other imports since these need it
 __version__ = version.__version__
 
-from litellm.integrations.langfuse.langfuse import LangFuseLogger
-
-from rasa.monkey_patches import litellm_langfuse_logger_init_fixed
-
-# Monkey-patch the init method as early as possible before the class is used
-LangFuseLogger.__init__ = litellm_langfuse_logger_init_fixed  # type: ignore
 
 logging.getLogger(__name__).addHandler(logging.NullHandler())

rasa/cli/run.py

@@ -64,12 +64,16 @@ def run_actions(args: argparse.Namespace) -> None:
 
 def _validate_model_path(model_path: Text, parameter: Text, default: Text) -> Text:
     if model_path is not None and not os.path.exists(model_path):
-        reason_str = f"'{model_path}' not found."
-        if model_path is None:
-            reason_str = f"Parameter '{parameter}' not set."
-
-        logger.debug(f"{reason_str} Using default location '{default}' instead.")
-
+        raise ModelNotFound(
+            f"The provided model path '{model_path}' could not be found. "
+            "Provide an existing model path."
+        )
+
+    if model_path is None:
+        logger.debug(
+            f"Parameter '{parameter}' not set. "
+            "Using default location '{default}' instead."
+        )
         os.makedirs(default, exist_ok=True)
         model_path = default
 

rasa/cli/utils.py

@@ -14,6 +14,7 @@ import structlog
 import rasa.shared.utils.cli
 import rasa.shared.utils.io
 from rasa import telemetry
+from rasa.exceptions import ModelNotFound
 from rasa.shared.constants import (
     ASSISTANT_ID_DEFAULT_VALUE,
     ASSISTANT_ID_KEY,
@@ -77,6 +78,12 @@ def get_validated_path(
     if current and os.path.exists(current):
         return current
 
+    if parameter == "model":
+        raise ModelNotFound(
+            f"The provided model path '{current}' could not be found. "
+            "Provide an existing model path."
+        )
+
     # try to find a valid option among the defaults
     if isinstance(default, str) or isinstance(default, Path):
         default_options = [str(default)]

rasa/core/actions/action.py

@@ -105,10 +105,6 @@ logger = logging.getLogger(__name__)
 def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["Action"]:
     """List default actions."""
     from rasa.core.actions.action_clean_stack import ActionCleanStack
-    from rasa.core.actions.action_handle_digressions import (
-        ActionBlockDigressions,
-        ActionContinueDigression,
-    )
     from rasa.core.actions.action_hangup import ActionHangup
     from rasa.core.actions.action_repeat_bot_messages import ActionRepeatBotMessages
     from rasa.core.actions.action_run_slot_rejections import ActionRunSlotRejections
@@ -143,8 +139,6 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionResetRouting(),
         ActionHangup(),
         ActionRepeatBotMessages(),
-        ActionBlockDigressions(),
-        ActionContinueDigression(),
     ]
 
 

rasa/core/channels/voice_ready/audiocodes.py

@@ -115,11 +115,21 @@ class Conversation:
     async def handle_activities(
         self,
         message: Dict[Text, Any],
+        input_channel_name: str,
         output_channel: OutputChannel,
         on_new_message: Callable[[UserMessage], Awaitable[Any]],
     ) -> None:
         """Handle activities sent by Audiocodes."""
         structlogger.debug("audiocodes.handle.activities")
+        if input_channel_name == "":
+            structlogger.warning(
+                "audiocodes.handle.activities.empty_input_channel_name",
+                event_info=(
+                    "Audiocodes input channel name is empty "
+                    f"for conversation {self.conversation_id}"
+                ),
+            )
+
         for activity in message["activities"]:
             text = None
             if activity[ACTIVITY_ID_KEY] in self.activity_ids:
@@ -143,6 +153,7 @@ class Conversation:
             metadata = self.get_metadata(activity)
             user_msg = UserMessage(
                 text=text,
+                input_channel=input_channel_name,
                 output_channel=output_channel,
                 sender_id=self.conversation_id,
                 metadata=metadata,
@@ -394,7 +405,12 @@ class AudiocodesInput(InputChannel):
             # start a background task to handle activities
             self._create_task(
                 conversation_id,
-                conversation.handle_activities(request.json, ac_output, on_new_message),
+                conversation.handle_activities(
+                    request.json,
+                    input_channel_name=self.name(),
+                    output_channel=ac_output,
+                    on_new_message=on_new_message,
+                ),
             )
             return response.json(response_json)
 
@@ -407,23 +423,9 @@ class AudiocodesInput(InputChannel):
             Example of payload:
             {"conversation": <conversation_id>, "reason": Optional[Text]}.
             """
-            self._get_conversation(request.token, conversation_id)
-            reason = {"reason": request.json.get("reason")}
-            await on_new_message(
-                UserMessage(
-                    text=f"{INTENT_MESSAGE_PREFIX}session_end",
-                    output_channel=None,
-                    sender_id=conversation_id,
-                    metadata=reason,
-                )
-            )
-            del self.conversations[conversation_id]
-            structlogger.debug(
-                "audiocodes.disconnect",
-                conversation=conversation_id,
-                request=request.json,
+            return await self._handle_disconnect(
+                request, conversation_id, on_new_message
             )
-            return response.json({})
 
         @ac_webhook.route("/conversation/<conversation_id>/keepalive", methods=["POST"])
         async def keepalive(request: Request, conversation_id: Text) -> HTTPResponse:
@@ -438,6 +440,32 @@ class AudiocodesInput(InputChannel):
 
         return ac_webhook
 
+    async def _handle_disconnect(
+        self,
+        request: Request,
+        conversation_id: Text,
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+    ) -> HTTPResponse:
+        """Triggered when the call is disconnected."""
+        self._get_conversation(request.token, conversation_id)
+        reason = {"reason": request.json.get("reason")}
+        await on_new_message(
+            UserMessage(
+                text=f"{INTENT_MESSAGE_PREFIX}session_end",
+                input_channel=self.name(),
+                output_channel=None,
+                sender_id=conversation_id,
+                metadata=reason,
+            )
+        )
+        del self.conversations[conversation_id]
+        structlogger.debug(
+            "audiocodes.disconnect",
+            conversation=conversation_id,
+            request=request.json,
+        )
+        return response.json({})
+
 
 class AudiocodesOutput(OutputChannel):
     @classmethod
@@ -445,6 +473,7 @@ class AudiocodesOutput(OutputChannel):
         return CHANNEL_NAME
 
     def __init__(self) -> None:
+        super().__init__()
         self.messages: List[Dict] = []
 
     async def add_message(self, message: Dict) -> None:

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,9 +199,7 @@ class ContextualResponseRephraser(
         return None
 
     @measure_llm_latency
-    async def _generate_llm_response(
-        self, prompt: str, sender_id: str
-    ) -> Optional[LLMResponse]:
+    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
@@ -215,21 +207,14 @@ class ContextualResponseRephraser(
 
         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 +258,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 +315,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(

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/policies/enterprise_search_policy.py

@@ -46,10 +46,6 @@ 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,
-    LANGFUSE_CUSTOM_METADATA_DICT,
-    LANGFUSE_METADATA_SESSION_ID,
-    LANGFUSE_METADATA_USER_ID,
-    LANGFUSE_TAGS,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
     MODEL_NAME_CONFIG_KEY,
@@ -549,9 +545,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
         if self.use_llm:
             prompt = self._render_prompt(tracker, documents.results)
-            llm_response = await self._generate_llm_answer(
-                llm, prompt, tracker.sender_id
-            )
+            llm_response = await self._generate_llm_answer(llm, prompt)
             llm_response = LLMResponse.ensure_llm_response(llm_response)
 
             self._add_prompt_and_llm_response_to_latest_message(
@@ -647,26 +641,19 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
     @measure_llm_latency
     async def _generate_llm_answer(
-        self, llm: LLMClient, prompt: Text, sender_id: str
+        self, llm: LLMClient, prompt: Text
     ) -> Optional[LLMResponse]:
         """Fetches an LLM completion for the provided prompt.
 
         Args:
             llm: The LLM client used to get the completion.
             prompt: The prompt text to send to the model.
-            sender_id: sender_id from the tracker.
 
         Returns:
             An LLMResponse object, or None if the call fails.
         """
-        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

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/policies/intentless_policy.py

@@ -30,10 +30,6 @@ 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,
-    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,
@@ -623,7 +619,6 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         response_examples: List[str],
         conversation_samples: List[str],
         history: str,
-        sender_id: str,
     ) -> Optional[str]:
         """Make the llm call to generate an answer."""
         llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
@@ -639,19 +634,11 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             log_event="intentless_policy.generate_answer.prompt_rendered",
             prompt=prompt,
         )
-        return await self._generate_llm_answer(llm, prompt, sender_id)
+        return await self._generate_llm_answer(llm, prompt)
 
-    async def _generate_llm_answer(
-        self, llm: LLMClient, prompt: str, sender_id: str
-    ) -> Optional[str]:
-        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__],
-        }
+    async def _generate_llm_answer(self, llm: LLMClient, prompt: str) -> Optional[str]:
         try:
-            llm_response = await llm.acompletion(prompt, metadata)
+            llm_response = await llm.acompletion(prompt)
             return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
@@ -727,7 +714,7 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
                 final_response_examples.append(resp)
 
         llm_response = await self.generate_answer(
-            final_response_examples, conversation_samples, history, tracker.sender_id
+            final_response_examples, conversation_samples, history
         )
         if not llm_response:
             structlogger.debug("intentless_policy.prediction.skip_llm_fail")

rasa/core/policies/policy.py

@@ -39,7 +39,6 @@ from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, RasaException
 from rasa.shared.nlu.constants import ACTION_NAME, ACTION_TEXT, ENTITIES, INTENT, TEXT
-from rasa.utils.licensing import get_human_readable_licence_owner
 
 if TYPE_CHECKING:
     from rasa.core.featurizers.tracker_featurizers import (
@@ -173,7 +172,6 @@ class Policy(GraphComponent):
 
         self._model_storage = model_storage
         self._resource = resource
-        self.user_id = get_human_readable_licence_owner()
 
     @classmethod
     def create(

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

rasa/core/utils.py

@@ -19,6 +19,7 @@ from rasa.core.constants import (
 )
 from rasa.core.lock_store import InMemoryLockStore, LockStore, RedisLockStore
 from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH, TCP_PROTOCOL
+from rasa.shared.core.constants import SlotMappingType
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import (
     EndpointConfig,
@@ -30,6 +31,7 @@ from rasa.utils.io import write_yaml
 if TYPE_CHECKING:
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.domain import Domain
+    from rasa.shared.core.flows.flows_list import FlowsList
 
 structlogger = structlog.get_logger()
 
@@ -364,3 +366,54 @@ def add_bot_utterance_metadata(
         ]
 
     return message
+
+
+def should_force_slot_filling(
+    tracker: Optional[DialogueStateTracker], flows: "FlowsList"
+) -> Tuple[bool, Optional[str]]:
+    """Check if the flow should force slot filling.
+
+    This is only valid when the flow is at a collect information step which
+    has set `force_slot_filling` to true and the slot has a valid `from_text` mapping.
+
+    Args:
+        tracker: The dialogue state tracker.
+        flows: The list of flows.
+
+    Returns:
+        A tuple of a boolean indicating if the flow should force slot filling
+        and the name of the slot if applicable.
+    """
+    from rasa.dialogue_understanding.processor.command_processor import (
+        get_current_collect_step,
+    )
+
+    if tracker is None:
+        structlogger.error(
+            "slot.force_slot_filling.error",
+            event_info="Tracker is None. Cannot force slot filling.",
+        )
+        return False, None
+
+    stack = tracker.stack
+    step = get_current_collect_step(stack, flows)
+    if step is None or not step.force_slot_filling:
+        return False, None
+
+    slot_name = step.collect
+    slot = tracker.slots.get(slot_name)
+
+    if not slot:
+        structlogger.debug(
+            "slot.force_slot_filling.error",
+            event_info=f"Slot '{slot_name}' not found in tracker. "
+            f"Cannot force slot filling. "
+            f"Please check if the slot is defined in the domain.",
+        )
+        return False, None
+
+    for slot_mapping in slot.mappings:
+        if slot_mapping.type == SlotMappingType.FROM_TEXT:
+            return True, slot_name
+
+    return False, None

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -23,10 +23,6 @@ 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 (
-    LANGFUSE_CUSTOM_METADATA_DICT,
-    LANGFUSE_METADATA_SESSION_ID,
-    LANGFUSE_METADATA_USER_ID,
-    LANGFUSE_TAGS,
     MODEL_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
@@ -47,7 +43,6 @@ from rasa.shared.utils.llm import (
     llm_factory,
     resolve_model_client_config,
 )
-from rasa.utils.licensing import get_human_readable_licence_owner
 from rasa.utils.log_utils import log_llm
 
 LLM_BASED_ROUTER_PROMPT_FILE_NAME = "llm_based_router_prompt.jinja2"
@@ -118,7 +113,6 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         self._model_storage = model_storage
         self._resource = resource
         self.validate_config()
-        self.user_id = get_human_readable_licence_owner()
 
     def validate_config(self) -> None:
         """Validate the config of the router."""
@@ -166,6 +160,7 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         **kwargs: Any,
     ) -> "LLMBasedRouter":
         """Loads trained component (see parent class for full docstring)."""
+
         # Perform health check on the resolved LLM client config
         llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
         cls.perform_llm_health_check(
@@ -237,7 +232,7 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
                 prompt=prompt,
             )
             # generating answer
-            answer = await self._generate_answer_using_llm(prompt, tracker.sender_id)
+            answer = await self._generate_answer_using_llm(prompt)
             log_llm(
                 logger=structlogger,
                 log_module="LLMBasedRouter",
@@ -297,9 +292,7 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
 
         return Template(self.prompt_template).render(**inputs)
 
-    async def _generate_answer_using_llm(
-        self, prompt: str, sender_id: str
-    ) -> Optional[str]:
+    async def _generate_answer_using_llm(self, prompt: str) -> Optional[str]:
         """Use LLM to generate a response.
 
         Args:
@@ -310,15 +303,8 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         """
         llm = llm_factory(self.config.get(LLM_CONFIG_KEY), 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:
-            llm_response = await llm.acompletion(prompt, metadata)
+            llm_response = await llm.acompletion(prompt)
             return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means