rasa-pro 3.13.7__py3-none-any.whl → 3.14.0.dev1__py3-none-any.whl

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

@@ -40,6 +40,15 @@ export interface Stack {
   collect?: string
   utter?: string
   ended: boolean
+  agent_id?: string
+  state?: "waiting_for_input" | "interrupted"
+}
+
+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 Tracker {
@@ -47,6 +56,7 @@ export interface Tracker {
   slots: { [key: string]: unknown }
   events: Event[]
   stack: Stack[]
+  latency?: LatencyData
 }
 
 export interface Flow {
@@ -87,4 +97,6 @@ interface Step {
   reset_after_flow_ends: boolean
   utter: string
   set_slots?: unknown
+  call?: string
+  noop?: boolean
 }

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 (
@@ -16,6 +19,7 @@ from typing import (
     Tuple,
 )
 
+import orjson
 import structlog
 
 from rasa.core.channels import UserMessage
@@ -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
@@ -42,14 +47,16 @@ if TYPE_CHECKING:
     from sanic import Sanic, Websocket  # type: ignore[attr-defined]
     from socketio import AsyncServer
 
-    from rasa.core.channels.channel import InputChannel, UserMessage
+    from rasa.core.channels.channel import UserMessage
     from rasa.shared.core.trackers import DialogueStateTracker
 
 
 structlogger = structlog.get_logger()
 
 
-def tracker_as_dump(tracker: "DialogueStateTracker") -> str:
+def tracker_as_dump(
+    tracker: "DialogueStateTracker", latency: Optional[float] = None
+) -> str:
     """Create a dump of the tracker state."""
     from rasa.shared.core.trackers import get_trackers_for_conversation_sessions
 
@@ -61,7 +68,10 @@ def tracker_as_dump(tracker: "DialogueStateTracker") -> str:
         last_tracker = multiple_tracker_sessions[-1]
 
     state = last_tracker.current_state(EventVerbosity.AFTER_RESTART)
-    return json.dumps(state)
+
+    if latency is not None:
+        state["latency"] = {"rasa_processing_latency_ms": latency}
+    return orjson.dumps(state, option=orjson.OPT_SERIALIZE_NUMPY).decode("utf-8")
 
 
 def does_need_action_prediction(tracker: "DialogueStateTracker") -> bool:
@@ -175,11 +185,14 @@ 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()
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> "InputChannel":
+    def from_credentials(
+        cls, credentials: Optional[Dict[Text, Any]]
+    ) -> "StudioChatInput":
         """Creates a StudioChatInput channel from credentials."""
         credentials = credentials or {}
 
@@ -199,19 +212,41 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             metadata_key=credentials.get("metadata_key", "metadata"),
         )
 
+    async def emit(self, event: str, data: 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.sio.emit("tracker", tracker_dump, room=sender_id)
+        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,
@@ -222,10 +257,18 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
 
         Triggers a tracker update notification after processing the message.
         """
+        self._record_turn_start_time(message.sender_id)
         await on_new_message(message)
 
-        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)
@@ -233,7 +276,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
@@ -251,21 +306,41 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             structlogger.error("studio_chat.sio.domain_not_initialized")
             return None
 
-        async with self.agent.lock_store.lock(data["sender_id"]):
-            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)
+        tracker: Optional[DialogueStateTracker] = None
 
-            processor = self.agent.processor
-            if processor and does_need_action_prediction(tracker):
-                output_channel = self.get_output_channel()
+        async with self.agent.lock_store.lock(data["sender_id"]):
+            try:
+                tracker = DialogueStateTracker.from_dict(
+                    data["sender_id"], data["events"], domain.slots
+                )
 
-                await processor._run_prediction_loop(output_channel, 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()
+
+                    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:
@@ -275,7 +350,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
     async def collect_call_parameters(
         self, channel_websocket: "Websocket"
     ) -> Optional[CallParameters]:
-        """Voice method to collect call parameters"""
+        """Voice method to collect call parameters."""
         session_id = channel_websocket.session_id
         return CallParameters(session_id, "local", "local", stream_id=session_id)
 
@@ -292,20 +367,20 @@ 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(
         self, voice_websocket: "Websocket", tts_engine: TTSEngine
     ) -> VoiceOutputChannel:
-        """Create a voice output channel"""
+        """Create a voice output channel."""
         return StudioVoiceOutputChannel(
             voice_websocket,
             tts_engine,
@@ -382,9 +457,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")
@@ -419,7 +493,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:
@@ -433,7 +507,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
                 return
 
             # Handle text messages
-            await self.handle_user_message(sid, data, on_new_message)
+            await self.handle_user_message(sid, data, proxied_on_message)
 
         @self.sio.on("update_tracker", namespace=self.namespace)
         async def on_update_tracker(sid: Text, data: Dict) -> None:
@@ -457,7 +531,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/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,
@@ -85,7 +88,7 @@ class AudiocodesVoiceOutputChannel(VoiceOutputChannel):
         # 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  # type: ignore[attr-defined]
+        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."""
@@ -127,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))
@@ -184,7 +187,7 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
                     pass
                 elif activity["name"] == "playFinished":
                     logger.debug("audiocodes_stream.playFinished", data=activity)
-                    call_state.is_bot_speaking = False  # type: ignore[attr-defined]
+                    call_state.is_bot_speaking = False
                     if call_state.should_hangup:
                         logger.info("audiocodes_stream.hangup")
                         self._send_hangup(ws, data)

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,
@@ -35,7 +38,7 @@ 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"])