rasa-pro 3.14.0.dev20250901__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

rasa/core/actions/direct_custom_actions_executor.py

@@ -35,8 +35,6 @@ class DirectCustomActionExecutor(CustomActionExecutor):
         self.action_name = action_name
         self.action_endpoint = action_endpoint
         self.action_executor = self._create_action_executor()
-        self.register_actions_from_a_module()
-        self.action_executor.reload()
 
     @staticmethod
     @lru_cache(maxsize=1)
@@ -88,12 +86,21 @@ class DirectCustomActionExecutor(CustomActionExecutor):
 
         Returns:
             The response from the execution of the custom action.
+
+        Raises:
+            RasaException: If the actions module specified does not exist.
         """
         structlogger.debug(
             "action.direct_custom_action_executor.run",
             action_name=self.action_name,
         )
 
+        # Register actions module if not already registered.
+        # This is done here instead of __init__ to allow proper
+        # exception handling and avoid hanging conversations.
+        self.register_actions_from_a_module()
+        self.action_executor.reload()
+
         tracker_state = tracker.current_state(EventVerbosity.ALL)
         action_call = {
             "next_action": self.action_name,

rasa/core/actions/grpc_custom_action_executor.py

@@ -152,7 +152,7 @@ class GRPCCustomActionExecutor(CustomActionExecutor):
                 structlogger.error(
                     "rasa.core.actions.grpc_custom_action_executor.domain_not_found",
                     event_info=(
-                        f"Failed to execute custom action '{self.action_endpoint}'. "
+                        f"Failed to execute custom action '{self.action_name}'. "
                         f"Could not find domain. {resource_not_found_error.message}"
                     ),
                 )

rasa/core/agent.py

@@ -12,9 +12,11 @@ import aiohttp
 from aiohttp import ClientError
 
 import rasa.shared.utils.io
+from rasa.agents.utils import initialize_agents
 from rasa.core import jobs
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.available_agents import AvailableAgents
 from rasa.core.channels.channel import OutputChannel, UserMessage
+from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.core.constants import DEFAULT_REQUEST_TIMEOUT
 from rasa.core.exceptions import AgentNotReady
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
@@ -34,7 +36,7 @@ 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.shared.exceptions import AgentInitializationException, RasaException
 from rasa.telemetry import track_privacy_enabled
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
@@ -202,6 +204,7 @@ async def load_agent(
     model_server: Optional[EndpointConfig] = None,
     remote_storage: Optional[StorageType] = None,
     endpoints: Optional[AvailableEndpoints] = None,
+    sub_agents: Optional[AvailableAgents] = None,
     loop: Optional[AbstractEventLoop] = None,
 ) -> Agent:
     """Loads agent from server, remote storage or disk.
