rasa-pro 3.12.0.dev12__py3-none-any.whl → 3.12.0rc1__py3-none-any.whl

rasa/core/channels/voice_stream/asr/deepgram.py

@@ -4,7 +4,9 @@ from dataclasses import dataclass
 from typing import Any, Dict, Optional
 from urllib.parse import urlencode
 
+import structlog
 import websockets
+import websockets.exceptions
 from websockets.legacy.client import WebSocketClientProtocol
 
 from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineConfig
@@ -16,6 +18,8 @@ from rasa.core.channels.voice_stream.asr.asr_event import (
 from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.shared.constants import DEEPGRAM_API_KEY_ENV_VAR
 
+logger = structlog.get_logger(__name__)
+
 
 @dataclass
 class DeepgramASRConfig(ASREngineConfig):
@@ -41,10 +45,22 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
         """Connect to the ASR system."""
         deepgram_api_key = os.environ[DEEPGRAM_API_KEY_ENV_VAR]
         extra_headers = {"Authorization": f"Token {deepgram_api_key}"}
-        return await websockets.connect(  # type: ignore
-            self._get_api_url_with_query_params(),
-            extra_headers=extra_headers,
-        )
+        try:
+            return await websockets.connect(  # type: ignore
+                self._get_api_url_with_query_params(),
+                extra_headers=extra_headers,
+            )
+        except websockets.exceptions.InvalidStatusCode as e:
+            if e.status_code == 401:
+                error_msg = "Please make sure your Deepgram API key is correct."
+            else:
+                error_msg = "Connection to Deepgram failed."
+            logger.error(
+                "deepgram.connection.failed",
+                status_code=e.status_code,
+                error=error_msg,
+            )
+            raise
 
     def _get_api_url_with_query_params(self) -> str:
         """Combine api url and query params."""

rasa/core/channels/voice_stream/audiocodes.py

@@ -0,0 +1,264 @@
+import asyncio
+import base64
+import json
+from typing import Any, Awaitable, Callable, Dict, Optional, Text
+
+import structlog
+from sanic import (  # type: ignore[attr-defined]
+    Blueprint,
+    HTTPResponse,
+    Request,
+    Websocket,
+    response,
+)
+
+from rasa.core.channels import UserMessage
+from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
+from rasa.core.channels.voice_stream.call_state import (
+    call_state,
+)
+from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
+from rasa.core.channels.voice_stream.voice_channel import (
+    ContinueConversationAction,
+    EndConversationAction,
+    NewAudioAction,
+    VoiceChannelAction,
+    VoiceInputChannel,
+    VoiceOutputChannel,
+)
+
+logger = structlog.get_logger(__name__)
+
+
+def map_call_params(data: Dict[Text, Any]) -> CallParameters:
+    """Map the audiocodes stream parameters to the CallParameters dataclass."""
+    return CallParameters(
+        call_id=data["conversationId"],
+        user_phone=data["caller"],
+        # Bot phone is not available in the Audiocodes API
+        direction="inbound",  # AudioCodes calls are always inbound
+    )
+
+
+class AudiocodesVoiceOutputChannel(VoiceOutputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "ac_voice"
+
+    def rasa_audio_bytes_to_channel_bytes(
+        self, rasa_audio_bytes: RasaAudioBytes
+    ) -> bytes:
+        return base64.b64encode(rasa_audio_bytes)
+
+    def channel_bytes_to_message(self, recipient_id: str, channel_bytes: bytes) -> str:
+        media_message = json.dumps(
+            {
+                "type": "playStream.chunk",
+                "streamId": str(call_state.stream_id),
+                "audioChunk": channel_bytes.decode("utf-8"),
+            }
+        )
+        return media_message
+
+    async def send_start_marker(self, recipient_id: str) -> None:
+        """Send playStream.start before first audio chunk."""
+        call_state.stream_id += 1  # type: ignore[attr-defined]
+        media_message = json.dumps(
+            {
+                "type": "playStream.start",
+                "streamId": str(call_state.stream_id),
+            }
+        )
+        logger.debug("Sending start marker", stream_id=call_state.stream_id)
+        await self.voice_websocket.send(media_message)
+
+    async def send_intermediate_marker(self, recipient_id: str) -> None:
+        """Audiocodes doesn't need intermediate markers, so do nothing."""
+        pass
+
+    async def send_end_marker(self, recipient_id: str) -> None:
+        """Send playStream.stop after last audio chunk."""
+        media_message = json.dumps(
+            {
+                "type": "playStream.stop",
+                "streamId": str(call_state.stream_id),
+            }
+        )
+        logger.debug("Sending end marker", stream_id=call_state.stream_id)
+        await self.voice_websocket.send(media_message)
+
+
+class AudiocodesVoiceInputChannel(VoiceInputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "ac_voice"
+
+    def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
+        return RasaAudioBytes(base64.b64decode(input_bytes))
+
+    async def collect_call_parameters(
+        self, channel_websocket: Websocket
+    ) -> Optional[CallParameters]:
+        async for message in channel_websocket:
+            data = json.loads(message)
+            if data["type"] == "session.initiate":
+                # retrieve parameters set in the webhook - contains info about the
+                # caller
+                logger.info("received initiate message", data=data)
+                self._send_accepted(channel_websocket, data)
+                return map_call_params(data)
+            else:
+                logger.warning("ac_voice.unknown_message", data=data)
+        return None
+
+    def map_input_message(
+        self,
+        message: Any,
+        ws: Websocket,
+    ) -> VoiceChannelAction:
+        data = json.loads(message)
+        if data["type"] == "activities":
+            activities = data["activities"]
+            for activity in activities:
+                logger.debug("ac_voice.activity", data=activity)
+                if activity["name"] == "start":
+                    pass
+                elif activity["name"] == "dtmf":
+                    # TODO: handle DTMF input
+                    pass
+                elif activity["name"] == "playFinished":
+                    logger.debug("ac_voice.playFinished", data=activity)
+                    if call_state.should_hangup:
+                        logger.info("audiocodes.hangup")
+                        self._send_hangup(ws, data)
+                        # the conversation should continue until
+                        # we receive a end message from audiocodes
+                    pass
+                else:
+                    logger.warning("ac_voice.unknown_activity", data=activity)
+        elif data["type"] == "userStream.start":
+            logger.debug("ac_voice.userStream.start", data=data)
+            self._send_recognition_started(ws, data)
+        elif data["type"] == "userStream.chunk":
+            audio_bytes = self.channel_bytes_to_rasa_audio_bytes(data["audioChunk"])
+            return NewAudioAction(audio_bytes)
+        elif data["type"] == "userStream.stop":
+            logger.debug("ac_voice.stop_recognition", data=data)
+            self._send_recognition_ended(ws, data)
+        elif data["type"] == "session.resume":
+            logger.debug("ac_voice.resume", data=data)
+            self._send_accepted(ws, data)
+        elif data["type"] == "session.end":
+            logger.debug("ac_voice.end", data=data)
+            return EndConversationAction()
+        elif data["type"] == "connection.validate":
+            # not part of call flow; only sent when integration is created
+            self._send_validated(ws, data)
+        else:
+            logger.warning("ac_voice.unknown_message", data=data)
+
+        return ContinueConversationAction()
+
+    def _send_accepted(self, ws: Websocket, data: Dict[Text, Any]) -> None:
+        supported_formats = data.get("supportedMediaFormats", [])
+        preferred_format = "raw/mulaw"
+
+        if preferred_format not in supported_formats:
+            logger.warning(
+                "ac_voice.format_not_supported",
+                supported_formats=supported_formats,
+                preferred_format=preferred_format,
+            )
+            raise
+
+        payload = {
+            "type": "session.accepted",
+            "mediaFormat": "raw/mulaw",
+        }
+        _schedule_async_task(ws.send(json.dumps(payload)))
+
+    def _send_recognition_started(self, ws: Websocket, data: Dict[Text, Any]) -> None:
+        payload = {"type": "userStream.started"}
+        _schedule_async_task(ws.send(json.dumps(payload)))
+
+    def _send_recognition_ended(self, ws: Websocket, data: Dict[Text, Any]) -> None:
+        payload = {"type": "userStream.stopped"}
+        _schedule_async_task(ws.send(json.dumps(payload)))
+
+    def _send_hypothesis(self, ws: Websocket, data: Dict[Text, Any]) -> None:
+        """
+        TODO: The hypothesis message is sent by the bot to provide partial
+        recognition results. Using this message is recommended,
+        as VAIC relies on it for performing barge-in.
+        """
+        pass
+
+    def _send_recognition(self, ws: Websocket, data: Dict[Text, Any]) -> None:
+        """
+        TODO: The recognition message is sent by the bot to provide
+        the final recognition result. Using this message is recommended
+        mainly for logging purposes.
+        """
+        pass
+
+    def _send_hangup(self, ws: Websocket, data: Dict[Text, Any]) -> None:
+        payload = {
+            "conversationId": data["conversationId"],
+            "type": "activities",
+            "activities": [{"type": "event", "name": "hangup"}],
+        }
+        _schedule_async_task(ws.send(json.dumps(payload)))
+
+    def _send_validated(self, ws: Websocket, data: Dict[Text, Any]) -> None:
+        payload = {
+            "type": "connection.validated",
+            "success": True,
+        }
+        _schedule_async_task(ws.send(json.dumps(payload)))
+
+    def create_output_channel(
+        self, voice_websocket: Websocket, tts_engine: TTSEngine
+    ) -> VoiceOutputChannel:
+        return AudiocodesVoiceOutputChannel(
+            voice_websocket,
+            tts_engine,
+            self.tts_cache,
+        )
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> Blueprint:
+        """Defines a Sanic bluelogger.debug."""
+        blueprint = Blueprint("ac_voice", __name__)
+
+        @blueprint.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @blueprint.websocket("/websocket")  # type: ignore
+        async def receive(request: Request, ws: Websocket) -> None:
+            # TODO: validate API key header
+            logger.info("audiocodes.receive", message="Starting audio streaming")
+            try:
+                await self.run_audio_streaming(on_new_message, ws)
+            except Exception as e:
+                logger.exception(
+                    "audiocodes.receive",
+                    message="Error during audio streaming",
+                    error=e,
+                )
+                # return 500 error
+                raise
+
+        return blueprint
+
+
+def _schedule_async_task(coro: Awaitable[Any]) -> None:
+    """Helper function to schedule a coroutine in the event loop.
+
+    Args:
+        coro: The coroutine to schedule
+    """
+    loop = asyncio.get_running_loop()
+    loop.call_soon_threadsafe(lambda: loop.create_task(coro))

rasa/core/channels/voice_stream/browser_audio.py

@@ -65,6 +65,7 @@ class BrowserAudioInputChannel(VoiceInputChannel):
     def map_input_message(
         self,
         message: Any,
+        ws: Websocket,
     ) -> VoiceChannelAction:
         data = json.loads(message)
         if "audio" in data:
@@ -105,6 +106,9 @@ class BrowserAudioInputChannel(VoiceInputChannel):
 
         @blueprint.websocket("/websocket")  # type: ignore
         async def handle_message(request: Request, ws: Websocket) -> None:
-            await self.run_audio_streaming(on_new_message, ws)
+            try:
+                await self.run_audio_streaming(on_new_message, ws)
+            except Exception as e:
+                logger.error("browser_audio.handle_message.error", error=e)
 
         return blueprint

rasa/core/channels/voice_stream/call_state.py

@@ -1,6 +1,6 @@
 import asyncio
 from contextvars import ContextVar
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 
 from werkzeug.local import LocalProxy
@@ -19,6 +19,15 @@ class CallState:
     should_hangup: bool = False
     connection_failed: bool = False
 
+    # Genesys requires the server and client each maintain a
+    # monotonically increasing message sequence number.
+    client_sequence_number: int = 0
+    server_sequence_number: int = 0
+    audio_buffer: bytearray = field(default_factory=bytearray)
+
+    # Audiocodes requires a stream ID at start and end of stream
+    stream_id: int = 0
+
 
 _call_state: ContextVar[CallState] = ContextVar("call_state")
 call_state = LocalProxy(_call_state)

rasa/core/channels/voice_stream/genesys.py

@@ -0,0 +1,335 @@
+import asyncio
+import json
+from typing import Any, Awaitable, Callable, Dict, Optional, Text
+
+import structlog
+from sanic import (  # type: ignore[attr-defined]
+    Blueprint,
+    HTTPResponse,
+    Request,
+    Websocket,
+    response,
+)
+
+from rasa.core.channels import UserMessage
+from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
+from rasa.core.channels.voice_stream.call_state import (
+    call_state,
+)
+from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
+from rasa.core.channels.voice_stream.voice_channel import (
+    ContinueConversationAction,
+    EndConversationAction,
+    NewAudioAction,
+    VoiceChannelAction,
+    VoiceInputChannel,
+    VoiceOutputChannel,
+)
+
+# Not mentioned in the documentation but observed in Geneys's example
+# https://github.com/GenesysCloudBlueprints/audioconnector-server-reference-implementation
+MAXIMUM_BINARY_MESSAGE_SIZE = 64000  # 64KB
+logger = structlog.get_logger(__name__)
+
+
+def map_call_params(data: Dict[Text, Any]) -> CallParameters:
+    """Map the twilio stream parameters to the CallParameters dataclass."""
+    parameters = data["parameters"]
+    participant = parameters["participant"]
+    # sent as {"ani": "tel:+491604697810"}
+    ani = participant.get("ani", "")
+    user_phone = ani.split(":")[-1] if ani else ""
+
+    return CallParameters(
+        call_id=parameters.get("conversationId", ""),
+        user_phone=user_phone,
+        bot_phone=participant.get("dnis", ""),
+    )
+
+
+class GenesysOutputChannel(VoiceOutputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "genesys"
+
+    async def send_audio_bytes(
+        self, recipient_id: str, audio_bytes: RasaAudioBytes
+    ) -> None:
+        """
+        Send audio bytes to the recipient with buffering.
+
+        Genesys throws a rate limit error with too many audio messages.
+        To avoid this, we buffer the audio messages and send them in chunks.
+
+        - global.inbound.binary.average.rate.per.second: 5
+        The allowed average rate per second of inbound binary data
+
+        - global.inbound.binary.max: 25
+        The maximum number of inbound binary data messages
+        that can be sent instantaneously
+
+        https://developer.genesys.cloud/organization/organization/limits#audiohook
+        """
+        call_state.audio_buffer.extend(audio_bytes)
+
+        # If we receive a non-standard chunk size, assume it's the end of a sequence
+        # or buffer is more than 32KB (this is half of genesys's max audio message size)
+        if len(audio_bytes) != 1024 or len(call_state.audio_buffer) >= (
+            MAXIMUM_BINARY_MESSAGE_SIZE / 2
+        ):
+            # TODO: we should send the buffer when we receive a synthesis complete event
+            # from TTS. This will ensure that the last audio chunk is always sent.
+            await self._send_audio_buffer(self.voice_websocket)
+
+    async def _send_audio_buffer(self, ws: Websocket) -> None:
+        """Send the audio buffer to the recipient if it's not empty."""
+        if call_state.audio_buffer:
+            buffer_bytes = bytes(call_state.audio_buffer)
+            await self._send_bytes_to_ws(ws, buffer_bytes)
+            call_state.audio_buffer.clear()
+
+    async def _send_bytes_to_ws(self, ws: Websocket, data: bytes) -> None:
+        """Send audio bytes to the recipient as a binary websocket message."""
+        if len(data) <= MAXIMUM_BINARY_MESSAGE_SIZE:
+            await self.voice_websocket.send(data)
+        else:
+            # split the audio into chunks
+            current_position = 0
+            while current_position < len(data):
+                end_position = min(
+                    current_position + MAXIMUM_BINARY_MESSAGE_SIZE, len(data)
+                )
+                await self.voice_websocket.send(data[current_position:end_position])
+                current_position = end_position
+
+    async def send_marker_message(self, recipient_id: str) -> None:
+        """
+        Send a message that marks positions in the audio stream.
+        Genesys does not support this feature, so we do nothing here.
+        """
+        pass
+
+
+class GenesysInputChannel(VoiceInputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "genesys"
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    def _get_next_sequence(self) -> int:
+        """
+        Get the next message sequence number
+        Rasa == Server
+        Genesys == Client
+
+        Genesys requires the server and client each maintain a
+        monotonically increasing message sequence number.
+        """
+        cs = call_state
+        cs.server_sequence_number += 1  # type: ignore[attr-defined]
+        return cs.server_sequence_number
+
+    def _get_last_client_sequence(self) -> int:
+        """Get the last client(Genesys) sequence number."""
+        return call_state.client_sequence_number
+
+    def _update_client_sequence(self, seq: int) -> None:
+        """Update the client(Genesys) sequence number."""
+        if seq - call_state.client_sequence_number != 1:
+            logger.warning(
+                "genesys.update_client_sequence.sequence_gap",
+                received_seq=seq,
+                last_seq=call_state.client_sequence_number,
+            )
+        call_state.client_sequence_number = seq  # type: ignore[attr-defined]
+
+    def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
+        return RasaAudioBytes(input_bytes)
+
+    async def collect_call_parameters(
+        self, channel_websocket: Websocket
+    ) -> Optional[CallParameters]:
+        """Call Parameters are collected during the open event."""
+        async for message in channel_websocket:
+            data = json.loads(message)
+            self._update_client_sequence(data["seq"])
+            if data.get("type") == "open":
+                call_params = await self.handle_open(channel_websocket, data)
+                return call_params
+            else:
+                logger.error("genesys.receive.unexpected_initial_message", message=data)
+
+        return None
+
+    def map_input_message(
+        self,
+        message: Any,
+        ws: Websocket,
+    ) -> VoiceChannelAction:
+        # if message is binary, it's audio
+        if isinstance(message, bytes):
+            return NewAudioAction(self.channel_bytes_to_rasa_audio_bytes(message))
+        else:
+            # process text message
+            data = json.loads(message)
+            self._update_client_sequence(data["seq"])
+            msg_type = data.get("type")
+            if msg_type == "close":
+                logger.info("genesys.handle_close", message=data)
+                self.handle_close(ws, data)
+                return EndConversationAction()
+            elif msg_type == "ping":
+                logger.info("genesys.handle_ping", message=data)
+                self.handle_ping(ws, data)
+            elif msg_type == "playback_started":
+                logger.debug("genesys.handle_playback_started", message=data)
+                call_state.is_bot_speaking = True  # type: ignore[attr-defined]
+            elif msg_type == "playback_completed":
+                logger.debug("genesys.handle_playback_completed", message=data)
+                call_state.is_bot_speaking = False  # type: ignore[attr-defined]
+                if call_state.should_hangup:
+                    logger.info("genesys.hangup")
+                    self.disconnect(ws, data)
+                    # the conversation should continue until
+                    # we receive a close message from Genesys
+            elif msg_type == "dtmf":
+                logger.info("genesys.handle_dtmf", message=data)
+            elif msg_type == "error":
+                logger.warning("genesys.handle_error", message=data)
+            else:
+                logger.warning("genesys.map_input_message.unknown_type", message=data)
+
+        return ContinueConversationAction()
+
+    def create_output_channel(
+        self, voice_websocket: Websocket, tts_engine: TTSEngine
+    ) -> VoiceOutputChannel:
+        return GenesysOutputChannel(
+            voice_websocket,
+            tts_engine,
+            self.tts_cache,
+        )
+
+    async def handle_open(self, ws: Websocket, message: dict) -> CallParameters:
+        """Handle initial open transaction from Genesys."""
+        call_parameters = map_call_params(message)
+        params = message["parameters"]
+        media_options = params.get("media", [])
+
+        # Send opened response
+        if media_options:
+            logger.info("genesys.handle_open", media_parameter=media_options[0])
+            response = {
+                "version": "2",
+                "type": "opened",
+                "seq": self._get_next_sequence(),
+                "clientseq": self._get_last_client_sequence(),
+                "id": message.get("id"),
+                "parameters": {"startPaused": False, "media": [media_options[0]]},
+            }
+            logger.debug("genesys.handle_open.opened", response=response)
+            await ws.send(json.dumps(response))
+        else:
+            logger.warning(
+                "genesys.handle_open.no_media_formats", client_message=message
+            )
+        return call_parameters
+
+    def handle_ping(self, ws: Websocket, message: dict) -> None:
+        """Handle ping message from Genesys."""
+        response = {
+            "version": "2",
+            "type": "pong",
+            "seq": self._get_next_sequence(),
+            "clientseq": message.get("seq"),
+            "id": message.get("id"),
+            "parameters": {},
+        }
+        logger.debug("genesys.handle_ping.pong", response=response)
+        _schedule_ws_task(ws.send(json.dumps(response)))
+
+    def handle_close(self, ws: Websocket, message: dict) -> None:
+        """Handle close message from Genesys."""
+        response = {
+            "version": "2",
+            "type": "closed",
+            "seq": self._get_next_sequence(),
+            "clientseq": self._get_last_client_sequence(),
+            "id": message.get("id"),
+            "parameters": message.get("parameters", {}),
+        }
+        logger.debug("genesys.handle_close.closed", response=response)
+
+        _schedule_ws_task(ws.send(json.dumps(response)))
+
+    def disconnect(self, ws: Websocket, data: dict) -> None:
+        """
+        Send disconnect message to Genesys.
+
+        https://developer.genesys.cloud/devapps/audiohook/protocol-reference#disconnect
+        It should be used to hangup the call.
+        Genesys will respond with a "close" message to us
+        that is handled by the handle_close method.
+        """
+        message = {
+            "version": "2",
+            "type": "disconnect",
+            "seq": self._get_next_sequence(),
+            "clientseq": self._get_last_client_sequence(),
+            "id": data.get("id"),
+            "parameters": {
+                "reason": "completed",
+                # arbitrary values can be sent here
+            },
+        }
+        logger.debug("genesys.disconnect", message=message)
+        _schedule_ws_task(ws.send(json.dumps(message)))
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> Blueprint:
+        """Defines a Sanic blueprint for the voice input channel."""
+        blueprint = Blueprint("genesys", __name__)
+
+        @blueprint.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @blueprint.websocket("/websocket")  # type: ignore[misc]
+        async def receive(request: Request, ws: Websocket) -> None:
+            logger.debug(
+                "genesys.receive",
+                audiohook_session_id=request.headers.get("audiohook-session-id"),
+            )
+            # validate required headers
+            required_headers = [
+                "audiohook-organization-id",
+                "audiohook-correlation-id",
+                "audiohook-session-id",
+                "x-api-key",
+            ]
+
+            for header in required_headers:
+                if header not in request.headers:
+                    await ws.close(1008, f"Missing required header: {header}")
+                    return
+
+            # TODO: validate API key header
+            # process audio streaming
+            logger.info("genesys.receive", message="Starting audio streaming")
+            await self.run_audio_streaming(on_new_message, ws)
+
+        return blueprint
+
+
+def _schedule_ws_task(coro: Awaitable[Any]) -> None:
+    """Helper function to schedule a coroutine in the event loop.
+
+    Args:
+        coro: The coroutine to schedule
+    """
+    loop = asyncio.get_running_loop()
+    loop.call_soon_threadsafe(lambda: loop.create_task(coro))