rasa-pro 3.13.0.dev7__py3-none-any.whl → 3.13.0.dev8__py3-none-any.whl

rasa/core/actions/action_run_slot_rejections.py

@@ -105,7 +105,6 @@ def run_rejections(
             structlogger.error(
                 "run.predicate.error",
                 predicate=condition,
-                document=document,
                 error=str(e),
             )
             violation = True

rasa/core/agent.py

@@ -13,6 +13,7 @@ from aiohttp import ClientError
 
 import rasa.shared.utils.io
 from rasa.core import jobs
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels.channel import OutputChannel, UserMessage
 from rasa.core.constants import DEFAULT_REQUEST_TIMEOUT
 from rasa.core.exceptions import AgentNotReady
@@ -27,13 +28,14 @@ from rasa.core.tracker_stores.tracker_store import (
     InMemoryTrackerStore,
     TrackerStore,
 )
-from rasa.core.utils import AvailableEndpoints
 from rasa.exceptions import ModelNotFound
 from rasa.nlu.utils import is_url
+from rasa.privacy.privacy_manager import BackgroundPrivacyManager
 from rasa.shared.constants import DEFAULT_SENDER_ID
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
 from rasa.shared.exceptions import RasaException
+from rasa.telemetry import track_privacy_enabled
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
 
@@ -222,6 +224,7 @@ async def load_agent(
     generator = None
     action_endpoint = None
     http_interpreter = None
+    privacy_manager = None
 
     if endpoints:
         broker = await EventBroker.create(endpoints.event_broker, loop=loop)
@@ -234,6 +237,12 @@ async def load_agent(
         model_server = endpoints.model if endpoints.model else model_server
         if endpoints.nlu:
             http_interpreter = RasaNLUHttpInterpreter(endpoints.nlu)
+        if endpoints.privacy:
+            privacy_manager = await BackgroundPrivacyManager.create_instance(
+                endpoints=endpoints,
+                event_loop=loop,
+            )
+            track_privacy_enabled(privacy_manager.config, broker)
 
     agent = Agent(
         generator=generator,
@@ -244,6 +253,7 @@ async def load_agent(
         remote_storage=remote_storage,
         http_interpreter=http_interpreter,
         endpoints=endpoints,
+        privacy_manager=privacy_manager,
     )
 
     try:
@@ -306,6 +316,7 @@ class Agent:
         remote_storage: Optional[StorageType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional[AvailableEndpoints] = None,
+        privacy_manager: Optional[BackgroundPrivacyManager] = None,
     ):
         """Initializes an `Agent`."""
         self.domain = domain
@@ -321,6 +332,7 @@ class Agent:
         self._set_fingerprint(fingerprint)
         self.model_server = model_server
         self.remote_storage = remote_storage
+        self.privacy_manager = privacy_manager
 
     @classmethod
     def load(
@@ -336,6 +348,7 @@ class Agent:
         remote_storage: Optional[StorageType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional[AvailableEndpoints] = None,
+        privacy_manager: Optional[BackgroundPrivacyManager] = None,
     ) -> Agent:
         """Constructs a new agent and loads the processor and model."""
         agent = Agent(
@@ -349,6 +362,7 @@ class Agent:
             remote_storage=remote_storage,
             http_interpreter=http_interpreter,
             endpoints=endpoints,
+            privacy_manager=privacy_manager,
         )
         agent.load_model(model_path=model_path, fingerprint=fingerprint)
         return agent
@@ -365,6 +379,7 @@ class Agent:
             generator=self.nlg,
             http_interpreter=self.http_interpreter,
             endpoints=self.endpoints,
+            privacy_manager=self.privacy_manager,
         )
         self.domain = self.processor.domain
 

rasa/core/available_endpoints.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, Dict, List, Optional, Union
+
+from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH
+from rasa.shared.core.constants import (
+    GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE,
+    GLOBAL_SILENCE_TIMEOUT_KEY,
+)
+from rasa.shared.exceptions import RasaException
+from rasa.utils.endpoints import (
+    EndpointConfig,
+    read_endpoint_config,
+    read_property_config_from_endpoints_file,
+)
+
+
+@dataclasses.dataclass
+class InteractionHandlingConfig:
+    """Configuration for interaction handling."""
+
+    global_silence_timeout: Union[float, int] = GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+
+    def __post_init__(self) -> None:
+        # Validate the type of `global_silence_timeout`.
+        if isinstance(self.global_silence_timeout, str):
+            try:
+                self.global_silence_timeout = float(self.global_silence_timeout)
+            except ValueError:
+                raise RasaException(
+                    f"Type for {GLOBAL_SILENCE_TIMEOUT_KEY} is wrong, expected number. "
+                    f"Got: '{self.global_silence_timeout}'. "
+                )
+
+        if not isinstance(self.global_silence_timeout, (float, int)):
+            raise RasaException(
+                f"Type for {GLOBAL_SILENCE_TIMEOUT_KEY} is wrong, expected number. "
+                f"Got: '{type(self.global_silence_timeout)}'. "
+            )
+
+        if self.global_silence_timeout <= 0:
+            raise RasaException(
+                f"Value for {GLOBAL_SILENCE_TIMEOUT_KEY} must be a positive number. "
+                f"Got: '{self.global_silence_timeout}'. "
+            )
+
+    @classmethod
+    def from_dict(cls, data: Optional[Dict[str, Any]]) -> InteractionHandlingConfig:
+        """Create a InteractionHandlingConfig instance from a dictionary."""
+        return cls(
+            global_silence_timeout=data.get(
+                GLOBAL_SILENCE_TIMEOUT_KEY, GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+            )
+            if data is not None
+            else GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+        )
+
+
+class AvailableEndpoints:
+    """Collection of configured endpoints."""
+
+    _instance = None
+
+    @classmethod
+    def read_endpoints(cls, endpoint_file: str) -> AvailableEndpoints:
+        """Read the different endpoints from a yaml file."""
+        nlg = read_endpoint_config(endpoint_file, endpoint_type="nlg")
+        nlu = read_endpoint_config(endpoint_file, endpoint_type="nlu")
+        action = read_endpoint_config(endpoint_file, endpoint_type="action_endpoint")
+        model = read_endpoint_config(endpoint_file, endpoint_type="models")
+        tracker_store = read_endpoint_config(
+            endpoint_file, endpoint_type="tracker_store"
+        )
+        lock_store = read_endpoint_config(endpoint_file, endpoint_type="lock_store")
+        event_broker = read_endpoint_config(endpoint_file, endpoint_type="event_broker")
+        vector_store = read_endpoint_config(endpoint_file, endpoint_type="vector_store")
+        model_groups = read_property_config_from_endpoints_file(
+            endpoint_file, property_name="model_groups"
+        )
+        privacy = read_property_config_from_endpoints_file(
+            endpoint_file, property_name="privacy"
+        )
+
+        interaction_handling = InteractionHandlingConfig.from_dict(
+            read_property_config_from_endpoints_file(
+                endpoint_file, property_name="interaction_handling"
+            )
+        )
+
+        return cls(
+            nlg,
+            nlu,
+            action,
+            model,
+            tracker_store,
+            lock_store,
+            event_broker,
+            vector_store,
+            model_groups,
+            privacy,
+            interaction_handling,
+        )
+
+    def __init__(
+        self,
+        nlg: Optional[EndpointConfig] = None,
+        nlu: Optional[EndpointConfig] = None,
+        action: Optional[EndpointConfig] = None,
+        model: Optional[EndpointConfig] = None,
+        tracker_store: Optional[EndpointConfig] = None,
+        lock_store: Optional[EndpointConfig] = None,
+        event_broker: Optional[EndpointConfig] = None,
+        vector_store: Optional[EndpointConfig] = None,
+        model_groups: Optional[List[Dict[str, Any]]] = None,
+        privacy: Optional[Dict[str, Any]] = None,
+        interaction_handling: InteractionHandlingConfig = InteractionHandlingConfig(
+            global_silence_timeout=GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+        ),
+    ) -> None:
+        """Create an `AvailableEndpoints` object."""
+        self.model = model
+        self.action = action
+        self.nlu = nlu
+        self.nlg = nlg
+        self.tracker_store = tracker_store
+        self.lock_store = lock_store
+        self.event_broker = event_broker
+        self.vector_store = vector_store
+        self.model_groups = model_groups
+        self.privacy = privacy
+        self.interaction_handling = interaction_handling
+
+    @classmethod
+    def get_instance(
+        cls, endpoint_file: Optional[str] = DEFAULT_ENDPOINTS_PATH
+    ) -> AvailableEndpoints:
+        """Get the singleton instance of AvailableEndpoints."""
+        # Ensure that the instance is initialized only once.
+        if cls._instance is None:
+            cls._instance = cls.read_endpoints(endpoint_file)
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls) -> None:
+        cls._instance = None

rasa/core/brokers/pika.py

@@ -316,9 +316,8 @@ class PikaEventBroker(EventBroker):
         except Exception as e:
             structlogger.error(
                 "pika.events.publish.failed",
-                event_info="Logging a reduced version of the failed Pika event",
+                event_info=f"Failed to publish Pika event. Error: {e}",
                 host=self.host,
-                rasa_event=reduced_event,
             )
             if self.should_keep_unpublished_messages:
                 self._unpublished_events.append(event)

rasa/core/channels/botframework.py

@@ -115,8 +115,8 @@ class BotFramework(OutputChannel):
 
         if not send_response.ok:
             logger.error(
-                "Error trying to send botframework messge. Response: %s",
-                send_response.text,
+                "Error trying to send botframework messge. "
+                f"Error: {send_response.reason}"
             )
 
     async def send_text_message(

rasa/core/channels/channel.py

@@ -103,7 +103,7 @@ class UserMessage:
 
 
 def register(
-    input_channels: List["InputChannel"], app: Sanic, route: Optional[Text]
+    input_channels: List[InputChannel], app: Sanic, route: Optional[Text]
 ) -> None:
     """Registers input channel blueprints with Sanic."""
 
@@ -129,7 +129,7 @@ class InputChannel:
         return cls.__name__
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> "InputChannel":
+    def from_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> InputChannel:
         return cls()
 
     def url_prefix(self) -> Text:

rasa/core/channels/hangouts.py

@@ -1,4 +1,3 @@
-import copy
 import logging
 from asyncio import CancelledError
 from typing import Any, Awaitable, Callable, Dict, Iterable, List, Optional, Text, Union
@@ -314,13 +313,17 @@ class HangoutsInput(InputChannel):
                         metadata={"room": room_name},
                     )
                 )
-            except CancelledError:
+            except CancelledError as e:
                 structlogger.error(
-                    "hangouts.message.blueprint.timeout", text=copy.deepcopy(text)
+                    "hangouts.message.blueprint.timeout",
+                    event_info=f"Message processing was cancelled. Error: {e}",
                 )
-            except Exception:
+            except Exception as e:
                 structlogger.exception(
-                    "hangouts.message.blueprint.failure", text=copy.deepcopy(text)
+                    "hangouts.message.blueprint.failure",
+                    event_info=(
+                        f"An error occurred while processing the message. Error: {e}",
+                    ),
                 )
 
             return response.json(collector.messages)

rasa/core/channels/mattermost.py

@@ -28,7 +28,7 @@ class MattermostBot(OutputChannel):
         if r.status_code == 200:
             return r.headers["Token"]
         else:
-            logger.error(f"Failed to login mattermost user {user}. Response: {r}")
+            logger.error(f"Failed to login mattermost user. Response: {r}")
             return None
 
     def __init__(

rasa/core/channels/rasa_chat.py

@@ -107,10 +107,8 @@ class RasaChatInput(RestInput):
                 return req.json[CONVERSATION_ID_KEY]
             else:
                 logger.error(
-                    "User '{}' does not have permissions to send messages to "
-                    "conversation '{}'.".format(
-                        jwt_payload[JWT_USERNAME_KEY], req.json[CONVERSATION_ID_KEY]
-                    )
+                    "User does not have permissions to send messages to "
+                    "conversation '{}'.".format(req.json[CONVERSATION_ID_KEY])
                 )
                 raise SanicException(status_code=401)
 

rasa/core/channels/rest.py

@@ -1,5 +1,4 @@
 import asyncio
-import copy
 import inspect
 import json
 import logging
@@ -166,11 +165,13 @@ class RestInput(InputChannel):
                 )
             except CancelledError:
                 structlogger.error(
-                    "rest.message.received.timeout", text=copy.deepcopy(text)
+                    "rest.message.received.timeout",
+                    event_info="Message processing was cancelled.",
                 )
-            except Exception:
+            except Exception as e:
                 structlogger.exception(
-                    "rest.message.received.failure", text=copy.deepcopy(text)
+                    "rest.message.received.failure",
+                    event_info=f"Message processing failed. Error: {e}",
                 )
 
             return response.json(collector.messages)

rasa/core/channels/studio_chat.py

@@ -83,7 +83,9 @@ class StudioTrackerUpdatePlugin:
 
     def handle_tracker_update(self, tracker: "DialogueStateTracker") -> None:
         """Handles a tracker update when triggered by a hook."""
-        structlogger.info("studio_chat.after_tracker_update", tracker=tracker)
+        structlogger.info(
+            "studio_chat.after_tracker_update", sender_id=tracker.sender_id
+        )
         # directly create a dump to avoid the tracker getting modified by another
         # function before it gets published (since the publishing is scheduled
         # as an async task)
@@ -185,7 +187,6 @@ class StudioChatInput(SocketIOInput):
                 output_channel = self.get_output_channel()
 
                 await processor._run_prediction_loop(output_channel, tracker)
-                await processor.run_anonymization_pipeline(tracker)
                 await self.agent.tracker_store.save(tracker)
 
         await self.on_tracker_updated(tracker)

rasa/core/channels/vier_cvg.py

@@ -129,9 +129,8 @@ class CVGOutput(OutputChannel):
                 )
 
             logger.info(
-                "Creating incoming UserMessage: {text=%s, output_channel=%s, sender_id=%s, metadata=%s}"  # noqa: E501
+                "Creating incoming UserMessage: {output_channel=%s, sender_id=%s, metadata=%s}"  # noqa: E501
                 % (
-                    user_message.text,
                     user_message.output_channel,
                     user_message.sender_id,
                     user_message.metadata,

rasa/core/channels/voice_ready/audiocodes.py

@@ -193,16 +193,9 @@ class Conversation:
             try:
                 await on_new_message(user_msg)
             except Exception as e:  # skipcq: PYL-W0703
-                if isinstance(user_msg.text, dict):
-                    anonymized_info = json.dumps(user_msg.text)
-                elif isinstance(user_msg.text, str):
-                    anonymized_info = user_msg.text
-                else:
-                    anonymized_info = INFO_UNKNOWN
-
                 structlogger.exception(
                     "audiocodes.handle.activities.failure",
-                    user_message=copy.deepcopy(anonymized_info),
+                    sender_id=self.conversation_id,
                     error=e,
                     exc_info=True,
                 )

rasa/core/channels/voice_stream/audiocodes.py

@@ -108,15 +108,19 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
     ):
         mark_as_beta_feature("Audiocodes (audiocodes_stream) Channel")
-        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        super().__init__(
+            server_url=server_url,
+            asr_config=asr_config,
+            tts_config=tts_config,
+        )
         self.token = token
 
     @classmethod
     def from_credentials(
-        cls, credentials: Optional[Dict[str, Any]]
+        cls,
+        credentials: Optional[Dict[str, Any]],
     ) -> VoiceInputChannel:
         if not credentials:
             raise ValueError("No credentials given for Audiocodes voice channel.")
@@ -126,7 +130,6 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
             server_url=credentials["server_url"],
             asr_config=credentials["asr"],
             tts_config=credentials["tts"],
-            monitor_silence=credentials.get("monitor_silence", False),
         )
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:

rasa/core/channels/voice_stream/genesys.py

@@ -99,7 +99,8 @@ class GenesysInputChannel(VoiceInputChannel):
 
     @classmethod
     def from_credentials(
-        cls, credentials: Optional[Dict[str, Any]]
+        cls,
+        credentials: Optional[Dict[str, Any]],
     ) -> VoiceInputChannel:
         if not credentials:
             raise ValueError("No credentials given for Genesys voice channel.")
@@ -113,7 +114,6 @@ class GenesysInputChannel(VoiceInputChannel):
             server_url=credentials["server_url"],
             asr_config=credentials["asr"],
             tts_config=credentials["tts"],
-            monitor_silence=credentials.get("monitor_silence", False),
         )
 
     def _ensure_channel_data_initialized(self) -> None:

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -14,7 +14,7 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
-from rasa.core.channels import InputChannel, UserMessage
+from rasa.core.channels import UserMessage
 from rasa.core.channels.channel import (
     create_auth_requested_response_provider,
     requires_basic_auth,
@@ -102,16 +102,22 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
         username: Optional[Text] = None,
         password: Optional[Text] = None,
     ):