@@ -211,6 +214,7 @@ async def load_agent(
         model_server: Configuration for a potential server which serves the model.
         remote_storage: Remote storage to use for loading the model.
         endpoints: Endpoint configuration.
+        sub_agents: Sub-agents configuration.
         loop: Optional async loop to pass to broker creation.
 
     Returns:
@@ -281,8 +285,19 @@ async def load_agent(
                 "No valid configuration given to load agent. "
                 "Agent loaded with no model!"
             )
+
+        if agent.processor and sub_agents:
+            flows = await agent.processor.get_flows()
+            # CLI commands that accept --sub-agents
+            # all route through this entry point.
+            # With all required data available,
+            # this is the best spot to initialize the subagents.
+            await initialize_agents(flows, sub_agents)
+
         return agent
 
+    except AgentInitializationException as e:
+        raise e
     except Exception as e:
         logger.error(f"Could not load model due to {e}.", exc_info=True)
         return agent
@@ -322,6 +337,7 @@ class Agent:
         remote_storage: Optional[StorageType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional[AvailableEndpoints] = None,
+        sub_agents: Optional[AvailableAgents] = None,
         privacy_manager: Optional[BackgroundPrivacyManager] = None,
     ):
         """Initializes an `Agent`."""
@@ -334,6 +350,7 @@ class Agent:
         self.action_endpoint = action_endpoint
         self.http_interpreter = http_interpreter
         self.endpoints = endpoints
+        self.sub_agents = sub_agents
 
         self._set_fingerprint(fingerprint)
         self.model_server = model_server

rasa/core/available_agents.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import os
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+import structlog
+from pydantic import BaseModel, Field, model_validator
+from ruamel import yaml as yaml
+
+from rasa.exceptions import ValidationError
+from rasa.utils.singleton import Singleton
+
+DEFAULT_AGENTS_CONFIG_FOLDER = "sub_agents"
+
+structlogger = structlog.get_logger()
+
+
+class ProtocolConfig(str, Enum):
+    """Supported protocols for agents."""
+
+    RASA = "RASA"
+    A2A = "A2A"
+
+
+class AgentInfo(BaseModel):
+    """Configuration for an agent."""
+
+    name: str = Field(..., description="Agent name")
+    protocol: ProtocolConfig = Field(
+        default=ProtocolConfig.RASA,
+        description="Protocol used to communicate with the agent.",
+    )
+    description: str = Field(..., description="Agent description")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_protocol(cls, values: Any) -> Any:
+        """Validate and normalize protocol values to support lowercase input."""
+        if isinstance(values, dict) and "protocol" in values:
+            protocol_value = values["protocol"]
+            if isinstance(protocol_value, str):
+                # Map lowercase protocol names to uppercase enum values
+                protocol_mapping = {
+                    "rasa": ProtocolConfig.RASA,
+                    "a2a": ProtocolConfig.A2A,
+                    "RASA": ProtocolConfig.RASA,
+                    "A2A": ProtocolConfig.A2A,
+                }
+
+                if protocol_value.lower() in protocol_mapping:
+                    values["protocol"] = protocol_mapping[protocol_value.lower()]
+                else:
+                    # If it's not a recognized protocol, let Pydantic handle the
+                    # validation
+                    # This will raise a proper validation error
+                    pass
+
+        return values
+
+
+class AgentConfiguration(BaseModel):
+    llm: Optional[Dict[str, Any]] = None
+    prompt_template: Optional[str] = None
+    module: Optional[str] = None
+    timeout: Optional[int] = None  # timeout in seconds
+    max_retries: Optional[int] = None
+    agent_card: Optional[str] = None
+    auth: Optional[Dict[str, Any]] = None
+
+
+class AgentConnections(BaseModel):
+    mcp_servers: Optional[List[AgentMCPServerConfig]] = None
+
+
+class AgentMCPServerConfig(BaseModel):
+    name: str  # Reference to MCPServerConfig
+    url: Optional[str] = None
+    type: Optional[str] = None
+    include_tools: Optional[List[str]] = None
+    exclude_tools: Optional[List[str]] = None
+    # Additional parameters for the MCP server
+    additional_params: Optional[Dict[str, Any]] = None
+
+
+class AgentConfig(BaseModel):
+    agent: AgentInfo
+    configuration: Optional[AgentConfiguration] = None
+    connections: Optional[AgentConnections] = None
+
+
+class AvailableAgents(metaclass=Singleton):
+    """Collection of configured agents."""
+
+    _instance = None
+
+    def __init__(self, agents: Optional[Dict[str, AgentConfig]] = None) -> None:
+        """Create an `AvailableAgents` object."""
+        self.agents = agents or {}
+
+    @classmethod
+    def _read_agent_folder(cls, agent_folder: str) -> AvailableAgents:
+        """Read the different agents from the given folder."""
+        agents: Dict[str, AgentConfig] = {}
+
+        if not os.path.isdir(agent_folder):
+            if agent_folder != DEFAULT_AGENTS_CONFIG_FOLDER:
+                # User explicitly specified a folder, it should exist
+                structlogger.error(
+                    f"The specified agents config folder '{agent_folder}' does not "
+                    f"exist or is not a directory."
+                )
+                raise ValueError(
+                    f"The specified agents config folder '{agent_folder}' does not "
+                    f"exist or is not a directory."
+                )
+            else:
+                # We are using the default folder, it may not be created yet
+                # Init with an empty agents in this case
+                structlogger.info(
+                    f"Default agents config folder '{agent_folder}' does not exist. "
+                    f"Agent configurations won't be loaded."
+                )
+                return cls(agents)
+
+        # First, load all agent configs into a temporary list for validation
+        agent_configs: List[AgentConfig] = []
+        for agent_name in os.listdir(agent_folder):
+            config_path = os.path.join(agent_folder, agent_name, "config.yml")
+            if not os.path.isfile(config_path):
+                continue
+            try:
+                agent_config = cls._read_agent_config(config_path)
+                if not isinstance(agent_config, AgentConfig):
+                    raise ValueError(f"Invalid agent config type for {agent_name}")
+                agent_configs.append(agent_config)
+            except Exception as e:
+                raise ValidationError(
+                    code="agent.load_failed",
+                    event_info=f"Failed to load agent '{agent_name}': {e}",
+                    details={
+                        "agent_name": agent_name,
+                        "agent_folder": agent_folder,
+                        "error": str(e),
+                    },
+                )
+
+        # Validate agent names are unique before adding to dictionary
+        from rasa.agents.validation import validate_agent_names_unique
+
+        validate_agent_names_unique(agent_configs)
+
+        for agent_config in agent_configs:
+            agents[agent_config.agent.name] = agent_config
+
+        return cls(agents)
+
+    @staticmethod
+    def _read_agent_config(config_path: str) -> AgentConfig:
+        """Read the agent config from a yaml file into Pydantic models.
+
+        Args:
+            config_path: Path to the config file.
+
+        Returns:
+            The parsed AgentConfig.
+
+        Raises:
+            yaml.YAMLError: If the YAML file is invalid.
+            ValueError: If the data structure is invalid for Pydantic models.
+        """
+        with open(config_path, "r") as f:
+            data = yaml.safe_load(f)
+
+        # Create the agent config (this will trigger Pydantic validation)
+        agent_config = AgentConfig(
+            agent=AgentInfo(**data.get("agent", {})),
+            configuration=AgentConfiguration(**data.get("configuration", {}))
+            if data.get("configuration")
+            else None,
+            connections=AgentConnections(**data.get("connections", {}))
+            if data.get("connections")
+            else None,
+        )
+
+        return agent_config
+
+    @classmethod
+    def get_instance(
+        cls, agent_folder: Optional[str] = DEFAULT_AGENTS_CONFIG_FOLDER
+    ) -> AvailableAgents:
+        """Get the singleton instance of `AvailableAgents`."""
+        if cls._instance is None:
+            cls._instance = cls._read_agent_folder(agent_folder)
+
+        return cls._instance
+
+    @classmethod
+    def reset_instance(cls) -> None:
+        cls._instance = None
+        # Also clear the metaclass singleton instances
+        if hasattr(type(cls), "_instances"):
+            type(cls)._instances.clear()
+
+    def as_json_list(self) -> List[Dict[str, Any]]:
+        """Convert the available agents to a JSON-serializable list."""
+        return [
+            {
+                "name": agent_name,
+                "agent": agent_config.agent.model_dump(),
+                "configuration": agent_config.configuration.model_dump()
+                if agent_config.configuration
+                else None,
+                "connections": agent_config.connections.model_dump()
+                if agent_config.connections
+                else None,
+            }
+            for agent_name, agent_config in self.agents.items()
+        ]
+
+    @classmethod
+    def get_agent_config(cls, agent_id: str) -> Optional[AgentConfig]:
+        instance = cls.get_instance()
+        return instance.agents.get(agent_id)
+
+    @classmethod
+    def has_agents(cls) -> bool:
+        instance = cls.get_instance()
+        return len(instance.agents) > 0

rasa/core/brokers/broker.py

@@ -66,7 +66,7 @@ class EventBroker:
         raise NotImplementedError("Event broker must implement the `publish` method.")
 
     def is_ready(self) -> bool:
-        """Determine whether or not the event broker is ready.
+        """Determine whether the event broker is ready.
 
         Returns:
             `True` by default, but this may be overridden by subclasses.

rasa/core/brokers/kafka.py

@@ -6,13 +6,18 @@ import threading
 import time
 from asyncio import AbstractEventLoop
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, Union
 
 import structlog
 
 import rasa.shared.utils.common
 from rasa.core.brokers.broker import EventBroker
 from rasa.core.exceptions import KafkaProducerInitializationError
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    IAMCredentialsProviderInput,
+    SupportedServiceType,
+    create_iam_credentials_provider,
+)
 from rasa.shared.core.events import ErrorHandled
 from rasa.shared.utils.io import DEFAULT_ENCODING
 from rasa.utils.endpoints import EndpointConfig
