rasa-pro 3.14.0a15__py3-none-any.whl → 3.14.0a17__py3-none-any.whl

rasa/core/channels/inspector/src/components/LatencyDisplay.tsx

@@ -2,40 +2,47 @@ import {
   Box,
   Flex,
   FlexProps,
-  Text,
-  useColorModeValue,
-  Tooltip,
   Table,
   Tbody,
-  Tr,
   Td,
+  Text,
+  Tooltip,
+  Tr,
+  useColorModeValue,
 } from '@chakra-ui/react'
 import { useOurTheme } from '../theme'
-import { LatencyData } from '../types'
+import {
+  isRasaLatency,
+  isVoiceLatency,
+  RasaLatency,
+  VoiceLatency,
+} from '../types'
 
-interface Props extends FlexProps {
-  latency: LatencyData
+interface MinimalDisplayProps extends FlexProps {
+  latency: RasaLatency
 }
 
 /**
  * Simple latency display for text-only conversations.
  * Shows a single response time value.
  */
-const MinimalDisplay = ({ latency, sx, ...props }: Props) => {
+const MinimalDisplay = ({ latency, sx, ...props }: MinimalDisplayProps) => {
   const containerSx = {
     ...sx,
     display: 'flex',
     alignItems: 'center',
   }
-  
+
   const getLatencyColor = (latency: number) => {
     if (latency < 1500) return 'green.500'
     if (latency < 2500) return 'orange.500'
     return 'red.500'
   }
-  
-  const value = Math.round(latency.rasa_processing_latency_ms || 0);
-  const color = getLatencyColor(value);
+
+  const value = Math.round(
+    (latency.command_processor || 0) + (latency.prediction_loop || 0),
+  )
+  const color = getLatencyColor(value)
 
   return (
     <Flex sx={containerSx} {...props}>
@@ -49,11 +56,15 @@ const MinimalDisplay = ({ latency, sx, ...props }: Props) => {
   )
 }
 
+interface WaterfallDisplayProps extends FlexProps {
+  latency: VoiceLatency
+}
+
 /**
  * Detailed latency waterfall chart for voice conversations.
  * Displays processing times for ASR, Rasa, and TTS components.
  */
-const WaterfallDisplay = ({ latency, sx, ...props }: Props) => {
+const WaterfallDisplay = ({ latency, sx, ...props }: WaterfallDisplayProps) => {
   const { rasaSpace } = useOurTheme()
 
   const containerSx = {
@@ -61,13 +72,13 @@ const WaterfallDisplay = ({ latency, sx, ...props }: Props) => {
     flexDirection: 'column',
     gap: rasaSpace[1],
   }
-  
+
   const headerSx = {
     fontSize: 'sm',
     fontWeight: 'bold',
     color: useColorModeValue('gray.700', 'gray.300'),
   }
-  
+
   const waterfallBarSx = {
     height: '24px',
     borderRadius: '4px',
@@ -75,10 +86,10 @@ const WaterfallDisplay = ({ latency, sx, ...props }: Props) => {
     border: '1px solid',
     borderColor: useColorModeValue('gray.200', 'gray.600'),
   }
-  
+
   const legendTableSx = {
     size: 'sm',
-    mt: rasaSpace[0.5]
+    mt: rasaSpace[0.5],
   }
 
   const getLatencyColor = (type: string) => {
@@ -95,8 +106,10 @@ const WaterfallDisplay = ({ latency, sx, ...props }: Props) => {
     const descriptions: { [key: string]: string } = {
       asr: 'Time from the first Partial Transcript event to the Final Transcript event from Speech Recognition. It also includes the time taken by the user to speak.',
       rasa: 'Time taken by Rasa to process the text from the Final Transcript event from Speech Recognition until a text response is generated.',
-      tts_first: 'Time between the request sent to Text-to-Speech processing and the first byte of audio received by Rasa.',
-      tts_complete: 'Time taken by Text-to-Speech to complete audio generation. It depends on the length of the text and could overlap with the Bot speaking time.'
+      tts_first:
+        'Time between the request sent to Text-to-Speech processing and the first byte of audio received by Rasa.',
+      tts_complete:
+        'Time taken by Text-to-Speech to complete audio generation. It depends on the length of the text and could overlap with the Bot speaking time.',
     }
     return descriptions[type] || ''
   }
@@ -151,10 +164,10 @@ const WaterfallDisplay = ({ latency, sx, ...props }: Props) => {
   )
 
   // Calculate total latency for title (Rasa + TTS First Byte)
-  const totalDisplayLatency = 
-    (latency.rasa_processing_latency_ms || 0) + 
-    (latency.tts_first_byte_latency_ms || 0);
-    
+  const totalDisplayLatency =
+    (latency.rasa_processing_latency_ms || 0) +
+    (latency.tts_first_byte_latency_ms || 0)
+
   return (
     <Flex sx={containerSx} {...props}>
       <Text sx={headerSx}>
@@ -241,28 +254,43 @@ const WaterfallDisplay = ({ latency, sx, ...props }: Props) => {
   )
 }
 
+interface LatencyDisplayProps extends FlexProps {
+  voiceLatency?: any
+  rasaLatency?: any
+}
+
 /**
  * Displays processing latency information for the conversation.
- * Shows either a detailed waterfall chart for voice conversations or 
+ * Shows either a detailed waterfall chart for voice conversations or
  * a simpler display for text-only conversations.
  */
 export const LatencyDisplay = ({
   sx,
-  latency,
+  voiceLatency,
+  rasaLatency,
   ...props
-}: Props) => {
-  if (!latency) {
-    console.warn('Latency data is not available')
-    return null
+}: LatencyDisplayProps) => {
+  // We give priority to voice latency as most comprehensive.
+  if (isVoiceLatency(voiceLatency)) {
+    return <WaterfallDisplay latency={voiceLatency} sx={sx} {...props} />
   }
 
-  // Show waterfall if voice metrics are available, otherwise show minimal display
-  const isVoiceMetricsAvailable =
-    latency.asr_latency_ms && latency.tts_complete_latency_ms
+  // If voice latency is not available, we use rasa latency.
+  if (isRasaLatency(rasaLatency)) {
+    return <MinimalDisplay latency={rasaLatency} sx={sx} {...props} />
+  }
 
-  if (isVoiceMetricsAvailable) {
-    return <WaterfallDisplay latency={latency} sx={sx} {...props} />
+  // If rasa latency is not available, we are either waiting for first data from voice stream or the conversation is not started yet.
+  if (!rasaLatency) {
+    return <Text>Rasa latency data is not available yet</Text>
   }
 
-  return <MinimalDisplay latency={latency} sx={sx} {...props} />
+  // If rasa latency is available but did not pass type guard, we are in an unexpected state
+  // and we should log an error but gracefully fallback to showing no data.
+  console.warn(
+    `Latency data has unexpected format. Raw data of rasaLatency: ${rasaLatency},
+    raw data of voice latency: ${voiceLatency}`,
+  )
+
+  return <Text>Latency data is not available yet</Text>
 }

rasa/core/channels/inspector/src/helpers/audio/audiostream.ts

@@ -52,6 +52,7 @@ interface AudioQueue {
   addMarker: (id: string) => void
   reduceMarkers: (bytesRead: number) => void
   popMarkers: () => void
+  clear: () => void
 }
 
 const createAudioQueue = (socket: WebSocket): AudioQueue => {
@@ -108,6 +109,14 @@ const createAudioQueue = (socket: WebSocket): AudioQueue => {
         }
       })
     },
+
+    /**
+     * Clears the audio queue, removing all buffered audio and markers.
+     */
+    clear: function () {
+      this.buffer = new Float32Array(0)
+      this.marks = []
+    },
   }
 }
 
@@ -204,7 +213,12 @@ const addDataToAudioQueue =
         }
         console.log('Voice Latency Metrics:', data['latency'])
         audioQueue.addMarker(data['marker'])
+      } else if (data['interruptPlayback']) {
+        // User interrupted the bot, immediately clear the audio queue
+        audioQueue.clear()
+        console.log('Audio queue cleared due to user interruption.')
       }
+
     } catch (error) {
       console.error('Error processing server incoming audio data:', error)
     }

rasa/core/channels/inspector/src/types.ts

@@ -17,7 +17,8 @@ export interface Event {
   timestamp: string
   update?: string
   parse_data?: { commands: Command[] }
-  metadata?: { utter_action?: string }
+  metadata?: { utter_action?: string; execution_times?: RasaLatency }
+  name?: string
 }
 
 export interface Command {
@@ -42,11 +43,16 @@ export interface Stack {
   ended: boolean
 }
 
-export interface LatencyData {
-  rasa_processing_latency_ms?: number
-  asr_latency_ms?: number
-  tts_first_byte_latency_ms?: number
-  tts_complete_latency_ms?: number
+export interface RasaLatency {
+  command_processor: number
+  prediction_loop: number
+}
+
+export interface VoiceLatency {
+  rasa_processing_latency_ms: number
+  asr_latency_ms: number
+  tts_first_byte_latency_ms: number
+  tts_complete_latency_ms: number
 }
 
 export interface Tracker {
@@ -54,7 +60,6 @@ export interface Tracker {
   slots: { [key: string]: unknown }
   events: Event[]
   stack: Stack[]
-  latency?: LatencyData
 }
 
 export interface Flow {
@@ -96,3 +101,23 @@ interface Step {
   utter: string
   set_slots?: unknown
 }
+
+export function isRasaLatency(obj: any): obj is RasaLatency {
+  return (
+    obj !== null &&
+    typeof obj === 'object' &&
+    typeof obj.command_processor === 'number' &&
+    typeof obj.prediction_loop === 'number'
+  )
+}
+
+export function isVoiceLatency(obj: any): obj is VoiceLatency {
+  return (
+    obj !== null &&
+    typeof obj === 'object' &&
+    typeof obj.rasa_processing_latency_ms === 'number' &&
+    typeof obj.asr_latency_ms === 'number' &&
+    typeof obj.tts_first_byte_latency_ms === 'number' &&
+    typeof obj.tts_complete_latency_ms === 'number'
+  )
+}

rasa/core/channels/studio_chat.py

@@ -4,7 +4,6 @@ import asyncio
 import audioop
 import base64
 import json
-import time
 import uuid
 from functools import partial
 from typing import (
@@ -53,9 +52,7 @@ if TYPE_CHECKING:
 structlogger = structlog.get_logger()
 
 
-def tracker_as_dump(
-    tracker: "DialogueStateTracker", latency: Optional[float] = None
-) -> Dict[str, Any]:
+def tracker_as_dump(tracker: "DialogueStateTracker") -> Dict[str, Any]:
     """Create a dump of the tracker state."""
     from rasa.shared.core.trackers import get_trackers_for_conversation_sessions
 
@@ -66,13 +63,7 @@ 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
 
 
@@ -227,32 +218,16 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
     def _register_tracker_update_hook(self) -> None:
         plugin_manager().register(StudioTrackerUpdatePlugin(self))
 
-    async def on_tracker_updated(
-        self, tracker: "DialogueStateTracker", latency: Optional[float] = None
-    ) -> None:
+    async def on_tracker_updated(self, tracker: "DialogueStateTracker") -> None:
         """Triggers a tracker update notification after a change to the tracker."""
-        await self.publish_tracker_update(
-            tracker.sender_id, tracker_as_dump(tracker, latency)
-        )
+        await self.publish_tracker_update(tracker.sender_id, tracker_as_dump(tracker))
 
-    async def publish_tracker_update(self, sender_id: str, tracker_dump: str) -> None:
+    async def publish_tracker_update(
+        self, sender_id: str, tracker_dump: Dict[str, Any]
+    ) -> None:
         """Publishes a tracker update notification to the websocket."""
         await self.emit("tracker", tracker_dump, room=sender_id)
 
-    def _record_turn_start_time(self, sender_id: Text) -> None:
-        """Records the start time of a new turn."""
-        self._turn_start_times[sender_id] = time.time()
-
-    def _get_latency(self, sender_id: Text) -> Optional[float]:
-        """Returns the latency of the current turn in milliseconds."""
-        if sender_id not in self._turn_start_times:
-            return None
-
-        latency = (time.time() - self._turn_start_times[sender_id]) * 1000
-        # The turn is over, so we can remove the start time
-        del self._turn_start_times[sender_id]
-        return latency
-
     async def on_message_proxy(
         self,
         on_new_message: Callable[[UserMessage], Awaitable[Any]],
@@ -262,7 +237,6 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
         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:
@@ -288,8 +262,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             structlogger.error("studio_chat.on_message_proxy.tracker_not_found")
             return
 
-        latency = self._get_latency(message.sender_id)
-        await self.on_tracker_updated(tracker, latency)
+        await self.on_tracker_updated(tracker)
 
     async def emit_error(self, message: str, room: str, e: Exception) -> None:
         await self.emit(
@@ -389,16 +362,23 @@ 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."""
+        """Create a voice output channel. This is used by VoiceInputChannel."""
         return StudioVoiceOutputChannel(
             voice_websocket,
             tts_engine,
             self.tts_cache,
         )
 
+    async def interrupt_playback(
+        self, ws: Websocket, call_parameters: CallParameters
+    ) -> None:
+        """Interrupt the current playback of audio."""
+        structlogger.debug("studio_chat.interrupt_playback")
+        await ws.send(json.dumps({"interruptPlayback": True}))
+
     def _start_voice_session(
         self,
         session_id: str,
@@ -469,8 +449,9 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
     def blueprint(
         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)
+        socket_blueprint = super().blueprint(
+            partial(self.on_message_proxy, on_new_message)
+        )
 
         if not self.sio_server:
             structlogger.error("studio_chat.blueprint.sio_not_initialized")
@@ -506,7 +487,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
             # start a voice session if requested
             if data and data.get("is_voice", False):
-                self._start_voice_session(data["session_id"], sid, proxied_on_message)
+                self._start_voice_session(data["session_id"], sid, on_new_message)
 
         @self.sio_server.on(self.user_message_evt, namespace=self.namespace)
         async def handle_message(sid: Text, data: Dict) -> None:
@@ -521,7 +502,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
             try:
                 # Handle text messages
-                await self.handle_user_message(sid, data, proxied_on_message)
+                await self.handle_user_message(sid, data, on_new_message)
             except Exception as e:
                 structlogger.exception(
                     "studio_chat.sio.handle_message.error",

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

@@ -15,7 +15,7 @@ class NewTranscript(ASREvent):
 
 @dataclass
 class UserIsSpeaking(ASREvent):
-    pass
+    text: str
 
 
 @dataclass

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

@@ -1,7 +1,7 @@
 import asyncio
 import os
 from dataclasses import dataclass
-from typing import Any, AsyncIterator, Dict, Optional
+from typing import TYPE_CHECKING, Any, AsyncIterator, Dict, Optional
 
 import structlog
 
@@ -15,6 +15,9 @@ from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.shared.constants import AZURE_SPEECH_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
+if TYPE_CHECKING:
+    from azure.cognitiveservices.speech import SpeechRecognitionEventArgs
+
 logger = structlog.get_logger(__name__)
 
 
@@ -43,9 +46,9 @@ class AzureASR(ASREngine[AzureASRConfig]):
         )
         self.main_loop = asyncio.get_running_loop()
 
-    def signal_user_is_speaking(self, event: Any) -> None:
+    def signal_user_is_speaking(self, event: "SpeechRecognitionEventArgs") -> None:
         """Replace the azure event with a generic is speaking event."""
-        self.fill_queue(UserIsSpeaking())
+        self.fill_queue(UserIsSpeaking(event.result.text))
 
     def fill_queue(self, event: Any) -> None:
         """Either puts the event or a dedicated ASR Event into the queue."""

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

@@ -117,7 +117,7 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
                         self.accumulated_transcript, transcript
                     )
             elif transcript:
-                return UserIsSpeaking()
+                return UserIsSpeaking(transcript)
         # event that comes after utterance_end_ms of no new transcript
         elif data_type == "UtteranceEnd":
             if self.accumulated_transcript:

rasa/core/channels/voice_stream/audiocodes.py

@@ -89,6 +89,7 @@ class AudiocodesVoiceOutputChannel(VoiceOutputChannel):
         # This is an approximation, as the bot will be sent the audio chunks next
         # which are played to the user immediately.
         call_state.is_bot_speaking = True
+        VoiceInputChannel._cancel_silence_timeout_watcher()
 
     async def send_intermediate_marker(self, recipient_id: str) -> None:
         """Audiocodes doesn't need intermediate markers, so do nothing."""
@@ -116,6 +117,7 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        interruptions: Optional[Dict[str, int]] = None,
         token: Optional[Text] = None,
     ):
         mark_as_beta_feature("Audiocodes (audiocodes_stream) Channel")
@@ -123,6 +125,7 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
             server_url=server_url,
             asr_config=asr_config,
             tts_config=tts_config,
+            interruptions=interruptions,
         )
         self.token = token
 

rasa/core/channels/voice_stream/browser_audio.py

@@ -3,7 +3,9 @@ from __future__ import annotations
 import audioop
 import base64
 import json
+import os
 import uuid
+import wave
 from typing import Any, Awaitable, Callable, Dict, Optional, Tuple
 
 import structlog
@@ -70,10 +72,45 @@ class BrowserAudioOutputChannel(VoiceOutputChannel):
 
 class BrowserAudioInputChannel(VoiceInputChannel):
     def __init__(
-        self, server_url: str, asr_config: Dict[str, Any], tts_config: Dict[str, Any]
+        self,
+        server_url: str,
+        asr_config: Dict[str, Any],
+        tts_config: Dict[str, Any],
+        recording: bool = False,
+        interruptions: Optional[Dict[str, int]] = None,
     ) -> None:
         """Initializes the browser audio input channel."""
-        super().__init__(server_url, asr_config, tts_config)
+        super().__init__(server_url, asr_config, tts_config, interruptions)
+
+        # For debugging, recording of user audio might be useful
+        # to identify audio quality issues or transcription errors
+        self._recording_enabled = recording
+        self._wav_file: Optional[wave.Wave_write] = None
+
+    def _start_recording(self, call_id: str, user_id: str) -> None:
+        os.makedirs("recordings", exist_ok=True)
+        filename = f"{user_id}_{call_id}.wav"
+        file_path = os.path.join("recordings", filename)
+
+        if not self._recording_enabled:
+            return
+
+        self._wav_file = wave.open(file_path, "wb")
+        self._wav_file.setnchannels(1)  # Mono audio
+        self._wav_file.setsampwidth(4)  # 32-bit audio (4 bytes)
+        self._wav_file.setframerate(8000)  # 8kHz sample rate
+        logger.info("voice_channel.user_audio_recording.started", file_path=file_path)
+
+    def _append_audio_to_recording(self, audio_bytes: bytes) -> None:
+        if self._wav_file and self._recording_enabled:
+            self._wav_file.writeframes(audio_bytes)
+
+    def _stop_recording(self) -> None:
+        """Close the recording file if it's open."""
+        if self._wav_file:
+            self._wav_file.close()
+            self._wav_file = None
+            logger.debug("voice_channel.user_audio_recording.stopped")
 
     @classmethod
     def name(cls) -> str:
@@ -94,7 +131,7 @@ class BrowserAudioInputChannel(VoiceInputChannel):
         credentials: Optional[Dict[str, Any]],
     ) -> BrowserAudioInputChannel:
         cls.validate_basic_credentials(credentials)
-        new_creds = repack_voice_credentials(credentials)
+        new_creds = repack_voice_credentials(credentials or {})
         return cls(**new_creds)
 
     def map_input_message(
@@ -105,6 +142,7 @@ class BrowserAudioInputChannel(VoiceInputChannel):
         data = json.loads(message)
         if "audio" in data:
             channel_bytes = base64.b64decode(data["audio"])
+            self._append_audio_to_recording(channel_bytes)
             audio_bytes = self.channel_bytes_to_rasa_audio_bytes(channel_bytes)
             return NewAudioAction(audio_bytes)
         elif "marker" in data:
@@ -120,6 +158,13 @@ class BrowserAudioInputChannel(VoiceInputChannel):
                 call_state.is_bot_speaking = True
         return ContinueConversationAction()
 
+    async def interrupt_playback(
+        self, ws: Websocket, call_parameters: CallParameters
+    ) -> None:
+        """Interrupt the current playback of audio."""
+        logger.debug("browser_audio.interrupt_playback")
+        await ws.send(json.dumps({"interruptPlayback": True}))
+
     def create_output_channel(
         self, voice_websocket: Websocket, tts_engine: TTSEngine
     ) -> VoiceOutputChannel:
@@ -142,8 +187,13 @@ class BrowserAudioInputChannel(VoiceInputChannel):
         @blueprint.websocket("/websocket")  # type: ignore
         async def handle_message(request: Request, ws: Websocket) -> None:
             try:
+                call_parameters = await self.collect_call_parameters(ws)
+                if call_parameters and call_parameters.call_id:
+                    self._start_recording(call_parameters.call_id, "local")
                 await self.run_audio_streaming(on_new_message, ws)
             except Exception as e:
                 logger.error("browser_audio.handle_message.error", error=e)
+            finally:
+                self._stop_recording()
 
         return blueprint

rasa/core/channels/voice_stream/genesys.py

@@ -99,10 +99,11 @@ class GenesysInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        interruptions: Optional[Dict[str, int]] = None,
         api_key: Optional[Text] = None,
         client_secret: Optional[Text] = None,
     ) -> None:
-        super().__init__(server_url, asr_config, tts_config)
+        super().__init__(server_url, asr_config, tts_config, interruptions)
         self.api_key = api_key
         self.client_secret = client_secret
 

rasa/core/channels/voice_stream/jambonz.py

@@ -81,6 +81,7 @@ class JambonzStreamInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        interruptions: Optional[Dict[str, int]] = None,
         username: Optional[Text] = None,
         password: Optional[Text] = None,
     ) -> None:
@@ -90,7 +91,7 @@ class JambonzStreamInputChannel(VoiceInputChannel):
             username: Optional username for basic auth
             password: Optional password for basic auth
         """
-        super().__init__(server_url, asr_config, tts_config)
+        super().__init__(server_url, asr_config, tts_config, interruptions)
         self.username = username
         self.password = password
 
@@ -185,6 +186,13 @@ class JambonzStreamInputChannel(VoiceInputChannel):
             self.tts_cache,
         )
 
+    async def interrupt_playback(
+        self, ws: Websocket, call_parameters: CallParameters
+    ) -> None:
+        """Interrupt the current playback of audio."""
+        logger.debug("jambonz.interrupt_playback")
+        await ws.send(json.dumps({"type": "killAudio"}))
+
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint: