rasa-pro 3.13.1a18__py3-none-any.whl → 3.13.1a20__py3-none-any.whl

rasa/core/channels/studio_chat.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 import asyncio
 import audioop
 import base64
 import json
+import time
 import uuid
 from functools import partial
 from typing import (
@@ -14,6 +17,7 @@ from typing import (
     Optional,
     Text,
     Tuple,
+    Union,
 )
 
 import structlog
@@ -32,6 +36,7 @@ from rasa.core.channels.voice_stream.voice_channel import (
     VoiceInputChannel,
     VoiceOutputChannel,
 )
+from rasa.core.exceptions import AgentNotReady
 from rasa.hooks import hookimpl
 from rasa.plugin import plugin_manager
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
@@ -49,7 +54,9 @@ if TYPE_CHECKING:
 structlogger = structlog.get_logger()
 
 
-def tracker_as_dump(tracker: "DialogueStateTracker") -> Dict[str, Any]:
+def tracker_as_dump(
+    tracker: "DialogueStateTracker", latency: Optional[float] = None
+) -> Dict[str, Any]:
     """Create a dump of the tracker state."""
     from rasa.shared.core.trackers import get_trackers_for_conversation_sessions
 
@@ -62,7 +69,12 @@ def tracker_as_dump(tracker: "DialogueStateTracker") -> Dict[str, Any]:
 
     # TODO: this is a bug: the bridge converts this back to json, but it
     # should be json in the first place
-    return last_tracker.current_state(EventVerbosity.AFTER_RESTART)
+    state = last_tracker.current_state(EventVerbosity.AFTER_RESTART)
+
+    if latency is not None:
+        state["latency"] = {"rasa_processing_latency_ms": latency}
+
+    return state
 
 
 def does_need_action_prediction(tracker: "DialogueStateTracker") -> bool:
@@ -149,7 +161,6 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         from rasa.core.agent import Agent
 
         self.agent: Optional[Agent] = None
-        self.latest_tracker_session_id = None
 
         # Initialize the SocketIO input channel
         SocketIOInput.__init__(
@@ -177,6 +188,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         # `background_tasks` holds the asyncio tasks for voice streaming
         self.active_connections: Dict[str, SocketIOVoiceWebsocketAdapter] = {}
         self.background_tasks: Dict[str, asyncio.Task] = {}
+        self._turn_start_times: Dict[Text, float] = {}
 
         self._register_tracker_update_hook()
 
@@ -203,24 +215,41 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             metadata_key=credentials.get("metadata_key", "metadata"),
         )
 
+    async def emit(self, event: str, data: Union[Dict, str], room: str) -> None:
+        """Emits an event to the websocket."""
+        if not self.sio:
+            structlogger.error("studio_chat.emit.sio_not_initialized")
+            return
+        await self.sio.emit(event, data, room=room)
+
     def _register_tracker_update_hook(self) -> None:
         plugin_manager().register(StudioTrackerUpdatePlugin(self))
 
-    async def on_tracker_updated(self, tracker: "DialogueStateTracker") -> None:
+    async def on_tracker_updated(
+        self, tracker: "DialogueStateTracker", latency: Optional[float] = None
+    ) -> None:
         """Triggers a tracker update notification after a change to the tracker."""
-        await self.publish_tracker_update(tracker.sender_id, tracker_as_dump(tracker))
+        await self.publish_tracker_update(
+            tracker.sender_id, tracker_as_dump(tracker, latency)
+        )
 
-    async def publish_tracker_update(self, sender_id: str, tracker_dump: Dict) -> None:
+    async def publish_tracker_update(self, sender_id: str, tracker_dump: str) -> None:
         """Publishes a tracker update notification to the websocket."""
-        if not self.sio:
-            structlogger.error("studio_chat.on_tracker_updated.sio_not_initialized")
-            return
+        await self.emit("tracker", tracker_dump, room=sender_id)
 
-        # we need the latest session id to use it for the llm helper to get the
-        # most recent conversation the user had with the bot.
-        self.latest_tracker_session_id = 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
 
-        await self.sio.emit("tracker", tracker_dump, room=sender_id)
+        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,
@@ -231,6 +260,7 @@ 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:
@@ -240,8 +270,15 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
                 sender_id=message.sender_id,
             )
 
-        if not self.agent:
+        if not self.agent or not self.agent.is_ready():
             structlogger.error("studio_chat.on_message_proxy.agent_not_initialized")
+            await self.emit_error(
+                "The Rasa Pro model could not be loaded. "
+                "Please check the training and deployment logs "
+                "for more information.",
+                message.sender_id,
+                AgentNotReady("The Rasa Pro model could not be loaded."),
+            )
             return
 
         tracker = await self.agent.tracker_store.retrieve(message.sender_id)
@@ -249,7 +286,19 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             structlogger.error("studio_chat.on_message_proxy.tracker_not_found")
             return
 
-        await self.on_tracker_updated(tracker)
+        latency = self._get_latency(message.sender_id)
+        await self.on_tracker_updated(tracker, latency)
+
+    async def emit_error(self, message: str, room: str, e: Exception) -> None:
+        await self.emit(
+            "error",
+            {
+                "message": message,
+                "error": str(e),
+                "exception": str(type(e).__name__),
+            },
+            room=room,
+        )
 
     async def handle_tracker_update(self, sid: str, data: Dict) -> None:
         from rasa.shared.core.trackers import DialogueStateTracker
@@ -267,21 +316,41 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             structlogger.error("studio_chat.sio.domain_not_initialized")
             return None
 
+        tracker: Optional[DialogueStateTracker] = None
+
         async with self.agent.lock_store.lock(data["sender_id"]):
-            tracker = DialogueStateTracker.from_dict(
-                data["sender_id"], data["events"], domain.slots
-            )
+            try:
+                tracker = DialogueStateTracker.from_dict(
+                    data["sender_id"], data["events"], domain.slots
+                )
 
-            # will override an existing tracker with the same id!
-            await self.agent.tracker_store.save(tracker)
+                # will override an existing tracker with the same id!
+                await self.agent.tracker_store.save(tracker)
 
-            processor = self.agent.processor
-            if processor and does_need_action_prediction(tracker):
-                output_channel = self.get_output_channel()
+                processor = self.agent.processor
+                if processor and does_need_action_prediction(tracker):
+                    output_channel = self.get_output_channel()
 
-                await processor._run_prediction_loop(output_channel, tracker)
-                await self.agent.tracker_store.save(tracker)
+                    await processor._run_prediction_loop(output_channel, tracker)
+                    await self.agent.tracker_store.save(tracker)
+            except Exception as e:
+                structlogger.error(
+                    "studio_chat.sio.handle_tracker_update.error",
+                    error=e,
+                    sender_id=data["sender_id"],
+                )
+                await self.emit_error(
+                    "An error occurred while updating the conversation.",
+                    data["sender_id"],
+                    e,
+                )
 
+        if not tracker:
+            # in case the tracker couldn't be updated, we retrieve the prior
+            # version and use that to populate the update
+            tracker = await self.agent.tracker_store.get_or_create_tracker(
+                data["sender_id"]
+            )
         await self.on_tracker_updated(tracker)
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
@@ -308,14 +377,14 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         elif "marker" in message:
             if message["marker"] == call_state.latest_bot_audio_id:
                 # Just finished streaming last audio bytes
-                call_state.is_bot_speaking = False  # type: ignore[attr-defined]
+                call_state.is_bot_speaking = False
                 if call_state.should_hangup:
                     structlogger.debug(
                         "studio_chat.hangup", marker=call_state.latest_bot_audio_id
                     )
                     return EndConversationAction()
             else:
-                call_state.is_bot_speaking = True  # type: ignore[attr-defined]
+                call_state.is_bot_speaking = True
         return ContinueConversationAction()
 
     def create_output_channel(
@@ -398,9 +467,8 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
     def blueprint(
         self, on_new_message: Callable[["UserMessage"], Awaitable[Any]]
     ) -> SocketBlueprint:
-        socket_blueprint = super().blueprint(
-            partial(self.on_message_proxy, on_new_message)
-        )
+        proxied_on_message = partial(self.on_message_proxy, on_new_message)
+        socket_blueprint = super().blueprint(proxied_on_message)
 
         if not self.sio:
             structlogger.error("studio_chat.blueprint.sio_not_initialized")
@@ -435,7 +503,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, on_new_message)
+                self._start_voice_session(data["session_id"], sid, proxied_on_message)
 
         @self.sio.on(self.user_message_evt, namespace=self.namespace)
         async def handle_message(sid: Text, data: Dict) -> None:
@@ -450,14 +518,14 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
             try:
                 # Handle text messages
-                await self.handle_user_message(sid, data, on_new_message)
+                await self.handle_user_message(sid, data, proxied_on_message)
             except Exception as e:
                 structlogger.exception(
                     "studio_chat.sio.handle_message.error",
                     error=str(e),
                     sid=sid,
                 )
