rasa-pro 3.12.6.dev2__py3-none-any.whl → 3.13.0.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/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,
@@ -105,10 +108,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 +142,6 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionResetRouting(),
         ActionHangup(),
         ActionRepeatBotMessages(),
-        ActionBlockDigressions(),
-        ActionContinueDigression(),
     ]
 
 
@@ -254,25 +251,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 +393,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 +427,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 +893,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 +911,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 +1068,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 +1119,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 +1152,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/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=(
+                    f"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",
+                output_channel=None,
+                input_channel=self.name(),
+                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/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",
@@ -113,10 +169,15 @@ class FAISS_Store(InformationRetrieval):
         pass
 
     async def search(
-        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
+        self,
+        query: Text,
+        tracker_state: Dict[str, Any],
+        threshold: float = 0.0,
+        k: int = 1,
     ) -> SearchResultList:
         logger.debug("information_retrieval.faiss_store.search", query=query)
         try:
+            # TODO: make use of k
             documents = await self.index.as_retriever().ainvoke(query)
         except Exception as exc:
             raise InformationRetrievalException from exc

rasa/core/information_retrieval/information_retrieval.py

@@ -36,6 +36,19 @@ class SearchResult:
         """Construct a SearchResult object from Langchain Document object."""
         return cls(text=document.page_content, metadata=document.metadata)
 
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "SearchResult":
+        """Construct a SearchResult object from a JSON object."""
+        return cls(text=data["text"], metadata=data["metadata"], score=data["score"])
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert the SearchResult object to a dictionary."""
+        return {
+            "text": self.text,
+            "metadata": self.metadata,
+            "score": self.score,
+        }
+
 
 @dataclass
 class SearchResultList:
@@ -44,8 +57,7 @@ class SearchResultList:
 
     @classmethod
     def from_document_list(cls, documents: List["Document"]) -> "SearchResultList":
-        """
-        Convert a list of Langchain Documents to a SearchResultList object.
+        """Convert a list of Langchain Documents to a SearchResultList object.
 
         Args:
             documents: List of Langchain Documents.
@@ -58,6 +70,31 @@ class SearchResultList:
             metadata={"total_results": len(documents)},
         )
 
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "SearchResultList":
+        """Convert a JSON object to a SearchResultList object.
+
+        Args:
+            data: JSON object.
+
+        Returns:
+            SearchResultList object.
+        """
+        if not data:
+            return cls(results=[], metadata={})
+
+        return cls(
+            results=[SearchResult.from_dict(result) for result in data["results"]],
+            metadata=data["metadata"],
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert the SearchResultList object to a dictionary."""
+        return {
+            "results": [result.to_dict() for result in self.results],
+            "metadata": self.metadata,
+        }
+
 
 class InformationRetrievalException(RasaException):
     """Base class for exceptions raised by InformationRetrieval operations."""
@@ -89,6 +126,7 @@ class InformationRetrieval:
         query: Text,
         tracker_state: dict[str, Any],
         threshold: float = 0.0,
+        k: int = 1,
     ) -> SearchResultList:
         """Search for a document in the InformationRetrieval system."""
         raise NotImplementedError(

rasa/core/information_retrieval/milvus.py

@@ -31,20 +31,25 @@ class Milvus_Store(InformationRetrieval):
         )
 
     async def search(
-        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
+        self,
+        query: Text,
+        tracker_state: Dict[str, Any],
+        threshold: float = 0.0,
+        k: int = 1,
     ) -> SearchResultList:
         """Search for documents in the Milvus store.
 
         Args:
             query: The query to search for.
             threshold: minimum similarity score to consider a document a match.
+            k: number of results to return.
 
         Returns:
         A list of documents that match the query.
         """
         logger.debug("information_retrieval.milvus_store.search", query=query)
         try:
-            hits = await self.client.asimilarity_search_with_score(query, k=4)
+            hits = await self.client.asimilarity_search_with_score(query, k=k)
         except Exception as exc:
             raise InformationRetrievalException from exc
 

rasa/core/information_retrieval/qdrant.py

@@ -66,13 +66,18 @@ class Qdrant_Store(InformationRetrieval):
         )
 
     async def search(
-        self, query: Text, tracker_state: Dict[str, Any], threshold: float = 0.0
+        self,
+        query: Text,
+        tracker_state: Dict[str, Any],
+        threshold: float = 0.0,
+        k: int = 1,
     ) -> SearchResultList:
         """Search for a document in the Qdrant vector store.
 
         Args:
             query: The query to search for.
             threshold: minimum similarity score to consider a document a match.
+            k: number of results to return.
 
         Returns:
         A list of documents that match the query.
@@ -80,7 +85,7 @@ class Qdrant_Store(InformationRetrieval):
         logger.debug("information_retrieval.qdrant_store.search", query=query)
         try:
             hits = await self.client.asimilarity_search(
-                query, k=4, score_threshold=threshold
+                query, k=k, score_threshold=threshold
             )
         except ValidationError as e:
             raise PayloadNotFoundException(