Update lxml to 6.0.0 (#149640)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.devcontainer/devcontainer.json

@@ -8,6 +8,7 @@
     "PYTHONASYNCIODEBUG": "1"
   },
   "features": {
+    "ghcr.io/anthropics/devcontainer-features/claude-code:1.0": {},
     "ghcr.io/devcontainers/features/github-cli:1": {}
   },
   // Port 5683 udp is used by Shelly integration

.github/ISSUE_TEMPLATE/task.yml

@@ -0,0 +1,53 @@
+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: 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: [link]
+        - Epic: [link]
+        - Feature request: [link]
+        - Technical design documents: [link]
+        - Prototype/mockup: [link]
+        - Dependencies: [links]
+    validations:
+      required: false

.github/dependabot.yml

@@ -6,3 +6,6 @@ updates:
       interval: daily
       time: "06:00"
     open-pull-requests-limit: 10
+    labels:
+      - dependency
+      - github_actions

.github/workflows/builder.yml

@@ -324,7 +324,7 @@ jobs:
         uses: actions/checkout@v4.2.2
 
       - name: Install Cosign
-        uses: sigstore/cosign-installer@v3.9.1
+        uses: sigstore/cosign-installer@v3.9.2
         with:
           cosign-release: "v2.2.3"
 

.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.7"
+  HA_SHORT_VERSION: "2025.8"
   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.0
+        uses: github/codeql-action/init@v3.29.5
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.29.0
+        uses: github/codeql-action/analyze@v3.29.5
         with:
           category: "/language:python"

.github/workflows/detect-duplicate-issues.yml

@@ -231,7 +231,7 @@ jobs:
       - name: Detect duplicates using AI
         id: ai_detection
         if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
-        uses: actions/ai-inference@v1.1.0
+        uses: actions/ai-inference@v1.2.3
         with:
           model: openai/gpt-4o
           system-prompt: |

.github/workflows/detect-non-english-issues.yml

@@ -57,7 +57,7 @@ jobs:
       - name: Detect language using AI
         id: ai_language_detection
         if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/ai-inference@v1.1.0
+        uses: actions/ai-inference@v1.2.3
         with:
           model: openai/gpt-4o-mini
           system-prompt: |

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

@@ -0,0 +1,84 @@
+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,4 +137,8 @@ tmp_cache
 .ropeproject
 
 # Will be created from script/split_tests.py
-pytest_buckets.txt
+pytest_buckets.txt
+
+# AI tooling
+.claude
+

.pre-commit-config.yaml

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

.strict-typing

@@ -53,6 +53,7 @@ homeassistant.components.air_quality.*
 homeassistant.components.airgradient.*
 homeassistant.components.airly.*
 homeassistant.components.airnow.*
+homeassistant.components.airos.*
 homeassistant.components.airq.*
 homeassistant.components.airthings.*
 homeassistant.components.airthings_ble.*
@@ -377,10 +378,12 @@ homeassistant.components.onedrive.*
 homeassistant.components.onewire.*
 homeassistant.components.onkyo.*
 homeassistant.components.open_meteo.*
+homeassistant.components.open_router.*
 homeassistant.components.openai_conversation.*
 homeassistant.components.openexchangerates.*
 homeassistant.components.opensky.*
 homeassistant.components.openuv.*
+homeassistant.components.opower.*
 homeassistant.components.oralb.*
 homeassistant.components.otbr.*
 homeassistant.components.overkiz.*
@@ -499,6 +502,7 @@ homeassistant.components.tag.*
 homeassistant.components.tailscale.*
 homeassistant.components.tailwind.*
 homeassistant.components.tami4.*
+homeassistant.components.tankerkoenig.*
 homeassistant.components.tautulli.*
 homeassistant.components.tcp.*
 homeassistant.components.technove.*
@@ -534,6 +538,7 @@ homeassistant.components.unifiprotect.*
 homeassistant.components.upcloud.*
 homeassistant.components.update.*
 homeassistant.components.uptime.*
+homeassistant.components.uptime_kuma.*
 homeassistant.components.uptimerobot.*
 homeassistant.components.usb.*
 homeassistant.components.uvc.*
@@ -543,6 +548,7 @@ homeassistant.components.valve.*
 homeassistant.components.velbus.*
 homeassistant.components.vlc_telnet.*
 homeassistant.components.vodafone_station.*
+homeassistant.components.volvo.*
 homeassistant.components.wake_on_lan.*
 homeassistant.components.wake_word.*
 homeassistant.components.wallbox.*

CLAUDE.md

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

CODEOWNERS

@@ -67,6 +67,8 @@ build.json @home-assistant/supervisor
 /tests/components/airly/ @bieniu
 /homeassistant/components/airnow/ @asymworks
 /tests/components/airnow/ @asymworks
+/homeassistant/components/airos/ @CoMPaTech
+/tests/components/airos/ @CoMPaTech
 /homeassistant/components/airq/ @Sibgatulin @dl2080
 /tests/components/airq/ @Sibgatulin @dl2080
 /homeassistant/components/airthings/ @danielhiversen @LaStrada
@@ -452,8 +454,8 @@ build.json @home-assistant/supervisor
 /tests/components/eq3btsmart/ @eulemitkeule @dbuezas
 /homeassistant/components/escea/ @lazdavila
 /tests/components/escea/ @lazdavila
-/homeassistant/components/esphome/ @OttoWinter @jesserockz @kbx81 @bdraco
-/tests/components/esphome/ @OttoWinter @jesserockz @kbx81 @bdraco
+/homeassistant/components/esphome/ @jesserockz @kbx81 @bdraco
+/tests/components/esphome/ @jesserockz @kbx81 @bdraco
 /homeassistant/components/eufylife_ble/ @bdr99
 /tests/components/eufylife_ble/ @bdr99
 /homeassistant/components/event/ @home-assistant/core
@@ -684,8 +686,8 @@ build.json @home-assistant/supervisor
 /tests/components/husqvarna_automower/ @Thomas55555
 /homeassistant/components/husqvarna_automower_ble/ @alistair23
 /tests/components/husqvarna_automower_ble/ @alistair23
-/homeassistant/components/huum/ @frwickst
-/tests/components/huum/ @frwickst
+/homeassistant/components/huum/ @frwickst @vincentwolsink
+/tests/components/huum/ @frwickst @vincentwolsink
 /homeassistant/components/hvv_departures/ @vigonotion
 /tests/components/hvv_departures/ @vigonotion
 /homeassistant/components/hydrawise/ @dknowles2 @thomaskistler @ptcryan
@@ -1102,6 +1104,8 @@ build.json @home-assistant/supervisor
 /tests/components/onvif/ @hunterjm @jterrace
 /homeassistant/components/open_meteo/ @frenck
 /tests/components/open_meteo/ @frenck
+/homeassistant/components/open_router/ @joostlek
+/tests/components/open_router/ @joostlek
 /homeassistant/components/openai_conversation/ @balloob
 /tests/components/openai_conversation/ @balloob
 /homeassistant/components/openerz/ @misialq
@@ -1658,6 +1662,8 @@ build.json @home-assistant/supervisor
 /tests/components/upnp/ @StevenLooman
 /homeassistant/components/uptime/ @frenck
 /tests/components/uptime/ @frenck
+/homeassistant/components/uptime_kuma/ @tr4nt0r
+/tests/components/uptime_kuma/ @tr4nt0r
 /homeassistant/components/uptimerobot/ @ludeeus @chemelli74
 /tests/components/uptimerobot/ @ludeeus @chemelli74
 /homeassistant/components/usb/ @bdraco
@@ -1702,6 +1708,8 @@ build.json @home-assistant/supervisor
 /tests/components/voip/ @balloob @synesthesiam @jaminh
 /homeassistant/components/volumio/ @OnFreund
 /tests/components/volumio/ @OnFreund
+/homeassistant/components/volvo/ @thomasddn
+/tests/components/volvo/ @thomasddn
 /homeassistant/components/volvooncall/ @molobrakos
 /tests/components/volvooncall/ @molobrakos
 /homeassistant/components/vulcan/ @Antoni-Czaplicki
@@ -1756,8 +1764,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/wirelesstag/ @sergeymaysak
 /homeassistant/components/withings/ @joostlek
 /tests/components/withings/ @joostlek
-/homeassistant/components/wiz/ @sbidy
-/tests/components/wiz/ @sbidy
+/homeassistant/components/wiz/ @sbidy @arturpragacz
+/tests/components/wiz/ @sbidy @arturpragacz
 /homeassistant/components/wled/ @frenck
 /tests/components/wled/ @frenck
 /homeassistant/components/wmspro/ @mback2k

Dockerfile.dev

@@ -1,15 +1,7 @@
-FROM mcr.microsoft.com/devcontainers/python:1-3.13
+FROM mcr.microsoft.com/vscode/devcontainers/base:debian
 
 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 \
@@ -32,21 +24,18 @@ 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
 
-# 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
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+RUN uv python install 3.13.2
 
 USER vscode
 ENV VIRTUAL_ENV="/home/vscode/.local/ha-venv"