-        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        super().__init__(
+            server_url=server_url,
+            asr_config=asr_config,
+            tts_config=tts_config,
+        )
         self.username = username
         self.password = password
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+    def from_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> VoiceInputChannel:
         credentials = credentials or {}
 
         username = credentials.get("username")
@@ -126,7 +132,6 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             credentials["server_url"],
             credentials["asr"],
             credentials["tts"],
-            credentials.get("monitor_silence", False),
             username=username,
             password=password,
         )

rasa/core/channels/voice_stream/voice_channel.py

@@ -31,8 +31,10 @@ from rasa.core.channels.voice_stream.tts.azure import AzureTTS
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
-from rasa.core.channels.voice_stream.util import generate_silence
-from rasa.shared.core.constants import SLOT_SILENCE_TIMEOUT
+from rasa.core.channels.voice_stream.util import (
+    generate_silence,
+)
+from rasa.shared.core.constants import SILENCE_TIMEOUT_SLOT
 from rasa.shared.utils.cli import print_error_and_exit
 from rasa.shared.utils.common import (
     class_from_module_path,
@@ -171,8 +173,12 @@ class VoiceOutputChannel(OutputChannel):
     def update_silence_timeout(self) -> None:
         """Updates the silence timeout for the session."""
         if self.tracker_state:
-            call_state.silence_timeout = (  # type: ignore[attr-defined]
-                self.tracker_state["slots"][SLOT_SILENCE_TIMEOUT]
+            call_state.silence_timeout = self.tracker_state["slots"][  # type: ignore[attr-defined]
+                SILENCE_TIMEOUT_SLOT
+            ]
+            logger.debug(
+                "voice_channel.silence_timeout_updated",
+                silence_timeout=call_state.silence_timeout,
             )
 
     async def send_text_with_buttons(
@@ -285,21 +291,24 @@ class VoiceInputChannel(InputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
-        monitor_silence: bool = False,
     ):
         validate_voice_license_scope()
         self.server_url = server_url
         self.asr_config = asr_config
         self.tts_config = tts_config
-        self.monitor_silence = monitor_silence
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
 
+        logger.info(
+            "voice_channel.initialized",
+            server_url=self.server_url,
+            asr_config=self.asr_config,
+            tts_config=self.tts_config,
+        )
+
     async def monitor_silence_timeout(self, asr_event_queue: asyncio.Queue) -> None:
         timeout = call_state.silence_timeout
         if not timeout:
             return
-        if not self.monitor_silence:
-            return
         logger.debug("voice_channel.silence_timeout_watch_started", timeout=timeout)
         await asyncio.sleep(timeout)
         await asr_event_queue.put(UserSilence())
@@ -314,13 +323,15 @@ class VoiceInputChannel(InputChannel):
             call_state.silence_timeout_watcher = None  # type: ignore[attr-defined]
 
     @classmethod
-    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+    def from_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> InputChannel:
         credentials = credentials or {}
         return cls(
             credentials["server_url"],
             credentials["asr"],
             credentials["tts"],
-            credentials.get("monitor_silence", False),
         )
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
@@ -340,9 +351,9 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         output_channel = self.create_output_channel(channel_websocket, tts_engine)
         message = UserMessage(
-            USER_CONVERSATION_SESSION_START,
-            output_channel,
-            call_parameters.stream_id,
+            text=USER_CONVERSATION_SESSION_START,
+            output_channel=output_channel,
+            sender_id=call_parameters.stream_id,
             input_channel=self.name(),
             metadata=asdict(call_parameters),
         )
@@ -377,17 +388,17 @@ class VoiceInputChannel(InputChannel):
 
         async def consume_audio_bytes() -> None:
             async for message in channel_websocket:
-                is_bot_speaking_before = call_state.is_bot_speaking
+                was_bot_speaking_before = call_state.is_bot_speaking
                 channel_action = self.map_input_message(message, channel_websocket)
                 is_bot_speaking_after = call_state.is_bot_speaking
 
-                if not is_bot_speaking_before and is_bot_speaking_after:
+                if not was_bot_speaking_before and is_bot_speaking_after:
                     logger.debug("voice_channel.bot_started_speaking")
                     # relevant when the bot speaks multiple messages in one turn
                     self._cancel_silence_timeout_watcher()
 
                 # we just stopped speaking, starting a watcher for silence timeout
-                if is_bot_speaking_before and not is_bot_speaking_after:
+                if was_bot_speaking_before and not is_bot_speaking_after:
                     logger.debug("voice_channel.bot_stopped_speaking")
                     self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
@@ -458,9 +469,9 @@ class VoiceInputChannel(InputChannel):
             call_state.is_user_speaking = False  # type: ignore[attr-defined]
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                e.text,
-                output_channel,
-                call_parameters.stream_id,
+                text=e.text,
+                output_channel=output_channel,
+                sender_id=call_parameters.stream_id,
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )
@@ -471,9 +482,9 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserSilence):
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                USER_CONVERSATION_SILENCE_TIMEOUT,
-                output_channel,
-                call_parameters.stream_id,
+                text=USER_CONVERSATION_SILENCE_TIMEOUT,
+                output_channel=output_channel,
+                sender_id=call_parameters.stream_id,
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )