rasa-pro 3.14.0.dev5__py3-none-any.whl → 3.14.0.dev6__py3-none-any.whl

rasa/core/channels/studio_chat.py

@@ -17,9 +17,9 @@ from typing import (
     Optional,
     Text,
     Tuple,
-    Union,
 )
 
+import orjson
 import structlog
 
 from rasa.core.channels import UserMessage
@@ -47,6 +47,7 @@ if TYPE_CHECKING:
     from sanic import Sanic, Websocket  # type: ignore[attr-defined]
     from socketio import AsyncServer
 
+    from rasa.core.channels.channel import UserMessage
     from rasa.shared.core.trackers import DialogueStateTracker
 
 
@@ -55,7 +56,7 @@ structlogger = structlog.get_logger()
 
 def tracker_as_dump(
     tracker: "DialogueStateTracker", latency: Optional[float] = None
-) -> Dict[str, Any]:
+) -> str:
     """Create a dump of the tracker state."""
     from rasa.shared.core.trackers import get_trackers_for_conversation_sessions
 
@@ -66,14 +67,11 @@ def tracker_as_dump(
     else:
         last_tracker = multiple_tracker_sessions[-1]
 
-    # TODO: this is a bug: the bridge converts this back to json, but it
-    # should be json in the first place
     state = last_tracker.current_state(EventVerbosity.AFTER_RESTART)
 
     if latency is not None:
         state["latency"] = {"rasa_processing_latency_ms": latency}
-
-    return state
+    return orjson.dumps(state, option=orjson.OPT_SERIALIZE_NUMPY).decode("utf-8")
 
 
 def does_need_action_prediction(tracker: "DialogueStateTracker") -> bool:
@@ -102,12 +100,12 @@ class StudioTrackerUpdatePlugin:
         """Remove tasks that have already completed."""
         self.tasks = [task for task in self.tasks if not task.done()]
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_new_user_message(self, tracker: "DialogueStateTracker") -> None:
         """Triggers a tracker update notification after a new user message."""
         self.handle_tracker_update(tracker)
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_action_executed(self, tracker: "DialogueStateTracker") -> None:
         """Triggers a tracker update notification after an action is executed."""
         self.handle_tracker_update(tracker)
@@ -127,7 +125,7 @@ class StudioTrackerUpdatePlugin:
         self.tasks.append(task)
         self._cleanup_tasks()
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_server_stop(self) -> None:
         """Cancels all remaining tasks when the server stops."""
         self._cancel_tasks()
@@ -155,7 +153,6 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         jwt_key: Optional[Text] = None,
         jwt_method: Optional[Text] = "HS256",
         metadata_key: Optional[Text] = "metadata",
-        enable_silence_timeout: bool = False,
     ) -> None:
         """Creates a `StudioChatInput` object."""
         from rasa.core.agent import Agent
@@ -173,7 +170,6 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             jwt_key=jwt_key,
             jwt_method=jwt_method,
             metadata_key=metadata_key,
-            enable_silence_timeout=enable_silence_timeout,
         )
 
         # Initialize the Voice Input Channel
@@ -214,15 +210,14 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             jwt_key=credentials.get("jwt_key"),
             jwt_method=credentials.get("jwt_method", "HS256"),
             metadata_key=credentials.get("metadata_key", "metadata"),
-            enable_silence_timeout=credentials.get("enable_silence_timeout", False),
         )
 
-    async def emit(self, event: str, data: Union[Dict, str], room: str) -> None:
+    async def emit(self, event: str, data: str, room: str) -> None:
         """Emits an event to the websocket."""
-        if not self.sio_server:
+        if not self.sio:
             structlogger.error("studio_chat.emit.sio_not_initialized")
             return
-        await self.sio_server.emit(event, data, room=room)
+        await self.sio.emit(event, data, room=room)
 
     def _register_tracker_update_hook(self) -> None:
         plugin_manager().register(StudioTrackerUpdatePlugin(self))
@@ -255,22 +250,15 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
     async def on_message_proxy(
         self,
-        on_new_message: Callable[[UserMessage], Awaitable[Any]],
-        message: UserMessage,
+        on_new_message: Callable[["UserMessage"], Awaitable[Any]],
+        message: "UserMessage",
     ) -> None:
         """Proxies the on_new_message call to the underlying channel.
 
         Triggers a tracker update notification after processing the message.
         """
         self._record_turn_start_time(message.sender_id)
-        try:
-            await on_new_message(message)
-        except Exception as e:
-            structlogger.exception(
-                "studio_chat.on_new_message.error",
-                error=str(e),
-                sender_id=message.sender_id,
-            )
+        await on_new_message(message)
 
         if not self.agent or not self.agent.is_ready():
             structlogger.error("studio_chat.on_message_proxy.agent_not_initialized")
@@ -389,7 +377,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
                 call_state.is_bot_speaking = True
         return ContinueConversationAction()
 