-                await self.sio.emit("error", str(e), room=sid)
+                await self.emit("error", str(e), room=sid)
 
         @self.sio.on("update_tracker", namespace=self.namespace)
         async def on_update_tracker(sid: Text, data: Dict) -> None:
@@ -481,7 +549,24 @@ class StudioVoiceOutputChannel(VoiceOutputChannel):
 
     def create_marker_message(self, recipient_id: str) -> Tuple[str, str]:
         message_id = uuid.uuid4().hex
-        return json.dumps({"marker": message_id}), message_id
+        marker_data = {"marker": message_id}
+
+        # Include comprehensive latency information if available
+        latency_data = {
+            "asr_latency_ms": call_state.asr_latency_ms,
+            "rasa_processing_latency_ms": call_state.rasa_processing_latency_ms,
+            "tts_first_byte_latency_ms": call_state.tts_first_byte_latency_ms,
+            "tts_complete_latency_ms": call_state.tts_complete_latency_ms,
+        }
+
+        # Filter out None values from latency data
+        latency_data = {k: v for k, v in latency_data.items() if v is not None}
+
+        # Add latency data to marker if any metrics are available
+        if latency_data:
+            marker_data["latency"] = latency_data  # type: ignore[assignment]
+
+        return json.dumps(marker_data), message_id
 
 
 class SocketIOVoiceWebsocketAdapter:

rasa/core/channels/voice_ready/twilio_voice.py

@@ -30,7 +30,7 @@ TWILIO_VOICE_PATH = "webhooks/twilio_voice/webhook"
 
 
 def map_call_params(form: RequestParameters) -> CallParameters:
