rasa-pro 3.12.22__py3-none-any.whl → 3.13.0__py3-none-any.whl

rasa/core/channels/voice_stream/audiocodes.py

@@ -104,30 +104,27 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
 
     def __init__(
         self,
-        token: Optional[Text],
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
+        token: Optional[Text] = None,
     ):
         mark_as_beta_feature("Audiocodes (audiocodes_stream) Channel")
-        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        super().__init__(
+            server_url=server_url,
+            asr_config=asr_config,
+            tts_config=tts_config,
+        )
         self.token = token
 
     @classmethod
     def from_credentials(
-        cls, credentials: Optional[Dict[str, Any]]
-    ) -> VoiceInputChannel:
-        if not credentials:
-            raise ValueError("No credentials given for Audiocodes voice channel.")
-
-        return cls(
-            token=credentials.get("token"),
-            server_url=credentials["server_url"],
-            asr_config=credentials["asr"],
-            tts_config=credentials["tts"],
-            monitor_silence=credentials.get("monitor_silence", False),
-        )
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> "AudiocodesVoiceInputChannel":
+        channel = super().from_credentials(credentials)
+        channel.token = credentials.get("token")  # type: ignore[attr-defined, union-attr]
+        return channel  # type: ignore[return-value]
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         return RasaAudioBytes(base64.b64decode(input_bytes))
@@ -292,7 +289,7 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
-        """Defines a Sanic bluelogger.debug."""
+        """Defines a Sanic blueprint"""
         blueprint = Blueprint("audiocodes_stream", __name__)
 
         @blueprint.route("/", methods=["GET"])

rasa/core/channels/voice_stream/browser_audio.py

@@ -97,7 +97,7 @@ class BrowserAudioInputChannel(VoiceInputChannel):
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
-        """Defines a Sanic bluelogger.debug."""
+        """Defines a Sanic blueprint"""
         blueprint = Blueprint("browser_audio", __name__)
 
         @blueprint.route("/", methods=["GET"])

rasa/core/channels/voice_stream/genesys.py

@@ -29,6 +29,7 @@ from rasa.core.channels.voice_stream.voice_channel import (
     VoiceInputChannel,
     VoiceOutputChannel,
 )
+from rasa.shared.exceptions import InvalidConfigException
 
 """
 Genesys throws a rate limit error with too many audio messages.
@@ -91,30 +92,48 @@ class GenesysInputChannel(VoiceInputChannel):
         return "genesys"
 
     def __init__(
-        self, api_key: Text, client_secret: Optional[Text], *args: Any, **kwargs: Any
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        api_key: Optional[Text] = None,
+        client_secret: Optional[Text] = None,
     ) -> None:
-        super().__init__(*args, **kwargs)
+        super().__init__(server_url, asr_config, tts_config)
         self.api_key = api_key
         self.client_secret = client_secret
 
     @classmethod
     def from_credentials(
-        cls, credentials: Optional[Dict[str, Any]]
-    ) -> VoiceInputChannel:
-        if not credentials:
-            raise ValueError("No credentials given for Genesys voice channel.")
-
-        if not credentials.get("api_key"):
-            raise ValueError("No API key given for Genesys voice channel (api_key).")
-
-        return cls(
-            api_key=credentials["api_key"],
-            client_secret=credentials.get("client_secret"),
-            server_url=credentials["server_url"],
-            asr_config=credentials["asr"],
-            tts_config=credentials["tts"],
-            monitor_silence=credentials.get("monitor_silence", False),
-        )
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> "GenesysInputChannel":
+        """Create a channel from credentials dictionary.
+
+        Args:
+            credentials: Dictionary containing the required credentials:
+                - server_url: URL where the server is hosted
+                - asr: ASR engine configuration
+                - tts: TTS engine configuration
+                - api_key: Required API key for Genesys authentication
+                - client_secret: Optional client secret for signature verification
+
+        Returns:
+            GenesysInputChannel instance
+        """
+        channel = super().from_credentials(credentials)
+
+        # Check required Genesys-specific credentials
+        if not credentials.get("api_key"):  # type: ignore[union-attr]
+            raise InvalidConfigException(
+                "No API key given for Genesys voice channel (api_key)."
+            )
+
+        # Update channel with Genesys-specific credentials
+        channel.api_key = credentials["api_key"]  # type: ignore[index,attr-defined]
+        channel.client_secret = credentials.get("client_secret")  # type: ignore[union-attr,attr-defined]
+
+        return channel  # type: ignore[return-value]
 
     def _ensure_channel_data_initialized(self) -> None:
         """Initialize Genesys-specific channel data if not already present.

