homeassistant 2025.6.3__py3-none-any.whl → 2025.7.0b1__py3-none-any.whl

homeassistant/helpers/trigger.py

@@ -2,13 +2,14 @@
 
 from __future__ import annotations
 
+import abc
 import asyncio
 from collections import defaultdict
-from collections.abc import Callable, Coroutine
+from collections.abc import Callable, Coroutine, Iterable
 from dataclasses import dataclass, field
 import functools
 import logging
-from typing import Any, Protocol, TypedDict, cast
+from typing import TYPE_CHECKING, Any, Protocol, TypedDict, cast
 
 import voluptuous as vol
 
@@ -28,13 +29,24 @@ from homeassistant.core import (
     is_callback,
 )
 from homeassistant.exceptions import HomeAssistantError, TemplateError
-from homeassistant.loader import IntegrationNotFound, async_get_integration
+from homeassistant.loader import (
+    Integration,
+    IntegrationNotFound,
+    async_get_integration,
+    async_get_integrations,
+)
 from homeassistant.util.async_ import create_eager_task
 from homeassistant.util.hass_dict import HassKey
+from homeassistant.util.yaml import load_yaml_dict
+from homeassistant.util.yaml.loader import JSON_TYPE
 
+from . import config_validation as cv
+from .integration_platform import async_process_integration_platforms
 from .template import Template
 from .typing import ConfigType, TemplateVarsType
 
+_LOGGER = logging.getLogger(__name__)
+
 _PLATFORM_ALIASES = {
     "device": "device_automation",
     "event": "homeassistant",
@@ -48,13 +60,131 @@ DATA_PLUGGABLE_ACTIONS: HassKey[defaultdict[tuple, PluggableActionsEntry]] = Has
     "pluggable_actions"
 )
 
+TRIGGER_DESCRIPTION_CACHE: HassKey[dict[str, dict[str, Any] | None]] = HassKey(
+    "trigger_description_cache"
+)
+TRIGGER_PLATFORM_SUBSCRIPTIONS: HassKey[
+    list[Callable[[set[str]], Coroutine[Any, Any, None]]]
+] = HassKey("trigger_platform_subscriptions")
+TRIGGERS: HassKey[dict[str, str]] = HassKey("triggers")
+
+
+# Basic schemas to sanity check the trigger descriptions,
+# full validation is done by hassfest.triggers
+_FIELD_SCHEMA = vol.Schema(
+    {},
+    extra=vol.ALLOW_EXTRA,
+)
+
+_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Optional("fields"): vol.Schema({str: _FIELD_SCHEMA}),
+    },
+    extra=vol.ALLOW_EXTRA,
+)
+
+
+def starts_with_dot(key: str) -> str:
+    """Check if key starts with dot."""
+    if not key.startswith("."):
+        raise vol.Invalid("Key does not start with .")
+    return key
+
+
+_TRIGGERS_SCHEMA = vol.Schema(
+    {
+        vol.Remove(vol.All(str, starts_with_dot)): object,
+        cv.slug: vol.Any(None, _TRIGGER_SCHEMA),
+    }
+)
+
+
+async def async_setup(hass: HomeAssistant) -> None:
+    """Set up the trigger helper."""
+    hass.data[TRIGGER_DESCRIPTION_CACHE] = {}
+    hass.data[TRIGGER_PLATFORM_SUBSCRIPTIONS] = []
+    hass.data[TRIGGERS] = {}
+    await async_process_integration_platforms(
+        hass, "trigger", _register_trigger_platform, wait_for_platforms=True
+    )
+
+
+@callback
+def async_subscribe_platform_events(
+    hass: HomeAssistant,
+    on_event: Callable[[set[str]], Coroutine[Any, Any, None]],
+) -> Callable[[], None]:
+    """Subscribe to trigger platform events."""
+    trigger_platform_event_subscriptions = hass.data[TRIGGER_PLATFORM_SUBSCRIPTIONS]
+
+    def remove_subscription() -> None:
+        trigger_platform_event_subscriptions.remove(on_event)
+
+    trigger_platform_event_subscriptions.append(on_event)
+    return remove_subscription
+
+
+async def _register_trigger_platform(
+    hass: HomeAssistant, integration_domain: str, platform: TriggerProtocol
+) -> None:
+    """Register a trigger platform."""
+
+    new_triggers: set[str] = set()
+
+    if hasattr(platform, "async_get_triggers"):
+        for trigger_key in await platform.async_get_triggers(hass):
+            hass.data[TRIGGERS][trigger_key] = integration_domain
+            new_triggers.add(trigger_key)
+    elif hasattr(platform, "async_validate_trigger_config") or hasattr(
+        platform, "TRIGGER_SCHEMA"
+    ):
+        hass.data[TRIGGERS][integration_domain] = integration_domain
+        new_triggers.add(integration_domain)
+    else:
+        _LOGGER.debug(
+            "Integration %s does not provide trigger support, skipping",
+            integration_domain,
+        )
+        return
+
+    tasks: list[asyncio.Task[None]] = [
+        create_eager_task(listener(new_triggers))
+        for listener in hass.data[TRIGGER_PLATFORM_SUBSCRIPTIONS]
+    ]
+    await asyncio.gather(*tasks)
+
+
+class Trigger(abc.ABC):
+    """Trigger class."""
+
+    def __init__(self, hass: HomeAssistant, config: ConfigType) -> None:
+        """Initialize trigger."""
+
+    @classmethod
+    @abc.abstractmethod
+    async def async_validate_trigger_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+
+    @abc.abstractmethod
+    async def async_attach_trigger(
+        self,
+        action: TriggerActionType,
+        trigger_info: TriggerInfo,
+    ) -> CALLBACK_TYPE:
+        """Attach a trigger."""
+
 
 class TriggerProtocol(Protocol):
     """Define the format of trigger modules.
 
-    Each module must define either TRIGGER_SCHEMA or async_validate_trigger_config.
+    New implementations should only implement async_get_triggers.
     """
 
+    async def async_get_triggers(self, hass: HomeAssistant) -> dict[str, type[Trigger]]:
+        """Return the triggers provided by this integration."""
+
     TRIGGER_SCHEMA: vol.Schema
 
     async def async_validate_trigger_config(
@@ -219,13 +349,14 @@ class PluggableAction:
 async def _async_get_trigger_platform(
     hass: HomeAssistant, config: ConfigType
 ) -> TriggerProtocol:
-    platform_and_sub_type = config[CONF_PLATFORM].split(".")
+    trigger_key: str = config[CONF_PLATFORM]
+    platform_and_sub_type = trigger_key.split(".")
     platform = platform_and_sub_type[0]
     platform = _PLATFORM_ALIASES.get(platform, platform)
     try:
         integration = await async_get_integration(hass, platform)
     except IntegrationNotFound:
-        raise vol.Invalid(f"Invalid trigger '{platform}' specified") from None
+        raise vol.Invalid(f"Invalid trigger '{trigger_key}' specified") from None
     try:
         return await integration.async_get_platform("trigger")
     except ImportError:
@@ -241,7 +372,13 @@ async def async_validate_trigger_config(
     config = []
     for conf in trigger_config:
         platform = await _async_get_trigger_platform(hass, conf)
-        if hasattr(platform, "async_validate_trigger_config"):
+        if hasattr(platform, "async_get_triggers"):
+            trigger_descriptors = await platform.async_get_triggers(hass)
+            trigger_key: str = conf[CONF_PLATFORM]
+            if not (trigger := trigger_descriptors.get(trigger_key)):
+                raise vol.Invalid(f"Invalid trigger '{trigger_key}' specified")
+            conf = await trigger.async_validate_trigger_config(hass, conf)
+        elif hasattr(platform, "async_validate_trigger_config"):
             conf = await platform.async_validate_trigger_config(hass, conf)
         else:
             conf = platform.TRIGGER_SCHEMA(conf)
@@ -337,13 +474,15 @@ async def async_initialize_triggers(
             trigger_data=trigger_data,
         )
 
-        triggers.append(
-            create_eager_task(
-                platform.async_attach_trigger(
-                    hass, conf, _trigger_action_wrapper(hass, action, conf), info
-                )
-            )
-        )
+        action_wrapper = _trigger_action_wrapper(hass, action, conf)
+        if hasattr(platform, "async_get_triggers"):
+            trigger_descriptors = await platform.async_get_triggers(hass)
+            trigger = trigger_descriptors[conf[CONF_PLATFORM]](hass, conf)
+            coro = trigger.async_attach_trigger(action_wrapper, info)
+        else:
+            coro = platform.async_attach_trigger(hass, conf, action_wrapper, info)
+
+        triggers.append(create_eager_task(coro))
 
     attach_results = await asyncio.gather(*triggers, return_exceptions=True)
     removes: list[Callable[[], None]] = []
@@ -374,3 +513,107 @@ async def async_initialize_triggers(
             remove()
 
     return remove_triggers
+
+
+def _load_triggers_file(hass: HomeAssistant, integration: Integration) -> JSON_TYPE:
+    """Load triggers file for an integration."""
+    try:
+        return cast(
+            JSON_TYPE,
+            _TRIGGERS_SCHEMA(
+                load_yaml_dict(str(integration.file_path / "triggers.yaml"))
+            ),
+        )
+    except FileNotFoundError:
+        _LOGGER.warning(
+            "Unable to find triggers.yaml for the %s integration", integration.domain
+        )
+        return {}
+    except (HomeAssistantError, vol.Invalid) as ex:
+        _LOGGER.warning(
+            "Unable to parse triggers.yaml for the %s integration: %s",
+            integration.domain,
+            ex,
+        )
+        return {}
+
+
+def _load_triggers_files(
+    hass: HomeAssistant, integrations: Iterable[Integration]
+) -> dict[str, JSON_TYPE]:
+    """Load trigger files for multiple integrations."""
+    return {
+        integration.domain: _load_triggers_file(hass, integration)
+        for integration in integrations
+    }
+
+
+async def async_get_all_descriptions(
+    hass: HomeAssistant,
+) -> dict[str, dict[str, Any] | None]:
+    """Return descriptions (i.e. user documentation) for all triggers."""
+    descriptions_cache = hass.data[TRIGGER_DESCRIPTION_CACHE]
+
+    triggers = hass.data[TRIGGERS]
+    # See if there are new triggers not seen before.
+    # Any trigger that we saw before already has an entry in description_cache.
+    all_triggers = set(triggers)
+    previous_all_triggers = set(descriptions_cache)
+    # If the triggers are the same, we can return the cache
+    if previous_all_triggers == all_triggers:
+        return descriptions_cache
+
+    # Files we loaded for missing descriptions
+    new_triggers_descriptions: dict[str, JSON_TYPE] = {}
+    # We try to avoid making a copy in the event the cache is good,
+    # but now we must make a copy in case new triggers get added
+    # while we are loading the missing ones so we do not
+    # add the new ones to the cache without their descriptions
+    triggers = triggers.copy()
+
+    if missing_triggers := all_triggers.difference(descriptions_cache):
+        domains_with_missing_triggers = {
+            triggers[missing_trigger] for missing_trigger in missing_triggers
+        }
+        ints_or_excs = await async_get_integrations(hass, domains_with_missing_triggers)
+        integrations: list[Integration] = []
+        for domain, int_or_exc in ints_or_excs.items():
+            if type(int_or_exc) is Integration and int_or_exc.has_triggers:
+                integrations.append(int_or_exc)
+                continue
+            if TYPE_CHECKING:
+                assert isinstance(int_or_exc, Exception)
+            _LOGGER.debug(
+                "Failed to load triggers.yaml for integration: %s",
+                domain,
+                exc_info=int_or_exc,
+            )
+
+        if integrations:
+            new_triggers_descriptions = await hass.async_add_executor_job(
+                _load_triggers_files, hass, integrations
+            )
+
+    # Make a copy of the old cache and add missing descriptions to it
+    new_descriptions_cache = descriptions_cache.copy()
+    for missing_trigger in missing_triggers:
+        domain = triggers[missing_trigger]
+
+        if (
+            yaml_description := new_triggers_descriptions.get(domain, {}).get(  # type: ignore[union-attr]
+                missing_trigger
+            )
+        ) is None:
+            _LOGGER.debug(
+                "No trigger descriptions found for trigger %s, skipping",
+                missing_trigger,
+            )
+            new_descriptions_cache[missing_trigger] = None
+            continue
+
+        description = {"fields": yaml_description.get("fields", {})}
+
+        new_descriptions_cache[missing_trigger] = description
+
+    hass.data[TRIGGER_DESCRIPTION_CACHE] = new_descriptions_cache
+    return new_descriptions_cache

homeassistant/helpers/typing.py

@@ -41,8 +41,7 @@ def _deprecated_typing_helper(attr: str) -> DeferredDeprecatedAlias:
     """Help to make a DeferredDeprecatedAlias."""
 
     def value_fn() -> Any:
-        # pylint: disable-next=import-outside-toplevel
-        import homeassistant.core
+        import homeassistant.core  # noqa: PLC0415
 
         return getattr(homeassistant.core, attr)
 

homeassistant/loader.py

@@ -291,7 +291,7 @@ def _get_custom_components(hass: HomeAssistant) -> dict[str, Integration]:
         return {}
 
     try:
-        import custom_components  # pylint: disable=import-outside-toplevel
+        import custom_components  # noqa: PLC0415
     except ImportError:
         return {}
 
@@ -857,15 +857,20 @@ class Integration:
         # True.
         return self.manifest.get("import_executor", True)
 
+    @cached_property
+    def has_services(self) -> bool:
+        """Return if the integration has services."""
+        return "services.yaml" in self._top_level_files
+
     @cached_property
     def has_translations(self) -> bool:
         """Return if the integration has translations."""
         return "translations" in self._top_level_files
 
     @cached_property
-    def has_services(self) -> bool:
-        """Return if the integration has services."""
-        return "services.yaml" in self._top_level_files
+    def has_triggers(self) -> bool:
+        """Return if the integration has triggers."""
+        return "triggers.yaml" in self._top_level_files
 
     @property
     def mqtt(self) -> list[str] | None:
@@ -1392,7 +1397,7 @@ async def async_get_integrations(
 
     # Now the rest use resolve_from_root
     if needed:
-        from . import components  # pylint: disable=import-outside-toplevel
+        from . import components  # noqa: PLC0415
 
         integrations = await hass.async_add_executor_job(
             _resolve_integrations_from_root, hass, components, needed
@@ -1728,7 +1733,7 @@ def _async_mount_config_dir(hass: HomeAssistant) -> None:
 
     sys.path.insert(0, hass.config.config_dir)
     with suppress(ImportError):
-        import custom_components  # pylint: disable=import-outside-toplevel  # noqa: F401
+        import custom_components  # noqa: F401, PLC0415
     sys.path.remove(hass.config.config_dir)
     sys.path_importer_cache.pop(hass.config.config_dir, None)
 

homeassistant/package_constraints.txt

@@ -3,12 +3,11 @@
 aiodhcpwatcher==1.2.0
 aiodiscover==2.7.0
 aiodns==3.5.0
-aiofiles==24.1.0
 aiohasupervisor==0.3.1
 aiohttp-asyncmdnsresolver==0.1.1
 aiohttp-fast-zlib==0.3.0
 aiohttp==3.12.13
-aiohttp_cors==0.7.0
+aiohttp_cors==0.8.1
 aiousbwatcher==1.1.1
 aiozoneinfo==0.2.3
 annotatedyaml==0.4.5
@@ -16,11 +15,11 @@ astral==2.2
 async-interrupt==1.2.2
 async-upnp-client==0.44.0
 atomicwrites-homeassistant==1.4.1
-attrs==25.1.0
+attrs==25.3.0
 audioop-lts==0.2.1
 av==13.1.0
-awesomeversion==24.6.0
-bcrypt==4.2.0
+awesomeversion==25.5.0
+bcrypt==4.3.0
 bleak-retry-connector==3.9.0
 bleak==0.22.3
 bluetooth-adapters==0.21.4
@@ -30,23 +29,22 @@ cached-ipaddress==0.10.0
 certifi>=2021.5.30
 ciso8601==2.3.2
 cronsim==2.6
-cryptography==45.0.1
+cryptography==45.0.3
 dbus-fast==2.43.0
 fnv-hash-fast==1.5.0
 go2rtc-client==0.2.1
 ha-ffmpeg==3.2.2
 habluetooth==3.49.0
-hass-nabucasa==0.101.0
+hass-nabucasa==0.104.0
 hassil==2.2.3
 home-assistant-bluetooth==1.13.1
-home-assistant-frontend==20250531.4
-home-assistant-intents==2025.6.10
+home-assistant-frontend==20250626.0
+home-assistant-intents==2025.6.23
 httpx==0.28.1
 ifaddr==0.2.0
 Jinja2==3.1.6
 lru-dict==1.3.0
 mutagen==1.47.0
-numpy==2.2.2
 orjson==3.10.18
 packaging>=23.1
 paho-mqtt==2.1.0
@@ -60,16 +58,16 @@ pyOpenSSL==25.1.0
 pyserial==3.5
 pyspeex-noise==1.0.2
 python-slugify==8.0.4
-PyTurboJPEG==1.7.5
+PyTurboJPEG==1.8.0
 PyYAML==6.0.2
 requests==2.32.4
 securetar==2025.2.1
-SQLAlchemy==2.0.40
+SQLAlchemy==2.0.41
 standard-aifc==3.13.0
 standard-telnetlib==3.13.0
-typing-extensions>=4.13.0,<5.0
+typing-extensions>=4.14.0,<5.0
 ulid-transform==1.4.0
-urllib3>=1.26.5,<2
+urllib3>=2.0
 uv==0.7.1
 voluptuous-openapi==0.1.0
 voluptuous-serialize==2.6.0
@@ -112,16 +110,16 @@ uuid==1000000000.0.0
 # even newer versions seem to introduce new issues, it's useful for us to pin all these
 # requirements so we can directly link HA versions to these library versions.
 anyio==4.9.0
-h11==0.14.0
-httpcore==1.0.7
+h11==0.16.0
+httpcore==1.0.9
 
 # Ensure we have a hyperframe version that works in Python 3.10
 # 5.2.0 fixed a collections abc deprecation
 hyperframe>=5.2.0
 
 # Ensure we run compatible with musllinux build env
-numpy==2.2.2
-pandas~=2.2.3
+numpy==2.3.0
+pandas==2.3.0
 
 # Constrain multidict to avoid typing issues
 # https://github.com/home-assistant/core/pull/67046
@@ -131,7 +129,7 @@ multidict>=6.0.2
 backoff>=2.0
 
 # ensure pydantic version does not float since it might have breaking changes
-pydantic==2.11.3
+pydantic==2.11.7
 
 # Required for Python 3.12.4 compatibility (#119223).
 mashumaro>=3.13.1
@@ -202,6 +200,14 @@ tenacity!=8.4.0
 # TypeError: 'Timeout' object does not support the context manager protocol
 async-timeout==4.0.3
 
+# aiofiles keeps getting downgraded by custom components
+# causing newer methods to not be available and breaking
+# some integrations at startup
+# https://github.com/home-assistant/core/issues/127529
+# https://github.com/home-assistant/core/issues/122508
+# https://github.com/home-assistant/core/issues/118004
+aiofiles>=24.1.0
+
 # multidict < 6.4.0 has memory leaks
 # https://github.com/aio-libs/multidict/issues/1134
 # https://github.com/aio-libs/multidict/issues/1131

homeassistant/scripts/__init__.py

@@ -46,10 +46,8 @@ def run(args: list[str]) -> int:
 
     config_dir = extract_config_dir()
 
-    loop = asyncio.get_event_loop()
-
     if not is_virtual_env():
-        loop.run_until_complete(async_mount_local_lib_path(config_dir))
+        asyncio.run(async_mount_local_lib_path(config_dir))
 
     _pip_kwargs = pip_kwargs(config_dir)
 

homeassistant/scripts/check_config.py

@@ -47,8 +47,7 @@ WARNING_STR = "General Warnings"
 
 def color(the_color, *args, reset=None):
     """Color helper."""
-    # pylint: disable-next=import-outside-toplevel
-    from colorlog.escape_codes import escape_codes, parse_colors
+    from colorlog.escape_codes import escape_codes, parse_colors  # noqa: PLC0415
 
     try:
         if not args:

homeassistant/setup.py

@@ -101,8 +101,7 @@ def async_notify_setup_error(
 
     This method must be run in the event loop.
     """
-    # pylint: disable-next=import-outside-toplevel
-    from .components import persistent_notification
+    from .components import persistent_notification  # noqa: PLC0415
 
     if (errors := hass.data.get(_DATA_PERSISTENT_ERRORS)) is None:
         errors = hass.data[_DATA_PERSISTENT_ERRORS] = {}

homeassistant/strings.json

@@ -53,6 +53,7 @@
         "email": "Email",
         "host": "Host",
         "ip": "IP address",
+        "implementation": "Application Credentials",
         "language": "Language",
         "latitude": "Latitude",
         "llm_hass_api": "Control Home Assistant",
@@ -71,7 +72,8 @@
         "verify_ssl": "Verify SSL certificate"
       },
       "description": {
-        "confirm_setup": "Do you want to start setup?"
+        "confirm_setup": "Do you want to start setup?",
+        "implementation": "The credentials you want to use to authenticate."
       },
       "error": {
         "cannot_connect": "Failed to connect",

homeassistant/util/async_.py

@@ -36,8 +36,7 @@ def create_eager_task[_T](
             # If there is no running loop, create_eager_task is being called from
             # the wrong thread.
             # Late import to avoid circular dependencies
-            # pylint: disable-next=import-outside-toplevel
-            from homeassistant.helpers import frame
+            from homeassistant.helpers import frame  # noqa: PLC0415
 
             frame.report_usage("attempted to create an asyncio task from a thread")
             raise

homeassistant/util/signal_type.pyi

@@ -31,9 +31,8 @@ def _test_signal_type_typing() -> None:  # noqa: PYI048
 
     This is tested during the mypy run. Do not move it to 'tests'!
     """
-    # pylint: disable=import-outside-toplevel
-    from homeassistant.core import HomeAssistant
-    from homeassistant.helpers.dispatcher import (
+    from homeassistant.core import HomeAssistant  # noqa: PLC0415
+    from homeassistant.helpers.dispatcher import (  # noqa: PLC0415
         async_dispatcher_connect,
         async_dispatcher_send,
     )

homeassistant/util/timeout.py

@@ -148,6 +148,7 @@ class _GlobalTaskContext:
         task: asyncio.Task[Any],
         timeout: float,
         cool_down: float,
+        cancel_message: str | None,
     ) -> None:
         """Initialize internal timeout context manager."""
         self._loop: asyncio.AbstractEventLoop = asyncio.get_running_loop()
@@ -161,6 +162,7 @@ class _GlobalTaskContext:
         self._state: _State = _State.INIT
         self._cool_down: float = cool_down
         self._cancelling = 0
+        self._cancel_message = cancel_message
 
     async def __aenter__(self) -> Self:
         self._manager.global_tasks.append(self)
@@ -242,7 +244,9 @@ class _GlobalTaskContext:
         """Cancel own task."""
         if self._task.done():
             return
-        self._task.cancel("Global task timeout")
+        self._task.cancel(
+            f"Global task timeout{': ' + self._cancel_message if self._cancel_message else ''}"
+        )
 
     def pause(self) -> None:
         """Pause timers while it freeze."""
@@ -270,6 +274,7 @@ class _ZoneTaskContext:
         zone: _ZoneTimeoutManager,
         task: asyncio.Task[Any],
         timeout: float,
+        cancel_message: str | None,
     ) -> None:
         """Initialize internal timeout context manager."""
         self._loop: asyncio.AbstractEventLoop = asyncio.get_running_loop()
@@ -280,6 +285,7 @@ class _ZoneTaskContext:
         self._expiration_time: float | None = None
         self._timeout_handler: asyncio.Handle | None = None
         self._cancelling = 0
+        self._cancel_message = cancel_message
 
     @property
     def state(self) -> _State:
@@ -354,7 +360,9 @@ class _ZoneTaskContext:
         # Timeout
         if self._task.done():
             return
-        self._task.cancel("Zone timeout")
+        self._task.cancel(
+            f"Zone timeout{': ' + self._cancel_message if self._cancel_message else ''}"
+        )
 
     def pause(self) -> None:
         """Pause timers while it freeze."""
@@ -486,7 +494,11 @@ class TimeoutManager:
             task.zones_done_signal()
 
     def async_timeout(
-        self, timeout: float, zone_name: str = ZONE_GLOBAL, cool_down: float = 0
+        self,
+        timeout: float,
+        zone_name: str = ZONE_GLOBAL,
+        cool_down: float = 0,
+        cancel_message: str | None = None,
     ) -> _ZoneTaskContext | _GlobalTaskContext:
         """Timeout based on a zone.
 
@@ -497,7 +509,9 @@ class TimeoutManager:
 
         # Global Zone
         if zone_name == ZONE_GLOBAL:
-            return _GlobalTaskContext(self, current_task, timeout, cool_down)
+            return _GlobalTaskContext(
+                self, current_task, timeout, cool_down, cancel_message
+            )
 
         # Zone Handling
         if zone_name in self.zones:
@@ -506,7 +520,7 @@ class TimeoutManager:
             self.zones[zone_name] = zone = _ZoneTimeoutManager(self, zone_name)
 
         # Create Task
-        return _ZoneTaskContext(zone, current_task, timeout)
+        return _ZoneTaskContext(zone, current_task, timeout, cancel_message)
 
     def async_freeze(
         self, zone_name: str = ZONE_GLOBAL