@@ -55,6 +44,10 @@ 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
@@ -65,4 +58,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,8 +75,8 @@ from .core_config import async_process_ha_core_config
 from .exceptions import HomeAssistantError
 from .helpers import (
     area_registry,
-    backup,
     category_registry,
+    condition,
     config_validation as cv,
     device_registry,
     entity,
@@ -332,6 +332,9 @@ async def async_setup_hass(
             if not is_virtual_env():
                 await async_mount_local_lib_path(runtime_config.config_dir)
 
+            if hass.config.safe_mode:
+                _LOGGER.info("Starting in safe mode")
+
             basic_setup_success = (
                 await async_from_config_dict(config_dict, hass) is not None
             )
@@ -384,8 +387,6 @@ async def async_setup_hass(
             {"recovery_mode": {}, "http": http_conf},
             hass,
         )
-    elif hass.config.safe_mode:
-        _LOGGER.info("Starting in safe mode")
 
     if runtime_config.open_ui:
         hass.add_job(open_hass_ui, hass)
@@ -453,6 +454,7 @@ async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
         create_eager_task(restore_state.async_load(hass)),
         create_eager_task(hass.config_entries.async_initialize()),
         create_eager_task(async_get_system_info(hass)),
+        create_eager_task(condition.async_setup(hass)),
         create_eager_task(trigger.async_setup(hass)),
     )
 
@@ -607,7 +609,7 @@ async def async_enable_logging(
     )
     threading.excepthook = lambda args: logging.getLogger().exception(
         "Uncaught thread exception",
-        exc_info=(  # type: ignore[arg-type]  # noqa: LOG014
+        exc_info=(  # type: ignore[arg-type]
             args.exc_type,
             args.exc_value,
             args.exc_traceback,
@@ -693,10 +695,10 @@ async def async_mount_local_lib_path(config_dir: str) -> str:
 
 def _get_domains(hass: core.HomeAssistant, config: dict[str, Any]) -> set[str]:
     """Get domains of components to set up."""
-    # Filter out the repeating and common config section [homeassistant]
-    domains = {
-        domain for key in config if (domain := cv.domain_key(key)) != core.DOMAIN
-    }
+    # The common config section [homeassistant] could be filtered here,
+    # but that is not necessary, since it corresponds to the core integration,
+    # that is always unconditionally loaded.
+    domains = {cv.domain_key(key) for key in config}
 
     # Add config entry and default domains
     if not hass.config.recovery_mode:
@@ -724,34 +726,28 @@ async def _async_resolve_domains_and_preload(
       together with all their dependencies.
     """
     domains_to_setup = _get_domains(hass, config)
-    platform_integrations = conf_util.extract_platform_integrations(
-        config, BASE_PLATFORMS
-    )
-    # Ensure base platforms that have platform integrations are added to `domains`,
-    # so they can be setup first instead of discovering them later when a config
-    # entry setup task notices that it's needed and there is already a long line
-    # to use the import executor.
+
+    # Also process all base platforms since we do not require the manifest
+    # to list them as dependencies.
+    # We want to later avoid lock contention when multiple integrations try to load
+    # their manifests at once.
     #
+    # Additionally process integrations that are defined under base platforms
+    # to speed things up.
     # For example if we have
     # sensor:
     #   - platform: template
     #
-    # `template` has to be loaded to validate the config for sensor
-    # so we want to start loading `sensor` as soon as we know
-    # it will be needed. The more platforms under `sensor:`, the longer
+    # `template` has to be loaded to validate the config for sensor.
+    # The more platforms under `sensor:`, the longer
     # it will take to finish setup for `sensor` because each of these
     # platforms has to be imported before we can validate the config.
     #
     # Thankfully we are migrating away from the platform pattern
     # so this will be less of a problem in the future.
-    domains_to_setup.update(platform_integrations)
-
-    # Additionally process base platforms since we do not require the manifest
-    # to list them as dependencies.
-    # We want to later avoid lock contention when multiple integrations try to load
-    # their manifests at once.
-    # Also process integrations that are defined under base platforms
-    # to speed things up.
+    platform_integrations = conf_util.extract_platform_integrations(
+        config, BASE_PLATFORMS
+    )
     additional_domains_to_process = {
         *BASE_PLATFORMS,
         *chain.from_iterable(platform_integrations.values()),
@@ -869,9 +865,9 @@ async def _async_set_up_integrations(
     domains = set(integrations) & all_domains
 
     _LOGGER.info(
-        "Domains to be set up: %s | %s",
-        domains,
-        all_domains - domains,
+        "Domains to be set up: %s\nDependencies: %s",
+        domains or "{}",
+        (all_domains - domains) or "{}",
     )
 
     async_set_domains_to_be_loaded(hass, all_domains)
@@ -880,10 +876,6 @@ 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)
@@ -916,12 +908,13 @@ async def _async_set_up_integrations(
         stage_all_domains = stage_domains | stage_dep_domains
 
         _LOGGER.info(
-            "Setting up stage %s: %s | %s\nDependencies: %s | %s",
+            "Setting up stage %s: %s; already set up: %s\n"
+            "Dependencies: %s; already set up: %s",
             name,
             stage_domains,
-            stage_domains_unfiltered - stage_domains,
-            stage_dep_domains,
-            stage_dep_domains_unfiltered - stage_dep_domains,
+            (stage_domains_unfiltered - stage_domains) or "{}",
+            stage_dep_domains or "{}",
+            (stage_dep_domains_unfiltered - stage_dep_domains) or "{}",
         )
 
         if timeout is None:
@@ -1061,5 +1054,5 @@ async def _async_setup_multi_components(
             _LOGGER.error(
                 "Error setting up integration %s - received exception",
                 domain,
-                exc_info=(type(result), result, result.__traceback__),  # noqa: LOG014
+                exc_info=(type(result), result, result.__traceback__),
             )

homeassistant/brands/ubiquiti.json

@@ -1,5 +1,5 @@
 {
   "domain": "ubiquiti",
   "name": "Ubiquiti",
-  "integrations": ["unifi", "unifi_direct", "unifiled", "unifiprotect"]
+  "integrations": ["airos", "unifi", "unifi_direct", "unifiled", "unifiprotect"]
 }

homeassistant/components/ai_task/__init__.py

@@ -1,11 +1,12 @@
 """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
+from homeassistant.const import ATTR_ENTITY_ID, CONF_DESCRIPTION, CONF_SELECTOR
 from homeassistant.core import (
     HassJobType,
     HomeAssistant,
@@ -14,12 +15,15 @@ from homeassistant.core import (
     SupportsResponse,
     callback,
 )
-from homeassistant.helpers import config_validation as cv, storage
+from homeassistant.helpers import config_validation as cv, selector, storage
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import UNDEFINED, ConfigType, UndefinedType
 
 from .const import (
+    ATTR_ATTACHMENTS,
     ATTR_INSTRUCTIONS,
+    ATTR_REQUIRED,
+    ATTR_STRUCTURE,
     ATTR_TASK_NAME,
     DATA_COMPONENT,
     DATA_PREFERENCES,
@@ -47,6 +51,27 @@ _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."""
@@ -64,6 +89,13 @@ 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,
+                ),
+                vol.Optional(ATTR_ATTACHMENTS): vol.All(
+                    cv.ensure_list, [selector.MediaSelector({"accept": ["*/*"]})]
+                ),
             }
         ),
         supports_response=SupportsResponse.ONLY,

homeassistant/components/ai_task/const.py

@@ -21,6 +21,9 @@ SERVICE_GENERATE_DATA = "generate_data"
 
 ATTR_INSTRUCTIONS: Final = "instructions"
 ATTR_TASK_NAME: Final = "task_name"
+ATTR_STRUCTURE: Final = "structure"
+ATTR_REQUIRED: Final = "required"
+ATTR_ATTACHMENTS: Final = "attachments"
 
 DEFAULT_SYSTEM_PROMPT = (
     "You are a Home Assistant expert and help users with their tasks."
@@ -32,3 +35,6 @@ class AITaskEntityFeature(IntFlag):
 
     GENERATE_DATA = 1
     """Generate data based on instructions."""
+
+    SUPPORT_ATTACHMENTS = 2
+    """Support attachments with generate data."""

homeassistant/components/ai_task/entity.py

@@ -13,7 +13,7 @@ from homeassistant.components.conversation import (
 )
 from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.helpers import llm
-from homeassistant.helpers.chat_session import async_get_chat_session
+from homeassistant.helpers.chat_session import ChatSession
 from homeassistant.helpers.restore_state import RestoreEntity
 from homeassistant.util import dt as dt_util
 
@@ -56,12 +56,12 @@ class AITaskEntity(RestoreEntity):
     @contextlib.asynccontextmanager
     async def _async_get_ai_task_chat_log(
         self,
+        session: ChatSession,
         task: GenDataTask,
     ) -> AsyncGenerator[ChatLog]:
         """Context manager used to manage the ChatLog used during an AI Task."""
         # pylint: disable-next=contextmanager-generator-missing-cleanup
         with (
-            async_get_chat_session(self.hass) as session,
             async_get_chat_log(
                 self.hass,
                 session,
@@ -79,19 +79,22 @@ class AITaskEntity(RestoreEntity):
                 user_llm_prompt=DEFAULT_SYSTEM_PROMPT,
             )
 
-            chat_log.async_add_user_content(UserContent(task.instructions))
+            chat_log.async_add_user_content(
+                UserContent(task.instructions, attachments=task.attachments)
+            )
 
             yield chat_log
 
     @final
     async def internal_async_generate_data(
         self,
+        session: ChatSession,
         task: GenDataTask,
     ) -> GenDataTaskResult:
         """Run a gen data task."""
         self.__last_activity = dt_util.utcnow().isoformat()
         self.async_write_ha_state()
-        async with self._async_get_ai_task_chat_log(task) as chat_log:
+        async with self._async_get_ai_task_chat_log(session, task) as chat_log:
             return await self._async_generate_data(task, chat_log)
 
     async def _async_generate_data(

homeassistant/components/ai_task/manifest.json

@@ -1,8 +1,9 @@
 {
   "domain": "ai_task",
   "name": "AI Task",
+  "after_dependencies": ["camera"],
   "codeowners": ["@home-assistant/core"],
-  "dependencies": ["conversation"],
+  "dependencies": ["conversation", "media_source"],
   "documentation": "https://www.home-assistant.io/integrations/ai_task",
   "integration_type": "system",
   "quality_scale": "internal"

homeassistant/components/ai_task/services.yaml

@@ -10,10 +10,24 @@ generate_data:
       required: true
       selector:
         text:
+          multiline: true
     entity_id:
       required: false
       selector:
         entity:
-          domain: ai_task
-          supported_features:
-            - ai_task.AITaskEntityFeature.GENERATE_DATA
+          filter:
+            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:
+    attachments:
+      required: false
+      selector:
+        media:
+          accept:
+            - "*"

homeassistant/components/ai_task/strings.json

@@ -15,6 +15,14 @@
         "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."
+        },
+        "attachments": {
+          "name": "Attachments",
+          "description": "List of files to attach for multi-modal AI analysis."
         }
       }
     }

homeassistant/components/ai_task/task.py

@@ -3,20 +3,40 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+import mimetypes
+from pathlib import Path
+import tempfile
 from typing import Any
 
-from homeassistant.core import HomeAssistant
+import voluptuous as vol
+
+from homeassistant.components import camera, conversation, media_source
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.chat_session import async_get_chat_session
 
 from .const import DATA_COMPONENT, DATA_PREFERENCES, AITaskEntityFeature
 
 
+def _save_camera_snapshot(image: camera.Image) -> Path:
+    """Save camera snapshot to temp file."""
+    with tempfile.NamedTemporaryFile(
+        mode="wb",
+        suffix=mimetypes.guess_extension(image.content_type, False),
+        delete=False,
+    ) as temp_file:
+        temp_file.write(image.content)
+        return Path(temp_file.name)
+
+
 async def async_generate_data(
     hass: HomeAssistant,
     *,
     task_name: str,
     entity_id: str | None = None,
     instructions: str,
+    structure: vol.Schema | None = None,
+    attachments: list[dict] | None = None,
 ) -> GenDataTaskResult:
     """Run a task in the AI Task integration."""
     if entity_id is None:
@@ -34,12 +54,80 @@ async def async_generate_data(
             f"AI Task entity {entity_id} does not support generating data"
         )
 
-    return await entity.internal_async_generate_data(
-        GenDataTask(
-            name=task_name,
-            instructions=instructions,
+    # Resolve attachments
+    resolved_attachments: list[conversation.Attachment] = []
+    created_files: list[Path] = []
+
+    if (
+        attachments
+        and AITaskEntityFeature.SUPPORT_ATTACHMENTS not in entity.supported_features
+    ):
+        raise HomeAssistantError(
+            f"AI Task entity {entity_id} does not support attachments"
+        )
+
+    for attachment in attachments or []:
+        media_content_id = attachment["media_content_id"]
+
+        # Special case for camera media sources
+        if media_content_id.startswith("media-source://camera/"):
+            # Extract entity_id from the media content ID
+            entity_id = media_content_id.removeprefix("media-source://camera/")
+
+            # Get snapshot from camera
+            image = await camera.async_get_image(hass, entity_id)
+
+            temp_filename = await hass.async_add_executor_job(
+                _save_camera_snapshot, image
+            )
+            created_files.append(temp_filename)
+
+            resolved_attachments.append(
+                conversation.Attachment(
+                    media_content_id=media_content_id,
+                    mime_type=image.content_type,
+                    path=temp_filename,
+                )
+            )
+        else:
+            # Handle regular media sources
+            media = await media_source.async_resolve_media(hass, media_content_id, None)
+            if media.path is None:
+                raise HomeAssistantError(
+                    "Only local attachments are currently supported"
+                )
+            resolved_attachments.append(
+                conversation.Attachment(
+                    media_content_id=media_content_id,
+                    mime_type=media.mime_type,
+                    path=media.path,
+                )
+            )
+
+    with async_get_chat_session(hass) as session:
+        if created_files:
+
+            def cleanup_files() -> None:
+                """Cleanup temporary files."""
+                for file in created_files:
+                    file.unlink(missing_ok=True)
+
+            @callback
+            def cleanup_files_callback() -> None:
+                """Cleanup temporary files."""
+                hass.async_add_executor_job(cleanup_files)
+
+            session.async_on_cleanup(cleanup_files_callback)
+
+        return await entity.internal_async_generate_data(
+            session,
+            GenDataTask(
+                name=task_name,
+                instructions=instructions,
+                structure=structure,
+                attachments=resolved_attachments or None,
+            ),
         )
-    )
 
 
 @dataclass(slots=True)
@@ -52,6 +140,12 @@ class GenDataTask:
     instructions: str
     """Instructions on what needs to be done."""
 
+    structure: vol.Schema | None = None
+    """Optional structure for the data to be generated."""
+
+    attachments: list[conversation.Attachment] | None = None
+    """List of attachments to go along the instructions."""
+
     def __str__(self) -> str:
         """Return task as a string."""
         return f"<GenDataTask {self.name}: {id(self)}>"

homeassistant/components/airgradient/manifest.json

@@ -6,6 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/airgradient",
   "integration_type": "device",
   "iot_class": "local_polling",
+  "quality_scale": "platinum",
   "requirements": ["airgradient==0.9.2"],
   "zeroconf": ["_airgradient._tcp.local."]
 }

homeassistant/components/airgradient/quality_scale.yaml

@@ -14,9 +14,9 @@ rules:
     status: exempt
     comment: |
       This integration does not provide additional actions.
-  docs-high-level-description: todo
-  docs-installation-instructions: todo
-  docs-removal-instructions: todo
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
   entity-event-setup:
     status: exempt
     comment: |
@@ -34,7 +34,7 @@ rules:
   docs-configuration-parameters:
     status: exempt
     comment: No options to configure
-  docs-installation-parameters: todo
+  docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
@@ -43,23 +43,19 @@ rules:
     status: exempt
     comment: |
       This integration does not require authentication.
-  test-coverage: todo
+  test-coverage: done
   # Gold
   devices: done
   diagnostics: done
-  discovery-update-info:
-    status: todo
-    comment: DHCP is still possible
-  discovery:
-    status: todo
-    comment: DHCP is still possible
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
+  discovery-update-info: done
+  discovery: done
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
   dynamic-devices:
     status: exempt
     comment: |

homeassistant/components/airnow/__init__.py

@@ -45,9 +45,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirNowConfigEntry) -> bo
     # Store Entity and Initialize Platforms
     entry.runtime_data = coordinator
 
-    # Listen for option changes
-    entry.async_on_unload(entry.add_update_listener(update_listener))
-
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     # Clean up unused device entries with no entities
@@ -88,8 +85,3 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 async def async_unload_entry(hass: HomeAssistant, entry: AirNowConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-
-async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
-    """Handle options update."""
-    await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/airnow/config_flow.py

@@ -13,7 +13,7 @@ from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
-    OptionsFlow,
+    OptionsFlowWithReload,
 )
 from homeassistant.const import CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE, CONF_RADIUS
 from homeassistant.core import HomeAssistant, callback
@@ -126,7 +126,7 @@ class AirNowConfigFlow(ConfigFlow, domain=DOMAIN):
         return AirNowOptionsFlowHandler()
 
 
-class AirNowOptionsFlowHandler(OptionsFlow):
+class AirNowOptionsFlowHandler(OptionsFlowWithReload):
     """Handle an options flow for AirNow."""
 
     async def async_step_init(

homeassistant/components/airos/__init__.py

@@ -0,0 +1,42 @@
+"""The Ubiquiti airOS integration."""
+
+from __future__ import annotations
+
+from airos.airos8 import AirOS
+
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .coordinator import AirOSConfigEntry, AirOSDataUpdateCoordinator
+
+_PLATFORMS: list[Platform] = [Platform.SENSOR]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
+    """Set up Ubiquiti airOS from a config entry."""
+
+    # By default airOS 8 comes with self-signed SSL certificates,
+    # with no option in the web UI to change or upload a custom certificate.
+    session = async_get_clientsession(hass, verify_ssl=False)
+
+    airos_device = AirOS(
+        host=entry.data[CONF_HOST],
+        username=entry.data[CONF_USERNAME],
+        password=entry.data[CONF_PASSWORD],
+        session=session,
+    )
+
+    coordinator = AirOSDataUpdateCoordinator(hass, entry, airos_device)
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)

homeassistant/components/airos/config_flow.py

@@ -0,0 +1,82 @@
+"""Config flow for the Ubiquiti airOS integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from airos.exceptions import (
+    ConnectionAuthenticationError,
+    ConnectionSetupError,
+    DataMissingError,
+    DeviceConnectionError,
+    KeyDataMissingError,
+)
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+from .coordinator import AirOS
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_HOST): str,
+        vol.Required(CONF_USERNAME, default="ubnt"): str,
+        vol.Required(CONF_PASSWORD): str,
+    }
+)
+
+
+class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Ubiquiti airOS."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            # By default airOS 8 comes with self-signed SSL certificates,
+            # with no option in the web UI to change or upload a custom certificate.
+            session = async_get_clientsession(self.hass, verify_ssl=False)
+
+            airos_device = AirOS(
+                host=user_input[CONF_HOST],
+                username=user_input[CONF_USERNAME],
+                password=user_input[CONF_PASSWORD],
+                session=session,
+            )
+            try:
+                await airos_device.login()
+                airos_data = await airos_device.status()
+
+            except (
+                ConnectionSetupError,
+                DeviceConnectionError,
+            ):
+                errors["base"] = "cannot_connect"
+            except (ConnectionAuthenticationError, DataMissingError):
+                errors["base"] = "invalid_auth"
+            except KeyDataMissingError:
+                errors["base"] = "key_data_missing"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                await self.async_set_unique_id(airos_data.derived.mac)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(
+                    title=airos_data.host.hostname, data=user_input
+                )
+
+        return self.async_show_form(
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
+        )

homeassistant/components/airos/const.py

@@ -0,0 +1,9 @@
+"""Constants for the Ubiquiti airOS integration."""
+
+from datetime import timedelta
+
+DOMAIN = "airos"
+
+SCAN_INTERVAL = timedelta(minutes=1)
+
+MANUFACTURER = "Ubiquiti"

homeassistant/components/airos/coordinator.py

@@ -0,0 +1,66 @@
+"""DataUpdateCoordinator for AirOS."""
+
+from __future__ import annotations
+
+import logging
+
+from airos.airos8 import AirOS, AirOSData
+from airos.exceptions import (
+    ConnectionAuthenticationError,
+    ConnectionSetupError,
+    DataMissingError,
+    DeviceConnectionError,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN, SCAN_INTERVAL
+
+_LOGGER = logging.getLogger(__name__)
+
+type AirOSConfigEntry = ConfigEntry[AirOSDataUpdateCoordinator]
+
+
+class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOSData]):
+    """Class to manage fetching AirOS data from single endpoint."""
+
+    config_entry: AirOSConfigEntry
+
+    def __init__(
+        self, hass: HomeAssistant, config_entry: AirOSConfigEntry, airos_device: AirOS
+    ) -> None:
+        """Initialize the coordinator."""
+        self.airos_device = airos_device
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=DOMAIN,
+            update_interval=SCAN_INTERVAL,
+        )
+
+    async def _async_update_data(self) -> AirOSData:
+        """Fetch data from AirOS."""
+        try:
+            await self.airos_device.login()
+            return await self.airos_device.status()
+        except (ConnectionAuthenticationError,) as err:
+            _LOGGER.exception("Error authenticating with airOS device")
+            raise ConfigEntryError(
+                translation_domain=DOMAIN, translation_key="invalid_auth"
+            ) from err
+        except (ConnectionSetupError, DeviceConnectionError, TimeoutError) as err:
+            _LOGGER.error("Error connecting to airOS device: %s", err)
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect",
+            ) from err
+        except (DataMissingError,) as err:
+            _LOGGER.error("Expected data not returned by airOS device: %s", err)
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="error_data_missing",
+            ) from err