@@ -93,6 +98,9 @@ class KafkaEventBroker(EventBroker):
         self.ssl_keyfile = ssl_keyfile
         self.queue_size = kwargs.get("queue_size")
         self.ssl_check_hostname = "https" if ssl_check_hostname else None
+        self.iam_credentials_provider = create_iam_credentials_provider(
+            IAMCredentialsProviderInput(service_name=SupportedServiceType.EVENT_BROKER)
+        )
 
         # PII management attributes
         self.stream_pii = kwargs.get("stream_pii", True)
@@ -134,8 +142,8 @@ class KafkaEventBroker(EventBroker):
             try:
                 self._check_kafka_connection()
                 logger.debug("Connection to kafka successful.")
-            except KafkaException:
-                logger.debug("Failed to connect kafka.")
+            except KafkaException as exc:
+                logger.debug(f"Failed to connect to kafka: {exc}")
                 return
         while retries:
             try:
@@ -215,7 +223,31 @@ class KafkaEventBroker(EventBroker):
             KafkaException: if Kafka is disconnected.
         """
         if self.producer is not None:
-            self.producer.list_topics(timeout=5)
+            structlogger.debug(
+                "rasa.core.brokers.kafka.KafkaEventBroker.check_kafka_connection",
+            )
+            # we have to poll to trigger the oauth_cb if using IAM authentication
+            self.producer.poll(0)
+            self.producer.list_topics(self.topic, timeout=5)
+
+    def get_aws_iam_token(
+        self, oauth_config: Any
+    ) -> Tuple[Optional[str], Optional[float]]:
+        """Callback function to fetch AWS IAM token for MSK authentication.
+
+        The callback function requires this specific signature to work correctly.
+
+        Args:
+            oauth_config: OAuth configuration.
+
+        Returns:
+            A tuple of auth token and expiry time in seconds.
+        """
+        if self.iam_credentials_provider is None:
+            return None, None
+
+        temp_credentials = self.iam_credentials_provider.get_temporary_credentials()
+        return temp_credentials.auth_token, temp_credentials.expiration
 
     def _get_kafka_config(self) -> Dict[Text, Any]:
         config = {
@@ -246,15 +278,27 @@ class KafkaEventBroker(EventBroker):
             }
         elif self.security_protocol == "SASL_SSL":
             authentication_params = {
-                "sasl.username": self.sasl_username,
-                "sasl.password": self.sasl_password,
                 "ssl.ca.location": self.ssl_cafile,
-                "ssl.certificate.location": self.ssl_certfile,
-                "ssl.key.location": self.ssl_keyfile,
                 "ssl.endpoint.identification.algorithm": self.ssl_check_hostname,
                 "security.protocol": self.security_protocol,
                 "sasl.mechanism": self.sasl_mechanism,
             }
+
+            if self.iam_credentials_provider is not None:
+                authentication_params.update(
+                    {
+                        "oauth_cb": self.get_aws_iam_token,
+                    }
+                )
+            else:
+                authentication_params.update(
+                    {
+                        "sasl.username": self.sasl_username,
+                        "sasl.password": self.sasl_password,
+                        "ssl.certificate.location": self.ssl_certfile,
+                        "ssl.key.location": self.ssl_keyfile,
+                    }
+                )
         else:
             raise ValueError(
                 f"Cannot initialise `KafkaEventBroker`: "

rasa/core/channels/__init__.py

@@ -1,5 +1,5 @@
 # ruff: noqa: I001
-from typing import Text, Dict, List, Type
+from typing import Text, Dict, List, Type, Optional
 
 from rasa.core.channels.channel import (  # noqa: F401
     InputChannel,
@@ -15,54 +15,101 @@ from rasa.core.channels.socketio import SocketIOInput
 from rasa.core.channels.botframework import BotFrameworkInput
 from rasa.core.channels.callback import CallbackInput
 from rasa.core.channels.console import CmdlineInput
-from rasa.core.channels.facebook import FacebookInput
 from rasa.core.channels.mattermost import MattermostInput
 from rasa.core.channels.rasa_chat import RasaChatInput
 from rasa.core.channels.rest import RestInput
 from rasa.core.channels.rocketchat import RocketChatInput
-from rasa.core.channels.slack import SlackInput
-from rasa.core.channels.telegram import TelegramInput
-from rasa.core.channels.twilio import TwilioInput
-from rasa.core.channels.voice_ready.twilio_voice import TwilioVoiceInput
 from rasa.core.channels.voice_ready.jambonz import JambonzVoiceReadyInput
 from rasa.core.channels.voice_ready.audiocodes import AudiocodesInput
 from rasa.core.channels.voice_stream.browser_audio import BrowserAudioInputChannel
-from rasa.core.channels.webexteams import WebexTeamsInput
 from rasa.core.channels.hangouts import HangoutsInput
-from rasa.core.channels.vier_cvg import CVGInput
-from rasa.core.channels.voice_stream.twilio_media_streams import (
-    TwilioMediaStreamsInputChannel,
-)
 from rasa.core.channels.voice_stream.genesys import GenesysInputChannel
 from rasa.core.channels.studio_chat import StudioChatInput
 from rasa.core.channels.voice_stream.audiocodes import AudiocodesVoiceInputChannel
 from rasa.core.channels.voice_stream.jambonz import JambonzStreamInputChannel
 
+# Type annotations for channels with optional dependencies
+FacebookInput: Optional[Type[InputChannel]]
+SlackInput: Optional[Type[InputChannel]]
+TelegramInput: Optional[Type[InputChannel]]
+TwilioInput: Optional[Type[InputChannel]]
+TwilioVoiceInput: Optional[Type[InputChannel]]
+TwilioMediaStreamsInputChannel: Optional[Type[InputChannel]]
+WebexTeamsInput: Optional[Type[InputChannel]]
+CVGInput: Optional[Type[InputChannel]]
+
+# Channels with optional dependencies - import with try-except
+try:
+    from rasa.core.channels.facebook import FacebookInput
+except ImportError:
+    FacebookInput = None
+
+try:
+    from rasa.core.channels.slack import SlackInput
+except ImportError:
+    SlackInput = None
+
+try:
+    from rasa.core.channels.telegram import TelegramInput
+except ImportError:
+    TelegramInput = None
+
+try:
+    from rasa.core.channels.twilio import TwilioInput
+except ImportError:
+    TwilioInput = None
+
+try:
+    from rasa.core.channels.voice_ready.twilio_voice import TwilioVoiceInput
+except ImportError:
+    TwilioVoiceInput = None
+
+try:
+    from rasa.core.channels.voice_stream.twilio_media_streams import (
+        TwilioMediaStreamsInputChannel,
+    )
+except ImportError:
+    TwilioMediaStreamsInputChannel = None
+
+try:
+    from rasa.core.channels.webexteams import WebexTeamsInput
+except ImportError:
+    WebexTeamsInput = None
+
+try:
+    from rasa.core.channels.vier_cvg import CVGInput
+except ImportError:
+    CVGInput = None
+
 input_channel_classes: List[Type[InputChannel]] = [
-    CmdlineInput,
-    FacebookInput,
-    SlackInput,
-    TelegramInput,
-    MattermostInput,
-    TwilioInput,
-    TwilioVoiceInput,
-    RasaChatInput,
-    BotFrameworkInput,
-    RocketChatInput,
-    CallbackInput,
-    RestInput,
-    SocketIOInput,
-    WebexTeamsInput,
-    HangoutsInput,
-    AudiocodesInput,
-    CVGInput,
-    JambonzVoiceReadyInput,
-    TwilioMediaStreamsInputChannel,
-    BrowserAudioInputChannel,
-    GenesysInputChannel,
-    StudioChatInput,
-    AudiocodesVoiceInputChannel,
-    JambonzStreamInputChannel,
+    c
+    for c in [
+        CmdlineInput,
+        FacebookInput,
+        SlackInput,
+        TelegramInput,
+        MattermostInput,
+        TwilioInput,
+        TwilioVoiceInput,
+        RasaChatInput,
+        BotFrameworkInput,
+        RocketChatInput,
+        CallbackInput,
+        RestInput,
+        SocketIOInput,
+        WebexTeamsInput,
+        HangoutsInput,
+        AudiocodesInput,
+        CVGInput,
+        JambonzVoiceReadyInput,
+        TwilioMediaStreamsInputChannel,
+        BrowserAudioInputChannel,
+        GenesysInputChannel,
+        StudioChatInput,
+        AudiocodesVoiceInputChannel,
+        JambonzStreamInputChannel,
+    ]
+    if c is not None
 ]
 
 # Mapping from an input channel name to its class to allow name based lookup.

rasa/core/channels/development_inspector.py

@@ -70,17 +70,17 @@ class DevelopmentInspectorPlugin:
         self.tasks.append(task)
         self._cleanup_completed_tasks()
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_new_user_message(self, tracker: DialogueStateTracker) -> None:
         """Broadcasts tracker updates after a new user message."""
         self._create_broadcast_task(tracker)
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_action_executed(self, tracker: DialogueStateTracker) -> None:
         """Broadcasts tracker updates after an action is executed."""
         self._create_broadcast_task(tracker)
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_server_stop(self) -> None:
         """Cancels all remaining tasks when the server stops."""
         self._cancel_tasks()
@@ -145,15 +145,10 @@ class DevelopmentInspectProxy(InputChannel):
         state = tracker.current_state(EventVerbosity.AFTER_RESTART)
         return orjson.dumps(state, option=orjson.OPT_SERIALIZE_NUMPY).decode("utf-8")
 
-    async def on_tracker_updated(
-        self, tracker: DialogueStateTracker, latency: Optional[float] = None
-    ) -> None:
+    async def on_tracker_updated(self, tracker: DialogueStateTracker) -> None:
         """Notifies all clients about tracker updates in real-time."""
         if self.tracker_stream and tracker.sender_id:
             state = tracker.current_state(EventVerbosity.AFTER_RESTART)
-            if latency is not None:
-                state["latency"] = {"rasa_processing_latency_ms": latency}
-
             tracker_dump = orjson.dumps(
                 state, option=orjson.OPT_SERIALIZE_NUMPY
             ).decode("utf-8")
@@ -163,28 +158,13 @@ class DevelopmentInspectProxy(InputChannel):
         """Records the start time of a new turn."""
         self._turn_start_times[sender_id] = time.time()
 
-    async def _broadcast_latency(self, sender_id: Text) -> None:
-        """Broadcasts the tracker with latency of the current turn to all clients."""
-        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]
-
-        # broadcast tracker update with latency
-        tracker = await self._get_tracker(sender_id)
-        await self.on_tracker_updated(tracker, latency)
-
     async def on_message_proxy(
         self,
         on_new_message: Callable[["UserMessage"], Awaitable[Any]],
         message: "UserMessage",
     ) -> None:
         """Proxies the on_new_message call to the underlying channel."""
-        self._record_turn_start_time(message.sender_id)
         await on_new_message(message)
-        await self._broadcast_latency(message.sender_id)
 
     @classmethod
     async def serve_inspect_html(cls) -> HTTPResponse:

rasa/core/channels/hangouts.py

@@ -213,7 +213,7 @@ class HangoutsInput(InputChannel):
         # every message. Actual caching depends on response headers.
         # see: https://github.com/googleapis/google-auth-library-python/blob/main/google/oauth2/id_token.py#L15 # noqa: E501
         cached_session = cachecontrol.CacheControl(requests.session())
-        self.google_request = google.auth.transport.requests.Request(
+        self.google_request = google.auth.transport.requests.Request(  # type: ignore[no-untyped-call]
             session=cached_session
         )
 
@@ -267,7 +267,7 @@ class HangoutsInput(InputChannel):
         # see https://developers.google.com/chat/how-tos/bots-develop#verifying_bot_authenticity # noqa: E501
         # and https://google-auth.readthedocs.io/en/latest/user-guide.html#identity-tokens # noqa: E501
         try:
-            decoded_token = id_token.verify_token(
+            decoded_token = id_token.verify_token(  # type: ignore[no-untyped-call]
                 bot_token,
                 self.google_request,
                 audience=self.project_id,