rasa-pro 3.14.0.dev4__py3-none-any.whl → 3.14.0.dev5__py3-none-any.whl

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

@@ -5,26 +5,25 @@ import {
   useColorModeValue,
   useToast,
 } from '@chakra-ui/react'
-import { useEffect, useState, useCallback } from 'react'
 import axios from 'axios'
-import { useOurTheme } from './theme'
-import { Welcome } from './components/Welcome'
-import { DialogueStack } from './components/DialogueStack'
+import queryString from 'query-string'
+import { useCallback, useEffect, useState } from 'react'
+import useWebSocket, { ReadyState } from 'react-use-websocket'
+import { Chat } from './components/Chat'
+import { DiagramFlow } from './components/DiagramFlow'
 import { DialougeInformation } from './components/DialogueInformation'
+import { DialogueStack } from './components/DialogueStack'
 import { LoadingSpinner } from './components/LoadingSpinner'
-import { DiagramFlow } from './components/DiagramFlow'
 import { RecruitmentPanel } from './components/RecruitmentPanel'
+import { Welcome } from './components/Welcome'
 import { formatSlots } from './helpers/formatters'
-import { Slot, Stack, Event, Flow, SelectedStack, Tracker } from './types'
 import {
   createHistoricalStack,
   flowStepTrail,
   updatedActiveFrame,
 } 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'