homeassistant/components/airos/entity.py

@@ -0,0 +1,36 @@
+"""Generic AirOS Entity Class."""
+
+from __future__ import annotations
+
+from homeassistant.const import CONF_HOST
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN, MANUFACTURER
+from .coordinator import AirOSDataUpdateCoordinator
+
+
+class AirOSEntity(CoordinatorEntity[AirOSDataUpdateCoordinator]):
+    """Represent a AirOS Entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, coordinator: AirOSDataUpdateCoordinator) -> None:
+        """Initialise the gateway."""
+        super().__init__(coordinator)
+
+        airos_data = self.coordinator.data
+
+        configuration_url: str | None = (
+            f"https://{coordinator.config_entry.data[CONF_HOST]}"
+        )
+
+        self._attr_device_info = DeviceInfo(
+            connections={(CONNECTION_NETWORK_MAC, airos_data.derived.mac)},
+            configuration_url=configuration_url,
+            identifiers={(DOMAIN, str(airos_data.host.device_id))},
+            manufacturer=MANUFACTURER,
+            model=airos_data.host.devmodel,
+            name=airos_data.host.hostname,
+            sw_version=airos_data.host.fwversion,
+        )

homeassistant/components/airos/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "airos",
+  "name": "Ubiquiti airOS",
+  "codeowners": ["@CoMPaTech"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/airos",
+  "iot_class": "local_polling",
+  "quality_scale": "bronze",
+  "requirements": ["airos==0.2.1"]
+}

homeassistant/components/airos/quality_scale.yaml

@@ -0,0 +1,72 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: airOS does not have actions
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: airOS does not have actions
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: local_polling without events
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: airOS does not have actions
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: todo
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates: todo
+  reauthentication-flow: todo
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: done
+  docs-examples: todo
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: todo
+  docs-troubleshooting: done
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default:
+    status: todo
+    comment: prepared binary_sensors will provide this
+  entity-translations: done
+  exception-translations: done
+  icon-translations:
+    status: exempt
+    comment: no (custom) icons used or envisioned
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/airos/sensor.py

@@ -0,0 +1,152 @@
+"""AirOS Sensor component for Home Assistant."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+import logging
+
+from airos.data import NetRole, WirelessMode
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import (
+    PERCENTAGE,
+    SIGNAL_STRENGTH_DECIBELS,
+    UnitOfDataRate,
+    UnitOfFrequency,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
+
+from .coordinator import AirOSConfigEntry, AirOSData, AirOSDataUpdateCoordinator
+from .entity import AirOSEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+WIRELESS_MODE_OPTIONS = [mode.value.replace("-", "_").lower() for mode in WirelessMode]
+NETROLE_OPTIONS = [mode.value for mode in NetRole]
+
+
+@dataclass(frozen=True, kw_only=True)
+class AirOSSensorEntityDescription(SensorEntityDescription):
+    """Describe an AirOS sensor."""
+
+    value_fn: Callable[[AirOSData], StateType]
+
+
+SENSORS: tuple[AirOSSensorEntityDescription, ...] = (
+    AirOSSensorEntityDescription(
+        key="host_cpuload",
+        translation_key="host_cpuload",
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: data.host.cpuload,
+        entity_registry_enabled_default=False,
+    ),
+    AirOSSensorEntityDescription(
+        key="host_netrole",
+        translation_key="host_netrole",
+        device_class=SensorDeviceClass.ENUM,
+        value_fn=lambda data: data.host.netrole.value,
+        options=NETROLE_OPTIONS,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_frequency",
+        translation_key="wireless_frequency",
+        native_unit_of_measurement=UnitOfFrequency.MEGAHERTZ,
+        device_class=SensorDeviceClass.FREQUENCY,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: data.wireless.frequency,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_essid",
+        translation_key="wireless_essid",
+        value_fn=lambda data: data.wireless.essid,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_mode",
+        translation_key="wireless_mode",
+        device_class=SensorDeviceClass.ENUM,
+        value_fn=lambda data: data.wireless.mode.value.replace("-", "_").lower(),
+        options=WIRELESS_MODE_OPTIONS,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_antenna_gain",
+        translation_key="wireless_antenna_gain",
+        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS,
+        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: data.wireless.antenna_gain,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_throughput_tx",
+        translation_key="wireless_throughput_tx",
+        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
+        device_class=SensorDeviceClass.DATA_RATE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: data.wireless.throughput.tx,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_throughput_rx",
+        translation_key="wireless_throughput_rx",
+        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
+        device_class=SensorDeviceClass.DATA_RATE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: data.wireless.throughput.rx,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_polling_dl_capacity",
+        translation_key="wireless_polling_dl_capacity",
+        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
+        device_class=SensorDeviceClass.DATA_RATE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: data.wireless.polling.dl_capacity,
+    ),
+    AirOSSensorEntityDescription(
+        key="wireless_polling_ul_capacity",
+        translation_key="wireless_polling_ul_capacity",
+        native_unit_of_measurement=UnitOfDataRate.KILOBITS_PER_SECOND,
+        device_class=SensorDeviceClass.DATA_RATE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda data: data.wireless.polling.ul_capacity,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: AirOSConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the AirOS sensors from a config entry."""
+    coordinator = config_entry.runtime_data
+
+    async_add_entities(AirOSSensor(coordinator, description) for description in SENSORS)
+
+
+class AirOSSensor(AirOSEntity, SensorEntity):
+    """Representation of a Sensor."""
+
+    entity_description: AirOSSensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: AirOSDataUpdateCoordinator,
+        description: AirOSSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        super().__init__(coordinator)
+
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.data.derived.mac}_{description.key}"
+
+    @property
+    def native_value(self) -> StateType:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self.coordinator.data)

homeassistant/components/airos/strings.json

@@ -0,0 +1,87 @@
+{
+  "config": {
+    "flow_title": "Ubiquiti airOS device",
+    "step": {
+      "user": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]",
+          "username": "[%key:common::config_flow::data::username%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "host": "IP address or hostname of the airOS device",
+          "username": "Administrator username for the airOS device, normally 'ubnt'",
+          "password": "Password configured through the UISP app or web interface"
+        }
+      }
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "key_data_missing": "Expected data not returned from the device, check the documentation for supported devices",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    }
+  },
+  "entity": {
+    "sensor": {
+      "host_cpuload": {
+        "name": "CPU load"
+      },
+      "host_netrole": {
+        "name": "Network role",
+        "state": {
+          "bridge": "Bridge",
+          "router": "Router"
+        }
+      },
+      "wireless_frequency": {
+        "name": "Wireless frequency"
+      },
+      "wireless_essid": {
+        "name": "Wireless SSID"
+      },
+      "wireless_mode": {
+        "name": "Wireless mode",
+        "state": {
+          "ap_ptp": "Access point",
+          "sta_ptp": "Station"
+        }
+      },
+      "wireless_antenna_gain": {
+        "name": "Antenna gain"
+      },
+      "wireless_throughput_tx": {
+        "name": "Throughput transmit (actual)"
+      },
+      "wireless_throughput_rx": {
+        "name": "Throughput receive (actual)"
+      },
+      "wireless_polling_dl_capacity": {
+        "name": "Download capacity"
+      },
+      "wireless_polling_ul_capacity": {
+        "name": "Upload capacity"
+      },
+      "wireless_remote_hostname": {
+        "name": "Remote hostname"
+      }
+    }
+  },
+  "exceptions": {
+    "invalid_auth": {
+      "message": "[%key:common::config_flow::error::invalid_auth%]"
+    },
+    "cannot_connect": {
+      "message": "[%key:common::config_flow::error::cannot_connect%]"
+    },
+    "key_data_missing": {
+      "message": "Key data not returned from device"
+    },
+    "error_data_missing": {
+      "message": "Data incomplete or missing"
+    }
+  }
+}

homeassistant/components/airq/const.py

@@ -6,6 +6,5 @@ CONF_RETURN_AVERAGE: Final = "return_average"
 CONF_CLIP_NEGATIVE: Final = "clip_negatives"
 DOMAIN: Final = "airq"
 MANUFACTURER: Final = "CorantGmbH"
-CONCENTRATION_GRAMS_PER_CUBIC_METER: Final = "g/m³"
 ACTIVITY_BECQUEREL_PER_CUBIC_METER: Final = "Bq/m³"
 UPDATE_INTERVAL: float = 10.0

homeassistant/components/airq/icons.json

@@ -4,9 +4,6 @@
       "health_index": {
         "default": "mdi:heart-pulse"
       },
-      "absolute_humidity": {
-        "default": "mdi:water"
-      },
       "oxygen": {
         "default": "mdi:leaf"
       },

homeassistant/components/airq/sensor.py

@@ -14,6 +14,7 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import (
+    CONCENTRATION_GRAMS_PER_CUBIC_METER,
     CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
     CONCENTRATION_MILLIGRAMS_PER_CUBIC_METER,
     CONCENTRATION_PARTS_PER_BILLION,
@@ -28,10 +29,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from . import AirQConfigEntry, AirQCoordinator
-from .const import (
-    ACTIVITY_BECQUEREL_PER_CUBIC_METER,
-    CONCENTRATION_GRAMS_PER_CUBIC_METER,
-)
+from .const import ACTIVITY_BECQUEREL_PER_CUBIC_METER
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -195,7 +193,7 @@ SENSOR_TYPES: list[AirQEntityDescription] = [
     ),
     AirQEntityDescription(
         key="humidity_abs",
-        translation_key="absolute_humidity",
+        device_class=SensorDeviceClass.ABSOLUTE_HUMIDITY,
         native_unit_of_measurement=CONCENTRATION_GRAMS_PER_CUBIC_METER,
         state_class=SensorStateClass.MEASUREMENT,
         value=lambda data: data.get("humidity_abs"),

homeassistant/components/airq/strings.json

@@ -93,9 +93,6 @@
       "health_index": {
         "name": "Health index"
       },
-      "absolute_humidity": {
-        "name": "Absolute humidity"
-      },
       "hydrogen": {
         "name": "Hydrogen"
       },

homeassistant/components/airthings/config_flow.py

@@ -45,6 +45,8 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
             )
 
         errors = {}
+        await self.async_set_unique_id(user_input[CONF_ID])
+        self._abort_if_unique_id_configured()
 
         try:
             await airthings.get_token(
@@ -60,9 +62,6 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
             _LOGGER.exception("Unexpected exception")
             errors["base"] = "unknown"
         else:
-            await self.async_set_unique_id(user_input[CONF_ID])
-            self._abort_if_unique_id_configured()
-
             return self.async_create_entry(title="Airthings", data=user_input)
 
         return self.async_show_form(

homeassistant/components/airthings/sensor.py

@@ -150,7 +150,7 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
     entities = [
-        AirthingsHeaterEnergySensor(
+        AirthingsDeviceSensor(
             coordinator,
             airthings_device,
             SENSORS[sensor_types],
@@ -162,7 +162,7 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class AirthingsHeaterEnergySensor(
+class AirthingsDeviceSensor(
     CoordinatorEntity[AirthingsDataUpdateCoordinator], SensorEntity
 ):
     """Representation of a Airthings Sensor device."""

homeassistant/components/airzone_cloud/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/airzone_cloud",
   "iot_class": "cloud_push",
   "loggers": ["aioairzone_cloud"],
-  "requirements": ["aioairzone-cloud==0.6.12"]
+  "requirements": ["aioairzone-cloud==0.7.1"]
 }

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,19 +2,50 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from typing import Any
 
 from aioamazondevices.api import AmazonEchoApi
-from aioamazondevices.exceptions import CannotAuthenticate, CannotConnect
+from aioamazondevices.exceptions import (
+    CannotAuthenticate,
+    CannotConnect,
+    CannotRetrieveData,
+    WrongCountry,
+)
 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."""
@@ -25,17 +56,16 @@ 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 client.login_mode_interactive(user_input[CONF_CODE])
+                data = await validate_input(self.hass, user_input)
             except CannotConnect:
                 errors["base"] = "cannot_connect"
             except CannotAuthenticate:
                 errors["base"] = "invalid_auth"
+            except CannotRetrieveData:
+                errors["base"] = "cannot_retrieve_data"
+            except WrongCountry:
+                errors["base"] = "wrong_country"
             else:
                 await self.async_set_unique_id(data["customer_info"]["user_id"])
                 self._abort_if_unique_id_configured()
@@ -44,8 +74,6 @@ 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",
@@ -61,3 +89,45 @@ 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"
+            except CannotRetrieveData:
+                errors["base"] = "cannot_retrieve_data"
+            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 ConfigEntryError
+from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import _LOGGER, CONF_LOGIN_DATA
+from .const import _LOGGER, CONF_LOGIN_DATA, DOMAIN
 
 SCAN_INTERVAL = 30
 
@@ -52,7 +52,21 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
         try:
             await self.api.login_mode_stored_data()
             return await self.api.get_devices_data()
-        except (CannotConnect, CannotRetrieveData) as err:
-            raise UpdateFailed(f"Error occurred while updating {self.name}") from err
+        except CannotConnect as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect_with_error",
+                translation_placeholders={"error": repr(err)},
+            ) from err
+        except CannotRetrieveData as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_retrieve_data_with_error",
+                translation_placeholders={"error": repr(err)},
+            ) from err
         except CannotAuthenticate as err:
-            raise ConfigEntryError("Could not authenticate") from err
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="invalid_auth",
+                translation_placeholders={"error": repr(err)},
+            ) from err

