2025.7.3 (#149024)

Co-authored-by: Joakim Plate <elupus@ecce.se>

.github/ISSUE_TEMPLATE/task.yml

@@ -1,51 +0,0 @@
-name: Task
-description: For staff only - Create a task
-type: Task
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## ⚠️ RESTRICTED ACCESS
-
-        **This form is restricted to Open Home Foundation staff, authorized contributors, and integration code owners only.**
-
-        If you are a community member wanting to contribute, please:
-        - For bug reports: Use the [bug report form](https://github.com/home-assistant/core/issues/new?template=bug_report.yml)
-        - For feature requests: Submit to [Feature Requests](https://github.com/orgs/home-assistant/discussions)
-
-        ---
-
-        ### For authorized contributors
-
-        Use this form to create tasks for development work, improvements, or other actionable items that need to be tracked.
-  - type: textarea
-    id: description
-    attributes:
-      label: Task description
-      description: |
-        Provide a clear and detailed description of the task that needs to be accomplished.
-
-        Be specific about what needs to be done, why it's important, and any constraints or requirements.
-      placeholder: |
-        Describe the task, including:
-        - What needs to be done
-        - Why this task is needed
-        - Expected outcome
-        - Any constraints or requirements
-    validations:
-      required: true
-  - type: textarea
-    id: additional_context
-    attributes:
-      label: Additional context
-      description: |
-        Any additional information, links, research, or context that would be helpful.
-
-        Include links to related issues, research, prototypes, roadmap opportunities etc.
-      placeholder: |
-        - Roadmap opportunity: [links]
-        - Feature request: [link]
-        - Technical design documents: [link]
-        - Prototype/mockup: [link]
-    validations:
-      required: false

.github/workflows/ci.yaml

@@ -37,10 +37,10 @@ on:
         type: boolean
 
 env:
-  CACHE_VERSION: 3
+  CACHE_VERSION: 4
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2025.8"
+  HA_SHORT_VERSION: "2025.7"
   DEFAULT_PYTHON: "3.13"
   ALL_PYTHON_VERSIONS: "['3.13']"
   # 10.3 is the oldest supported version

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@v4.2.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.29.2
+        uses: github/codeql-action/init@v3.29.0
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.29.2
+        uses: github/codeql-action/analyze@v3.29.0
         with:
           category: "/language:python"

.github/workflows/restrict-task-creation.yml

@@ -1,84 +0,0 @@
-name: Restrict task creation
-
-# yamllint disable-line rule:truthy
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  check-authorization:
-    runs-on: ubuntu-latest
-    # Only run if this is a Task issue type (from the issue form)
-    if: github.event.issue.issue_type == 'Task'
-    steps:
-      - name: Check if user is authorized
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const issueAuthor = context.payload.issue.user.login;
-
-            // First check if user is an organization member
-            try {
-              await github.rest.orgs.checkMembershipForUser({
-                org: 'home-assistant',
-                username: issueAuthor
-              });
-              console.log(`✅ ${issueAuthor} is an organization member`);
-              return; // Authorized, no need to check further
-            } catch (error) {
-              console.log(`ℹ️ ${issueAuthor} is not an organization member, checking codeowners...`);
-            }
-
-            // If not an org member, check if they're a codeowner
-            try {
-              // Fetch CODEOWNERS file from the repository
-              const { data: codeownersFile } = await github.rest.repos.getContent({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                path: 'CODEOWNERS',
-                ref: 'dev'
-              });
-
-              // Decode the content (it's base64 encoded)
-              const codeownersContent = Buffer.from(codeownersFile.content, 'base64').toString('utf-8');
-
-              // Check if the issue author is mentioned in CODEOWNERS
-              // GitHub usernames in CODEOWNERS are prefixed with @
-              if (codeownersContent.includes(`@${issueAuthor}`)) {
-                console.log(`✅ ${issueAuthor} is a integration code owner`);
-                return; // Authorized
-              }
-            } catch (error) {
-              console.error('Error checking CODEOWNERS:', error);
-            }
-
-            // If we reach here, user is not authorized
-            console.log(`❌ ${issueAuthor} is not authorized to create Task issues`);
-
-            // Close the issue with a comment
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `Hi @${issueAuthor}, thank you for your contribution!\n\n` +
-                    `Task issues are restricted to Open Home Foundation staff, authorized contributors, and integration code owners.\n\n` +
-                    `If you would like to:\n` +
-                    `- Report a bug: Please use the [bug report form](https://github.com/home-assistant/core/issues/new?template=bug_report.yml)\n` +
-                    `- Request a feature: Please submit to [Feature Requests](https://github.com/orgs/home-assistant/discussions)\n\n` +
-                    `If you believe you should have access to create Task issues, please contact the maintainers.`
-            });
-
-            await github.rest.issues.update({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              state: 'closed'
-            });
-
-            // Add a label to indicate this was auto-closed
-            await github.rest.issues.addLabels({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              labels: ['auto-closed']
-            });

.gitignore

@@ -137,8 +137,4 @@ tmp_cache
 .ropeproject
 
 # Will be created from script/split_tests.py
-pytest_buckets.txt
-
-# AI tooling
-.claude
-
+pytest_buckets.txt

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.1
+    rev: v0.12.0
     hooks:
       - id: ruff-check
         args:

CLAUDE.md

@@ -1 +0,0 @@
-.github/copilot-instructions.md

CODEOWNERS

@@ -452,8 +452,8 @@ build.json @home-assistant/supervisor
 /tests/components/eq3btsmart/ @eulemitkeule @dbuezas
 /homeassistant/components/escea/ @lazdavila
 /tests/components/escea/ @lazdavila
-/homeassistant/components/esphome/ @jesserockz @kbx81 @bdraco
-/tests/components/esphome/ @jesserockz @kbx81 @bdraco
+/homeassistant/components/esphome/ @OttoWinter @jesserockz @kbx81 @bdraco
+/tests/components/esphome/ @OttoWinter @jesserockz @kbx81 @bdraco
 /homeassistant/components/eufylife_ble/ @bdr99
 /tests/components/eufylife_ble/ @bdr99
 /homeassistant/components/event/ @home-assistant/core

Dockerfile.dev

@@ -1,7 +1,15 @@
-FROM mcr.microsoft.com/vscode/devcontainers/base:debian
+FROM mcr.microsoft.com/devcontainers/python:1-3.13
 
 SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 
+# Uninstall pre-installed formatting and linting tools
+# They would conflict with our pinned versions
+RUN \
+    pipx uninstall pydocstyle \
+    && pipx uninstall pycodestyle \
+    && pipx uninstall mypy \
+    && pipx uninstall pylint
+
 RUN \
     curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - \
     && apt-get update \
@@ -24,18 +32,21 @@ RUN \
         libxml2 \
         git \
         cmake \
-        autoconf \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
 # Add go2rtc binary
 COPY --from=ghcr.io/alexxit/go2rtc:latest /usr/local/bin/go2rtc /bin/go2rtc
 
+# Install uv
+RUN pip3 install uv
+
 WORKDIR /usr/src
 
-COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
-
-RUN uv python install 3.13.2
+# Setup hass-release
+RUN git clone --depth 1 https://github.com/home-assistant/hass-release \
+    && uv pip install --system -e hass-release/ \
+    && chown -R vscode /usr/src/hass-release/data
 
 USER vscode
 ENV VIRTUAL_ENV="/home/vscode/.local/ha-venv"
@@ -44,10 +55,6 @@ ENV PATH="$VIRTUAL_ENV/bin:$PATH"
 
 WORKDIR /tmp
 
-# Setup hass-release
-RUN git clone --depth 1 https://github.com/home-assistant/hass-release ~/hass-release \
-    && uv pip install -e ~/hass-release/
-
 # Install Python dependencies from requirements
 COPY requirements.txt ./
 COPY homeassistant/package_constraints.txt homeassistant/package_constraints.txt
@@ -58,4 +65,4 @@ RUN uv pip install -r requirements_test.txt
 WORKDIR /workspaces
 
 # Set the default shell to bash instead of sh
-ENV SHELL=/bin/bash
+ENV SHELL /bin/bash

homeassistant/bootstrap.py

@@ -75,6 +75,7 @@ from .core_config import async_process_ha_core_config
 from .exceptions import HomeAssistantError
 from .helpers import (
     area_registry,
+    backup,
     category_registry,
     config_validation as cv,
     device_registry,
@@ -606,7 +607,7 @@ async def async_enable_logging(
     )
     threading.excepthook = lambda args: logging.getLogger().exception(
         "Uncaught thread exception",
-        exc_info=(  # type: ignore[arg-type]
+        exc_info=(  # type: ignore[arg-type]  # noqa: LOG014
             args.exc_type,
             args.exc_value,
             args.exc_traceback,
@@ -879,6 +880,10 @@ async def _async_set_up_integrations(
     if "recorder" in all_domains:
         recorder.async_initialize_recorder(hass)
 
+    # Initialize backup
+    if "backup" in all_domains:
+        backup.async_initialize_backup(hass)
+
     stages: list[tuple[str, set[str], int | None]] = [
         *(
             (name, domain_group, timeout)
@@ -1056,5 +1061,5 @@ async def _async_setup_multi_components(
             _LOGGER.error(
                 "Error setting up integration %s - received exception",
                 domain,
-                exc_info=(type(result), result, result.__traceback__),
+                exc_info=(type(result), result, result.__traceback__),  # noqa: LOG014
             )

homeassistant/components/ai_task/__init__.py

@@ -1,12 +1,11 @@
 """Integration to offer AI tasks to Home Assistant."""
 
 import logging
-from typing import Any
 
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_ENTITY_ID, CONF_DESCRIPTION, CONF_SELECTOR
+from homeassistant.const import ATTR_ENTITY_ID
 from homeassistant.core import (
     HassJobType,
     HomeAssistant,
@@ -15,14 +14,12 @@ from homeassistant.core import (
     SupportsResponse,
     callback,
 )
-from homeassistant.helpers import config_validation as cv, selector, storage
+from homeassistant.helpers import config_validation as cv, storage
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import UNDEFINED, ConfigType, UndefinedType
 
 from .const import (
     ATTR_INSTRUCTIONS,
-    ATTR_REQUIRED,
-    ATTR_STRUCTURE,
     ATTR_TASK_NAME,
     DATA_COMPONENT,
     DATA_PREFERENCES,
@@ -50,27 +47,6 @@ _LOGGER = logging.getLogger(__name__)
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
-STRUCTURE_FIELD_SCHEMA = vol.Schema(
-    {
-        vol.Optional(CONF_DESCRIPTION): str,
-        vol.Optional(ATTR_REQUIRED): bool,
-        vol.Required(CONF_SELECTOR): selector.validate_selector,
-    }
-)
-
-
-def _validate_structure_fields(value: dict[str, Any]) -> vol.Schema:
-    """Validate the structure fields as a voluptuous Schema."""
-    if not isinstance(value, dict):
-        raise vol.Invalid("Structure must be a dictionary")
-    fields = {}
-    for k, v in value.items():
-        field_class = vol.Required if v.get(ATTR_REQUIRED, False) else vol.Optional
-        fields[field_class(k, description=v.get(CONF_DESCRIPTION))] = selector.selector(
-            v[CONF_SELECTOR]
-        )
-    return vol.Schema(fields, extra=vol.PREVENT_EXTRA)
-
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Register the process service."""
@@ -88,10 +64,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                 vol.Required(ATTR_TASK_NAME): cv.string,
                 vol.Optional(ATTR_ENTITY_ID): cv.entity_id,
                 vol.Required(ATTR_INSTRUCTIONS): cv.string,
-                vol.Optional(ATTR_STRUCTURE): vol.All(
-                    vol.Schema({str: STRUCTURE_FIELD_SCHEMA}),
-                    _validate_structure_fields,
-                ),
             }
         ),
         supports_response=SupportsResponse.ONLY,

homeassistant/components/ai_task/const.py

@@ -21,8 +21,6 @@ SERVICE_GENERATE_DATA = "generate_data"
 
 ATTR_INSTRUCTIONS: Final = "instructions"
 ATTR_TASK_NAME: Final = "task_name"
-ATTR_STRUCTURE: Final = "structure"
-ATTR_REQUIRED: Final = "required"
 
 DEFAULT_SYSTEM_PROMPT = (
     "You are a Home Assistant expert and help users with their tasks."

homeassistant/components/ai_task/services.yaml

@@ -17,9 +17,3 @@ generate_data:
           domain: ai_task
           supported_features:
             - ai_task.AITaskEntityFeature.GENERATE_DATA
-    structure:
-      advanced: true
-      required: false
-      example: '{ "name": { "selector": { "text": }, "description": "Name of the user", "required": "True" } } }, "age": { "selector": { "number": }, "description": "Age of the user" } }'
-      selector:
-        object:

homeassistant/components/ai_task/strings.json

@@ -15,10 +15,6 @@
         "entity_id": {
           "name": "Entity ID",
           "description": "Entity ID to run the task on. If not provided, the preferred entity will be used."
-        },
-        "structure": {
-          "name": "Structured output",
-          "description": "When set, the AI Task will output fields with this in structure. The structure is a dictionary where the keys are the field names and the values contain a 'description', a 'selector', and an optional 'required' field."
         }
       }
     }

homeassistant/components/ai_task/task.py

@@ -5,8 +5,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any
 
-import voluptuous as vol
-
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 
@@ -19,7 +17,6 @@ async def async_generate_data(
     task_name: str,
     entity_id: str | None = None,
     instructions: str,
-    structure: vol.Schema | None = None,
 ) -> GenDataTaskResult:
     """Run a task in the AI Task integration."""
     if entity_id is None:
@@ -41,7 +38,6 @@ async def async_generate_data(
         GenDataTask(
             name=task_name,
             instructions=instructions,
-            structure=structure,
         )
     )
 
@@ -56,9 +52,6 @@ class GenDataTask:
     instructions: str
     """Instructions on what needs to be done."""
 
-    structure: vol.Schema | None = None
-    """Optional structure for the data to be generated."""
-
     def __str__(self) -> str:
         """Return task as a string."""
         return f"<GenDataTask {self.name}: {id(self)}>"

homeassistant/components/alexa/entities.py

@@ -505,8 +505,13 @@ class ClimateCapabilities(AlexaEntity):
         ):
             yield AlexaThermostatController(self.hass, self.entity)
             yield AlexaTemperatureSensor(self.hass, self.entity)
-        if self.entity.domain == water_heater.DOMAIN and (
-            supported_features & water_heater.WaterHeaterEntityFeature.OPERATION_MODE
+        if (
+            self.entity.domain == water_heater.DOMAIN
+            and (
+                supported_features
+                & water_heater.WaterHeaterEntityFeature.OPERATION_MODE
+            )
+            and self.entity.attributes.get(water_heater.ATTR_OPERATION_LIST)
         ):
             yield AlexaModeController(
                 self.entity,
@@ -634,7 +639,9 @@ class FanCapabilities(AlexaEntity):
                 self.entity, instance=f"{fan.DOMAIN}.{fan.ATTR_OSCILLATING}"
             )
             force_range_controller = False
-        if supported & fan.FanEntityFeature.PRESET_MODE:
+        if supported & fan.FanEntityFeature.PRESET_MODE and self.entity.attributes.get(
+            fan.ATTR_PRESET_MODES
+        ):
             yield AlexaModeController(
                 self.entity, instance=f"{fan.DOMAIN}.{fan.ATTR_PRESET_MODE}"
             )
@@ -672,7 +679,11 @@ class RemoteCapabilities(AlexaEntity):
         yield AlexaPowerController(self.entity)
         supported = self.entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
         activities = self.entity.attributes.get(remote.ATTR_ACTIVITY_LIST) or []
-        if activities and supported & remote.RemoteEntityFeature.ACTIVITY:
+        if (
+            activities
+            and (supported & remote.RemoteEntityFeature.ACTIVITY)
+            and self.entity.attributes.get(remote.ATTR_ACTIVITY_LIST)
+        ):
             yield AlexaModeController(
                 self.entity, instance=f"{remote.DOMAIN}.{remote.ATTR_ACTIVITY}"
             )
@@ -692,7 +703,9 @@ class HumidifierCapabilities(AlexaEntity):
         """Yield the supported interfaces."""
         yield AlexaPowerController(self.entity)
         supported = self.entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
-        if supported & humidifier.HumidifierEntityFeature.MODES:
+        if (
+            supported & humidifier.HumidifierEntityFeature.MODES
+        ) and self.entity.attributes.get(humidifier.ATTR_AVAILABLE_MODES):
             yield AlexaModeController(
                 self.entity, instance=f"{humidifier.DOMAIN}.{humidifier.ATTR_MODE}"
             )

homeassistant/components/alexa_devices/config_flow.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
 from typing import Any
 
 from aioamazondevices.api import AmazonEchoApi
@@ -11,36 +10,11 @@ import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_CODE, CONF_COUNTRY, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.core import HomeAssistant
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.selector import CountrySelector
 
 from .const import CONF_LOGIN_DATA, DOMAIN
 
-STEP_REAUTH_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_PASSWORD): cv.string,
-        vol.Required(CONF_CODE): cv.string,
-    }
-)
-
-
-async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str, Any]:
-    """Validate the user input allows us to connect."""
-
-    api = AmazonEchoApi(
-        data[CONF_COUNTRY],
-        data[CONF_USERNAME],
-        data[CONF_PASSWORD],
-    )
-
-    try:
-        data = await api.login_mode_interactive(data[CONF_CODE])
-    finally:
-        await api.close()
-
-    return data
-
 
 class AmazonDevicesConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Alexa Devices."""
@@ -51,8 +25,13 @@ class AmazonDevicesConfigFlow(ConfigFlow, domain=DOMAIN):
         """Handle the initial step."""
         errors = {}
         if user_input:
+            client = AmazonEchoApi(
+                user_input[CONF_COUNTRY],
+                user_input[CONF_USERNAME],
+                user_input[CONF_PASSWORD],
+            )
             try:
-                data = await validate_input(self.hass, user_input)
+                data = await client.login_mode_interactive(user_input[CONF_CODE])
             except CannotConnect:
                 errors["base"] = "cannot_connect"
             except CannotAuthenticate:
@@ -67,6 +46,8 @@ class AmazonDevicesConfigFlow(ConfigFlow, domain=DOMAIN):
                     title=user_input[CONF_USERNAME],
                     data=user_input | {CONF_LOGIN_DATA: data},
                 )
+            finally:
+                await client.close()
 
         return self.async_show_form(
             step_id="user",
@@ -82,43 +63,3 @@ class AmazonDevicesConfigFlow(ConfigFlow, domain=DOMAIN):
                 }
             ),
         )
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle reauth flow."""
-        self.context["title_placeholders"] = {CONF_USERNAME: entry_data[CONF_USERNAME]}
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reauth confirm."""
-        errors: dict[str, str] = {}
-
-        reauth_entry = self._get_reauth_entry()
-        entry_data = reauth_entry.data
-
-        if user_input is not None:
-            try:
-                await validate_input(self.hass, {**reauth_entry.data, **user_input})
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except CannotAuthenticate:
-                errors["base"] = "invalid_auth"
-            else:
-                return self.async_update_reload_and_abort(
-                    reauth_entry,
-                    data={
-                        CONF_USERNAME: entry_data[CONF_USERNAME],
-                        CONF_PASSWORD: entry_data[CONF_PASSWORD],
-                        CONF_CODE: user_input[CONF_CODE],
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            description_placeholders={CONF_USERNAME: entry_data[CONF_USERNAME]},
-            data_schema=STEP_REAUTH_DATA_SCHEMA,
-            errors=errors,
-        )

homeassistant/components/alexa_devices/coordinator.py

@@ -12,10 +12,10 @@ from aioamazondevices.exceptions import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_COUNTRY, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.exceptions import ConfigEntryError
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import _LOGGER, CONF_LOGIN_DATA, DOMAIN
+from .const import _LOGGER, CONF_LOGIN_DATA
 
 SCAN_INTERVAL = 30
 
@@ -55,8 +55,4 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
         except (CannotConnect, CannotRetrieveData) as err:
             raise UpdateFailed(f"Error occurred while updating {self.name}") from err
         except CannotAuthenticate as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="invalid_auth",
-                translation_placeholders={"error": repr(err)},
-            ) from err
+            raise ConfigEntryError("Could not authenticate") from err

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "bronze",
-  "requirements": ["aioamazondevices==3.2.2"]
+  "requirements": ["aioamazondevices==3.5.0"]
 }

homeassistant/components/alexa_devices/quality_scale.yaml

@@ -34,7 +34,7 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow: done
+  reauthentication-flow: todo
   test-coverage:
     status: todo
     comment: all tests missing

homeassistant/components/alexa_devices/strings.json

@@ -22,23 +22,12 @@
           "password": "[%key:component::alexa_devices::common::data_description_password%]",
           "code": "[%key:component::alexa_devices::common::data_description_code%]"
         }
-      },
-      "reauth_confirm": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "code": "[%key:component::alexa_devices::common::data_code%]"
-        },
-        "data_description": {
-          "password": "[%key:component::alexa_devices::common::data_description_password%]",
-          "code": "[%key:component::alexa_devices::common::data_description_code%]"
-        }
       }
     },
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "error": {

homeassistant/components/androidtv_remote/__init__.py

@@ -5,18 +5,26 @@ from __future__ import annotations
 from asyncio import timeout
 import logging
 
-from androidtvremote2 import CannotConnect, ConnectionClosed, InvalidAuth
+from androidtvremote2 import (
+    AndroidTVRemote,
+    CannotConnect,
+    ConnectionClosed,
+    InvalidAuth,
+)
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_NAME, EVENT_HOMEASSISTANT_STOP, Platform
 from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 
-from .helpers import AndroidTVRemoteConfigEntry, create_api, get_enable_ime
+from .helpers import create_api, get_enable_ime
 
 _LOGGER = logging.getLogger(__name__)
 
 PLATFORMS: list[Platform] = [Platform.MEDIA_PLAYER, Platform.REMOTE]
 
+AndroidTVRemoteConfigEntry = ConfigEntry[AndroidTVRemote]
+
 
 async def async_setup_entry(
     hass: HomeAssistant, entry: AndroidTVRemoteConfigEntry
@@ -74,17 +82,13 @@ async def async_setup_entry(
     return True
 
 
-async def async_unload_entry(
-    hass: HomeAssistant, entry: AndroidTVRemoteConfigEntry
-) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     _LOGGER.debug("async_unload_entry: %s", entry.data)
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
-async def async_update_options(
-    hass: HomeAssistant, entry: AndroidTVRemoteConfigEntry
-) -> None:
+async def async_update_options(hass: HomeAssistant, entry: ConfigEntry) -> None:
     """Handle options update."""
     _LOGGER.debug(
         "async_update_options: data: %s options: %s", entry.data, entry.options

homeassistant/components/androidtv_remote/config_flow.py

@@ -16,7 +16,7 @@ import voluptuous as vol
 
 from homeassistant.config_entries import (
     SOURCE_REAUTH,
-    SOURCE_RECONFIGURE,
+    ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
     OptionsFlow,
@@ -33,7 +33,7 @@ from homeassistant.helpers.selector import (
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
 from .const import CONF_APP_ICON, CONF_APP_NAME, CONF_APPS, CONF_ENABLE_IME, DOMAIN
-from .helpers import AndroidTVRemoteConfigEntry, create_api, get_enable_ime
+from .helpers import create_api, get_enable_ime
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,6 +41,12 @@ APPS_NEW_ID = "NewApp"
 CONF_APP_DELETE = "app_delete"
 CONF_APP_ID = "app_id"
 
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required("host"): str,
+    }
+)
+
 STEP_PAIR_DATA_SCHEMA = vol.Schema(
     {
         vol.Required("pin"): str,
@@ -61,7 +67,7 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Handle the initial and reconfigure step."""
+        """Handle the initial step."""
         errors: dict[str, str] = {}
         if user_input is not None:
             self.host = user_input[CONF_HOST]
@@ -70,32 +76,15 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
                 await api.async_generate_cert_if_missing()
                 self.name, self.mac = await api.async_get_name_and_mac()
                 await self.async_set_unique_id(format_mac(self.mac))
-                if self.source == SOURCE_RECONFIGURE:
-                    self._abort_if_unique_id_mismatch()
-                    return self.async_update_reload_and_abort(
-                        self._get_reconfigure_entry(),
-                        data={
-                            CONF_HOST: self.host,
-                            CONF_NAME: self.name,
-                            CONF_MAC: self.mac,
-                        },
-                    )
                 self._abort_if_unique_id_configured(updates={CONF_HOST: self.host})
                 return await self._async_start_pair()
             except (CannotConnect, ConnectionClosed):
                 # Likely invalid IP address or device is network unreachable. Stay
                 # in the user step allowing the user to enter a different host.
                 errors["base"] = "cannot_connect"
-        else:
-            user_input = {}
-        default_host = user_input.get(CONF_HOST, vol.UNDEFINED)
-        if self.source == SOURCE_RECONFIGURE:
-            default_host = self._get_reconfigure_entry().data[CONF_HOST]
         return self.async_show_form(
-            step_id="reconfigure" if self.source == SOURCE_RECONFIGURE else "user",
-            data_schema=vol.Schema(
-                {vol.Required(CONF_HOST, default=default_host): str}
-            ),
+            step_id="user",
+            data_schema=STEP_USER_DATA_SCHEMA,
             errors=errors,
         )
 
@@ -228,16 +217,10 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration."""
-        return await self.async_step_user(user_input)
-
     @staticmethod
     @callback
     def async_get_options_flow(
-        config_entry: AndroidTVRemoteConfigEntry,
+        config_entry: ConfigEntry,
     ) -> AndroidTVRemoteOptionsFlowHandler:
         """Create the options flow."""
         return AndroidTVRemoteOptionsFlowHandler(config_entry)
@@ -246,7 +229,7 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
 class AndroidTVRemoteOptionsFlowHandler(OptionsFlow):
     """Android TV Remote options flow."""
 
-    def __init__(self, config_entry: AndroidTVRemoteConfigEntry) -> None:
+    def __init__(self, config_entry: ConfigEntry) -> None:
         """Initialize options flow."""
         self._apps: dict[str, Any] = dict(config_entry.options.get(CONF_APPS, {}))
         self._conf_app_id: str | None = None

homeassistant/components/androidtv_remote/diagnostics.py

@@ -8,7 +8,7 @@ from homeassistant.components.diagnostics import async_redact_data
 from homeassistant.const import CONF_HOST, CONF_MAC
 from homeassistant.core import HomeAssistant
 
-from .helpers import AndroidTVRemoteConfigEntry
+from . import AndroidTVRemoteConfigEntry
 
 TO_REDACT = {CONF_HOST, CONF_MAC}
 

homeassistant/components/androidtv_remote/entity.py

@@ -6,6 +6,7 @@ from typing import Any
 
 from androidtvremote2 import AndroidTVRemote, ConnectionClosed
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_MAC, CONF_NAME
 from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
@@ -13,7 +14,6 @@ from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, Device
 from homeassistant.helpers.entity import Entity
 
 from .const import CONF_APPS, DOMAIN
-from .helpers import AndroidTVRemoteConfigEntry
 
 
 class AndroidTVRemoteBaseEntity(Entity):
@@ -23,9 +23,7 @@ class AndroidTVRemoteBaseEntity(Entity):
     _attr_has_entity_name = True
     _attr_should_poll = False
 
-    def __init__(
-        self, api: AndroidTVRemote, config_entry: AndroidTVRemoteConfigEntry
-    ) -> None:
+    def __init__(self, api: AndroidTVRemote, config_entry: ConfigEntry) -> None:
         """Initialize the entity."""
         self._api = api
         self._host = config_entry.data[CONF_HOST]

homeassistant/components/androidtv_remote/helpers.py

@@ -10,8 +10,6 @@ from homeassistant.helpers.storage import STORAGE_DIR
 
 from .const import CONF_ENABLE_IME, CONF_ENABLE_IME_DEFAULT_VALUE
 
-AndroidTVRemoteConfigEntry = ConfigEntry[AndroidTVRemote]
-
 
 def create_api(hass: HomeAssistant, host: str, enable_ime: bool) -> AndroidTVRemote:
     """Create an AndroidTVRemote instance."""
@@ -25,6 +23,6 @@ def create_api(hass: HomeAssistant, host: str, enable_ime: bool) -> AndroidTVRem
     )
 
 
-def get_enable_ime(entry: AndroidTVRemoteConfigEntry) -> bool:
+def get_enable_ime(entry: ConfigEntry) -> bool:
     """Get value of enable_ime option or its default value."""
     return entry.options.get(CONF_ENABLE_IME, CONF_ENABLE_IME_DEFAULT_VALUE)

homeassistant/components/androidtv_remote/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["androidtvremote2"],
-  "requirements": ["androidtvremote2==0.2.3"],
+  "requirements": ["androidtvremote2==0.2.2"],
   "zeroconf": ["_androidtvremote2._tcp.local."]
 }

homeassistant/components/androidtv_remote/media_player.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 from typing import Any
 
-from androidtvremote2 import AndroidTVRemote, ConnectionClosed, VolumeInfo
+from androidtvremote2 import AndroidTVRemote, ConnectionClosed
 
 from homeassistant.components.media_player import (
     BrowseMedia,
@@ -20,9 +20,9 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
+from . import AndroidTVRemoteConfigEntry
 from .const import CONF_APP_ICON, CONF_APP_NAME, DOMAIN
 from .entity import AndroidTVRemoteBaseEntity
-from .helpers import AndroidTVRemoteConfigEntry
 
 PARALLEL_UPDATES = 0
 
@@ -75,11 +75,13 @@ class AndroidTVRemoteMediaPlayerEntity(AndroidTVRemoteBaseEntity, MediaPlayerEnt
             else current_app
         )
 
-    def _update_volume_info(self, volume_info: VolumeInfo) -> None:
+    def _update_volume_info(self, volume_info: dict[str, str | bool]) -> None:
         """Update volume info."""
         if volume_info.get("max"):
-            self._attr_volume_level = volume_info["level"] / volume_info["max"]
-            self._attr_is_volume_muted = volume_info["muted"]
+            self._attr_volume_level = int(volume_info["level"]) / int(
+                volume_info["max"]
+            )
+            self._attr_is_volume_muted = bool(volume_info["muted"])
         else:
             self._attr_volume_level = None
             self._attr_is_volume_muted = None
@@ -91,7 +93,7 @@ class AndroidTVRemoteMediaPlayerEntity(AndroidTVRemoteBaseEntity, MediaPlayerEnt
         self.async_write_ha_state()
 
     @callback
-    def _volume_info_updated(self, volume_info: VolumeInfo) -> None:
+    def _volume_info_updated(self, volume_info: dict[str, str | bool]) -> None:
         """Update the state when the volume info changes."""
         self._update_volume_info(volume_info)
         self.async_write_ha_state()
@@ -100,10 +102,8 @@ class AndroidTVRemoteMediaPlayerEntity(AndroidTVRemoteBaseEntity, MediaPlayerEnt
         """Register callbacks."""
         await super().async_added_to_hass()
 
-        if self._api.current_app is not None:
-            self._update_current_app(self._api.current_app)
-        if self._api.volume_info is not None:
-            self._update_volume_info(self._api.volume_info)
+        self._update_current_app(self._api.current_app)
+        self._update_volume_info(self._api.volume_info)
 
         self._api.add_current_app_updated_callback(self._current_app_updated)
         self._api.add_volume_info_updated_callback(self._volume_info_updated)

homeassistant/components/androidtv_remote/remote.py

@@ -20,9 +20,9 @@ from homeassistant.components.remote import (
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
+from . import AndroidTVRemoteConfigEntry
 from .const import CONF_APP_NAME
 from .entity import AndroidTVRemoteBaseEntity
-from .helpers import AndroidTVRemoteConfigEntry
 
 PARALLEL_UPDATES = 0
 
@@ -63,8 +63,7 @@ class AndroidTVRemoteEntity(AndroidTVRemoteBaseEntity, RemoteEntity):
         self._attr_activity_list = [
             app.get(CONF_APP_NAME, "") for app in self._apps.values()
         ]
-        if self._api.current_app is not None:
-            self._update_current_app(self._api.current_app)
+        self._update_current_app(self._api.current_app)
         self._api.add_current_app_updated_callback(self._current_app_updated)
 
     async def async_will_remove_from_hass(self) -> None:

homeassistant/components/androidtv_remote/strings.json

@@ -6,18 +6,6 @@
         "description": "Enter the IP address of the Android TV you want to add to Home Assistant. It will turn on and a pairing code will be displayed on it that you will need to enter in the next screen.",
         "data": {
           "host": "[%key:common::config_flow::data::host%]"
-        },
-        "data_description": {
-          "host": "The hostname or IP address of the Android TV device."
-        }
-      },
-      "reconfigure": {
-        "description": "Update the IP address of this previously configured Android TV device.",
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]"
-        },
-        "data_description": {
-          "host": "The hostname or IP address of the Android TV device."
         }
       },
       "zeroconf_confirm": {
@@ -28,9 +16,6 @@
         "description": "Enter the pairing code displayed on the Android TV ({name}).",
         "data": {
           "pin": "[%key:common::config_flow::data::pin%]"
-        },
-        "data_description": {
-          "pin": "Pairing code displayed on the Android TV device."
         }
       },
       "reauth_confirm": {
@@ -47,9 +32,7 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
-      "unique_id_mismatch": "Please ensure you reconfigure against the same device."
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     }
   },
   "options": {
@@ -57,11 +40,7 @@
       "init": {
         "data": {
           "apps": "Configure applications list",
-          "enable_ime": "Enable IME"
-        },
-        "data_description": {
-          "apps": "Here you can define the list of applications, specify names and icons that will be displayed in the UI.",
-          "enable_ime": "Enable this option to be able to get the current app name and send text as keyboard input. Disable it for devices that show 'Use keyboard on mobile device screen' instead of the on-screen keyboard."
+          "enable_ime": "Enable IME. Needed for getting the current app. Disable for devices that show 'Use keyboard on mobile device screen' instead of the on screen keyboard."
         }
       },
       "apps": {
@@ -74,10 +53,8 @@
           "app_delete": "Check to delete this application"
         },
         "data_description": {
-          "app_name": "Name of the application as you would like it to be displayed in Home Assistant.",
           "app_id": "E.g. com.plexapp.android for https://play.google.com/store/apps/details?id=com.plexapp.android",
-          "app_icon": "Image URL. From the Play Store app page, right click on the icon and select 'Copy image address' and then paste it here. Alternatively, download the image, upload it under /config/www/ and use the URL /local/filename",
-          "app_delete": "Check this box to delete the application from the list."
+          "app_icon": "Image URL. From the Play Store app page, right click on the icon and select 'Copy image address' and then paste it here. Alternatively, download the image, upload it under /config/www/ and use the URL /local/filename"
         }
       }
     }

homeassistant/components/anthropic/__init__.py

@@ -61,8 +61,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) ->
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-    entry.async_on_unload(entry.add_update_listener(async_update_options))
-
     return True
 
 
@@ -71,13 +69,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
-async def async_update_options(
-    hass: HomeAssistant, entry: AnthropicConfigEntry
-) -> None:
-    """Update options."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
 async def async_migrate_integration(hass: HomeAssistant) -> None:
     """Migrate integration entry structure."""
 

homeassistant/components/anthropic/conversation.py

@@ -1,17 +1,69 @@
 """Conversation support for Anthropic."""
 
-from typing import Literal
+from collections.abc import AsyncGenerator, Callable, Iterable
+import json
+from typing import Any, Literal, cast
+
+import anthropic
+from anthropic import AsyncStream
+from anthropic._types import NOT_GIVEN
+from anthropic.types import (
+    InputJSONDelta,
+    MessageDeltaUsage,
+    MessageParam,
+    MessageStreamEvent,
+    RawContentBlockDeltaEvent,
+    RawContentBlockStartEvent,
+    RawContentBlockStopEvent,
+    RawMessageDeltaEvent,
+    RawMessageStartEvent,
+    RawMessageStopEvent,
+    RedactedThinkingBlock,
+    RedactedThinkingBlockParam,
+    SignatureDelta,
+    TextBlock,
+    TextBlockParam,
+    TextDelta,
+    ThinkingBlock,
+    ThinkingBlockParam,
+    ThinkingConfigDisabledParam,
+    ThinkingConfigEnabledParam,
+    ThinkingDelta,
+    ToolParam,
+    ToolResultBlockParam,
+    ToolUseBlock,
+    ToolUseBlockParam,
+    Usage,
+)
+from voluptuous_openapi import convert
 
 from homeassistant.components import conversation
-from homeassistant.config_entries import ConfigSubentry
+from homeassistant.config_entries import ConfigEntry, ConfigSubentry
 from homeassistant.const import CONF_LLM_HASS_API, MATCH_ALL
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import intent
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import device_registry as dr, intent, llm
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AnthropicConfigEntry
-from .const import CONF_PROMPT, DOMAIN
-from .entity import AnthropicBaseLLMEntity
+from .const import (
+    CONF_CHAT_MODEL,
+    CONF_MAX_TOKENS,
+    CONF_PROMPT,
+    CONF_TEMPERATURE,
+    CONF_THINKING_BUDGET,
+    DOMAIN,
+    LOGGER,
+    MIN_THINKING_BUDGET,
+    RECOMMENDED_CHAT_MODEL,
+    RECOMMENDED_MAX_TOKENS,
+    RECOMMENDED_TEMPERATURE,
+    RECOMMENDED_THINKING_BUDGET,
+    THINKING_MODELS,
+)
+
+# Max number of back and forth with the LLM to generate a response
+MAX_TOOL_ITERATIONS = 10
 
 
 async def async_setup_entry(
@@ -30,10 +82,253 @@ async def async_setup_entry(
         )
 
 
+def _format_tool(
+    tool: llm.Tool, custom_serializer: Callable[[Any], Any] | None
+) -> ToolParam:
+    """Format tool specification."""
+    return ToolParam(
+        name=tool.name,
+        description=tool.description or "",
+        input_schema=convert(tool.parameters, custom_serializer=custom_serializer),
+    )
+
+
+def _convert_content(
+    chat_content: Iterable[conversation.Content],
+) -> list[MessageParam]:
+    """Transform HA chat_log content into Anthropic API format."""
+    messages: list[MessageParam] = []
+
+    for content in chat_content:
+        if isinstance(content, conversation.ToolResultContent):
+            tool_result_block = ToolResultBlockParam(
+                type="tool_result",
+                tool_use_id=content.tool_call_id,
+                content=json.dumps(content.tool_result),
+            )
+            if not messages or messages[-1]["role"] != "user":
+                messages.append(
+                    MessageParam(
+                        role="user",
+                        content=[tool_result_block],
+                    )
+                )
+            elif isinstance(messages[-1]["content"], str):
+                messages[-1]["content"] = [
+                    TextBlockParam(type="text", text=messages[-1]["content"]),
+                    tool_result_block,
+                ]
+            else:
+                messages[-1]["content"].append(tool_result_block)  # type: ignore[attr-defined]
+        elif isinstance(content, conversation.UserContent):
+            # Combine consequent user messages
+            if not messages or messages[-1]["role"] != "user":
+                messages.append(
+                    MessageParam(
+                        role="user",
+                        content=content.content,
+                    )
+                )
+            elif isinstance(messages[-1]["content"], str):
+                messages[-1]["content"] = [
+                    TextBlockParam(type="text", text=messages[-1]["content"]),
+                    TextBlockParam(type="text", text=content.content),
+                ]
+            else:
+                messages[-1]["content"].append(  # type: ignore[attr-defined]
+                    TextBlockParam(type="text", text=content.content)
+                )
+        elif isinstance(content, conversation.AssistantContent):
+            # Combine consequent assistant messages
+            if not messages or messages[-1]["role"] != "assistant":
+                messages.append(
+                    MessageParam(
+                        role="assistant",
+                        content=[],
+                    )
+                )
+
+            if content.content:
+                messages[-1]["content"].append(  # type: ignore[union-attr]
+                    TextBlockParam(type="text", text=content.content)
+                )
+            if content.tool_calls:
+                messages[-1]["content"].extend(  # type: ignore[union-attr]
+                    [
+                        ToolUseBlockParam(
+                            type="tool_use",
+                            id=tool_call.id,
+                            name=tool_call.tool_name,
+                            input=tool_call.tool_args,
+                        )
+                        for tool_call in content.tool_calls
+                    ]
+                )
+        else:
+            # Note: We don't pass SystemContent here as its passed to the API as the prompt
+            raise TypeError(f"Unexpected content type: {type(content)}")
+
+    return messages
+
+
+async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
+    chat_log: conversation.ChatLog,
+    result: AsyncStream[MessageStreamEvent],
+    messages: list[MessageParam],
+) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
+    """Transform the response stream into HA format.
+
+    A typical stream of responses might look something like the following:
+    - RawMessageStartEvent with no content
+    - RawContentBlockStartEvent with an empty ThinkingBlock (if extended thinking is enabled)
+    - RawContentBlockDeltaEvent with a ThinkingDelta
+    - RawContentBlockDeltaEvent with a ThinkingDelta
+    - RawContentBlockDeltaEvent with a ThinkingDelta
+    - ...
+    - RawContentBlockDeltaEvent with a SignatureDelta
+    - RawContentBlockStopEvent
+    - RawContentBlockStartEvent with a RedactedThinkingBlock (occasionally)
+    - RawContentBlockStopEvent (RedactedThinkingBlock does not have a delta)
+    - RawContentBlockStartEvent with an empty TextBlock
+    - RawContentBlockDeltaEvent with a TextDelta
+    - RawContentBlockDeltaEvent with a TextDelta
+    - RawContentBlockDeltaEvent with a TextDelta
+    - ...
+    - RawContentBlockStopEvent
+    - RawContentBlockStartEvent with ToolUseBlock specifying the function name
+    - RawContentBlockDeltaEvent with a InputJSONDelta
+    - RawContentBlockDeltaEvent with a InputJSONDelta
+    - ...
+    - RawContentBlockStopEvent
+    - RawMessageDeltaEvent with a stop_reason='tool_use'
+    - RawMessageStopEvent(type='message_stop')
+
+    Each message could contain multiple blocks of the same type.
+    """
+    if result is None:
+        raise TypeError("Expected a stream of messages")
+
+    current_message: MessageParam | None = None
+    current_block: (
+        TextBlockParam
+        | ToolUseBlockParam
+        | ThinkingBlockParam
+        | RedactedThinkingBlockParam
+        | None
+    ) = None
+    current_tool_args: str
+    input_usage: Usage | None = None
+
+    async for response in result:
+        LOGGER.debug("Received response: %s", response)
+
+        if isinstance(response, RawMessageStartEvent):
+            if response.message.role != "assistant":
+                raise ValueError("Unexpected message role")
+            current_message = MessageParam(role=response.message.role, content=[])
+            input_usage = response.message.usage
+        elif isinstance(response, RawContentBlockStartEvent):
+            if isinstance(response.content_block, ToolUseBlock):
+                current_block = ToolUseBlockParam(
+                    type="tool_use",
+                    id=response.content_block.id,
+                    name=response.content_block.name,
+                    input="",
+                )
+                current_tool_args = ""
+            elif isinstance(response.content_block, TextBlock):
+                current_block = TextBlockParam(
+                    type="text", text=response.content_block.text
+                )
+                yield {"role": "assistant"}
+                if response.content_block.text:
+                    yield {"content": response.content_block.text}
+            elif isinstance(response.content_block, ThinkingBlock):
+                current_block = ThinkingBlockParam(
+                    type="thinking",
+                    thinking=response.content_block.thinking,
+                    signature=response.content_block.signature,
+                )
+            elif isinstance(response.content_block, RedactedThinkingBlock):
+                current_block = RedactedThinkingBlockParam(
+                    type="redacted_thinking", data=response.content_block.data
+                )
+                LOGGER.debug(
+                    "Some of Claude’s internal reasoning has been automatically "
+                    "encrypted for safety reasons. This doesn’t affect the quality of "
+                    "responses"
+                )
+        elif isinstance(response, RawContentBlockDeltaEvent):
+            if current_block is None:
+                raise ValueError("Unexpected delta without a block")
+            if isinstance(response.delta, InputJSONDelta):
+                current_tool_args += response.delta.partial_json
+            elif isinstance(response.delta, TextDelta):
+                text_block = cast(TextBlockParam, current_block)
+                text_block["text"] += response.delta.text
+                yield {"content": response.delta.text}
+            elif isinstance(response.delta, ThinkingDelta):
+                thinking_block = cast(ThinkingBlockParam, current_block)
+                thinking_block["thinking"] += response.delta.thinking
+            elif isinstance(response.delta, SignatureDelta):
+                thinking_block = cast(ThinkingBlockParam, current_block)
+                thinking_block["signature"] += response.delta.signature
+        elif isinstance(response, RawContentBlockStopEvent):
+            if current_block is None:
+                raise ValueError("Unexpected stop event without a current block")
+            if current_block["type"] == "tool_use":
+                # tool block
+                tool_args = json.loads(current_tool_args) if current_tool_args else {}
+                current_block["input"] = tool_args
+                yield {
+                    "tool_calls": [
+                        llm.ToolInput(
+                            id=current_block["id"],
+                            tool_name=current_block["name"],
+                            tool_args=tool_args,
+                        )
+                    ]
+                }
+            elif current_block["type"] == "thinking":
+                # thinking block
+                LOGGER.debug("Thinking: %s", current_block["thinking"])
+
+            if current_message is None:
+                raise ValueError("Unexpected stop event without a current message")
+            current_message["content"].append(current_block)  # type: ignore[union-attr]
+            current_block = None
+        elif isinstance(response, RawMessageDeltaEvent):
+            if (usage := response.usage) is not None:
+                chat_log.async_trace(_create_token_stats(input_usage, usage))
+            if response.delta.stop_reason == "refusal":
+                raise HomeAssistantError("Potential policy violation detected")
+        elif isinstance(response, RawMessageStopEvent):
+            if current_message is not None:
+                messages.append(current_message)
+                current_message = None
+
+
+def _create_token_stats(
+    input_usage: Usage | None, response_usage: MessageDeltaUsage
+) -> dict[str, Any]:
+    """Create token stats for conversation agent tracing."""
+    input_tokens = 0
+    cached_input_tokens = 0
+    if input_usage:
+        input_tokens = input_usage.input_tokens
+        cached_input_tokens = input_usage.cache_creation_input_tokens or 0
+    output_tokens = response_usage.output_tokens
+    return {
+        "stats": {
+            "input_tokens": input_tokens,
+            "cached_input_tokens": cached_input_tokens,
+            "output_tokens": output_tokens,
+        }
+    }
+
+
 class AnthropicConversationEntity(
-    conversation.ConversationEntity,
-    conversation.AbstractConversationAgent,
-    AnthropicBaseLLMEntity,
+    conversation.ConversationEntity, conversation.AbstractConversationAgent
 ):
     """Anthropic conversation agent."""
 
@@ -41,7 +336,17 @@ class AnthropicConversationEntity(
 
     def __init__(self, entry: AnthropicConfigEntry, subentry: ConfigSubentry) -> None:
         """Initialize the agent."""
-        super().__init__(entry, subentry)
+        self.entry = entry
+        self.subentry = subentry
+        self._attr_name = subentry.title
+        self._attr_unique_id = subentry.subentry_id
+        self._attr_device_info = dr.DeviceInfo(
+            identifiers={(DOMAIN, subentry.subentry_id)},
+            name=subentry.title,
+            manufacturer="Anthropic",
+            model="Claude",
+            entry_type=dr.DeviceEntryType.SERVICE,
+        )
         if self.subentry.data.get(CONF_LLM_HASS_API):
             self._attr_supported_features = (
                 conversation.ConversationEntityFeature.CONTROL
@@ -52,6 +357,13 @@ class AnthropicConversationEntity(
         """Return a list of supported languages."""
         return MATCH_ALL
 
+    async def async_added_to_hass(self) -> None:
+        """When entity is added to Home Assistant."""
+        await super().async_added_to_hass()
+        self.entry.async_on_unload(
+            self.entry.add_update_listener(self._async_entry_update_listener)
+        )
+
     async def _async_handle_message(
         self,
         user_input: conversation.ConversationInput,
@@ -82,3 +394,77 @@ class AnthropicConversationEntity(
             conversation_id=chat_log.conversation_id,
             continue_conversation=chat_log.continue_conversation,
         )
+
+    async def _async_handle_chat_log(
+        self,
+        chat_log: conversation.ChatLog,
+    ) -> None:
+        """Generate an answer for the chat log."""
+        options = self.subentry.data
+
+        tools: list[ToolParam] | None = None
+        if chat_log.llm_api:
+            tools = [
+                _format_tool(tool, chat_log.llm_api.custom_serializer)
+                for tool in chat_log.llm_api.tools
+            ]
+
+        system = chat_log.content[0]
+        if not isinstance(system, conversation.SystemContent):
+            raise TypeError("First message must be a system message")
+        messages = _convert_content(chat_log.content[1:])
+
+        client = self.entry.runtime_data
+
+        thinking_budget = options.get(CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET)
+        model = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
+
+        # To prevent infinite loops, we limit the number of iterations
+        for _iteration in range(MAX_TOOL_ITERATIONS):
+            model_args = {
+                "model": model,
+                "messages": messages,
+                "tools": tools or NOT_GIVEN,
+                "max_tokens": options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS),
+                "system": system.content,
+                "stream": True,
+            }
+            if model in THINKING_MODELS and thinking_budget >= MIN_THINKING_BUDGET:
+                model_args["thinking"] = ThinkingConfigEnabledParam(
+                    type="enabled", budget_tokens=thinking_budget
+                )
+            else:
+                model_args["thinking"] = ThinkingConfigDisabledParam(type="disabled")
+                model_args["temperature"] = options.get(
+                    CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
+                )
+
+            try:
+                stream = await client.messages.create(**model_args)
+            except anthropic.AnthropicError as err:
+                raise HomeAssistantError(
+                    f"Sorry, I had a problem talking to Anthropic: {err}"
+                ) from err
+
+            messages.extend(
+                _convert_content(
+                    [
+                        content
+                        async for content in chat_log.async_add_delta_content_stream(
+                            self.entity_id,
+                            _transform_stream(chat_log, stream, messages),
+                        )
+                        if not isinstance(content, conversation.AssistantContent)
+                    ]
+                )
+            )
+
+            if not chat_log.unresponded_tool_results:
+                break
+
+    async def _async_entry_update_listener(
+        self, hass: HomeAssistant, entry: ConfigEntry
+    ) -> None:
+        """Handle options update."""
+        # Reload as we update device info + entity name + supported features
+        await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/anthropic/entity.py

@@ -1,393 +0,0 @@
-"""Base entity for Anthropic."""
-
-from collections.abc import AsyncGenerator, Callable, Iterable
-import json
-from typing import Any, cast
-
-import anthropic
-from anthropic import AsyncStream
-from anthropic._types import NOT_GIVEN
-from anthropic.types import (
-    InputJSONDelta,
-    MessageDeltaUsage,
-    MessageParam,
-    MessageStreamEvent,
-    RawContentBlockDeltaEvent,
-    RawContentBlockStartEvent,
-    RawContentBlockStopEvent,
-    RawMessageDeltaEvent,
-    RawMessageStartEvent,
-    RawMessageStopEvent,
-    RedactedThinkingBlock,
-    RedactedThinkingBlockParam,
-    SignatureDelta,
-    TextBlock,
-    TextBlockParam,
-    TextDelta,
-    ThinkingBlock,
-    ThinkingBlockParam,
-    ThinkingConfigDisabledParam,
-    ThinkingConfigEnabledParam,
-    ThinkingDelta,
-    ToolParam,
-    ToolResultBlockParam,
-    ToolUseBlock,
-    ToolUseBlockParam,
-    Usage,
-)
-from voluptuous_openapi import convert
-
-from homeassistant.components import conversation
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import device_registry as dr, llm
-from homeassistant.helpers.entity import Entity
-
-from . import AnthropicConfigEntry
-from .const import (
-    CONF_CHAT_MODEL,
-    CONF_MAX_TOKENS,
-    CONF_TEMPERATURE,
-    CONF_THINKING_BUDGET,
-    DOMAIN,
-    LOGGER,
-    MIN_THINKING_BUDGET,
-    RECOMMENDED_CHAT_MODEL,
-    RECOMMENDED_MAX_TOKENS,
-    RECOMMENDED_TEMPERATURE,
-    RECOMMENDED_THINKING_BUDGET,
-    THINKING_MODELS,
-)
-
-# Max number of back and forth with the LLM to generate a response
-MAX_TOOL_ITERATIONS = 10
-
-
-def _format_tool(
-    tool: llm.Tool, custom_serializer: Callable[[Any], Any] | None
-) -> ToolParam:
-    """Format tool specification."""
-    return ToolParam(
-        name=tool.name,
-        description=tool.description or "",
-        input_schema=convert(tool.parameters, custom_serializer=custom_serializer),
-    )
-
-
-def _convert_content(
-    chat_content: Iterable[conversation.Content],
-) -> list[MessageParam]:
-    """Transform HA chat_log content into Anthropic API format."""
-    messages: list[MessageParam] = []
-
-    for content in chat_content:
-        if isinstance(content, conversation.ToolResultContent):
-            tool_result_block = ToolResultBlockParam(
-                type="tool_result",
-                tool_use_id=content.tool_call_id,
-                content=json.dumps(content.tool_result),
-            )
-            if not messages or messages[-1]["role"] != "user":
-                messages.append(
-                    MessageParam(
-                        role="user",
-                        content=[tool_result_block],
-                    )
-                )
-            elif isinstance(messages[-1]["content"], str):
-                messages[-1]["content"] = [
-                    TextBlockParam(type="text", text=messages[-1]["content"]),
-                    tool_result_block,
-                ]
-            else:
-                messages[-1]["content"].append(tool_result_block)  # type: ignore[attr-defined]
-        elif isinstance(content, conversation.UserContent):
-            # Combine consequent user messages
-            if not messages or messages[-1]["role"] != "user":
-                messages.append(
-                    MessageParam(
-                        role="user",
-                        content=content.content,
-                    )
-                )
-            elif isinstance(messages[-1]["content"], str):
-                messages[-1]["content"] = [
-                    TextBlockParam(type="text", text=messages[-1]["content"]),
-                    TextBlockParam(type="text", text=content.content),
-                ]
-            else:
-                messages[-1]["content"].append(  # type: ignore[attr-defined]
-                    TextBlockParam(type="text", text=content.content)
-                )
-        elif isinstance(content, conversation.AssistantContent):
-            # Combine consequent assistant messages
-            if not messages or messages[-1]["role"] != "assistant":
-                messages.append(
-                    MessageParam(
-                        role="assistant",
-                        content=[],
-                    )
-                )
-
-            if content.content:
-                messages[-1]["content"].append(  # type: ignore[union-attr]
-                    TextBlockParam(type="text", text=content.content)
-                )
-            if content.tool_calls:
-                messages[-1]["content"].extend(  # type: ignore[union-attr]
-                    [
-                        ToolUseBlockParam(
-                            type="tool_use",
-                            id=tool_call.id,
-                            name=tool_call.tool_name,
-                            input=tool_call.tool_args,
-                        )
-                        for tool_call in content.tool_calls
-                    ]
-                )
-        else:
-            # Note: We don't pass SystemContent here as its passed to the API as the prompt
-            raise TypeError(f"Unexpected content type: {type(content)}")
-
-    return messages
-
-
-async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
-    chat_log: conversation.ChatLog,
-    result: AsyncStream[MessageStreamEvent],
-    messages: list[MessageParam],
-) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
-    """Transform the response stream into HA format.
-
-    A typical stream of responses might look something like the following:
-    - RawMessageStartEvent with no content
-    - RawContentBlockStartEvent with an empty ThinkingBlock (if extended thinking is enabled)
-    - RawContentBlockDeltaEvent with a ThinkingDelta
-    - RawContentBlockDeltaEvent with a ThinkingDelta
-    - RawContentBlockDeltaEvent with a ThinkingDelta
-    - ...
-    - RawContentBlockDeltaEvent with a SignatureDelta
-    - RawContentBlockStopEvent
-    - RawContentBlockStartEvent with a RedactedThinkingBlock (occasionally)
-    - RawContentBlockStopEvent (RedactedThinkingBlock does not have a delta)
-    - RawContentBlockStartEvent with an empty TextBlock
-    - RawContentBlockDeltaEvent with a TextDelta
-    - RawContentBlockDeltaEvent with a TextDelta
-    - RawContentBlockDeltaEvent with a TextDelta
-    - ...
-    - RawContentBlockStopEvent
-    - RawContentBlockStartEvent with ToolUseBlock specifying the function name
-    - RawContentBlockDeltaEvent with a InputJSONDelta
-    - RawContentBlockDeltaEvent with a InputJSONDelta
-    - ...
-    - RawContentBlockStopEvent
-    - RawMessageDeltaEvent with a stop_reason='tool_use'
-    - RawMessageStopEvent(type='message_stop')
-
-    Each message could contain multiple blocks of the same type.
-    """
-    if result is None:
-        raise TypeError("Expected a stream of messages")
-
-    current_message: MessageParam | None = None
-    current_block: (
-        TextBlockParam
-        | ToolUseBlockParam
-        | ThinkingBlockParam
-        | RedactedThinkingBlockParam
-        | None
-    ) = None
-    current_tool_args: str
-    input_usage: Usage | None = None
-
-    async for response in result:
-        LOGGER.debug("Received response: %s", response)
-
-        if isinstance(response, RawMessageStartEvent):
-            if response.message.role != "assistant":
-                raise ValueError("Unexpected message role")
-            current_message = MessageParam(role=response.message.role, content=[])
-            input_usage = response.message.usage
-        elif isinstance(response, RawContentBlockStartEvent):
-            if isinstance(response.content_block, ToolUseBlock):
-                current_block = ToolUseBlockParam(
-                    type="tool_use",
-                    id=response.content_block.id,
-                    name=response.content_block.name,
-                    input="",
-                )
-                current_tool_args = ""
-            elif isinstance(response.content_block, TextBlock):
-                current_block = TextBlockParam(
-                    type="text", text=response.content_block.text
-                )
-                yield {"role": "assistant"}
-                if response.content_block.text:
-                    yield {"content": response.content_block.text}
-            elif isinstance(response.content_block, ThinkingBlock):
-                current_block = ThinkingBlockParam(
-                    type="thinking",
-                    thinking=response.content_block.thinking,
-                    signature=response.content_block.signature,
-                )
-            elif isinstance(response.content_block, RedactedThinkingBlock):
-                current_block = RedactedThinkingBlockParam(
-                    type="redacted_thinking", data=response.content_block.data
-                )
-                LOGGER.debug(
-                    "Some of Claude’s internal reasoning has been automatically "
-                    "encrypted for safety reasons. This doesn’t affect the quality of "
-                    "responses"
-                )
-        elif isinstance(response, RawContentBlockDeltaEvent):
-            if current_block is None:
-                raise ValueError("Unexpected delta without a block")
-            if isinstance(response.delta, InputJSONDelta):
-                current_tool_args += response.delta.partial_json
-            elif isinstance(response.delta, TextDelta):
-                text_block = cast(TextBlockParam, current_block)
-                text_block["text"] += response.delta.text
-                yield {"content": response.delta.text}
-            elif isinstance(response.delta, ThinkingDelta):
-                thinking_block = cast(ThinkingBlockParam, current_block)
-                thinking_block["thinking"] += response.delta.thinking
-            elif isinstance(response.delta, SignatureDelta):
-                thinking_block = cast(ThinkingBlockParam, current_block)
-                thinking_block["signature"] += response.delta.signature
-        elif isinstance(response, RawContentBlockStopEvent):
-            if current_block is None:
-                raise ValueError("Unexpected stop event without a current block")
-            if current_block["type"] == "tool_use":
-                # tool block
-                tool_args = json.loads(current_tool_args) if current_tool_args else {}
-                current_block["input"] = tool_args
-                yield {
-                    "tool_calls": [
-                        llm.ToolInput(
-                            id=current_block["id"],
-                            tool_name=current_block["name"],
-                            tool_args=tool_args,
-                        )
-                    ]
-                }
-            elif current_block["type"] == "thinking":
-                # thinking block
-                LOGGER.debug("Thinking: %s", current_block["thinking"])
-
-            if current_message is None:
-                raise ValueError("Unexpected stop event without a current message")
-            current_message["content"].append(current_block)  # type: ignore[union-attr]
-            current_block = None
-        elif isinstance(response, RawMessageDeltaEvent):
-            if (usage := response.usage) is not None:
-                chat_log.async_trace(_create_token_stats(input_usage, usage))
-            if response.delta.stop_reason == "refusal":
-                raise HomeAssistantError("Potential policy violation detected")
-        elif isinstance(response, RawMessageStopEvent):
-            if current_message is not None:
-                messages.append(current_message)
-                current_message = None
-
-
-def _create_token_stats(
-    input_usage: Usage | None, response_usage: MessageDeltaUsage
-) -> dict[str, Any]:
-    """Create token stats for conversation agent tracing."""
-    input_tokens = 0
-    cached_input_tokens = 0
-    if input_usage:
-        input_tokens = input_usage.input_tokens
-        cached_input_tokens = input_usage.cache_creation_input_tokens or 0
-    output_tokens = response_usage.output_tokens
-    return {
-        "stats": {
-            "input_tokens": input_tokens,
-            "cached_input_tokens": cached_input_tokens,
-            "output_tokens": output_tokens,
-        }
-    }
-
-
-class AnthropicBaseLLMEntity(Entity):
-    """Anthropic base LLM entity."""
-
-    def __init__(self, entry: AnthropicConfigEntry, subentry: ConfigSubentry) -> None:
-        """Initialize the entity."""
-        self.entry = entry
-        self.subentry = subentry
-        self._attr_name = subentry.title
-        self._attr_unique_id = subentry.subentry_id
-        self._attr_device_info = dr.DeviceInfo(
-            identifiers={(DOMAIN, subentry.subentry_id)},
-            name=subentry.title,
-            manufacturer="Anthropic",
-            model="Claude",
-            entry_type=dr.DeviceEntryType.SERVICE,
-        )
-
-    async def _async_handle_chat_log(
-        self,
-        chat_log: conversation.ChatLog,
-    ) -> None:
-        """Generate an answer for the chat log."""
-        options = self.subentry.data
-
-        tools: list[ToolParam] | None = None
-        if chat_log.llm_api:
-            tools = [
-                _format_tool(tool, chat_log.llm_api.custom_serializer)
-                for tool in chat_log.llm_api.tools
-            ]
-
-        system = chat_log.content[0]
-        if not isinstance(system, conversation.SystemContent):
-            raise TypeError("First message must be a system message")
-        messages = _convert_content(chat_log.content[1:])
-
-        client = self.entry.runtime_data
-
-        thinking_budget = options.get(CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET)
-        model = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
-
-        # To prevent infinite loops, we limit the number of iterations
-        for _iteration in range(MAX_TOOL_ITERATIONS):
-            model_args = {
-                "model": model,
-                "messages": messages,
-                "tools": tools or NOT_GIVEN,
-                "max_tokens": options.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS),
-                "system": system.content,
-                "stream": True,
-            }
-            if model in THINKING_MODELS and thinking_budget >= MIN_THINKING_BUDGET:
-                model_args["thinking"] = ThinkingConfigEnabledParam(
-                    type="enabled", budget_tokens=thinking_budget
-                )
-            else:
-                model_args["thinking"] = ThinkingConfigDisabledParam(type="disabled")
-                model_args["temperature"] = options.get(
-                    CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
-                )
-
-            try:
-                stream = await client.messages.create(**model_args)
-            except anthropic.AnthropicError as err:
-                raise HomeAssistantError(
-                    f"Sorry, I had a problem talking to Anthropic: {err}"
-                ) from err
-
-            messages.extend(
-                _convert_content(
-                    [
-                        content
-                        async for content in chat_log.async_add_delta_content_stream(
-                            self.entity_id,
-                            _transform_stream(chat_log, stream, messages),
-                        )
-                        if not isinstance(content, conversation.AssistantContent)
-                    ]
-                )
-            )
-
-            if not chat_log.unresponded_tool_results:
-                break

homeassistant/components/assist_satellite/__init__.py

@@ -72,7 +72,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                 {
                     vol.Optional("message"): str,
                     vol.Optional("media_id"): _media_id_validator,
-                    vol.Optional("preannounce", default=True): bool,
+                    vol.Optional("preannounce"): bool,
                     vol.Optional("preannounce_media_id"): _media_id_validator,
                 }
             ),
@@ -89,7 +89,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                 {
                     vol.Optional("start_message"): str,
                     vol.Optional("start_media_id"): _media_id_validator,
-                    vol.Optional("preannounce", default=True): bool,
+                    vol.Optional("preannounce"): bool,
                     vol.Optional("preannounce_media_id"): _media_id_validator,
                     vol.Optional("extra_system_prompt"): str,
                 }
@@ -114,7 +114,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         ask_question_args = {
             "question": call.data.get("question"),
             "question_media_id": call.data.get("question_media_id"),
-            "preannounce": call.data.get("preannounce", True),
+            "preannounce": call.data.get("preannounce", False),
             "answers": call.data.get("answers"),
         }
 
@@ -137,7 +137,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                 vol.Required(ATTR_ENTITY_ID): cv.entity_domain(DOMAIN),
                 vol.Optional("question"): str,
                 vol.Optional("question_media_id"): _media_id_validator,
-                vol.Optional("preannounce", default=True): bool,
+                vol.Optional("preannounce"): bool,
                 vol.Optional("preannounce_media_id"): _media_id_validator,
                 vol.Optional("answers"): [
                     {

homeassistant/components/backup/__init__.py

@@ -2,9 +2,9 @@
 
 from homeassistant.config_entries import SOURCE_SYSTEM
 from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import config_validation as cv, discovery_flow
+from homeassistant.helpers.backup import DATA_BACKUP
 from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.typing import ConfigType
 
@@ -37,6 +37,7 @@ from .manager import (
     IdleEvent,
     IncorrectPasswordError,
     ManagerBackup,
+    ManagerStateEvent,
     NewBackup,
     RestoreBackupEvent,
     RestoreBackupStage,
@@ -44,7 +45,6 @@ from .manager import (
     WrittenBackup,
 )
 from .models import AddonInfo, AgentBackup, BackupNotFound, Folder
-from .services import async_setup_services
 from .util import suggested_filename, suggested_filename_from_name_date
 from .websocket import async_register_websocket_handlers
 
@@ -71,12 +71,12 @@ __all__ = [
     "IncorrectPasswordError",
     "LocalBackupAgent",
     "ManagerBackup",
+    "ManagerStateEvent",
     "NewBackup",
     "RestoreBackupEvent",
     "RestoreBackupStage",
     "RestoreBackupState",
     "WrittenBackup",
-    "async_get_manager",
     "suggested_filename",
     "suggested_filename_from_name_date",
 ]
@@ -103,11 +103,39 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     backup_manager = BackupManager(hass, reader_writer)
     hass.data[DATA_MANAGER] = backup_manager
-    await backup_manager.async_setup()
+    try:
+        await backup_manager.async_setup()
+    except Exception as err:
+        hass.data[DATA_BACKUP].manager_ready.set_exception(err)
+        raise
+    else:
+        hass.data[DATA_BACKUP].manager_ready.set_result(None)
 
     async_register_websocket_handlers(hass, with_hassio)
 
-    async_setup_services(hass)
+    async def async_handle_create_service(call: ServiceCall) -> None:
+        """Service handler for creating backups."""
+        agent_id = list(backup_manager.local_backup_agents)[0]
+        await backup_manager.async_create_backup(
+            agent_ids=[agent_id],
+            include_addons=None,
+            include_all_addons=False,
+            include_database=True,
+            include_folders=None,
+            include_homeassistant=True,
+            name=None,
+            password=None,
+        )
+
+    async def async_handle_create_automatic_service(call: ServiceCall) -> None:
+        """Service handler for creating automatic backups."""
+        await backup_manager.async_create_automatic_backup()
+
+    if not with_hassio:
+        hass.services.async_register(DOMAIN, "create", async_handle_create_service)
+    hass.services.async_register(
+        DOMAIN, "create_automatic", async_handle_create_automatic_service
+    )
 
     async_register_http_views(hass)
 
@@ -136,15 +164,3 @@ async def async_setup_entry(hass: HomeAssistant, entry: BackupConfigEntry) -> bo
 async def async_unload_entry(hass: HomeAssistant, entry: BackupConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-
-@callback
-def async_get_manager(hass: HomeAssistant) -> BackupManager:
-    """Get the backup manager instance.
-
-    Raises HomeAssistantError if the backup integration is not available.
-    """
-    if DATA_MANAGER not in hass.data:
-        raise HomeAssistantError("Backup integration is not available")
-
-    return hass.data[DATA_MANAGER]

homeassistant/components/backup/basic_websocket.py

@@ -0,0 +1,38 @@
+"""Websocket commands for the Backup integration."""
+
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components import websocket_api
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.backup import async_subscribe_events
+
+from .const import DATA_MANAGER
+from .manager import ManagerStateEvent
+
+
+@callback
+def async_register_websocket_handlers(hass: HomeAssistant) -> None:
+    """Register websocket commands."""
+    websocket_api.async_register_command(hass, handle_subscribe_events)
+
+
+@websocket_api.require_admin
+@websocket_api.websocket_command({vol.Required("type"): "backup/subscribe_events"})
+@websocket_api.async_response
+async def handle_subscribe_events(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Subscribe to backup events."""
+
+    def on_event(event: ManagerStateEvent) -> None:
+        connection.send_message(websocket_api.event_message(msg["id"], event))
+
+    if DATA_MANAGER in hass.data:
+        manager = hass.data[DATA_MANAGER]
+        on_event(manager.last_event)
+    connection.subscriptions[msg["id"]] = async_subscribe_events(hass, on_event)
+    connection.send_result(msg["id"])

homeassistant/components/backup/coordinator.py

@@ -8,6 +8,10 @@ from datetime import datetime
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.backup import (
+    async_subscribe_events,
+    async_subscribe_platform_events,
+)
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .const import DOMAIN, LOGGER
@@ -52,8 +56,8 @@ class BackupDataUpdateCoordinator(DataUpdateCoordinator[BackupCoordinatorData]):
             update_interval=None,
         )
         self.unsubscribe: list[Callable[[], None]] = [
-            backup_manager.async_subscribe_events(self._on_event),
-            backup_manager.async_subscribe_platform_events(self._on_event),
+            async_subscribe_events(hass, self._on_event),
+            async_subscribe_platform_events(hass, self._on_event),
         ]
 
         self.backup_manager = backup_manager

homeassistant/components/backup/manager.py

@@ -36,6 +36,7 @@ from homeassistant.helpers import (
     issue_registry as ir,
     start,
 )
+from homeassistant.helpers.backup import DATA_BACKUP
 from homeassistant.helpers.json import json_bytes
 from homeassistant.util import dt as dt_util, json as json_util
 
@@ -371,10 +372,12 @@ class BackupManager:
         # Latest backup event and backup event subscribers
         self.last_event: ManagerStateEvent = BlockedEvent()
         self.last_action_event: ManagerStateEvent | None = None
-        self._backup_event_subscriptions: list[Callable[[ManagerStateEvent], None]] = []
-        self._backup_platform_event_subscriptions: list[
-            Callable[[BackupPlatformEvent], None]
-        ] = []
+        self._backup_event_subscriptions = hass.data[
+            DATA_BACKUP
+        ].backup_event_subscriptions
+        self._backup_platform_event_subscriptions = hass.data[
+            DATA_BACKUP
+        ].backup_platform_event_subscriptions
 
     async def async_setup(self) -> None:
         """Set up the backup manager."""
@@ -1382,32 +1385,6 @@ class BackupManager:
         for subscription in self._backup_event_subscriptions:
             subscription(event)
 
-    @callback
-    def async_subscribe_events(
-        self,
-        on_event: Callable[[ManagerStateEvent], None],
-    ) -> Callable[[], None]:
-        """Subscribe events."""
-
-        def remove_subscription() -> None:
-            self._backup_event_subscriptions.remove(on_event)
-
-        self._backup_event_subscriptions.append(on_event)
-        return remove_subscription
-
-    @callback
-    def async_subscribe_platform_events(
-        self,
-        on_event: Callable[[BackupPlatformEvent], None],
-    ) -> Callable[[], None]:
-        """Subscribe to backup platform events."""
-
-        def remove_subscription() -> None:
-            self._backup_platform_event_subscriptions.remove(on_event)
-
-        self._backup_platform_event_subscriptions.append(on_event)
-        return remove_subscription
-
     def _create_automatic_backup_failed_issue(
         self, translation_key: str, translation_placeholders: dict[str, str] | None
     ) -> None:

homeassistant/components/backup/onboarding.py

@@ -19,14 +19,9 @@ from homeassistant.components.onboarding import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.backup import async_get_manager as async_get_backup_manager
 
-from . import (
-    BackupManager,
-    Folder,
-    IncorrectPasswordError,
-    async_get_manager,
-    http as backup_http,
-)
+from . import BackupManager, Folder, IncorrectPasswordError, http as backup_http
 
 if TYPE_CHECKING:
     from homeassistant.components.onboarding import OnboardingStoreData
@@ -59,7 +54,7 @@ def with_backup_manager[_ViewT: BaseOnboardingView, **_P](
         if self._data["done"]:
             raise HTTPUnauthorized
 
-        manager = async_get_manager(request.app[KEY_HASS])
+        manager = await async_get_backup_manager(request.app[KEY_HASS])
         return await func(self, manager, request, *args, **kwargs)
 
     return with_backup

homeassistant/components/backup/services.py

@@ -1,36 +0,0 @@
-"""The Backup integration."""
-
-from homeassistant.core import HomeAssistant, ServiceCall
-from homeassistant.helpers.hassio import is_hassio
-
-from .const import DATA_MANAGER, DOMAIN
-
-
-async def _async_handle_create_service(call: ServiceCall) -> None:
-    """Service handler for creating backups."""
-    backup_manager = call.hass.data[DATA_MANAGER]
-    agent_id = list(backup_manager.local_backup_agents)[0]
-    await backup_manager.async_create_backup(
-        agent_ids=[agent_id],
-        include_addons=None,
-        include_all_addons=False,
-        include_database=True,
-        include_folders=None,
-        include_homeassistant=True,
-        name=None,
-        password=None,
-    )
-
-
-async def _async_handle_create_automatic_service(call: ServiceCall) -> None:
-    """Service handler for creating automatic backups."""
-    await call.hass.data[DATA_MANAGER].async_create_automatic_backup()
-
-
-def async_setup_services(hass: HomeAssistant) -> None:
-    """Register services."""
-    if not is_hassio(hass):
-        hass.services.async_register(DOMAIN, "create", _async_handle_create_service)
-    hass.services.async_register(
-        DOMAIN, "create_automatic", _async_handle_create_automatic_service
-    )

homeassistant/components/backup/websocket.py

@@ -10,11 +10,7 @@ from homeassistant.helpers import config_validation as cv
 
 from .config import Day, ScheduleRecurrence
 from .const import DATA_MANAGER, LOGGER
-from .manager import (
-    DecryptOnDowloadNotSupported,
-    IncorrectPasswordError,
-    ManagerStateEvent,
-)
+from .manager import DecryptOnDowloadNotSupported, IncorrectPasswordError
 from .models import BackupNotFound, Folder
 
 
@@ -34,7 +30,6 @@ def async_register_websocket_handlers(hass: HomeAssistant, with_hassio: bool) ->
     websocket_api.async_register_command(hass, handle_create_with_automatic_settings)
     websocket_api.async_register_command(hass, handle_delete)
     websocket_api.async_register_command(hass, handle_restore)
-    websocket_api.async_register_command(hass, handle_subscribe_events)
 
     websocket_api.async_register_command(hass, handle_config_info)
     websocket_api.async_register_command(hass, handle_config_update)
@@ -422,22 +417,3 @@ def handle_config_update(
     changes.pop("type")
     manager.config.update(**changes)
     connection.send_result(msg["id"])
-
-
-@websocket_api.require_admin
-@websocket_api.websocket_command({vol.Required("type"): "backup/subscribe_events"})
-@websocket_api.async_response
-async def handle_subscribe_events(
-    hass: HomeAssistant,
-    connection: websocket_api.ActiveConnection,
-    msg: dict[str, Any],
-) -> None:
-    """Subscribe to backup events."""
-
-    def on_event(event: ManagerStateEvent) -> None:
-        connection.send_message(websocket_api.event_message(msg["id"], event))
-
-    manager = hass.data[DATA_MANAGER]
-    on_event(manager.last_event)
-    connection.subscriptions[msg["id"]] = manager.async_subscribe_events(on_event)
-    connection.send_result(msg["id"])

homeassistant/components/bosch_alarm/__init__.py

@@ -14,7 +14,7 @@ from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
 from homeassistant.helpers.typing import ConfigType
 
 from .const import CONF_INSTALLER_CODE, CONF_USER_CODE, DOMAIN
-from .services import async_setup_services
+from .services import setup_services
 from .types import BoschAlarmConfigEntry
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
@@ -29,7 +29,7 @@ PLATFORMS: list[Platform] = [
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up bosch alarm services."""
-    async_setup_services(hass)
+    setup_services(hass)
     return True
 
 

homeassistant/components/bosch_alarm/services.py

@@ -9,7 +9,7 @@ from typing import Any
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntryState
-from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.util import dt as dt_util
@@ -66,8 +66,7 @@ async def async_set_panel_date(call: ServiceCall) -> None:
         ) from err
 
 
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
+def setup_services(hass: HomeAssistant) -> None:
     """Set up the services for the bosch alarm integration."""
 
     hass.services.async_register(

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==0.105.0"],
+  "requirements": ["hass-nabucasa==0.106.0"],
   "single_config_entry": true
 }

homeassistant/components/compensation/__init__.py

@@ -6,18 +6,11 @@ from operator import itemgetter
 import numpy as np
 import voluptuous as vol
 
-from homeassistant.components.sensor import (
-    CONF_STATE_CLASS,
-    DEVICE_CLASSES_SCHEMA as SENSOR_DEVICE_CLASSES_SCHEMA,
-    DOMAIN as SENSOR_DOMAIN,
-    STATE_CLASSES_SCHEMA as SENSOR_STATE_CLASSES_SCHEMA,
-)
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.const import (
     CONF_ATTRIBUTE,
-    CONF_DEVICE_CLASS,
     CONF_MAXIMUM,
     CONF_MINIMUM,
-    CONF_NAME,
     CONF_SOURCE,
     CONF_UNIQUE_ID,
     CONF_UNIT_OF_MEASUREMENT,
@@ -57,23 +50,20 @@ def datapoints_greater_than_degree(value: dict) -> dict:
 
 COMPENSATION_SCHEMA = vol.Schema(
     {
-        vol.Optional(CONF_ATTRIBUTE): cv.string,
+        vol.Required(CONF_SOURCE): cv.entity_id,
         vol.Required(CONF_DATAPOINTS): [
             vol.ExactSequence([vol.Coerce(float), vol.Coerce(float)])
         ],
+        vol.Optional(CONF_UNIQUE_ID): cv.string,
+        vol.Optional(CONF_ATTRIBUTE): cv.string,
+        vol.Optional(CONF_UPPER_LIMIT, default=False): cv.boolean,
+        vol.Optional(CONF_LOWER_LIMIT, default=False): cv.boolean,
+        vol.Optional(CONF_PRECISION, default=DEFAULT_PRECISION): cv.positive_int,
         vol.Optional(CONF_DEGREE, default=DEFAULT_DEGREE): vol.All(
             vol.Coerce(int),
             vol.Range(min=1, max=7),
         ),
-        vol.Optional(CONF_DEVICE_CLASS): SENSOR_DEVICE_CLASSES_SCHEMA,
-        vol.Optional(CONF_LOWER_LIMIT, default=False): cv.boolean,
-        vol.Optional(CONF_NAME): cv.string,
-        vol.Optional(CONF_PRECISION, default=DEFAULT_PRECISION): cv.positive_int,
-        vol.Required(CONF_SOURCE): cv.entity_id,
-        vol.Optional(CONF_STATE_CLASS): SENSOR_STATE_CLASSES_SCHEMA,
-        vol.Optional(CONF_UNIQUE_ID): cv.string,
         vol.Optional(CONF_UNIT_OF_MEASUREMENT): cv.string,
-        vol.Optional(CONF_UPPER_LIMIT, default=False): cv.boolean,
     }
 )
 

homeassistant/components/compensation/sensor.py

@@ -7,23 +7,15 @@ from typing import Any
 
 import numpy as np
 
-from homeassistant.components.sensor import (
-    ATTR_STATE_CLASS,
-    CONF_STATE_CLASS,
-    SensorEntity,
-)
+from homeassistant.components.sensor import SensorEntity
 from homeassistant.const import (
-    ATTR_DEVICE_CLASS,
     ATTR_UNIT_OF_MEASUREMENT,
     CONF_ATTRIBUTE,
-    CONF_DEVICE_CLASS,
     CONF_MAXIMUM,
     CONF_MINIMUM,
-    CONF_NAME,
     CONF_SOURCE,
     CONF_UNIQUE_ID,
     CONF_UNIT_OF_MEASUREMENT,
-    STATE_UNAVAILABLE,
     STATE_UNKNOWN,
 )
 from homeassistant.core import (
@@ -67,13 +59,24 @@ async def async_setup_platform(
 
     source: str = conf[CONF_SOURCE]
     attribute: str | None = conf.get(CONF_ATTRIBUTE)
-    if not (name := conf.get(CONF_NAME)):
-        name = f"{DEFAULT_NAME} {source}"
-        if attribute is not None:
-            name = f"{name} {attribute}"
+    name = f"{DEFAULT_NAME} {source}"
+    if attribute is not None:
+        name = f"{name} {attribute}"
 
     async_add_entities(
-        [CompensationSensor(conf.get(CONF_UNIQUE_ID), name, source, attribute, conf)]
+        [
+            CompensationSensor(
+                conf.get(CONF_UNIQUE_ID),
+                name,
+                source,
+                attribute,
+                conf[CONF_PRECISION],
+                conf[CONF_POLYNOMIAL],
+                conf.get(CONF_UNIT_OF_MEASUREMENT),
+                conf[CONF_MINIMUM],
+                conf[CONF_MAXIMUM],
+            )
+        ]
     )
 
 
@@ -88,27 +91,23 @@ class CompensationSensor(SensorEntity):
         name: str,
         source: str,
         attribute: str | None,
-        config: dict[str, Any],
+        precision: int,
+        polynomial: np.poly1d,
+        unit_of_measurement: str | None,
+        minimum: tuple[float, float] | None,
+        maximum: tuple[float, float] | None,
     ) -> None:
         """Initialize the Compensation sensor."""
-
-        self._attr_name = name
         self._source_entity_id = source
+        self._precision = precision
         self._source_attribute = attribute
-
-        self._precision = config[CONF_PRECISION]
-        self._attr_native_unit_of_measurement = config.get(CONF_UNIT_OF_MEASUREMENT)
-
-        polynomial: np.poly1d = config[CONF_POLYNOMIAL]
+        self._attr_native_unit_of_measurement = unit_of_measurement
         self._poly = polynomial
         self._coefficients = polynomial.coefficients.tolist()
-
         self._attr_unique_id = unique_id
-        self._minimum = config[CONF_MINIMUM]
-        self._maximum = config[CONF_MAXIMUM]
-
-        self._attr_device_class = config.get(CONF_DEVICE_CLASS)
-        self._attr_state_class = config.get(CONF_STATE_CLASS)
+        self._attr_name = name
+        self._minimum = minimum
+        self._maximum = maximum
 
     async def async_added_to_hass(self) -> None:
         """Handle added to Hass."""
@@ -138,40 +137,13 @@ class CompensationSensor(SensorEntity):
         """Handle sensor state changes."""
         new_state: State | None
         if (new_state := event.data["new_state"]) is None:
-            _LOGGER.warning(
-                "While updating compensation %s, the new_state is None", self.name
-            )
-            self._attr_native_value = None
-            self.async_write_ha_state()
             return
 
-        if new_state.state == STATE_UNKNOWN:
-            self._attr_native_value = None
-            self.async_write_ha_state()
-            return
-
-        if new_state.state == STATE_UNAVAILABLE:
-            self._attr_available = False
-            self.async_write_ha_state()
-            return
-
-        self._attr_available = True
-
         if self.native_unit_of_measurement is None and self._source_attribute is None:
             self._attr_native_unit_of_measurement = new_state.attributes.get(
                 ATTR_UNIT_OF_MEASUREMENT
             )
 
-        if self._attr_device_class is None and (
-            device_class := new_state.attributes.get(ATTR_DEVICE_CLASS)
-        ):
-            self._attr_device_class = device_class
-
-        if self._attr_state_class is None and (
-            state_class := new_state.attributes.get(ATTR_STATE_CLASS)
-        ):
-            self._attr_state_class = state_class
-
         if self._source_attribute:
             value = new_state.attributes.get(self._source_attribute)
         else:

homeassistant/components/coolmaster/__init__.py

@@ -5,9 +5,8 @@ from pycoolmasternet_async import CoolMasterNet
 from homeassistant.const import CONF_HOST, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr
 
-from .const import CONF_SWING_SUPPORT, DOMAIN
+from .const import CONF_SWING_SUPPORT
 from .coordinator import CoolmasterConfigEntry, CoolmasterDataUpdateCoordinator
 
 PLATFORMS = [Platform.BINARY_SENSOR, Platform.BUTTON, Platform.CLIMATE, Platform.SENSOR]
@@ -49,14 +48,3 @@ async def async_setup_entry(hass: HomeAssistant, entry: CoolmasterConfigEntry) -
 async def async_unload_entry(hass: HomeAssistant, entry: CoolmasterConfigEntry) -> bool:
     """Unload a Coolmaster config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-
-async def async_remove_config_entry_device(
-    hass: HomeAssistant,
-    config_entry: CoolmasterConfigEntry,
-    device_entry: dr.DeviceEntry,
-) -> bool:
-    """Remove a config entry from a device."""
-    return not device_entry.identifiers.intersection(
-        (DOMAIN, unit_id) for unit_id in config_entry.runtime_data.data
-    )

homeassistant/components/demo/vacuum.py

@@ -19,7 +19,10 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 SUPPORT_MINIMAL_SERVICES = VacuumEntityFeature.TURN_ON | VacuumEntityFeature.TURN_OFF
 
 SUPPORT_BASIC_SERVICES = (
-    VacuumEntityFeature.STATE | VacuumEntityFeature.START | VacuumEntityFeature.STOP
+    VacuumEntityFeature.STATE
+    | VacuumEntityFeature.START
+    | VacuumEntityFeature.STOP
+    | VacuumEntityFeature.BATTERY
 )
 
 SUPPORT_MOST_SERVICES = (
@@ -28,6 +31,7 @@ SUPPORT_MOST_SERVICES = (
     | VacuumEntityFeature.STOP
     | VacuumEntityFeature.PAUSE
     | VacuumEntityFeature.RETURN_HOME
+    | VacuumEntityFeature.BATTERY
     | VacuumEntityFeature.FAN_SPEED
 )
 
@@ -42,6 +46,7 @@ SUPPORT_ALL_SERVICES = (
     | VacuumEntityFeature.SEND_COMMAND
     | VacuumEntityFeature.LOCATE
     | VacuumEntityFeature.STATUS
+    | VacuumEntityFeature.BATTERY
     | VacuumEntityFeature.LOCATE
     | VacuumEntityFeature.MAP
     | VacuumEntityFeature.CLEAN_SPOT
@@ -85,6 +90,12 @@ class StateDemoVacuum(StateVacuumEntity):
         self._attr_activity = VacuumActivity.DOCKED
         self._fan_speed = FAN_SPEEDS[1]
         self._cleaned_area: float = 0
+        self._battery_level = 100
+
+    @property
+    def battery_level(self) -> int:
+        """Return the current battery level of the vacuum."""
+        return max(0, min(100, self._battery_level))
 
     @property
     def fan_speed(self) -> str:
@@ -106,6 +117,7 @@ class StateDemoVacuum(StateVacuumEntity):
         if self._attr_activity != VacuumActivity.CLEANING:
             self._attr_activity = VacuumActivity.CLEANING
             self._cleaned_area += 1.32
+            self._battery_level -= 1
             self.schedule_update_ha_state()
 
     def pause(self) -> None:
@@ -130,6 +142,7 @@ class StateDemoVacuum(StateVacuumEntity):
         """Perform a spot clean-up."""
         self._attr_activity = VacuumActivity.CLEANING
         self._cleaned_area += 1.32
+        self._battery_level -= 1
         self.schedule_update_ha_state()
 
     def set_fan_speed(self, fan_speed: str, **kwargs: Any) -> None:

homeassistant/components/devolo_home_control/entity.py

@@ -9,7 +9,7 @@ from devolo_home_control_api.devices.zwave import Zwave
 from devolo_home_control_api.homecontrol import HomeControl
 
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
 
 from .const import DOMAIN
@@ -35,7 +35,7 @@ class DevoloDeviceEntity(Entity):
         )  # This is not doing I/O. It fetches an internal state of the API
         self._attr_should_poll = False
         self._attr_unique_id = element_uid
-        self._attr_device_info = dr.DeviceInfo(
+        self._attr_device_info = DeviceInfo(
             configuration_url=f"https://{urlparse(device_instance.href).netloc}",
             identifiers={(DOMAIN, self._device_instance.uid)},
             manufacturer=device_instance.brand,
@@ -88,16 +88,6 @@ class DevoloDeviceEntity(Entity):
         elif len(message) == 3 and message[2] == "status":
             # Maybe the API wants to tell us, that the device went on- or offline.
             self._attr_available = self._device_instance.is_online()
-        elif message[1] == "del" and self.platform.config_entry:
-            device_registry = dr.async_get(self.hass)
-            device = device_registry.async_get_device(
-                identifiers={(DOMAIN, self._device_instance.uid)}
-            )
-            if device:
-                device_registry.async_update_device(
-                    device.id,
-                    remove_config_entry_id=self.platform.config_entry.entry_id,
-                )
         else:
             _LOGGER.debug("No valid message received: %s", message)
 

homeassistant/components/dlna_dmr/manifest.json

@@ -8,7 +8,7 @@
   "documentation": "https://www.home-assistant.io/integrations/dlna_dmr",
   "iot_class": "local_push",
   "loggers": ["async_upnp_client"],
-  "requirements": ["async-upnp-client==0.44.0", "getmac==0.9.5"],
+  "requirements": ["async-upnp-client==0.45.0", "getmac==0.9.5"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/dlna_dms/manifest.json

@@ -7,7 +7,7 @@
   "dependencies": ["ssdp"],
   "documentation": "https://www.home-assistant.io/integrations/dlna_dms",
   "iot_class": "local_polling",
-  "requirements": ["async-upnp-client==0.44.0"],
+  "requirements": ["async-upnp-client==0.45.0"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaServer:1",

homeassistant/components/doods/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "local_polling",
   "loggers": ["pydoods"],
   "quality_scale": "legacy",
-  "requirements": ["pydoods==1.0.2", "Pillow==11.3.0"]
+  "requirements": ["pydoods==1.0.2", "Pillow==11.2.1"]
 }

homeassistant/components/dynalite/__init__.py

@@ -12,7 +12,7 @@ from .bridge import DynaliteBridge
 from .const import DOMAIN, LOGGER, PLATFORMS
 from .convert_config import convert_config
 from .panel import async_register_dynalite_frontend
-from .services import async_setup_services
+from .services import setup_services
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
@@ -21,7 +21,7 @@ type DynaliteConfigEntry = ConfigEntry[DynaliteBridge]
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Dynalite platform."""
-    async_setup_services(hass)
+    setup_services(hass)
 
     await async_register_dynalite_frontend(hass)
 

homeassistant/components/dynalite/services.py

@@ -50,7 +50,7 @@ async def _request_channel_level(service_call: ServiceCall) -> None:
 
 
 @callback
-def async_setup_services(hass: HomeAssistant) -> None:
+def setup_services(hass: HomeAssistant) -> None:
     """Set up the Dynalite platform."""
     hass.services.async_register(
         DOMAIN,

homeassistant/components/eheimdigital/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["eheimdigital"],
   "quality_scale": "bronze",
-  "requirements": ["eheimdigital==1.3.0"],
+  "requirements": ["eheimdigital==1.2.0"],
   "zeroconf": [
     { "type": "_http._tcp.local.", "name": "eheimdigital._http._tcp.local." }
   ]

homeassistant/components/emoncms/config_flow.py

@@ -16,12 +16,7 @@ from homeassistant.config_entries import (
 from homeassistant.const import CONF_API_KEY, CONF_URL
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.selector import (
-    SelectSelector,
-    SelectSelectorConfig,
-    SelectSelectorMode,
-    selector,
-)
+from homeassistant.helpers.selector import selector
 
 from .const import (
     CONF_MESSAGE,
@@ -31,9 +26,6 @@ from .const import (
     FEED_ID,
     FEED_NAME,
     FEED_TAG,
-    SYNC_MODE,
-    SYNC_MODE_AUTO,
-    SYNC_MODE_MANUAL,
 )
 
 
@@ -110,17 +102,6 @@ class EmoncmsConfigFlow(ConfigFlow, domain=DOMAIN):
                     "mode": "dropdown",
                     "multiple": True,
                 }
-                if user_input.get(SYNC_MODE) == SYNC_MODE_AUTO:
-                    return self.async_create_entry(
-                        title=sensor_name(self.url),
-                        data={
-                            CONF_URL: self.url,
-                            CONF_API_KEY: self.api_key,
-                            CONF_ONLY_INCLUDE_FEEDID: [
-                                feed[FEED_ID] for feed in result[CONF_MESSAGE]
-                            ],
-                        },
-                    )
                 return await self.async_step_choose_feeds()
         return self.async_show_form(
             step_id="user",
@@ -129,15 +110,6 @@ class EmoncmsConfigFlow(ConfigFlow, domain=DOMAIN):
                     {
                         vol.Required(CONF_URL): str,
                         vol.Required(CONF_API_KEY): str,
-                        vol.Required(
-                            SYNC_MODE, default=SYNC_MODE_MANUAL
-                        ): SelectSelector(
-                            SelectSelectorConfig(
-                                options=[SYNC_MODE_MANUAL, SYNC_MODE_AUTO],
-                                mode=SelectSelectorMode.DROPDOWN,
-                                translation_key=SYNC_MODE,
-                            )
-                        ),
                     }
                 ),
                 user_input,

homeassistant/components/emoncms/const.py

@@ -14,9 +14,6 @@ EMONCMS_UUID_DOC_URL = (
 FEED_ID = "id"
 FEED_NAME = "name"
 FEED_TAG = "tag"
-SYNC_MODE = "sync_mode"
-SYNC_MODE_AUTO = "auto"
-SYNC_MODE_MANUAL = "manual"
 
 
 LOGGER = logging.getLogger(__package__)

homeassistant/components/emoncms/strings.json

@@ -7,8 +7,7 @@
       "user": {
         "data": {
           "url": "[%key:common::config_flow::data::url%]",
-          "api_key": "[%key:common::config_flow::data::api_key%]",
-          "sync_mode": "Synchronization mode"
+          "api_key": "[%key:common::config_flow::data::api_key%]"
         },
         "data_description": {
           "url": "Server URL starting with the protocol (http or https)",
@@ -25,14 +24,6 @@
       "already_configured": "This server is already configured"
     }
   },
-  "selector": {
-    "sync_mode": {
-      "options": {
-        "auto": "Synchronize all available Feeds",
-        "manual": "Select which Feeds to synchronize"
-      }
-    }
-  },
   "entity": {
     "sensor": {
       "energy": {

homeassistant/components/enphase_envoy/manifest.json

@@ -7,7 +7,7 @@
   "iot_class": "local_polling",
   "loggers": ["pyenphase"],
   "quality_scale": "platinum",
-  "requirements": ["pyenphase==2.2.0"],
+  "requirements": ["pyenphase==2.2.2"],
   "zeroconf": [
     {
       "type": "_enphase-envoy._tcp.local."

homeassistant/components/enphase_envoy/strings.json

@@ -363,7 +363,7 @@
           "discharging": "[%key:common::state::discharging%]",
           "idle": "[%key:common::state::idle%]",
           "charging": "[%key:common::state::charging%]",
-          "full": "[%key:common::state::full%]"
+          "full": "Full"
         }
       },
       "acb_available_energy": {

homeassistant/components/esphome/manifest.json

@@ -2,7 +2,7 @@
   "domain": "esphome",
   "name": "ESPHome",
   "after_dependencies": ["hassio", "zeroconf", "tag"],
-  "codeowners": ["@jesserockz", "@kbx81", "@bdraco"],
+  "codeowners": ["@OttoWinter", "@jesserockz", "@kbx81", "@bdraco"],
   "config_flow": true,
   "dependencies": ["assist_pipeline", "bluetooth", "intent", "ffmpeg", "http"],
   "dhcp": [
@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==34.1.0",
+    "aioesphomeapi==33.1.1",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==2.16.0"
   ],

homeassistant/components/flipr/sensor.py

@@ -19,7 +19,7 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
     SensorEntityDescription(
         key="chlorine",
         translation_key="chlorine",
-        native_unit_of_measurement="mg/L",
+        native_unit_of_measurement=UnitOfElectricPotential.MILLIVOLT,
         state_class=SensorStateClass.MEASUREMENT,
     ),
     SensorEntityDescription(

homeassistant/components/fritzbox/coordinator.py

@@ -171,14 +171,19 @@ class FritzboxDataUpdateCoordinator(DataUpdateCoordinator[FritzboxCoordinatorDat
 
         for device in new_data.devices.values():
             # create device registry entry for new main devices
-            if (
-                device.ain not in self.data.devices
-                and device.device_and_unit_id[1] is None
+            if device.ain not in self.data.devices and (
+                device.device_and_unit_id[1] is None
+                or (
+                    # workaround for sub units without a main device, e.g. Energy 250
+                    # https://github.com/home-assistant/core/issues/145204
+                    device.device_and_unit_id[1] == "1"
+                    and device.device_and_unit_id[0] not in new_data.devices
+                )
             ):
                 dr.async_get(self.hass).async_get_or_create(
                     config_entry_id=self.config_entry.entry_id,
                     name=device.name,
-                    identifiers={(DOMAIN, device.ain)},
+                    identifiers={(DOMAIN, device.device_and_unit_id[0])},
                     manufacturer=device.manufacturer,
                     model=device.productname,
                     sw_version=device.fw_version,

homeassistant/components/frontend/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20250702.0"]
+  "requirements": ["home-assistant-frontend==20250702.3"]
 }

homeassistant/components/generic/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/generic",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["av==13.1.0", "Pillow==11.3.0"]
+  "requirements": ["av==13.1.0", "Pillow==11.2.1"]
 }

homeassistant/components/gios/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["dacite", "gios"],
-  "requirements": ["gios==6.0.0"]
+  "requirements": ["gios==6.1.2"]
 }

homeassistant/components/go2rtc/__init__.py

@@ -306,6 +306,11 @@ class WebRTCProvider(CameraWebRTCProvider):
             await self.teardown()
             raise HomeAssistantError("Camera has no stream source")
 
+        if camera.platform.platform_name == "generic":
+            # This is a workaround to use ffmpeg for generic cameras
+            # A proper fix will be added in the future together with supporting multiple streams per camera
+            stream_source = "ffmpeg:" + stream_source
+
         if not self.async_is_supported(stream_source):
             await self.teardown()
             raise HomeAssistantError("Stream source is not supported by go2rtc")

homeassistant/components/google_cloud/stt.py

@@ -127,7 +127,7 @@ class GoogleCloudSpeechToTextEntity(SpeechToTextEntity):
         try:
             responses = await self._client.streaming_recognize(
                 requests=request_generator(),
-                timeout=10,
+                timeout=30,
                 retry=AsyncRetry(initial=0.1, maximum=2.0, multiplier=2.0),
             )
 

homeassistant/components/google_cloud/tts.py

@@ -218,7 +218,7 @@ class BaseGoogleCloudProvider:
 
         response = await self._client.synthesize_speech(
             request,
-            timeout=10,
+            timeout=30,
             retry=AsyncRetry(initial=0.1, maximum=2.0, multiplier=2.0),
         )
 

homeassistant/components/google_generative_ai_conversation/__init__.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import asyncio
-from functools import partial
 import mimetypes
 from pathlib import Path
 from types import MappingProxyType
@@ -38,13 +37,11 @@ from homeassistant.helpers.typing import ConfigType
 
 from .const import (
     CONF_PROMPT,
-    DEFAULT_AI_TASK_NAME,
     DEFAULT_TITLE,
     DEFAULT_TTS_NAME,
     DOMAIN,
     FILE_POLLING_INTERVAL_SECONDS,
     LOGGER,
-    RECOMMENDED_AI_TASK_OPTIONS,
     RECOMMENDED_CHAT_MODEL,
     RECOMMENDED_TTS_OPTIONS,
     TIMEOUT_MILLIS,
@@ -56,7 +53,6 @@ CONF_FILENAMES = "filenames"
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = (
-    Platform.AI_TASK,
     Platform.CONVERSATION,
     Platform.TTS,
 )
@@ -191,9 +187,11 @@ async def async_setup_entry(
     """Set up Google Generative AI Conversation from a config entry."""
 
     try:
-        client = await hass.async_add_executor_job(
-            partial(Client, api_key=entry.data[CONF_API_KEY])
-        )
+
+        def _init_client() -> Client:
+            return Client(api_key=entry.data[CONF_API_KEY])
+
+        client = await hass.async_add_executor_job(_init_client)
         await client.aio.models.get(
             model=RECOMMENDED_CHAT_MODEL,
             config={"http_options": {"timeout": TIMEOUT_MILLIS}},
@@ -352,19 +350,6 @@ async def async_migrate_entry(
 
         hass.config_entries.async_update_entry(entry, minor_version=2)
 
-    if entry.version == 2 and entry.minor_version == 2:
-        # Add AI Task subentry with default options
-        hass.config_entries.async_add_subentry(
-            entry,
-            ConfigSubentry(
-                data=MappingProxyType(RECOMMENDED_AI_TASK_OPTIONS),
-                subentry_type="ai_task_data",
-                title=DEFAULT_AI_TASK_NAME,
-                unique_id=None,
-            ),
-        )
-        hass.config_entries.async_update_entry(entry, minor_version=3)
-
     LOGGER.debug(
         "Migration to version %s:%s successful", entry.version, entry.minor_version
     )

homeassistant/components/google_generative_ai_conversation/ai_task.py

@@ -1,57 +0,0 @@
-"""AI Task integration for Google Generative AI Conversation."""
-
-from __future__ import annotations
-
-from homeassistant.components import ai_task, conversation
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import LOGGER
-from .entity import ERROR_GETTING_RESPONSE, GoogleGenerativeAILLMBaseEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up AI Task entities."""
-    for subentry in config_entry.subentries.values():
-        if subentry.subentry_type != "ai_task_data":
-            continue
-
-        async_add_entities(
-            [GoogleGenerativeAITaskEntity(config_entry, subentry)],
-            config_subentry_id=subentry.subentry_id,
-        )
-
-
-class GoogleGenerativeAITaskEntity(
-    ai_task.AITaskEntity,
-    GoogleGenerativeAILLMBaseEntity,
-):
-    """Google Generative AI AI Task entity."""
-
-    _attr_supported_features = ai_task.AITaskEntityFeature.GENERATE_DATA
-
-    async def _async_generate_data(
-        self,
-        task: ai_task.GenDataTask,
-        chat_log: conversation.ChatLog,
-    ) -> ai_task.GenDataTaskResult:
-        """Handle a generate data task."""
-        await self._async_handle_chat_log(chat_log)
-
-        if not isinstance(chat_log.content[-1], conversation.AssistantContent):
-            LOGGER.error(
-                "Last content in chat log is not an AssistantContent: %s. This could be due to the model not returning a valid response",
-                chat_log.content[-1],
-            )
-            raise HomeAssistantError(ERROR_GETTING_RESPONSE)
-
-        return ai_task.GenDataTaskResult(
-            conversation_id=chat_log.conversation_id,
-            data=chat_log.content[-1].content or "",
-        )

homeassistant/components/google_generative_ai_conversation/config_flow.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from functools import partial
 import logging
 from typing import Any, cast
 
@@ -47,12 +46,10 @@ from .const import (
     CONF_TOP_K,
     CONF_TOP_P,
     CONF_USE_GOOGLE_SEARCH_TOOL,
-    DEFAULT_AI_TASK_NAME,
     DEFAULT_CONVERSATION_NAME,
     DEFAULT_TITLE,
     DEFAULT_TTS_NAME,
     DOMAIN,
-    RECOMMENDED_AI_TASK_OPTIONS,
     RECOMMENDED_CHAT_MODEL,
     RECOMMENDED_CONVERSATION_OPTIONS,
     RECOMMENDED_HARM_BLOCK_THRESHOLD,
@@ -75,14 +72,12 @@ STEP_API_DATA_SCHEMA = vol.Schema(
 )
 
 
-async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
+async def validate_input(data: dict[str, Any]) -> None:
     """Validate the user input allows us to connect.
 
     Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
     """
-    client = await hass.async_add_executor_job(
-        partial(genai.Client, api_key=data[CONF_API_KEY])
-    )
+    client = genai.Client(api_key=data[CONF_API_KEY])
     await client.aio.models.list(
         config={
             "http_options": {
@@ -97,7 +92,7 @@ class GoogleGenerativeAIConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Google Generative AI Conversation."""
 
     VERSION = 2
-    MINOR_VERSION = 3
+    MINOR_VERSION = 2
 
     async def async_step_api(
         self, user_input: dict[str, Any] | None = None
@@ -107,7 +102,7 @@ class GoogleGenerativeAIConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             self._async_abort_entries_match(user_input)
             try:
-                await validate_input(self.hass, user_input)
+                await validate_input(user_input)
             except (APIError, Timeout) as err:
                 if isinstance(err, ClientError) and "API_KEY_INVALID" in str(err):
                     errors["base"] = "invalid_auth"
@@ -138,12 +133,6 @@ class GoogleGenerativeAIConfigFlow(ConfigFlow, domain=DOMAIN):
                             "title": DEFAULT_TTS_NAME,
                             "unique_id": None,
                         },
-                        {
-                            "subentry_type": "ai_task_data",
-                            "data": RECOMMENDED_AI_TASK_OPTIONS,
-                            "title": DEFAULT_AI_TASK_NAME,
-                            "unique_id": None,
-                        },
                     ],
                 )
         return self.async_show_form(
@@ -192,7 +181,6 @@ class GoogleGenerativeAIConfigFlow(ConfigFlow, domain=DOMAIN):
         return {
             "conversation": LLMSubentryFlowHandler,
             "tts": LLMSubentryFlowHandler,
-            "ai_task_data": LLMSubentryFlowHandler,
         }
 
 
@@ -226,8 +214,6 @@ class LLMSubentryFlowHandler(ConfigSubentryFlow):
                 options: dict[str, Any]
                 if self._subentry_type == "tts":
                     options = RECOMMENDED_TTS_OPTIONS.copy()
-                elif self._subentry_type == "ai_task_data":
-                    options = RECOMMENDED_AI_TASK_OPTIONS.copy()
                 else:
                     options = RECOMMENDED_CONVERSATION_OPTIONS.copy()
             else:
@@ -302,8 +288,6 @@ async def google_generative_ai_config_option_schema(
             default_name = options[CONF_NAME]
         elif subentry_type == "tts":
             default_name = DEFAULT_TTS_NAME
-        elif subentry_type == "ai_task_data":
-            default_name = DEFAULT_AI_TASK_NAME
         else:
             default_name = DEFAULT_CONVERSATION_NAME
         schema: dict[vol.Required | vol.Optional, Any] = {
@@ -331,7 +315,6 @@ async def google_generative_ai_config_option_schema(
                 ),
             }
         )
-
     schema.update(
         {
             vol.Required(
@@ -460,5 +443,4 @@ async def google_generative_ai_config_option_schema(
                 ): bool,
             }
         )
-
     return schema

homeassistant/components/google_generative_ai_conversation/const.py

@@ -12,7 +12,6 @@ CONF_PROMPT = "prompt"
 
 DEFAULT_CONVERSATION_NAME = "Google AI Conversation"
 DEFAULT_TTS_NAME = "Google AI TTS"
-DEFAULT_AI_TASK_NAME = "Google AI Task"
 
 CONF_RECOMMENDED = "recommended"
 CONF_CHAT_MODEL = "chat_model"
@@ -36,7 +35,6 @@ RECOMMENDED_USE_GOOGLE_SEARCH_TOOL = False
 
 TIMEOUT_MILLIS = 10000
 FILE_POLLING_INTERVAL_SECONDS = 0.05
-
 RECOMMENDED_CONVERSATION_OPTIONS = {
     CONF_PROMPT: llm.DEFAULT_INSTRUCTIONS_PROMPT,
     CONF_LLM_HASS_API: [llm.LLM_API_ASSIST],
@@ -46,7 +44,3 @@ RECOMMENDED_CONVERSATION_OPTIONS = {
 RECOMMENDED_TTS_OPTIONS = {
     CONF_RECOMMENDED: True,
 }
-
-RECOMMENDED_AI_TASK_OPTIONS = {
-    CONF_RECOMMENDED: True,
-}

homeassistant/components/google_generative_ai_conversation/strings.json

@@ -88,34 +88,6 @@
         "entry_not_loaded": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::abort::entry_not_loaded%]",
         "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
       }
-    },
-    "ai_task_data": {
-      "initiate_flow": {
-        "user": "Add Generate data with AI service",
-        "reconfigure": "Reconfigure Generate data with AI service"
-      },
-      "entry_type": "Generate data with AI service",
-      "step": {
-        "set_options": {
-          "data": {
-            "name": "[%key:common::config_flow::data::name%]",
-            "recommended": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::step::set_options::data::recommended%]",
-            "chat_model": "[%key:common::generic::model%]",
-            "temperature": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::step::set_options::data::temperature%]",
-            "top_p": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::step::set_options::data::top_p%]",
-            "top_k": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::step::set_options::data::top_k%]",
-            "max_tokens": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::step::set_options::data::max_tokens%]",
-            "harassment_block_threshold": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::step::set_options::data::harassment_block_threshold%]",
-            "hate_block_threshold": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::step::set_options::data::hate_block_threshold%]",
-            "sexual_block_threshold": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::step::set_options::data::sexual_block_threshold%]",
-            "dangerous_block_threshold": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::step::set_options::data::dangerous_block_threshold%]"
-          }
-        }
-      },
-      "abort": {
-        "entry_not_loaded": "[%key:component::google_generative_ai_conversation::config_subentries::conversation::abort::entry_not_loaded%]",
-        "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
-      }
     }
   },
   "services": {

homeassistant/components/guardian/__init__.py

@@ -27,7 +27,7 @@ from .const import (
     SIGNAL_PAIRED_SENSOR_COORDINATOR_ADDED,
 )
 from .coordinator import GuardianDataUpdateCoordinator
-from .services import async_setup_services
+from .services import setup_services
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
@@ -55,7 +55,7 @@ class GuardianData:
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Elexa Guardian component."""
-    async_setup_services(hass)
+    setup_services(hass)
     return True
 
 

homeassistant/components/guardian/services.py

@@ -122,9 +122,8 @@ async def async_upgrade_firmware(call: ServiceCall, data: GuardianData) -> None:
     )
 
 
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
-    """Register the guardian services."""
+def setup_services(hass: HomeAssistant) -> None:
+    """Register the Renault services."""
     for service_name, schema, method in (
         (
             SERVICE_NAME_PAIR_SENSOR,

homeassistant/components/hassio/backup.py

@@ -48,13 +48,13 @@ from homeassistant.components.backup import (
     RestoreBackupStage,
     RestoreBackupState,
     WrittenBackup,
-    async_get_manager as async_get_backup_manager,
     suggested_filename as suggested_backup_filename,
     suggested_filename_from_name_date,
 )
 from homeassistant.const import __version__ as HAVERSION
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.backup import async_get_manager as async_get_backup_manager
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.util import dt as dt_util
 from homeassistant.util.enum import try_parse_enum
@@ -839,7 +839,7 @@ async def backup_addon_before_update(
 
 async def backup_core_before_update(hass: HomeAssistant) -> None:
     """Prepare for updating core."""
-    backup_manager = async_get_backup_manager(hass)
+    backup_manager = await async_get_backup_manager(hass)
     client = get_supervisor_client(hass)
 
     try:

homeassistant/components/hddtemp/__init__.py

@@ -1,3 +1 @@
 """The hddtemp component."""
-
-DOMAIN = "hddtemp"

homeassistant/components/hddtemp/sensor.py

@@ -22,14 +22,11 @@ from homeassistant.const import (
     CONF_PORT,
     UnitOfTemperature,
 )
-from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.issue_registry import IssueSeverity, create_issue
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
-from . import DOMAIN
-
 _LOGGER = logging.getLogger(__name__)
 
 ATTR_DEVICE = "device"
@@ -59,21 +56,6 @@ def setup_platform(
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
     """Set up the HDDTemp sensor."""
-    create_issue(
-        hass,
-        HOMEASSISTANT_DOMAIN,
-        f"deprecated_system_packages_yaml_integration_{DOMAIN}",
-        breaks_in_ha_version="2025.12.0",
-        is_fixable=False,
-        issue_domain=DOMAIN,
-        severity=IssueSeverity.WARNING,
-        translation_key="deprecated_system_packages_yaml_integration",
-        translation_placeholders={
-            "domain": DOMAIN,
-            "integration_title": "hddtemp",
-        },
-    )
-
     name = config.get(CONF_NAME)
     host = config.get(CONF_HOST)
     port = config.get(CONF_PORT)

homeassistant/components/heos/__init__.py

@@ -9,9 +9,9 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.typing import ConfigType
 
+from . import services
 from .const import DOMAIN
 from .coordinator import HeosConfigEntry, HeosCoordinator
-from .services import async_setup_services
 
 PLATFORMS = [Platform.MEDIA_PLAYER]
 
@@ -22,7 +22,7 @@ CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the HEOS component."""
-    async_setup_services(hass)
+    services.register(hass)
     return True
 
 

homeassistant/components/heos/services.py

@@ -9,7 +9,7 @@ import voluptuous as vol
 
 from homeassistant.components.media_player import ATTR_MEDIA_VOLUME_LEVEL
 from homeassistant.config_entries import ConfigEntryState
-from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse, callback
+from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import (
     config_validation as cv,
@@ -44,8 +44,7 @@ HEOS_SIGN_IN_SCHEMA = vol.Schema(
 HEOS_SIGN_OUT_SCHEMA = vol.Schema({})
 
 
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
+def register(hass: HomeAssistant) -> None:
     """Register HEOS services."""
     hass.services.async_register(
         DOMAIN,

homeassistant/components/home_connect/__init__.py

@@ -23,7 +23,7 @@ from homeassistant.helpers.typing import ConfigType
 from .api import AsyncConfigEntryAuth
 from .const import DOMAIN, OLD_NEW_UNIQUE_ID_SUFFIX_MAP
 from .coordinator import HomeConnectConfigEntry, HomeConnectCoordinator
-from .services import async_setup_services
+from .services import register_actions
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -43,7 +43,7 @@ PLATFORMS = [
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Home Connect component."""
-    async_setup_services(hass)
+    register_actions(hass)
     return True
 
 

homeassistant/components/home_connect/coordinator.py

@@ -41,7 +41,12 @@ from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr, issue_registry as ir
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import API_DEFAULT_RETRY_AFTER, APPLIANCES_WITH_PROGRAMS, DOMAIN
+from .const import (
+    API_DEFAULT_RETRY_AFTER,
+    APPLIANCES_WITH_PROGRAMS,
+    BSH_OPERATION_STATE_PAUSE,
+    DOMAIN,
+)
 from .utils import get_dict_from_home_connect_error
 
 _LOGGER = logging.getLogger(__name__)
@@ -66,6 +71,7 @@ class HomeConnectApplianceData:
 
     def update(self, other: HomeConnectApplianceData) -> None:
         """Update data with data from other instance."""
+        self.commands.clear()
         self.commands.update(other.commands)
         self.events.update(other.events)
         self.info.connected = other.info.connected
@@ -201,6 +207,28 @@ class HomeConnectCoordinator(
                                         raw_key=status_key.value,
                                         value=event.value,
                                     )
+                                if (
+                                    status_key == StatusKey.BSH_COMMON_OPERATION_STATE
+                                    and event.value == BSH_OPERATION_STATE_PAUSE
+                                    and CommandKey.BSH_COMMON_RESUME_PROGRAM
+                                    not in (
+                                        commands := self.data[
+                                            event_message_ha_id
+                                        ].commands
+                                    )
+                                ):
+                                    # All the appliances that can be paused
+                                    # should have the resume command available.
+                                    commands.add(CommandKey.BSH_COMMON_RESUME_PROGRAM)
+                                    for (
+                                        listener,
+                                        context,
+                                    ) in self._special_listeners.values():
+                                        if (
+                                            EventKey.BSH_COMMON_APPLIANCE_DEPAIRED
+                                            not in context
+                                        ):
+                                            listener()
                             self._call_event_listener(event_message)
 
                         case EventType.NOTIFY:
@@ -627,10 +655,7 @@ class HomeConnectCoordinator(
                     "times": str(MAX_EXECUTIONS),
                     "time_window": str(MAX_EXECUTIONS_TIME_WINDOW // 60),
                     "home_connect_resource_url": "https://www.home-connect.com/global/help-support/error-codes#/Togglebox=15362315-13320636-1/",
-                    "home_assistant_core_new_issue_url": (
-                        "https://github.com/home-assistant/core/issues/new?template=bug_report.yml"
-                        f"&integration_name={DOMAIN}&integration_link=https://www.home-assistant.io/integrations/{DOMAIN}/"
-                    ),
+                    "home_assistant_core_issue_url": "https://github.com/home-assistant/core/issues/147299",
                 },
             )
             return True

homeassistant/components/home_connect/services.py

@@ -18,7 +18,7 @@ from aiohomeconnect.model.error import HomeConnectError
 import voluptuous as vol
 
 from homeassistant.const import ATTR_DEVICE_ID
-from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
@@ -522,8 +522,7 @@ async def async_service_start_program(call: ServiceCall) -> None:
     await _async_service_program(call, True)
 
 
-@callback
-def async_setup_services(hass: HomeAssistant) -> None:
+def register_actions(hass: HomeAssistant) -> None:
     """Register custom actions."""
 
     hass.services.async_register(

homeassistant/components/home_connect/strings.json

@@ -130,7 +130,7 @@
         "step": {
           "confirm": {
             "title": "[%key:component::home_connect::issues::home_connect_too_many_connected_paired_events::title%]",
-            "description": "The appliance \"{appliance_name}\" has been reported as connected or paired {times} times in less than {time_window} minutes, so refreshes on connected or paired events has been disabled to avoid exceeding the API rate limit.\n\nPlease refer to the [Home Connect Wi-Fi requirements and recommendations]({home_connect_resource_url}). If everything seems right with your network configuration, restart the appliance.\n\nClick \"submit\" to re-enable the updates.\nIf the issue persists, please create an issue in the [Home Assistant core repository]({home_assistant_core_new_issue_url})."
+            "description": "The appliance \"{appliance_name}\" has been reported as connected or paired {times} times in less than {time_window} minutes, so refreshes on connected or paired events has been disabled to avoid exceeding the API rate limit.\n\nPlease refer to the [Home Connect Wi-Fi requirements and recommendations]({home_connect_resource_url}). If everything seems right with your network configuration, restart the appliance.\n\nClick \"submit\" to re-enable the updates.\nIf the issue persists, please see the following issue in the [Home Assistant core repository]({home_assistant_core_issue_url})."
           }
         }
       }

homeassistant/components/homematicip_cloud/hap.py

@@ -113,9 +113,7 @@ class HomematicipHAP:
 
         self._ws_close_requested = False
         self._ws_connection_closed = asyncio.Event()
-        self._retry_task: asyncio.Task | None = None
-        self._tries = 0
-        self._accesspoint_connected = True
+        self._get_state_task: asyncio.Task | None = None
         self.hmip_device_by_entity_id: dict[str, Any] = {}
         self.reset_connection_listener: Callable | None = None
 
@@ -161,17 +159,8 @@ class HomematicipHAP:
         """
         if not self.home.connected:
             _LOGGER.error("HMIP access point has lost connection with the cloud")
-            self._accesspoint_connected = False
+            self._ws_connection_closed.set()
             self.set_all_to_unavailable()
-        elif not self._accesspoint_connected:
-            # Now the HOME_CHANGED event has fired indicating the access
-            # point has reconnected to the cloud again.
-            # Explicitly getting an update as entity states might have
-            # changed during access point disconnect."""
-
-            job = self.hass.async_create_task(self.get_state())
-            job.add_done_callback(self.get_state_finished)
-            self._accesspoint_connected = True
 
     @callback
     def async_create_entity(self, *args, **kwargs) -> None:
@@ -185,20 +174,43 @@ class HomematicipHAP:
             await asyncio.sleep(30)
         await self.hass.config_entries.async_reload(self.config_entry.entry_id)
 
+    async def _try_get_state(self) -> None:
+        """Call get_state in a loop until no error occurs, using exponential backoff on error."""
+
+        # Wait until WebSocket connection is established.
+        while not self.home.websocket_is_connected():
+            await asyncio.sleep(2)
+
+        delay = 8
+        max_delay = 1500
+        while True:
+            try:
+                await self.get_state()
+                break
+            except HmipConnectionError as err:
+                _LOGGER.warning(
+                    "Get_state failed, retrying in %s seconds: %s", delay, err
+                )
+                await asyncio.sleep(delay)
+                delay = min(delay * 2, max_delay)
+
     async def get_state(self) -> None:
         """Update HMIP state and tell Home Assistant."""
         await self.home.get_current_state_async()
         self.update_all()
 
     def get_state_finished(self, future) -> None:
-        """Execute when get_state coroutine has finished."""
+        """Execute when try_get_state coroutine has finished."""
         try:
             future.result()
-        except HmipConnectionError:
-            # Somehow connection could not recover. Will disconnect and
-            # so reconnect loop is taking over.
-            _LOGGER.error("Updating state after HMIP access point reconnect failed")
-            self.hass.async_create_task(self.home.disable_events())
+        except Exception as err:  # noqa: BLE001
+            _LOGGER.error(
+                "Error updating state after HMIP access point reconnect: %s", err
+            )
+        else:
+            _LOGGER.info(
+                "Updating state after HMIP access point reconnect finished successfully",
+            )
 
     def set_all_to_unavailable(self) -> None:
         """Set all devices to unavailable and tell Home Assistant."""
@@ -222,8 +234,8 @@ class HomematicipHAP:
     async def async_reset(self) -> bool:
         """Close the websocket connection."""
         self._ws_close_requested = True
-        if self._retry_task is not None:
-            self._retry_task.cancel()
+        if self._get_state_task is not None:
+            self._get_state_task.cancel()
         await self.home.disable_events_async()
         _LOGGER.debug("Closed connection to HomematicIP cloud server")
         await self.hass.config_entries.async_unload_platforms(
@@ -247,7 +259,9 @@ class HomematicipHAP:
         """Handle websocket connected."""
         _LOGGER.info("Websocket connection to HomematicIP Cloud established")
         if self._ws_connection_closed.is_set():
-            await self.get_state()
+            self._get_state_task = self.hass.async_create_task(self._try_get_state())
+            self._get_state_task.add_done_callback(self.get_state_finished)
+
             self._ws_connection_closed.clear()
 
     async def ws_disconnected_handler(self) -> None:
@@ -256,11 +270,12 @@ class HomematicipHAP:
         self._ws_connection_closed.set()
 
     async def ws_reconnected_handler(self, reason: str) -> None:
-        """Handle websocket reconnection."""
+        """Handle websocket reconnection. Is called when Websocket tries to reconnect."""
         _LOGGER.info(
-            "Websocket connection to HomematicIP Cloud re-established due to reason: %s",
+            "Websocket connection to HomematicIP Cloud trying to reconnect due to reason: %s",
             reason,
         )
+
         self._ws_connection_closed.set()
 
     async def get_hap(

homeassistant/components/homematicip_cloud/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/homematicip_cloud",
   "iot_class": "cloud_push",
   "loggers": ["homematicip"],
-  "requirements": ["homematicip==2.0.6"]
+  "requirements": ["homematicip==2.0.7"]
 }

homeassistant/components/huawei_lte/config_flow.py

@@ -63,8 +63,8 @@ from .utils import get_device_macs, non_verifying_requests_session
 _LOGGER = logging.getLogger(__name__)
 
 
-class HuaweiLteConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Huawei LTE config flow."""
+class ConfigFlowHandler(ConfigFlow, domain=DOMAIN):
+    """Handle Huawei LTE config flow."""
 
     VERSION = 3
 
@@ -75,9 +75,9 @@ class HuaweiLteConfigFlow(ConfigFlow, domain=DOMAIN):
     @callback
     def async_get_options_flow(
         config_entry: ConfigEntry,
-    ) -> HuaweiLteOptionsFlow:
+    ) -> OptionsFlowHandler:
         """Get options flow."""
-        return HuaweiLteOptionsFlow()
+        return OptionsFlowHandler()
 
     async def _async_show_user_form(
         self,
@@ -354,7 +354,7 @@ class HuaweiLteConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_update_reload_and_abort(entry, data=new_data)
 
 
-class HuaweiLteOptionsFlow(OptionsFlow):
+class OptionsFlowHandler(OptionsFlow):
     """Huawei LTE options flow."""
 
     async def async_step_init(

homeassistant/components/husqvarna_automower/calendar.py

@@ -2,18 +2,15 @@
 
 from datetime import datetime
 import logging
-from typing import TYPE_CHECKING
 
 from aioautomower.model import make_name_string
 
 from homeassistant.components.calendar import CalendarEntity, CalendarEvent
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util
 
 from . import AutomowerConfigEntry
-from .const import DOMAIN
 from .coordinator import AutomowerDataUpdateCoordinator
 from .entity import AutomowerBaseEntity
 
@@ -54,25 +51,13 @@ class AutomowerCalendarEntity(AutomowerBaseEntity, CalendarEntity):
         self._attr_unique_id = mower_id
         self._event: CalendarEvent | None = None
 
-    @property
-    def device_name(self) -> str:
-        """Return the prefix for the event summary."""
-        device_registry = dr.async_get(self.hass)
-        device_entry = device_registry.async_get_device(
-            identifiers={(DOMAIN, self.mower_id)}
-        )
-        if TYPE_CHECKING:
-            assert device_entry is not None
-            assert device_entry.name is not None
-
-        return device_entry.name_by_user or device_entry.name
-
     @property
     def event(self) -> CalendarEvent | None:
         """Return the current or next upcoming event."""
         schedule = self.mower_attributes.calendar
         cursor = schedule.timeline.active_after(dt_util.now())
         program_event = next(cursor, None)
+        _LOGGER.debug("program_event %s", program_event)
         if not program_event:
             return None
         work_area_name = None
@@ -81,7 +66,7 @@ class AutomowerCalendarEntity(AutomowerBaseEntity, CalendarEntity):
                 program_event.work_area_id
             ]
         return CalendarEvent(
-            summary=f"{self.device_name} {make_name_string(work_area_name, program_event.schedule_no)}",
+            summary=make_name_string(work_area_name, program_event.schedule_no),
             start=program_event.start,
             end=program_event.end,
             rrule=program_event.rrule_str,
@@ -108,7 +93,7 @@ class AutomowerCalendarEntity(AutomowerBaseEntity, CalendarEntity):
                 ]
             calendar_events.append(
                 CalendarEvent(
-                    summary=f"{self.device_name} {make_name_string(work_area_name, program_event.schedule_no)}",
+                    summary=make_name_string(work_area_name, program_event.schedule_no),
                     start=program_event.start.replace(tzinfo=start_date.tzinfo),
                     end=program_event.end.replace(tzinfo=start_date.tzinfo),
                     rrule=program_event.rrule_str,

homeassistant/components/husqvarna_automower/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_push",
   "loggers": ["aioautomower"],
   "quality_scale": "silver",
-  "requirements": ["aioautomower==1.0.1"]
+  "requirements": ["aioautomower==2025.6.0"]
 }

homeassistant/components/image_upload/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/image_upload",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["Pillow==11.3.0"]
+  "requirements": ["Pillow==11.2.1"]
 }

homeassistant/components/immich/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "loggers": ["aioimmich"],
   "quality_scale": "silver",
-  "requirements": ["aioimmich==0.10.1"]
+  "requirements": ["aioimmich==0.10.2"]
 }

homeassistant/components/immich/update.py

@@ -44,7 +44,7 @@ class ImmichUpdateEntity(ImmichEntity, UpdateEntity):
         return self.coordinator.data.server_about.version
 
     @property
-    def latest_version(self) -> str:
+    def latest_version(self) -> str | None:
         """Available new immich server version."""
         assert self.coordinator.data.server_version_check
         return self.coordinator.data.server_version_check.release_version

homeassistant/components/iron_os/const.py

@@ -10,8 +10,4 @@ OHM = "Ω"
 DISCOVERY_SVC_UUID = "9eae1000-9d0d-48c5-aa55-33e27f9bc533"
 
 MAX_TEMP: int = 450
-MAX_TEMP_F: int = 850
 MIN_TEMP: int = 10
-MIN_TEMP_F: int = 50
-MIN_BOOST_TEMP: int = 250
-MIN_BOOST_TEMP_F: int = 480

homeassistant/components/iron_os/coordinator.py

@@ -168,9 +168,7 @@ class IronOSSettingsCoordinator(IronOSBaseCoordinator[SettingsDataResponse]):
 
         if self.device.is_connected and characteristics:
             try:
-                return await self.device.get_settings(
-                    list(characteristics | {CharSetting.TEMP_UNIT})
-                )
+                return await self.device.get_settings(list(characteristics))
             except CommunicationError as e:
                 _LOGGER.debug("Failed to fetch settings", exc_info=e)
 

homeassistant/components/iron_os/icons.json

@@ -209,12 +209,6 @@
         "state": {
           "off": "mdi:card-bulleted-off-outline"
         }
-      },
-      "boost": {
-        "default": "mdi:thermometer-high",
-        "state": {
-          "off": "mdi:thermometer-off"
-        }
       }
     }
   }

homeassistant/components/iron_os/number.py

@@ -6,9 +6,10 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from enum import StrEnum
 
-from pynecil import CharSetting, LiveDataResponse, SettingsDataResponse, TempUnit
+from pynecil import CharSetting, LiveDataResponse, SettingsDataResponse
 
 from homeassistant.components.number import (
+    DEFAULT_MAX_VALUE,
     NumberDeviceClass,
     NumberEntity,
     NumberEntityDescription,
@@ -23,17 +24,9 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.util.unit_conversion import TemperatureConverter
 
 from . import IronOSConfigEntry
-from .const import (
-    MAX_TEMP,
-    MAX_TEMP_F,
-    MIN_BOOST_TEMP,
-    MIN_BOOST_TEMP_F,
-    MIN_TEMP,
-    MIN_TEMP_F,
-)
+from .const import MAX_TEMP, MIN_TEMP
 from .coordinator import IronOSCoordinators
 from .entity import IronOSBaseEntity
 
@@ -45,10 +38,9 @@ class IronOSNumberEntityDescription(NumberEntityDescription):
     """Describes IronOS number entity."""
 
     value_fn: Callable[[LiveDataResponse, SettingsDataResponse], float | int | None]
+    max_value_fn: Callable[[LiveDataResponse], float | int] | None = None
     characteristic: CharSetting
     raw_value_fn: Callable[[float], float | int] | None = None
-    native_max_value_f: float | None = None
-    native_min_value_f: float | None = None
 
 
 class PinecilNumber(StrEnum):
@@ -82,6 +74,44 @@ def multiply(value: float | None, multiplier: float) -> float | None:
 
 
 PINECIL_NUMBER_DESCRIPTIONS: tuple[IronOSNumberEntityDescription, ...] = (
+    IronOSNumberEntityDescription(
+        key=PinecilNumber.SETPOINT_TEMP,
+        translation_key=PinecilNumber.SETPOINT_TEMP,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=NumberDeviceClass.TEMPERATURE,
+        value_fn=lambda data, _: data.setpoint_temp,
+        characteristic=CharSetting.SETPOINT_TEMP,
+        mode=NumberMode.BOX,
+        native_min_value=MIN_TEMP,
+        native_step=5,
+        max_value_fn=lambda data: min(data.max_tip_temp_ability or MAX_TEMP, MAX_TEMP),
+    ),
+    IronOSNumberEntityDescription(
+        key=PinecilNumber.SLEEP_TEMP,
+        translation_key=PinecilNumber.SLEEP_TEMP,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=NumberDeviceClass.TEMPERATURE,
+        value_fn=lambda _, settings: settings.get("sleep_temp"),
+        characteristic=CharSetting.SLEEP_TEMP,
+        mode=NumberMode.BOX,
+        native_min_value=MIN_TEMP,
+        native_max_value=MAX_TEMP,
+        native_step=10,
+        entity_category=EntityCategory.CONFIG,
+    ),
+    IronOSNumberEntityDescription(
+        key=PinecilNumber.BOOST_TEMP,
+        translation_key=PinecilNumber.BOOST_TEMP,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        device_class=NumberDeviceClass.TEMPERATURE,
+        value_fn=lambda _, settings: settings.get("boost_temp"),
+        characteristic=CharSetting.BOOST_TEMP,
+        mode=NumberMode.BOX,
+        native_min_value=0,
+        native_max_value=MAX_TEMP,
+        native_step=10,
+        entity_category=EntityCategory.CONFIG,
+    ),
     IronOSNumberEntityDescription(
         key=PinecilNumber.QC_MAX_VOLTAGE,
         translation_key=PinecilNumber.QC_MAX_VOLTAGE,
@@ -266,6 +296,32 @@ PINECIL_NUMBER_DESCRIPTIONS: tuple[IronOSNumberEntityDescription, ...] = (
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
     ),
+    IronOSNumberEntityDescription(
+        key=PinecilNumber.TEMP_INCREMENT_SHORT,
+        translation_key=PinecilNumber.TEMP_INCREMENT_SHORT,
+        value_fn=(lambda _, settings: settings.get("temp_increment_short")),
+        characteristic=CharSetting.TEMP_INCREMENT_SHORT,
+        raw_value_fn=lambda value: value,
+        mode=NumberMode.BOX,
+        native_min_value=1,
+        native_max_value=50,
+        native_step=1,
+        entity_category=EntityCategory.CONFIG,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
+    IronOSNumberEntityDescription(
+        key=PinecilNumber.TEMP_INCREMENT_LONG,
+        translation_key=PinecilNumber.TEMP_INCREMENT_LONG,
+        value_fn=(lambda _, settings: settings.get("temp_increment_long")),
+        characteristic=CharSetting.TEMP_INCREMENT_LONG,
+        raw_value_fn=lambda value: value,
+        mode=NumberMode.BOX,
+        native_min_value=5,
+        native_max_value=90,
+        native_step=5,
+        entity_category=EntityCategory.CONFIG,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+    ),
 )
 
 PINECIL_NUMBER_DESCRIPTIONS_V223: tuple[IronOSNumberEntityDescription, ...] = (
@@ -285,82 +341,6 @@ PINECIL_NUMBER_DESCRIPTIONS_V223: tuple[IronOSNumberEntityDescription, ...] = (
     ),
 )
 
-"""
-The `device_class` attribute was removed from the `setpoint_temperature`, `sleep_temperature`, and `boost_temp` entities.
-These entities represent user-defined input values, not measured temperatures, and their
-interpretation depends on the device's current unit configuration. Applying a device_class
-results in automatic unit conversions, which introduce rounding errors due to the use of integers.
-This can prevent the correct value from being set, as the input is modified during synchronization with the device.
-"""
-PINECIL_TEMP_NUMBER_DESCRIPTIONS: tuple[IronOSNumberEntityDescription, ...] = (
-    IronOSNumberEntityDescription(
-        key=PinecilNumber.SLEEP_TEMP,
-        translation_key=PinecilNumber.SLEEP_TEMP,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        value_fn=lambda _, settings: settings.get("sleep_temp"),
-        characteristic=CharSetting.SLEEP_TEMP,
-        mode=NumberMode.BOX,
-        native_min_value=MIN_TEMP,
-        native_max_value=MAX_TEMP,
-        native_min_value_f=MIN_TEMP_F,
-        native_max_value_f=MAX_TEMP_F,
-        native_step=10,
-        entity_category=EntityCategory.CONFIG,
-    ),
-    IronOSNumberEntityDescription(
-        key=PinecilNumber.BOOST_TEMP,
-        translation_key=PinecilNumber.BOOST_TEMP,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        value_fn=lambda _, settings: settings.get("boost_temp"),
-        characteristic=CharSetting.BOOST_TEMP,
-        mode=NumberMode.BOX,
-        native_min_value=MIN_BOOST_TEMP,
-        native_min_value_f=MIN_BOOST_TEMP_F,
-        native_max_value=MAX_TEMP,
-        native_max_value_f=MAX_TEMP_F,
-        native_step=10,
-        entity_category=EntityCategory.CONFIG,
-    ),
-    IronOSNumberEntityDescription(
-        key=PinecilNumber.TEMP_INCREMENT_SHORT,
-        translation_key=PinecilNumber.TEMP_INCREMENT_SHORT,
-        value_fn=(lambda _, settings: settings.get("temp_increment_short")),
-        characteristic=CharSetting.TEMP_INCREMENT_SHORT,
-        raw_value_fn=lambda value: value,
-        mode=NumberMode.BOX,
-        native_min_value=1,
-        native_max_value=50,
-        native_step=1,
-        entity_category=EntityCategory.CONFIG,
-    ),
-    IronOSNumberEntityDescription(
-        key=PinecilNumber.TEMP_INCREMENT_LONG,
-        translation_key=PinecilNumber.TEMP_INCREMENT_LONG,
-        value_fn=(lambda _, settings: settings.get("temp_increment_long")),
-        characteristic=CharSetting.TEMP_INCREMENT_LONG,
-        raw_value_fn=lambda value: value,
-        mode=NumberMode.BOX,
-        native_min_value=5,
-        native_max_value=90,
-        native_step=5,
-        entity_category=EntityCategory.CONFIG,
-    ),
-)
-
-PINECIL_SETPOINT_NUMBER_DESCRIPTION = IronOSNumberEntityDescription(
-    key=PinecilNumber.SETPOINT_TEMP,
-    translation_key=PinecilNumber.SETPOINT_TEMP,
-    native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-    value_fn=lambda data, _: data.setpoint_temp,
-    characteristic=CharSetting.SETPOINT_TEMP,
-    mode=NumberMode.BOX,
-    native_min_value=MIN_TEMP,
-    native_max_value=MAX_TEMP,
-    native_min_value_f=MIN_TEMP_F,
-    native_max_value_f=MAX_TEMP_F,
-    native_step=5,
-)
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -374,18 +354,9 @@ async def async_setup_entry(
     if coordinators.live_data.v223_features:
         descriptions += PINECIL_NUMBER_DESCRIPTIONS_V223
 
-    entities = [
+    async_add_entities(
         IronOSNumberEntity(coordinators, description) for description in descriptions
-    ]
-
-    entities.extend(
-        IronOSTemperatureNumberEntity(coordinators, description)
-        for description in PINECIL_TEMP_NUMBER_DESCRIPTIONS
     )
-    entities.append(
-        IronOSSetpointNumberEntity(coordinators, PINECIL_SETPOINT_NUMBER_DESCRIPTION)
-    )
-    async_add_entities(entities)
 
 
 class IronOSNumberEntity(IronOSBaseEntity, NumberEntity):
@@ -417,6 +388,15 @@ class IronOSNumberEntity(IronOSBaseEntity, NumberEntity):
             self.coordinator.data, self.settings.data
         )
 
+    @property
+    def native_max_value(self) -> float:
+        """Return sensor state."""
+
+        if self.entity_description.max_value_fn is not None:
+            return self.entity_description.max_value_fn(self.coordinator.data)
+
+        return self.entity_description.native_max_value or DEFAULT_MAX_VALUE
+
     async def async_added_to_hass(self) -> None:
         """Run when entity about to be added to hass."""
 
@@ -427,70 +407,3 @@ class IronOSNumberEntity(IronOSBaseEntity, NumberEntity):
             )
         )
         await self.settings.async_request_refresh()
-
-
-class IronOSTemperatureNumberEntity(IronOSNumberEntity):
-    """Implementation of a IronOS temperature number entity."""
-
-    @property
-    def native_unit_of_measurement(self) -> str | None:
-        """Return the unit of measurement of the sensor, if any."""
-
-        return (
-            UnitOfTemperature.FAHRENHEIT
-            if self.settings.data.get("temp_unit") is TempUnit.FAHRENHEIT
-            else UnitOfTemperature.CELSIUS
-        )
-
-    @property
-    def native_min_value(self) -> float:
-        """Return the minimum value."""
-
-        return (
-            self.entity_description.native_min_value_f
-            if self.entity_description.native_min_value_f
-            and self.native_unit_of_measurement is UnitOfTemperature.FAHRENHEIT
-            else super().native_min_value
-        )
-
-    @property
-    def native_max_value(self) -> float:
-        """Return the maximum value."""
-
-        return (
-            self.entity_description.native_max_value_f
-            if self.entity_description.native_max_value_f
-            and self.native_unit_of_measurement is UnitOfTemperature.FAHRENHEIT
-            else super().native_max_value
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        if (
-            self.entity_description.key is PinecilNumber.BOOST_TEMP
-            and self.native_value == 0
-        ):
-            return False
-        return super().available
-
-
-class IronOSSetpointNumberEntity(IronOSTemperatureNumberEntity):
-    """IronOS setpoint temperature entity."""
-
-    @property
-    def native_max_value(self) -> float:
-        """Return the maximum value."""
-
-        return (
-            min(
-                TemperatureConverter.convert(
-                    float(max_tip_c),
-                    UnitOfTemperature.CELSIUS,
-                    self.native_unit_of_measurement,
-                ),
-                super().native_max_value,
-            )
-            if (max_tip_c := self.coordinator.data.max_tip_temp_ability) is not None
-            else super().native_max_value
-        )

homeassistant/components/iron_os/strings.json

@@ -278,9 +278,6 @@
       },
       "calibrate_cjc": {
         "name": "Calibrate CJC"
-      },
-      "boost": {
-        "name": "Boost"
       }
     }
   },

homeassistant/components/iron_os/switch.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 from enum import StrEnum
 from typing import Any
 
-from pynecil import CharSetting, SettingsDataResponse, TempUnit
+from pynecil import CharSetting, SettingsDataResponse
 
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
 from homeassistant.const import EntityCategory
@@ -15,7 +15,6 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import IronOSConfigEntry
-from .const import MIN_BOOST_TEMP, MIN_BOOST_TEMP_F
 from .coordinator import IronOSCoordinators
 from .entity import IronOSBaseEntity
 
@@ -40,7 +39,6 @@ class IronOSSwitch(StrEnum):
     INVERT_BUTTONS = "invert_buttons"
     DISPLAY_INVERT = "display_invert"
     CALIBRATE_CJC = "calibrate_cjc"
-    BOOST = "boost"
 
 
 SWITCH_DESCRIPTIONS: tuple[IronOSSwitchEntityDescription, ...] = (
@@ -96,13 +94,6 @@ SWITCH_DESCRIPTIONS: tuple[IronOSSwitchEntityDescription, ...] = (
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.CONFIG,
     ),
-    IronOSSwitchEntityDescription(
-        key=IronOSSwitch.BOOST,
-        translation_key=IronOSSwitch.BOOST,
-        characteristic=CharSetting.BOOST_TEMP,
-        is_on_fn=lambda x: bool(x.get("boost_temp")),
-        entity_category=EntityCategory.CONFIG,
-    ),
 )
 
 
@@ -145,15 +136,7 @@ class IronOSSwitchEntity(IronOSBaseEntity, SwitchEntity):
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
-        if self.entity_description.key is IronOSSwitch.BOOST:
-            await self.settings.write(
-                self.entity_description.characteristic,
-                MIN_BOOST_TEMP_F
-                if self.settings.data.get("temp_unit") is TempUnit.FAHRENHEIT
-                else MIN_BOOST_TEMP,
-            )
-        else:
-            await self.settings.write(self.entity_description.characteristic, True)
+        await self.settings.write(self.entity_description.characteristic, True)
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the entity on."""