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

rasa/core/channels/socketio.py

@@ -1,54 +1,34 @@
-from __future__ import annotations
-
-import asyncio
 import inspect
 import json
+import logging
 import uuid
-from asyncio import Task
-from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, Dict, Iterable, List, Optional, Text
 
-import structlog
 from sanic import Blueprint, Sanic, response
 from sanic.request import Request
 from sanic.response import HTTPResponse
 from socketio import AsyncServer
 
+import rasa.core.channels.channel
 import rasa.shared.utils.io
-from rasa.core.channels.channel import (
-    InputChannel,
-    OnNewMessageType,
-    OutputChannel,
-    UserMessage,
-)
-from rasa.core.channels.constants import USER_CONVERSATION_SILENCE_TIMEOUT
-from rasa.shared.core.constants import SILENCE_TIMEOUT_SLOT
-
-logger = structlog.getLogger(__name__)
-
+from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
 
-@dataclass
-class SilenceTimeout:
-    sender_id: str
-    timeout: float
-
-
-UserSilenceHandlerType = Callable[[SilenceTimeout], Awaitable[Any]]
+logger = logging.getLogger(__name__)
 
 
 class SocketBlueprint(Blueprint):
     """Blueprint for socketio connections."""
 
     def __init__(
-        self, sio_server: AsyncServer, socketio_path: Text, *args: Any, **kwargs: Any
+        self, sio: AsyncServer, socketio_path: Text, *args: Any, **kwargs: Any
     ) -> None:
-        """Creates a :class:`sanic.Blueprint` for routing socketio connections.
+        """Creates a :class:`sanic.Blueprint` for routing socketio connenctions.
 