homeassistant/components/alexa_devices/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
-  "quality_scale": "bronze",
-  "requirements": ["aioamazondevices==3.1.22"]
+  "quality_scale": "silver",
+  "requirements": ["aioamazondevices==3.5.1"]
 }

homeassistant/components/alexa_devices/quality_scale.yaml

@@ -28,39 +28,37 @@ rules:
   # Silver
   action-exceptions: done
   config-entry-unloading: done
-  docs-configuration-parameters: todo
-  docs-installation-parameters: todo
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow: todo
-  test-coverage:
-    status: todo
-    comment: all tests missing
+  reauthentication-flow: done
+  test-coverage: done
 
   # Gold
   devices: done
-  diagnostics: todo
+  diagnostics: done
   discovery-update-info:
     status: exempt
     comment: Network information not relevant
   discovery:
     status: exempt
     comment: There are a ton of mac address ranges in use, but also by kindles which are not supported by this integration
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
   dynamic-devices: todo
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done
   entity-translations: done
-  exception-translations: todo
+  exception-translations: done
   icon-translations: done
   reconfiguration-flow: todo
   repair-issues:

homeassistant/components/alexa_devices/strings.json

@@ -22,17 +22,30 @@
           "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": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "cannot_retrieve_data": "Unable to retrieve data from Amazon. Please try again later.",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "wrong_country": "Wrong country selected. Please select the country where your Amazon account is registered.",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     }
   },
