rasa-pro 3.14.0.dev20250731__py3-none-any.whl → 3.14.0.dev20250818__py3-none-any.whl

rasa/core/channels/inspector/src/App.tsx

@@ -5,7 +5,7 @@ import {
   useColorModeValue,
   useToast,
 } from '@chakra-ui/react'
-import { useEffect, useState } from 'react'
+import { useEffect, useState, useCallback } from 'react'
 import axios from 'axios'
 import { useOurTheme } from './theme'
 import { Welcome } from './components/Welcome'
@@ -23,6 +23,7 @@ import {
 } from './helpers/utils'
 import queryString from 'query-string'
 import { Chat } from './components/Chat'
+import { LatencyDisplay } from './components/LatencyDisplay'
 import useWebSocket, { ReadyState } from 'react-use-websocket'
 
 export function App() {
@@ -35,6 +36,7 @@ export function App() {
   const [story, setStory] = useState<string>('')
   const [stack, setStack] = useState<Stack[]>([])
   const [frame, setFrame] = useState<SelectedStack | undefined>(undefined)
+  const [latency, setLatency] = useState<any>(null)
 
   // State to control the visibility of the RecruitmentPanel
   const [showRecruitmentPanel, setShowRecruitmentPanel] = useState(true)
@@ -127,6 +129,13 @@ export function App() {
       !rasaChatSessionId ||
       lastJsonMessage?.sender_id === rasaChatSessionId
     ) {
+      if (lastJsonMessage.latency) {
+        console.log('Latency update:', lastJsonMessage.latency)
+        setLatency((prevLatency: any) => ({
+          ...prevLatency,
+          ...lastJsonMessage.latency,
+        }))
+      }
       setSlots(formatSlots(lastJsonMessage.slots))
       setEvents(lastJsonMessage.events)
       const updatedStack = createHistoricalStack(
@@ -175,6 +184,21 @@ export function App() {
       : 'max-content minmax(10rem, 17.5rem) minmax(10rem, auto)',
     gridRowGap: rasaSpace[1],
   }
+  const rightColumnSx = {
+    height: '100%',
+    overflow: 'hidden',
+    gridTemplateColumns: '1fr',
+    gridTemplateRows: 'max-content 1fr',
+    gridRowGap: rasaSpace[1],
+  }
+
+  const chatContainerSx = {
+    ...borderRadiusSx,
+    padding: rasaSpace[1],
+    bg: useColorModeValue('neutral.50', 'neutral.50'),
+    overflow: 'auto', // Allow scrolling for chat
+    height: '100%',
+  }
 
   const onFrameSelected = (stack: Stack) => {
     setFrame({
@@ -188,8 +212,25 @@ export function App() {
     setShowRecruitmentPanel(false)
   }
 
+  const onLatencyUpdate = useCallback((newLatency: any) => {
+    setLatency((prevLatency: any) => ({
+      ...prevLatency,
+      ...newLatency,
+    }))
+  }, [])
+
+  // Make latency update function available globally for audio stream
+  useEffect(() => {
+    if (window.location.href.includes('browser_audio')) {
+      ;(window as any).updateLatency = onLatencyUpdate
+    }
+    return () => {
+      delete (window as any).updateLatency
+    }
+  }, [onLatencyUpdate])
+
   if (!rasaChatSessionId && !window.location.href.includes('socketio'))
-    return <LoadingSpinner />
+    return <LoadingSpinner onLatencyUpdate={onLatencyUpdate} />
 
   return (
     <Grid sx={gridSx}>
@@ -222,11 +263,16 @@ export function App() {
           slots={slots}
         />
       </GridItem>
-      {shouldShowTranscript && (
-        <GridItem>
-          <Chat events={events || []} />
-        </GridItem>
-      )}
+      <GridItem overflow="hidden">
+        <Grid sx={rightColumnSx}>
+          <LatencyDisplay latency={latency} sx={boxSx} />
+          {shouldShowTranscript && (
+            <GridItem sx={chatContainerSx}>
+              <Chat events={events || []} />
+            </GridItem>
+          )}
+        </Grid>
+      </GridItem>
     </Grid>
   )
 }

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

@@ -5,6 +5,7 @@ import { Command, Event } from '../types'
 
 interface Props extends FlexProps {
   events: Event[]
+  hasLatencyDisplay?: boolean
 }
 
 export const Chat = ({ sx, events, ...props }: Props) => {
@@ -12,9 +13,9 @@ export const Chat = ({ sx, events, ...props }: Props) => {
     ...sx,
     p: 0,
     flexDirection: 'column',
+    height: '100%',
   }
 
-  const maxHeight = document.documentElement.scrollHeight - 64
   // 21 and 25 are the rem number we're using for the columns. We add 0.75rem for the padding
   // A potential improvement would be to add a onresize event for both width and height
   let remReference = 21.75
@@ -110,7 +111,7 @@ export const Chat = ({ sx, events, ...props }: Props) => {
           borderRadius: '10px',
           border: 'none',
           width: columnWidth,
-          height: maxHeight,
+          height: '100%',
         }}
         history={messages}
         demo={true}

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

@@ -22,7 +22,7 @@ export const DiagramFlow = ({ stackFrame, stepTrail, flows, slots }: Props) => {
 
   const config = {
     startOnLoad: true,
-    logLevel: 'info',
+    logLevel: 'warning',
     flowchart: {
       useMaxWidth: false,
     },

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

@@ -0,0 +1,268 @@
+import {
+  Box,
+  Flex,
+  FlexProps,
+  Text,
+  useColorModeValue,
+  Tooltip,
+  Table,
+  Tbody,
+  Tr,
+  Td,
+} from '@chakra-ui/react'
+import { useOurTheme } from '../theme'
+import { LatencyData } from '../types'
+
+interface Props extends FlexProps {
+  latency: LatencyData
+}
+
+/**
+ * Simple latency display for text-only conversations.
+ * Shows a single response time value.
+ */
+const MinimalDisplay = ({ latency, sx, ...props }: Props) => {
+  const containerSx = {
+    ...sx,
+    display: 'flex',
+    alignItems: 'center',
+  }
+  
+  const getLatencyColor = (latency: number) => {
+    if (latency < 1500) return 'green.500'
+    if (latency < 2500) return 'orange.500'
+    return 'red.500'
+  }
+  
+  const value = Math.round(latency.rasa_processing_latency_ms || 0);
+  const color = getLatencyColor(value);
+
+  return (
+    <Flex sx={containerSx} {...props}>
+      <Text fontSize="md" color={useColorModeValue('gray.700', 'gray.300')}>
+        Response latency:
+        <Text as="span" ml={2} fontWeight="bold" color={color}>
+          {value}ms
+        </Text>
+      </Text>
+    </Flex>
+  )
+}
+
+/**
+ * Detailed latency waterfall chart for voice conversations.
+ * Displays processing times for ASR, Rasa, and TTS components.
+ */
+const WaterfallDisplay = ({ latency, sx, ...props }: Props) => {
+  const { rasaSpace } = useOurTheme()
+
+  const containerSx = {
+    ...sx,
+    flexDirection: 'column',
+    gap: rasaSpace[1],
+  }
+  
+  const headerSx = {
+    fontSize: 'sm',
+    fontWeight: 'bold',
+    color: useColorModeValue('gray.700', 'gray.300'),
+  }
+  
+  const waterfallBarSx = {
+    height: '24px',
+    borderRadius: '4px',
+    overflow: 'hidden',
+    border: '1px solid',
+    borderColor: useColorModeValue('gray.200', 'gray.600'),
+  }
+  
+  const legendTableSx = {
+    size: 'sm',
+    mt: rasaSpace[0.5]
+  }
+
+  const getLatencyColor = (type: string) => {
+    const colors: { [key: string]: string } = {
+      asr: 'blue.500',
+      rasa: 'purple.500',
+      tts_first: 'orange.500',
+      tts_complete: 'green.500',
+    }
+    return colors[type] || 'gray.500'
+  }
+
+  const getLatencyDescription = (type: string) => {
+    const descriptions: { [key: string]: string } = {
+      asr: 'Time from the first Partial Transcript event to the Final Transcript event from Speech Recognition. It also includes the time taken by the user to speak.',
+      rasa: 'Time taken by Rasa to process the text from the Final Transcript event from Speech Recognition until a text response is generated.',
+      tts_first: 'Time between the request sent to Text-to-Speech processing and the first byte of audio received by Rasa.',
+      tts_complete: 'Time taken by Text-to-Speech to complete audio generation. It depends on the length of the text and could overlap with the Bot speaking time.'
+    }
+    return descriptions[type] || ''
+  }
+
+  // Metrics for proportional display (only actual processing latencies)
+  const chartMetrics = [
+    latency.asr_latency_ms && {
+      type: 'asr',
+      label: 'ASR',
+      value: latency.asr_latency_ms,
+    },
+    latency.rasa_processing_latency_ms && {
+      type: 'rasa',
+      label: 'Rasa',
+      value: latency.rasa_processing_latency_ms,
+    },
+    latency.tts_complete_latency_ms && {
+      type: 'tts_complete',
+      label: 'TTS',
+      value: latency.tts_complete_latency_ms,
+    },
+  ].filter(Boolean)
+
+  // All metrics for legend display
+  const allMetrics = [
+    latency.asr_latency_ms && {
+      type: 'asr',
+      label: 'ASR',
+      value: latency.asr_latency_ms,
+    },
+    latency.rasa_processing_latency_ms && {
+      type: 'rasa',
+      label: 'Rasa',
+      value: latency.rasa_processing_latency_ms,
+    },
+    latency.tts_first_byte_latency_ms && {
+      type: 'tts_first',
+      label: 'TTS First Byte',
+      value: latency.tts_first_byte_latency_ms,
+    },
+    latency.tts_complete_latency_ms && {
+      type: 'tts_complete',
+      label: 'TTS Complete',
+      value: latency.tts_complete_latency_ms,
+    },
+  ].filter(Boolean)
+
+  // Calculate total for proportional sizing (only processing latencies)
+  const totalLatency = chartMetrics.reduce(
+    (sum: number, metric: any) => sum + metric.value,
+    0,
+  )
+
+  // Calculate total latency for title (Rasa + TTS First Byte)
+  const totalDisplayLatency = 
+    (latency.rasa_processing_latency_ms || 0) + 
+    (latency.tts_first_byte_latency_ms || 0);
+    
+  return (
+    <Flex sx={containerSx} {...props}>
+      <Text sx={headerSx}>
+        Response latency: ~{Math.round(totalDisplayLatency)}ms
+      </Text>
+
+      {/* Waterfall Bar */}
+      <Box>
+        <Flex sx={waterfallBarSx}>
+          {chartMetrics.map((metric: any) => {
+            const widthPercentage =
+              totalLatency > 0 ? (metric.value / totalLatency) * 100 : 0
+            return (
+              <Tooltip
+                key={metric.type}
+                label={
+                  <Box>
+                    <Text fontWeight="bold">
+                      {metric.label}: {Math.round(metric.value)}ms
+                    </Text>
+                    <Text fontSize="xs" mt={1}>
+                      {getLatencyDescription(metric.type)}
+                    </Text>
+                  </Box>
+                }
+                hasArrow
+                placement="top"
+              >
+                <Box
+                  bg={getLatencyColor(metric.type)}
+                  width={`${widthPercentage}%`}
+                  height="100%"
+                  minWidth="40px" // Increased minimum width for better visibility
+                  cursor="pointer"
+                  _hover={{ opacity: 0.8 }}
+                />
+              </Tooltip>
+            )
+          })}
+        </Flex>
+
+        {/* Legend */}
+        <Table sx={legendTableSx}>
+          <Tbody>
+            {/* Split metrics into pairs for 2x2 table */}
+            {Array.from(
+              { length: Math.ceil(allMetrics.length / 2) },
+              (_, rowIndex) => (
+                <Tr key={rowIndex}>
+                  {allMetrics
+                    .slice(rowIndex * 2, rowIndex * 2 + 2)
+                    .map((metric: any) => (
+                      <Td key={metric.type} p={rasaSpace[0.25]} border="none">
+                        <Flex align="center" gap={rasaSpace[0.25]}>
+                          <Box
+                            width="8px"
+                            height="8px"
+                            bg={getLatencyColor(metric.type)}
+                            borderRadius="2px"
+                            flexShrink={0}
+                          />
+                          <Text
+                            fontSize="xs"
+                            color={useColorModeValue('gray.600', 'gray.400')}
+                            noOfLines={1}
+                          >
+                            {metric.label}: {Math.round(metric.value)}ms
+                          </Text>
+                        </Flex>
+                      </Td>
+                    ))}
+                  {/* Fill empty cell if odd number of metrics */}
+                  {allMetrics.length % 2 !== 0 &&
+                    rowIndex === Math.ceil(allMetrics.length / 2) - 1 && (
+                      <Td p={rasaSpace[0.25]} border="none" />
+                    )}
+                </Tr>
+              ),
+            )}
+          </Tbody>
+        </Table>
+      </Box>
+    </Flex>
+  )
+}
+
+/**
+ * Displays processing latency information for the conversation.
+ * Shows either a detailed waterfall chart for voice conversations or 
+ * a simpler display for text-only conversations.
+ */
+export const LatencyDisplay = ({
+  sx,
+  latency,
+  ...props
+}: Props) => {
+  if (!latency) {
+    console.warn('Latency data is not available')
+    return null
+  }
+
+  // Show waterfall if voice metrics are available, otherwise show minimal display
+  const isVoiceMetricsAvailable =
+    latency.asr_latency_ms && latency.tts_complete_latency_ms
+
+  if (isVoiceMetricsAvailable) {
+    return <WaterfallDisplay latency={latency} sx={sx} {...props} />
+  }
+
+  return <MinimalDisplay latency={latency} sx={sx} {...props} />
+}

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

@@ -8,7 +8,11 @@ import {
 import { useOurTheme } from '../theme'
 import { createAudioConnection } from '../helpers/audio/audiostream.ts'
 
-export const LoadingSpinner = () => {
+interface LoadingSpinnerProps {
+  onLatencyUpdate?: (latency: any) => void
+}
+
+export const LoadingSpinner = ({ onLatencyUpdate }: LoadingSpinnerProps) => {
   const { rasaSpace } = useOurTheme()
   const isVoice = window.location.href.includes('browser_audio')
   const text = isVoice
@@ -27,7 +31,7 @@ export const LoadingSpinner = () => {
       {isVoice ? (
         <Button
           onClick={async () =>
-            await createAudioConnection(window.location.href)
+            await createAudioConnection(window.location.href, onLatencyUpdate)
           }
         >
           Go

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

@@ -187,7 +187,7 @@ const setupAudioPlayback = async (socket: WebSocket): Promise<AudioQueue> => {
 }
 
 const addDataToAudioQueue =
-  (audioQueue: AudioQueue) => (message: MessageEvent<any>) => {
+  (audioQueue: AudioQueue, onLatencyUpdate?: (latency: any) => void) => (message: MessageEvent<any>) => {
     try {
       const data = JSON.parse(message.data.toString())
       if (data['error']) {
@@ -199,6 +199,10 @@ const addDataToAudioQueue =
         const audioData = intToFloatArray(int32Data)
         audioQueue.write(audioData)
       } else if (data['marker']) {
+        if (data['latency'] && onLatencyUpdate) {
+          onLatencyUpdate(data['latency'])
+        }
+        console.log('Voice Latency Metrics:', data['latency'])
         audioQueue.addMarker(data['marker'])
       }
     } catch (error) {
@@ -231,8 +235,9 @@ function getWebSocketUrl(baseUrl: string) {
  * Creates a WebSocket connection for browser audio and streams microphone input to the server
  *
  * @param baseUrl - The base URL (e.g., "https://example.com" or "http://localhost:5005")
+ * @param onLatencyUpdate - Optional callback function to receive latency updates
  */
-export async function createAudioConnection(baseUrl: string) {
+export async function createAudioConnection(baseUrl: string, onLatencyUpdate?: (latency: any) => void) {
   const websocketURL = getWebSocketUrl(baseUrl)
   const socket = new WebSocket(websocketURL)
 
@@ -241,5 +246,5 @@ export async function createAudioConnection(baseUrl: string) {
   }
 
   const audioQueue = await setupAudioPlayback(socket)
-  socket.onmessage = addDataToAudioQueue(audioQueue)
+  socket.onmessage = addDataToAudioQueue(audioQueue, onLatencyUpdate)
 }

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

@@ -42,11 +42,19 @@ export interface Stack {
   ended: boolean
 }
 
+export interface LatencyData {
+  rasa_processing_latency_ms?: number
+  asr_latency_ms?: number
+  tts_first_byte_latency_ms?: number
+  tts_complete_latency_ms?: number
+}
+
 export interface Tracker {
   sender_id: string
   slots: { [key: string]: unknown }
   events: Event[]
   stack: Stack[]
+  latency?: LatencyData
 }
 
 export interface Flow {

rasa/core/channels/studio_chat.py

@@ -4,6 +4,7 @@ import asyncio
 import audioop
 import base64
 import json
+import time
 import uuid
 from functools import partial
 from typing import (
@@ -18,6 +19,7 @@ from typing import (
     Tuple,
 )
 
+import orjson
 import structlog
 
 from rasa.core.channels import UserMessage
@@ -52,7 +54,9 @@ if TYPE_CHECKING:
 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
 
@@ -64,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:
@@ -178,6 +185,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()
 
@@ -204,7 +212,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
             metadata_key=credentials.get("metadata_key", "metadata"),
         )
 
-    async def emit(self, event: str, data: Dict, room: str) -> None:
+    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")
@@ -214,14 +222,32 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
     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."""
         await self.emit("tracker", tracker_dump, room=sender_id)
 
+    def _record_turn_start_time(self, sender_id: Text) -> None:
+        """Records the start time of a new turn."""
+        self._turn_start_times[sender_id] = time.time()
+
+    def _get_latency(self, sender_id: Text) -> Optional[float]:
+        """Returns the latency of the current turn in milliseconds."""
+        if sender_id not in self._turn_start_times:
+            return None
+
+        latency = (time.time() - self._turn_start_times[sender_id]) * 1000
+        # The turn is over, so we can remove the start time
+        del self._turn_start_times[sender_id]
+        return latency
+
     async def on_message_proxy(
         self,
         on_new_message: Callable[["UserMessage"], Awaitable[Any]],
@@ -231,6 +257,7 @@ 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 or not self.agent.is_ready():
@@ -249,7 +276,8 @@ 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(
@@ -339,14 +367,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(
@@ -429,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")
@@ -466,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:
@@ -480,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:
@@ -504,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_stream/audiocodes.py

@@ -88,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."""
@@ -187,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)