rasa-pro 3.13.11__py3-none-any.whl → 3.14.0__py3-none-any.whl

rasa/core/available_agents.py

@@ -0,0 +1,239 @@
+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.shared.utils.yaml import read_config_file
+
+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:
+    """Collection of configured agents."""
+
+    def __init__(self, agents: Optional[Dict[str, AgentConfig]] = None) -> None:
+        """Create an `AvailableAgents` object."""
+        self.agents: Dict[str, AgentConfig] = agents or {}
+
+    @classmethod
+    def read_from_folder(cls, sub_agents_folder: str) -> AvailableAgents:
+        """Read the different agents from the given folder."""
+        agents: Dict[str, AgentConfig] = {}
+
+        if not os.path.isdir(sub_agents_folder):
+            if sub_agents_folder != DEFAULT_AGENTS_CONFIG_FOLDER:
+                # User explicitly specified a folder, it should exist
+                raise ValidationError(
+                    code="agent.sub_agents_folder_not_found",
+                    event_info=f"The specified agents config folder "
+                    f"'{sub_agents_folder}' does not exist or is not a "
+                    f"directory.",
+                    details={"folder": sub_agents_folder},
+                )
+            else:
+                # We are using the default folder, it may not be created yet
+                # Init with an empty agents in this case
+                structlogger.debug(
+                    f"Default agents config folder '{sub_agents_folder}' does not "
+                    f"exist. 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(sub_agents_folder):
+            agent_folder = os.path.join(sub_agents_folder, agent_name)
+            if not os.path.isdir(agent_folder):
+                raise ValidationError(
+                    code="agent.invalid_directory_structure",
+                    event_info=f"Invalid structure: '{agent_folder}' is not a folder. "
+                    f"Each agent must be stored in its own folder inside "
+                    f"'{sub_agents_folder}'. Expected structure: "
+                    f"{sub_agents_folder}/<agent_name>/config.yml",
+                    details={
+                        "agent_name": agent_name,
+                        "sub_agents_folder": sub_agents_folder,
+                    },
+                )
+            config_path = os.path.join(agent_folder, "config.yml")
+            if not os.path.isfile(config_path):
+                raise ValidationError(
+                    code="agent.missing_config_file",
+                    event_info=f"Missing config file for agent '{agent_name}'. "
+                    f"Expected file: '{config_path}'. "
+                    f"Each agent folder must contain a 'config.yml' file.",
+                    details={
+                        "agent_name": agent_name,
+                        "expected_config_file": config_path,
+                        "sub_agents_folder": sub_agents_folder,
+                    },
+                )
+            try:
+                agent_config = cls._read_agent_config_file(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,
+                        "sub_agents_folder": sub_agents_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
+
+        structlogger.info(f"Loaded agent configs: {[k for k in agents.keys()]}")
+        return cls(agents)
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> AgentConfig:
+        """Parse the agent config from raw data into Pydantic models.
+
+        Args:
+            data: Raw data from the config file as a dictionary.
+
+        Returns:
+            The parsed AgentConfig as a Pydantic model.
+
+        Raises:
+            ValueError: If the data structure is invalid for Pydantic models.
+        """
+        return 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,
+        )
+
+    @classmethod
+    def _read_agent_config_file(cls, 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.
+            ValidationError: If the data structure is invalid for Pydantic models.
+        """
+        data = read_config_file(config_path)
+        return cls.from_dict(data)
+
+    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()
+        ]
+
+    def get_agent_config(self, agent_id: str) -> Optional[AgentConfig]:
+        return self.agents.get(agent_id)
+
+    def has_agents(self) -> bool:
+        return len(self.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,19 @@ 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.constants import KAFKA_SERVICE_NAME
 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 +99,12 @@ 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_type=SupportedServiceType.EVENT_BROKER,
+                service_name=KAFKA_SERVICE_NAME,
+            )
+        )
 
         # PII management attributes
         self.stream_pii = kwargs.get("stream_pii", True)
@@ -134,8 +146,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 +227,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 +282,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/channel.py

@@ -102,6 +102,9 @@ class UserMessage:
         return f"{self.__class__.__name__}({self.text})"
 
 
+OnNewMessageType = Callable[[UserMessage], Awaitable[Any]]
+
+
 def register(
     input_channels: List[InputChannel], app: Sanic, route: Optional[Text]
 ) -> None:
@@ -135,9 +138,7 @@ class InputChannel:
     def url_prefix(self) -> Text:
         return self.name()
 
-    def blueprint(
-        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
-    ) -> Blueprint:
+    def blueprint(self, on_new_message: OnNewMessageType) -> Blueprint:
         """Defines a Sanic blueprint.
 
         The blueprint will be attached to a running sanic server and handle

rasa/core/channels/constants.py

@@ -0,0 +1,3 @@
+USER_CONVERSATION_SESSION_END = "/session_end"
+USER_CONVERSATION_SESSION_START = "/session_start"
+USER_CONVERSATION_SILENCE_TIMEOUT = "/silence_timeout"

rasa/core/channels/development_inspector.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import time
 from functools import partial
 from typing import (
     TYPE_CHECKING,
@@ -35,6 +36,7 @@ if TYPE_CHECKING:
     from sanic.response import HTTPResponse
 
     from rasa.core.channels.channel import UserMessage
+    from rasa.core.processor import MessageProcessor
     from rasa.shared.core.trackers import DialogueStateTracker
 
 from rasa.hooks import hookimpl
@@ -49,6 +51,7 @@ class DevelopmentInspectorPlugin:
     """Plugin for broadcasting tracker updates to development inspector clients."""
 
     def __init__(self, inspector: DevelopmentInspectProxy) -> None:
+        """Initializes the plugin."""
         self.inspector = inspector
         self.tasks: List[asyncio.Task] = []
 
@@ -61,21 +64,23 @@ class DevelopmentInspectorPlugin:
         """Remove tasks that have already completed."""
         self.tasks = [task for task in self.tasks if not task.done()]
 
-    @hookimpl  # type: ignore[misc]
-    def after_new_user_message(self, tracker: DialogueStateTracker) -> None:
-        """Broadcasts tracker updates after a new user message."""
+    def _create_broadcast_task(self, tracker: DialogueStateTracker) -> None:
+        """Creates a task to broadcast tracker updates."""
         task = asyncio.create_task(self.inspector.on_tracker_updated(tracker))
         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
     def after_action_executed(self, tracker: DialogueStateTracker) -> None:
         """Broadcasts tracker updates after an action is executed."""
-        task = asyncio.create_task(self.inspector.on_tracker_updated(tracker))
-        self.tasks.append(task)
-        self._cleanup_completed_tasks()
+        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()
@@ -93,8 +98,9 @@ class DevelopmentInspectProxy(InputChannel):
         super().__init__()
         self.underlying = underlying
         self.is_voice = is_voice
-        self.processor = None
+        self.processor: Optional[MessageProcessor] = None
         self.tracker_stream = TrackerStream(get_tracker=self.get_tracker_state)
+        self._turn_start_times: Dict[Text, float] = {}
         # Register the plugin to get tracker updates
         plugin_manager().register(DevelopmentInspectorPlugin(self))
 
@@ -124,15 +130,18 @@ class DevelopmentInspectProxy(InputChannel):
 
         return pkg_resources.resource_filename(__name__, INSPECT_TEMPLATE_PATH)
 
-    async def get_tracker_state(self, sender_id: str) -> str:
-        """Returns the state of the tracker as a json string."""
+    async def _get_tracker(self, sender_id: Text) -> DialogueStateTracker:
+        """Returns the tracker for the given sender ID."""
         if not self.processor:
             structlogger.error(
-                "development_inspector.get_tracker_state.agent_not_initialized"
+                "development_inspector._get_tracker.agent_not_initialized"
             )
-            return ""
+            raise ValueError("Agent processor is not initialized.")
+        return await self.processor.get_tracker(sender_id)
 
-        tracker = await self.processor.get_tracker(sender_id)
+    async def get_tracker_state(self, sender_id: str) -> str:
+        """Returns the state of the tracker as a json string."""
+        tracker = await self._get_tracker(sender_id)
         state = tracker.current_state(EventVerbosity.AFTER_RESTART)
         return orjson.dumps(state, option=orjson.OPT_SERIALIZE_NUMPY).decode("utf-8")
 
@@ -145,6 +154,10 @@ class DevelopmentInspectProxy(InputChannel):
             ).decode("utf-8")
             await self.tracker_stream.broadcast(tracker_dump)
 
+    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()
+
     async def on_message_proxy(
         self,
         on_new_message: Callable[["UserMessage"], Awaitable[Any]],
@@ -162,7 +175,7 @@ class DevelopmentInspectProxy(InputChannel):
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> "Blueprint":
         """Defines a Sanic blueprint."""
-        self.sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
+        self.sio_server = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
         underlying_webhook: Blueprint = self.underlying.blueprint(
             partial(self.on_message_proxy, on_new_message)
         )
@@ -197,7 +210,7 @@ class DevelopmentInspectProxy(InputChannel):
 class TrackerStream:
     """Stream tracker state to connected clients."""
 
-    def __init__(self, get_tracker: Callable[[str], Awaitable[Dict[str, Any]]]) -> None:
+    def __init__(self, get_tracker: Callable[[str], Awaitable[str]]) -> None:
         """Initializes the TrackerStream."""
         self._connected_clients: Set[Websocket] = set()
         self.get_tracker = get_tracker

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,