@@ -72,10 +85,10 @@
     }
   },
   "exceptions": {
-    "cannot_connect": {
+    "cannot_connect_with_error": {
       "message": "Error connecting: {error}"
     },
-    "cannot_retrieve_data": {
+    "cannot_retrieve_data_with_error": {
       "message": "Error retrieving data: {error}"
     }
   }

homeassistant/components/alexa_devices/utils.py

@@ -26,14 +26,14 @@ def alexa_api_call[_T: AmazonEntity, **_P](
             self.coordinator.last_update_success = False
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
-                translation_key="cannot_connect",
+                translation_key="cannot_connect_with_error",
                 translation_placeholders={"error": repr(err)},
             ) from err
         except CannotRetrieveData as err:
             self.coordinator.last_update_success = False
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
-                translation_key="cannot_retrieve_data",
+                translation_key="cannot_retrieve_data_with_error",
                 translation_placeholders={"error": repr(err)},
             ) from err
 

homeassistant/components/amberelectric/__init__.py

@@ -2,11 +2,22 @@
 
 import amberelectric
 
+from homeassistant.components.sensor import ConfigType
 from homeassistant.const import CONF_API_TOKEN
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 
-from .const import CONF_SITE_ID, PLATFORMS
+from .const import CONF_SITE_ID, DOMAIN, PLATFORMS
 from .coordinator import AmberConfigEntry, AmberUpdateCoordinator
+from .services import setup_services
+
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Amber component."""
+    setup_services(hass)
+    return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AmberConfigEntry) -> bool:

homeassistant/components/amberelectric/const.py

@@ -1,14 +1,24 @@
 """Amber Electric Constants."""
 
 import logging
+from typing import Final
 
 from homeassistant.const import Platform
 
-DOMAIN = "amberelectric"
+DOMAIN: Final = "amberelectric"
 CONF_SITE_NAME = "site_name"
 CONF_SITE_ID = "site_id"
 
+ATTR_CONFIG_ENTRY_ID = "config_entry_id"
+ATTR_CHANNEL_TYPE = "channel_type"
+
 ATTRIBUTION = "Data provided by Amber Electric"
 
 LOGGER = logging.getLogger(__package__)
 PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR]
+
+SERVICE_GET_FORECASTS = "get_forecasts"
+
+GENERAL_CHANNEL = "general"
+CONTROLLED_LOAD_CHANNEL = "controlled_load"
+FEED_IN_CHANNEL = "feed_in"

homeassistant/components/amberelectric/coordinator.py

@@ -10,7 +10,6 @@ from amberelectric.models.actual_interval import ActualInterval
 from amberelectric.models.channel import ChannelType
 from amberelectric.models.current_interval import CurrentInterval
 from amberelectric.models.forecast_interval import ForecastInterval
-from amberelectric.models.price_descriptor import PriceDescriptor
 from amberelectric.rest import ApiException
 
 from homeassistant.config_entries import ConfigEntry
@@ -18,6 +17,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import LOGGER
+from .helpers import normalize_descriptor
 
 type AmberConfigEntry = ConfigEntry[AmberUpdateCoordinator]
 
@@ -49,27 +49,6 @@ def is_feed_in(interval: ActualInterval | CurrentInterval | ForecastInterval) ->
     return interval.channel_type == ChannelType.FEEDIN
 
 
-def normalize_descriptor(descriptor: PriceDescriptor | None) -> str | None:
-    """Return the snake case versions of descriptor names. Returns None if the name is not recognized."""
-    if descriptor is None:
-        return None
-    if descriptor.value == "spike":
-        return "spike"
-    if descriptor.value == "high":
-        return "high"
-    if descriptor.value == "neutral":
-        return "neutral"
-    if descriptor.value == "low":
-        return "low"
-    if descriptor.value == "veryLow":
-        return "very_low"
-    if descriptor.value == "extremelyLow":
-        return "extremely_low"
-    if descriptor.value == "negative":
-        return "negative"
-    return None
-
-
 class AmberUpdateCoordinator(DataUpdateCoordinator):
     """AmberUpdateCoordinator - In charge of downloading the data for a site, which all the sensors read."""
 
@@ -103,7 +82,7 @@ class AmberUpdateCoordinator(DataUpdateCoordinator):
             "grid": {},
         }
         try:
-            data = self._api.get_current_prices(self.site_id, next=48)
+            data = self._api.get_current_prices(self.site_id, next=288)
             intervals = [interval.actual_instance for interval in data]
         except ApiException as api_exception:
             raise UpdateFailed("Missing price data, skipping update") from api_exception

homeassistant/components/amberelectric/helpers.py

@@ -0,0 +1,25 @@
+"""Formatting helpers used to convert things."""
+
+from amberelectric.models.price_descriptor import PriceDescriptor
+
+DESCRIPTOR_MAP: dict[str, str] = {
+    PriceDescriptor.SPIKE: "spike",
+    PriceDescriptor.HIGH: "high",
+    PriceDescriptor.NEUTRAL: "neutral",
+    PriceDescriptor.LOW: "low",
+    PriceDescriptor.VERYLOW: "very_low",
+    PriceDescriptor.EXTREMELYLOW: "extremely_low",
+    PriceDescriptor.NEGATIVE: "negative",
+}
+
+
+def normalize_descriptor(descriptor: PriceDescriptor | None) -> str | None:
+    """Return the snake case versions of descriptor names. Returns None if the name is not recognized."""
+    if descriptor in DESCRIPTOR_MAP:
+        return DESCRIPTOR_MAP[descriptor]
+    return None
+
+
+def format_cents_to_dollars(cents: float) -> float:
+    """Return a formatted conversion from cents to dollars."""
+    return round(cents / 100, 2)

homeassistant/components/amberelectric/icons.json

@@ -22,5 +22,10 @@
         }
       }
     }
+  },
+  "services": {
+    "get_forecasts": {
+      "service": "mdi:transmission-tower"
+    }
   }
 }

homeassistant/components/amberelectric/sensor.py

@@ -23,16 +23,12 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import ATTRIBUTION
-from .coordinator import AmberConfigEntry, AmberUpdateCoordinator, normalize_descriptor
+from .coordinator import AmberConfigEntry, AmberUpdateCoordinator
+from .helpers import format_cents_to_dollars, normalize_descriptor
 
 UNIT = f"{CURRENCY_DOLLAR}/{UnitOfEnergy.KILO_WATT_HOUR}"
 
 
-def format_cents_to_dollars(cents: float) -> float:
-    """Return a formatted conversion from cents to dollars."""
-    return round(cents / 100, 2)
-
-
 def friendly_channel_type(channel_type: str) -> str:
     """Return a human readable version of the channel type."""
     if channel_type == "controlled_load":

homeassistant/components/amberelectric/services.py

@@ -0,0 +1,121 @@
+"""Amber Electric Service class."""
+
+from amberelectric.models.channel import ChannelType
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.core import (
+    HomeAssistant,
+    ServiceCall,
+    ServiceResponse,
+    SupportsResponse,
+)
+from homeassistant.exceptions import ServiceValidationError
+from homeassistant.helpers.selector import ConfigEntrySelector
+from homeassistant.util.json import JsonValueType
+
+from .const import (
+    ATTR_CHANNEL_TYPE,
+    ATTR_CONFIG_ENTRY_ID,
+    CONTROLLED_LOAD_CHANNEL,
+    DOMAIN,
+    FEED_IN_CHANNEL,
+    GENERAL_CHANNEL,
+    SERVICE_GET_FORECASTS,
+)
+from .coordinator import AmberConfigEntry
+from .helpers import format_cents_to_dollars, normalize_descriptor
+
+GET_FORECASTS_SCHEMA = vol.Schema(
+    {
+        ATTR_CONFIG_ENTRY_ID: ConfigEntrySelector({"integration": DOMAIN}),
+        ATTR_CHANNEL_TYPE: vol.In(
+            [GENERAL_CHANNEL, CONTROLLED_LOAD_CHANNEL, FEED_IN_CHANNEL]
+        ),
+    }
+)
+
+
+def async_get_entry(hass: HomeAssistant, config_entry_id: str) -> AmberConfigEntry:
+    """Get the Amber config entry."""
+    if not (entry := hass.config_entries.async_get_entry(config_entry_id)):
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="integration_not_found",
+            translation_placeholders={"target": config_entry_id},
+        )
+    if entry.state is not ConfigEntryState.LOADED:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="not_loaded",
+            translation_placeholders={"target": entry.title},
+        )
+    return entry
+
+
+def get_forecasts(channel_type: str, data: dict) -> list[JsonValueType]:
+    """Return an array of forecasts."""
+    results: list[JsonValueType] = []
+
+    if channel_type not in data["forecasts"]:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="channel_not_found",
+            translation_placeholders={"channel_type": channel_type},
+        )
+
+    intervals = data["forecasts"][channel_type]
+
+    for interval in intervals:
+        datum = {}
+        datum["duration"] = interval.duration
+        datum["date"] = interval.var_date.isoformat()
+        datum["nem_date"] = interval.nem_time.isoformat()
+        datum["per_kwh"] = format_cents_to_dollars(interval.per_kwh)
+        if interval.channel_type == ChannelType.FEEDIN:
+            datum["per_kwh"] = datum["per_kwh"] * -1
+        datum["spot_per_kwh"] = format_cents_to_dollars(interval.spot_per_kwh)
+        datum["start_time"] = interval.start_time.isoformat()
+        datum["end_time"] = interval.end_time.isoformat()
+        datum["renewables"] = round(interval.renewables)
+        datum["spike_status"] = interval.spike_status.value
+        datum["descriptor"] = normalize_descriptor(interval.descriptor)
+
+        if interval.range is not None:
+            datum["range_min"] = format_cents_to_dollars(interval.range.min)
+            datum["range_max"] = format_cents_to_dollars(interval.range.max)
+
+        if interval.advanced_price is not None:
+            multiplier = -1 if interval.channel_type == ChannelType.FEEDIN else 1
+            datum["advanced_price_low"] = multiplier * format_cents_to_dollars(
+                interval.advanced_price.low
+            )
+            datum["advanced_price_predicted"] = multiplier * format_cents_to_dollars(
+                interval.advanced_price.predicted
+            )
+            datum["advanced_price_high"] = multiplier * format_cents_to_dollars(
+                interval.advanced_price.high
+            )
+
+        results.append(datum)
+
+    return results
+
+
+def setup_services(hass: HomeAssistant) -> None:
+    """Set up the services for the Amber integration."""
+
+    async def handle_get_forecasts(call: ServiceCall) -> ServiceResponse:
+        channel_type = call.data[ATTR_CHANNEL_TYPE]
+        entry = async_get_entry(hass, call.data[ATTR_CONFIG_ENTRY_ID])
+        coordinator = entry.runtime_data
+        forecasts = get_forecasts(channel_type, coordinator.data)
+        return {"forecasts": forecasts}
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_GET_FORECASTS,
+        handle_get_forecasts,
+        GET_FORECASTS_SCHEMA,
+        supports_response=SupportsResponse.ONLY,
+    )

homeassistant/components/amberelectric/services.yaml

@@ -0,0 +1,16 @@
+get_forecasts:
+  fields:
+    config_entry_id:
+      required: true
+      selector:
+        config_entry:
+          integration: amberelectric
+    channel_type:
+      required: true
+      selector:
+        select:
+          options:
+            - general
+            - controlled_load
+            - feed_in
+          translation_key: channel_type

homeassistant/components/amberelectric/strings.json

@@ -1,25 +1,61 @@
 {
   "config": {
+    "error": {
+      "invalid_api_token": "[%key:common::config_flow::error::invalid_api_key%]",
+      "no_site": "No site provided",
+      "unknown_error": "[%key:common::config_flow::error::unknown%]"
+    },
     "step": {
+      "site": {
+        "data": {
+          "site_id": "Site NMI",
+          "site_name": "Site name"
+        },
+        "description": "Select the NMI of the site you would like to add"
+      },
       "user": {
         "data": {
           "api_token": "[%key:common::config_flow::data::api_token%]",
           "site_id": "Site ID"
         },
         "description": "Go to {api_url} to generate an API key"
-      },
-      "site": {
-        "data": {
-          "site_id": "Site NMI",
-          "site_name": "Site Name"
-        },
-        "description": "Select the NMI of the site you would like to add"
       }
+    }
+  },
+  "services": {
+    "get_forecasts": {
+      "name": "Get price forecasts",
+      "description": "Retrieves price forecasts from Amber Electric for a site.",
+      "fields": {
+        "config_entry_id": {
+          "description": "The config entry of the site to get forecasts for.",
+          "name": "Config entry"
+        },
+        "channel_type": {
+          "name": "Channel type",
+          "description": "The channel to get forecasts for."
+        }
+      }
+    }
+  },
+  "exceptions": {
+    "integration_not_found": {
+      "message": "Config entry \"{target}\" not found in registry."
     },
-    "error": {
-      "invalid_api_token": "[%key:common::config_flow::error::invalid_api_key%]",
-      "no_site": "No site provided",
-      "unknown_error": "[%key:common::config_flow::error::unknown%]"
+    "not_loaded": {
+      "message": "{target} is not loaded."
+    },
+    "channel_not_found": {
+      "message": "There is no {channel_type} channel at this site."
+    }
+  },
+  "selector": {
+    "channel_type": {
+      "options": {
+        "general": "General",
+        "controlled_load": "Controlled load",
+        "feed_in": "Feed-in"
+      }
     }
   }
 }

homeassistant/components/amcrest/manifest.json

@@ -7,5 +7,5 @@
   "iot_class": "local_polling",
   "loggers": ["amcrest"],
   "quality_scale": "legacy",
-  "requirements": ["amcrest==1.9.8"]
+  "requirements": ["amcrest==1.9.9"]
 }

homeassistant/components/analytics/__init__.py

@@ -14,6 +14,7 @@ from homeassistant.util.hass_dict import HassKey
 
 from .analytics import Analytics
 from .const import ATTR_ONBOARDED, ATTR_PREFERENCES, DOMAIN, INTERVAL, PREFERENCE_SCHEMA
+from .http import AnalyticsDevicesView
 
 CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
@@ -55,6 +56,8 @@ async def async_setup(hass: HomeAssistant, _: ConfigType) -> bool:
     websocket_api.async_register_command(hass, websocket_analytics)
     websocket_api.async_register_command(hass, websocket_analytics_preferences)
 
+    hass.http.register_view(AnalyticsDevicesView)
+
     hass.data[DATA_COMPONENT] = analytics
     return True
 

homeassistant/components/analytics/analytics.py

@@ -27,7 +27,7 @@ from homeassistant.config_entries import SOURCE_IGNORE
 from homeassistant.const import ATTR_DOMAIN, BASE_PLATFORMS, __version__ as HA_VERSION
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.storage import Store
@@ -77,6 +77,11 @@ from .const import (
 )
 
 
+def gen_uuid() -> str:
+    """Generate a new UUID."""
+    return uuid.uuid4().hex
+
+
 @dataclass
 class AnalyticsData:
     """Analytics data."""
@@ -184,7 +189,7 @@ class Analytics:
             return
 
         if self._data.uuid is None:
-            self._data.uuid = uuid.uuid4().hex
+            self._data.uuid = gen_uuid()
             await self._store.async_save(dataclass_asdict(self._data))
 
         if self.supervisor:
@@ -381,3 +386,83 @@ def _domains_from_yaml_config(yaml_configuration: dict[str, Any]) -> set[str]:
     ).values():
         domains.update(platforms)
     return domains
+
+
+async def async_devices_payload(hass: HomeAssistant) -> dict:
+    """Return the devices payload."""
+    integrations_without_model_id: set[str] = set()
+    devices: list[dict[str, Any]] = []
+    dev_reg = dr.async_get(hass)
+    # Devices that need via device info set
+    new_indexes: dict[str, int] = {}
+    via_devices: dict[str, str] = {}
+
+    seen_integrations = set()
+
+    for device in dev_reg.devices.values():
+        # Ignore services
+        if device.entry_type:
+            continue
+
+        if not device.primary_config_entry:
+            continue
+
+        config_entry = hass.config_entries.async_get_entry(device.primary_config_entry)
+
+        if config_entry is None:
+            continue
+
+        seen_integrations.add(config_entry.domain)
+
+        if not device.model_id:
+            integrations_without_model_id.add(config_entry.domain)
+            continue
+
+        if not device.manufacturer:
+            continue
+
+        new_indexes[device.id] = len(devices)
+        devices.append(
+            {
+                "integration": config_entry.domain,
+                "manufacturer": device.manufacturer,
+                "model_id": device.model_id,
+                "model": device.model,
+                "sw_version": device.sw_version,
+                "hw_version": device.hw_version,
+                "has_suggested_area": device.suggested_area is not None,
+                "has_configuration_url": device.configuration_url is not None,
+                "via_device": None,
+            }
+        )
+        if device.via_device_id:
+            via_devices[device.id] = device.via_device_id
+
+    for from_device, via_device in via_devices.items():
+        if via_device not in new_indexes:
+            continue
+        devices[new_indexes[from_device]]["via_device"] = new_indexes[via_device]
+
+    integrations = {
+        domain: integration
+        for domain, integration in (
+            await async_get_integrations(hass, seen_integrations)
+        ).items()
+        if isinstance(integration, Integration)
+    }
+
+    for device_info in devices:
+        if integration := integrations.get(device_info["integration"]):
+            device_info["is_custom_integration"] = not integration.is_built_in
+
+    return {
+        "version": "home-assistant:1",
+        "no_model_id": sorted(
+            [
+                domain
+                for domain in integrations_without_model_id
+                if domain in integrations and integrations[domain].is_built_in
+            ]
+        ),
+        "devices": devices,
+    }

homeassistant/components/analytics/http.py

@@ -0,0 +1,27 @@
+"""HTTP endpoints for analytics integration."""
+
+from aiohttp import web
+
+from homeassistant.components.http import KEY_HASS, HomeAssistantView, require_admin
+from homeassistant.core import HomeAssistant
+
+from .analytics import async_devices_payload
+
+
+class AnalyticsDevicesView(HomeAssistantView):
+    """View to handle analytics devices payload download requests."""
+
+    url = "/api/analytics/devices"
+    name = "api:analytics:devices"
+
+    @require_admin
+    async def get(self, request: web.Request) -> web.Response:
+        """Return analytics devices payload as JSON."""
+        hass: HomeAssistant = request.app[KEY_HASS]
+        payload = await async_devices_payload(hass)
+        return self.json(
+            payload,
+            headers={
+                "Content-Disposition": "attachment; filename=analytics_devices.json"
+            },
+        )

homeassistant/components/analytics/manifest.json

@@ -3,7 +3,7 @@
   "name": "Analytics",
   "after_dependencies": ["energy", "hassio", "recorder"],
   "codeowners": ["@home-assistant/core", "@ludeeus"],
-  "dependencies": ["api", "websocket_api"],
+  "dependencies": ["api", "websocket_api", "http"],
   "documentation": "https://www.home-assistant.io/integrations/analytics",
   "integration_type": "system",
   "iot_class": "cloud_push",

homeassistant/components/analytics_insights/__init__.py

@@ -55,7 +55,6 @@ async def async_setup_entry(
     entry.runtime_data = AnalyticsInsightsData(coordinator=coordinator, names=names)
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    entry.async_on_unload(entry.add_update_listener(update_listener))
 
     return True
 
@@ -65,10 +64,3 @@ async def async_unload_entry(
 ) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-
-async def update_listener(
-    hass: HomeAssistant, entry: AnalyticsInsightsConfigEntry
-) -> None:
-    """Handle options update."""
-    await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/analytics_insights/config_flow.py

@@ -11,7 +11,11 @@ from python_homeassistant_analytics import (
 from python_homeassistant_analytics.models import Environment, IntegrationType
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult, OptionsFlow
+from homeassistant.config_entries import (
+    ConfigFlow,
+    ConfigFlowResult,
+    OptionsFlowWithReload,
+)
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import (
@@ -129,7 +133,7 @@ class HomeassistantAnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):
         )
 
 
-class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlow):
+class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlowWithReload):
     """Handle Homeassistant Analytics options."""
 
     async def async_step_init(

homeassistant/components/androidtv/media_player.py

@@ -56,7 +56,7 @@ SERVICE_UPLOAD = "upload"
 ANDROIDTV_STATES = {
     "off": MediaPlayerState.OFF,
     "idle": MediaPlayerState.IDLE,
-    "standby": MediaPlayerState.STANDBY,
+    "standby": MediaPlayerState.IDLE,
     "playing": MediaPlayerState.PLAYING,
     "paused": MediaPlayerState.PAUSED,
 }

homeassistant/components/androidtv_remote/__init__.py

@@ -5,26 +5,18 @@ from __future__ import annotations
 from asyncio import timeout
 import logging
 
-from androidtvremote2 import (
-    AndroidTVRemote,
-    CannotConnect,
-    ConnectionClosed,
-    InvalidAuth,
-)
+from androidtvremote2 import 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 create_api, get_enable_ime
+from .helpers import AndroidTVRemoteConfigEntry, 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
@@ -76,21 +68,14 @@ async def async_setup_entry(
     entry.async_on_unload(
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, on_hass_stop)
     )
-    entry.async_on_unload(entry.add_update_listener(async_update_options))
     entry.async_on_unload(api.disconnect)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(
+    hass: HomeAssistant, entry: AndroidTVRemoteConfigEntry
+) -> 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: ConfigEntry) -> None:
-    """Handle options update."""
-    _LOGGER.debug(
-        "async_update_options: data: %s options: %s", entry.data, entry.options
-    )
-    await hass.config_entries.async_reload(entry.entry_id)

homeassistant/components/androidtv_remote/config_flow.py

@@ -16,10 +16,10 @@ import voluptuous as vol
 
 from homeassistant.config_entries import (
     SOURCE_REAUTH,
-    ConfigEntry,
+    SOURCE_RECONFIGURE,
     ConfigFlow,
     ConfigFlowResult,
-    OptionsFlow,
+    OptionsFlowWithReload,
 )
 from homeassistant.const import CONF_HOST, CONF_MAC, CONF_NAME
 from homeassistant.core import callback
@@ -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 create_api, get_enable_ime
+from .helpers import AndroidTVRemoteConfigEntry, create_api, get_enable_ime
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -41,12 +41,6 @@ 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,
@@ -67,7 +61,7 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Handle the initial step."""
+        """Handle the initial and reconfigure step."""
         errors: dict[str, str] = {}
         if user_input is not None:
             self.host = user_input[CONF_HOST]
@@ -76,15 +70,32 @@ 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="user",
-            data_schema=STEP_USER_DATA_SCHEMA,
+            step_id="reconfigure" if self.source == SOURCE_RECONFIGURE else "user",
+            data_schema=vol.Schema(
+                {vol.Required(CONF_HOST, default=default_host): str}
+            ),
             errors=errors,
         )
 