rasa/core/channels/voice_stream/jambonz.py

@@ -0,0 +1,232 @@
+import audioop
+import json
+import uuid
+from typing import Any, Awaitable, Callable, Dict, Optional, Text, Tuple
+
+import structlog
+from sanic import (  # type: ignore[attr-defined]
+    Blueprint,
+    HTTPResponse,
+    Request,
+    Websocket,
+    response,
+)
+
+from rasa.core.channels import UserMessage, requires_basic_auth
+from rasa.core.channels.voice_ready.utils import (
+    CallParameters,
+    validate_username_password_credentials,
+)
+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()
+
+JAMBONZ_STREAMS_WEBSOCKET_PATH = "webhooks/jambonz_streams/websocket"
+
+
+def map_call_params(data: Dict[Text, str]) -> CallParameters:
+    """Map the twilio stream parameters to the CallParameters dataclass."""
+    call_sid = data.get("callSid", "None")
+    from_number = data.get("from", "Unknown")
+    to_number = data.get("to")
+    return CallParameters(
+        call_id=call_sid,
+        user_phone=from_number,
+        bot_phone=to_number,
+        stream_id=call_sid,
+    )
+
+
+class JambonzStreamOutputChannel(VoiceOutputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "jambonz_stream"
+
+    async def send_audio_bytes(
+        self, recipient_id: str, audio_bytes: RasaAudioBytes
+    ) -> None:
+        """Overridden to send binary websocket messages for Jambonz.
+
+        Converts 8kHz μ-law to 8kHz L16 PCM for Jambonz streaming.
+        """
+        pcm = audioop.ulaw2lin(audio_bytes, 2)
+        await self.voice_websocket.send(pcm)
+
+    def create_marker_message(self, recipient_id: str) -> Tuple[str, str]:
+        """Create a marker message to track audio stream position."""
+        marker_id = uuid.uuid4().hex
+        return json.dumps({"type": "mark", "data": {"name": marker_id}}), marker_id
+
+
+class JambonzStreamInputChannel(VoiceInputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "jambonz_stream"
+
+    def __init__(
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        username: Optional[Text] = None,
+        password: Optional[Text] = None,
+    ) -> None:
+        """Initialize the channel.
+
+        Args:
+            username: Optional username for basic auth
+            password: Optional password for basic auth
+        """
+        super().__init__(server_url, asr_config, tts_config)
+        self.username = username
+        self.password = password
+
+    @classmethod
+    def from_credentials(
+        cls, credentials: Optional[Dict[Text, Any]]
+    ) -> "JambonzStreamInputChannel":
+        """Create a channel from credentials dictionary.
+
+        Args:
+            credentials: Dictionary containing the required credentials:
+                - server_url: URL where the server is hosted
+                - asr: ASR engine configuration
+                - tts: TTS engine configuration
+                - username: Optional username for basic auth
+                - password: Optional password for basic auth
+
+        Returns:
+            JambonzStreamInputChannel instance
+        """
+        # Get common credentials from parent
+        channel = super().from_credentials(credentials)
+
+        # Check optional basic auth credentials
+        username = credentials.get("username")  # type: ignore[union-attr]
+        password = credentials.get("password")  # type: ignore[union-attr]
+        validate_username_password_credentials(username, password, "Jambonz Stream")
+
+        # Update channel with auth credentials
+        channel.username = username  # type: ignore[attr-defined]
+        channel.password = password  # type: ignore[attr-defined]
+
+        return channel  # type: ignore[return-value]
+
+    def _websocket_stream_url(self) -> str:
+        """Returns the websocket stream URL."""
+        # depending on the config value, the url might contain http as a
+        # protocol or not - we'll make sure both work
+        if self.server_url.startswith("http"):
+            base_url = self.server_url.replace("http", "ws")
+        else:
+            base_url = f"wss://{self.server_url}"
+        return f"{base_url}/{JAMBONZ_STREAMS_WEBSOCKET_PATH}"
+
+    def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
+        """Convert Jambonz audio bytes (L16 PCM) to Rasa audio bytes (μ-law)."""
+        ulaw = audioop.lin2ulaw(input_bytes, 2)
+        return RasaAudioBytes(ulaw)
+
+    async def collect_call_parameters(
+        self, channel_websocket: Websocket
+    ) -> Optional[CallParameters]:
+        # Wait for initial metadata message
+        message = await channel_websocket.recv()
+        logger.debug("jambonz.collect_call_parameters", message=message)
+        metadata = json.loads(message)
+        return map_call_params(metadata)
+
+    def map_input_message(self, message: Any, ws: Websocket) -> VoiceChannelAction:
+        # Handle binary audio frames
+        if isinstance(message, bytes):
+            channel_bytes = message
+            audio_bytes = self.channel_bytes_to_rasa_audio_bytes(channel_bytes)
+            return NewAudioAction(audio_bytes)
+
+        # Handle JSON messages
+        data = json.loads(message)
+        if data["type"] == "mark":
+            if data["data"]["name"] == 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(
+                        "jambonz.hangup", marker=call_state.latest_bot_audio_id
+                    )
+                    return EndConversationAction()
+            else:
+                call_state.is_bot_speaking = True  # type: ignore[attr-defined]
+        elif data["event"] == "dtmf":
+            # TODO: handle DTMF input
+            logger.debug("jambonz.dtmf.received", dtmf=data["dtmf"])
+        else:
+            logger.warning("jambonz.unexpected_message", message=data)
+
+        return ContinueConversationAction()
+
+    def create_output_channel(
+        self, voice_websocket: Websocket, tts_engine: TTSEngine
+    ) -> VoiceOutputChannel:
+        return JambonzStreamOutputChannel(
+            voice_websocket,
+            tts_engine,
+            self.tts_cache,
+        )
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> Blueprint:
+        blueprint = Blueprint("jambonz_stream", __name__)
+
+        @blueprint.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @blueprint.route("/call_status", methods=["POST"])
+        @requires_basic_auth(self.username, self.password)
+        async def call_status(request: Request) -> HTTPResponse:
+            """Handle call status updates from Jambonz."""
+            data = request.json
+            logger.debug("jambonz.call_status.received", data=data)
+            return response.json({"status": "ok"})
+
+        @blueprint.route("/webhook", methods=["POST"])
+        @requires_basic_auth(self.username, self.password)
+        async def webhook(request: Request) -> HTTPResponse:
+            """Handle incoming webhook requests from Jambonz."""
+            data = request.json
+            logger.debug("jambonz.webhook.received", data=data)
+            return response.json(
+                [
+                    {
+                        "verb": "listen",
+                        "url": self._websocket_stream_url(),
+                        "sampleRate": 8000,
+                        "passDtmf": True,
+                        "bidirectionalAudio": {
+                            "enabled": True,
+                            "streaming": True,
+                            "sampleRate": 8000,
+                        },
+                    }
+                ]
+            )
+
+        @blueprint.websocket("/websocket", subprotocols=["audio.jambonz.org"])  # type: ignore[misc]
+        async def handle_message(request: Request, ws: Websocket) -> None:
+            try:
+                await self.run_audio_streaming(on_new_message, ws)
+            except Exception as e:
+                logger.error("jambonz.handle_message.error", error=e)
+
+        return blueprint

rasa/core/channels/voice_stream/tts/__init__.py

@@ -0,0 +1,8 @@
+from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
+from rasa.core.channels.voice_stream.tts.tts_engine import (
+    TTSEngine,
+    TTSEngineConfig,
+    TTSError,
+)
+
+__all__ = ["TTSEngine", "TTSEngineConfig", "TTSError", "TTSCache"]

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -14,12 +14,15 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
-from rasa.core.channels import InputChannel, UserMessage
+from rasa.core.channels import UserMessage
 from rasa.core.channels.channel import (
     create_auth_requested_response_provider,
     requires_basic_auth,
 )
-from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.core.channels.voice_ready.utils import (
+    CallParameters,
+    validate_username_password_credentials,
+)
 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
@@ -31,7 +34,6 @@ from rasa.core.channels.voice_stream.voice_channel import (
     VoiceInputChannel,
     VoiceOutputChannel,
 )
-from rasa.shared.exceptions import RasaException
 
 if TYPE_CHECKING:
     from twilio.twiml.voice_response import VoiceResponse
@@ -102,31 +104,32 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
         username: Optional[Text] = None,
         password: Optional[Text] = None,
     ):
-        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        super().__init__(
+            server_url=server_url,
+            asr_config=asr_config,
+            tts_config=tts_config,
+        )
         self.username = username
         self.password = password
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+    def from_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> VoiceInputChannel:
         credentials = credentials or {}
 
         username = credentials.get("username")
         password = credentials.get("password")
-        if (username is None) != (password is None):
-            raise RasaException(
-                "In TwilioMediaStreams channel, either both username and password "
-                "or neither should be provided. "
-            )
+        validate_username_password_credentials(username, password, "TwilioMediaStreams")
 
         return cls(
             credentials["server_url"],
             credentials["asr"],
             credentials["tts"],
-            credentials.get("monitor_silence", False),
             username=username,
             password=password,
         )

rasa/core/channels/voice_stream/voice_channel.py

@@ -31,9 +31,11 @@ from rasa.core.channels.voice_stream.tts.azure import AzureTTS
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
-from rasa.core.channels.voice_stream.util import generate_silence
-from rasa.shared.core.constants import SLOT_SILENCE_TIMEOUT
-from rasa.shared.utils.cli import print_error_and_exit
+from rasa.core.channels.voice_stream.util import (
+    generate_silence,
+)
+from rasa.shared.core.constants import SILENCE_TIMEOUT_SLOT
+from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.utils.common import (
     class_from_module_path,
     mark_as_beta_feature,
@@ -42,6 +44,11 @@ from rasa.utils.io import remove_emojis
 
 logger = structlog.get_logger(__name__)
 
+# define constants for the voice channel
+USER_CONVERSATION_SESSION_END = "/session_end"
+USER_CONVERSATION_SESSION_START = "/session_start"
+USER_CONVERSATION_SILENCE_TIMEOUT = "/silence_timeout"
+
 
 @dataclass
 class VoiceChannelAction:
@@ -64,6 +71,14 @@ class ContinueConversationAction(VoiceChannelAction):
 
 
 def asr_engine_from_config(asr_config: Dict) -> ASREngine:
+    if not asr_config:
+        raise ValueError("ASR configuration dictionary cannot be empty")
+
+    if "name" not in asr_config:
+        raise ValueError(
+            "ASR configuration must contain 'name' key specifying the engine type"
+        )
+
     name = str(asr_config["name"])
     asr_config = copy.copy(asr_config)
     asr_config.pop("name")
@@ -77,12 +92,12 @@ def asr_engine_from_config(asr_config: Dict) -> ASREngine:
             asr_engine_class = class_from_module_path(name)
             return asr_engine_class.from_config_dict(asr_config)
         except NameError:
-            print_error_and_exit(
+            raise InvalidConfigException(
                 f"Failed to initialize ASR Engine with type '{name}'. "
                 f"Please make sure the method `from_config_dict`is implemented."
             )
         except TypeError as e:
-            print_error_and_exit(
+            raise InvalidConfigException(
                 f"Failed to initialize ASR Engine with type '{name}'. "
                 f"Invalid configuration provided. "
                 f"Error: {e}"
@@ -90,6 +105,14 @@ def asr_engine_from_config(asr_config: Dict) -> ASREngine:
 
 
 def tts_engine_from_config(tts_config: Dict) -> TTSEngine:
+    if not tts_config:
+        raise ValueError("TTS configuration dictionary cannot be empty")
+
+    if "name" not in tts_config:
+        raise ValueError(
+            "TTS configuration must contain 'name' key specifying the engine type"
+        )
+
     name = str(tts_config["name"])
     tts_config = copy.copy(tts_config)
     tts_config.pop("name")
@@ -103,13 +126,13 @@ def tts_engine_from_config(tts_config: Dict) -> TTSEngine:
             tts_engine_class = class_from_module_path(name)
             return tts_engine_class.from_config_dict(tts_config)
         except NameError:
-            print_error_and_exit(
+            raise InvalidConfigException(
                 f"Failed to initialize TTS Engine with type '{name}'. "
                 f"Please make sure the method `from_config_dict`is implemented."
             )
         except TypeError as e:
-            print_error_and_exit(
-                f"Failed to initialize ASR Engine with type '{name}'. "
+            raise InvalidConfigException(
+                f"Failed to initialize TTS Engine with type '{name}'. "
                 f"Invalid configuration provided. "
                 f"Error: {e}"
             )
@@ -166,8 +189,12 @@ class VoiceOutputChannel(OutputChannel):
     def update_silence_timeout(self) -> None:
         """Updates the silence timeout for the session."""
         if self.tracker_state:
-            call_state.silence_timeout = (  # type: ignore[attr-defined]
-                self.tracker_state["slots"][SLOT_SILENCE_TIMEOUT]
+            call_state.silence_timeout = self.tracker_state["slots"][  # type: ignore[attr-defined]
+                SILENCE_TIMEOUT_SLOT
+            ]
+            logger.debug(
+                "voice_channel.silence_timeout_updated",
+                silence_timeout=call_state.silence_timeout,
             )
 
     async def send_text_with_buttons(
@@ -189,6 +216,7 @@ class VoiceOutputChannel(OutputChannel):
         collected_audio_bytes = RasaAudioBytes(b"")
         seconds_marker = -1
         last_sent_offset = 0
+        logger.debug("voice_channel.sending_audio", text=text)
 
         # Send start marker before first chunk
         try:
@@ -274,18 +302,21 @@ class VoiceOutputChannel(OutputChannel):
 
 
 class VoiceInputChannel(InputChannel):
+    # All children of this class require a voice license to be used.
+    requires_voice_license = True
+
     def __init__(
         self,
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
     ):
-        validate_voice_license_scope()
+        if self.requires_voice_license:
+            validate_voice_license_scope()
+
         self.server_url = server_url
         self.asr_config = asr_config
         self.tts_config = tts_config
-        self.monitor_silence = monitor_silence
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
 
         logger.info(
@@ -303,8 +334,6 @@ class VoiceInputChannel(InputChannel):
         timeout = call_state.silence_timeout
         if not timeout:
             return
-        if not self.monitor_silence:
-            return
         logger.debug("voice_channel.silence_timeout_watch_started", timeout=timeout)
         await asyncio.sleep(timeout)
         await asr_event_queue.put(UserSilence())
@@ -319,13 +348,28 @@ class VoiceInputChannel(InputChannel):
             call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
-        credentials = credentials or {}
+    def from_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> InputChannel:
+        if not credentials:
+            cls.raise_missing_credentials_exception()
+
+        if not credentials.get("server_url"):
+            raise InvalidConfigException("No server_url provided in credentials.")
+        if not credentials.get("asr"):
+            raise InvalidConfigException(
+                "No ASR configuration provided in credentials."
+            )
+        if not credentials.get("tts"):
+            raise InvalidConfigException(
+                "No TTS configuration provided in credentials."
+            )
+
         return cls(
-            credentials["server_url"],
-            credentials["asr"],
-            credentials["tts"],
-            credentials.get("monitor_silence", False),
+            server_url=credentials["server_url"],
+            asr_config=credentials["asr"],
+            tts_config=credentials["tts"],
         )
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
@@ -345,7 +389,7 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         output_channel = self.create_output_channel(channel_websocket, tts_engine)
         message = UserMessage(
-            text="/session_start",
+            text=USER_CONVERSATION_SESSION_START,
             output_channel=output_channel,
             sender_id=self.get_sender_id(call_parameters),
             input_channel=self.name(),
@@ -382,17 +426,17 @@ class VoiceInputChannel(InputChannel):
 
         async def consume_audio_bytes() -> None:
             async for message in channel_websocket:
-                is_bot_speaking_before = call_state.is_bot_speaking
+                was_bot_speaking_before = call_state.is_bot_speaking
                 channel_action = self.map_input_message(message, channel_websocket)
                 is_bot_speaking_after = call_state.is_bot_speaking
 
-                if not is_bot_speaking_before and is_bot_speaking_after:
+                if not was_bot_speaking_before and is_bot_speaking_after:
                     logger.debug("voice_channel.bot_started_speaking")
                     # relevant when the bot speaks multiple messages in one turn
                     self._cancel_silence_timeout_watcher()
 
                 # we just stopped speaking, starting a watcher for silence timeout
-                if is_bot_speaking_before and not is_bot_speaking_after:
+                if was_bot_speaking_before and not is_bot_speaking_after:
                     logger.debug("voice_channel.bot_stopped_speaking")
                     self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
@@ -476,7 +520,7 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserSilence):
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                text="/silence_timeout",
+                text=USER_CONVERSATION_SILENCE_TIMEOUT,
                 output_channel=output_channel,
                 sender_id=self.get_sender_id(call_parameters),
                 input_channel=self.name(),
@@ -494,7 +538,7 @@ class VoiceInputChannel(InputChannel):
         """Handle disconnection from the channel."""
         output_channel = self.create_output_channel(channel_websocket, tts_engine)
         message = UserMessage(
-            text="/session_end",
+            text=USER_CONVERSATION_SESSION_END,
             output_channel=output_channel,
             sender_id=self.get_sender_id(call_parameters),
             input_channel=self.name(),