+import { useOurTheme } from './theme'
+import { Event, Flow, SelectedStack, Slot, Stack, Tracker } from './types'
 
 export function App() {
   const toast = useToast()
@@ -252,6 +251,7 @@ export function App() {
             slots={slots}
             events={events}
             story={story}
+            latency={latency}
           />
         </Grid>
       </GridItem>
@@ -265,7 +265,6 @@ export function App() {
       </GridItem>
       <GridItem overflow="hidden">
         <Grid sx={rightColumnSx}>
-          <LatencyDisplay latency={latency} sx={boxSx} />
           {shouldShowTranscript && (
             <GridItem sx={chatContainerSx}>
               <Chat events={events || []} />

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

@@ -13,13 +13,14 @@ import {
   useTab,
   useToast,
 } from '@chakra-ui/react'
+import { useEffect } from 'react'
 import { Light as SyntaxHighlighter } from 'react-syntax-highlighter'
+import { useCopyToClipboard } from 'usehooks-ts'
+import { formatTestCases } from '../helpers/formatters'
 import { useOurTheme } from '../theme'
 import { Event, Slot } from '../types'
-import { formatTestCases } from '../helpers/formatters'
-import { useCopyToClipboard } from 'usehooks-ts'
-import { useEffect } from 'react'
 import { FullscreenButton } from './FullscreenButton'
+import { LatencyDisplay } from './LatencyDisplay'
 import { SlotTable, Slots } from './Slots'
 
 interface Props extends FlexProps {
@@ -27,6 +28,7 @@ interface Props extends FlexProps {
   events: Event[]
   story: string
   slots: Slot[]
+  latency: any
 }
 
 export const DialougeInformation = ({
@@ -35,6 +37,7 @@ export const DialougeInformation = ({
   events,
   story,
   slots,
+  latency,
   ...props
 }: Props) => {
   const toast = useToast()
@@ -105,6 +108,7 @@ export const DialougeInformation = ({
           <CustomTab>Slots</CustomTab>
           <CustomTab>End-2-end test</CustomTab>
           <CustomTab>Tracker state</CustomTab>
+          <CustomTab>Latency</CustomTab>
         </TabList>
         <TabPanels height="100%" overflow="hidden">
           <TabPanel sx={tabPanelSx}>
@@ -160,6 +164,11 @@ export const DialougeInformation = ({
               </FullscreenButton>
             </HStack>
           </TabPanel>
+          <TabPanel sx={tabPanelSx}>
+            <Box sx={overflowBox}>
+              <LatencyDisplay latency={latency} />
+            </Box>
+          </TabPanel>
         </TabPanels>
       </Tabs>
     </Flex>

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

@@ -52,8 +52,6 @@ function StackRow({
     },
   }
 
-  const agentOrStep = stack.agent_id ?? stack.step_id;
-
   return (
     <Tr
       sx={
@@ -67,12 +65,12 @@ function StackRow({
         </Tooltip>
       </Td>
       <Td>
-        {shouldShowTooltip(agentOrStep) ? (
-          <Tooltip label={`${agentOrStep} ${stack.agent_id && `(${stack.step_id})`}`} hasArrow>
-            <Text noOfLines={1}>{agentOrStep}</Text>
+        {shouldShowTooltip(stack.step_id) ? (
+          <Tooltip label={stack.step_id} hasArrow>
+            <Text noOfLines={1}>{stack.step_id}</Text>
           </Tooltip>
         ) : (
-          <Text noOfLines={1}>{agentOrStep}</Text>
+          <Text noOfLines={1}>{stack.step_id}</Text>
         )}
       </Td>
     </Tr>

rasa/core/channels/inspector/src/helpers/formatters.ts

@@ -1,5 +1,5 @@
-import {rasaColors} from '../theme/base/colors'
-import type {Event, Flow, Slot, Stack} from '../types'
+import { rasaColors } from '../theme/base/colors'
+import type { Event, Flow, Slot, Stack } from '../types'
 
 export function formatSlots(slots: { [key: string]: unknown }) {
   if (!slots) {
@@ -13,7 +13,7 @@ export function formatSlots(slots: { [key: string]: unknown }) {
         slotDuple[0] !== 'flow_hashes' &&
         slotDuple[1] != null,
     )
-    .map((slotDuple) => ({name: slotDuple[0], value: slotDuple[1]}))
+    .map((slotDuple) => ({ name: slotDuple[0], value: slotDuple[1] }))
 }
 
 export const formatTestCases = (events: Event[], sessionId: string) => {
@@ -85,14 +85,11 @@ export const formatFlow = (
     `flowchart TD
 classDef collect stroke-width:1px
 classDef action fill:#FBFCFD,stroke:#A0B8CF
-classDef noop fill:#FBFCFD
-classDef callstep fill:#FBFCFD
 classDef link fill:#f43
 classDef slot fill:#e8f3db,stroke:#c5e1a5
 classDef endstep fill:#ccc,stroke:#444
 classDef previous stroke:${rasaColors.rasaOrange[400]},stroke-width:1px
 classDef active stroke:${rasaColors.rasaOrange[400]},stroke-width:3px,fill:${rasaColors.warning[50]}
-classDef pulse animation:pulse 2s infinite
 `,
   ]
   try {
@@ -213,24 +210,6 @@ function renderStepSequence(
       )}"]:::slot\n`
     }
 
-    if (step.call) {
-      const isAgentWaitingOnInput = !!currentStack?.agent_id && currentStack?.state === 'waiting_for_input'
-      mermaidTextFragment += `${mermaidId}["${encodeDoubleQuotes(
-        stepId,
-      )} 🤖"]:::callstep\n`
-
-      if (isAgentWaitingOnInput) {
-        mermaidTextFragment += `class ${mermaidId} pulse\n`
-      }
-    }
-
-    if (step.noop) {
-      mermaidTextFragment += `${mermaidId}["${parseFieldUsingStack(
-        stepId,
-        currentStack
-      )}"]:::noop\n`
-    }
-
     if (activeStep && stepId === activeStep) {
       mermaidTextFragment += `class ${mermaidId} active\n`
     } else if (stepTrail?.includes(stepId)) {

rasa/core/channels/inspector/src/theme/base/styles.ts

@@ -1,19 +1,4 @@
-import {mode, StyleFunctionProps} from '@chakra-ui/theme-tools'
-import {keyframes} from "@chakra-ui/react";
-
-
-const pulse = keyframes`
-    0% {
-        opacity: 1;
-    }
-    50% {
-        opacity: 0.5;
-    }
-    100% {
-        opacity: 1;
-    }
-`;
-
+import { mode, StyleFunctionProps } from '@chakra-ui/theme-tools'
 
 export const styles = {
   global: {
@@ -24,8 +9,5 @@ export const styles = {
       fontSize: theme.rasaFontSizes.md,
       letterSpacing: '0.025rem',
     }),
-    '.pulse': {
-      animation: `${pulse} 2s infinite`,
-    },
   },
 }

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

@@ -40,8 +40,6 @@ export interface Stack {
   collect?: string
   utter?: string
   ended: boolean
-  agent_id?: string
-  state?: "waiting_for_input" | "interrupted"
 }
 
 export interface LatencyData {
@@ -97,6 +95,4 @@ interface Step {
   reset_after_flow_ends: boolean
   utter: string
   set_slots?: unknown
-  call?: string
-  noop?: boolean
 }

rasa/core/channels/socketio.py

@@ -1,34 +1,54 @@
+from __future__ import annotations
+
+import asyncio
 import inspect
 import json
-import logging
 import uuid
+from asyncio import Task
+from dataclasses import dataclass
 from typing import Any, Awaitable, Callable, Dict, Iterable, List, Optional, Text
 
+import structlog
 from sanic import Blueprint, Sanic, response
 from sanic.request import Request
 from sanic.response import HTTPResponse
 from socketio import AsyncServer
 
-import rasa.core.channels.channel
 import rasa.shared.utils.io
-from rasa.core.channels.channel import InputChannel, OutputChannel, UserMessage
+from rasa.core.channels.channel import (
+    InputChannel,
+    OnNewMessageType,
+    OutputChannel,
+    UserMessage,
+)
+from rasa.core.channels.constants import USER_CONVERSATION_SILENCE_TIMEOUT
+from rasa.shared.core.constants import SILENCE_TIMEOUT_SLOT
+
+logger = structlog.getLogger(__name__)
+
 
-logger = logging.getLogger(__name__)
+@dataclass
+class SilenceTimeout:
+    sender_id: str
+    timeout: float
+
+
+UserSilenceHandlerType = Callable[[SilenceTimeout], Awaitable[Any]]
 
 
 class SocketBlueprint(Blueprint):
     """Blueprint for socketio connections."""
 
     def __init__(
-        self, sio: AsyncServer, socketio_path: Text, *args: Any, **kwargs: Any
+        self, sio_server: AsyncServer, socketio_path: Text, *args: Any, **kwargs: Any
     ) -> None:
-        """Creates a :class:`sanic.Blueprint` for routing socketio connenctions.
+        """Creates a :class:`sanic.Blueprint` for routing socketio connections.
 
-        :param sio: Instance of :class:`socketio.AsyncServer` class
+        :param sio_server: Instance of :class:`socketio.AsyncServer` class
         :param socketio_path: string indicating the route to accept requests on.
         """
         super().__init__(*args, **kwargs)
-        self.ctx.sio = sio
+        self.ctx.sio_server = sio_server
         self.ctx.socketio_path = socketio_path
 
     def register(self, app: Sanic, options: Dict[Text, Any]) -> None:
@@ -42,7 +62,7 @@ class SocketBlueprint(Blueprint):
             path = self.ctx.socketio_path
         else:
             path = options.get("url_prefix", "/socket.io")
-        self.ctx.sio.attach(app, path)
+        self.ctx.sio_server.attach(app, path)
         super().register(app, options)
 
 
@@ -51,14 +71,45 @@ class SocketIOOutput(OutputChannel):
     def name(cls) -> Text:
         return "socketio"
 
-    def __init__(self, sio: AsyncServer, bot_message_evt: Text) -> None:
+    def __init__(
+        self,
+        input_channel: SocketIOInput,
+        sio_server: AsyncServer,
+        bot_message_evt: Text,
+    ) -> None:
         super().__init__()
-        self.sio = sio
+        self._input_channel = input_channel
+        self.sio_server = sio_server
         self.bot_message_evt = bot_message_evt
 
     async def _send_message(self, socket_id: Text, response: Any) -> None:
         """Sends a message to the recipient using the bot event."""
-        await self.sio.emit(self.bot_message_evt, response, room=socket_id)
+        await self.sio_server.emit(self.bot_message_evt, response, room=socket_id)
+        if self.tracker_state and self._input_channel.enable_silence_timeout:
+            silence_timeout = self.tracker_state["slots"][SILENCE_TIMEOUT_SLOT]
+
+            logger.debug(
+                "socketio_channel.silence_timeout_updated",
+                sender_id=socket_id,
+                silence_timeout=silence_timeout,
+            )
+
+            silence_timeout_counts = self.tracker_state["slots"][
+                "consecutive_silence_timeouts"
+            ]
+
+            logger.debug(
+                "socketio_channel.consecutive_silence_timeouts_updated",
+                sender_id=socket_id,
+                silence_timeout_counts=silence_timeout_counts,
+            )
+
+            self._input_channel.reset_silence_timeout(
+                SilenceTimeout(
+                    sender_id=socket_id,
+                    timeout=silence_timeout,
+                ),
+            )
 
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any
@@ -123,9 +174,11 @@ class SocketIOOutput(OutputChannel):
         """Sends custom json to the output."""
         if "data" in json_message:
             json_message.setdefault("room", recipient_id)
-            await self.sio.emit(self.bot_message_evt, **json_message)
+            await self.sio_server.emit(self.bot_message_evt, **json_message)
         else:
-            await self.sio.emit(self.bot_message_evt, json_message, room=recipient_id)
+            await self.sio_server.emit(
+                self.bot_message_evt, json_message, room=recipient_id
+            )
 
     async def send_attachment(  # type: ignore[override]
         self, recipient_id: Text, attachment: Dict[Text, Any], **kwargs: Any
@@ -133,26 +186,38 @@ class SocketIOOutput(OutputChannel):
         """Sends an attachment to the user."""
         await self._send_message(recipient_id, {"attachment": attachment})
 
+    async def hangup(self, recipient_id: Text, **kwargs: Any) -> None:
+        """Hangs up the call for the given sender."""
+        # This method is not applicable for socket.io, but we implement it
+        # to satisfy the OutputChannel interface.
+        logger.debug(
+            "socketio_channel.output.hangup",
+            message=f"Hanging up call for user {recipient_id}.",
+        )
+
+        self._input_channel.disconnect(recipient_id)
+
 
 class SocketIOInput(InputChannel):
     """A socket.io input channel."""
 
     @classmethod
-    def name(cls) -> Text:
+    def name(cls) -> str:
         return "socketio"
 
     @classmethod
     def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
         credentials = credentials or {}
         return cls(
-            credentials.get("user_message_evt", "user_uttered"),
-            credentials.get("bot_message_evt", "bot_uttered"),
-            credentials.get("namespace"),
-            credentials.get("session_persistence", False),
-            credentials.get("socketio_path", "/socket.io"),
-            credentials.get("jwt_key"),
-            credentials.get("jwt_method", "HS256"),
-            credentials.get("metadata_key", "metadata"),
+            user_message_evt=credentials.get("user_message_evt", "user_uttered"),
+            bot_message_evt=credentials.get("bot_message_evt", "bot_uttered"),
+            namespace=credentials.get("namespace"),
+            session_persistence=credentials.get("session_persistence", False),
+            socketio_path=credentials.get("socketio_path", "/socket.io"),
+            jwt_key=credentials.get("jwt_key"),
+            jwt_method=credentials.get("jwt_method", "HS256"),
+            metadata_key=credentials.get("metadata_key", "metadata"),
+            enable_silence_timeout=credentials.get("enable_silence_timeout", False),
         )
 
     def __init__(
@@ -165,6 +230,7 @@ class SocketIOInput(InputChannel):
         jwt_key: Optional[Text] = None,
         jwt_method: Optional[Text] = "HS256",
         metadata_key: Optional[Text] = "metadata",
+        enable_silence_timeout: bool = False,
     ):
         """Creates a ``SocketIOInput`` object."""
         self.bot_message_evt = bot_message_evt
@@ -172,15 +238,18 @@ class SocketIOInput(InputChannel):
         self.user_message_evt = user_message_evt
         self.namespace = namespace
         self.socketio_path = socketio_path
-        self.sio: Optional[AsyncServer] = None
+        self.sio_server: Optional[AsyncServer] = None
         self.metadata_key = metadata_key
+        self.enable_silence_timeout = enable_silence_timeout
 
         self.jwt_key = jwt_key
         self.jwt_algorithm = jwt_method
+        self.on_new_message: Optional[OnNewMessageType] = None
+        self.sender_silence_map: Dict[str, Task] = {}
 
-    def get_output_channel(self) -> Optional["OutputChannel"]:
+    def get_output_channel(self) -> Optional[OutputChannel]:
         """Creates socket.io output channel object."""
-        if self.sio is None:
+        if self.sio_server is None:
             rasa.shared.utils.io.raise_warning(
                 "SocketIO output channel cannot be recreated. "
                 "This is expected behavior when using multiple Sanic "
@@ -189,7 +258,7 @@ class SocketIOInput(InputChannel):
                 "scenarios."
             )
             return None
-        return SocketIOOutput(self.sio, self.bot_message_evt)
+        return SocketIOOutput(self, self.sio_server, self.bot_message_evt)
 
     async def handle_session_request(
         self, sid: Text, data: Optional[Dict] = None
@@ -200,23 +269,26 @@ class SocketIOInput(InputChannel):
         if "session_id" not in data or data["session_id"] is None:
             data["session_id"] = uuid.uuid4().hex
         if self.session_persistence:
-            if inspect.iscoroutinefunction(self.sio.enter_room):  # type: ignore[union-attr]
-                await self.sio.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
+            if inspect.iscoroutinefunction(self.sio_server.enter_room):  # type: ignore[union-attr]
+                await self.sio_server.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
             else:
                 # for backwards compatibility with python-socketio < 5.10.
                 # previously, this function was NOT async.
-                self.sio.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
-        await self.sio.emit("session_confirm", data["session_id"], room=sid)  # type: ignore[union-attr]
-        logger.debug(f"User {sid} connected to socketIO endpoint.")
+                self.sio_server.enter_room(sid, data["session_id"])  # type: ignore[union-attr]
+        await self.sio_server.emit("session_confirm", data["session_id"], room=sid)  # type: ignore[union-attr]
+        logger.debug(
+            "socketio_channel.input.handle_session_request",
+            message=f"User {sid} connected to socketIO endpoint.",
+        )
 
     async def handle_user_message(
         self,
         sid: Text,
         data: Dict,
-        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+        on_new_message: OnNewMessageType,
     ) -> None:
         """Handles user messages received from the client."""
-        output_channel = SocketIOOutput(self.sio, self.bot_message_evt)
+        output_channel = self.get_output_channel()
 
         if self.session_persistence:
             if not data.get("session_id"):
@@ -232,38 +304,44 @@ class SocketIOInput(InputChannel):
         else:
             sender_id = sid
 
+        # We cancel silence timeout when a new message is received
+        # to prevent sending a silence timeout message
+        # if the user sends a message after the silence timeout
+        self._cancel_silence_timeout(sender_id)
+
         metadata = data.get(self.metadata_key, {})
         if isinstance(metadata, Text):
             metadata = json.loads(metadata)
 
         message = UserMessage(
-            data.get("message", ""),
-            output_channel,
-            sender_id,
+            text=data.get("message", ""),
+            output_channel=output_channel,
+            sender_id=sender_id,
             input_channel=self.name(),
             metadata=metadata,
         )
         await on_new_message(message)
 
-    def blueprint(
-        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
-    ) -> SocketBlueprint:
+    def blueprint(self, on_new_message: OnNewMessageType) -> SocketBlueprint:
         """Defines a Sanic blueprint."""
         # Workaround so that socketio works with requests from other origins.
         # https://github.com/miguelgrinberg/python-socketio/issues/205#issuecomment-493769183
-        sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
+        sio_server = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
         socketio_webhook = SocketBlueprint(
-            sio, self.socketio_path, "socketio_webhook", __name__
+            sio_server, self.socketio_path, "socketio_webhook", __name__
         )
 
-        # make sio object static to use in get_output_channel
-        self.sio = sio
+        # make sio_server object static to use in get_output_channel
+        self.sio_server = sio_server
+        # We need to store the on_new_message callback
+        # so that we can call it when a silence timeout occurs
+        self.on_new_message = on_new_message
 
         @socketio_webhook.route("/", methods=["GET"])
         async def health(_: Request) -> HTTPResponse:
             return response.json({"status": "ok"})
 
-        @sio.on("connect", namespace=self.namespace)
+        @sio_server.on("connect", namespace=self.namespace)
         async def connect(sid: Text, environ: Dict, auth: Optional[Dict]) -> bool:
             if self.jwt_key:
                 jwt_payload = None
@@ -273,24 +351,107 @@ class SocketIOInput(InputChannel):
                     )
 
                 if jwt_payload:
-                    logger.debug(f"User {sid} connected to socketIO endpoint.")
+                    logger.debug(
+                        "socketio_channel.input.connect.jwt",
+                        message=f"User {sid} connected to socketIO endpoint.",
+                    )
+                    # Store the chat state for this user
                     return True
                 else:
                     return False
             else:
-                logger.debug(f"User {sid} connected to socketIO endpoint.")
+                logger.debug(
+                    "socketio_channel.input.connect",
+                    message=f"User {sid} connected to socketIO endpoint.",
+                )
+                # Store the chat state for this user
                 return True
 
-        @sio.on("disconnect", namespace=self.namespace)
+        @sio_server.on("disconnect", namespace=self.namespace)
         async def disconnect(sid: Text) -> None:
-            logger.debug(f"User {sid} disconnected from socketIO endpoint.")
+            logger.debug(
+                "socketio_channel.input.disconnect",
+                message=f"User {sid} disconnected from socketIO endpoint.",
+            )
 
-        @sio.on("session_request", namespace=self.namespace)
+        @sio_server.on("session_request", namespace=self.namespace)
         async def session_request(sid: Text, data: Optional[Dict]) -> None:
+            logger.debug(
+                "socketio_channel.input.session_request",
+                message=f"User {sid} requested a session.",
+            )
             await self.handle_session_request(sid, data)
 
-        @sio.on(self.user_message_evt, namespace=self.namespace)
+        @sio_server.on(self.user_message_evt, namespace=self.namespace)
         async def handle_message(sid: Text, data: Dict) -> None:
+            logger.debug(
+                "socketio_channel.input.handle_message",
+                message=f"User {sid} sent a message.",
+                data=data,
+            )
             await self.handle_user_message(sid, data, on_new_message)
 
         return socketio_webhook
+
+    def reset_silence_timeout(self, silence_timeout: SilenceTimeout) -> None:
+        self._cancel_silence_timeout(silence_timeout.sender_id)
+
+        self.sender_silence_map[silence_timeout.sender_id] = (
+            asyncio.get_event_loop().create_task(
+                self._monitor_silence_timeout(
+                    silence_timeout,
+                )
+            )
+        )
+
+    def disconnect(self, sender_id: str) -> None:
+        """Disconnects the user with the given sender ID."""
+        self._cancel_silence_timeout(sender_id)
+        if self.sio_server:
+            asyncio.get_event_loop().create_task(self.sio_server.disconnect(sender_id))
+            logger.debug(
+                "socketio_channel.input.disconnect",
+                message=f"User {sender_id} disconnected from socketIO endpoint.",
+            )
+
+    async def _monitor_silence_timeout(self, silence_timeout: SilenceTimeout) -> None:
+        logger.debug(
+            "socketio_channel.input.silence_timeout_watch_started",
+            sender_id=silence_timeout.sender_id,
+            timeout=silence_timeout.timeout,
+        )
+        await asyncio.sleep(silence_timeout.timeout)
+
+        # once the timer is up, we call the handler
+        # to notify the user about the silence timeout
+        # this is important if monitoring trask is cancelled while handler is executed
+        asyncio.get_event_loop().create_task(
+            self._handle_silence_timeout(silence_timeout)
+        )
+
+        logger.debug(
+            "socketio_channel.input.silence_timeout_tripped",
+            sender_id=silence_timeout.sender_id,
+            silence_timeout=silence_timeout.timeout,
+        )
+
+    async def _handle_silence_timeout(self, event: SilenceTimeout) -> None:
+        if self.on_new_message:
+            output_channel = self.get_output_channel()
+            message = UserMessage(
+                text=USER_CONVERSATION_SILENCE_TIMEOUT,
+                output_channel=output_channel,
+                sender_id=event.sender_id,
+                input_channel=self.name(),
+            )
+            await self.on_new_message(message)
+
+    def _cancel_silence_timeout(self, sender_id: str) -> None:
+        """Cancels the silence timeout task for the given sender."""
+        task = self.sender_silence_map.pop(sender_id, None)
+        if task and not task.done():
+            logger.debug(
+                "socketio_channel.input.silence_timeout_cancelled",
+                sender_id=sender_id,
+            )
+            task.cancel()