@@ -105,10 +116,10 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
                 pin = user_input["pin"]
                 await self.api.async_finish_pairing(pin)
                 if self.source == SOURCE_REAUTH:
-                    await self.hass.config_entries.async_reload(
-                        self._get_reauth_entry().entry_id
+                    return self.async_update_reload_and_abort(
+                        self._get_reauth_entry(), reload_even_if_entry_is_unchanged=True
                     )
-                    return self.async_abort(reason="reauth_successful")
+
                 return self.async_create_entry(
                     title=self.name,
                     data={
@@ -217,19 +228,25 @@ 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: ConfigEntry,
+        config_entry: AndroidTVRemoteConfigEntry,
     ) -> AndroidTVRemoteOptionsFlowHandler:
         """Create the options flow."""
         return AndroidTVRemoteOptionsFlowHandler(config_entry)
 
 
-class AndroidTVRemoteOptionsFlowHandler(OptionsFlow):
+class AndroidTVRemoteOptionsFlowHandler(OptionsFlowWithReload):
     """Android TV Remote options flow."""
 
-    def __init__(self, config_entry: ConfigEntry) -> None:
+    def __init__(self, config_entry: AndroidTVRemoteConfigEntry) -> 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 . import AndroidTVRemoteConfigEntry
+from .helpers import AndroidTVRemoteConfigEntry
 
 TO_REDACT = {CONF_HOST, CONF_MAC}
 

homeassistant/components/androidtv_remote/entity.py

@@ -6,7 +6,6 @@ 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
@@ -14,6 +13,7 @@ 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,7 +23,9 @@ class AndroidTVRemoteBaseEntity(Entity):
     _attr_has_entity_name = True
     _attr_should_poll = False
 
-    def __init__(self, api: AndroidTVRemote, config_entry: ConfigEntry) -> None:
+    def __init__(
+        self, api: AndroidTVRemote, config_entry: AndroidTVRemoteConfigEntry
+    ) -> None:
         """Initialize the entity."""
         self._api = api
         self._host = config_entry.data[CONF_HOST]

homeassistant/components/androidtv_remote/helpers.py

@@ -10,6 +10,8 @@ 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."""
@@ -23,6 +25,6 @@ def create_api(hass: HomeAssistant, host: str, enable_ime: bool) -> AndroidTVRem
     )
 
 
-def get_enable_ime(entry: ConfigEntry) -> bool:
+def get_enable_ime(entry: AndroidTVRemoteConfigEntry) -> bool:
     """Get value of enable_ime option or its default value."""
-    return entry.options.get(CONF_ENABLE_IME, CONF_ENABLE_IME_DEFAULT_VALUE)
+    return entry.options.get(CONF_ENABLE_IME, CONF_ENABLE_IME_DEFAULT_VALUE)  # type: ignore[no-any-return]

homeassistant/components/androidtv_remote/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["androidtvremote2"],
-  "requirements": ["androidtvremote2==0.2.2"],
+  "requirements": ["androidtvremote2==0.2.3"],
   "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
+from androidtvremote2 import AndroidTVRemote, ConnectionClosed, VolumeInfo
 
 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,13 +75,11 @@ class AndroidTVRemoteMediaPlayerEntity(AndroidTVRemoteBaseEntity, MediaPlayerEnt
             else current_app
         )
 
-    def _update_volume_info(self, volume_info: dict[str, str | bool]) -> None:
+    def _update_volume_info(self, volume_info: VolumeInfo) -> None:
         """Update volume info."""
         if volume_info.get("max"):
-            self._attr_volume_level = int(volume_info["level"]) / int(
-                volume_info["max"]
-            )
-            self._attr_is_volume_muted = bool(volume_info["muted"])
+            self._attr_volume_level = volume_info["level"] / volume_info["max"]
+            self._attr_is_volume_muted = volume_info["muted"]
         else:
             self._attr_volume_level = None
             self._attr_is_volume_muted = None
@@ -93,7 +91,7 @@ class AndroidTVRemoteMediaPlayerEntity(AndroidTVRemoteBaseEntity, MediaPlayerEnt
         self.async_write_ha_state()
 
     @callback
-    def _volume_info_updated(self, volume_info: dict[str, str | bool]) -> None:
+    def _volume_info_updated(self, volume_info: VolumeInfo) -> None:
         """Update the state when the volume info changes."""
         self._update_volume_info(volume_info)
         self.async_write_ha_state()
@@ -102,8 +100,10 @@ class AndroidTVRemoteMediaPlayerEntity(AndroidTVRemoteBaseEntity, MediaPlayerEnt
         """Register callbacks."""
         await super().async_added_to_hass()
 
-        self._update_current_app(self._api.current_app)
-        self._update_volume_info(self._api.volume_info)
+        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._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,7 +63,8 @@ class AndroidTVRemoteEntity(AndroidTVRemoteBaseEntity, RemoteEntity):
         self._attr_activity_list = [
             app.get(CONF_APP_NAME, "") for app in self._apps.values()
         ]
-        self._update_current_app(self._api.current_app)
+        if self._api.current_app is not None:
+            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,6 +6,18 @@
         "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": {
@@ -16,6 +28,9 @@
         "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": {
@@ -32,7 +47,9 @@
     "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%]"
+      "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."
     }
   },
   "options": {
@@ -40,7 +57,11 @@
       "init": {
         "data": {
           "apps": "Configure applications list",
-          "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."
+          "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."
         }
       },
       "apps": {
@@ -53,8 +74,10 @@
           "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_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."
         }
       }
     }

homeassistant/components/anthemav/strings.json

@@ -10,7 +10,7 @@
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "cannot_receive_deviceinfo": "Failed to retrieve MAC Address. Make sure the device is turned on"
+      "cannot_receive_deviceinfo": "Failed to retrieve MAC address. Make sure the device is turned on"
     },
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"

homeassistant/components/anthropic/__init__.py

@@ -61,6 +61,8 @@ 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
 
 
@@ -69,6 +71,13 @@ 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."""
 
@@ -138,4 +147,34 @@ async def async_migrate_integration(hass: HomeAssistant) -> None:
                 title=DEFAULT_CONVERSATION_NAME,
                 options={},
                 version=2,
+                minor_version=2,
             )
+
+
+async def async_migrate_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) -> bool:
+    """Migrate entry."""
+    LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)
+
+    if entry.version > 2:
+        # This means the user has downgraded from a future version
+        return False
+
+    if entry.version == 2 and entry.minor_version == 1:
+        # Correct broken device migration in Home Assistant Core 2025.7.0b0-2025.7.0b1
+        device_registry = dr.async_get(hass)
+        for device in dr.async_entries_for_config_entry(
+            device_registry, entry.entry_id
+        ):
+            device_registry.async_update_device(
+                device.id,
+                remove_config_entry_id=entry.entry_id,
+                remove_config_subentry_id=None,
+            )
+
+        hass.config_entries.async_update_entry(entry, minor_version=2)
+
+    LOGGER.debug(
+        "Migration to version %s:%s successful", entry.version, entry.minor_version
+    )
+
+    return True