-    """Map the Audiocodes parameters to the CallParameters dataclass."""
+    """Map the Twilio Voice parameters to the CallParameters dataclass."""
     return CallParameters(
         call_id=form.get("CallSid"),
         user_phone=form.get("Caller"),

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

@@ -26,7 +26,7 @@ logger = structlog.get_logger(__name__)
 
 @dataclass
 class ASREngineConfig(MergeableConfig):
-    pass
+    keep_alive_interval: int = 5  # seconds
 
 
 class ASREngine(Generic[T]):
@@ -93,3 +93,7 @@ class ASREngine(Generic[T]):
     def get_default_config() -> T:
         """Get the default config for this component."""
         raise NotImplementedError
+
+    async def send_keep_alive(self) -> None:
+        """Send a keep-alive message to the ASR system if supported."""
+        pass

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

@@ -145,3 +145,8 @@ class DeepgramASR(ASREngine[DeepgramASRConfig]):
     def concatenate_transcripts(t1: str, t2: str) -> str:
         """Concatenate two transcripts making sure there is a space between them."""
         return (t1.strip() + " " + t2.strip()).strip()
+
+    async def send_keep_alive(self) -> None:
+        """Send a keep-alive message to the Deepgram websocket connection."""
+        if self.asr_socket is not None:
+            await self.asr_socket.send(json.dumps({"type": "KeepAlive"}))

rasa/core/channels/voice_stream/audiocodes.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import base64
 import hmac
@@ -21,6 +23,7 @@ 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.util import repack_voice_credentials
 from rasa.core.channels.voice_stream.voice_channel import (
     ContinueConversationAction,
     EndConversationAction,
@@ -81,6 +84,12 @@ class AudiocodesVoiceOutputChannel(VoiceOutputChannel):
         logger.debug("Sending start marker", stream_id=self._get_stream_id())
         await self.voice_websocket.send(media_message)
 
+        # This should be set when the bot actually starts speaking
+        # however, Audiocodes does not have an event to indicate that.
+        # 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
+
     async def send_intermediate_marker(self, recipient_id: str) -> None:
         """Audiocodes doesn't need intermediate markers, so do nothing."""
         pass
@@ -121,10 +130,10 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
     def from_credentials(
         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]
+    ) -> AudiocodesVoiceInputChannel:
+        cls.validate_basic_credentials(credentials)
+        new_creds = repack_voice_credentials(credentials)
+        return cls(**new_creds)
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         return RasaAudioBytes(base64.b64decode(input_bytes))
@@ -170,21 +179,20 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
         if data["type"] == "activities":
             activities = data["activities"]
             for activity in activities:
-                logger.debug("audiocodes_stream.activity", data=activity)
                 if activity["name"] == "start":
-                    # already handled in collect_call_parameters
+                    # handled in collect_call_parameters
                     pass
                 elif activity["name"] == "dtmf":
-                    # TODO: handle DTMF input
+                    logger.info("audiocodes_stream.dtmf_ignored", data=activity)
                     pass
                 elif activity["name"] == "playFinished":
                     logger.debug("audiocodes_stream.playFinished", data=activity)
+                    call_state.is_bot_speaking = False
                     if call_state.should_hangup:
                         logger.info("audiocodes_stream.hangup")
                         self._send_hangup(ws, data)
                         # the conversation should continue until
                         # we receive a end message from audiocodes
-                    pass
                 else:
                     logger.warning("audiocodes_stream.unknown_activity", data=activity)
         elif data["type"] == "userStream.start":

rasa/core/channels/voice_stream/browser_audio.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import audioop
 import base64
 import json
 import uuid
-from typing import Any, Awaitable, Callable, Optional, Tuple
+from typing import Any, Awaitable, Callable, Dict, Optional, Tuple
 
 import structlog
 from sanic import (  # type: ignore[attr-defined]
@@ -18,6 +20,7 @@ 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.util import repack_voice_credentials
 from rasa.core.channels.voice_stream.voice_channel import (
     ContinueConversationAction,
     EndConversationAction,
@@ -45,10 +48,33 @@ class BrowserAudioOutputChannel(VoiceOutputChannel):
 
     def create_marker_message(self, recipient_id: str) -> Tuple[str, str]:
         message_id = uuid.uuid4().hex
-        return json.dumps({"marker": message_id}), message_id
+        marker_data = {"marker": message_id}
+
+        # Include comprehensive latency information if available
+        latency_data = {
+            "asr_latency_ms": call_state.asr_latency_ms,
+            "rasa_processing_latency_ms": call_state.rasa_processing_latency_ms,
+            "tts_first_byte_latency_ms": call_state.tts_first_byte_latency_ms,
+            "tts_complete_latency_ms": call_state.tts_complete_latency_ms,
+        }
+
+        # Filter out None values from latency data
+        latency_data = {k: v for k, v in latency_data.items() if v is not None}
+
+        # Add latency data to marker if any metrics are available
+        if latency_data:
+            marker_data["latency"] = latency_data  # type: ignore[assignment]
+
+        return json.dumps(marker_data), message_id
 
 
 class BrowserAudioInputChannel(VoiceInputChannel):
+    def __init__(
+        self, server_url: str, asr_config: Dict[str, Any], tts_config: Dict[str, Any]
+    ) -> None:
+        """Initializes the browser audio input channel."""
+        super().__init__(server_url, asr_config, tts_config)
+
     @classmethod
     def name(cls) -> str:
         return "browser_audio"
@@ -62,6 +88,15 @@ class BrowserAudioInputChannel(VoiceInputChannel):
         call_id = f"inspect-{uuid.uuid4()}"
         return CallParameters(call_id, "local", "local", stream_id=call_id)
 
+    @classmethod
+    def from_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> BrowserAudioInputChannel:
+        cls.validate_basic_credentials(credentials)
+        new_creds = repack_voice_credentials(credentials)
+        return cls(**new_creds)
+
     def map_input_message(
         self,
         message: Any,
@@ -75,14 +110,14 @@ class BrowserAudioInputChannel(VoiceInputChannel):
         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]
+                call_state.is_bot_speaking = False
                 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]
+                call_state.is_bot_speaking = True
         return ContinueConversationAction()
 
     def create_output_channel(

rasa/core/channels/voice_stream/call_state.py

@@ -1,7 +1,7 @@
 import asyncio
 from contextvars import ContextVar
 from dataclasses import dataclass, field
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, cast
 
 from werkzeug.local import LocalProxy
 
@@ -19,9 +19,20 @@ class CallState:
     should_hangup: bool = False
     connection_failed: bool = False
 
+    # Latency tracking - start times only
+    user_speech_start_time: Optional[float] = None
+    rasa_processing_start_time: Optional[float] = None
+    tts_start_time: Optional[float] = None
+
+    # Calculated latencies (used by channels like browser_audio)
+    asr_latency_ms: Optional[float] = None
+    rasa_processing_latency_ms: Optional[float] = None
+    tts_first_byte_latency_ms: Optional[float] = None
+    tts_complete_latency_ms: Optional[float] = None
+
     # Generic field for channel-specific state data
     channel_data: Dict[str, Any] = field(default_factory=dict)
 
 
 _call_state: ContextVar[CallState] = ContextVar("call_state")
-call_state = LocalProxy(_call_state)
+call_state: CallState = cast(CallState, LocalProxy(_call_state))

rasa/core/channels/voice_stream/genesys.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import base64
 import hashlib
@@ -21,6 +23,7 @@ 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.util import repack_voice_credentials
 from rasa.core.channels.voice_stream.voice_channel import (
     ContinueConversationAction,
     EndConversationAction,
@@ -54,7 +57,7 @@ logger = structlog.get_logger(__name__)
 
 
 def map_call_params(data: Dict[Text, Any]) -> CallParameters:
-    """Map the twilio stream parameters to the CallParameters dataclass."""
+    """Map the Genesys parameters to the CallParameters dataclass."""
     parameters = data["parameters"]
     participant = parameters["participant"]
     # sent as {"ani": "tel:+491604697810"}
@@ -107,7 +110,7 @@ class GenesysInputChannel(VoiceInputChannel):
     def from_credentials(
         cls,
         credentials: Optional[Dict[str, Any]],
-    ) -> "GenesysInputChannel":
+    ) -> GenesysInputChannel:
         """Create a channel from credentials dictionary.
 
         Args:
@@ -121,21 +124,21 @@ class GenesysInputChannel(VoiceInputChannel):
         Returns:
             GenesysInputChannel instance
         """
-        channel = super().from_credentials(credentials)
+        cls.validate_credentials(credentials)
+        new_creds = repack_voice_credentials(credentials)
+        return cls(**new_creds)
 
-        # Check required Genesys-specific credentials
+    @classmethod
+    def validate_credentials(cls, credentials: Optional[Dict[str, Any]]) -> None:
+        """Validate the credentials for the Genesys voice channel."""
+        cls.validate_basic_credentials(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:
+    @staticmethod
+    def _ensure_channel_data_initialized() -> None:
         """Initialize Genesys-specific channel data if not already present.
 
         Genesys requires the server and client each maintain a
@@ -216,10 +219,10 @@ class GenesysInputChannel(VoiceInputChannel):
                 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]
+                call_state.is_bot_speaking = True
             elif msg_type == "playback_completed":
                 logger.debug("genesys.handle_playback_completed", message=data)
-                call_state.is_bot_speaking = False  # type: ignore[attr-defined]
+                call_state.is_bot_speaking = False
                 if call_state.should_hangup:
                     logger.info("genesys.hangup")
                     self.disconnect(ws, data)

rasa/core/channels/voice_stream/jambonz.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import audioop
 import json
 import uuid
@@ -20,6 +22,7 @@ from rasa.core.channels.voice_ready.utils import (
 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.util import repack_voice_credentials
 from rasa.core.channels.voice_stream.voice_channel import (
     ContinueConversationAction,
     EndConversationAction,
@@ -31,11 +34,11 @@ from rasa.core.channels.voice_stream.voice_channel import (
 
 logger = structlog.get_logger()
 
-JAMBONZ_STREAMS_WEBSOCKET_PATH = "webhooks/jambonz_streams/websocket"
+JAMBONZ_STREAMS_WEBSOCKET_PATH = "webhooks/jambonz_stream/websocket"
 
 
 def map_call_params(data: Dict[Text, str]) -> CallParameters:
-    """Map the twilio stream parameters to the CallParameters dataclass."""
+    """Map the Jambonz stream parameters to the CallParameters dataclass."""
     call_sid = data.get("callSid", "None")
     from_number = data.get("from", "Unknown")
     to_number = data.get("to")
@@ -94,7 +97,7 @@ class JambonzStreamInputChannel(VoiceInputChannel):
     @classmethod
     def from_credentials(
         cls, credentials: Optional[Dict[Text, Any]]
-    ) -> "JambonzStreamInputChannel":
+    ) -> JambonzStreamInputChannel:
         """Create a channel from credentials dictionary.
 
         Args:
@@ -109,19 +112,18 @@ class JambonzStreamInputChannel(VoiceInputChannel):
             JambonzStreamInputChannel instance
         """
         # Get common credentials from parent
-        channel = super().from_credentials(credentials)
+        cls.validate_credentials(credentials)
+        new_creds = repack_voice_credentials(credentials)
+        return cls(**new_creds)
 
+    @classmethod
+    def validate_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> None:
+        cls.validate_basic_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
@@ -158,14 +160,14 @@ class JambonzStreamInputChannel(VoiceInputChannel):
         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]
+                call_state.is_bot_speaking = False
                 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]
+                call_state.is_bot_speaking = True
         elif data["event"] == "dtmf":
             # TODO: handle DTMF input
             logger.debug("jambonz.dtmf.received", dtmf=data["dtmf"])