rasa-pro 3.10.16__py3-none-any.whl → 3.11.0__py3-none-any.whl

rasa/core/channels/{twilio_voice.py → voice_ready/twilio_voice.py}

@@ -1,9 +1,11 @@
 from sanic import Blueprint, response
-from sanic.request import Request
+from sanic.request import Request, RequestParameters
 from sanic.response import HTTPResponse
 from twilio.twiml.voice_response import VoiceResponse, Gather
 from typing import Text, Callable, Awaitable, List, Any, Dict, Optional
+from dataclasses import asdict
 
+import structlog
 import rasa.utils.io
 import rasa.shared.utils.io
 from rasa.shared.core.events import BotUttered
@@ -13,6 +15,19 @@ from rasa.core.channels.channel import (
     CollectingOutputChannel,
     UserMessage,
 )
+from rasa.core.channels.voice_ready.utils import CallParameters
+
+logger = structlog.get_logger(__name__)
+
+
+def map_call_params(form: RequestParameters) -> CallParameters:
+    """Map the Audiocodes parameters to the CallParameters dataclass."""
+    return CallParameters(
+        call_id=form.get("CallSid"),
+        user_phone=form.get("Caller"),
+        bot_phone=form.get("Called"),
+        direction=form.get("Direction"),
+    )
 
 
 class TwilioVoiceInput(InputChannel):