homeassistant/components/anthropic/config_flow.py

@@ -75,6 +75,7 @@ class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Anthropic."""
 
     VERSION = 2
+    MINOR_VERSION = 2
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None

homeassistant/components/anthropic/const.py

@@ -10,9 +10,9 @@ DEFAULT_CONVERSATION_NAME = "Claude conversation"
 CONF_RECOMMENDED = "recommended"
 CONF_PROMPT = "prompt"
 CONF_CHAT_MODEL = "chat_model"
-RECOMMENDED_CHAT_MODEL = "claude-3-haiku-20240307"
+RECOMMENDED_CHAT_MODEL = "claude-3-5-haiku-latest"
 CONF_MAX_TOKENS = "max_tokens"
-RECOMMENDED_MAX_TOKENS = 1024
+RECOMMENDED_MAX_TOKENS = 3000
 CONF_TEMPERATURE = "temperature"
 RECOMMENDED_TEMPERATURE = 1.0
 CONF_THINKING_BUDGET = "thinking_budget"

homeassistant/components/anthropic/conversation.py

@@ -1,69 +1,16 @@
 """Conversation support for Anthropic."""
 
-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 typing import Literal
 
 from homeassistant.components import conversation
-from homeassistant.config_entries import ConfigEntry, ConfigSubentry
+from homeassistant.config_entries import ConfigSubentry
 from homeassistant.const import CONF_LLM_HASS_API, MATCH_ALL
 from homeassistant.core import HomeAssistant
-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_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
+from .const import CONF_PROMPT, DOMAIN
+from .entity import AnthropicBaseLLMEntity
 
 
 async def async_setup_entry(
@@ -82,253 +29,10 @@ 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
+    conversation.ConversationEntity,
+    conversation.AbstractConversationAgent,
+    AnthropicBaseLLMEntity,
 ):
     """Anthropic conversation agent."""
 
@@ -336,17 +40,7 @@ class AnthropicConversationEntity(
 
     def __init__(self, entry: AnthropicConfigEntry, subentry: ConfigSubentry) -> None:
         """Initialize the agent."""
-        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,
-        )
+        super().__init__(entry, subentry)
         if self.subentry.data.get(CONF_LLM_HASS_API):
             self._attr_supported_features = (
                 conversation.ConversationEntityFeature.CONTROL
@@ -357,13 +51,6 @@ 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,
@@ -384,87 +71,4 @@ class AnthropicConversationEntity(
 
         await self._async_handle_chat_log(chat_log)
 
-        response_content = chat_log.content[-1]
-        if not isinstance(response_content, conversation.AssistantContent):
-            raise TypeError("Last message must be an assistant message")
-        intent_response = intent.IntentResponse(language=user_input.language)
-        intent_response.async_set_speech(response_content.content or "")
-        return conversation.ConversationResult(
-            response=intent_response,
-            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)
+        return conversation.async_get_result_from_chat_log(user_input, chat_log)

homeassistant/components/anthropic/entity.py

@@ -0,0 +1,395 @@
+"""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."""
+
+    _attr_has_entity_name = True
+    _attr_name = None
+
+    def __init__(self, entry: AnthropicConfigEntry, subentry: ConfigSubentry) -> None:
+        """Initialize the entity."""
+        self.entry = entry
+        self.subentry = subentry
+        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/anthropic/strings.json

@@ -29,7 +29,7 @@
         "set_options": {
           "data": {
             "name": "[%key:common::config_flow::data::name%]",
-            "prompt": "Instructions",
+            "prompt": "[%key:common::config_flow::data::prompt%]",
             "chat_model": "[%key:common::generic::model%]",
             "max_tokens": "Maximum tokens to return in response",
             "temperature": "Temperature",

homeassistant/components/apple_tv/manifest.json

@@ -7,7 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/apple_tv",
   "iot_class": "local_push",
   "loggers": ["pyatv", "srptools"],
-  "requirements": ["pyatv==0.16.0"],
+  "requirements": ["pyatv==0.16.1"],
   "zeroconf": [
     "_mediaremotetv._tcp.local.",
     "_companion-link._tcp.local.",

homeassistant/components/apple_tv/media_player.py

@@ -191,7 +191,7 @@ class AppleTvMediaPlayer(
             self._is_feature_available(FeatureName.PowerState)
             and self.atv.power.power_state == PowerState.Off
         ):
-            return MediaPlayerState.STANDBY
+            return MediaPlayerState.OFF
         if self._playing:
             state = self._playing.device_state
             if state in (DeviceState.Idle, DeviceState.Loading):
@@ -200,7 +200,7 @@ class AppleTvMediaPlayer(
                 return MediaPlayerState.PLAYING
             if state in (DeviceState.Paused, DeviceState.Seeking, DeviceState.Stopped):
                 return MediaPlayerState.PAUSED
-            return MediaPlayerState.STANDBY  # Bad or unknown state?
+            return MediaPlayerState.IDLE  # Bad or unknown state?
         return None
 
     @callback

homeassistant/components/arcam_fmj/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/arcam_fmj",
   "iot_class": "local_polling",
   "loggers": ["arcam"],
-  "requirements": ["arcam-fmj==1.8.1"],
+  "requirements": ["arcam-fmj==1.8.2"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/assist_pipeline/__init__.py

@@ -38,8 +38,6 @@ from .pipeline import (
     async_create_default_pipeline,
     async_get_pipeline,
     async_get_pipelines,
-    async_migrate_engine,
-    async_run_migrations,
     async_setup_pipeline_store,
     async_update_pipeline,
 )
@@ -61,7 +59,6 @@ __all__ = (
     "WakeWordSettings",
     "async_create_default_pipeline",
     "async_get_pipelines",
-    "async_migrate_engine",
     "async_pipeline_from_audio_stream",
     "async_setup",
     "async_update_pipeline",
@@ -87,7 +84,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     hass.data[DATA_LAST_WAKE_UP] = {}
 
     await async_setup_pipeline_store(hass)
-    await async_run_migrations(hass)
     async_register_websocket_api(hass)
 
     return True

homeassistant/components/assist_pipeline/const.py

@@ -3,7 +3,6 @@
 DOMAIN = "assist_pipeline"
 
 DATA_CONFIG = f"{DOMAIN}.config"
-DATA_MIGRATIONS = f"{DOMAIN}_migrations"
 
 DEFAULT_PIPELINE_TIMEOUT = 60 * 5  # seconds
 

homeassistant/components/assist_pipeline/pipeline.py

@@ -13,7 +13,7 @@ from pathlib import Path
 from queue import Empty, Queue
 from threading import Thread
 import time
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, cast
 import wave
 
 import hass_nabucasa
@@ -49,7 +49,6 @@ from .const import (
     CONF_DEBUG_RECORDING_DIR,
     DATA_CONFIG,
     DATA_LAST_WAKE_UP,
-    DATA_MIGRATIONS,
     DOMAIN,
     MS_PER_CHUNK,
     SAMPLE_CHANNELS,
@@ -2059,50 +2058,6 @@ async def async_setup_pipeline_store(hass: HomeAssistant) -> PipelineData:
     return PipelineData(pipeline_store)
 
 
-@callback
-def async_migrate_engine(
-    hass: HomeAssistant,
-    engine_type: Literal["conversation", "stt", "tts", "wake_word"],
-    old_value: str,
-    new_value: str,
-) -> None:
-    """Register a migration of an engine used in pipelines."""
-    hass.data.setdefault(DATA_MIGRATIONS, {})[engine_type] = (old_value, new_value)
-
-    # Run migrations when config is already loaded
-    if DATA_CONFIG in hass.data:
-        hass.async_create_background_task(
-            async_run_migrations(hass), "assist_pipeline_migration", eager_start=True
-        )
-
-
-async def async_run_migrations(hass: HomeAssistant) -> None:
-    """Run pipeline migrations."""
-    if not (migrations := hass.data.get(DATA_MIGRATIONS)):
-        return
-
-    engine_attr = {
-        "conversation": "conversation_engine",
-        "stt": "stt_engine",
-        "tts": "tts_engine",
-        "wake_word": "wake_word_entity",
-    }
-
-    updates = []
-
-    for pipeline in async_get_pipelines(hass):
-        attr_updates = {}
-        for engine_type, (old_value, new_value) in migrations.items():
-            if getattr(pipeline, engine_attr[engine_type]) == old_value:
-                attr_updates[engine_attr[engine_type]] = new_value
-
-        if attr_updates:
-            updates.append((pipeline, attr_updates))
-
-    for pipeline, attr_updates in updates:
-        await async_update_pipeline(hass, pipeline, **attr_updates)
-
-
 @dataclass
 class PipelineConversationData:
     """Hold data for the duration of a conversation."""

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"): bool,
+                    vol.Optional("preannounce", default=True): 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"): bool,
+                    vol.Optional("preannounce", default=True): 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", False),
+            "preannounce": call.data.get("preannounce", True),
             "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"): bool,
+                vol.Optional("preannounce", default=True): bool,
                 vol.Optional("preannounce_media_id"): _media_id_validator,
                 vol.Optional("answers"): [
                     {

homeassistant/components/assist_satellite/services.yaml

@@ -68,9 +68,10 @@ ask_question:
       required: true
       selector:
         entity:
-          domain: assist_satellite
-          supported_features:
-            - assist_satellite.AssistSatelliteEntityFeature.START_CONVERSATION
+          filter:
+            domain: assist_satellite
+            supported_features:
+              - assist_satellite.AssistSatelliteEntityFeature.START_CONVERSATION
     question:
       required: false
       example: "What kind of music would you like to play?"

homeassistant/components/august/manifest.json

@@ -28,5 +28,5 @@
   "documentation": "https://www.home-assistant.io/integrations/august",
   "iot_class": "cloud_push",
   "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==8.10.0", "yalexs-ble==2.6.0"]
+  "requirements": ["yalexs==8.10.0", "yalexs-ble==3.1.0"]
 }

homeassistant/components/awair/const.py

@@ -6,6 +6,7 @@ from datetime import timedelta
 import logging
 
 API_CO2 = "carbon_dioxide"
+API_DEW_POINT = "dew_point"
 API_DUST = "dust"
 API_HUMID = "humidity"
 API_LUX = "illuminance"

homeassistant/components/awair/sensor.py

@@ -34,6 +34,7 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import (
     API_CO2,
+    API_DEW_POINT,
     API_DUST,
     API_HUMID,
     API_LUX,
@@ -110,6 +111,15 @@ SENSOR_TYPES: tuple[AwairSensorEntityDescription, ...] = (
         unique_id_tag="CO2",  # matches legacy format
         state_class=SensorStateClass.MEASUREMENT,
     ),
+    AwairSensorEntityDescription(
+        key=API_DEW_POINT,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        translation_key="dew_point",
+        unique_id_tag="dew_point",
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_registry_enabled_default=False,
+    ),
 )
 
 SENSOR_TYPES_DUST: tuple[AwairSensorEntityDescription, ...] = (

homeassistant/components/awair/strings.json

@@ -57,6 +57,9 @@
       },
       "sound_level": {
         "name": "Sound level"
+      },
+      "dew_point": {
+        "name": "Dew point"
       }
     }
   }

homeassistant/components/axis/__init__.py

@@ -30,7 +30,9 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: AxisConfigEntry)
     await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
     hub.setup()
 
-    config_entry.add_update_listener(hub.async_new_address_callback)
+    config_entry.async_on_unload(
+        config_entry.add_update_listener(hub.async_new_address_callback)
+    )
     config_entry.async_on_unload(hub.teardown)
     config_entry.async_on_unload(
         hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, hub.shutdown)

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, ServiceCall
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
 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,7 +37,6 @@ from .manager import (
     IdleEvent,
     IncorrectPasswordError,
     ManagerBackup,
-    ManagerStateEvent,
     NewBackup,
     RestoreBackupEvent,
     RestoreBackupStage,
@@ -45,6 +44,7 @@ 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,39 +103,11 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     backup_manager = BackupManager(hass, reader_writer)
     hass.data[DATA_MANAGER] = backup_manager
-    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)
+    await backup_manager.async_setup()
 
     async_register_websocket_handlers(hass, with_hassio)
 
-    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_setup_services(hass)
 
     async_register_http_views(hass)
 
@@ -164,3 +136,15 @@ 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

@@ -1,38 +0,0 @@
-"""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"])