-        :param sio_server: Instance of :class:`socketio.AsyncServer` class
+        :param sio: Instance of :class:`socketio.AsyncServer` class
         :param socketio_path: string indicating the route to accept requests on.
         """
         super().__init__(*args, **kwargs)
-        self.ctx.sio_server = sio_server
+        self.ctx.sio = sio
         self.ctx.socketio_path = socketio_path
 
     def register(self, app: Sanic, options: Dict[Text, Any]) -> None:
@@ -62,7 +42,7 @@ class SocketBlueprint(Blueprint):
             path = self.ctx.socketio_path
         else:
             path = options.get("url_prefix", "/socket.io")
-        self.ctx.sio_server.attach(app, path)
+        self.ctx.sio.attach(app, path)
         super().register(app, options)
 
 
@@ -71,45 +51,14 @@ class SocketIOOutput(OutputChannel):
     def name(cls) -> Text:
         return "socketio"
 
-    def __init__(
-        self,
-        input_channel: SocketIOInput,
-        sio_server: AsyncServer,
-        bot_message_evt: Text,
-    ) -> None:
+    def __init__(self, sio: AsyncServer, bot_message_evt: Text) -> None:
         super().__init__()
-        self._input_channel = input_channel
-        self.sio_server = sio_server
+        self.sio = sio
         self.bot_message_evt = bot_message_evt
 
     async def _send_message(self, socket_id: Text, response: Any) -> None:
         """Sends a message to the recipient using the bot event."""
-        await self.sio_server.emit(self.bot_message_evt, response, room=socket_id)
-        if self.tracker_state and self._input_channel.enable_silence_timeout:
-            silence_timeout = self.tracker_state["slots"][SILENCE_TIMEOUT_SLOT]
-
-            logger.debug(
-                "socketio_channel.silence_timeout_updated",
-                sender_id=socket_id,
-                silence_timeout=silence_timeout,
-            )
-
-            silence_timeout_counts = self.tracker_state["slots"][
-                "consecutive_silence_timeouts"
-            ]
-
-            logger.debug(
-                "socketio_channel.consecutive_silence_timeouts_updated",
-                sender_id=socket_id,
-                silence_timeout_counts=silence_timeout_counts,
-            )
-
-            self._input_channel.reset_silence_timeout(
-                SilenceTimeout(
-                    sender_id=socket_id,
-                    timeout=silence_timeout,
-                ),
-            )
+        await self.sio.emit(self.bot_message_evt, response, room=socket_id)
 
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any
@@ -174,11 +123,9 @@ class SocketIOOutput(OutputChannel):
         """Sends custom json to the output."""
         if "data" in json_message:
             json_message.setdefault("room", recipient_id)
-            await self.sio_server.emit(self.bot_message_evt, **json_message)
+            await self.sio.emit(self.bot_message_evt, **json_message)
         else:
-            await self.sio_server.emit(
-                self.bot_message_evt, json_message, room=recipient_id
-            )
+            await self.sio.emit(self.bot_message_evt, json_message, room=recipient_id)
 
     async def send_attachment(  # type: ignore[override]
         self, recipient_id: Text, attachment: Dict[Text, Any], **kwargs: Any
@@ -186,38 +133,26 @@ class SocketIOOutput(OutputChannel):
         """Sends an attachment to the user."""
         await self._send_message(recipient_id, {"attachment": attachment})
 
-    async def hangup(self, recipient_id: Text, **kwargs: Any) -> None:
-        """Hangs up the call for the given sender."""
-        # This method is not applicable for socket.io, but we implement it
-        # to satisfy the OutputChannel interface.
-        logger.debug(
-            "socketio_channel.output.hangup",
-            message=f"Hanging up call for user {recipient_id}.",
-        )
-
-        self._input_channel.disconnect(recipient_id)
-
 
 class SocketIOInput(InputChannel):
     """A socket.io input channel."""
 
     @classmethod
-    def name(cls) -> str:
+    def name(cls) -> Text:
         return "socketio"
 
     @classmethod
     def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
         credentials = credentials or {}
         return cls(
-            user_message_evt=credentials.get("user_message_evt", "user_uttered"),
-            bot_message_evt=credentials.get("bot_message_evt", "bot_uttered"),
-            namespace=credentials.get("namespace"),
-            session_persistence=credentials.get("session_persistence", False),
-            socketio_path=credentials.get("socketio_path", "/socket.io"),
-            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),
+            credentials.get("user_message_evt", "user_uttered"),
+            credentials.get("bot_message_evt", "bot_uttered"),
+            credentials.get("namespace"),
+            credentials.get("session_persistence", False),
+            credentials.get("socketio_path", "/socket.io"),
+            credentials.get("jwt_key"),
+            credentials.get("jwt_method", "HS256"),
+            credentials.get("metadata_key", "metadata"),
         )
 
     def __init__(
@@ -230,7 +165,6 @@ class SocketIOInput(InputChannel):
         jwt_key: Optional[Text] = None,
         jwt_method: Optional[Text] = "HS256",
         metadata_key: Optional[Text] = "metadata",
-        enable_silence_timeout: bool = False,
     ):
         """Creates a ``SocketIOInput`` object."""
         self.bot_message_evt = bot_message_evt
@@ -238,18 +172,15 @@ class SocketIOInput(InputChannel):
         self.user_message_evt = user_message_evt
         self.namespace = namespace
         self.socketio_path = socketio_path
-        self.sio_server: Optional[AsyncServer] = None
+        self.sio: Optional[AsyncServer] = None
         self.metadata_key = metadata_key
-        self.enable_silence_timeout = enable_silence_timeout
 
         self.jwt_key = jwt_key
         self.jwt_algorithm = jwt_method
-        self.on_new_message: Optional[OnNewMessageType] = None
-        self.sender_silence_map: Dict[str, Task] = {}
 
-    def get_output_channel(self) -> Optional[OutputChannel]:
+    def get_output_channel(self) -> Optional["OutputChannel"]:
         """Creates socket.io output channel object."""
-        if self.sio_server is None:
+        if self.sio is None:
             rasa.shared.utils.io.raise_warning(
                 "SocketIO output channel cannot be recreated. "
                 "This is expected behavior when using multiple Sanic "
@@ -258,7 +189,7 @@ class SocketIOInput(InputChannel):
                 "scenarios."
             )
             return None
-        return SocketIOOutput(self, self.sio_server, self.bot_message_evt)
+        return SocketIOOutput(self.sio, self.bot_message_evt)
 
     async def handle_session_request(
         self, sid: Text, data: Optional[Dict] = None
@@ -269,26 +200,23 @@ class SocketIOInput(InputChannel):
         if "session_id" not in data or data["session_id"] is None:
             data["session_id"] = uuid.uuid4().hex
         if self.session_persistence:
-            if inspect.iscoroutinefunction(self.sio_server.enter_room):  # type: ignore[union-attr]
-                await self.sio_server.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
+            if inspect.iscoroutinefunction(self.sio.enter_room):  # type: ignore[union-attr]
+                await self.sio.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
             else:
                 # for backwards compatibility with python-socketio < 5.10.
                 # previously, this function was NOT async.
-                self.sio_server.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
-        await self.sio_server.emit("session_confirm", data["session_id"], room=sid)  # type: ignore[union-attr]
-        logger.debug(
-            "socketio_channel.input.handle_session_request",
-            message=f"User {sid} connected to socketIO endpoint.",
-        )
+                self.sio.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
+        await self.sio.emit("session_confirm", data["session_id"], room=sid)  # type: ignore[union-attr]
+        logger.debug(f"User {sid} connected to socketIO endpoint.")
 
     async def handle_user_message(
         self,
         sid: Text,
         data: Dict,
-        on_new_message: OnNewMessageType,
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
     ) -> None:
         """Handles user messages received from the client."""
-        output_channel = self.get_output_channel()
+        output_channel = SocketIOOutput(self.sio, self.bot_message_evt)
 
         if self.session_persistence:
             if not data.get("session_id"):
@@ -304,44 +232,38 @@ class SocketIOInput(InputChannel):
         else:
             sender_id = sid
 
-        # We cancel silence timeout when a new message is received
-        # to prevent sending a silence timeout message
-        # if the user sends a message after the silence timeout
-        self._cancel_silence_timeout(sender_id)
-
         metadata = data.get(self.metadata_key, {})
         if isinstance(metadata, Text):
             metadata = json.loads(metadata)
 
         message = UserMessage(
-            text=data.get("message", ""),
-            output_channel=output_channel,
-            sender_id=sender_id,
+            data.get("message", ""),
+            output_channel,
+            sender_id,
             input_channel=self.name(),
             metadata=metadata,
         )
         await on_new_message(message)
 
-    def blueprint(self, on_new_message: OnNewMessageType) -> SocketBlueprint:
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> SocketBlueprint:
         """Defines a Sanic blueprint."""
         # Workaround so that socketio works with requests from other origins.
         # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183
-        sio_server = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
+        sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
         socketio_webhook = SocketBlueprint(
-            sio_server, self.socketio_path, "socketio_webhook", __name__
+            sio, self.socketio_path, "socketio_webhook", __name__
         )
 
-        # make sio_server object static to use in get_output_channel
-        self.sio_server = sio_server
-        # We need to store the on_new_message callback
-        # so that we can call it when a silence timeout occurs
-        self.on_new_message = on_new_message
+        # make sio object static to use in get_output_channel
+        self.sio = sio
 
         @socketio_webhook.route("/", methods=["GET"])
         async def health(_: Request) -> HTTPResponse:
             return response.json({"status": "ok"})
 
-        @sio_server.on("connect", namespace=self.namespace)
+        @sio.on("connect", namespace=self.namespace)
         async def connect(sid: Text, environ: Dict, auth: Optional[Dict]) -> bool:
             if self.jwt_key:
                 jwt_payload = None
@@ -351,107 +273,24 @@ class SocketIOInput(InputChannel):
                     )
 
                 if jwt_payload:
-                    logger.debug(
-                        "socketio_channel.input.connect.jwt",
-                        message=f"User {sid} connected to socketIO endpoint.",
-                    )
-                    # Store the chat state for this user
+                    logger.debug(f"User {sid} connected to socketIO endpoint.")
                     return True
                 else:
                     return False
             else:
-                logger.debug(
-                    "socketio_channel.input.connect",
-                    message=f"User {sid} connected to socketIO endpoint.",
-                )
-                # Store the chat state for this user
+                logger.debug(f"User {sid} connected to socketIO endpoint.")
                 return True
 
-        @sio_server.on("disconnect", namespace=self.namespace)
+        @sio.on("disconnect", namespace=self.namespace)
         async def disconnect(sid: Text) -> None:
-            logger.debug(
-                "socketio_channel.input.disconnect",
-                message=f"User {sid} disconnected from socketIO endpoint.",
-            )
+            logger.debug(f"User {sid} disconnected from socketIO endpoint.")
 
-        @sio_server.on("session_request", namespace=self.namespace)
+        @sio.on("session_request", namespace=self.namespace)
         async def session_request(sid: Text, data: Optional[Dict]) -> None:
-            logger.debug(
-                "socketio_channel.input.session_request",
-                message=f"User {sid} requested a session.",
-            )
             await self.handle_session_request(sid, data)
 
-        @sio_server.on(self.user_message_evt, namespace=self.namespace)
+        @sio.on(self.user_message_evt, namespace=self.namespace)
         async def handle_message(sid: Text, data: Dict) -> None:
-            logger.debug(
-                "socketio_channel.input.handle_message",
-                message=f"User {sid} sent a message.",
-                data=data,
-            )
             await self.handle_user_message(sid, data, on_new_message)
 
         return socketio_webhook
-
-    def reset_silence_timeout(self, silence_timeout: SilenceTimeout) -> None:
-        self._cancel_silence_timeout(silence_timeout.sender_id)
-
-        self.sender_silence_map[silence_timeout.sender_id] = (
-            asyncio.get_event_loop().create_task(
-                self._monitor_silence_timeout(
-                    silence_timeout,
-                )
-            )
-        )
-
-    def disconnect(self, sender_id: str) -> None:
-        """Disconnects the user with the given sender ID."""
-        self._cancel_silence_timeout(sender_id)
-        if self.sio_server:
-            asyncio.get_event_loop().create_task(self.sio_server.disconnect(sender_id))
-            logger.debug(
-                "socketio_channel.input.disconnect",
-                message=f"User {sender_id} disconnected from socketIO endpoint.",
-            )
-
-    async def _monitor_silence_timeout(self, silence_timeout: SilenceTimeout) -> None:
-        logger.debug(
-            "socketio_channel.input.silence_timeout_watch_started",
-            sender_id=silence_timeout.sender_id,
-            timeout=silence_timeout.timeout,
-        )
-        await asyncio.sleep(silence_timeout.timeout)
-
-        # once the timer is up, we call the handler
-        # to notify the user about the silence timeout
-        # this is important if monitoring trask is cancelled while handler is executed
-        asyncio.get_event_loop().create_task(
-            self._handle_silence_timeout(silence_timeout)
-        )
-
-        logger.debug(
-            "socketio_channel.input.silence_timeout_tripped",
-            sender_id=silence_timeout.sender_id,
-            silence_timeout=silence_timeout.timeout,
-        )
-
-    async def _handle_silence_timeout(self, event: SilenceTimeout) -> None:
-        if self.on_new_message:
-            output_channel = self.get_output_channel()
-            message = UserMessage(
-                text=USER_CONVERSATION_SILENCE_TIMEOUT,
-                output_channel=output_channel,
-                sender_id=event.sender_id,
-                input_channel=self.name(),
-            )
-            await self.on_new_message(message)
-
-    def _cancel_silence_timeout(self, sender_id: str) -> None:
-        """Cancels the silence timeout task for the given sender."""
-        task = self.sender_silence_map.pop(sender_id, None)
-        if task and not task.done():
-            logger.debug(
-                "socketio_channel.input.silence_timeout_cancelled",
-                sender_id=sender_id,
-            )
-            task.cancel()

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(),