@@ -105,7 +120,6 @@ class TwilioVoiceInput(InputChannel):
         credentials = credentials or {}
 
         return cls(
-            credentials.get("initial_prompt", "hello"),
             credentials.get(
                 "reprompt_fallback_phrase",
                 "I'm sorry I didn't get that could you rephrase.",
@@ -118,7 +132,6 @@ class TwilioVoiceInput(InputChannel):
 
     def __init__(
         self,
-        initial_prompt: Optional[Text],
         reprompt_fallback_phrase: Optional[Text],
         assistant_voice: Optional[Text],
         speech_timeout: Text = "5",
@@ -128,14 +141,12 @@ class TwilioVoiceInput(InputChannel):
         """Creates a connection to Twilio voice.
 
         Args:
-            initial_prompt: text to use to prompt a conversation when call is answered.
             reprompt_fallback_phrase: phrase to use if no user response.
             assistant_voice: name of the assistant voice to use.
             speech_timeout: how long to pause when user finished speaking.
             speech_model: type of transcription model to use from Twilio.
             enhanced: toggle to use Twilio's premium speech transcription model.
         """
-        self.initial_prompt = initial_prompt
         self.reprompt_fallback_phrase = reprompt_fallback_phrase
         self.assistant_voice = assistant_voice
         self.speech_timeout = speech_timeout
@@ -239,22 +250,43 @@ class TwilioVoiceInput(InputChannel):
             text = request.form.get("SpeechResult")
             input_channel = self.name()
             call_status = request.form.get("CallStatus")
+            metadata = {}
 
             collector = TwilioVoiceCollectingOutputChannel()
 
+            logger.debug(
+                "twilio_voice.webhook",
+                sender_id=sender_id,
+                text=text,
+                call_status=call_status,
+            )
             # Provide an initial greeting to answer the user's call.
             if (text is None) and (call_status == "ringing"):
-                text = self.initial_prompt
+                text = "/session_start"
+                metadata = asdict(map_call_params(request.form))
+
+            # when call is disconnected
+            if call_status == "completed":
+                text = "/session_end"
+                metadata = {"reason": "user disconnected"}
 
             # determine the response.
             if text is not None:
+                logger.info("twilio_voice.webhook.text_not_none", sender_id=sender_id)
                 await on_new_message(
-                    UserMessage(text, collector, sender_id, input_channel=input_channel)
+                    UserMessage(
+                        text,
+                        collector,
+                        sender_id,
+                        input_channel=input_channel,
+                        metadata=metadata,
+                    )
                 )
 
                 twilio_response = self._build_twilio_voice_response(collector.messages)
             # If the user doesn't respond resend the last message.
             else:
+                logger.info("twilio_voice.webhook.text_none", sender_id=sender_id)
                 # Get last user utterance from tracker.
                 tracker = await request.app.ctx.agent.tracker_store.retrieve(sender_id)
                 last_response = None
@@ -285,6 +317,7 @@ class TwilioVoiceInput(InputChannel):
         self, messages: List[Dict[Text, Any]]
     ) -> VoiceResponse:
         """Builds the Twilio Voice Response object."""
+        logger.debug("twilio_voice.build_twilio_voice_response", messages=messages)
         voice_response = VoiceResponse()
         gather = Gather(
             input="speech",
@@ -299,6 +332,11 @@ class TwilioVoiceInput(InputChannel):
         # Add a listener to the last message to listen for user response.
         for i, message in enumerate(messages):
             msg_text = message["text"]
+            # Check if the message is a hangup message.
+            if message.get("custom", {}).get("hangup"):
+                voice_response.hangup()
+                break
+
             if i + 1 == len(messages):
                 gather.say(msg_text, voice=self.assistant_voice)
                 voice_response.append(gather)
@@ -320,38 +358,23 @@ class TwilioVoiceCollectingOutputChannel(CollectingOutputChannel):
         """Name of the output channel."""
         return "twilio_voice"
 
-    @staticmethod
-    def _emoji_warning(text: Text) -> None:
-        """Raises a warning if text contains an emoji."""
-        emoji_regex = rasa.utils.io.get_emoji_regex()
-        if emoji_regex.findall(text):
-            rasa.shared.utils.io.raise_warning(
-                "Text contains an emoji in a voice response. "
-                "Review responses to provide a voice-friendly alternative."
-            )
-
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any
     ) -> None:
         """Sends the text message after removing emojis."""
-        self._emoji_warning(text)
+        text = rasa.utils.io.remove_emojis(text)
         for message_part in text.strip().split("\n\n"):
             await self._persist_message(self._message(recipient_id, text=message_part))
 
     async def send_text_with_buttons(
         self,
-        recipient_id: Text,
-        text: Text,
-        buttons: List[Dict[Text, Any]],
+        recipient_id: str,
+        text: str,
+        buttons: List[Dict[str, Any]],
         **kwargs: Any,
     ) -> None:
-        """Convert buttons into a voice representation."""
-        self._emoji_warning(text)
-        await self._persist_message(self._message(recipient_id, text=text))
-
-        for b in buttons:
-            self._emoji_warning(b["title"])
-            await self._persist_message(self._message(recipient_id, text=b["title"]))
+        """Uses the concise button output format for voice channels."""
+        await self.send_text_with_buttons_concise(recipient_id, text, buttons, **kwargs)
 
     async def send_image_url(
         self, recipient_id: Text, image: Text, **kwargs: Any
@@ -365,3 +388,16 @@ class TwilioVoiceCollectingOutputChannel(CollectingOutputChannel):
             "with a visual elements such as images and emojis "
             "that are used in your voice channel."
         )
+
+    async def hangup(self, recipient_id: Text, **kwargs: Any) -> None:
+        """
+        Indicate that the conversation should be ended.
+
+        Parent class is a collecting output channel, so we don't actually hang up
+        but we add a custom message to the list of messages to be sent.
+        This message will be picked up by _build_twilio_voice_response
+        which will hang up the call.
+        """
+        await self._persist_message(
+            self._message(recipient_id, custom={"hangup": True})
+        )

rasa/core/channels/voice_ready/utils.py

@@ -0,0 +1,37 @@
+import structlog
+from dataclasses import dataclass
+from typing import Optional
+
+
+structlogger = structlog.get_logger()
+
+
+def validate_voice_license_scope() -> None:
+    from rasa.utils.licensing import (
+        PRODUCT_AREA,
+        VOICE_SCOPE,
+        validate_license_from_env,
+    )
+
+    """Validate that the correct license scope is present."""
+    structlogger.info(
+        f"Validating current Rasa Pro license scope which must include "
+        f"the '{VOICE_SCOPE}' scope to use the voice channel."
+    )
+
+    voice_product_scope = PRODUCT_AREA + " " + VOICE_SCOPE
+    validate_license_from_env(product_area=voice_product_scope)
+
+
+@dataclass
+class CallParameters:
+    """Standardized call parameters for voice channels."""
+
+    call_id: str
+    user_phone: str
+    bot_phone: str
+    user_name: Optional[str] = None
+    user_host: Optional[str] = None
+    bot_host: Optional[str] = None
+    direction: Optional[str] = None
+    stream_id: Optional[str] = None

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

@@ -0,0 +1,89 @@
+from dataclasses import dataclass
+from typing import (
+    Dict,
+    AsyncIterator,
+    Any,
+    Generic,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+)
+
+from websockets.legacy.client import WebSocketClientProtocol
+
+from rasa.core.channels.voice_stream.asr.asr_event import ASREvent
+from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
+from rasa.core.channels.voice_stream.util import MergeableConfig
+from rasa.shared.exceptions import ConnectionException
+from rasa.shared.utils.common import validate_environment
+
+T = TypeVar("T", bound="ASREngineConfig")
+E = TypeVar("E", bound="ASREngine")
+
+
+@dataclass
+class ASREngineConfig(MergeableConfig):
+    pass
+
+
+class ASREngine(Generic[T]):
+    required_env_vars: Tuple[str, ...] = ()
+    required_packages: Tuple[str, ...] = ()
+
+    def __init__(self, config: Optional[T] = None):
+        self.config = self.get_default_config().merge(config)
+        self.asr_socket: Optional[WebSocketClientProtocol] = None
+        validate_environment(
+            self.required_env_vars,
+            self.required_packages,
+            f"ASR Engine {self.__class__.__name__}",
+        )
+
+    async def connect(self) -> None:
+        self.asr_socket = await self.open_websocket_connection()
+
+    async def open_websocket_connection(self) -> WebSocketClientProtocol:
+        """Connect to the ASR system."""
+        raise NotImplementedError
+
+    @classmethod
+    def from_config_dict(cls: Type[E], config: Dict) -> E:
+        raise NotImplementedError
+
+    async def close_connection(self) -> None:
+        if self.asr_socket:
+            await self.asr_socket.close()
+
+    async def signal_audio_done(self) -> None:
+        """Signal to the ASR Api that you are done sending data."""
+        raise NotImplementedError
+
+    async def send_audio_chunks(self, chunk: RasaAudioBytes) -> None:
+        """Send audio chunks to the ASR system via the websocket."""
+        if self.asr_socket is None:
+            raise ConnectionException("Websocket not connected.")
+        engine_bytes = self.rasa_audio_bytes_to_engine_bytes(chunk)
+        await self.asr_socket.send(engine_bytes)
+
+    def rasa_audio_bytes_to_engine_bytes(self, chunk: RasaAudioBytes) -> bytes:
+        """Convert RasaAudioBytes to bytes usable by this engine."""
+        raise NotImplementedError
+
+    async def stream_asr_events(self) -> AsyncIterator[ASREvent]:
+        """Stream the events returned by the ASR system as it is fed audio bytes."""
+        if self.asr_socket is None:
+            raise ConnectionException("Websocket not connected.")
+        async for message in self.asr_socket:
+            asr_event = self.engine_event_to_asr_event(message)
+            if asr_event:
+                yield asr_event
+
+    def engine_event_to_asr_event(self, e: Any) -> Optional[ASREvent]:
+        """Translate an engine event to a common ASREvent."""
+        raise NotImplementedError
+
+    @staticmethod
+    def get_default_config() -> T:
+        """Get the default config for this component."""
+        raise NotImplementedError

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

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class ASREvent:
+    @classmethod
+    def name(cls) -> str:
+        return cls.__name__
+
+
+@dataclass
+class NewTranscript(ASREvent):
+    text: str
+
+
+@dataclass
+class UserIsSpeaking(ASREvent):
+    pass

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

@@ -0,0 +1,129 @@
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, AsyncIterator
+import asyncio
+
+from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineConfig
+from rasa.core.channels.voice_stream.asr.asr_event import (
+    ASREvent,
+    NewTranscript,
+    UserIsSpeaking,
+)
+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
+
+
+@dataclass
+class AzureASRConfig(ASREngineConfig):
+    language: Optional[str] = None
+    speech_region: Optional[str] = None
+
+
+class AzureASR(ASREngine[AzureASRConfig]):
+    required_env_vars = (AZURE_SPEECH_API_KEY_ENV_VAR,)
+    required_packages = ("azure.cognitiveservices.speech",)
+
+    def __init__(self, config: Optional[AzureASRConfig] = None):
+        super().__init__(config)
+
+        import azure.cognitiveservices.speech as speechsdk
+
+        self.speech_recognizer: Optional[speechsdk.SpeechRecognizer] = None
+        self.stream: Optional[speechsdk.audio.PushAudioInputStream] = None
+        self.is_recognizing = False
+        self.queue: asyncio.Queue[speechsdk.SpeechRecognitionEventArgs] = (
+            asyncio.Queue()
+        )
+
+    @staticmethod
+    def validate_environment() -> None:
+        """Make sure all needed requirements for this component are met."""
+
+    def signal_user_is_speaking(self, event: Any) -> None:
+        """Replace the azure event with a generic is speaking event."""
+        self.fill_queue(UserIsSpeaking())
+
+    def fill_queue(self, event: Any) -> None:
+        """Either puts the event or a dedicated ASR Event into the queue."""
+        self.queue.put_nowait(event)
+
+    async def connect(self) -> None:
+        import azure.cognitiveservices.speech as speechsdk
+
+        speech_config = speechsdk.SpeechConfig(
+            subscription=os.environ[AZURE_SPEECH_API_KEY_ENV_VAR],
+            region=self.config.speech_region,
+        )
+        audio_format = speechsdk.audio.AudioStreamFormat(
+            samples_per_second=HERTZ,
+            bits_per_sample=8,
+            channels=1,
+            wave_stream_format=speechsdk.AudioStreamWaveFormat.MULAW,
+        )
+        self.stream = speechsdk.audio.PushAudioInputStream(stream_format=audio_format)
+        audio_config = speechsdk.audio.AudioConfig(stream=self.stream)
+        self.speech_recognizer = speechsdk.SpeechRecognizer(
+            speech_config=speech_config,
+            language=self.config.language,
+            audio_config=audio_config,
+        )
+        self.speech_recognizer.recognized.connect(self.fill_queue)
+        self.speech_recognizer.recognizing.connect(self.signal_user_is_speaking)
+        self.speech_recognizer.start_continuous_recognition_async()
+        self.is_recognizing = True
+
+    async def close_connection(self) -> None:
+        if self.speech_recognizer is None:
+            raise ConnectionException("Websocket not connected.")
+        self.speech_recognizer.stop_continuous_recognition_async()
+
+    async def signal_audio_done(self) -> None:
+        """Signal to the ASR Api that you are done sending data."""
+        self.is_recognizing = False
+
+    def rasa_audio_bytes_to_engine_bytes(self, chunk: RasaAudioBytes) -> bytes:
+        """Convert RasaAudioBytes to bytes usable by this engine."""
+        return chunk
+
+    async def send_audio_chunks(self, chunk: RasaAudioBytes) -> None:
+        """Send audio chunks to the ASR system via the websocket."""
+        if self.speech_recognizer is None or self.stream is None:
+            raise ConnectionException("ASR not connected.")
+        engine_bytes = self.rasa_audio_bytes_to_engine_bytes(chunk)
+        self.stream.write(engine_bytes)
+
+    async def stream_asr_events(self) -> AsyncIterator[ASREvent]:
+        """Stream the events returned by the ASR system as it is fed audio bytes."""
+        if self.speech_recognizer is None:
+            raise ConnectionException("Websocket not connected.")
+        while self.is_recognizing or not self.queue.empty():
+            try:
+                message = await asyncio.wait_for(self.queue.get(), timeout=2)
+                asr_event = self.engine_event_to_asr_event(message)
+                if asr_event:
+                    yield asr_event
+            except asyncio.TimeoutError:
+                pass
+
+    def engine_event_to_asr_event(self, e: Any) -> Optional[ASREvent]:
+        """Translate an engine event to a common ASREvent."""
+        import azure.cognitiveservices.speech as speechsdk
+
+        if isinstance(e, speechsdk.SpeechRecognitionEventArgs) and isinstance(
+            e.result, speechsdk.SpeechRecognitionResult
+        ):
+            return NewTranscript(e.result.text)
+        if isinstance(e, ASREvent):
+            # transformation happened before
+            return e
+
+        return None
+
+    @staticmethod
+    def get_default_config() -> AzureASRConfig:
+        return AzureASRConfig("en-US", "germanywestcentral")
+
+    @classmethod
+    def from_config_dict(cls, config: Dict) -> "AzureASR":
+        return AzureASR(AzureASRConfig.from_dict(config))

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

@@ -0,0 +1,90 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+import json
+import os
+
+import websockets
+from websockets.legacy.client import WebSocketClientProtocol
+
+from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineConfig
+from rasa.core.channels.voice_stream.asr.asr_event import (
+    ASREvent,
+    NewTranscript,
+    UserIsSpeaking,
+)
+from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
+from rasa.shared.constants import DEEPGRAM_API_KEY_ENV_VAR
+
+
+@dataclass
+class DeepgramASRConfig(ASREngineConfig):
+    endpoint: Optional[str] = None
+    # number of miliseconds of silence to determine end of speech
+    endpointing: Optional[int] = None
+    language: Optional[str] = None
+    model: Optional[str] = None
+    smart_format: Optional[bool] = None
+
+
+class DeepgramASR(ASREngine[DeepgramASRConfig]):
+    required_env_vars = (DEEPGRAM_API_KEY_ENV_VAR,)
+
+    def __init__(self, config: Optional[DeepgramASRConfig] = None):
+        super().__init__(config)
+        self.accumulated_transcript = ""
+
+    async def open_websocket_connection(self) -> WebSocketClientProtocol:
+        """Connect to the ASR system."""
+        deepgram_api_key = os.environ[DEEPGRAM_API_KEY_ENV_VAR]
+        extra_headers = {"Authorization": f"Token {deepgram_api_key}"}
+        api_url = self._get_api_url()
+        query_params = self._get_query_params()
+        return await websockets.connect(  # type: ignore
+            api_url + query_params,
+            extra_headers=extra_headers,
+        )
+
+    def _get_api_url(self) -> str:
+        return f"wss://{self.config.endpoint}/v1/listen?"
+
+    def _get_query_params(self) -> str:
+        return (
+            f"encoding=mulaw&sample_rate={HERTZ}&endpointing={self.config.endpointing}"
+            f"&vad_events=true&language={self.config.language}&interim_results=true"
+            f"&model={self.config.model}&smart_format={str(self.config.smart_format).lower()}"
+        )
+
+    async def signal_audio_done(self) -> None:
+        """Signal to the ASR Api that you are done sending data."""
+        if self.asr_socket is None:
+            raise AttributeError("Websocket not connected.")
+        await self.asr_socket.send(json.dumps({"type": "CloseStream"}))
+
+    def rasa_audio_bytes_to_engine_bytes(self, chunk: RasaAudioBytes) -> bytes:
+        """Convert RasaAudioBytes to bytes usable by this engine."""
+        return chunk
+
+    def engine_event_to_asr_event(self, e: Any) -> Optional[ASREvent]:
+        """Translate an engine event to a common ASREvent."""
+        data = json.loads(e)
+        if "is_final" in data:
+            transcript = data["channel"]["alternatives"][0]["transcript"]
+            if data["is_final"]:
+                if data.get("speech_final"):
+                    full_transcript = self.accumulated_transcript + transcript
+                    self.accumulated_transcript = ""
+                    if full_transcript:
+                        return NewTranscript(full_transcript)
+                else:
+                    self.accumulated_transcript += transcript
+            elif transcript:
+                return UserIsSpeaking()
+        return None
+
+    @staticmethod
+    def get_default_config() -> DeepgramASRConfig:
+        return DeepgramASRConfig("api.deepgram.com", 400, "en", "nova-2-general", True)
+
+    @classmethod
+    def from_config_dict(cls, config: Dict) -> "DeepgramASR":
+        return DeepgramASR(DeepgramASRConfig.from_dict(config))

rasa/core/channels/voice_stream/audio_bytes.py

@@ -0,0 +1,8 @@
+from typing import NewType
+
+# a common intermediate audio byte format that acts as a common data format,
+# to prevent quadratic complexity between formats of channels, asr engines,
+# and tts engines
+# currently corresponds to raw wave, 8khz, 8bit, mono channel, mulaw encoding
+RasaAudioBytes = NewType("RasaAudioBytes", bytes)
+HERTZ = 8000

rasa/core/channels/voice_stream/browser_audio.py

@@ -0,0 +1,107 @@
+import audioop
+import base64
+import json
+
+import structlog
+import uuid
+from typing import Any, Awaitable, Callable, Optional, Tuple
+
+from sanic import Blueprint, HTTPResponse, Request, response
+from sanic import Websocket  # type: ignore
+
+
+from rasa.core.channels import UserMessage
+from rasa.core.channels.voice_ready.utils import CallParameters
+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.audio_bytes import RasaAudioBytes
+from rasa.core.channels.voice_stream.voice_channel import (
+    ContinueConversationAction,
+    EndConversationAction,
+    NewAudioAction,
+    VoiceChannelAction,
+    VoiceInputChannel,
+    VoiceOutputChannel,
+)
+
+logger = structlog.get_logger()
+
+
+class BrowserAudioOutputChannel(VoiceOutputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "browser_audio"
+
+    def rasa_audio_bytes_to_channel_bytes(
+        self, rasa_audio_bytes: RasaAudioBytes
+    ) -> bytes:
+        return audioop.ulaw2lin(rasa_audio_bytes, 4)
+
+    def channel_bytes_to_message(self, recipient_id: str, channel_bytes: bytes) -> str:
+        return json.dumps({"audio": base64.b64encode(channel_bytes).decode("utf-8")})
+
+    def create_marker_message(self, recipient_id: str) -> Tuple[str, str]:
+        message_id = uuid.uuid4().hex
+        return json.dumps({"marker": message_id}), message_id
+
+
+class BrowserAudioInputChannel(VoiceInputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "browser_audio"
+
+    def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
+        return RasaAudioBytes(audioop.lin2ulaw(input_bytes, 4))
+
+    async def collect_call_parameters(
+        self, channel_websocket: Websocket
+    ) -> Optional[CallParameters]:
+        call_id = f"inspect-{uuid.uuid4()}"
+        return CallParameters(call_id, "local", "local", stream_id=call_id)
+
+    def map_input_message(
+        self,
+        message: Any,
+    ) -> VoiceChannelAction:
+        data = json.loads(message)
+        if "audio" in data:
+            channel_bytes = base64.b64decode(data["audio"])
+            audio_bytes = self.channel_bytes_to_rasa_audio_bytes(channel_bytes)
+            return NewAudioAction(audio_bytes)
+        elif "marker" in data:
+            if data["marker"] == call_state.latest_bot_audio_id:
+                # Just finished streaming last audio bytes
+                call_state.is_bot_speaking = False  # type: ignore[attr-defined]
+                if call_state.should_hangup:
+                    logger.debug(
+                        "browser_audio.hangup", marker=call_state.latest_bot_audio_id
+                    )
+                    return EndConversationAction()
+            else:
+                call_state.is_bot_speaking = True  # type: ignore[attr-defined]
+        return ContinueConversationAction()
+
+    def create_output_channel(
+        self, voice_websocket: Websocket, tts_engine: TTSEngine
+    ) -> VoiceOutputChannel:
+        return BrowserAudioOutputChannel(
+            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("browser_audio", __name__)
+
+        @blueprint.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @blueprint.websocket("/websocket")  # type: ignore
+        async def handle_message(request: Request, ws: Websocket) -> None:
+            await self.run_audio_streaming(on_new_message, ws)
+
+        return blueprint