-    def _create_output_channel(
+    def create_output_channel(
         self, voice_websocket: "Websocket", tts_engine: TTSEngine
     ) -> VoiceOutputChannel:
         """Create a voice output channel."""
@@ -419,7 +407,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
         # Create a websocket adapter for this connection
         ws_adapter = SocketIOVoiceWebsocketAdapter(
-            sio_server=self.sio_server,
+            sio=self.sio,
             session_id=session_id,
             sid=sid,
             bot_message_evt=self.bot_message_evt,
@@ -458,7 +446,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         if sid in self.active_connections:
             del self.active_connections[sid]
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_server_stop(self) -> None:
         """Cleanup background tasks and active connections when the server stops."""
         structlogger.info("studio_chat.after_server_stop.cleanup")
@@ -467,12 +455,12 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             task.cancel()
 
     def blueprint(
-        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+        self, on_new_message: Callable[["UserMessage"], Awaitable[Any]]
     ) -> SocketBlueprint:
         proxied_on_message = partial(self.on_message_proxy, on_new_message)
         socket_blueprint = super().blueprint(proxied_on_message)
 
-        if not self.sio_server:
+        if not self.sio:
             structlogger.error("studio_chat.blueprint.sio_not_initialized")
             return socket_blueprint
 
@@ -482,12 +470,12 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         ) -> None:
             self.agent = app.ctx.agent
 
-        @self.sio_server.on("disconnect", namespace=self.namespace)
+        @self.sio.on("disconnect", namespace=self.namespace)
         async def disconnect(sid: Text) -> None:
             structlogger.debug("studio_chat.sio.disconnect", sid=sid)
             self._cleanup_tasks_for_sid(sid)
 
-        @self.sio_server.on("session_request", namespace=self.namespace)
+        @self.sio.on("session_request", namespace=self.namespace)
         async def session_request(sid: Text, data: Optional[Dict]) -> None:
             """Overrides the base SocketIOInput session_request handler.
 
@@ -507,7 +495,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             if data and data.get("is_voice", False):
                 self._start_voice_session(data["session_id"], sid, proxied_on_message)
 
-        @self.sio_server.on(self.user_message_evt, namespace=self.namespace)
+        @self.sio.on(self.user_message_evt, namespace=self.namespace)
         async def handle_message(sid: Text, data: Dict) -> None:
             """Overrides the base SocketIOInput handle_message handler."""
             # Handle voice messages
@@ -518,18 +506,10 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
                     ws.put_message(data)
                 return
 
-            try:
-                # Handle text messages
-                await self.handle_user_message(sid, data, proxied_on_message)
-            except Exception as e:
-                structlogger.exception(
-                    "studio_chat.sio.handle_message.error",
-                    error=str(e),
-                    sid=sid,
-                )
-                await self.emit("error", str(e), room=sid)
+            # Handle text messages
+            await self.handle_user_message(sid, data, proxied_on_message)
 
-        @self.sio_server.on("update_tracker", namespace=self.namespace)
+        @self.sio.on("update_tracker", namespace=self.namespace)
         async def on_update_tracker(sid: Text, data: Dict) -> None:
             await self.handle_tracker_update(sid, data)
 
@@ -551,7 +531,7 @@ class StudioVoiceOutputChannel(VoiceOutputChannel):
 
     def create_marker_message(self, recipient_id: str) -> Tuple[str, str]:
         message_id = uuid.uuid4().hex
-        marker_data = {"marker": message_id}
+        marker_data: Dict[str, Any] = {"marker": message_id}
 
         # Include comprehensive latency information if available
         latency_data = {
@@ -566,7 +546,7 @@ class StudioVoiceOutputChannel(VoiceOutputChannel):
 
         # Add latency data to marker if any metrics are available
         if latency_data:
-            marker_data["latency"] = latency_data  # type: ignore[assignment]
+            marker_data["latency"] = latency_data
 
         return json.dumps(marker_data), message_id
 
@@ -575,9 +555,9 @@ class SocketIOVoiceWebsocketAdapter:
     """Adapter to make Socket.IO work like a Sanic WebSocket for voice channels."""
 
     def __init__(
-        self, sio_server: "AsyncServer", session_id: str, sid: str, bot_message_evt: str
+        self, sio: "AsyncServer", session_id: str, sid: str, bot_message_evt: str
     ) -> None:
-        self.sio_server = sio_server
+        self.sio = sio
         self.bot_message_evt = bot_message_evt
         self._closed = False
         self._receive_queue: asyncio.Queue[Any] = asyncio.Queue()
@@ -596,7 +576,7 @@ class SocketIOVoiceWebsocketAdapter:
     async def send(self, data: Any) -> None:
         """Send data to the client."""
         if not self.closed:
-            await self.sio_server.emit(self.bot_message_evt, data, room=self.sid)
+            await self.sio.emit(self.bot_message_evt, data, room=self.sid)
 
     async def recv(self) -> Any:
         """Receive data from the client."""

rasa/core/channels/voice_stream/genesys.py

@@ -274,7 +274,7 @@ class GenesysInputChannel(VoiceInputChannel):
 
     def handle_ping(self, ws: Websocket, message: dict) -> None:
         """Handle ping message from Genesys."""
-        response = {
+        response: Dict[str, Any] = {
             "version": "2",
             "type": "pong",
             "seq": self._get_next_sequence(),

rasa/core/channels/voice_stream/voice_channel.py

@@ -11,11 +11,6 @@ from sanic import Websocket  # type: ignore
 from sanic.exceptions import ServerError, WebsocketClosed
 
 from rasa.core.channels import InputChannel, OutputChannel, UserMessage
-from rasa.core.channels.constants import (
-    USER_CONVERSATION_SESSION_END,
-    USER_CONVERSATION_SESSION_START,
-    USER_CONVERSATION_SILENCE_TIMEOUT,
-)
 from rasa.core.channels.voice_ready.utils import (
     CallParameters,
     validate_voice_license_scope,
@@ -53,6 +48,9 @@ from rasa.utils.io import remove_emojis
 logger = structlog.get_logger(__name__)
 
 # define constants for the voice channel
+USER_CONVERSATION_SESSION_END = "/session_end"
+USER_CONVERSATION_SESSION_START = "/session_start"
+USER_CONVERSATION_SILENCE_TIMEOUT = "/silence_timeout"
 
 
 @dataclass

rasa/core/constants.py

@@ -31,6 +31,10 @@ BEARER_TOKEN_PREFIX = "Bearer "
 # The lowest priority is intended to be used by machine learning policies.
 DEFAULT_POLICY_PRIORITY = 1
 
+DEFAULT_SUB_AGENTS = "sub_agents"
+
+MCP_SERVERS_KEY = "mcp_servers"
+
 # The priority of intent-prediction policies.
 # This should be below all rule based policies but higher than ML
 # based policies. This enables a loop inside ensemble where if none

rasa/core/policies/enterprise_search_policy.py

@@ -63,6 +63,8 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTION_CANCEL_FLOW,
+    ACTION_METADATA_MESSAGE_KEY,
+    ACTION_METADATA_TEXT_KEY,
     ACTION_SEND_TEXT_NAME,
     DEFAULT_SLOT_NAMES,
 )
@@ -585,8 +587,8 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             return self._create_prediction_internal_error(domain, tracker)
 
         action_metadata = {
-            "message": {
-                "text": response,
+            ACTION_METADATA_MESSAGE_KEY: {
+                ACTION_METADATA_TEXT_KEY: response,
                 SEARCH_RESULTS_METADATA_KEY: [
                     result.text for result in documents.results
                 ],
@@ -781,7 +783,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         if not os.path.exists(docs_folder) or not os.path.isdir(docs_folder):
             error_message = (
                 f"Document source directory does not exist or is not a "
-                f"directory: '{os.path.abspath(docs_folder)}'. "
+                f"directory: '{docs_folder}'. "
                 "Please specify a valid path to the documents source directory in the "
                 "vector_store configuration."
             )
@@ -1130,7 +1132,8 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         embeddings_config: Dict[Text, Any],
         log_source_method: str,
     ) -> None:
-        """Perform the health checks using resolved LLM and embeddings configurations.
+        """
+        Perform the health checks using resolved LLM and embeddings configurations.
         Resolved means the configuration is either:
         - A reference to a model group that has already been expanded into
           its corresponding configuration using the information from
@@ -1159,7 +1162,8 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
     @classmethod
     def get_system_default_prompt_based_on_config(cls, config: Dict[str, Any]) -> str:
-        """Resolves the default prompt template for Enterprise Search Policy based on
+        """
+        Resolves the default prompt template for Enterprise Search Policy based on
         the component's configuration.
 
         - The old prompt is selected when both citation and relevancy check are either
@@ -1190,7 +1194,8 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         relevancy_check_enabled: bool,
         citation_enabled: bool,
     ) -> str:
-        """Returns the appropriate default prompt template based on the feature flags.
+        """
+        Returns the appropriate default prompt template based on the feature flags.
 
         The selection follows this priority:
         1. If relevancy check is enabled, return the prompt that includes both relevancy

rasa/core/policies/flow_policy.py

@@ -137,8 +137,8 @@ class FlowPolicy(Policy):
 
         # create executor and predict next action
         try:
-            prediction = flow_executor.advance_flows(
-                tracker, domain.action_names_or_texts, flows
+            prediction = await flow_executor.advance_flows(
+                tracker, domain.action_names_or_texts, flows, domain.slots
             )
             return self._create_prediction_result(
                 prediction.action_name,
@@ -164,8 +164,8 @@ class FlowPolicy(Policy):
             # we retry, with the internal error frame on the stack
             events = tracker.create_stack_updated_events(updated_stack)
             tracker.update_with_events(events)
-            prediction = flow_executor.advance_flows(
-                tracker, domain.action_names_or_texts, flows
+            prediction = await flow_executor.advance_flows(
+                tracker, domain.action_names_or_texts, flows, domain.slots
             )
             collected_events = events + (prediction.events or [])
             return self._create_prediction_result(